Documentation

monadIOExample :: IO () Source #

monadFailExample :: Either String () Source #

throwExample :: Either Int String Source #

handleExample :: String Source #

exampleGet :: (Int, Int) Source #

examplePut :: ((), Int) Source #

exampleModify :: ((), Int) Source #

yieldExample :: ([Int], ()) Source #

withYieldToListExample :: Int Source #

forEachExample :: ([Int], ()) Source #

inFoldableExample :: ([Int], ()) Source #

enumerateExample :: ([(Int, String)], ()) Source #

returnEarlyExample :: String Source #

effIOExample :: IO () Source #

example1_ :: (Int, Int) Source #

example2_ :: ((Int, Int), (Int, Int)) Source #

example3' :: Int -> Either String Int Source #

example3_ :: IO () Source #

countPositivesNegatives :: [Int] -> String Source #

type MyHandle = Compound (State Int) (Exception String) Source #

myInc :: e :> es => MyHandle e -> Eff es () Source #

myBail :: e :> es => MyHandle e -> Eff es r Source #

runMyHandle :: (forall e. MyHandle e -> Eff (e :& es) a) -> Eff es (Either String (a, Int)) Source #

compoundExample :: Either String (a, Int) Source #

countExample :: IO () Source #

writerExample1 :: Bool Source #

writerExample2 :: Bool Source #

while :: Eff es Bool -> Eff es a -> Eff es () Source #

stateSourceExample :: Int Source #

incrementReadLine :: (e1 :> es, e2 :> es, e3 :> es) => State Int e1 -> Exception String e2 -> IOE e3 -> Eff es () Source #

runIncrementReadLine :: IO (Either String Int) Source #

newtype Counter1 e Source #

incCounter1 :: e :> es => Counter1 e -> Eff es () Source #

runCounter1 :: (forall e. Counter1 e -> Eff (e :& es) r) -> Eff es Int Source #

exampleCounter1 :: Int Source #

data Counter2 e1 e2 Source #

incCounter2 :: (e1 :> es, e2 :> es) => Counter2 e1 e2 -> Eff es () Source #

runCounter2 :: (forall e1 e2. Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) r) -> Eff es Int Source #

exampleCounter2 :: Int Source #

data Counter3 e Source #

incCounter3 :: e :> es => Counter3 e -> Eff es () Source #

runCounter3 :: (forall e. Counter3 e -> Eff (e :& es) r) -> Eff es Int Source #

exampleCounter3 :: Int Source #

data Counter4 e Source #

incCounter4 :: e :> es => Counter4 e -> Eff es () Source #

getCounter4 :: e :> es => Counter4 e -> String -> Eff es Int Source #

runCounter4 :: e1 :> es => Stream String e1 -> (forall e. Counter4 e -> Eff (e :& es) r) -> Eff es Int Source #

exampleCounter4 :: ([String], Int) Source #

data Counter5 e Source #

incCounter5 :: e :> es => Counter5 e -> Eff es () Source #

getCounter5 :: e :> es => Counter5 e -> String -> Eff es Int Source #

runCounter5 :: e1 :> es => Stream String e1 -> (forall e. Counter5 e -> Eff (e :& es) r) -> Eff es Int Source #

exampleCounter5 :: ([String], Int) Source #

data Counter6 e Source #

incCounter6 :: e :> es => Counter6 e -> Eff es () Source #

getCounter6 :: e :> es => Counter6 e -> String -> Eff es Int Source #

runCounter6 :: e1 :> es => Stream String e1 -> (forall e. Counter6 e -> Eff (e :& es) r) -> Eff es Int Source #

exampleCounter6 :: ([String], Int) Source #

data FileSystem es Source #

readFile :: e :> es => FileSystem e -> FilePath -> Eff es String Source #

writeFile :: e :> es => FileSystem e -> FilePath -> String -> Eff es () Source #

runFileSystemPure :: e1 :> es => Exception String e1 -> [(FilePath, String)] -> (forall e2. FileSystem e2 -> Eff (e2 :& es) r) -> Eff es r Source #

runFileSystemIO :: forall e1 e2 es r. (e1 :> es, e2 :> es) => Exception String e1 -> IOE e2 -> (forall e. FileSystem e -> Eff (e :& es) r) -> Eff es r Source #

action :: e :> es => FileSystem e -> Eff es String Source #

exampleRunFileSystemPure :: Either String String Source #

exampleRunFileSystemIO :: IO (Either String String) Source #

data Application e Source #