def test_split_with_state_monad(self): value = 7 arrow = kleisli_split(state_return) state = KleisliArrow.runKleisli(arrow, value) result = State.runState(state, list()) target = ((value, value), list()) self.assertEquals(target, result)
def test_right_with_state_monad(self): s1 = "*2" w = lambda a: a * 2 f = lambda a: State(lambda s: (w(a), s.append(s1) or s)) k = KleisliArrowChoice(state_return, f).right() value = 3.141 left_state = KleisliArrow.runKleisli(k, Left(value)) left = State.runState(left_state, []) left_target = (Left(value), []) self.assertEquals(left_target, left) right_state = KleisliArrow.runKleisli(k, Right(value)) right = State.runState(right_state, []) right_target = (Right(w(value)), [s1]) self.assertEquals(right_target, right)
def test_with_return(self): value = 7 state = list() m = return_(value) result = State.runState(m, state) self.assertEquals((value, state), result)
def test_exec_state(self): value = 7 state = list() msg = "*2" m_one = return_(value) m_two = m_one >= (lambda a: State(lambda s: (a * 2, s.append(msg) or s))) self.assertEquals([msg], State.execState(m_two, state))
def test_single_mutable_state(self): # Value/state pair value = 7 state = list() # Build stuff m = State(lambda s: (value, s.append(value))) target = (value, state.append(value)) result = State.runState(m, state) self.assertEquals(target, result)
def test_first_with_state_monad(self): w = lambda a: a * 2 s1 = "*2" wk = lambda a: State(lambda s: (w(a), s.append(s1) or s)) arrow = KleisliArrow(state_return, wk).first() value = 9 state = KleisliArrow.runKleisli(arrow, (value, value)) result = State.runState(state, list()) target = ((w(value), value), [s1]) self.assertEquals(target, result)
def test_single_immutable_state(self): # Value/state pair value = 7 state = list() # Build stuff m = return_(value) target = (value, state) result = State.runState(m, state) self.assertEquals(target, result)
def test_unsplit_with_state_monad(self): value = 7 k1 = kleisli_split(state_return) f = lambda x, y: x * y k2 = kleisli_unsplit(state_return, f) arrow = k1 >> k2 state = KleisliArrow.runKleisli(arrow, value) result = State.runState(state, list()) target = (f(value, value), list()) self.assertEquals(target, result)
def test_triple_pipe_with_state_monad(self): s1 = "*2" w = lambda a: a * 2 f = lambda a: State(lambda s: (w(a), s.append(s1) or s)) k1 = KleisliArrowChoice(state_return, f) s2 = "-9" y = lambda a: a - 9 h = lambda a: State(lambda s: (y(a), s.append(s2) or s)) k2 = KleisliArrowChoice(state_return, h) arrow = k1 | k2 value = 19 left_state = KleisliArrow.runKleisli(arrow, Left(value)) left = State.runState(left_state, []) left_target = (w(value), [s1]) self.assertEquals(left_target, left) right_state = KleisliArrow.runKleisli(arrow, Right(value)) right = State.runState(right_state, []) right_target = (y(value), [s2]) self.assertEquals(right_target, right)
def test_many_mutable_state(self): # Build this: # state (\s -> (1, s ++ ["Initial value 1"])) # >>= (\a -> state (\s -> (a * 2, s ++ ["Mult by 2"]))) # >>= (\a -> state (\s -> (a - 9, s ++ ["Minus 9"]))) s_one = "Initial value 1" s_two = "Multiply by 2" s_three = "Minus 9" m_one = State(lambda s: (1, s.append(s_one) or s)) m_two = m_one >= (lambda a: State(lambda s: (a * 2, s.append(s_two) or s))) m_three = m_two >= (lambda a: State(lambda s: (a - 9, s.append(s_three) or s))) result = State.runState(m_three, list()) self.assertEquals((-7, [s_one, s_two, s_three]), result)
def test_state_monad(self): s1 = "*2" w = lambda a: a * 2 f = lambda a: State(lambda s: (w(a), s.append(s1) or s)) k1 = KleisliArrow(state_return, f) s2 = "-9" x = lambda a: a - 9 h = lambda a: State(lambda s: (x(a), s.append(s2) or s)) k2 = KleisliArrow(state_return, h) arrow = k1 >> k2 value = 5 state = list() state_monad = KleisliArrow.runKleisli(arrow, value) # This is the value self.assertEquals((x(w(value)), [s1, s2]), State.runState(state_monad, state)) # This is the state
def test_triple_ampersand_with_state_monad(self): s1 = "*2" w = lambda a: a * 2 f = lambda a: State(lambda s: (w(a), s.append(s1) or s)) k1 = KleisliArrow(state_return, f) s2 = "-9" x = lambda a: a - 9 h = lambda a: State(lambda s: (x(a), s.append(s2) or s)) k2 = KleisliArrow(state_return, h) arrow = k1 & k2 value = 5 state = list() state_monad = KleisliArrow.runKleisli(arrow, value) target = ((w(value), x(value)), [s1, s2]) result = State.runState(state_monad, state) self.assertEquals(target, result)
def exec_pipeline(state_monad, state): return State.execState(state_monad, state)
def eval_pipeline(state_monad, state): return State.evalState(state_monad, state)
def run_pipeline(state_monad, state): return State.runState(state_monad, state)
def test_eval_state(self): value = 7 state = list() m = return_(value) self.assertEquals(value, State.evalState(m, state))
def exec_pipeline(state_monad, state): wrapped_state = State.execState(state_monad, state) return wrapped_state.state
def eval_pipeline(state_monad, state): future = State.evalState(state_monad, state) return __handle_output(future)
def run_pipeline(state_monad, state): output = State.runState(state_monad, state) return (__handle_output(output[0]), output[1].state)