{-# LANGUAGE NoMonoLocalBinds #-}
{-# LANGUAGE NoMonomorphismRestriction #-}

module Bluefin.Internal.Examples where

import Bluefin.Internal hiding (b, w)
import Bluefin.Internal.Pipes
  ( Producer,
    runEffect,
    stdinLn,
    stdoutLn,
    takeWhile',
    (>->),
  )
import qualified Bluefin.Internal.Pipes as P
import Control.Exception (IOException)
import qualified Control.Exception
import Control.Monad (forever, replicateM_, unless, when)
import Control.Monad.IO.Class (liftIO)
import Data.Foldable (for_)
import Data.Monoid (Any (Any, getAny))
import Text.Read (readMaybe)
import Prelude hiding
  ( break,
    drop,
    head,
    read,
    readFile,
    return,
    writeFile,
  )
import qualified Prelude

monadIOExample :: IO ()
monadIOExample :: IO ()
monadIOExample = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> IOE e -> (forall {m :: * -> *}. MonadIO m => m ()) -> Eff e ()
forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
IOE e -> (forall (m :: * -> *). MonadIO m => m r) -> Eff es r
withMonadIO IOE e
io ((forall {m :: * -> *}. MonadIO m => m ()) -> Eff e ())
-> (forall {m :: * -> *}. MonadIO m => m ()) -> Eff e ()
forall a b. (a -> b) -> a -> b
$ IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
  [Char]
name <- IO [Char]
forall a. Read a => IO a
readLn
  [Char] -> IO ()
putStrLn ([Char]
"Hello " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
name)

monadFailExample :: Either String ()
monadFailExample :: Either [Char] ()
monadFailExample = (forall (es :: Effects). Eff es (Either [Char] ()))
-> Either [Char] ()
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Either [Char] ()))
 -> Either [Char] ())
-> (forall (es :: Effects). Eff es (Either [Char] ()))
-> Either [Char] ()
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). Exception [Char] e -> Eff (e :& es) ())
-> Eff es (Either [Char] ())
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception [Char] e -> Eff (e :& es) ())
 -> Eff es (Either [Char] ()))
-> (forall (e :: Effects). Exception [Char] e -> Eff (e :& es) ())
-> Eff es (Either [Char] ())
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
e ->
  Bool -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ((Int
2 :: Int) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1) (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$
    Exception [Char] e
-> (forall (m :: * -> *). MonadFail m => m ()) -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
Exception [Char] e
-> (forall (m :: * -> *). MonadFail m => m r) -> Eff es r
withMonadFail Exception [Char] e
e ([Char] -> m ()
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"2 was bigger than 1")

throwExample :: Either Int String
throwExample :: Either Int [Char]
throwExample = (forall (es :: Effects). Eff es (Either Int [Char]))
-> Either Int [Char]
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Either Int [Char]))
 -> Either Int [Char])
-> (forall (es :: Effects). Eff es (Either Int [Char]))
-> Either Int [Char]
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). Exception Int e -> Eff (e :& es) [Char])
-> Eff es (Either Int [Char])
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception Int e -> Eff (e :& es) [Char])
 -> Eff es (Either Int [Char]))
-> (forall (e :: Effects). Exception Int e -> Eff (e :& es) [Char])
-> Eff es (Either Int [Char])
forall a b. (a -> b) -> a -> b
$ \Exception Int e
e -> do
  Any
_ <- Exception Int e -> Int -> Eff (e :& es) Any
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception Int e
e Int
42
  [Char] -> Eff (e :& es) [Char]
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"No exception thrown"

handleExample :: String
handleExample :: [Char]
handleExample = (forall (es :: Effects). Eff es [Char]) -> [Char]
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es [Char]) -> [Char])
-> (forall (es :: Effects). Eff es [Char]) -> [Char]
forall a b. (a -> b) -> a -> b
$ (Int -> Eff es [Char])
-> (forall {e :: Effects}. Exception Int e -> Eff (e :& es) [Char])
-> Eff es [Char]
forall exn (es :: Effects) a.
(exn -> Eff es a)
-> (forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es a
handle ([Char] -> Eff es [Char]
forall a. a -> Eff es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Char] -> Eff es [Char])
-> (Int -> [Char]) -> Int -> Eff es [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Char]
forall a. Show a => a -> [Char]
show) ((forall {e :: Effects}. Exception Int e -> Eff (e :& es) [Char])
 -> Eff es [Char])
-> (forall {e :: Effects}. Exception Int e -> Eff (e :& es) [Char])
-> Eff es [Char]
forall a b. (a -> b) -> a -> b
$ \Exception Int e
e -> do
  Any
_ <- Exception Int e -> Int -> Eff (e :& es) Any
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception Int e
e (Int
42 :: Int)
  [Char] -> Eff (e :& es) [Char]
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"No exception thrown"

exampleGet :: (Int, Int)
exampleGet :: (Int, Int)
exampleGet = (forall (es :: Effects). Eff es (Int, Int)) -> (Int, Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Int, Int)) -> (Int, Int))
-> (forall (es :: Effects). Eff es (Int, Int)) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es (Int, Int)
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es (a, s)
runState Int
10 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es (Int, Int))
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es (Int, Int)
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
  Int
n <- State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st
  Int -> Eff (e :& es) Int
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
2 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n)

examplePut :: ((), Int)
examplePut :: ((), Int)
examplePut = (forall (es :: Effects). Eff es ((), Int)) -> ((), Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ((), Int)) -> ((), Int))
-> (forall (es :: Effects). Eff es ((), Int)) -> ((), Int)
forall a b. (a -> b) -> a -> b
$ Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ((), Int)
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es (a, s)
runState Int
10 ((forall {e :: Effects}. State Int e -> Eff (e :& es) ())
 -> Eff es ((), Int))
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ((), Int)
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
  State Int e -> Int -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
st Int
30

exampleModify :: ((), Int)
exampleModify :: ((), Int)
exampleModify = (forall (es :: Effects). Eff es ((), Int)) -> ((), Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ((), Int)) -> ((), Int))
-> (forall (es :: Effects). Eff es ((), Int)) -> ((), Int)
forall a b. (a -> b) -> a -> b
$ Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ((), Int)
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es (a, s)
runState Int
10 ((forall {e :: Effects}. State Int e -> Eff (e :& es) ())
 -> Eff es ((), Int))
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ((), Int)
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
  State Int e -> (Int -> Int) -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
st (Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
2)

yieldExample :: ([Int], ())
yieldExample :: ([Int], ())
yieldExample = (forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ())
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ()))
-> (forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ())
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
-> Eff es ([Int], ())
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
 -> Eff es ([Int], ()))
-> (forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
-> Eff es ([Int], ())
forall a b. (a -> b) -> a -> b
$ \Stream Int e1
y -> do
  Stream Int e1 -> Int -> Eff (e1 :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e1
y Int
1
  Stream Int e1 -> Int -> Eff (e1 :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e1
y Int
2
  Stream Int e1 -> Int -> Eff (e1 :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e1
y Int
100

withYieldToListExample :: Int
withYieldToListExample :: Int
withYieldToListExample = (forall (es :: Effects). Eff es Int) -> Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Int) -> Int)
-> (forall (es :: Effects). Eff es Int) -> Int
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects).
 Stream Integer e -> Eff (e :& es) ([Integer] -> Int))
-> Eff es Int
forall a (es :: Effects) r.
(forall (e :: Effects). Stream a e -> Eff (e :& es) ([a] -> r))
-> Eff es r
withYieldToList ((forall (e :: Effects).
  Stream Integer e -> Eff (e :& es) ([Integer] -> Int))
 -> Eff es Int)
-> (forall (e :: Effects).
    Stream Integer e -> Eff (e :& es) ([Integer] -> Int))
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \Stream Integer e
y -> do
  Stream Integer e -> Integer -> Eff (e :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Integer e
y Integer
1
  Stream Integer e -> Integer -> Eff (e :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Integer e
y Integer
2
  Stream Integer e -> Integer -> Eff (e :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Integer e
y Integer
100
  ([Integer] -> Int) -> Eff (e :& es) ([Integer] -> Int)
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Integer] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length

-- This shows we can use forEach at any level of nesting with
-- insertManySecond
doubleNestedForEach ::
  (forall e. Stream () e -> Eff (e :& es) ()) ->
  Eff es ()
doubleNestedForEach :: forall (es :: Effects).
(forall (e :: Effects). Stream () e -> Eff (e :& es) ())
-> Eff es ()
doubleNestedForEach forall (e :: Effects). Stream () e -> Eff (e :& es) ()
f =
  ()
-> (forall {e :: Effects}. State () e -> Eff (e :& es) (() -> ()))
-> Eff es ()
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) (s -> a))
-> Eff es a
withState () ((forall {e :: Effects}. State () e -> Eff (e :& es) (() -> ()))
 -> Eff es ())
-> (forall {e :: Effects}. State () e -> Eff (e :& es) (() -> ()))
-> Eff es ()
forall a b. (a -> b) -> a -> b
$ \State () e
_ -> do
    ()
-> (forall {e :: Effects}.
    State () e -> Eff (e :& (e :& es)) (() -> () -> ()))
-> Eff (e :& es) (() -> ())
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) (s -> a))
-> Eff es a
withState () ((forall {e :: Effects}.
  State () e -> Eff (e :& (e :& es)) (() -> () -> ()))
 -> Eff (e :& es) (() -> ()))
-> (forall {e :: Effects}.
    State () e -> Eff (e :& (e :& es)) (() -> () -> ()))
-> Eff (e :& es) (() -> ())
forall a b. (a -> b) -> a -> b
$ \State () e
_ -> do
      (forall (e1 :: Effects).
 Coroutine () () e1 -> Eff (e1 :& (e :& (e :& es))) ())
-> (() -> Eff (e :& (e :& es)) ()) -> Eff (e :& (e :& es)) ()
forall a b (es :: Effects) r.
(forall (e1 :: Effects). Coroutine a b e1 -> Eff (e1 :& es) r)
-> (a -> Eff es b) -> Eff es r
forEach (Eff (e1 :& es) () -> Eff (e1 :& (e :& (e :& es))) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
insertManySecond (Eff (e1 :& es) () -> Eff (e1 :& (e :& (e :& es))) ())
-> (Coroutine () () e1 -> Eff (e1 :& es) ())
-> Coroutine () () e1
-> Eff (e1 :& (e :& (e :& es))) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Coroutine () () e1 -> Eff (e1 :& es) ()
forall (e :: Effects). Stream () e -> Eff (e :& es) ()
f) (\()
_ -> () -> Eff (e :& (e :& es)) ()
forall a. a -> Eff (e :& (e :& es)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
      (() -> () -> ()) -> Eff (e :& (e :& es)) (() -> () -> ())
forall a. a -> Eff (e :& (e :& es)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (\()
_ ()
_ -> ())

forEachExample :: ([Int], ())
forEachExample :: ([Int], ())
forEachExample = (forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ())
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ()))
-> (forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ())
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
-> Eff es ([Int], ())
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
 -> Eff es ([Int], ()))
-> (forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
-> Eff es ([Int], ())
forall a b. (a -> b) -> a -> b
$ \Stream Int e1
y -> do
  [Int] -> (Int -> Eff (e1 :& es) ()) -> Eff (e1 :& es) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
0 .. Int
4] ((Int -> Eff (e1 :& es) ()) -> Eff (e1 :& es) ())
-> (Int -> Eff (e1 :& es) ()) -> Eff (e1 :& es) ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> do
    Stream Int e1 -> Int -> Eff (e1 :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e1
y Int
i
    Stream Int e1 -> Int -> Eff (e1 :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e1
y (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
10)

ignoreStreamExample :: Int
ignoreStreamExample :: Int
ignoreStreamExample = (forall (es :: Effects). Eff es Int) -> Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Int) -> Int)
-> (forall (es :: Effects). Eff es Int) -> Int
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream Integer e1 -> Eff (e1 :& es) Int)
-> Eff es Int
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es r
ignoreStream ((forall (e1 :: Effects). Stream Integer e1 -> Eff (e1 :& es) Int)
 -> Eff es Int)
-> (forall (e1 :: Effects).
    Stream Integer e1 -> Eff (e1 :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \Stream Integer e1
y -> do
  [Integer] -> (Integer -> Eff (e1 :& es) ()) -> Eff (e1 :& es) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Integer
0 .. Integer
4] ((Integer -> Eff (e1 :& es) ()) -> Eff (e1 :& es) ())
-> (Integer -> Eff (e1 :& es) ()) -> Eff (e1 :& es) ()
forall a b. (a -> b) -> a -> b
$ \Integer
i -> do
    Stream Integer e1 -> Integer -> Eff (e1 :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Integer e1
y Integer
i
    Stream Integer e1 -> Integer -> Eff (e1 :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Integer e1
y (Integer
i Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
10)

  Int -> Eff (e1 :& es) Int
forall a. a -> Eff (e1 :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
42

inFoldableExample :: ([Int], ())
inFoldableExample :: ([Int], ())
inFoldableExample = (forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ())
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ()))
-> (forall (es :: Effects). Eff es ([Int], ())) -> ([Int], ())
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
-> Eff es ([Int], ())
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
 -> Eff es ([Int], ()))
-> (forall (e1 :: Effects). Stream Int e1 -> Eff (e1 :& es) ())
-> Eff es ([Int], ())
forall a b. (a -> b) -> a -> b
$ [Int] -> Stream Int e1 -> Eff (e1 :& es) ()
forall (t :: * -> *) (e1 :: Effects) (es :: Effects) a.
(Foldable t, e1 :> es) =>
t a -> Stream a e1 -> Eff es ()
inFoldable [Int
1, Int
2, Int
100]

enumerateExample :: ([(Int, String)], ())
enumerateExample :: ([(Int, [Char])], ())
enumerateExample = (forall (es :: Effects). Eff es ([(Int, [Char])], ()))
-> ([(Int, [Char])], ())
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([(Int, [Char])], ()))
 -> ([(Int, [Char])], ()))
-> (forall (es :: Effects). Eff es ([(Int, [Char])], ()))
-> ([(Int, [Char])], ())
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects).
 Stream (Int, [Char]) e1 -> Eff (e1 :& es) ())
-> Eff es ([(Int, [Char])], ())
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects).
  Stream (Int, [Char]) e1 -> Eff (e1 :& es) ())
 -> Eff es ([(Int, [Char])], ()))
-> (forall (e1 :: Effects).
    Stream (Int, [Char]) e1 -> Eff (e1 :& es) ())
-> Eff es ([(Int, [Char])], ())
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects).
 Stream [Char] e1 -> Eff (e1 :& (e1 :& es)) ())
-> Stream (Int, [Char]) e1 -> Eff (e1 :& es) ()
forall (e2 :: Effects) (es :: Effects) a r.
(e2 :> es) =>
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Stream (Int, a) e2 -> Eff es r
enumerate ([[Char]] -> Stream [Char] e1 -> Eff (e1 :& (e1 :& es)) ()
forall (t :: * -> *) (e1 :: Effects) (es :: Effects) a.
(Foldable t, e1 :> es) =>
t a -> Stream a e1 -> Eff es ()
inFoldable [[Char]
"A", [Char]
"B", [Char]
"C"])

returnEarlyExample :: String
returnEarlyExample :: [Char]
returnEarlyExample = (forall (es :: Effects). Eff es [Char]) -> [Char]
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es [Char]) -> [Char])
-> (forall (es :: Effects). Eff es [Char]) -> [Char]
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects).
 EarlyReturn [Char] e -> Eff (e :& es) [Char])
-> Eff es [Char]
forall r (es :: Effects).
(forall (e :: Effects). EarlyReturn r e -> Eff (e :& es) r)
-> Eff es r
withEarlyReturn ((forall (e :: Effects).
  EarlyReturn [Char] e -> Eff (e :& es) [Char])
 -> Eff es [Char])
-> (forall (e :: Effects).
    EarlyReturn [Char] e -> Eff (e :& es) [Char])
-> Eff es [Char]
forall a b. (a -> b) -> a -> b
$ \EarlyReturn [Char] e
e -> do
  [Int] -> (Int -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 :: Int .. Int
10] ((Int -> Eff (e :& es) ()) -> Eff (e :& es) ())
-> (Int -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> do
    Bool -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
5) (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$
      EarlyReturn [Char] e -> [Char] -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
returnEarly EarlyReturn [Char] e
e ([Char]
"Returned early with " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i)
  [Char] -> Eff (e :& es) [Char]
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"End of loop"

effIOExample :: IO ()
effIOExample :: IO ()
effIOExample = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  IOE e -> IO () -> Eff e ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Hello world!")

example1_ :: (Int, Int)
example1_ :: (Int, Int)
example1_ =
  let example1 :: Int -> Int
      example1 :: Int -> Int
example1 Int
n = (forall (es :: Effects). Eff es Int) -> Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Int) -> Int)
-> (forall (es :: Effects). Eff es Int) -> Int
forall a b. (a -> b) -> a -> b
$ Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
n ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
        Int
n' <- State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st
        Bool -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
10) (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$
          State Int e -> Int -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
st (Int
n' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10)
        State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st
   in (Int -> Int
example1 Int
5, Int -> Int
example1 Int
12)

example2_ :: ((Int, Int), (Int, Int))
example2_ :: ((Int, Int), (Int, Int))
example2_ =
  let example2 :: (Int, Int) -> (Int, Int)
      example2 :: (Int, Int) -> (Int, Int)
example2 (Int
m, Int
n) = (forall (es :: Effects). Eff es (Int, Int)) -> (Int, Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Int, Int)) -> (Int, Int))
-> (forall (es :: Effects). Eff es (Int, Int)) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$
        Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) (Int, Int))
-> Eff es (Int, Int)
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
m ((forall {e :: Effects}. State Int e -> Eff (e :& es) (Int, Int))
 -> Eff es (Int, Int))
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) (Int, Int))
-> Eff es (Int, Int)
forall a b. (a -> b) -> a -> b
$ \State Int e
sm -> do
          Int
-> (forall {e :: Effects}.
    State Int e -> Eff (e :& (e :& es)) (Int, Int))
-> Eff (e :& es) (Int, Int)
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
n ((forall {e :: Effects}.
  State Int e -> Eff (e :& (e :& es)) (Int, Int))
 -> Eff (e :& es) (Int, Int))
-> (forall {e :: Effects}.
    State Int e -> Eff (e :& (e :& es)) (Int, Int))
-> Eff (e :& es) (Int, Int)
forall a b. (a -> b) -> a -> b
$ \State Int e
sn -> do
            do
              Int
n' <- State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
sn
              Int
m' <- State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
sm

              if Int
n' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
m'
                then State Int e -> Int -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
