def if_left_function(futured_either):
     either = futured_either.result()
     if isinstance(either, Left):
         return left_function(either.val) >= (lambda a: return_(Left(a)))
     elif isinstance(either, Right):
         return return_(either)
     else:
         raise ValueError("Result of future must be of type Either")
Exemple #2
0
    def test_with_return(self):
        value = 7
        state = list()
        m = return_(value)

        result = State.runState(m, state)
        self.assertEquals((value, state), result)
Exemple #3
0
    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 cons_if_component(condition_function, then_component, else_component):
    """Construct a conditional execution component. If the conditional function evaluates to true the 'then' component is executed. Otherwise, the 'else' component is executed. Returns a Kleisli arrow."""
    if not isinstance(then_component, KleisliArrow):
        raise ValueError("Then component must be a KleisliArrow")
    if not isinstance(else_component, KleisliArrow):
        raise ValueError("Else component must be a KleisliArrow")

    def get_test_bind_function():
        def test_bind_function(bind_a):
            def test_state_function(wrapped_state):
                # Unpack state
                state = wrapped_state.state

                def do_transformation(a, s):
                    # Handle input
                    if isinstance(a, tuple):
                        the_a = (a[0].result(), a[1].result())
                    elif isinstance(a, Future):
                        the_a = a.result()
                    else:
                        raise ValueError("Test state function has value that is not of type tuple or Future")

                    condition_result = condition_function(a, s)
                    new_a = Left(a) if condition_result else Right(a)

                    return new_a

                # Execute
                new_future = wrapped_state.executor.submit(do_transformation,
                                                           bind_a,
                                                           state)

                # New value/state pair
                return (new_future, wrapped_state)
            return State(test_state_function)
        return test_bind_function

    def get_if_left_function(left_function):
        def if_left_function(futured_either):
            either = futured_either.result()
            if isinstance(either, Left):
                return left_function(either.val) >= (lambda a: return_(Left(a)))
            elif isinstance(either, Right):
                return return_(either)
            else:
                raise ValueError("Result of future must be of type Either")
        return if_left_function

    if_comp = KleisliArrow(return_, get_test_bind_function()) >> \
              ((KleisliArrowChoice(return_, get_if_left_function(then_component._func)) >> \
                KleisliArrowChoice(return_, else_component._func).right()) >> \
               KleisliArrow(return_, lambda either: return_(either.val)))

    return if_comp
Exemple #5
0
    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)
Exemple #6
0
    def test_eval_state(self):
        value = 7
        state = list()
        m = return_(value)

        self.assertEquals(value, State.evalState(m, state))