Documentation

class FunctorUnit t where Source

class FunctorDiscard t where Source

class FunctorFunctor t where Source

class FunctorIsoFunctor t where Source

newtype ID a Source

isoID :: ID a ⇄ a Source

type Failure = FailureT ID Source

failure :: Maybe a -> Failure a Source

runFailure :: Failure a -> Maybe a Source

commuteFailure :: Functor m => FailureT (FailureT m) ↝ FailureT (FailureT m) Source

type Error e = ErrorT e ID Source

runError :: Error e a -> e ⨄ a Source

errorCommute :: Functor m => ErrorT e (ErrorT e m) ↝ ErrorT e (ErrorT e m) Source

type Reader r = ReaderT r ID Source

reader :: (r -> a) -> Reader r a Source

runReader :: Reader r a -> r -> a Source

runReaderWith :: r -> Reader r a -> a Source

readerCommute :: ReaderT r₁ (ReaderT r₂ m) ↝ ReaderT r₂ (ReaderT r₁ m) Source

type Writer o = WriterT o ID Source

writer :: (a, o) -> Writer o a Source

runWriter :: Writer o a -> (a, o) Source

execWriter :: Writer o a -> o Source

writerCommute :: forall m o₁ o₂. Functor m => WriterT o₁ (WriterT o₂ m) ↝ WriterT o₂ (WriterT o₁ m) Source

type State s = StateT s ID Source

runStateWith :: s -> State s a -> (a, s) Source

evalStateWith :: s -> State s a -> a Source

execStateWith :: s -> State s a -> s Source

stateCommute :: forall m s₁ s₂. Functor m => StateT s₁ (StateT s₂ m) ↝ StateT s₂ (StateT s₁ m) Source

pluck :: [a] -> [[a]] -> Maybe ([a], [[a]]) Source

transpose :: [[a]] -> [[a]] Source

nondetAppendCommute :: Functor m => NondetAppendT (NondetAppendT m) ↝ NondetAppendT (NondetAppendT m) Source

transposeSetLazy :: 𝒫ᵇ (𝒫ᵇ a) -> 𝒫ᵇ (𝒫ᵇ a) Source

nondetCommute :: Functor m => NondetJoinT (NondetJoinT m) ↝ NondetJoinT (NondetJoinT m) Source

flowCommuteAppend :: forall s₁ s₂ m. (Functor m, Monoid s₁) => FlowAppendT s₁ (FlowAppendT s₂ m) ↝ FlowAppendT s₂ (FlowAppendT s₁ m) Source

flowCommuteJoin :: forall s₁ s₂ m. (Functor m, JoinLattice s₁) => FlowJoinT s₁ (FlowJoinT s₂ m) ↝ FlowJoinT s₂ (FlowJoinT s₁ m) Source

flowJoinFromState :: Functor m => StateT s m ↝ FlowJoinT s m Source

flowJoinStateI :: Functor m => FlowJoinT s m ↝ StateT s (FlowJoinT s m) Source

type Cont r = ContT r ID Source

cont :: ((a -> r) -> r) -> Cont r a Source

runCont :: Cont r a -> (a -> r) -> r Source

evalCont :: Cont r r -> r Source

type OpaqueCont k r = OpaqueContT k r ID Source

opaqueCont :: (k r ID a -> r) -> OpaqueCont k r a Source

runOpaqueCont :: OpaqueCont k r a -> k r ID a -> r Source

metaCont :: Isomorphic3 (k r) (ContFun r) => ((a -> r) -> r) -> OpaqueCont k r a Source

runMetaCont :: Isomorphic3 (ContFun r) (k r) => OpaqueCont k r a -> (a -> r) -> r Source

evalOpaqueCont :: Isomorphic3 (ContFun r) (k r) => OpaqueCont k r r -> r Source

class Balloon k r | k -> r where Source

failureErrorCommute :: Functor m => FailureT (ErrorT e m) ↝ ErrorT e (FailureT m) Source