sn (Int
n' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10)
                else State Int e -> Int -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
sm (Int
m' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10)

            Int
n' <- State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
sn
            Int
m' <- State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
sm

            (Int, Int) -> Eff (e :& (e :& es)) (Int, Int)
forall a. a -> Eff (e :& (e :& es)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
n', Int
m')
   in ((Int, Int) -> (Int, Int)
example2 (Int
5, Int
10), (Int, Int) -> (Int, Int)
example2 (Int
12, Int
5))

example3' :: Int -> Either String Int
example3' :: Int -> Either [Char] Int
example3' Int
n = (forall (es :: Effects). Eff es (Either [Char] Int))
-> Either [Char] Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Either [Char] Int))
 -> Either [Char] Int)
-> (forall (es :: Effects). Eff es (Either [Char] Int))
-> Either [Char] Int
forall a b. (a -> b) -> a -> b
$
  (forall (e :: Effects). Exception [Char] e -> Eff (e :& es) Int)
-> Eff es (Either [Char] Int)
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception [Char] e -> Eff (e :& es) Int)
 -> Eff es (Either [Char] Int))
-> (forall (e :: Effects). Exception [Char] e -> Eff (e :& es) Int)
-> Eff es (Either [Char] Int)
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
ex -> do
    Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) Int)
-> Eff (e :& es) Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) Int)
 -> Eff (e :& es) Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) Int)
-> Eff (e :& es) Int
forall a b. (a -> b) -> a -> b
$ \State Int e
total -> do
      [Int]
-> (Int -> Eff (e :& (e :& es)) ()) -> Eff (e :& (e :& es)) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 .. Int
n] ((Int -> Eff (e :& (e :& es)) ()) -> Eff (e :& (e :& es)) ())
-> (Int -> Eff (e :& (e :& es)) ()) -> Eff (e :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> do
        Int
soFar <- State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
total
        Bool -> Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
soFar Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
20) (Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ())
-> Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$ do
          Exception [Char] e -> [Char] -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception [Char] e
ex ([Char]
"Became too big: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
soFar)
        State Int e -> Int -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
total (Int
soFar Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)

      State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
total

