Safe Haskell	Safe-Inferred
Language	Haskell2010

Haskus.Utils.ContFlow

Description

Continuation based control-flow

Synopsis

newtype ContFlow (xs :: [Type]) r = ContFlow (ContTuple xs r -> r)
type family ContTuple (xs :: [Type]) r where ...
(>:>) :: MultiCont a => a -> ContTuple (MultiContTypes a) r -> r
(>-:>) :: (MultiCont a, MultiContTypes a ~ '[b]) => a -> (b -> r) -> r
(>%:>) :: (MultiCont a, ReorderTuple ts (ContTuple (MultiContTypes a) r)) => a -> ts -> r
(>::>) :: ContFlow xs r -> ContTuple xs r -> r
(>:-:>) :: ContFlow '[a] r -> (a -> r) -> r
(>:%:>) :: forall ts xs r. ReorderTuple ts (ContTuple xs r) => ContFlow xs r -> ts -> r
type family ToMultiCont xs r where ...
class MultiCont a where
- type MultiContTypes a :: [Type]
- toCont :: a -> ContFlow (MultiContTypes a) r
- toContM :: Monad m => m a -> ContFlow (MultiContTypes a) (m r)

Documentation

newtype ContFlow (xs :: [Type]) r Source #

A continuation based control-flow

Constructors

type family ContTuple (xs :: [Type]) r where ... Source #

Convert a list of types into the actual data type representing the continuations.

Equations

Bind a multi-continuable type to a tuple of continuations

(>-:>) :: (MultiCont a, MultiContTypes a ~ '[b]) => a -> (b -> r) -> r infixl 0 Source #

Bind a single-continuable type to a 1-tuple of continuations

Bind a multi-continuable type to a tuple of continuations and reorder fields if necessary

(>::>) :: ContFlow xs r -> ContTuple xs r -> r infixl 0 Source #

Bind a flow to a tuple of continuations

(>:-:>) :: ContFlow '[a] r -> (a -> r) -> r infixl 0 Source #

Bind a flow to a 1-tuple of continuations

(>:%:>) :: forall ts xs r. ReorderTuple ts (ContTuple xs r) => ContFlow xs r -> ts -> r infixl 0 Source #

Bind a flow to a tuple of continuations and reorder fields if necessary

type family ToMultiCont xs r where ... Source #

Equations

ToMultiCont '[] r = '[]
ToMultiCont (x ': xs) r = (x -> r) ': ToMultiCont xs r

A multi-continuable type

Associated Types

Methods

Convert a data into a multi-continuation

Convert a data into a multi-continuation (monadic)

Instances details

(Functor (VariantF xs), ContVariant (ApplyAll (EADT xs) xs)) => MultiCont (EADT xs) Source #	MultiCont instance `>>>` `let f x = toCont x >::> (const "[]", \(ConsF u us) -> u ++ ":" ++ f us)``>>>` `f a`"Hello:World:[]"
Instance details Defined in Haskus.Utils.EADT Associated Types type MultiContTypes (EADT xs) :: [Type] Source # Methods toCont :: EADT xs -> ContFlow (MultiContTypes (EADT xs)) r Source # toContM :: Monad m => m (EADT xs) -> ContFlow (MultiContTypes (EADT xs)) (m r) Source #
ContVariant xs => MultiCont (V xs) Source #
Instance details Defined in Haskus.Utils.Variant Associated Types type MultiContTypes (V xs) :: [Type] Source # Methods toCont :: V xs -> ContFlow (MultiContTypes (V xs)) r Source # toContM :: Monad m => m (V xs) -> ContFlow (MultiContTypes (V xs)) (m r) Source #
ContVariant (ApplyAll e xs) => MultiCont (VariantF xs e) Source #
Instance details Defined in Haskus.Utils.VariantF Associated Types type MultiContTypes (VariantF xs e) :: [Type] Source # Methods toCont :: VariantF xs e -> ContFlow (MultiContTypes (VariantF xs e)) r Source # toContM :: Monad m => m (VariantF xs e) -> ContFlow (MultiContTypes (VariantF xs e)) (m r) Source #