errorFailureCommute :: Functor m => ErrorT e (FailureT m) ↝ FailureT (ErrorT e m) Source

failureReaderCommute :: Functor m => FailureT (ReaderT r m) ↝ ReaderT r (FailureT m) Source

readerFailureCommute :: Functor m => ReaderT r (FailureT m) ↝ FailureT (ReaderT r m) Source

failureWriterCommute :: Functor m => FailureT (WriterT o m) ↝ WriterT o (FailureT m) Source

writerFailureCommute :: (Monoid o, Functor m) => WriterT o (FailureT m) ↝ FailureT (WriterT o m) Source

failureStateCommute :: forall s m. Functor m => FailureT (StateT s m) ↝ StateT s (FailureT m) Source

stateFailureCommute :: forall s m. Functor m => StateT s (FailureT m) ↝ FailureT (StateT s m) Source

failureNondetAppendCommute :: Functor m => FailureT (NondetAppendT m) ↝ NondetAppendT (FailureT m) Source

nondetAppendFailureCommute :: Functor m => NondetAppendT (FailureT m) ↝ FailureT (NondetAppendT m) Source

failureNondetCommute :: Functor m => FailureT (NondetJoinT m) ↝ NondetJoinT (FailureT m) Source

nondetFailureCommute :: Functor m => NondetJoinT (FailureT m) ↝ FailureT (NondetJoinT m) Source

errorReaderCommute :: ErrorT e (ReaderT r m) ↝ ReaderT r (ErrorT e m) Source

readerErrorCommute :: ReaderT r (ErrorT e m) ↝ ErrorT e (ReaderT r m) Source

errorWriterCommute :: forall e o m. Functor m => ErrorT e (WriterT o m) ↝ WriterT o (ErrorT e m) Source

writerErrorCommute :: (Functor m, Monoid o) => WriterT o (ErrorT e m) ↝ ErrorT e (WriterT o m) Source

errorStateCommute :: Functor m => ErrorT e (StateT s m) ↝ StateT s (ErrorT e m) Source

stateErrorCommute :: Functor m => StateT s (ErrorT e m) ↝ ErrorT e (StateT s m) Source

errorNondetAppendCommute :: Functor m => ErrorT e (NondetAppendT m) ↝ NondetAppendT (ErrorT e m) Source

nondetAppendErrorCommute :: Functor m => NondetAppendT (ErrorT e m) ↝ ErrorT e (NondetAppendT m) Source

errorNondetCommute :: Functor m => ErrorT e (NondetJoinT m) ↝ NondetJoinT (ErrorT e m) Source

nondetErrorCommute :: Functor m => NondetJoinT (ErrorT e m) ↝ ErrorT e (NondetJoinT m) Source

readerWriterCommute :: ReaderT r (WriterT o m) ↝ WriterT o (ReaderT r m) Source

writerReaderCommute :: WriterT o (ReaderT r m) ↝ ReaderT r (WriterT o m) Source

readerStateCommute :: Functor m => ReaderT r (StateT s m) ↝ StateT s (ReaderT r m) Source

stateReaderCommute :: Functor m => StateT s (ReaderT r m) ↝ ReaderT r (StateT s m) Source

readerNondetAppendCommute :: Functor m => ReaderT r (NondetAppendT m) ↝ NondetAppendT (ReaderT r m) Source

nondetAppendReaderCommute :: Functor m => NondetAppendT (ReaderT r m) ↝ ReaderT r (NondetAppendT m) Source

readerNondetCommute :: Functor m => ReaderT r (NondetJoinT m) ↝ NondetJoinT (ReaderT r m) Source

nondetReaderCommute :: Functor m => NondetJoinT (ReaderT r m) ↝ ReaderT r (NondetJoinT m) Source

readerFlowAppendCommute :: forall r s m. Functor m => ReaderT r (FlowAppendT s m) ↝ FlowAppendT s (ReaderT r m) Source