-- Count non-empty lines from stdin, and print a friendly message,
-- until we see "STOP".
example3_ :: IO ()
example3_ :: IO ()
example3_ = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  let getLineUntilStop :: Coroutine [Char] () e1 -> Eff es ()
getLineUntilStop Coroutine [Char] () e1
y = (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall (es :: Effects).
(forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
withJump ((forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ())
-> (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall a b. (a -> b) -> a -> b
$ \Jump e
stop -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ do
        [Char]
line <- IOE e -> IO [Char] -> Eff (e :& es) [Char]
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io IO [Char]
getLine
        Bool -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([Char]
line [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"STOP") (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$
          Jump e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Jump e -> Eff es a
jumpTo Jump e
stop
        Coroutine [Char] () e1 -> [Char] -> Eff (e :& es) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Coroutine [Char] () e1
y [Char]
line

      nonEmptyLines :: Stream [Char] e2 -> Eff es ()
nonEmptyLines =
        ([Char] -> Maybe [Char])
-> (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) ())
-> Stream [Char] e2
-> Eff es ()
forall (e2 :: Effects) (es :: Effects) a b r.
(e2 :> es) =>
(a -> Maybe b)
-> (forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Stream b e2
-> Eff es r
mapMaybe
          ( \case
              [Char]
"" -> Maybe [Char]
forall a. Maybe a
Nothing
              [Char]
line -> [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
line
          )
          Coroutine [Char] () e1 -> Eff (e1 :& es) ()
forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) ()
forall {es :: Effects} {e1 :: Effects}.
(e :> es, e1 :> es) =>
Coroutine [Char] () e1 -> Eff es ()
getLineUntilStop

      enumeratedLines :: Stream (Int, [Char]) e2 -> Eff es ()
enumeratedLines = Int
-> (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) ())
-> Stream (Int, [Char]) e2
-> Eff es ()
forall (e2 :: Effects) (es :: Effects) a r.
(e2 :> es) =>
Int
-> (forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Stream (Int, a) e2
-> Eff es r
enumerateFrom Int
1 Stream [Char] e1 -> Eff (e1 :& es) ()
forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) ()
forall {e2 :: Effects} {es :: Effects}.
(e2 :> es, e :> es) =>
Stream [Char] e2 -> Eff es ()
nonEmptyLines

      formattedLines :: Stream [Char] e2 -> Eff es ()
formattedLines =
        ((Int, [Char]) -> [Char])
-> (forall (e1 :: Effects).
    Stream (Int, [Char]) e1 -> Eff (e1 :& es) ())
-> Stream [Char] e2
-> Eff es ()
forall (e2 :: Effects) (es :: Effects) a b r.
(e2 :> es) =>
(a -> b)
-> (forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Stream b e2
-> Eff es r
mapStream
          (\(Int
i, [Char]
line) -> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
". Hello! You said " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
line)
          Stream (Int, [Char]) e1 -> Eff (e1 :& es) ()
forall (e1 :: Effects).
Stream (Int, [Char]) e1 -> Eff (e1 :& es) ()
forall {e2 :: Effects} {es :: Effects}.
(e2 :> es, e :> es) =>
Stream (Int, [Char]) e2 -> Eff es ()
enumeratedLines

  (forall (e1 :: Effects).
 Coroutine [Char] () e1 -> Eff (e1 :& e) ())
-> ([Char] -> Eff e ()) -> Eff e ()
forall a b (es :: Effects) r.
(forall (e1 :: Effects). Coroutine a b e1 -> Eff (e1 :& es) r)
-> (a -> Eff es b) -> Eff es r
forEach Stream [Char] e1 -> Eff (e1 :& e) ()
forall (e1 :: Effects). Coroutine [Char] () e1 -> Eff (e1 :& e) ()
forall {e2 :: Effects} {es :: Effects}.
(e2 :> es, e :> es) =>
Stream [Char] e2 -> Eff es ()
formattedLines (([Char] -> Eff e ()) -> Eff e ())
-> ([Char] -> Eff e ()) -> Eff e ()
forall a b. (a -> b) -> a -> b
$ \[Char]
line -> IOE e -> IO () -> Eff e ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
line)

awaitList ::
  (e :> es) =>
  [a] ->
  IOE e ->
  (forall e1. Consume a e1 -> Eff (e1 :& es) ()) ->
  Eff es ()
awaitList :: forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
[a]
-> IOE e
-> (forall (e1 :: Effects). Consume a e1 -> Eff (e1 :& es) ())
-> Eff es ()
awaitList [a]
l IOE e
io forall (e1 :: Effects). Consume a e1 -> Eff (e1 :& es) ()
k = [a]
-> (forall {e :: Effects}. State [a] e -> Eff (e :& es) ())
-> Eff es ()
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState [a]
l ((forall {e :: Effects}. State [a] e -> Eff (e :& es) ())
 -> Eff es ())
-> (forall {e :: Effects}. State [a] e -> Eff (e :& es) ())
-> Eff es ()
forall a b. (a -> b) -> a -> b
$ \State [a] e
s -> do
  (forall (e :: Effects). Jump e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) ()
forall (es :: Effects).
(forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
withJump ((forall (e :: Effects). Jump e -> Eff (e :& (e :& es)) ())
 -> Eff (e :& es) ())
-> (forall (e :: Effects). Jump e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \Jump e
done ->
    Eff (e :& (e :& es)) ()
-> (() -> Eff (e :& (e :& es)) ())
-> (() -> Eff (e :& (e :& es)) ())
-> Eff (e :& (e :& es)) ()
forall (es :: Effects) a b.
Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
bracket
      (() -> Eff (e :& (e :& es)) ()
forall a. a -> Eff (e :& (e :& es)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
      (\() -> IOE e -> IO () -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Released"))
      ((() -> Eff (e :& (e :& es)) ()) -> Eff (e :& (e :& es)) ())
-> (() -> Eff (e :& (e :& es)) ()) -> Eff (e :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$ \() -> do
        (forall (e :: Effects).
 Consume a e -> Eff (e :& (e :& (e :& es))) ())
-> Eff (e :& (e :& es)) a -> Eff (e :& (e :& es)) ()
forall b (es :: Effects) r.
(forall (e :: Effects). Consume b e -> Eff (e :& es) r)
-> Eff es b -> Eff es r
consumeEach (Eff (e :& es) () -> Eff (e :& (e :& (e :& es))) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (Eff (e :& es) () -> Eff (e :& (e :& (e :& es))) ())
-> (Consume a e -> Eff (e :& es) ())
-> Consume a e
-> Eff (e :& (e :& (e :& es))) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Consume a e -> Eff (e :& es) ()
forall (e1 :: Effects). Consume a e1 -> Eff (e1 :& es) ()
k) (Eff (e :& (e :& es)) a -> Eff (e :& (e :& es)) ())
-> Eff (e :& (e :& es)) a -> Eff (e :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$ do
          (a
x, [a]
xs) <-
            State [a] e -> Eff (e :& (e :& es)) [a]
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State [a] e
s Eff (e :& (e :& es)) [a]
-> ([a] -> Eff (e :& (e :& es)) (a, [a]))
-> Eff (e :& (e :& es)) (a, [a])
forall a b.
Eff (e :& (e :& es)) a
-> (a -> Eff (e :& (e :& es)) b) -> Eff (e :& (e :& es)) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
              [] -> Jump e -> Eff (e :& (e :& es)) (a, [a])
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Jump e -> Eff es a
jumpTo Jump e
done
              a
x : [a]
xs -> (a, [a]) -> Eff (e :& (e :& es)) (a, [a])
forall a. a -> Eff (e :& (e :& es)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a
x, [a]
xs)
          State [a] e -> [a] -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State [a] e
s [a]
xs
          a -> Eff (e :& (e :& es)) a
forall a. a -> Eff (e :& (e :& es)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x

takeRec ::
  (e3 :> es) =>
  Int ->
  (forall e. Consume a e -> Eff (e :& es) ()) ->
  Consume a e3 ->
  Eff es ()
takeRec :: forall (e3 :: Effects) (es :: Effects) a.
(e3 :> es) =>
Int
-> (forall (e :: Effects). Consume a e -> Eff (e :& es) ())
-> Consume a e3
-> Eff es ()
takeRec Int
n forall (e :: Effects). Consume a e -> Eff (e :& es) ()
k Consume a e3
rec =
  (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall (es :: Effects).
(forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
withJump ((forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ())
-> (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall a b. (a -> b) -> a -> b
$ \Jump e
done -> Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) ()
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
n ((forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) ())
 -> Eff (e :& es) ())
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \State Int e
s -> (forall (e :: Effects).
 Consume a e -> Eff (e :& (e :& (e :& es))) ())
-> Eff (e :& (e :& es)) a -> Eff (e :& (e :& es)) ()
forall b (es :: Effects) r.
(forall (e :: Effects). Consume b e -> Eff (e :& es) r)
-> Eff es b -> Eff es r
consumeEach (Eff (e :& es) () -> Eff (e :& (e :& (e :& es))) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (Eff (e :& es) () -> Eff (e :& (e :& (e :& es))) ())
-> (Consume a e -> Eff (e :& es) ())
-> Consume a e
-> Eff (e :& (e :& (e :& es))) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Consume a e -> Eff (e :& es) ()
forall (e :: Effects). Consume a e -> Eff (e :& es) ()
k) (Eff (e :& (e :& es)) a -> Eff (e :& (e :& es)) ())
-> Eff (e :& (e :& es)) a -> Eff (e :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$ do
    Int
s' <- State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
s
    if Int
s' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
      then Jump e -> Eff (e :& (e :& es)) a
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Jump e -> Eff es a
jumpTo Jump e
done
      else do
        State Int e -> (Int -> Int) -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
s (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1)
        Consume a e3 -> Eff (e :& (e :& es)) a
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Consume a e3
rec

mapRec ::
  (e :> es) =>
  (a -> b) ->
  (forall e1. Consume b e1 -> Eff (e1 :& es) ()) ->
  Consume a e ->
  Eff es ()
mapRec :: forall (e :: Effects) (es :: Effects) a b.
(e :> es) =>
(a -> b)
-> (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> Consume a e
-> Eff es ()
mapRec a -> b
f = (a -> Eff es b)
-> (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> Consume a e
-> Eff es ()
forall (e :: Effects) (es :: Effects) a b.
(e :> es) =>
(a -> Eff es b)
-> (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> Consume a e
-> Eff es ()
traverseRec (b -> Eff es b
forall a. a -> Eff es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b -> Eff es b) -> (a -> b) -> a -> Eff es b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)

traverseRec ::
  (e :> es) =>
  (a -> Eff es b) ->
  (forall e1. Consume b e1 -> Eff (e1 :& es) ()) ->
  Consume a e ->
  Eff es ()
traverseRec :: forall (e :: Effects) (es :: Effects) a b.
(e :> es) =>
(a -> Eff es b)
-> (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> Consume a e
-> Eff es ()
traverseRec a -> Eff es b
f forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ()
k Consume a e
rec = (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> (() -> Eff es b) -> Eff es ()
forall a b (es :: Effects) r.
(forall (e1 :: Effects). Coroutine a b e1 -> Eff (e1 :& es) r)
-> (a -> Eff es b) -> Eff es r
forEach Consume b e1 -> Eff (e1 :& es) ()
forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ()
k ((() -> Eff es b) -> Eff es ()) -> (() -> Eff es b) -> Eff es ()
forall a b. (a -> b) -> a -> b
$ \() -> do
  a
r <- Consume a e -> Eff es a
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Consume a e
rec
  a -> Eff es b
f a
r

awaitUsage ::
  (e1 :> es, e2 :> es) =>
  IOE e1 ->
  (forall e. Consume () e -> Eff (e :& es) ()) ->
  Consume Int e2 ->
  Eff es ()
awaitUsage :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects).
(e1 :> es, e2 :> es) =>
IOE e1
-> (forall (e :: Effects). Consume () e -> Eff (e :& es) ())
-> Consume Int e2
-> Eff es ()
awaitUsage IOE e1
io forall (e :: Effects). Consume () e -> Eff (e :& es) ()
x = do
  (Int -> Int)
-> (forall {e1 :: Effects}. Consume Int e1 -> Eff (e1 :& es) ())
-> Consume Int e2
-> Eff es ()
forall (e :: Effects) (es :: Effects) a b.
(e :> es) =>
(a -> b)
-> (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> Consume a e
-> Eff es ()
mapRec (Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
11) ((forall {e1 :: Effects}. Consume Int e1 -> Eff (e1 :& es) ())
 -> Consume Int e2 -> Eff es ())
-> (forall {e1 :: Effects}. Consume Int e1 -> Eff (e1 :& es) ())
-> Consume Int e2
-> Eff es ()
forall a b. (a -> b) -> a -> b
$
    (Int -> Int)
-> (forall {e1 :: Effects}.
    Consume Int e1 -> Eff (e1 :& (e1 :& es)) ())
-> Coroutine () Int e1
-> Eff (e1 :& es) ()
forall (e :: Effects) (es :: Effects) a b.
(e :> es) =>
(a -> b)
-> (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> Consume a e
-> Eff es ()
mapRec (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1) ((forall {e1 :: Effects}.
  Consume Int e1 -> Eff (e1 :& (e1 :& es)) ())
 -> Coroutine () Int e1 -> Eff (e1 :& es) ())
-> (forall {e1 :: Effects}.
    Consume Int e1 -> Eff (e1 :& (e1 :& es)) ())
-> Coroutine () Int e1
-> Eff (e1 :& es) ()
forall a b. (a -> b) -> a -> b
$
      Int
-> (forall {e :: Effects}.
    Consume Int e -> Eff (e :& (e1 :& (e1 :& es))) ())
-> Coroutine () Int e1
-> Eff (e1 :& (e1 :& es)) ()
forall (e3 :: Effects) (es :: Effects) a.
(e3 :> es) =>
Int
-> (forall (e :: Effects). Consume a e -> Eff (e :& es) ())
-> Consume a e3
-> Eff es ()
takeRec Int
3 ((forall {e :: Effects}.
  Consume Int e -> Eff (e :& (e1 :& (e1 :& es))) ())
 -> Coroutine () Int e1 -> Eff (e1 :& (e1 :& es)) ())
-> (forall {e :: Effects}.
    Consume Int e -> Eff (e :& (e1 :& (e1 :& es))) ())
-> Coroutine () Int e1
-> Eff (e1 :& (e1 :& es)) ()
forall a b. (a -> b) -> a -> b
$
        (Int -> Eff (e :& (e1 :& (e1 :& es))) ())
-> (forall {e1 :: Effects}.
    Consume () e1 -> Eff (e1 :& (e :& (e1 :& (e1 :& es)))) ())
-> Coroutine () Int e
-> Eff (e :& (e1 :& (e1 :& es))) ()
forall (e :: Effects) (es :: Effects) a b.
(e :> es) =>
(a -> Eff es b)
-> (forall (e1 :: Effects). Consume b e1 -> Eff (e1 :& es) ())
-> Consume a e
-> Eff es ()
traverseRec (IOE e1 -> IO () -> Eff (e :& (e1 :& (e1 :& es))) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e1
io (IO () -> Eff (e :& (e1 :& (e1 :& es))) ())
-> (Int -> IO ()) -> Int -> Eff (e :& (e1 :& (e1 :& es))) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> IO ()
forall a. Show a => a -> IO ()
print) ((forall {e1 :: Effects}.
  Consume () e1 -> Eff (e1 :& (e :& (e1 :& (e1 :& es)))) ())
 -> Coroutine () Int e -> Eff (e :& (e1 :& (e1 :& es))) ())
-> (forall {e1 :: Effects}.
    Consume () e1 -> Eff (e1 :& (e :& (e1 :& (e1 :& es)))) ())
-> Coroutine () Int e
-> Eff (e :& (e1 :& (e1 :& es))) ()
forall a b. (a -> b) -> a -> b
$
          Eff (e1 :& es) () -> Eff (e1 :& (e :& (e1 :& (e1 :& es)))) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (Eff (e1 :& es) () -> Eff (e1 :& (e :& (e1 :& (e1 :& es)))) ())
-> (Consume () e1 -> Eff (e1 :& es) ())
-> Consume () e1
-> Eff (e1 :& (e :& (e1 :& (e1 :& es)))) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Consume () e1 -> Eff (e1 :& es) ()
forall (e :: Effects). Consume () e -> Eff (e :& es) ()
x

awaitExample :: IO ()
awaitExample :: IO ()
awaitExample = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  [Int]
-> IOE e
-> (forall {e1 :: Effects}. Consume Int e1 -> Eff (e1 :& e) ())
-> Eff e ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
[a]
-> IOE e
-> (forall (e1 :: Effects). Consume a e1 -> Eff (e1 :& es) ())
-> Eff es ()
awaitList [Int
1 :: Int ..] IOE e
io ((forall {e1 :: Effects}. Consume Int e1 -> Eff (e1 :& e) ())
 -> Eff e ())
-> (forall {e1 :: Effects}. Consume Int e1 -> Eff (e1 :& e) ())
-> Eff e ()
forall a b. (a -> b) -> a -> b
$ IOE e
-> (forall {e :: Effects}. Consume () e -> Eff (e :& (e1 :& e)) ())
-> Coroutine () Int e1
-> Eff (e1 :& e) ()
forall (e1 :: Effects) (es :: Effects) (e2 :: Effects).
(e1 :> es, e2 :> es) =>
IOE e1
-> (forall (e :: Effects). Consume () e -> Eff (e :& es) ())
-> Consume Int e2
-> Eff es ()
awaitUsage IOE e
io ((forall {e :: Effects}. Consume () e -> Eff (e :& (e1 :& e)) ())
 -> Coroutine () Int e1 -> Eff (e1 :& e) ())
-> (forall {e :: Effects}. Consume () e -> Eff (e :& (e1 :& e)) ())
-> Coroutine () Int e1
-> Eff (e1 :& e) ()
forall a b. (a -> b) -> a -> b
$ \Consume () e
rec -> do
    Int -> Eff (e :& (e1 :& e)) () -> Eff (e :& (e1 :& e)) ()
forall (m :: * -> *) a. Applicative m => Int -> m a -> m ()
replicateM_ Int
5 (Consume () e -> Eff (e :& (e1 :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Consume () e
rec)

consumeStreamExample :: IO (Either String String)
consumeStreamExample :: IO (Either [Char] [Char])
consumeStreamExample = (forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
-> IO (Either [Char] [Char])
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
 -> IO (Either [Char] [Char]))
-> (forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
-> IO (Either [Char] [Char])
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  (forall (e :: Effects). Exception [Char] e -> Eff (e :& e) [Char])
-> Eff e (Either [Char] [Char])
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception [Char] e -> Eff (e :& e) [Char])
 -> Eff e (Either [Char] [Char]))
-> (forall (e :: Effects).
    Exception [Char] e -> Eff (e :& e) [Char])
-> Eff e (Either [Char] [Char])
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
ex -> do
    (forall (e :: Effects).
 Consume Int e -> Eff (e :& (e :& e)) [Char])
-> (forall (e :: Effects).
    Stream Int e -> Eff (e :& (e :& e)) [Char])
-> Eff (e :& e) [Char]
forall a (es :: Effects) r.
(forall (e :: Effects). Consume a e -> Eff (e :& es) r)
-> (forall (e :: Effects). Stream a e -> Eff (e :& es) r)
-> Eff es r
consumeStream
      ( \Consume Int e
r ->
          Eff (e :& (e :& e)) ()
-> (() -> Eff (e :& (e :& e)) ())
-> (() -> Eff (e :& (e :& e)) [Char])
-> Eff (e :& (e :& e)) [Char]
forall (es :: Effects) a b.
Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
bracket
            (IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Starting 2"))
            (\()
_ -> IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Leaving 2"))
            ((() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char])
-> (() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char]
forall a b. (a -> b) -> a -> b
$ \()
_ -> do
              [Int] -> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 :: Int .. Int
100] ((Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ())
-> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
                Int
b <- Consume Int e -> Eff (e :& (e :& e)) Int
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Consume Int e
r
                IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO
                  IOE e
io
                  ( [Char] -> IO ()
putStrLn
                      ([Char]
"Consumed body " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
b [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" at time " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n)
                  )
              [Char] -> Eff (e :& (e :& e)) [Char]
forall a. a -> Eff (e :& (e :& e)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"Consumer finished first"
      )
      ( \Stream Int e
y -> Eff (e :& (e :& e)) ()
-> (() -> Eff (e :& (e :& e)) ())
-> (() -> Eff (e :& (e :& e)) [Char])
-> Eff (e :& (e :& e)) [Char]
forall (es :: Effects) a b.
Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
bracket
          (IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Starting 1"))
          (\()
_ -> IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Leaving 1"))
          ((() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char])
-> (() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char]
forall a b. (a -> b) -> a -> b
$ \()
_ -> do
            [Int] -> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 :: Int .. Int
10] ((Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ())
-> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
              IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn ([Char]
"Sending " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n))
              Stream Int e -> Int -> Eff (e :& (e :& e)) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e
y Int
n
              Bool -> Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
5) (Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ())
-> Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ()
forall a b. (a -> b) -> a -> b
$ do
                IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Aborting...")
                Exception [Char] e -> [Char] -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception [Char] e
ex [Char]
"Aborted"

            [Char] -> Eff (e :& (e :& e)) [Char]
forall a. a -> Eff (e :& (e :& e)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"Yielder finished first"
      )

consumeStreamExample2 :: IO ()
consumeStreamExample2 :: IO ()
consumeStreamExample2 = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  let counter :: Stream Int e1 -> Stream Int e1 -> Eff es ()
counter Stream Int e1
yeven Stream Int e1
yodd = [Int] -> (Int -> Eff es ()) -> Eff es ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
0 :: Int .. Int
10] ((Int -> Eff es ()) -> Eff es ())
-> (Int -> Eff es ()) -> Eff es ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> do
        if Int -> Bool
forall a. Integral a => a -> Bool
even Int
i
          then Stream Int e1 -> Int -> Eff es ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e1
yeven Int
i
          else Stream Int e1 -> Int -> Eff es ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e1
yodd Int
i

  let foo :: Coroutine Int () e1 -> Eff es ()
foo Coroutine Int () e1
yeven =
        (forall (e :: Effects). Consume Int e -> Eff (e :& es) ())
-> (forall (e :: Effects). Stream Int e -> Eff (e :& es) ())
-> Eff es ()
forall a (es :: Effects) r.
(forall (e :: Effects). Consume a e -> Eff (e :& es) r)
-> (forall (e :: Effects). Stream a e -> Eff (e :& es) r)
-> Eff es r
consumeStream
          ( \Consume Int e
r -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ do
              Int
i <- Consume Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Consume Int e
r
              IOE e -> IO () -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn ([Char]
"Odd: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i))
          )
          (Coroutine Int () e1 -> Coroutine Int () e -> Eff (e :& es) ()
forall {e1 :: Effects} {es :: Effects} {e1 :: Effects}.
(e1 :> es, e1 :> es) =>
Stream Int e1 -> Stream Int e1 -> Eff es ()
counter Coroutine Int () e1
yeven)

  let bar :: Eff es ()
bar =
        (forall (e :: Effects). Consume Int e -> Eff (e :& es) ())
-> (forall (e :: Effects). Stream Int e -> Eff (e :& es) ())
-> Eff es ()
forall a (es :: Effects) r.
(forall (e :: Effects). Consume a e -> Eff (e :& es) r)
-> (forall (e :: Effects). Stream a e -> Eff (e :& es) r)
-> Eff es r
consumeStream
          ( \Consume Int e
r -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ do
              Int
i <- Consume Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Consume Int e
r
              IOE e -> IO () -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn ([Char]
"Even: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i))
          )
          Coroutine Int () e -> Eff (e :& es) ()
forall (e :: Effects). Stream Int e -> Eff (e :& es) ()
forall {es :: Effects} {e1 :: Effects}.
(e :> es, e1 :> es) =>
Coroutine Int () e1 -> Eff es ()
foo

  Eff e ()
forall {es :: Effects}. (e :> es) => Eff es ()
bar

connectExample :: IO (Either String String)
connectExample :: IO (Either [Char] [Char])
connectExample = (forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
-> IO (Either [Char] [Char])
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
 -> IO (Either [Char] [Char]))
-> (forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
-> IO (Either [Char] [Char])
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  (forall (e :: Effects). Exception [Char] e -> Eff (e :& e) [Char])
-> Eff e (Either [Char] [Char])
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception [Char] e -> Eff (e :& e) [Char])
 -> Eff e (Either [Char] [Char]))
-> (forall (e :: Effects).
    Exception [Char] e -> Eff (e :& e) [Char])
-> Eff e (Either [Char] [Char])
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
ex -> do
    (forall (e :: Effects).
 Coroutine Int () e -> Eff (e :& (e :& e)) [Char])
-> (forall (e :: Effects).
    Int -> Coroutine () Int e -> Eff (e :& (e :& e)) [Char])
-> Eff (e :& e) [Char]
forall (es :: Effects) a b r.
(forall (e :: Effects). Coroutine a b e -> Eff (e :& es) r)
-> (forall (e :: Effects). a -> Coroutine b a e -> Eff (e :& es) r)
-> Eff es r
connectCoroutines
      ( \Coroutine Int () e
y -> Eff (e :& (e :& e)) ()
-> (() -> Eff (e :& (e :& e)) ())
-> (() -> Eff (e :& (e :& e)) [Char])
-> Eff (e :& (e :& e)) [Char]
forall (es :: Effects) a b.
Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
bracket
          (IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Starting 1"))
          (\()
_ -> IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Leaving 1"))
          ((() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char])
-> (() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char]
forall a b. (a -> b) -> a -> b
$ \()
_ -> do
            [Int] -> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 :: Int .. Int
10] ((Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ())
-> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
              IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn ([Char]
"Sending " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n))
              Coroutine Int () e -> Int -> Eff (e :& (e :& e)) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Coroutine Int () e
y Int
n
              Bool -> Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
5) (Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ())
-> Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ()
forall a b. (a -> b) -> a -> b
$ do
                IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Aborting...")
                Exception [Char] e -> [Char] -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception [Char] e
ex [Char]
"Aborted"

            [Char] -> Eff (e :& (e :& e)) [Char]
forall a. a -> Eff (e :& (e :& e)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"Yielder finished first"
      )
      ( \Int
binit Coroutine () Int e
r ->
          Eff (e :& (e :& e)) ()
-> (() -> Eff (e :& (e :& e)) ())
-> (() -> Eff (e :& (e :& e)) [Char])
-> Eff (e :& (e :& e)) [Char]
forall (es :: Effects) a b.
Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
bracket
            (IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Starting 2"))
            (\()
_ -> IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Leaving 2"))
            ((() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char])
-> (() -> Eff (e :& (e :& e)) [Char]) -> Eff (e :& (e :& e)) [Char]
forall a b. (a -> b) -> a -> b
$ \()
_ -> do
              IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn ([Char]
"Consumed intial " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
binit))
              [Int] -> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 :: Int .. Int
100] ((Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ())
-> (Int -> Eff (e :& (e :& e)) ()) -> Eff (e :& (e :& e)) ()
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
                Int
b <- Coroutine () Int e -> Eff (e :& (e :& e)) Int
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Coroutine () Int e
r
                IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO
                  IOE e
io
                  ( [Char] -> IO ()
putStrLn
                      ([Char]
"Consumed body " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
b [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" at time " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n)
                  )
              [Char] -> Eff (e :& (e :& e)) [Char]
forall a. a -> Eff (e :& (e :& e)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"Consumer finished first"
      )

zipCoroutinesExample :: IO ()
zipCoroutinesExample :: IO ()
zipCoroutinesExample = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  let m1 :: Coroutine Int Int e1 -> Eff es ()
m1 Coroutine Int Int e1
y = do
        Int
r <- Coroutine Int Int e1 -> Int -> Eff es Int
forall (e1 :: Effects) (es :: Effects) a b.
(e1 :> es) =>
Coroutine a b e1 -> a -> Eff es b
yieldCoroutine Coroutine Int Int e1
y Int
1
        Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ()
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
r ((forall {e :: Effects}. State Int e -> Eff (e :& es) ())
 -> Eff es ())
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ()
forall a b. (a -> b) -> a -> b
$ \State Int e
rs -> do
          [Int] -> (Int -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 .. Int
10 :: Int] ((Int -> Eff (e :& es) ()) -> Eff (e :& es) ())
-> (Int -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> do
            Int
r' <- State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
rs
            Int
r'' <- Coroutine Int Int e1 -> Int -> Eff (e :& es) Int
forall (e1 :: Effects) (es :: Effects) a b.
(e1 :> es) =>
Coroutine a b e1 -> a -> Eff es b
yieldCoroutine Coroutine Int Int e1
y (Int
r' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)
            State Int e -> Int -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
rs Int
r''

  let m2 :: Coroutine Int Int e1 -> Eff es ()
m2 Coroutine Int Int e1
y = do
        Int
r <- Coroutine Int Int e1 -> Int -> Eff es Int
forall (e1 :: Effects) (es :: Effects) a b.
(e1 :> es) =>
Coroutine a b e1 -> a -> Eff es b
yieldCoroutine Coroutine Int Int e1
y Int
1
        Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ()
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
r ((forall {e :: Effects}. State Int e -> Eff (e :& es) ())
 -> Eff es ())
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) ())
-> Eff es ()
forall a b. (a -> b) -> a -> b
$ \State Int e
rs -> do
          [Int] -> (Int -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 .. Int
5 :: Int] ((Int -> Eff (e :& es) ()) -> Eff (e :& es) ())
-> (Int -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> do
            Int
r' <- State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
rs
            Int
r'' <- Coroutine Int Int e1 -> Int -> Eff (e :& es) Int
forall (e1 :: Effects) (es :: Effects) a b.
(e1 :> es) =>
Coroutine a b e1 -> a -> Eff es b
yieldCoroutine Coroutine Int Int e1
y (Int
r' Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i)
            State Int e -> Int -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
rs Int
r''

  (forall (e1 :: Effects).
 Coroutine (Int, Int) Int e1 -> Eff (e1 :& e) ())
-> ((Int, Int) -> Eff e Int) -> Eff e ()
forall a b (es :: Effects) r.
(forall (e1 :: Effects). Coroutine a b e1 -> Eff (e1 :& es) r)
-> (a -> Eff es b) -> Eff es r
forEach (\Coroutine (Int, Int) Int e1
c -> Coroutine (Int, Int) Int e1
-> (forall (e :: Effects).
    Coroutine Int Int e -> Eff (e :& (e1 :& e)) ())
-> (forall (e :: Effects).
    Coroutine Int Int e -> Eff (e :& (e1 :& e)) ())
-> Eff (e1 :& e) ()
forall (e1 :: Effects) (es :: Effects) a1 a2 b r.
(e1 :> es) =>
Coroutine (a1, a2) b e1
-> (forall (e :: Effects). Coroutine a1 b e -> Eff (e :& es) r)
-> (forall (e :: Effects). Coroutine a2 b e -> Eff (e :& es) r)
-> Eff es r
zipCoroutines Coroutine (Int, Int) Int e1
c Coroutine Int Int e -> Eff (e :& (e1 :& e)) ()
forall (e :: Effects).
Coroutine Int Int e -> Eff (e :& (e1 :& e)) ()
forall {e1 :: Effects} {es :: Effects}.
(e1 :> es) =>
Coroutine Int Int e1 -> Eff es ()
m1 Coroutine Int Int e -> Eff (e :& (e1 :& e)) ()
forall (e :: Effects).
Coroutine Int Int e -> Eff (e :& (e1 :& e)) ()
forall {e1 :: Effects} {es :: Effects}.
(e1 :> es) =>
Coroutine Int Int e1 -> Eff es ()
m2) (((Int, Int) -> Eff e Int) -> Eff e ())
-> ((Int, Int) -> Eff e Int) -> Eff e ()
forall a b. (a -> b) -> a -> b
$ \i :: (Int, Int)
i@(Int
i1, Int
i2) -> do
    IOE e -> IO () -> Eff e ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ((Int, Int) -> IO ()
forall a. Show a => a -> IO ()
print (Int, Int)
i)
    Int -> Eff e Int
forall a. a -> Eff e a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int
i1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i2)

-- Count the number of (strictly) positives and (strictly) negatives
-- in a list, unless we see a zero, in which case we bail with an
-- error message.
countPositivesNegatives :: [Int] -> String
countPositivesNegatives :: [Int] -> [Char]
countPositivesNegatives [Int]
is = (forall (es :: Effects). Eff es [Char]) -> [Char]
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es [Char]) -> [Char])
-> (forall (es :: Effects). Eff es [Char]) -> [Char]
forall a b. (a -> b) -> a -> b
$
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) [Char])
-> Eff es [Char]
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState (Int
0 :: Int) ((forall {e :: Effects}. State Int e -> Eff (e :& es) [Char])
 -> Eff es [Char])
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) [Char])
-> Eff es [Char]
forall a b. (a -> b) -> a -> b
$ \State Int e
positives -> do
    Either () [Char]
r <- (forall (e :: Effects).
 Exception () e -> Eff (e :& (e :& es)) [Char])
-> Eff (e :& es) (Either () [Char])
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects).
  Exception () e -> Eff (e :& (e :& es)) [Char])
 -> Eff (e :& es) (Either () [Char]))
-> (forall (e :: Effects).
    Exception () e -> Eff (e :& (e :& es)) [Char])
-> Eff (e :& es) (Either () [Char])
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex ->
      Int
-> (forall {e :: Effects}.
    State Int e -> Eff (e :& (e :& (e :& es))) [Char])
-> Eff (e :& (e :& es)) [Char]
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState (Int
0 :: Int) ((forall {e :: Effects}.
  State Int e -> Eff (e :& (e :& (e :& es))) [Char])
 -> Eff (e :& (e :& es)) [Char])
-> (forall {e :: Effects}.
    State Int e -> Eff (e :& (e :& (e :& es))) [Char])
-> Eff (e :& (e :& es)) [Char]
forall a b. (a -> b) -> a -> b
$ \State Int e
negatives -> do
        [Int]
-> (Int -> Eff (e :& (e :& (e :& es))) ())
-> Eff (e :& (e :& (e :& es))) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int]
is ((Int -> Eff (e :& (e :& (e :& es))) ())
 -> Eff (e :& (e :& (e :& es))) ())
-> (Int -> Eff (e :& (e :& (e :& es))) ())
-> Eff (e :& (e :& (e :& es))) ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> do
          case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
i Int
0 of
            Ordering
GT -> State Int e -> (Int -> Int) -> Eff (e :& (e :& (e :& es))) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
positives (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
            Ordering
EQ -> Exception () e -> () -> Eff (e :& (e :& (e :& es))) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception () e
ex ()
            Ordering
LT -> State Int e -> (Int -> Int) -> Eff (e :& (e :& (e :& es))) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
negatives (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

        Int
p <- State Int e -> Eff (e :& (e :& (e :& es))) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
positives
        Int
n <- State Int e -> Eff (e :& (e :& (e :& es))) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
negatives

        [Char] -> Eff (e :& (e :& (e :& es))) [Char]
forall a. a -> Eff (e :& (e :& (e :& es))) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Char] -> Eff (e :& (e :& (e :& es))) [Char])
-> [Char] -> Eff (e :& (e :& (e :& es))) [Char]
forall a b. (a -> b) -> a -> b
$
          [Char]
"Positives: "
            [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
p
            [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", negatives "
            [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n

    case Either () [Char]
r of
      Right [Char]
r' -> [Char] -> Eff (e :& es) [Char]
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
r'
      Left () -> do
        Int
p <- State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
positives
        [Char] -> Eff (e :& es) [Char]
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Char] -> Eff (e :& es) [Char]) -> [Char] -> Eff (e :& es) [Char]
forall a b. (a -> b) -> a -> b
$
          [Char]
"We saw a zero, but before that there were "
            [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
p
            [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" positives"

-- How to make compound effects

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

myInc :: (e :> es) => MyHandle e -> Eff es ()
myInc :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
MyHandle e -> Eff es ()
myInc MyHandle e
h = MyHandle e
-> (forall (e1 :: Effects) (e2 :: Effects).
    (e1 :> es, e2 :> es) =>
    State Int e1 -> Exception [Char] e2 -> Eff es ())
-> Eff es ()
forall (h1 :: Effects -> *) (h2 :: Effects -> *) (e :: Effects)
       (es :: Effects) r.
(e :> es) =>
Compound h1 h2 e
-> (forall (e1 :: Effects) (e2 :: Effects).
    (e1 :> es, e2 :> es) =>
    h1 e1 -> h2 e2 -> Eff es r)
-> Eff es r
withCompound MyHandle e
h (\State Int e1
s Exception [Char] e2
_ -> State Int e1 -> (Int -> Int) -> Eff es ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e1
s (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))

myBail :: (e :> es) => MyHandle e -> Eff es r
myBail :: forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
MyHandle e -> Eff es r
myBail MyHandle e
h = MyHandle e
-> (forall {e1 :: Effects} {e2 :: Effects}.
    (e1 :> es, e2 :> es) =>
    State Int e1 -> Exception [Char] e2 -> Eff es r)
-> Eff es r
forall (h1 :: Effects -> *) (h2 :: Effects -> *) (e :: Effects)
       (es :: Effects) r.
(e :> es) =>
Compound h1 h2 e
-> (forall (e1 :: Effects) (e2 :: Effects).
    (e1 :> es, e2 :> es) =>
    h1 e1 -> h2 e2 -> Eff es r)
-> Eff es r
withCompound MyHandle e
h ((forall {e1 :: Effects} {e2 :: Effects}.
  (e1 :> es, e2 :> es) =>
  State Int e1 -> Exception [Char] e2 -> Eff es r)
 -> Eff es r)
-> (forall {e1 :: Effects} {e2 :: Effects}.
    (e1 :> es, e2 :> es) =>
    State Int e1 -> Exception [Char] e2 -> Eff es r)
-> Eff es r
forall a b. (a -> b) -> a -> b
$ \State Int e1
s Exception [Char] e2
e -> do
  Int
i <- State Int e1 -> Eff es Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e1
s
  Exception [Char] e2 -> [Char] -> Eff es r
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception [Char] e2
e ([Char]
"Current state was: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i)

runMyHandle ::
  (forall e. MyHandle e -> Eff (e :& es) a) ->
  Eff es (Either String (a, Int))
runMyHandle :: forall (es :: Effects) a.
(forall (e :: Effects). MyHandle e -> Eff (e :& es) a)
-> Eff es (Either [Char] (a, Int))
runMyHandle forall (e :: Effects). MyHandle e -> Eff (e :& es) a
f =
  (forall (e :: Effects).
 Exception [Char] e -> Eff (e :& es) (a, Int))
-> Eff es (Either [Char] (a, Int))
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects).
  Exception [Char] e -> Eff (e :& es) (a, Int))
 -> Eff es (Either [Char] (a, Int)))
-> (forall (e :: Effects).
    Exception [Char] e -> Eff (e :& es) (a, Int))
-> Eff es (Either [Char] (a, Int))
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
e -> do
    Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) a)
-> Eff (e :& es) (a, Int)
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es (a, s)
runState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) a)
 -> Eff (e :& es) (a, Int))
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& es)) a)
-> Eff (e :& es) (a, Int)
forall a b. (a -> b) -> a -> b
$ \State Int e
s -> do
      State Int e
-> Exception [Char] e
-> (forall (e :: Effects). MyHandle e -> Eff (e :& es) a)
-> Eff (e :& (e :& es)) a
forall (e1 :: Effects -> *) (s1 :: Effects) (e2 :: Effects -> *)
       (s2 :: Effects) (es :: Effects) r.
e1 s1
-> e2 s2
-> (forall (es' :: Effects).
    Compound e1 e2 es' -> Eff (es' :& es) r)
-> Eff (s1 :& (s2 :& es)) r
runCompound State Int e
s Exception [Char] e
e MyHandle es' -> Eff (es' :& es) a
forall (e :: Effects). MyHandle e -> Eff (e :& es) a
f

compoundExample :: Either String (a, Int)
compoundExample :: forall a. Either [Char] (a, Int)
compoundExample = (forall (es :: Effects). Eff es (Either [Char] (a, Int)))
-> Either [Char] (a, Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Either [Char] (a, Int)))
 -> Either [Char] (a, Int))
-> (forall (es :: Effects). Eff es (Either [Char] (a, Int)))
-> Either [Char] (a, Int)
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). MyHandle e -> Eff (e :& es) a)
-> Eff es (Either [Char] (a, Int))
forall (es :: Effects) a.
(forall (e :: Effects). MyHandle e -> Eff (e :& es) a)
-> Eff es (Either [Char] (a, Int))
runMyHandle ((forall (e :: Effects). MyHandle e -> Eff (e :& es) a)
 -> Eff es (Either [Char] (a, Int)))
-> (forall (e :: Effects). MyHandle e -> Eff (e :& es) a)
-> Eff es (Either [Char] (a, Int))
forall a b. (a -> b) -> a -> b
$ \MyHandle e
h -> do
  MyHandle e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
MyHandle e -> Eff es ()
myInc MyHandle e
h
  MyHandle e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
MyHandle e -> Eff es ()
myInc MyHandle e
h
  MyHandle e -> Eff (e :& es) a
forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
MyHandle e -> Eff es r
myBail MyHandle e
h

countExample :: IO ()
countExample :: IO ()
countExample = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState @Int Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& e) ())
 -> Eff e ())
-> (forall {e :: Effects}. State Int e -> Eff (e :& e) ())
-> Eff e ()
forall a b. (a -> b) -> a -> b
$ \State Int e
sn -> do
    (forall (e :: Effects). Jump e -> Eff (e :& (e :& e)) ())
-> Eff (e :& e) ()
forall (es :: Effects).
(forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
withJump ((forall (e :: Effects). Jump e -> Eff (e :& (e :& e)) ())
 -> Eff (e :& e) ())
-> (forall (e :: Effects). Jump e -> Eff (e :& (e :& e)) ())
-> Eff (e :& e) ()
forall a b. (a -> b) -> a -> b
$ \Jump e
break -> Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ()
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ())
-> Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ()
forall a b. (a -> b) -> a -> b
$ do
      Int
n <- State Int e -> Eff (e :& (e :& e)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
sn
      Bool -> Eff (e :& (e :& e)) () -> Eff (e :& (e :& e)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
10) (Jump e -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Jump e -> Eff es a
jumpTo Jump e
break)
      IOE e -> IO () -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io (Int -> IO ()
forall a. Show a => a -> IO ()
print Int
n)
      State Int e -> (Int -> Int) -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
sn (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

writerExample1 :: Bool
writerExample1 :: Bool
writerExample1 = Any -> Bool
getAny (Any -> Bool) -> Any -> Bool
forall a b. (a -> b) -> a -> b
$ (forall (es :: Effects). Eff es Any) -> Any
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Any) -> Any)
-> (forall (es :: Effects). Eff es Any) -> Any
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). Writer Any e -> Eff (e :& es) ())
-> Eff es Any
forall w (es :: Effects) r.
Monoid w =>
(forall (e :: Effects). Writer w e -> Eff (e :& es) r) -> Eff es w
execWriter ((forall (e :: Effects). Writer Any e -> Eff (e :& es) ())
 -> Eff es Any)
-> (forall (e :: Effects). Writer Any e -> Eff (e :& es) ())
-> Eff es Any
forall a b. (a -> b) -> a -> b
$ \Writer Any e
w -> do
  [Any] -> (Any -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [] ((Any -> Eff (e :& es) ()) -> Eff (e :& es) ())
-> (Any -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \Any
_ -> Writer Any e -> Any -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) w.
(e :> es) =>
Writer w e -> w -> Eff es ()
tell Writer Any e
w (Bool -> Any
Any Bool
True)

writerExample2 :: Bool
writerExample2 :: Bool
writerExample2 = Any -> Bool
getAny (Any -> Bool) -> Any -> Bool
forall a b. (a -> b) -> a -> b
$ (forall (es :: Effects). Eff es Any) -> Any
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Any) -> Any)
-> (forall (es :: Effects). Eff es Any) -> Any
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). Writer Any e -> Eff (e :& es) ())
-> Eff es Any
forall w (es :: Effects) r.
Monoid w =>
(forall (e :: Effects). Writer w e -> Eff (e :& es) r) -> Eff es w
execWriter ((forall (e :: Effects). Writer Any e -> Eff (e :& es) ())
 -> Eff es Any)
-> (forall (e :: Effects). Writer Any e -> Eff (e :& es) ())
-> Eff es Any
forall a b. (a -> b) -> a -> b
$ \Writer Any e
w -> do
  [Integer] -> (Integer -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Integer
1 .. Integer
10] ((Integer -> Eff (e :& es) ()) -> Eff (e :& es) ())
-> (Integer -> Eff (e :& es) ()) -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \Integer
_ -> Writer Any e -> Any -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) w.
(e :> es) =>
Writer w e -> w -> Eff es ()
tell Writer Any e
w (Bool -> Any
Any Bool
True)

while :: Eff es Bool -> Eff es a -> Eff es ()
while :: forall (es :: Effects) a. Eff es Bool -> Eff es a -> Eff es ()
while Eff es Bool
condM Eff es a
body =
  (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall (es :: Effects).
(forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
withJump ((forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ())
-> (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall a b. (a -> b) -> a -> b
$ \Jump e
break_ -> do
    Eff (e :& es) a -> Eff (e :& es) ()
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& es) a -> Eff (e :& es) ())
-> Eff (e :& es) a -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ do
      Bool
cond <- Eff es Bool -> Eff (e :& es) Bool
forall (b :: Effects) r (c1 :: Effects). Eff b r -> Eff (c1 :& b) r
insertFirst Eff es Bool
condM
      Bool -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
cond (Jump e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Jump e -> Eff es a
jumpTo Jump e
break_)
      Eff es a -> Eff (e :& es) a
forall (b :: Effects) r (c1 :: Effects). Eff b r -> Eff (c1 :& b) r
insertFirst Eff es a
body

stateSourceExample :: Int
stateSourceExample :: Int
stateSourceExample = (forall (es :: Effects). Eff es Int) -> Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Int) -> Int)
-> (forall (es :: Effects). Eff es Int) -> Int
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). StateSource e -> Eff (e :& es) Int)
-> Eff es Int
forall (es :: Effects) a.
(forall (e :: Effects). StateSource e -> Eff (e :& es) a)
-> Eff es a
withStateSource ((forall (e :: Effects). StateSource e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall (e :: Effects). StateSource e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \StateSource e
source -> do
  State Int e
n <- StateSource e -> Int -> Eff (e :& es) (State Int e)
forall (e :: Effects) s (es :: Effects).
StateSource e -> s -> Eff es (State s e)
newState StateSource e
source Int
5
  State Int e
total <- StateSource e -> Int -> Eff (e :& es) (State Int e)
forall (e :: Effects) s (es :: Effects).
StateSource e -> s -> Eff es (State s e)
newState StateSource e
source Int
0

  (forall (e :: Effects). Jump e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) ()
forall (es :: Effects).
(forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
withJump ((forall (e :: Effects). Jump e -> Eff (e :& (e :& es)) ())
 -> Eff (e :& es) ())
-> (forall (e :: Effects). Jump e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ \Jump e
done -> Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ()
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ())
-> Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$ do
    Int
n' <- State Int e -> Eff (e :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
n
    State Int e -> (Int -> Int) -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
total (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n')
    Bool -> Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n' Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ())
-> Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$ Jump e -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Jump e -> Eff es a
jumpTo Jump e
done
    State Int e -> (Int -> Int) -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
n (Int -> Int -> Int
forall a. Num a => a -> a -> a
subtract Int
1)

  State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
total

incrementReadLine ::
  (e1 :> es, e2 :> es, e3 :> es) =>
  State Int e1 ->
  Exception String e2 ->
  IOE e3 ->
  Eff es ()
incrementReadLine :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects)
       (e3 :: Effects).
(e1 :> es, e2 :> es, e3 :> es) =>
State Int e1 -> Exception [Char] e2 -> IOE e3 -> Eff es ()
incrementReadLine State Int e1
state Exception [Char] e2
exception IOE e3
io = do
  (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall (es :: Effects).
(forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
withJump ((forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ())
-> (forall (e :: Effects). Jump e -> Eff (e :& es) ()) -> Eff es ()
forall a b. (a -> b) -> a -> b
$ \Jump e
break -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$ do
    [Char]
line <- IOE e3 -> IO [Char] -> Eff (e :& es) [Char]
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e3
io IO [Char]
getLine
    Int
i <- case [Char] -> Maybe Int
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
line of
      Maybe Int
Nothing ->
        Exception [Char] e2 -> [Char] -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception [Char] e2
exception ([Char]
"Couldn't read: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
line)
      Just Int
i ->
        Int -> Eff (e :& es) Int
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
i

    Bool -> Eff (e :& es) () -> Eff (e :& es) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (Eff (e :& es) () -> Eff (e :& es) ())
-> Eff (e :& es) () -> Eff (e :& es) ()
forall a b. (a -> b) -> a -> b
$
      Jump e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Jump e -> Eff es a
jumpTo Jump e
break

    State Int e1 -> (Int -> Int) -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e1
state (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)

runIncrementReadLine :: IO (Either String Int)
runIncrementReadLine :: IO (Either [Char] Int)
runIncrementReadLine = (forall (e :: Effects). IOE e -> Eff e (Either [Char] Int))
-> IO (Either [Char] Int)
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e (Either [Char] Int))
 -> IO (Either [Char] Int))
-> (forall (e :: Effects). IOE e -> Eff e (Either [Char] Int))
-> IO (Either [Char] Int)
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  (forall (e :: Effects). Exception [Char] e -> Eff (e :& e) Int)
-> Eff e (Either [Char] Int)
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception [Char] e -> Eff (e :& e) Int)
 -> Eff e (Either [Char] Int))
-> (forall (e :: Effects). Exception [Char] e -> Eff (e :& e) Int)
-> Eff e (Either [Char] Int)
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
exception -> do
    ((), Int
r) <- Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& e)) ())
-> Eff (e :& e) ((), Int)
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es (a, s)
runState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& (e :& e)) ())
 -> Eff (e :& e) ((), Int))
-> (forall {e :: Effects}. State Int e -> Eff (e :& (e :& e)) ())
-> Eff (e :& e) ((), Int)
forall a b. (a -> b) -> a -> b
$ \State Int e
state -> do
      State Int e
-> Exception [Char] e -> IOE e -> Eff (e :& (e :& e)) ()
forall (e1 :: Effects) (es :: Effects) (e2 :: Effects)
       (e3 :: Effects).
(e1 :> es, e2 :> es, e3 :> es) =>
State Int e1 -> Exception [Char] e2 -> IOE e3 -> Eff es ()
incrementReadLine State Int e
state Exception [Char] e
exception IOE e
io
    Int -> Eff (e :& e) Int
forall a. a -> Eff (e :& e) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
r

-- Counter 1

newtype Counter1 e = MkCounter1 (State Int e)

incCounter1 :: (e :> es) => Counter1 e -> Eff es ()
incCounter1 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter1 e -> Eff es ()
incCounter1 (MkCounter1 State Int e
st) = State Int e -> (Int -> Int) -> Eff es ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State Int e
st (Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

runCounter1 ::
  (forall e. Counter1 e -> Eff (e :& es) r) ->
  Eff es Int
runCounter1 :: forall (es :: Effects) r.
(forall (e :: Effects). Counter1 e -> Eff (e :& es) r)
-> Eff es Int
runCounter1 forall (e :: Effects). Counter1 e -> Eff (e :& es) r
k =
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
    r
_ <- Counter1 e -> Eff (e :& es) r
forall (e :: Effects). Counter1 e -> Eff (e :& es) r
k (State Int e -> Counter1 e
forall (e :: Effects). State Int e -> Counter1 e
MkCounter1 State Int e
st)
    State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

exampleCounter1 :: Int
exampleCounter1 :: Int
exampleCounter1 = (forall (es :: Effects). Eff es Int) -> Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Int) -> Int)
-> (forall (es :: Effects). Eff es Int) -> Int
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). Counter1 e -> Eff (e :& es) ())
-> Eff es Int
forall (es :: Effects) r.
(forall (e :: Effects). Counter1 e -> Eff (e :& es) r)
-> Eff es Int
runCounter1 ((forall (e :: Effects). Counter1 e -> Eff (e :& es) ())
 -> Eff es Int)
-> (forall (e :: Effects). Counter1 e -> Eff (e :& es) ())
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \Counter1 e
c -> do
  Counter1 e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter1 e -> Eff es ()
incCounter1 Counter1 e
c
  Counter1 e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter1 e -> Eff es ()
incCounter1 Counter1 e
c
  Counter1 e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter1 e -> Eff es ()
incCounter1 Counter1 e
c

-- > exampleCounter1
-- 3

-- Counter 2

data Counter2 e1 e2 = MkCounter2 (State Int e1) (Exception () e2)

incCounter2 :: (e1 :> es, e2 :> es) => Counter2 e1 e2 -> Eff es ()
incCounter2 :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects).
(e1 :> es, e2 :> es) =>
Counter2 e1 e2 -> Eff es ()
incCounter2 (MkCounter2 State Int e1
st Exception () e2
ex) = do
  Int
count <- State Int e1 -> Eff es Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e1
st
  Bool -> Eff es () -> Eff es ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
count Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
10) (Eff es () -> Eff es ()) -> Eff es () -> Eff es ()
forall a b. (a -> b) -> a -> b
$
    Exception () e2 -> () -> Eff es ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception () e2