flowAppendReaderCommute :: forall s r m. Functor m => FlowAppendT s (ReaderT r m) ↝ ReaderT r (FlowAppendT s m) Source

readerFlowJoinCommute :: forall r s m. Functor m => ReaderT r (FlowJoinT s m) ↝ FlowJoinT s (ReaderT r m) Source

flowJoinReaderCommute :: forall s r m. Functor m => FlowJoinT s (ReaderT r m) ↝ ReaderT r (FlowJoinT s m) Source

writerStateCommute :: forall o s m. Functor m => WriterT o (StateT s m) ↝ StateT s (WriterT o m) Source

stateWriterCommute :: forall o s m. Functor m => StateT s (WriterT o m) ↝ WriterT o (StateT s m) Source

writerNondetAppendCommute :: forall o m. (Functor m, Monoid o) => WriterT o (NondetAppendT m) ↝ NondetAppendT (WriterT o m) Source

nondetAppendWriterCommute :: forall o m. Functor m => NondetAppendT (WriterT o m) ↝ WriterT o (NondetAppendT m) Source

writerNondetJoinCommute :: forall o m. (Functor m, Monoid o) => WriterT o (NondetJoinT m) ↝ NondetJoinT (WriterT o m) Source

nondetJoinWriterCommute :: forall o m. Functor m => NondetJoinT (WriterT o m) ↝ WriterT o (NondetJoinT m) Source

mergeState :: Functor m => StateT s₁ (StateT s₂ m) a -> StateT (s₁, s₂) m a Source

splitState :: Functor m => StateT (s₁, s₂) m a -> StateT s₁ (StateT s₂ m) a Source

mapState :: forall m s₁ s₂ a. Functor m => (s₁ ⇄ s₂) -> StateT s₁ m a -> StateT s₂ m a Source

stateNondetAppendCommute :: forall s m. (Functor m, Monoid s) => StateT s (NondetAppendT m) ↝ NondetAppendT (StateT s m) Source

nondetAppendStateCommute :: forall s m. Functor m => NondetAppendT (StateT s m) ↝ StateT s (NondetAppendT m) Source

stateNondetJoinCommute :: forall s m. (Functor m, JoinLattice s) => StateT s (NondetJoinT m) ↝ NondetJoinT (StateT s m) Source

nondetJoinStateCommute :: forall s m. Functor m => NondetJoinT (StateT s m) ↝ StateT s (NondetJoinT m) Source

stateFlowAppendCommute :: forall s₁ s₂ m. (Functor m, Monoid s₁) => StateT s₁ (FlowAppendT s₂ m) ↝ FlowAppendT s₂ (StateT s₁ m) Source

flowAppendStateCommute :: forall s₁ s₂ m. (Functor m, Monoid s₁) => FlowAppendT s₁ (StateT s₂ m) ↝ StateT s₂ (FlowAppendT s₁ m) Source

stateFlowJoinCommute :: forall s₁ s₂ m. (Functor m, JoinLattice s₁) => StateT s₁ (FlowJoinT s₂ m) ↝ FlowJoinT s₂ (StateT s₁ m) Source

flowJoinStateCommute :: forall s₁ s₂ m. (Functor m, JoinLattice s₁) => FlowJoinT s₁ (StateT s₂ m) ↝ StateT s₂ (FlowJoinT s₁ m) Source

stateKonCommute :: StateT s (ContT (r, s) m) ↝ ContT r (StateT s m) Source

konStateCommute :: ContT r (StateT s m) ↝ StateT s (ContT (r, s) m) Source

newtype RWST r o s m a Source

runRWSTWith :: forall r o s m a. Functor m => r -> s -> RWST r o s m a -> m (a, o, s) Source

type RWS r o s = RWST r o s ID Source

runRWSWith :: r -> s -> RWS r o s a -> (a, o, s) Source