ex ()
  State Int e1 -> Int -> Eff es ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e1
st (Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

runCounter2 ::
  (forall e1 e2. Counter2 e1 e2 -> Eff (e2 :& e1 :& es) r) ->
  Eff es Int
runCounter2 :: forall (es :: Effects) r.
(forall (e1 :: Effects) (e2 :: Effects).
 Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) r)
-> Eff es Int
runCounter2 forall (e1 :: Effects) (e2 :: Effects).
Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) r
k =
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
    Either () r
_ <- (forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
 -> Eff (e :& es) (Either () r))
-> (forall (e :: Effects).
    Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex -> do
      Counter2 e e -> Eff (e :& (e :& es)) r
forall (e1 :: Effects) (e2 :: Effects).
Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) r
k (State Int e -> Exception () e -> Counter2 e e
forall (e1 :: Effects) (e2 :: Effects).
State Int e1 -> Exception () e2 -> Counter2 e1 e2
MkCounter2 State Int e
st Exception () e
ex)
    State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

exampleCounter2 :: Int
exampleCounter2 :: Int
exampleCounter2 = (forall (es :: Effects). Eff es Int) -> Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Int) -> Int)
-> (forall (es :: Effects). Eff es Int) -> Int
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects) (e2 :: Effects).
 Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) Any)
-> Eff es Int
forall (es :: Effects) r.
(forall (e1 :: Effects) (e2 :: Effects).
 Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) r)
-> Eff es Int
runCounter2 ((forall (e1 :: Effects) (e2 :: Effects).
  Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) Any)
 -> Eff es Int)
-> (forall (e1 :: Effects) (e2 :: Effects).
    Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) Any)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \Counter2 e1 e2
c ->
  Eff (e2 :& (e1 :& es)) () -> Eff (e2 :& (e1 :& es)) Any
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e2 :& (e1 :& es)) () -> Eff (e2 :& (e1 :& es)) Any)
-> Eff (e2 :& (e1 :& es)) () -> Eff (e2 :& (e1 :& es)) Any
forall a b. (a -> b) -> a -> b
$
    Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) ()
forall (e1 :: Effects) (es :: Effects) (e2 :: Effects).
(e1 :> es, e2 :> es) =>
Counter2 e1 e2 -> Eff es ()
incCounter2 Counter2 e1 e2
c

-- > exampleCounter2
-- 10

-- Counter 3

data Counter3 e = MkCounter3 (State Int e) (Exception () e)

incCounter3 :: (e :> es) => Counter3 e -> Eff es ()
incCounter3 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter3 e -> Eff es ()
incCounter3 (MkCounter3 State Int e
st Exception () e
ex) = do
  Int
count <- State Int e -> Eff es Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st
  Bool -> Eff es () -> Eff es ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
count Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
10) (Eff es () -> Eff es ()) -> Eff es () -> Eff es ()
forall a b. (a -> b) -> a -> b
$
    Exception () e -> () -> Eff es ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception () e
ex ()
  State Int e -> Int -> Eff es ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
st (Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

runCounter3 ::
  (forall e. Counter3 e -> Eff (e :& es) r) ->
  Eff es Int
runCounter3 :: forall (es :: Effects) r.
(forall (e :: Effects). Counter3 e -> Eff (e :& es) r)
-> Eff es Int
runCounter3 forall (e :: Effects). Counter3 e -> Eff (e :& es) r
k =
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
    Either () r
_ <- (forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
 -> Eff (e :& es) (Either () r))
-> (forall (e :: Effects).
    Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex -> do
      (Counter3 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r)
-> Counter3 (e :& (e :& es)) -> Eff (e :& (e :& es)) r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn Counter3 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r
forall (e :: Effects). Counter3 e -> Eff (e :& es) r
k (State Int (e :& (e :& es))
-> Exception () (e :& (e :& es)) -> Counter3 (e :& (e :& es))
forall (e :: Effects). State Int e -> Exception () e -> Counter3 e
MkCounter3 (State Int e -> State Int (e :& (e :& es))
forall (e :: Effects) (es :: Effects).
(e :> es) =>
State Int e -> State Int es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle State Int e
st) (Exception () e -> Exception () (e :& (e :& es))
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Exception () e -> Exception () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Exception () e
ex))
    State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

exampleCounter3 :: Int
exampleCounter3 :: Int
exampleCounter3 = (forall (es :: Effects). Eff es Int) -> Int
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es Int) -> Int)
-> (forall (es :: Effects). Eff es Int) -> Int
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). Counter3 e -> Eff (e :& es) Any)
-> Eff es Int
forall (es :: Effects) r.
(forall (e :: Effects). Counter3 e -> Eff (e :& es) r)
-> Eff es Int
runCounter3 ((forall (e :: Effects). Counter3 e -> Eff (e :& es) Any)
 -> Eff es Int)
-> (forall (e :: Effects). Counter3 e -> Eff (e :& es) Any)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \Counter3 e
c ->
  Eff (e :& es) () -> Eff (e :& es) Any
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Eff (e :& es) () -> Eff (e :& es) Any)
-> Eff (e :& es) () -> Eff (e :& es) Any
forall a b. (a -> b) -> a -> b
$
    Counter3 e -> Eff (e :& es) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter3 e -> Eff es ()
incCounter3 Counter3 e
c

-- > exampleCounter3
-- 10

-- Counter 3B

newtype Counter3B e = MkCounter3B (IOE e)

incCounter3B :: (e :> es) => Counter3B e -> Eff es ()
incCounter3B :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter3B e -> Eff es ()
incCounter3B (MkCounter3B IOE e
io) =
  IOE e -> IO () -> Eff es ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"You tried to increment the counter")

runCounter3B ::
  (e1 :> es) =>
  IOE e1 ->
  (forall e. Counter3B e -> Eff (e :& es) r) ->
  Eff es r
runCounter3B :: forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
IOE e1
-> (forall (e :: Effects). Counter3B e -> Eff (e :& es) r)
-> Eff es r
runCounter3B IOE e1
io forall (e :: Effects). Counter3B e -> Eff (e :& es) r
k = (Counter3B es -> Eff (es :& es) r) -> Counter3B es -> Eff es r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn Counter3B es -> Eff (es :& es) r
forall (e :: Effects). Counter3B e -> Eff (e :& es) r
k (IOE es -> Counter3B es
forall (e :: Effects). IOE e -> Counter3B e
MkCounter3B (IOE e1 -> IOE es
forall (e :: Effects) (es :: Effects). (e :> es) => IOE e -> IOE es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle IOE e1
io))

exampleCounter3B :: IO ()
exampleCounter3B :: IO ()
exampleCounter3B = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> IOE e
-> (forall {e :: Effects}. Counter3B e -> Eff (e :& e) ())
-> Eff e ()
forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
IOE e1
-> (forall (e :: Effects). Counter3B e -> Eff (e :& es) r)
-> Eff es r
runCounter3B IOE e
io ((forall {e :: Effects}. Counter3B e -> Eff (e :& e) ())
 -> Eff e ())
-> (forall {e :: Effects}. Counter3B e -> Eff (e :& e) ())
-> Eff e ()
forall a b. (a -> b) -> a -> b
$ \Counter3B e
c -> do
  Counter3B e -> Eff (e :& e) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter3B e -> Eff es ()
incCounter3B Counter3B e
c
  Counter3B e -> Eff (e :& e) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter3B e -> Eff es ()
incCounter3B Counter3B e
c
  Counter3B e -> Eff (e :& e) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter3B e -> Eff es ()
incCounter3B Counter3B e
c

-- ghci> exampleCounter3B
-- You tried to increment the counter
-- You tried to increment the counter
-- You tried to increment the counter

-- Counter 4

data Counter4 e
  = MkCounter4 (State Int e) (Exception () e) (Stream String e)

incCounter4 :: (e :> es) => Counter4 e -> Eff es ()
incCounter4 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter4 e -> Eff es ()
incCounter4 (MkCounter4 State Int e
st Exception () e
ex Stream [Char] e
y) = do
  Int
count <- State Int e -> Eff es Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

  Bool -> Eff es () -> Eff es ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int -> Bool
forall a. Integral a => a -> Bool
even Int
count) (Eff es () -> Eff es ()) -> Eff es () -> Eff es ()
forall a b. (a -> b) -> a -> b
$
    Stream [Char] e -> [Char] -> Eff es ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e
y [Char]
"Count was even"

  Bool -> Eff es () -> Eff es ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
count Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
10) (Eff es () -> Eff es ()) -> Eff es () -> Eff es ()
forall a b. (a -> b) -> a -> b
$
    Exception () e -> () -> Eff es ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception () e
ex ()

  State Int e -> Int -> Eff es ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
st (Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)

getCounter4 :: (e :> es) => Counter4 e -> String -> Eff es Int
getCounter4 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter4 e -> [Char] -> Eff es Int
getCounter4 (MkCounter4 State Int e
st Exception () e
_ Stream [Char] e
y) [Char]
msg = do
  Stream [Char] e -> [Char] -> Eff es ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e
y [Char]
msg
  State Int e -> Eff es Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

runCounter4 ::
  (e1 :> es) =>
  Stream String e1 ->
  (forall e. Counter4 e -> Eff (e :& es) r) ->
  Eff es Int
runCounter4 :: forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter4 e -> Eff (e :& es) r)
-> Eff es Int
runCounter4 Stream [Char] e1
y forall (e :: Effects). Counter4 e -> Eff (e :& es) r
k =
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
    Either () r
_ <- (forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
 -> Eff (e :& es) (Either () r))
-> (forall (e :: Effects).
    Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex -> do
      (Counter4 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r)
-> Counter4 (e :& (e :& es)) -> Eff (e :& (e :& es)) r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn Counter4 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r
forall (e :: Effects). Counter4 e -> Eff (e :& es) r
k (State Int (e :& (e :& es))
-> Exception () (e :& (e :& es))
-> Stream [Char] (e :& (e :& es))
-> Counter4 (e :& (e :& es))
forall (e :: Effects).
State Int e -> Exception () e -> Stream [Char] e -> Counter4 e
MkCounter4 (State Int e -> State Int (e :& (e :& es))
forall (e :: Effects) (es :: Effects).
(e :> es) =>
State Int e -> State Int es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle State Int e
st) (Exception () e -> Exception () (e :& (e :& es))
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Exception () e -> Exception () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Exception () e
ex) (Stream [Char] e1 -> Stream [Char] (e :& (e :& es))
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Coroutine [Char] () e -> Coroutine [Char] () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Stream [Char] e1
y))
    State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

exampleCounter4 :: ([String], Int)
exampleCounter4 :: ([[Char]], Int)
exampleCounter4 = (forall (es :: Effects). Eff es ([[Char]], Int)) -> ([[Char]], Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([[Char]], Int))
 -> ([[Char]], Int))
-> (forall (es :: Effects). Eff es ([[Char]], Int))
-> ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
 -> Eff es ([[Char]], Int))
-> (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ \Stream [Char] e1
y -> do
  Stream [Char] e1
-> (forall {e :: Effects}. Counter4 e -> Eff (e :& (e1 :& es)) ())
-> Eff (e1 :& es) Int
forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter4 e -> Eff (e :& es) r)
-> Eff es Int
runCounter4 Stream [Char] e1
y ((forall {e :: Effects}. Counter4 e -> Eff (e :& (e1 :& es)) ())
 -> Eff (e1 :& es) Int)
-> (forall {e :: Effects}. Counter4 e -> Eff (e :& (e1 :& es)) ())
-> Eff (e1 :& es) Int
forall a b. (a -> b) -> a -> b
$ \Counter4 e
c -> do
    Counter4 e -> Eff (e :& (e1 :& es)) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter4 e -> Eff es ()
incCounter4 Counter4 e
c
    Counter4 e -> Eff (e :& (e1 :& es)) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter4 e -> Eff es ()
incCounter4 Counter4 e
c
    Int
n <- Counter4 e -> [Char] -> Eff (e :& (e1 :& es)) Int
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter4 e -> [Char] -> Eff es Int
getCounter4 Counter4 e
c [Char]
"I'm getting the counter"
    Bool -> Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2) (Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ())
-> Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ()
forall a b. (a -> b) -> a -> b
$
      Stream [Char] e1 -> [Char] -> Eff (e :& (e1 :& es)) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
"n was 2, as expected"

-- > exampleCounter4
-- (["Count was even","I'm getting the counter","n was 2, as expected"],2)

-- Counter 5

data Counter5 e = MkCounter5
  { forall (e :: Effects).
Counter5 e -> forall (e' :: Effects). Eff (e' :& e) ()
incCounter5Impl :: forall e'. Eff (e' :& e) (),
    forall (e :: Effects).
Counter5 e -> forall (e' :: Effects). [Char] -> Eff (e' :& e) Int
getCounter5Impl :: forall e'. String -> Eff (e' :& e) Int
  }

instance Handle Counter5 where
  mapHandle :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> Counter5 es
mapHandle Counter5 e
c =
    MkCounter5
      { incCounter5Impl :: forall (e' :: Effects). Eff (e' :& es) ()
incCounter5Impl = Eff (e' :& e) () -> Eff (e' :& es) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (Counter5 e -> forall (e' :: Effects). Eff (e' :& e) ()
forall (e :: Effects).
Counter5 e -> forall (e' :: Effects). Eff (e' :& e) ()
incCounter5Impl Counter5 e
c),
        getCounter5Impl :: forall (e' :: Effects). [Char] -> Eff (e' :& es) Int
getCounter5Impl = \[Char]
msg -> Eff (e' :& e) Int -> Eff (e' :& es) Int
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (Counter5 e -> forall (e' :: Effects). [Char] -> Eff (e' :& e) Int
forall (e :: Effects).
Counter5 e -> forall (e' :: Effects). [Char] -> Eff (e' :& e) Int
getCounter5Impl Counter5 e
c [Char]
msg)
      }

incCounter5 :: (e :> es) => Counter5 e -> Eff es ()
incCounter5 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> Eff es ()
incCounter5 Counter5 e
e = Eff (es :& es) () -> Eff es ()
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (Counter5 es -> forall (e' :: Effects). Eff (e' :& es) ()
forall (e :: Effects).
Counter5 e -> forall (e' :: Effects). Eff (e' :& e) ()
incCounter5Impl (Counter5 e -> Counter5 es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> Counter5 es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Counter5 e
e))

getCounter5 :: (e :> es) => Counter5 e -> String -> Eff es Int
getCounter5 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> [Char] -> Eff es Int
getCounter5 Counter5 e
e [Char]
msg = Eff (es :& es) Int -> Eff es Int
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (Counter5 es -> forall (e' :: Effects). [Char] -> Eff (e' :& es) Int
forall (e :: Effects).
Counter5 e -> forall (e' :: Effects). [Char] -> Eff (e' :& e) Int
getCounter5Impl (Counter5 e -> Counter5 es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> Counter5 es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Counter5 e
e) [Char]
msg)

runCounter5 ::
  (e1 :> es) =>
  Stream String e1 ->
  (forall e. Counter5 e -> Eff (e :& es) r) ->
  Eff es Int
runCounter5 :: forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter5 e -> Eff (e :& es) r)
-> Eff es Int
runCounter5 Stream [Char] e1
y forall (e :: Effects). Counter5 e -> Eff (e :& es) r
k =
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
    Either () r
_ <- (forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
 -> Eff (e :& es) (Either () r))
-> (forall (e :: Effects).
    Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex -> do
      (Counter5 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r)
-> Counter5 (e :& (e :& es)) -> Eff (e :& (e :& es)) r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn
        Counter5 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r
forall (e :: Effects). Counter5 e -> Eff (e :& es) r
k
        ( MkCounter5
            { incCounter5Impl :: forall (e' :: Effects). Eff (e' :& (e :& (e :& es))) ()
incCounter5Impl = do
                Int
count <- State Int e -> Eff (e' :& (e :& (e :& es))) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

                Bool
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int -> Bool
forall a. Integral a => a -> Bool
even Int
count) (Eff (e' :& (e :& (e :& es))) ()
 -> Eff (e' :& (e :& (e :& es))) ())
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall a b. (a -> b) -> a -> b
$
                  Stream [Char] e1 -> [Char] -> Eff (e' :& (e :& (e :& es))) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
"Count was even"

                Bool
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
count Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
10) (Eff (e' :& (e :& (e :& es))) ()
 -> Eff (e' :& (e :& (e :& es))) ())
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall a b. (a -> b) -> a -> b
$
                  Exception () e -> () -> Eff (e' :& (e :& (e :& es))) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception () e
ex ()

                State Int e -> Int -> Eff (e' :& (e :& (e :& es))) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
st (Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1),
              getCounter5Impl :: forall (e' :: Effects). [Char] -> Eff (e' :& (e :& (e :& es))) Int
getCounter5Impl = \[Char]
msg -> do
                Stream [Char] e1 -> [Char] -> Eff (e' :& (e :& (e :& es))) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
msg
                State Int e -> Eff (e' :& (e :& (e :& es))) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st
            }
        )
    State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

exampleCounter5 :: ([String], Int)
exampleCounter5 :: ([[Char]], Int)
exampleCounter5 = (forall (es :: Effects). Eff es ([[Char]], Int)) -> ([[Char]], Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([[Char]], Int))
 -> ([[Char]], Int))
-> (forall (es :: Effects). Eff es ([[Char]], Int))
-> ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
 -> Eff es ([[Char]], Int))
-> (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ \Stream [Char] e1
y -> do
  Stream [Char] e1
-> (forall {e :: Effects}. Counter5 e -> Eff (e :& (e1 :& es)) ())
-> Eff (e1 :& es) Int
forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter5 e -> Eff (e :& es) r)
-> Eff es Int
runCounter5 Stream [Char] e1
y ((forall {e :: Effects}. Counter5 e -> Eff (e :& (e1 :& es)) ())
 -> Eff (e1 :& es) Int)
-> (forall {e :: Effects}. Counter5 e -> Eff (e :& (e1 :& es)) ())
-> Eff (e1 :& es) Int
forall a b. (a -> b) -> a -> b
$ \Counter5 e
c -> do
    Counter5 e -> Eff (e :& (e1 :& es)) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> Eff es ()
incCounter5 Counter5 e
c
    Counter5 e -> Eff (e :& (e1 :& es)) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> Eff es ()
incCounter5 Counter5 e
c
    Int
n <- Counter5 e -> [Char] -> Eff (e :& (e1 :& es)) Int
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter5 e -> [Char] -> Eff es Int
getCounter5 Counter5 e
c [Char]
"I'm getting the counter"
    Bool -> Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2) (Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ())
-> Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ()
forall a b. (a -> b) -> a -> b
$
      Stream [Char] e1 -> [Char] -> Eff (e :& (e1 :& es)) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
"n was 2, as expected"

-- > exampleCounter5
-- (["Count was even","I'm getting the counter","n was 2, as expected"],2)

-- Counter 6

data Counter6 e = MkCounter6
  { forall (e :: Effects).
Counter6 e -> forall (e' :: Effects). Eff (e' :& e) ()
incCounter6Impl :: forall e'. Eff (e' :& e) (),
    forall (e :: Effects). Counter6 e -> State Int e
counter6State :: State Int e,
    forall (e :: Effects). Counter6 e -> Stream [Char] e
counter6Stream :: Stream String e
  }

instance Handle Counter6 where
  mapHandle :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter6 e -> Counter6 es
mapHandle Counter6 e
c =
    MkCounter6
      { incCounter6Impl :: forall (e' :: Effects). Eff (e' :& es) ()
incCounter6Impl = Eff (e' :& e) () -> Eff (e' :& es) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (Counter6 e -> forall (e' :: Effects). Eff (e' :& e) ()
forall (e :: Effects).
Counter6 e -> forall (e' :: Effects). Eff (e' :& e) ()
incCounter6Impl Counter6 e
c),
        counter6State :: State Int es
counter6State = State Int e -> State Int es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
State Int e -> State Int es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle (Counter6 e -> State Int e
forall (e :: Effects). Counter6 e -> State Int e
counter6State Counter6 e
c),
        counter6Stream :: Stream [Char] es
counter6Stream = Coroutine [Char] () e -> Stream [Char] es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Coroutine [Char] () e -> Coroutine [Char] () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle (Counter6 e -> Coroutine [Char] () e
forall (e :: Effects). Counter6 e -> Stream [Char] e
counter6Stream Counter6 e
c)
      }

incCounter6 :: (e :> es) => Counter6 e -> Eff es ()
incCounter6 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter6 e -> Eff es ()
incCounter6 Counter6 e
e = Eff (es :& es) () -> Eff es ()
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (Counter6 es -> forall (e' :: Effects). Eff (e' :& es) ()
forall (e :: Effects).
Counter6 e -> forall (e' :: Effects). Eff (e' :& e) ()
incCounter6Impl (Counter6 e -> Counter6 es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter6 e -> Counter6 es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Counter6 e
e))

getCounter6 :: (e :> es) => Counter6 e -> String -> Eff es Int
getCounter6 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter6 e -> [Char] -> Eff es Int
getCounter6 (MkCounter6 forall (e' :: Effects). Eff (e' :& e) ()
_ State Int e
st Stream [Char] e
y) [Char]
msg = do
  Stream [Char] e -> [Char] -> Eff es ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e
y [Char]
msg
  State Int e -> Eff es Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

runCounter6 ::
  (e1 :> es) =>
  Stream String e1 ->
  (forall e. Counter6 e -> Eff (e :& es) r) ->
  Eff es Int
runCounter6 :: forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter6 e -> Eff (e :& es) r)
-> Eff es Int
runCounter6 Stream [Char] e1
y forall (e :: Effects). Counter6 e -> Eff (e :& es) r
k =
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
    Either () r
_ <- (forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception () e -> Eff (e :& (e :& es)) r)
 -> Eff (e :& es) (Either () r))
-> (forall (e :: Effects).
    Exception () e -> Eff (e :& (e :& es)) r)
-> Eff (e :& es) (Either () r)
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex -> do
      (Counter6 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r)
-> Counter6 (e :& (e :& es)) -> Eff (e :& (e :& es)) r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn
        Counter6 (e :& (e :& es)) -> Eff ((e :& (e :& es)) :& es) r
forall (e :: Effects). Counter6 e -> Eff (e :& es) r
k
        ( MkCounter6
            { incCounter6Impl :: forall (e' :: Effects). Eff (e' :& (e :& (e :& es))) ()
incCounter6Impl = do
                Int
count <- State Int e -> Eff (e' :& (e :& (e :& es))) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

                Bool
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int -> Bool
forall a. Integral a => a -> Bool
even Int
count) (Eff (e' :& (e :& (e :& es))) ()
 -> Eff (e' :& (e :& (e :& es))) ())
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall a b. (a -> b) -> a -> b
$
                  Stream [Char] e1 -> [Char] -> Eff (e' :& (e :& (e :& es))) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
"Count was even"

                Bool
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
count Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
10) (Eff (e' :& (e :& (e :& es))) ()
 -> Eff (e' :& (e :& (e :& es))) ())
-> Eff (e' :& (e :& (e :& es))) ()
-> Eff (e' :& (e :& (e :& es))) ()
forall a b. (a -> b) -> a -> b
$
                  Exception () e -> () -> Eff (e' :& (e :& (e :& es))) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception () e
ex ()

                State Int e -> Int -> Eff (e' :& (e :& (e :& es))) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
st (Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1),
              counter6State :: State Int (e :& (e :& es))
counter6State = State Int e -> State Int (e :& (e :& es))
forall (e :: Effects) (es :: Effects).
(e :> es) =>
State Int e -> State Int es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle State Int e
st,
              counter6Stream :: Stream [Char] (e :& (e :& es))
counter6Stream = Stream [Char] e1 -> Stream [Char] (e :& (e :& es))
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Coroutine [Char] () e -> Coroutine [Char] () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Stream [Char] e1
y
            }
        )
    State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

exampleCounter6 :: ([String], Int)
exampleCounter6 :: ([[Char]], Int)
exampleCounter6 = (forall (es :: Effects). Eff es ([[Char]], Int)) -> ([[Char]], Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([[Char]], Int))
 -> ([[Char]], Int))
-> (forall (es :: Effects). Eff es ([[Char]], Int))
-> ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
 -> Eff es ([[Char]], Int))
-> (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ \Stream [Char] e1
y -> do
  Stream [Char] e1
-> (forall {e :: Effects}. Counter6 e -> Eff (e :& (e1 :& es)) ())
-> Eff (e1 :& es) Int
forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter6 e -> Eff (e :& es) r)
-> Eff es Int
runCounter6 Stream [Char] e1
y ((forall {e :: Effects}. Counter6 e -> Eff (e :& (e1 :& es)) ())
 -> Eff (e1 :& es) Int)
-> (forall {e :: Effects}. Counter6 e -> Eff (e :& (e1 :& es)) ())
-> Eff (e1 :& es) Int
forall a b. (a -> b) -> a -> b
$ \Counter6 e
c -> do
    Counter6 e -> Eff (e :& (e1 :& es)) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter6 e -> Eff es ()
incCounter6 Counter6 e
c
    Counter6 e -> Eff (e :& (e1 :& es)) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter6 e -> Eff es ()
incCounter6 Counter6 e
c
    Int
n <- Counter6 e -> [Char] -> Eff (e :& (e1 :& es)) Int
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter6 e -> [Char] -> Eff es Int
getCounter6 Counter6 e
c [Char]
"I'm getting the counter"
    Bool -> Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2) (Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ())
-> Eff (e :& (e1 :& es)) () -> Eff (e :& (e1 :& es)) ()
forall a b. (a -> b) -> a -> b
$
      Stream [Char] e1 -> [Char] -> Eff (e :& (e1 :& es)) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
"n was 2, as expected"

-- > exampleCounter6
-- (["Count was even","I'm getting the counter","n was 2, as expected"],2)

-- Counter 7

data Counter7 e = MkCounter7
  { forall (e :: Effects).
Counter7 e
-> forall (e' :: Effects). Exception () e' -> Eff (e' :& e) ()
incCounter7Impl :: forall e'. Exception () e' -> Eff (e' :& e) (),
    forall (e :: Effects). Counter7 e -> State Int e
counter7State :: State Int e,
    forall (e :: Effects). Counter7 e -> Stream [Char] e
counter7Stream :: Stream String e
  }

instance Handle Counter7 where
  mapHandle :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter7 e -> Counter7 es
mapHandle Counter7 e
c =
    MkCounter7
      { incCounter7Impl :: forall (e' :: Effects). Exception () e' -> Eff (e' :& es) ()
incCounter7Impl = \Exception () e'
ex -> Eff (e' :& e) () -> Eff (e' :& es) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (Counter7 e
-> forall (e' :: Effects). Exception () e' -> Eff (e' :& e) ()
forall (e :: Effects).
Counter7 e
-> forall (e' :: Effects). Exception () e' -> Eff (e' :& e) ()
incCounter7Impl Counter7 e
c Exception () e'
ex),
        counter7State :: State Int es
counter7State = State Int e -> State Int es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
State Int e -> State Int es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle (Counter7 e -> State Int e
forall (e :: Effects). Counter7 e -> State Int e
counter7State Counter7 e
c),
        counter7Stream :: Stream [Char] es
counter7Stream = Coroutine [Char] () e -> Stream [Char] es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Coroutine [Char] () e -> Coroutine [Char] () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle (Counter7 e -> Coroutine [Char] () e
forall (e :: Effects). Counter7 e -> Stream [Char] e
counter7Stream Counter7 e
c)
      }

incCounter7 ::
  (e :> es, e1 :> es) => Counter7 e -> Exception () e1 -> Eff es ()
incCounter7 :: forall (e :: Effects) (es :: Effects) (e1 :: Effects).
(e :> es, e1 :> es) =>
Counter7 e -> Exception () e1 -> Eff es ()
incCounter7 Counter7 e
e Exception () e1
ex = Eff (es :& es) () -> Eff es ()
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (Counter7 es
-> forall (e' :: Effects). Exception () e' -> Eff (e' :& es) ()
forall (e :: Effects).
Counter7 e
-> forall (e' :: Effects). Exception () e' -> Eff (e' :& e) ()
incCounter7Impl (Counter7 e -> Counter7 es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter7 e -> Counter7 es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Counter7 e
e) (Exception () e1 -> Exception () es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Exception () e -> Exception () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Exception () e1
ex))

getCounter7 :: (e :> es) => Counter7 e -> String -> Eff es Int
getCounter7 :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter7 e -> [Char] -> Eff es Int
getCounter7 (MkCounter7 forall (e' :: Effects). Exception () e' -> Eff (e' :& e) ()
_ State Int e
st Stream [Char] e
y) [Char]
msg = do
  Stream [Char] e -> [Char] -> Eff es ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e
y [Char]
msg
  State Int e -> Eff es Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

runCounter7 ::
  (e1 :> es) =>
  Stream String e1 ->
  (forall e. Counter7 e -> Eff (e :& es) r) ->
  Eff es Int
runCounter7 :: forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter7 e -> Eff (e :& es) r)
-> Eff es Int
runCounter7 Stream [Char] e1
y forall (e :: Effects). Counter7 e -> Eff (e :& es) r
k =
  Int
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState Int
0 ((forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
 -> Eff es Int)
-> (forall {e :: Effects}. State Int e -> Eff (e :& es) Int)
-> Eff es Int
forall a b. (a -> b) -> a -> b
$ \State Int e
st -> do
    r
_ <-
      (Counter7 (e :& es) -> Eff ((e :& es) :& es) r)
-> Counter7 (e :& es) -> Eff (e :& es) r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn
        Counter7 (e :& es) -> Eff ((e :& es) :& es) r
forall (e :: Effects). Counter7 e -> Eff (e :& es) r
k
        ( MkCounter7
            { incCounter7Impl :: forall (e' :: Effects). Exception () e' -> Eff (e' :& (e :& es)) ()
incCounter7Impl = \Exception () e'
ex -> do
                Int
count <- State Int e -> Eff (e' :& (e :& es)) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

                Bool -> Eff (e' :& (e :& es)) () -> Eff (e' :& (e :& es)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int -> Bool
forall a. Integral a => a -> Bool
even Int
count) (Eff (e' :& (e :& es)) () -> Eff (e' :& (e :& es)) ())
-> Eff (e' :& (e :& es)) () -> Eff (e' :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$
                  Stream [Char] e1 -> [Char] -> Eff (e' :& (e :& es)) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
"Count was even"

                Bool -> Eff (e' :& (e :& es)) () -> Eff (e' :& (e :& es)) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
count Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
10) (Eff (e' :& (e :& es)) () -> Eff (e' :& (e :& es)) ())
-> Eff (e' :& (e :& es)) () -> Eff (e' :& (e :& es)) ()
forall a b. (a -> b) -> a -> b
$
                  Exception () e' -> () -> Eff (e' :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception () e'
ex ()

                State Int e -> Int -> Eff (e' :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> s -> Eff es ()
put State Int e
st (Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1),
              counter7State :: State Int (e :& es)
counter7State = State Int e -> State Int (e :& es)
forall (e :: Effects) (es :: Effects).
(e :> es) =>
State Int e -> State Int es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle State Int e
st,
              counter7Stream :: Stream [Char] (e :& es)
counter7Stream = Stream [Char] e1 -> Stream [Char] (e :& es)
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Coroutine [Char] () e -> Coroutine [Char] () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Stream [Char] e1
y
            }
        )
    State Int e -> Eff (e :& es) Int
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State Int e
st

exampleCounter7A :: ([String], Int)
exampleCounter7A :: ([[Char]], Int)
exampleCounter7A = (forall (es :: Effects). Eff es ([[Char]], Int)) -> ([[Char]], Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([[Char]], Int))
 -> ([[Char]], Int))
-> (forall (es :: Effects). Eff es ([[Char]], Int))
-> ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
 -> Eff es ([[Char]], Int))
-> (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ \Stream [Char] e1
y -> do
  (() -> Eff (e1 :& es) Int)
-> (forall {e :: Effects}.
    Exception () e -> Eff (e :& (e1 :& es)) Int)
-> Eff (e1 :& es) Int
forall exn (es :: Effects) a.
(exn -> Eff es a)
-> (forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es a
handle (\() -> Int -> Eff (e1 :& es) Int
forall a. a -> Eff (e1 :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (-Int
42)) ((forall {e :: Effects}.
  Exception () e -> Eff (e :& (e1 :& es)) Int)
 -> Eff (e1 :& es) Int)
-> (forall {e :: Effects}.
    Exception () e -> Eff (e :& (e1 :& es)) Int)
-> Eff (e1 :& es) Int
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex ->
    Stream [Char] e1
-> (forall {e :: Effects}.
    Counter7 e -> Eff (e :& (e :& (e1 :& es))) ())
-> Eff (e :& (e1 :& es)) Int
forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter7 e -> Eff (e :& es) r)
-> Eff es Int
runCounter7 Stream [Char] e1
y ((forall {e :: Effects}.
  Counter7 e -> Eff (e :& (e :& (e1 :& es))) ())
 -> Eff (e :& (e1 :& es)) Int)
-> (forall {e :: Effects}.
    Counter7 e -> Eff (e :& (e :& (e1 :& es))) ())
-> Eff (e :& (e1 :& es)) Int
forall a b. (a -> b) -> a -> b
$ \Counter7 e
c -> do
      Counter7 e -> Exception () e -> Eff (e :& (e :& (e1 :& es))) ()
forall (e :: Effects) (es :: Effects) (e1 :: Effects).
(e :> es, e1 :> es) =>
Counter7 e -> Exception () e1 -> Eff es ()
incCounter7 Counter7 e
c Exception () e
ex
      Counter7 e -> Exception () e -> Eff (e :& (e :& (e1 :& es))) ()
forall (e :: Effects) (es :: Effects) (e1 :: Effects).
(e :> es, e1 :> es) =>
Counter7 e -> Exception () e1 -> Eff es ()
incCounter7 Counter7 e
c Exception () e
ex
      Int
n <- Counter7 e -> [Char] -> Eff (e :& (e :& (e1 :& es))) Int
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Counter7 e -> [Char] -> Eff es Int
getCounter7 Counter7 e
c [Char]
"I'm getting the counter"
      Bool
-> Eff (e :& (e :& (e1 :& es))) ()
-> Eff (e :& (e :& (e1 :& es))) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
2) (Eff (e :& (e :& (e1 :& es))) ()
 -> Eff (e :& (e :& (e1 :& es))) ())
-> Eff (e :& (e :& (e1 :& es))) ()
-> Eff (e :& (e :& (e1 :& es))) ()
forall a b. (a -> b) -> a -> b
$
        Stream [Char] e1 -> [Char] -> Eff (e :& (e :& (e1 :& es))) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream [Char] e1
y [Char]
"n was 2, as expected"

-- > exampleCounter7A
-- (["Count was even","I'm getting the counter","n was 2, as expected"],2)

exampleCounter7B :: ([String], Int)
exampleCounter7B :: ([[Char]], Int)
exampleCounter7B = (forall (es :: Effects). Eff es ([[Char]], Int)) -> ([[Char]], Int)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es ([[Char]], Int))
 -> ([[Char]], Int))
-> (forall (es :: Effects). Eff es ([[Char]], Int))
-> ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a (es :: Effects) r.
(forall (e1 :: Effects). Stream a e1 -> Eff (e1 :& es) r)
-> Eff es ([a], r)
yieldToList ((forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
 -> Eff es ([[Char]], Int))
-> (forall (e1 :: Effects). Stream [Char] e1 -> Eff (e1 :& es) Int)
-> Eff es ([[Char]], Int)
forall a b. (a -> b) -> a -> b
$ \Stream [Char] e1
y -> do
  (() -> Eff (e1 :& es) Int)
-> (forall {e :: Effects}.
    Exception () e -> Eff (e :& (e1 :& es)) Int)
-> Eff (e1 :& es) Int
forall exn (es :: Effects) a.
(exn -> Eff es a)
-> (forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es a
handle (\() -> Int -> Eff (e1 :& es) Int
forall a. a -> Eff (e1 :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (-Int
42)) ((forall {e :: Effects}.
  Exception () e -> Eff (e :& (e1 :& es)) Int)
 -> Eff (e1 :& es) Int)
-> (forall {e :: Effects}.
    Exception () e -> Eff (e :& (e1 :& es)) Int)
-> Eff (e1 :& es) Int
forall a b. (a -> b) -> a -> b
$ \Exception () e
ex ->
    Stream [Char] e1
-> (forall {e :: Effects}.
    Counter7 e -> Eff (e :& (e :& (e1 :& es))) Any)
-> Eff (e :& (e1 :& es)) Int
forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Stream [Char] e1
-> (forall (e :: Effects). Counter7 e -> Eff (e :& es) r)
-> Eff es Int
runCounter7 Stream [Char] e1
y ((forall {e :: Effects}.
  Counter7 e -> Eff (e :& (e :& (e1 :& es))) Any)
 -> Eff (e :& (e1 :& es)) Int)
-> (forall {e :: Effects}.
    Counter7 e -> Eff (e :& (e :& (e1 :& es))) Any)
-> Eff (e :& (e1 :& es)) Int
forall a b. (a -> b) -> a -> b
$ \Counter7 e
c -> do
      Eff (e :& (e :& (e1 :& es))) () -> Eff (e :& (e :& (e1 :& es))) Any
forall (f :: * -> *) a b. Applicative f => f a -> f b
forever (Counter7 e -> Exception () e -> Eff (e :& (e :& (e1 :& es))) ()
forall (e :: Effects) (es :: Effects) (e1 :: Effects).
(e :> es, e1 :> es) =>
Counter7 e -> Exception () e1 -> Eff es ()
incCounter7 Counter7 e
c Exception () e
ex)

-- > exampleCounter7B
-- (["Count was even","Count was even","Count was even","Count was even","Count was even","Count was even"],-42)

-- FileSystem

data FileSystem es = MkFileSystem
  { forall (es :: Effects).
FileSystem es
-> forall (e :: Effects). [Char] -> Eff (e :& es) [Char]
readFileImpl :: forall e. FilePath -> Eff (e :& es) String,
    forall (es :: Effects).
FileSystem es
-> forall (e :: Effects). [Char] -> [Char] -> Eff (e :& es) ()
writeFileImpl :: forall e. FilePath -> String -> Eff (e :& es) ()
  }

instance Handle FileSystem where
  mapHandle :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> FileSystem es
mapHandle FileSystem e
fs =
    MkFileSystem
      { readFileImpl :: forall (e :: Effects). [Char] -> Eff (e :& es) [Char]
readFileImpl = \[Char]
fp -> Eff (e :& e) [Char] -> Eff (e :& es) [Char]
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (FileSystem e
-> forall (e :: Effects). [Char] -> Eff (e :& e) [Char]
forall (es :: Effects).
FileSystem es
-> forall (e :: Effects). [Char] -> Eff (e :& es) [Char]
readFileImpl FileSystem e
fs [Char]
fp),
        writeFileImpl :: forall (e :: Effects). [Char] -> [Char] -> Eff (e :& es) ()
writeFileImpl = \[Char]
fp [Char]
s -> Eff (e :& e) () -> Eff (e :& es) ()
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (FileSystem e
-> forall (e :: Effects). [Char] -> [Char] -> Eff (e :& e) ()
forall (es :: Effects).
FileSystem es
-> forall (e :: Effects). [Char] -> [Char] -> Eff (e :& es) ()
writeFileImpl FileSystem e
fs [Char]
fp [Char]
s)
      }

readFile :: (e :> es) => FileSystem e -> FilePath -> Eff es String
readFile :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> [Char] -> Eff es [Char]
readFile FileSystem e
fs [Char]
filepath = Eff (es :& es) [Char] -> Eff es [Char]
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (FileSystem es
-> forall (e :: Effects). [Char] -> Eff (e :& es) [Char]
forall (es :: Effects).
FileSystem es
-> forall (e :: Effects). [Char] -> Eff (e :& es) [Char]
readFileImpl (FileSystem e -> FileSystem es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> FileSystem es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle FileSystem e
fs) [Char]
filepath)

writeFile :: (e :> es) => FileSystem e -> FilePath -> String -> Eff es ()
writeFile :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> [Char] -> [Char] -> Eff es ()
writeFile FileSystem e
fs [Char]
filepath [Char]
contents =
  Eff (es :& es) () -> Eff es ()
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (FileSystem es
-> forall (e :: Effects). [Char] -> [Char] -> Eff (e :& es) ()
forall (es :: Effects).
FileSystem es
-> forall (e :: Effects). [Char] -> [Char] -> Eff (e :& es) ()
writeFileImpl (FileSystem e -> FileSystem es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> FileSystem es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle FileSystem e
fs) [Char]
filepath [Char]
contents)

runFileSystemPure ::
  (e1 :> es) =>
  Exception String e1 ->
  [(FilePath, String)] ->
  (forall e2. FileSystem e2 -> Eff (e2 :& es) r) ->
  Eff es r
runFileSystemPure :: forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Exception [Char] e1
-> [([Char], [Char])]
-> (forall (e2 :: Effects). FileSystem e2 -> Eff (e2 :& es) r)
-> Eff es r
runFileSystemPure Exception [Char] e1
ex [([Char], [Char])]
fs0 forall (e2 :: Effects). FileSystem e2 -> Eff (e2 :& es) r
k =
  [([Char], [Char])]
-> (forall {e :: Effects}.
    State [([Char], [Char])] e -> Eff (e :& es) r)
-> Eff es r
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es a
evalState [([Char], [Char])]
fs0 ((forall {e :: Effects}.
  State [([Char], [Char])] e -> Eff (e :& es) r)
 -> Eff es r)
-> (forall {e :: Effects}.
    State [([Char], [Char])] e -> Eff (e :& es) r)
-> Eff es r
forall a b. (a -> b) -> a -> b
$ \State [([Char], [Char])] e
fs ->
    (FileSystem (e :& es) -> Eff ((e :& es) :& es) r)
-> FileSystem (e :& es) -> Eff (e :& es) r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn
      FileSystem (e :& es) -> Eff ((e :& es) :& es) r
forall (e2 :: Effects). FileSystem e2 -> Eff (e2 :& es) r
k
      MkFileSystem
        { readFileImpl :: forall (e :: Effects). [Char] -> Eff (e :& (e :& es)) [Char]
readFileImpl = \[Char]
path -> do
            [([Char], [Char])]
fs' <- State [([Char], [Char])] e
-> Eff (e :& (e :& es)) [([Char], [Char])]
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> Eff es s
get State [([Char], [Char])] e
fs
            case [Char] -> [([Char], [Char])] -> Maybe [Char]
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup [Char]
path [([Char], [Char])]
fs' of
              Maybe [Char]
Nothing ->
                Exception [Char] e1 -> [Char] -> Eff (e :& (e :& es)) [Char]
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception [Char] e1
ex ([Char]
"File not found: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
path)
              Just [Char]
s -> [Char] -> Eff (e :& (e :& es)) [Char]
forall a. a -> Eff (e :& (e :& es)) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
s,
          writeFileImpl :: forall (e :: Effects). [Char] -> [Char] -> Eff (e :& (e :& es)) ()
writeFileImpl = \[Char]
path [Char]
contents ->
            State [([Char], [Char])] e
-> ([([Char], [Char])] -> [([Char], [Char])])
-> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State [([Char], [Char])] e
fs (([Char]
path, [Char]
contents) :)
        }

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
runFileSystemIO :: forall (e1 :: Effects) (e2 :: Effects) (es :: Effects) r.
(e1 :> es, e2 :> es) =>
Exception [Char] e1
-> IOE e2
-> (forall (e :: Effects). FileSystem e -> Eff (e :& es) r)
-> Eff es r
runFileSystemIO Exception [Char] e1
ex IOE e2
io forall (e :: Effects). FileSystem e -> Eff (e :& es) r
k =
  (FileSystem es -> Eff (es :& es) r) -> FileSystem es -> Eff es r
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn
    FileSystem es -> Eff (es :& es) r
forall (e :: Effects). FileSystem e -> Eff (e :& es) r
k
    MkFileSystem
      { readFileImpl :: forall (e :: Effects). [Char] -> Eff (e :& es) [Char]
readFileImpl =
          IO [Char] -> Eff (e :& es) [Char]
forall (ess :: Effects) a.
(e1 :> ess, e2 :> ess) =>
IO a -> Eff ess a
adapt (IO [Char] -> Eff (e :& es) [Char])
-> ([Char] -> IO [Char]) -> [Char] -> Eff (e :& es) [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> IO [Char]
Prelude.readFile,
        writeFileImpl :: forall (e :: Effects). [Char] -> [Char] -> Eff (e :& es) ()
writeFileImpl =
          \[Char]
path -> IO () -> Eff (e :& es) ()
forall (ess :: Effects) a.
(e1 :> ess, e2 :> ess) =>
IO a -> Eff ess a
adapt (IO () -> Eff (e :& es) ())
-> ([Char] -> IO ()) -> [Char] -> Eff (e :& es) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> IO ()
Prelude.writeFile [Char]
path
      }
  where
    adapt :: (e1 :> ess, e2 :> ess) => IO a -> Eff ess a
    adapt :: forall (ess :: Effects) a.
(e1 :> ess, e2 :> ess) =>
IO a -> Eff ess a
adapt IO a
m =
      IOE e2
-> IO (Either IOException a) -> Eff ess (Either IOException a)
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e2
io (forall e a. Exception e => IO a -> IO (Either e a)
Control.Exception.try @IOException IO a
m) Eff ess (Either IOException a)
-> (Either IOException a -> Eff ess a) -> Eff ess a
forall a b. Eff ess a -> (a -> Eff ess b) -> Eff ess b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
        Left IOException
e -> Exception [Char] e1 -> [Char] -> Eff ess a
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception [Char] e1
ex (IOException -> [Char]
forall a. Show a => a -> [Char]
show IOException
e)
        Right a
r -> a -> Eff ess a
forall a. a -> Eff ess a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
r

action :: (e :> es) => FileSystem e -> Eff es String
action :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> Eff es [Char]
action FileSystem e
fs = do
  [Char]
file <- FileSystem e -> [Char] -> Eff es [Char]
forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> [Char] -> Eff es [Char]
readFile FileSystem e
fs [Char]
"/dev/null"
  Bool -> Eff es () -> Eff es ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
file Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0) (Eff es () -> Eff es ()) -> Eff es () -> Eff es ()
forall a b. (a -> b) -> a -> b
$ do
    FileSystem e -> [Char] -> [Char] -> Eff es ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> [Char] -> [Char] -> Eff es ()
writeFile FileSystem e
fs [Char]
"/tmp/bluefin" [Char]
"Hello!\n"
  FileSystem e -> [Char] -> Eff es [Char]
forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> [Char] -> Eff es [Char]
readFile FileSystem e
fs [Char]
"/tmp/doesn't exist"

exampleRunFileSystemPure :: Either String String
exampleRunFileSystemPure :: Either [Char] [Char]
exampleRunFileSystemPure = (forall (es :: Effects). Eff es (Either [Char] [Char]))
-> Either [Char] [Char]
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Either [Char] [Char]))
 -> Either [Char] [Char])
-> (forall (es :: Effects). Eff es (Either [Char] [Char]))
-> Either [Char] [Char]
forall a b. (a -> b) -> a -> b
$ (forall (e :: Effects). Exception [Char] e -> Eff (e :& es) [Char])
-> Eff es (Either [Char] [Char])
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects).
  Exception [Char] e -> Eff (e :& es) [Char])
 -> Eff es (Either [Char] [Char]))
-> (forall (e :: Effects).
    Exception [Char] e -> Eff (e :& es) [Char])
-> Eff es (Either [Char] [Char])
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
ex ->
  Exception [Char] e
-> [([Char], [Char])]
-> (forall (e2 :: Effects).
    FileSystem e2 -> Eff (e2 :& (e :& es)) [Char])
-> Eff (e :& es) [Char]
forall (e1 :: Effects) (es :: Effects) r.
(e1 :> es) =>
Exception [Char] e1
-> [([Char], [Char])]
-> (forall (e2 :: Effects). FileSystem e2 -> Eff (e2 :& es) r)
-> Eff es r
runFileSystemPure Exception [Char] e
ex [([Char]
"/dev/null", [Char]
"")] FileSystem e2 -> Eff (e2 :& (e :& es)) [Char]
forall (e2 :: Effects).
FileSystem e2 -> Eff (e2 :& (e :& es)) [Char]
forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> Eff es [Char]
action

-- > exampleRunFileSystemPure
-- Left "File not found: /tmp/doesn't exist"

exampleRunFileSystemIO :: IO (Either String String)
exampleRunFileSystemIO :: IO (Either [Char] [Char])
exampleRunFileSystemIO = (forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
-> IO (Either [Char] [Char])
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
 -> IO (Either [Char] [Char]))
-> (forall (e :: Effects). IOE e -> Eff e (Either [Char] [Char]))
-> IO (Either [Char] [Char])
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> (forall (e :: Effects). Exception [Char] e -> Eff (e :& e) [Char])
-> Eff e (Either [Char] [Char])
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects). Exception [Char] e -> Eff (e :& e) [Char])
 -> Eff e (Either [Char] [Char]))
-> (forall (e :: Effects).
    Exception [Char] e -> Eff (e :& e) [Char])
-> Eff e (Either [Char] [Char])
forall a b. (a -> b) -> a -> b
$ \Exception [Char] e
ex ->
  Exception [Char] e
-> IOE e
-> (forall (e :: Effects).
    FileSystem e -> Eff (e :& (e :& e)) [Char])
-> Eff (e :& e) [Char]
forall (e1 :: Effects) (e2 :: Effects) (es :: Effects) r.
(e1 :> es, e2 :> es) =>
Exception [Char] e1
-> IOE e2
-> (forall (e :: Effects). FileSystem e -> Eff (e :& es) r)
-> Eff es r
runFileSystemIO Exception [Char] e
ex IOE e
io FileSystem e -> Eff (e :& (e :& e)) [Char]
forall (e :: Effects). FileSystem e -> Eff (e :& (e :& e)) [Char]
forall (e :: Effects) (es :: Effects).
(e :> es) =>
FileSystem e -> Eff es [Char]
action

-- > exampleRunFileSystemIO
-- Left "/tmp/doesn't exist: openFile: does not exist (No such file or directory)"
-- \$ cat /tmp/bluefin
-- Hello!

-- instance Handle example

data Application e = MkApplication
  { forall (e :: Effects).
Application e
-> forall (e' :: Effects). [Char] -> Int -> Eff (e' :& e) [[Char]]
queryDatabase :: forall e'. String -> Int -> Eff (e' :& e) [String],
    forall (e :: Effects). Application e -> State (Int, Bool) e
applicationState :: State (Int, Bool) e,
    forall (e :: Effects). Application e -> Stream [Char] e
logger :: Stream String e
  }

instance Handle Application where
  mapHandle :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Application e -> Application es
mapHandle
    MkApplication
      { queryDatabase :: forall (e :: Effects).
Application e
-> forall (e' :: Effects). [Char] -> Int -> Eff (e' :& e) [[Char]]
queryDatabase = forall (e' :: Effects). [Char] -> Int -> Eff (e' :& e) [[Char]]
q,
        applicationState :: forall (e :: Effects). Application e -> State (Int, Bool) e
applicationState = State (Int, Bool) e
a,
        logger :: forall (e :: Effects). Application e -> Stream [Char] e
logger = Stream [Char] e
l
      } =
      MkApplication
        { queryDatabase :: forall (e' :: Effects). [Char] -> Int -> Eff (e' :& es) [[Char]]
queryDatabase = \[Char]
s Int
i -> Eff (e' :& e) [[Char]] -> Eff (e' :& es) [[Char]]
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder ([Char] -> Int -> Eff (e' :& e) [[Char]]
forall (e' :: Effects). [Char] -> Int -> Eff (e' :& e) [[Char]]
q [Char]
s Int
i),
          applicationState :: State (Int, Bool) es
applicationState = State (Int, Bool) e -> State (Int, Bool) es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
State (Int, Bool) e -> State (Int, Bool) es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle State (Int, Bool) e
a,
          logger :: Stream [Char] es
logger = Stream [Char] e -> Stream [Char] es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Coroutine [Char] () e -> Coroutine [Char] () es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle Stream [Char] e
l
        }

-- This example shows a case where we can use @bracket@ polymorphically
-- in order to perform correct cleanup if @es@ is instantiated to a
-- set of effects that includes exceptions.
polymorphicBracket ::
  (st :> es) =>
  State (Integer, Bool) st ->
  Eff es () ->
  Eff es ()
polymorphicBracket :: forall (st :: Effects) (es :: Effects).
(st :> es) =>
State (Integer, Bool) st -> Eff es () -> Eff es ()
polymorphicBracket State (Integer, Bool) st
st Eff es ()
act =
  Eff es () -> (() -> Eff es ()) -> (() -> Eff es ()) -> Eff es ()
forall (es :: Effects) a b.
Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
bracket
    (() -> Eff es ()
forall a. a -> Eff es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
    -- Always set the boolean indicating that we have terminated
    (\()
_ -> State (Integer, Bool) st
-> ((Integer, Bool) -> (Integer, Bool)) -> Eff es ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State (Integer, Bool) st
st (\(Integer
c, Bool
b) -> (Integer
c, Bool
True)))
    -- Perform the given effectful action, then increment the counter
    (\()
_ -> do Eff es ()
act; State (Integer, Bool) st
-> ((Integer, Bool) -> (Integer, Bool)) -> Eff es ()
forall (e :: Effects) (es :: Effects) s.
(e :> es) =>
State s e -> (s -> s) -> Eff es ()
modify State (Integer, Bool) st
st (\(Integer
c, Bool
b) -> ((Integer
c Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1), Bool
b)))

-- Results in (1, True)
polymorphicBracketExample1 :: (Integer, Bool)
polymorphicBracketExample1 :: (Integer, Bool)
polymorphicBracketExample1 =
  (forall (es :: Effects). Eff es (Integer, Bool)) -> (Integer, Bool)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Integer, Bool))
 -> (Integer, Bool))
-> (forall (es :: Effects). Eff es (Integer, Bool))
-> (Integer, Bool)
forall a b. (a -> b) -> a -> b
$ do
    (()
_res, (Integer, Bool)
st) <- (Integer, Bool)
-> (forall {e :: Effects}.
    State (Integer, Bool) e -> Eff (e :& es) ())
-> Eff es ((), (Integer, Bool))
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es (a, s)
runState (Integer
0, Bool
False) ((forall {e :: Effects}.
  State (Integer, Bool) e -> Eff (e :& es) ())
 -> Eff es ((), (Integer, Bool)))
-> (forall {e :: Effects}.
    State (Integer, Bool) e -> Eff (e :& es) ())
-> Eff es ((), (Integer, Bool))
forall a b. (a -> b) -> a -> b
$ \State (Integer, Bool) e
st -> State (Integer, Bool) e -> Eff (e :& es) () -> Eff (e :& es) ()
forall (st :: Effects) (es :: Effects).
(st :> es) =>
State (Integer, Bool) st -> Eff es () -> Eff es ()
polymorphicBracket State (Integer, Bool) e
st (() -> Eff (e :& es) ()
forall a. a -> Eff (e :& es) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
    (Integer, Bool) -> Eff es (Integer, Bool)
forall a. a -> Eff es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer, Bool)
st

-- Results in (0, True)
polymorphicBracketExample2 :: (Integer, Bool)
polymorphicBracketExample2 :: (Integer, Bool)
polymorphicBracketExample2 =
  (forall (es :: Effects). Eff es (Integer, Bool)) -> (Integer, Bool)
forall a. (forall (es :: Effects). Eff es a) -> a
runPureEff ((forall (es :: Effects). Eff es (Integer, Bool))
 -> (Integer, Bool))
-> (forall (es :: Effects). Eff es (Integer, Bool))
-> (Integer, Bool)
forall a b. (a -> b) -> a -> b
$ do
    (Either Integer ()
_res, (Integer, Bool)
st) <- (Integer, Bool)
-> (forall {e :: Effects}.
    State (Integer, Bool) e -> Eff (e :& es) (Either Integer ()))
-> Eff es (Either Integer (), (Integer, Bool))
forall s (es :: Effects) a.
s
-> (forall (e :: Effects). State s e -> Eff (e :& es) a)
-> Eff es (a, s)
runState (Integer
0, Bool
False) ((forall {e :: Effects}.
  State (Integer, Bool) e -> Eff (e :& es) (Either Integer ()))
 -> Eff es (Either Integer (), (Integer, Bool)))
-> (forall {e :: Effects}.
    State (Integer, Bool) e -> Eff (e :& es) (Either Integer ()))
-> Eff es (Either Integer (), (Integer, Bool))
forall a b. (a -> b) -> a -> b
$ \State (Integer, Bool) e
st -> (forall (e :: Effects).
 Exception Integer e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) (Either Integer ())
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects).
  Exception Integer e -> Eff (e :& (e :& es)) ())
 -> Eff (e :& es) (Either Integer ()))
-> (forall (e :: Effects).
    Exception Integer e -> Eff (e :& (e :& es)) ())
-> Eff (e :& es) (Either Integer ())
forall a b. (a -> b) -> a -> b
$ \Exception Integer e
e -> State (Integer, Bool) e
-> Eff (e :& (e :& es)) () -> Eff (e :& (e :& es)) ()
forall (st :: Effects) (es :: Effects).
(st :> es) =>
State (Integer, Bool) st -> Eff es () -> Eff es ()
polymorphicBracket State (Integer, Bool) e
st (Exception Integer e -> Integer -> Eff (e :& (e :& es)) ()
forall (e :: Effects) (es :: Effects) ex a.
(e :> es) =>
Exception ex e -> ex -> Eff es a
throw Exception Integer e
e Integer
42)
    (Integer, Bool) -> Eff es (Integer, Bool)
forall a. a -> Eff es a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Integer, Bool)
st

pipesExample1 :: IO ()
pipesExample1 :: IO ()
pipesExample1 = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> (forall (e :: Effects). Effect e -> Eff (e :& e) ()) -> Eff e ()
forall (es :: Effects) r.
(forall (e :: Effects). Effect e -> Eff (e :& es) r) -> Eff es r
runEffect (Producer Int e -> Eff (e :& (e :& e)) ()
forall {e :: Effects}. Producer Int e -> Eff (e :& (e :& e)) ()
forall (e :: Effects) (es :: Effects).
(e :> es) =>
Producer Int e -> Eff es ()
count (forall {e :: Effects}. Producer Int e -> Eff (e :& (e :& e)) ())
-> (forall (e :: Effects).
    Proxy () Int () Void e -> Eff (e :& (e :& e)) ())
-> Proxy Void () () Void e
-> Eff (e :& e) ()
forall (e1 :: Effects) (es :: Effects) a' a b r c' c.
(e1 :> es) =>
(forall (e :: Effects). Proxy a' a () b e -> Eff (e :& es) r)
-> (forall (e :: Effects). Proxy () b c' c e -> Eff (e :& es) r)
-> Proxy a' a c' c e1
-> Eff es r
>-> IOE e -> Consumer Int e -> Eff (e :& (e :& e)) ()
forall (e2 :: Effects) (es :: Effects) (e1 :: Effects) a r.
(e2 :> es, e1 :> es, Show a) =>
IOE e1 -> Consumer a e2 -> Eff es r
P.print IOE e
io)
  where
    count :: (e :> es) => Producer Int e -> Eff es ()
    count :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
Producer Int e -> Eff es ()
count Producer Int e
p = [Int] -> (Int -> Eff es ()) -> Eff es ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 .. Int
5] ((Int -> Eff es ()) -> Eff es ())
-> (Int -> Eff es ()) -> Eff es ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> Producer Int e -> Int -> Eff es ()
forall (e :: Effects) (es :: Effects) x1 x a.
(e :> es) =>
Proxy x1 x () a e -> a -> Eff es ()
P.yield Producer Int e
p Int
i

pipesExample2 :: IO String
pipesExample2 :: IO [Char]
pipesExample2 = (forall (e :: Effects). IOE e -> Eff e [Char]) -> IO [Char]
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e [Char]) -> IO [Char])
-> (forall (e :: Effects). IOE e -> Eff e [Char]) -> IO [Char]
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> (forall (e :: Effects). Effect e -> Eff (e :& e) [Char])
-> Eff e [Char]
forall (es :: Effects) r.
(forall (e :: Effects). Effect e -> Eff (e :& es) r) -> Eff es r
runEffect ((forall (e :: Effects). Effect e -> Eff (e :& e) [Char])
 -> Eff e [Char])
-> (forall (e :: Effects). Effect e -> Eff (e :& e) [Char])
-> Eff e [Char]
forall a b. (a -> b) -> a -> b
$ do
  IOE e
-> Proxy Void () () [Char] e -> Eff (e :& (e :& (e :& e))) [Char]
forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) r.
(e1 :> es, e2 :> es) =>
IOE e1 -> Producer [Char] e2 -> Eff es r
stdinLn IOE e
io (forall {e :: Effects}.
 Proxy Void () () [Char] e -> Eff (e :& (e :& (e :& e))) [Char])
-> (forall (e :: Effects).
    Proxy () [Char] () [Char] e -> Eff (e :& (e :& (e :& e))) [Char])
-> Proxy Void () () [Char] e
-> Eff (e :& (e :& e)) [Char]
forall (e1 :: Effects) (es :: Effects) a' a b r c' c.
(e1 :> es) =>
(forall (e :: Effects). Proxy a' a () b e -> Eff (e :& es) r)
-> (forall (e :: Effects). Proxy () b c' c e -> Eff (e :& es) r)
-> Proxy a' a c' c e1
-> Eff es r
>-> ([Char] -> Bool)
-> Proxy () [Char] () [Char] e -> Eff (e :& (e :& (e :& e))) [Char]
forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
(r -> Bool) -> Pipe r r e -> Eff es r
takeWhile' ([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
/= [Char]
"quit") (forall {e :: Effects}.
 Proxy Void () () [Char] e -> Eff (e :& (e :& e)) [Char])
-> (forall (e :: Effects).
    Proxy () [Char] () Void e -> Eff (e :& (e :& e)) [Char])
-> Effect e
-> Eff (e :& e) [Char]
forall (e1 :: Effects) (es :: Effects) a' a b r c' c.
(e1 :> es) =>
(forall (e :: Effects). Proxy a' a () b e -> Eff (e :& es) r)
-> (forall (e :: Effects). Proxy () b c' c e -> Eff (e :& es) r)
-> Proxy a' a c' c e1
-> Eff es r
>-> IOE e -> Proxy () [Char] () Void e -> Eff (e :& (e :& e)) [Char]
forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) r.
(e1 :> es, e2 :> es) =>
IOE e1 -> Consumer [Char] e2 -> Eff es r
stdoutLn IOE e
io

-- Acquiring resource
-- 1
-- 2
-- 3
-- 4
-- 5
-- Releasing resource
-- Finishing
promptCoroutine :: IO ()
promptCoroutine :: IO ()
promptCoroutine = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  -- consumeStream connects a consumer to a producer
  (forall (e :: Effects). Consume Int e -> Eff (e :& e) ())
-> (forall (e :: Effects). Stream Int e -> Eff (e :& e) ())
-> Eff e ()
forall a (es :: Effects) r.
(forall (e :: Effects). Consume a e -> Eff (e :& es) r)
-> (forall (e :: Effects). Stream a e -> Eff (e :& es) r)
-> Eff es r
consumeStream
    -- Like a pipes Consumer.  Prints the first five elements it
    -- awaits.
    ( \Consume Int e
r -> [Int] -> (Int -> Eff (e :& e) ()) -> Eff (e :& e) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 :: Int .. Int
5] ((Int -> Eff (e :& e) ()) -> Eff (e :& e) ())
-> (Int -> Eff (e :& e) ()) -> Eff (e :& e) ()
forall a b. (a -> b) -> a -> b
$ \Int
_ -> do
        Int
v <- Consume Int e -> Eff (e :& e) Int
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
Consume a e -> Eff es a
await Consume Int e
r
        IOE e -> IO () -> Eff (e :& e) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io (Int -> IO ()
forall a. Show a => a -> IO ()
print Int
v)
    )
    -- Like a pipes Producer. Yields successive integers indefinitely.
    -- Unlike in pipes, we can simply use Bluefin's standard bracket
    -- for prompt release of a resource
    ( \Stream Int e
y ->
        Eff (e :& e) ()
-> (() -> Eff (e :& e) ())
-> (() -> Eff (e :& e) ())
-> Eff (e :& e) ()
forall (es :: Effects) a b.
Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b
bracket
          (IOE e -> IO () -> Eff (e :& e) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Acquiring resource"))
          (\()
_ -> IOE e -> IO () -> Eff (e :& e) ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Releasing resource"))
          (\()
_ -> [Int] -> (Int -> Eff (e :& e) ()) -> Eff (e :& e) ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Int
1 :: Int ..] ((Int -> Eff (e :& e) ()) -> Eff (e :& e) ())
-> (Int -> Eff (e :& e) ()) -> Eff (e :& e) ()
forall a b. (a -> b) -> a -> b
$ \Int
i -> Stream Int e -> Int -> Eff (e :& e) ()
forall (e1 :: Effects) (es :: Effects) a.
(e1 :> es) =>
Stream a e1 -> a -> Eff es ()
yield Stream Int e
y Int
i)
    )
  IOE e -> IO () -> Eff e ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO ()
putStrLn [Char]
"Finishing")

rethrowIOExample :: IO ()
rethrowIOExample :: IO ()
rethrowIOExample = (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a. (forall (e :: Effects). IOE e -> Eff e a) -> IO a
runEff_ ((forall (e :: Effects). IOE e -> Eff e ()) -> IO ())
-> (forall (e :: Effects). IOE e -> Eff e ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \IOE e
io -> do
  Either IOException [Char]
r <- (forall (e :: Effects).
 Exception IOException e -> Eff (e :& e) [Char])
-> Eff e (Either IOException [Char])
forall exn (es :: Effects) a.
(forall (e :: Effects). Exception exn e -> Eff (e :& es) a)
-> Eff es (Either exn a)
try ((forall (e :: Effects).
  Exception IOException e -> Eff (e :& e) [Char])
 -> Eff e (Either IOException [Char]))
-> (forall (e :: Effects).
    Exception IOException e -> Eff (e :& e) [Char])
-> Eff e (Either IOException [Char])
forall a b. (a -> b) -> a -> b
$ \Exception IOException e
ex -> do
    forall ex (es :: Effects) (e1 :: Effects) (e2 :: Effects) r.
(e1 :> es, e2 :> es, Exception ex) =>
IOE e1 -> Exception ex e2 -> Eff es r -> Eff es r
rethrowIO @Control.Exception.IOException IOE e
io Exception IOException e
ex (Eff (e :& e) [Char] -> Eff (e :& e) [Char])
-> Eff (e :& e) [Char] -> Eff (e :& e) [Char]
forall a b. (a -> b) -> a -> b
$ do
      IOE e -> IO [Char] -> Eff (e :& e) [Char]
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io ([Char] -> IO [Char]
Prelude.readFile [Char]
"/tmp/doesnt-exist")

  IOE e -> IO () -> Eff e ()
forall (e :: Effects) (es :: Effects) a.
(e :> es) =>
IOE e -> IO a -> Eff es a
effIO IOE e
io (IO () -> Eff e ()) -> IO () -> Eff e ()
forall a b. (a -> b) -> a -> b
$ [Char] -> IO ()
putStrLn ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ case Either IOException [Char]
r of
    Left IOException
e -> [Char]
"Caught IOException:\n" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ IOException -> [Char]
forall a. Show a => a -> [Char]
show IOException
e
    Right [Char]
contents -> [Char]
contents

data DynamicReader r e = DynamicReader
  { forall r (e :: Effects).
DynamicReader r e -> forall (e' :: Effects). Eff (e' :& e) r
askLRImpl :: forall e'. Eff (e' :& e) r,
    forall r (e :: Effects).
DynamicReader r e
-> forall (e' :: Effects) a.
   (r -> r) -> Eff e' a -> Eff (e' :& e) a
localLRImpl :: forall e' a. (r -> r) -> Eff e' a -> Eff (e' :& e) a
  }

instance Handle (DynamicReader r) where
  mapHandle :: forall (e :: Effects) (es :: Effects).
(e :> es) =>
DynamicReader r e -> DynamicReader r es
mapHandle DynamicReader r e
h =
    DynamicReader
      { askLRImpl :: forall (e' :: Effects). Eff (e' :& es) r
askLRImpl = Eff (e' :& e) r -> Eff (e' :& es) r
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (DynamicReader r e -> forall (e' :: Effects). Eff (e' :& e) r
forall r (e :: Effects).
DynamicReader r e -> forall (e' :: Effects). Eff (e' :& e) r
askLRImpl DynamicReader r e
h),
        localLRImpl :: forall (e' :: Effects) a. (r -> r) -> Eff e' a -> Eff (e' :& es) a
localLRImpl = \r -> r
f Eff e' a
k -> Eff (e' :& e) a -> Eff (e' :& es) a
forall (b :: Effects) (c :: Effects) (c1 :: Effects) r.
(b :> c) =>
Eff (c1 :& b) r -> Eff (c1 :& c) r
useImplUnder (DynamicReader r e
-> forall (e' :: Effects) a.
   (r -> r) -> Eff e' a -> Eff (e' :& e) a
forall r (e :: Effects).
DynamicReader r e
-> forall (e' :: Effects) a.
   (r -> r) -> Eff e' a -> Eff (e' :& e) a
localLRImpl DynamicReader r e
h r -> r
f Eff e' a
k)
      }

askLR ::
  (e :> es) =>
  DynamicReader r e ->
  Eff es r
askLR :: forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
DynamicReader r e -> Eff es r
askLR DynamicReader r e
c = Eff (es :& es) r -> Eff es r
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (DynamicReader r es -> forall (e' :: Effects). Eff (e' :& es) r
forall r (e :: Effects).
DynamicReader r e -> forall (e' :: Effects). Eff (e' :& e) r
askLRImpl (DynamicReader r e -> DynamicReader r es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
DynamicReader r e -> DynamicReader r es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle DynamicReader r e
c))

localLR ::
  (e :> es) =>
  DynamicReader r e ->
  (r -> r) ->
  Eff es a ->
  Eff es a
localLR :: forall (e :: Effects) (es :: Effects) r a.
(e :> es) =>
DynamicReader r e -> (r -> r) -> Eff es a -> Eff es a
localLR DynamicReader r e
c r -> r
f Eff es a
m = Eff (es :& es) a -> Eff es a
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (DynamicReader r es
-> forall (e' :: Effects) a.
   (r -> r) -> Eff e' a -> Eff (e' :& es) a
forall r (e :: Effects).
DynamicReader r e
-> forall (e' :: Effects) a.
   (r -> r) -> Eff e' a -> Eff (e' :& e) a
localLRImpl (DynamicReader r e -> DynamicReader r es
forall (e :: Effects) (es :: Effects).
(e :> es) =>
DynamicReader r e -> DynamicReader r es
forall (h :: Effects -> *) (e :: Effects) (es :: Effects).
(Handle h, e :> es) =>
h e -> h es
mapHandle DynamicReader r e
c) r -> r
f Eff es a
m)

runDynamicReader ::
  r ->
  (forall e. DynamicReader r e -> Eff (e :& es) a) ->
  Eff es a
runDynamicReader :: forall r (es :: Effects) a.
r
-> (forall (e :: Effects). DynamicReader r e -> Eff (e :& es) a)
-> Eff es a
runDynamicReader r
r forall (e :: Effects). DynamicReader r e -> Eff (e :& es) a
k =
  r
-> (forall {e :: Effects}. Reader r e -> Eff (e :& es) a)
-> Eff es a
forall r (es :: Effects) a.
r
-> (forall (e :: Effects). Reader r e -> Eff (e :& es) a)
-> Eff es a
runReader r
r ((forall {e :: Effects}. Reader r e -> Eff (e :& es) a)
 -> Eff es a)
-> (forall {e :: Effects}. Reader r e -> Eff (e :& es) a)
-> Eff es a
forall a b. (a -> b) -> a -> b
$ \Reader r e
h -> do
    (DynamicReader r (e :& es) -> Eff ((e :& es) :& es) a)
-> DynamicReader r (e :& es) -> Eff (e :& es) a
forall (e :: Effects) (es :: Effects) t r.
(e :> es) =>
(t -> Eff (es :& e) r) -> t -> Eff es r
useImplIn
      DynamicReader r (e :& es) -> Eff ((e :& es) :& es) a
forall (e :: Effects). DynamicReader r e -> Eff (e :& es) a
k
      DynamicReader
        { askLRImpl :: forall (e' :: Effects). Eff (e' :& (e :& es)) r
askLRImpl = Reader r e -> Eff (e' :& (e :& es)) r
forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
Reader r e -> Eff es r
ask Reader r e
h,
          localLRImpl :: forall (e' :: Effects) a.
(r -> r) -> Eff e' a -> Eff (e' :& (e :& es)) a
localLRImpl = \r -> r
f Eff e' a
k' -> Eff ((e' :& (e :& es)) :& (e' :& (e :& es))) a
-> Eff (e' :& (e :& es)) a
forall (e :: Effects) r. Eff (e :& e) r -> Eff e r
makeOp (Reader r e
-> (r -> r)
-> Eff ((e' :& (e :& es)) :& (e' :& (e :& es))) a
-> Eff ((e' :& (e :& es)) :& (e' :& (e :& es))) a
forall (e1 :: Effects) (es :: Effects) r a.
(e1 :> es) =>
Reader r e1 -> (r -> r) -> Eff es a -> Eff es a
local Reader r e
h r -> r
f (Eff e' a -> Eff ((e' :& (e :& es)) :& (e' :& (e :& es))) a
forall (e :: Effects) (es :: Effects) r.
(e :> es) =>
Eff e r -> Eff es r
useImpl Eff e' a
k'))
        }