bluefin-internal 0.1.1.0 → 0.1.2.0

raw patch · 3 files changed

+13/−2 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Bluefin.Internal: MkEffReader :: (r -> Eff es a) -> EffReader r es a

+ Bluefin.Internal: MkEffReader :: (r -> Eff es a) -> EffReader r (es :: Effects) a

- Bluefin.Internal: MkException :: (forall a. exn -> Eff e a) -> Exception exn (e :: Effects)

+ Bluefin.Internal: MkException :: (forall a. () => exn -> Eff e a) -> Exception exn (e :: Effects)

- Bluefin.Internal: MkReader :: State r e -> Reader r e

+ Bluefin.Internal: MkReader :: State r e -> Reader r (e :: Effects)

- Bluefin.Internal: UnsafeMkHandleReader :: State (h e) e -> HandleReader h e

+ Bluefin.Internal: UnsafeMkHandleReader :: State (h e) e -> HandleReader (h :: Effects -> Type) (e :: Effects)

- Bluefin.Internal: Writer :: Stream w e -> Writer w e

+ Bluefin.Internal: Writer :: Stream w e -> Writer w (e :: Effects)

- Bluefin.Internal: [Compound] :: Proxy# s1 -> Proxy# s2 -> e1 s1 -> e2 s2 -> Compound e1 e2 (s1 :& s2)

+ Bluefin.Internal: [Compound] :: forall (s1 :: Effects) (s2 :: Effects) (e1 :: Effects -> Type) (e2 :: Effects -> Type). Proxy# s1 -> Proxy# s2 -> e1 s1 -> e2 s2 -> Compound e1 e2 ('Union s1 s2)

- Bluefin.Internal: [unEffReader] :: EffReader r es a -> r -> Eff es a

+ Bluefin.Internal: [unEffReader] :: EffReader r (es :: Effects) a -> r -> Eff es a

- Bluefin.Internal: ask :: e :> es => Reader r e -> Eff es r

+ Bluefin.Internal: ask :: forall (e :: Effects) (es :: Effects) r. e :> es => Reader r e -> Eff es r

- Bluefin.Internal: askHandle :: (e :> es, Handle h) => HandleReader h e -> Eff es (h es)

+ Bluefin.Internal: askHandle :: forall (e :: Effects) (es :: Effects) h. (e :> es, Handle h) => HandleReader h e -> Eff es (h es)

- Bluefin.Internal: asks :: e :> es => Reader r e -> (r -> a) -> Eff es a

+ Bluefin.Internal: asks :: forall (e :: Effects) (es :: Effects) r a. e :> es => Reader r e -> (r -> a) -> Eff es a

- Bluefin.Internal: assoc1 :: (# #) -> ((a :& b) :& c) `In` (a :& (b :& c))

+ Bluefin.Internal: assoc1 :: forall (a :: Effects) (b :: Effects) (c :: Effects). (# #) -> In ((a :& b) :& c) (a :& (b :& c))

- Bluefin.Internal: assoc1Eff :: Eff ((a :& b) :& c) r -> Eff (a :& (b :& c)) r

+ Bluefin.Internal: assoc1Eff :: forall (a :: Effects) (b :: Effects) (c :: Effects) r. Eff ((a :& b) :& c) r -> Eff (a :& (b :& c)) r

- Bluefin.Internal: await :: e :> es => Consume a e -> Eff es a

+ Bluefin.Internal: await :: forall (e :: Effects) (es :: Effects) a. e :> es => Consume a e -> Eff es a

- Bluefin.Internal: b :: (a `In` b) -> (c :& a) `In` (c :& b)

+ Bluefin.Internal: b :: forall (a :: Effects) (b :: Effects) (c :: Effects). In a b -> In (c :& a) (c :& b)

- Bluefin.Internal: b2 :: (a `In` b) -> (a :& c) `In` (b :& c)

+ Bluefin.Internal: b2 :: forall (a :: Effects) (b :: Effects) (c :: Effects). In a b -> In (a :& c) (b :& c)

- Bluefin.Internal: bimap :: (a `In` b) -> (c `In` d) -> (a :& c) `In` (b :& d)

+ Bluefin.Internal: bimap :: forall (a :: Effects) (b :: Effects) (c :: Effects) (d :: Effects). In a b -> In c d -> In (a :& c) (b :& d)

- Bluefin.Internal: bracket :: Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b

+ Bluefin.Internal: bracket :: forall (es :: Effects) a b. Eff es a -> (a -> Eff es ()) -> (a -> Eff es b) -> Eff es b

- Bluefin.Internal: catMaybes :: e2 :> es => (forall e1. Stream (Maybe a) e1 -> Eff (e1 :& es) r) -> Stream a e2 -> Eff es r

+ Bluefin.Internal: catMaybes :: forall (e2 :: Effects) (es :: Effects) a r. e2 :> es => (forall (e1 :: Effects). () => Stream (Maybe a) e1 -> Eff (e1 :& es) r) -> Stream a e2 -> Eff es r

- Bluefin.Internal: catch :: forall exn (es :: Effects) a. (forall e. Exception exn e -> Eff (e :& es) a) -> (exn -> Eff es a) -> Eff es a

+ Bluefin.Internal: catch :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> (exn -> Eff es a) -> Eff es a

- Bluefin.Internal: cmp :: (a `In` b) -> (b `In` c) -> a `In` c

+ Bluefin.Internal: cmp :: forall (a :: Effects) (b :: Effects) (c :: Effects). In a b -> In b c -> In a c

- Bluefin.Internal: compound :: h1 e1 -> h2 e2 -> Compound h1 h2 (e1 :& e2)

+ Bluefin.Internal: compound :: forall h1 (e1 :: Effects) h2 (e2 :: Effects). h1 e1 -> h2 e2 -> Compound h1 h2 (e1 :& e2)

- Bluefin.Internal: connect :: (forall e1. Coroutine a b e1 -> Eff (e1 :& es) r1) -> (forall e2. a -> Coroutine b a e2 -> Eff (e2 :& es) r2) -> forall e1 e2. (e1 :> es, e2 :> es) => Eff es (Either (r1, a -> Coroutine b a e2 -> Eff es r2) (r2, b -> Coroutine a b e1 -> Eff es r1))

+ Bluefin.Internal: connect :: forall a b (es :: Effects) r1 r2. (forall (e1 :: Effects). () => Coroutine a b e1 -> Eff (e1 :& es) r1) -> (forall (e2 :: Effects). () => a -> Coroutine b a e2 -> Eff (e2 :& es) r2) -> forall (e1 :: Effects) (e2 :: Effects). (e1 :> es, e2 :> es) => Eff es (Either (r1, a -> Coroutine b a e2 -> Eff es r2) (r2, b -> Coroutine a b e1 -> Eff es r1))

- Bluefin.Internal: connectCoroutines :: forall es a b r. (forall e. Coroutine a b e -> Eff (e :& es) r) -> (forall e. a -> Coroutine b a e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal: connectCoroutines :: 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

- Bluefin.Internal: consumeEach :: (forall e. Consume b e -> Eff (e :& es) r) -> Eff es b -> Eff es r

+ Bluefin.Internal: consumeEach :: forall b (es :: Effects) r. (forall (e :: Effects). () => Consume b e -> Eff (e :& es) r) -> Eff es b -> Eff es r

- Bluefin.Internal: consumeStream :: (forall e. Consume a e -> Eff (e :& es) r) -> (forall e. Stream a e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal: consumeStream :: 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

- Bluefin.Internal: cycleToStream :: (Foldable f, ea :> es) => f a -> Stream a ea -> Eff es ()

+ Bluefin.Internal: cycleToStream :: forall f (ea :: Effects) (es :: Effects) a. (Foldable f, ea :> es) => f a -> Stream a ea -> Eff es ()

- Bluefin.Internal: data Compound e1 e2 ss

+ Bluefin.Internal: data Compound (e1 :: Effects -> Type) (e2 :: Effects -> Type) (ss :: Effects)

- Bluefin.Internal: drop :: (a `In` b) -> a `In` (c :& b)

+ Bluefin.Internal: drop :: forall (a :: Effects) (b :: Effects) (c :: Effects). In a b -> In a (c :& b)

- Bluefin.Internal: effIO :: e :> es => IOE e -> IO a -> Eff es a

+ Bluefin.Internal: effIO :: forall (e :: Effects) (es :: Effects) a. e :> es => IOE e -> IO a -> Eff es a

- Bluefin.Internal: effReader :: (r -> Eff es a) -> EffReader r es a

+ Bluefin.Internal: effReader :: forall r (es :: Effects) a. (r -> Eff es a) -> EffReader r es a

- Bluefin.Internal: enumerate :: e2 :> es => (forall e1. Stream a e1 -> Eff (e1 :& es) r) -> Stream (Int, a) e2 -> Eff es r

+ Bluefin.Internal: enumerate :: 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

- Bluefin.Internal: enumerateFrom :: e2 :> es => Int -> (forall e1. Stream a e1 -> Eff (e1 :& es) r) -> Stream (Int, a) e2 -> Eff es r

+ Bluefin.Internal: enumerateFrom :: 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

- Bluefin.Internal: eq :: (# #) -> a `In` a

+ Bluefin.Internal: eq :: forall (a :: Effects). (# #) -> In a a

- Bluefin.Internal: evalState :: s -> (forall e. State s e -> Eff (e :& es) a) -> Eff es a

+ Bluefin.Internal: evalState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => State s e -> Eff (e :& es) a) -> Eff es a

- Bluefin.Internal: execWriter :: Monoid w => (forall e. Writer w e -> Eff (e :& es) r) -> Eff es w

+ Bluefin.Internal: execWriter :: forall w (es :: Effects) r. Monoid w => (forall (e :: Effects). () => Writer w e -> Eff (e :& es) r) -> Eff es w

- Bluefin.Internal: forEach :: (forall e1. Coroutine a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r

+ Bluefin.Internal: forEach :: forall a b (es :: Effects) r. (forall (e1 :: Effects). () => Coroutine a b e1 -> Eff (e1 :& es) r) -> (a -> Eff es b) -> Eff es r

- Bluefin.Internal: fstI :: (# #) -> a `In` (a :& b)

+ Bluefin.Internal: fstI :: forall (a :: Effects) (b :: Effects). (# #) -> In a (a :& b)

- Bluefin.Internal: get :: e :> es => State s e -> Eff es s

+ Bluefin.Internal: get :: forall (e :: Effects) (es :: Effects) s. e :> es => State s e -> Eff es s

- Bluefin.Internal: getC :: forall ss es e. ss :> es => Compound e (State Int) ss -> Eff es Int

+ Bluefin.Internal: getC :: forall (ss :: Effects) (es :: Effects) (e :: Effects -> Type). ss :> es => Compound e (State Int) ss -> Eff es Int

- Bluefin.Internal: handle :: forall exn (es :: Effects) a. (exn -> Eff es a) -> (forall e. Exception exn e -> Eff (e :& es) a) -> Eff es a

+ Bluefin.Internal: handle :: forall exn (es :: Effects) a. (exn -> Eff es a) -> (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> Eff es a

- Bluefin.Internal: handleCoroutine :: (a -> Eff es b) -> (z -> Eff es r) -> (forall e1. Coroutine a b e1 -> Eff (e1 :& es) z) -> Eff es r

+ Bluefin.Internal: handleCoroutine :: forall a (es :: Effects) b z r. (a -> Eff es b) -> (z -> Eff es r) -> (forall (e1 :: Effects). () => Coroutine a b e1 -> Eff (e1 :& es) z) -> Eff es r

- Bluefin.Internal: has :: forall a b. a :> b => a `In` b

+ Bluefin.Internal: has :: forall (a :: Effects) (b :: Effects). a :> b => In a b

- Bluefin.Internal: have :: forall a b. (a `In` b) -> Dict (a :> b)

+ Bluefin.Internal: have :: forall (a :: Effects) (b :: Effects). In a b -> Dict (a :> b)

- Bluefin.Internal: head' :: forall a b r es. (forall e. Coroutine a b e -> Eff (e :& es) r) -> forall e. e :> es => Eff es (Either r (a, b -> Coroutine a b e -> Eff es r))

+ Bluefin.Internal: head' :: forall a b r (es :: Effects). (forall (e :: Effects). () => Coroutine a b e -> Eff (e :& es) r) -> forall (e :: Effects). e :> es => Eff es (Either r (a, b -> Coroutine a b e -> Eff es r))

- Bluefin.Internal: here :: (a `In` b) -> a `In` (b :& c)

+ Bluefin.Internal: here :: forall (a :: Effects) (b :: Effects) (c :: Effects). In a b -> In a (b :& c)

- Bluefin.Internal: hoistReader :: (forall b. m b -> n b) -> ReaderT r m a -> ReaderT r n a

+ Bluefin.Internal: hoistReader :: (forall b. () => m b -> n b) -> ReaderT r m a -> ReaderT r n a

- Bluefin.Internal: ignoreStream :: (forall e1. Stream a e1 -> Eff (e1 :& es) r) -> Eff es r

+ Bluefin.Internal: ignoreStream :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Eff es r

- Bluefin.Internal: inComp :: forall a b c r. a :> b => b :> c => (a :> c => r) -> r

+ Bluefin.Internal: inComp :: forall (a :: Effects) (b :: Effects) (c :: Effects) r. (a :> b, b :> c) => (a :> c => r) -> r

- Bluefin.Internal: inContext :: e2 :> e1 => Eff (e1 :& e2) r -> Eff e1 r

+ Bluefin.Internal: inContext :: forall (e2 :: Effects) (e1 :: Effects) r. e2 :> e1 => Eff (e1 :& e2) r -> Eff e1 r

- Bluefin.Internal: inFoldable :: (Foldable t, e1 :> es) => t a -> Stream a e1 -> Eff es ()

+ Bluefin.Internal: inFoldable :: forall t (e1 :: Effects) (es :: Effects) a. (Foldable t, e1 :> es) => t a -> Stream a e1 -> Eff es ()

- Bluefin.Internal: insertFirst :: Eff b r -> Eff (c1 :& b) r

+ Bluefin.Internal: insertFirst :: forall (b :: Effects) r (c1 :: Effects). Eff b r -> Eff (c1 :& b) r

- Bluefin.Internal: insertManySecond :: b :> c => Eff (c1 :& b) r -> Eff (c1 :& c) r

+ Bluefin.Internal: insertManySecond :: forall (b :: Effects) (c :: Effects) (c1 :: Effects) r. b :> c => Eff (c1 :& b) r -> Eff (c1 :& c) r

- Bluefin.Internal: insertSecond :: Eff (c1 :& b) r -> Eff (c1 :& (c2 :& b)) r

+ Bluefin.Internal: insertSecond :: forall (c1 :: Effects) (b :: Effects) r (c2 :: Effects). Eff (c1 :& b) r -> Eff (c1 :& (c2 :& b)) r

- Bluefin.Internal: jumpTo :: e :> es => Jump e -> Eff es a

+ Bluefin.Internal: jumpTo :: forall (e :: Effects) (es :: Effects) a. e :> es => Jump e -> Eff es a

- Bluefin.Internal: local :: e1 :> es => Reader r e1 -> (r -> r) -> Eff es a -> Eff es a

+ Bluefin.Internal: local :: forall (e1 :: Effects) (es :: Effects) r a. e1 :> es => Reader r e1 -> (r -> r) -> Eff es a -> Eff es a

- Bluefin.Internal: localHandle :: (e :> es, Handle h) => HandleReader h e -> (h es -> h es) -> Eff es r -> Eff es r

+ Bluefin.Internal: localHandle :: forall (e :: Effects) (es :: Effects) h r. (e :> es, Handle h) => HandleReader h e -> (h es -> h es) -> Eff es r -> Eff es r

- Bluefin.Internal: makeOp :: Eff (e :& e) r -> Eff e r

+ Bluefin.Internal: makeOp :: forall (e :: Effects) r. Eff (e :& e) r -> Eff e r

- Bluefin.Internal: mapHandle :: (Handle h, e :> es) => h e -> h es

+ Bluefin.Internal: mapHandle :: forall (e :: Effects) (es :: Effects). (Handle h, e :> es) => h e -> h es

- Bluefin.Internal: mapHandleReader :: forall h e es. (Handle h, e :> es) => HandleReader h e -> HandleReader h es

+ Bluefin.Internal: mapHandleReader :: forall (h :: Effects -> Type) (e :: Effects) (es :: Effects). (Handle h, e :> es) => HandleReader h e -> HandleReader h es

- Bluefin.Internal: mapMaybe :: e2 :> es => (a -> Maybe b) -> (forall e1. Stream a e1 -> Eff (e1 :& es) r) -> Stream b e2 -> Eff es r

+ Bluefin.Internal: mapMaybe :: 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

- Bluefin.Internal: mapStream :: e2 :> es => (a -> b) -> (forall e1. Stream a e1 -> Eff (e1 :& es) r) -> Stream b e2 -> Eff es r

+ Bluefin.Internal: mapStream :: 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

- Bluefin.Internal: merge :: (# #) -> (a :& a) `In` a

+ Bluefin.Internal: merge :: forall (a :: Effects). (# #) -> In (a :& a) a

- Bluefin.Internal: mergeEff :: Eff (a :& a) r -> Eff a r

+ Bluefin.Internal: mergeEff :: forall (a :: Effects) r. Eff (a :& a) r -> Eff a r

- Bluefin.Internal: modify :: e :> es => State s e -> (s -> s) -> Eff es ()

+ Bluefin.Internal: modify :: forall (e :: Effects) (es :: Effects) s. e :> es => State s e -> (s -> s) -> Eff es ()

- Bluefin.Internal: newState :: e :> es => StateSource e -> s -> Eff es (State s e)

+ Bluefin.Internal: newState :: forall (e :: Effects) (es :: Effects) s. e :> es => StateSource e -> s -> Eff es (State s e)

- Bluefin.Internal: newtype EffReader r es a

+ Bluefin.Internal: newtype EffReader r (es :: Effects) a

- Bluefin.Internal: newtype HandleReader h e

+ Bluefin.Internal: newtype HandleReader (h :: Effects -> Type) (e :: Effects)

- Bluefin.Internal: newtype In (a :: Effects) (b :: Effects)

+ Bluefin.Internal: newtype In (a :: Effects) (b :: Effects) :: ZeroBitType

- Bluefin.Internal: newtype Reader r e

+ Bluefin.Internal: newtype Reader r (e :: Effects)

- Bluefin.Internal: newtype Writer w e

+ Bluefin.Internal: newtype Writer w (e :: Effects)

- Bluefin.Internal: pushFirst :: Eff a r -> Eff (a :& b) r

+ Bluefin.Internal: pushFirst :: forall (a :: Effects) r (b :: Effects). Eff a r -> Eff (a :& b) r

- Bluefin.Internal: put :: e :> es => State s e -> s -> Eff es ()

+ Bluefin.Internal: put :: forall (e :: Effects) (es :: Effects) s. e :> es => State s e -> s -> Eff es ()

- Bluefin.Internal: putC :: forall ss es e. ss :> es => Compound e (State Int) ss -> Int -> Eff es ()

+ Bluefin.Internal: putC :: forall (ss :: Effects) (es :: Effects) (e :: Effects -> Type). ss :> es => Compound e (State Int) ss -> Int -> Eff es ()

- Bluefin.Internal: race :: e2 :> es => (forall e. IOE e -> Eff (e :& es) a) -> (forall e. IOE e -> Eff (e :& es) a) -> IOE e2 -> Eff es a

+ Bluefin.Internal: race :: forall (e2 :: Effects) (es :: Effects) a. e2 :> es => (forall (e :: Effects). () => IOE e -> Eff (e :& es) a) -> (forall (e :: Effects). () => IOE e -> Eff (e :& es) a) -> IOE e2 -> Eff es a

- Bluefin.Internal: receiveStream :: (forall e. Consume a e -> Eff (e :& es) r) -> (forall e. Stream a e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal: receiveStream :: 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

- Bluefin.Internal: rethrowIO :: forall ex es e1 e2 r. (e1 :> es, e2 :> es, Exception ex) => IOE e1 -> Exception ex e2 -> Eff es r -> Eff es r

+ Bluefin.Internal: rethrowIO :: 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

- Bluefin.Internal: returnEarly :: e :> es => EarlyReturn r e -> r -> Eff es a

+ Bluefin.Internal: returnEarly :: forall (e :: Effects) (es :: Effects) r a. e :> es => EarlyReturn r e -> r -> Eff es a

- Bluefin.Internal: runCompound :: e1 s1 -> e2 s2 -> (forall es'. Compound e1 e2 es' -> Eff (es' :& es) r) -> Eff (s1 :& (s2 :& es)) r

+ Bluefin.Internal: runCompound :: forall e1 (s1 :: Effects) e2 (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

- Bluefin.Internal: runConstEffect :: r -> (forall e. ConstEffect r e -> Eff (e :& es) a) -> Eff es a

+ Bluefin.Internal: runConstEffect :: forall r (es :: Effects) a. r -> (forall (e :: Effects). () => ConstEffect r e -> Eff (e :& es) a) -> Eff es a

- Bluefin.Internal: runEff :: (forall e es. IOE e -> Eff (e :& es) a) -> IO a

+ Bluefin.Internal: runEff :: (forall (e :: Effects) (es :: Effects). () => IOE e -> Eff (e :& es) a) -> IO a

- Bluefin.Internal: runEffReader :: r -> EffReader r es a -> Eff es a

+ Bluefin.Internal: runEffReader :: forall r (es :: Effects) a. r -> EffReader r es a -> Eff es a

- Bluefin.Internal: runEff_ :: (forall e. IOE e -> Eff e a) -> IO a

+ Bluefin.Internal: runEff_ :: (forall (e :: Effects). () => IOE e -> Eff e a) -> IO a

- Bluefin.Internal: runHandleReader :: (e1 :> es, Handle h) => h e1 -> (forall e. HandleReader h e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal: runHandleReader :: forall (e1 :: Effects) (es :: Effects) h r. (e1 :> es, Handle h) => h e1 -> (forall (e :: Effects). () => HandleReader h e -> Eff (e :& es) r) -> Eff es r

- Bluefin.Internal: runPureEff :: (forall es. Eff es a) -> a

+ Bluefin.Internal: runPureEff :: (forall (es :: Effects). () => Eff es a) -> a

- Bluefin.Internal: runReader :: r -> (forall e. Reader r e -> Eff (e :& es) a) -> Eff es a

+ Bluefin.Internal: runReader :: forall r (es :: Effects) a. r -> (forall (e :: Effects). () => Reader r e -> Eff (e :& es) a) -> Eff es a

- Bluefin.Internal: runState :: s -> (forall e. State s e -> Eff (e :& es) a) -> Eff es (a, s)

+ Bluefin.Internal: runState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => State s e -> Eff (e :& es) a) -> Eff es (a, s)

- Bluefin.Internal: runWriter :: Monoid w => (forall e. Writer w e -> Eff (e :& es) r) -> Eff es (r, w)

+ Bluefin.Internal: runWriter :: forall w (es :: Effects) r. Monoid w => (forall (e :: Effects). () => Writer w e -> Eff (e :& es) r) -> Eff es (r, w)

- Bluefin.Internal: sndI :: (# #) -> a `In` (b :& a)

+ Bluefin.Internal: sndI :: forall (a :: Effects) (b :: Effects). (# #) -> In a (b :& a)

- Bluefin.Internal: streamConsume :: forall a (es :: Effects) r. (forall (e :: Effects). Stream a e -> Eff (e :& es) r) -> (forall (e :: Effects). Consume a e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal: streamConsume :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Consume a e -> Eff (e :& es) r) -> Eff es r

- Bluefin.Internal: subsume1 :: (e2 `In` e1) -> (e1 :& e2) `In` e1

+ Bluefin.Internal: subsume1 :: forall (e2 :: Effects) (e1 :: Effects). In e2 e1 -> In (e1 :& e2) e1

- Bluefin.Internal: subsume2 :: (e1 `In` e2) -> (e1 :& e2) `In` e2

+ Bluefin.Internal: subsume2 :: forall (e1 :: Effects) (e2 :: Effects). In e1 e2 -> In (e1 :& e2) e2

- Bluefin.Internal: takeConsume :: (ea :> es, eb :> es) => Int -> Consume a ea -> Stream a eb -> Eff es ()

+ Bluefin.Internal: takeConsume :: forall (ea :: Effects) (es :: Effects) (eb :: Effects) a. (ea :> es, eb :> es) => Int -> Consume a ea -> Stream a eb -> Eff es ()

- Bluefin.Internal: tell :: e :> es => Writer w e -> w -> Eff es ()

+ Bluefin.Internal: tell :: forall (e :: Effects) (es :: Effects) w. e :> es => Writer w e -> w -> Eff es ()

- Bluefin.Internal: throw :: e :> es => Exception ex e -> ex -> Eff es a

+ Bluefin.Internal: throw :: forall (e :: Effects) (es :: Effects) ex a. e :> es => Exception ex e -> ex -> Eff es a

- Bluefin.Internal: try :: forall exn (es :: Effects) a. (forall e. Exception exn e -> Eff (e :& es) a) -> Eff es (Either exn a)

+ Bluefin.Internal: try :: forall exn (es :: Effects) a. (forall (e :: Effects). () => Exception exn e -> Eff (e :& es) a) -> Eff es (Either exn a)

- Bluefin.Internal: type (:&) = Union

+ Bluefin.Internal: type (:&) = 'Union

- Bluefin.Internal: unsafeCoerceDict :: forall c c'. Dict c -> Dict c'

+ Bluefin.Internal: unsafeCoerceDict :: Dict c -> Dict c'

- Bluefin.Internal: unsafeCoerceEff :: Eff t r -> Eff t' r

+ Bluefin.Internal: unsafeCoerceEff :: forall (t :: Effects) r (t' :: Effects). Eff t r -> Eff t' r

- Bluefin.Internal: unsafeProvideIO :: (forall e. IOE e -> Eff (e :& es) a) -> Eff es a

+ Bluefin.Internal: unsafeProvideIO :: forall (es :: Effects) a. (forall (e :: Effects). () => IOE e -> Eff (e :& es) a) -> Eff es a

- Bluefin.Internal: unwrap :: e :> es => Jump e -> Maybe a -> Eff es a

+ Bluefin.Internal: unwrap :: forall (e :: Effects) (es :: Effects) a. e :> es => Jump e -> Maybe a -> Eff es a

- Bluefin.Internal: useImpl :: e :> es => Eff e r -> Eff es r

+ Bluefin.Internal: useImpl :: forall (e :: Effects) (es :: Effects) r. e :> es => Eff e r -> Eff es r

- Bluefin.Internal: useImplIn :: e :> es => (t -> Eff (es :& e) r) -> t -> Eff es r

+ Bluefin.Internal: useImplIn :: forall (e :: Effects) (es :: Effects) t r. e :> es => (t -> Eff (es :& e) r) -> t -> Eff es r

- Bluefin.Internal: useImplUnder :: e :> es => Eff (e1 :& e) r -> Eff (e1 :& es) r

+ Bluefin.Internal: useImplUnder :: forall (e :: Effects) (es :: Effects) (e1 :: Effects) r. e :> es => Eff (e1 :& e) r -> Eff (e1 :& es) r

- Bluefin.Internal: useImplWithin :: e :> es => (t -> Eff (e1 :& e) r) -> t -> Eff (e1 :& es) r

+ Bluefin.Internal: useImplWithin :: forall (e :: Effects) (es :: Effects) t (e1 :: Effects) r. e :> es => (t -> Eff (e1 :& e) r) -> t -> Eff (e1 :& es) r

- Bluefin.Internal: w :: ((a :& b) `In` c) -> a `In` c

+ Bluefin.Internal: w :: forall (a :: Effects) (b :: Effects) (c :: Effects). In (a :& b) c -> In a c

- Bluefin.Internal: w2 :: ((b :& a) `In` c) -> a `In` c

+ Bluefin.Internal: w2 :: forall (b :: Effects) (a :: Effects) (c :: Effects). In (b :& a) c -> In a c

- Bluefin.Internal: weakenEff :: (t `In` t') -> Eff t r -> Eff t' r

+ Bluefin.Internal: weakenEff :: forall (t :: Effects) (t' :: Effects) r. In t t' -> Eff t r -> Eff t' r

- Bluefin.Internal: withC1 :: forall e1 e2 ss es r. ss :> es => Compound e1 e2 ss -> (forall st. st :> es => e1 st -> Eff es r) -> Eff es r

+ Bluefin.Internal: withC1 :: forall e1 (e2 :: Effects -> Type) (ss :: Effects) (es :: Effects) r. ss :> es => Compound e1 e2 ss -> (forall (st :: Effects). st :> es => e1 st -> Eff es r) -> Eff es r

- Bluefin.Internal: withC2 :: forall e1 e2 ss es r. ss :> es => Compound e1 e2 ss -> (forall st. st :> es => e2 st -> Eff es r) -> Eff es r

+ Bluefin.Internal: withC2 :: forall (e1 :: Effects -> Type) e2 (ss :: Effects) (es :: Effects) r. ss :> es => Compound e1 e2 ss -> (forall (st :: Effects). st :> es => e2 st -> Eff es r) -> Eff es r

- Bluefin.Internal: withCompound :: forall h1 h2 e es r. e :> es => Compound h1 h2 e -> (forall e1 e2. (e1 :> es, e2 :> es) => h1 e1 -> h2 e2 -> Eff es r) -> Eff es r

+ Bluefin.Internal: withCompound :: forall h1 h2 (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

- Bluefin.Internal: withEarlyReturn :: (forall e. EarlyReturn r e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal: withEarlyReturn :: forall r (es :: Effects). (forall (e :: Effects). () => EarlyReturn r e -> Eff (e :& es) r) -> Eff es r

- Bluefin.Internal: withEffToIO :: e2 :> es => ((forall r. (forall e1. IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a) -> IOE e2 -> Eff es a

+ Bluefin.Internal: withEffToIO :: forall (e2 :: Effects) (es :: Effects) a. e2 :> es => ((forall r. () => (forall (e1 :: Effects). () => IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a) -> IOE e2 -> Eff es a

- Bluefin.Internal: withEffToIO' :: e2 :> es => IOE e2 -> ((forall r. (forall e1. IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a) -> Eff es a

+ Bluefin.Internal: withEffToIO' :: forall (e2 :: Effects) (es :: Effects) a. e2 :> es => IOE e2 -> ((forall r. () => (forall (e1 :: Effects). () => IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a) -> Eff es a

- Bluefin.Internal: withEffToIO_ :: e :> es => IOE e -> ((forall r. Eff es r -> IO r) -> IO a) -> Eff es a

+ Bluefin.Internal: withEffToIO_ :: forall (e :: Effects) (es :: Effects) a. e :> es => IOE e -> ((forall r. () => Eff es r -> IO r) -> IO a) -> Eff es a

- Bluefin.Internal: withEffToIO_' :: e2 :> es => IOE e2 -> ((forall r. (forall e1. IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a) -> Eff es a

+ Bluefin.Internal: withEffToIO_' :: forall (e2 :: Effects) (es :: Effects) a. e2 :> es => IOE e2 -> ((forall r. () => (forall (e1 :: Effects). () => IOE e1 -> Eff (e1 :& es) r) -> IO r) -> IO a) -> Eff es a

- Bluefin.Internal: withJump :: (forall e. Jump e -> Eff (e :& es) ()) -> Eff es ()

+ Bluefin.Internal: withJump :: forall (es :: Effects). (forall (e :: Effects). () => Jump e -> Eff (e :& es) ()) -> Eff es ()

- Bluefin.Internal: withMonadFail :: e :> es => Exception String e -> (forall m. MonadFail m => m r) -> Eff es r

+ Bluefin.Internal: withMonadFail :: forall (e :: Effects) (es :: Effects) r. e :> es => Exception String e -> (forall (m :: Type -> Type). MonadFail m => m r) -> Eff es r

- Bluefin.Internal: withMonadIO :: e :> es => IOE e -> (forall m. MonadIO m => m r) -> Eff es r

+ Bluefin.Internal: withMonadIO :: forall (e :: Effects) (es :: Effects) r. e :> es => IOE e -> (forall (m :: Type -> Type). MonadIO m => m r) -> Eff es r

- Bluefin.Internal: withScopedException_ :: ((forall a. e -> IO a) -> IO r) -> IO (Either e r)

+ Bluefin.Internal: withScopedException_ :: ((forall a. () => e -> IO a) -> IO r) -> IO (Either e r)

- Bluefin.Internal: withState :: s -> (forall e. State s e -> Eff (e :& es) (s -> a)) -> Eff es a

+ Bluefin.Internal: withState :: forall s (es :: Effects) a. s -> (forall (e :: Effects). () => State s e -> Eff (e :& es) (s -> a)) -> Eff es a

- Bluefin.Internal: withStateInIO :: (e1 :> es, e2 :> es) => IOE e1 -> State s e2 -> (IORef s -> IO r) -> Eff es r

+ Bluefin.Internal: withStateInIO :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) s r. (e1 :> es, e2 :> es) => IOE e1 -> State s e2 -> (IORef s -> IO r) -> Eff es r

- Bluefin.Internal: withStateSource :: (forall e. StateSource e -> Eff (e :& es) a) -> Eff es a

+ Bluefin.Internal: withStateSource :: forall (es :: Effects) a. (forall (e :: Effects). () => StateSource e -> Eff (e :& es) a) -> Eff es a

- Bluefin.Internal: withYieldToList :: (forall e. Stream a e -> Eff (e :& es) ([a] -> r)) -> Eff es r

+ Bluefin.Internal: withYieldToList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) ([a] -> r)) -> Eff es r

- Bluefin.Internal: yield :: e1 :> es => Stream a e1 -> a -> Eff es ()

+ Bluefin.Internal: yield :: forall (e1 :: Effects) (es :: Effects) a. e1 :> es => Stream a e1 -> a -> Eff es ()

- Bluefin.Internal: yieldCoroutine :: e1 :> es => Coroutine a b e1 -> a -> Eff es b

+ Bluefin.Internal: yieldCoroutine :: forall (e1 :: Effects) (es :: Effects) a b. e1 :> es => Coroutine a b e1 -> a -> Eff es b

- Bluefin.Internal: yieldToList :: (forall e1. Stream a e1 -> Eff (e1 :& es) r) -> Eff es ([a], r)

+ Bluefin.Internal: yieldToList :: forall a (es :: Effects) r. (forall (e1 :: Effects). () => Stream a e1 -> Eff (e1 :& es) r) -> Eff es ([a], r)

- Bluefin.Internal: yieldToReverseList :: (forall e. Stream a e -> Eff (e :& es) r) -> Eff es ([a], r)

+ Bluefin.Internal: yieldToReverseList :: forall a (es :: Effects) r. (forall (e :: Effects). () => Stream a e -> Eff (e :& es) r) -> Eff es ([a], r)

- Bluefin.Internal: zipCoroutines :: e1 :> es => Coroutine (a1, a2) b e1 -> (forall e. Coroutine a1 b e -> Eff (e :& es) r) -> (forall e. Coroutine a2 b e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal: zipCoroutines :: 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

- Bluefin.Internal.Examples: DynamicReader :: (forall e'. Eff (e' :& e) r) -> (forall e' a. (r -> r) -> Eff e' a -> Eff (e' :& e) a) -> DynamicReader r e

+ Bluefin.Internal.Examples: DynamicReader :: (forall (e' :: Effects). () => Eff (e' :& e) r) -> (forall (e' :: Effects) a. () => (r -> r) -> Eff e' a -> Eff (e' :& e) a) -> DynamicReader r (e :: Effects)

- Bluefin.Internal.Examples: MkApplication :: (forall e'. String -> Int -> Eff (e' :& e) [String]) -> State (Int, Bool) e -> Stream String e -> Application e

+ Bluefin.Internal.Examples: MkApplication :: (forall (e' :: Effects). () => String -> Int -> Eff (e' :& e) [String]) -> State (Int, Bool) e -> Stream String e -> Application (e :: Effects)

- Bluefin.Internal.Examples: MkCounter1 :: State Int e -> Counter1 e

+ Bluefin.Internal.Examples: MkCounter1 :: State Int e -> Counter1 (e :: Effects)

- Bluefin.Internal.Examples: MkCounter2 :: State Int e1 -> Exception () e2 -> Counter2 e1 e2

+ Bluefin.Internal.Examples: MkCounter2 :: State Int e1 -> Exception () e2 -> Counter2 (e1 :: Effects) (e2 :: Effects)

- Bluefin.Internal.Examples: MkCounter3 :: State Int e -> Exception () e -> Counter3 e

+ Bluefin.Internal.Examples: MkCounter3 :: State Int e -> Exception () e -> Counter3 (e :: Effects)

- Bluefin.Internal.Examples: MkCounter3B :: IOE e -> Counter3B e

+ Bluefin.Internal.Examples: MkCounter3B :: IOE e -> Counter3B (e :: Effects)

- Bluefin.Internal.Examples: MkCounter4 :: State Int e -> Exception () e -> Stream String e -> Counter4 e

+ Bluefin.Internal.Examples: MkCounter4 :: State Int e -> Exception () e -> Stream String e -> Counter4 (e :: Effects)

- Bluefin.Internal.Examples: MkCounter5 :: (forall e'. Eff (e' :& e) ()) -> (forall e'. String -> Eff (e' :& e) Int) -> Counter5 e

+ Bluefin.Internal.Examples: MkCounter5 :: (forall (e' :: Effects). () => Eff (e' :& e) ()) -> (forall (e' :: Effects). () => String -> Eff (e' :& e) Int) -> Counter5 (e :: Effects)

- Bluefin.Internal.Examples: MkCounter6 :: (forall e'. Eff (e' :& e) ()) -> State Int e -> Stream String e -> Counter6 e

+ Bluefin.Internal.Examples: MkCounter6 :: (forall (e' :: Effects). () => Eff (e' :& e) ()) -> State Int e -> Stream String e -> Counter6 (e :: Effects)

- Bluefin.Internal.Examples: MkCounter7 :: (forall e'. Exception () e' -> Eff (e' :& e) ()) -> State Int e -> Stream String e -> Counter7 e

+ Bluefin.Internal.Examples: MkCounter7 :: (forall (e' :: Effects). () => Exception () e' -> Eff (e' :& e) ()) -> State Int e -> Stream String e -> Counter7 (e :: Effects)

- Bluefin.Internal.Examples: MkFileSystem :: (forall e. FilePath -> Eff (e :& es) String) -> (forall e. FilePath -> String -> Eff (e :& es) ()) -> FileSystem es

+ Bluefin.Internal.Examples: MkFileSystem :: (forall (e :: Effects). () => FilePath -> Eff (e :& es) String) -> (forall (e :: Effects). () => FilePath -> String -> Eff (e :& es) ()) -> FileSystem (es :: Effects)

- Bluefin.Internal.Examples: [applicationState] :: Application e -> State (Int, Bool) e

+ Bluefin.Internal.Examples: [applicationState] :: Application (e :: Effects) -> State (Int, Bool) e

- Bluefin.Internal.Examples: [askLRImpl] :: DynamicReader r e -> forall e'. Eff (e' :& e) r

+ Bluefin.Internal.Examples: [askLRImpl] :: DynamicReader r (e :: Effects) -> forall (e' :: Effects). () => Eff (e' :& e) r

- Bluefin.Internal.Examples: [counter6State] :: Counter6 e -> State Int e

+ Bluefin.Internal.Examples: [counter6State] :: Counter6 (e :: Effects) -> State Int e

- Bluefin.Internal.Examples: [counter6Stream] :: Counter6 e -> Stream String e

+ Bluefin.Internal.Examples: [counter6Stream] :: Counter6 (e :: Effects) -> Stream String e

- Bluefin.Internal.Examples: [counter7State] :: Counter7 e -> State Int e

+ Bluefin.Internal.Examples: [counter7State] :: Counter7 (e :: Effects) -> State Int e

- Bluefin.Internal.Examples: [counter7Stream] :: Counter7 e -> Stream String e

+ Bluefin.Internal.Examples: [counter7Stream] :: Counter7 (e :: Effects) -> Stream String e

- Bluefin.Internal.Examples: [getCounter5Impl] :: Counter5 e -> forall e'. String -> Eff (e' :& e) Int

+ Bluefin.Internal.Examples: [getCounter5Impl] :: Counter5 (e :: Effects) -> forall (e' :: Effects). () => String -> Eff (e' :& e) Int

- Bluefin.Internal.Examples: [incCounter5Impl] :: Counter5 e -> forall e'. Eff (e' :& e) ()

+ Bluefin.Internal.Examples: [incCounter5Impl] :: Counter5 (e :: Effects) -> forall (e' :: Effects). () => Eff (e' :& e) ()

- Bluefin.Internal.Examples: [incCounter6Impl] :: Counter6 e -> forall e'. Eff (e' :& e) ()

+ Bluefin.Internal.Examples: [incCounter6Impl] :: Counter6 (e :: Effects) -> forall (e' :: Effects). () => Eff (e' :& e) ()

- Bluefin.Internal.Examples: [incCounter7Impl] :: Counter7 e -> forall e'. Exception () e' -> Eff (e' :& e) ()

+ Bluefin.Internal.Examples: [incCounter7Impl] :: Counter7 (e :: Effects) -> forall (e' :: Effects). () => Exception () e' -> Eff (e' :& e) ()

- Bluefin.Internal.Examples: [localLRImpl] :: DynamicReader r e -> forall e' a. (r -> r) -> Eff e' a -> Eff (e' :& e) a

+ Bluefin.Internal.Examples: [localLRImpl] :: DynamicReader r (e :: Effects) -> forall (e' :: Effects) a. () => (r -> r) -> Eff e' a -> Eff (e' :& e) a

- Bluefin.Internal.Examples: [logger] :: Application e -> Stream String e

+ Bluefin.Internal.Examples: [logger] :: Application (e :: Effects) -> Stream String e

- Bluefin.Internal.Examples: [queryDatabase] :: Application e -> forall e'. String -> Int -> Eff (e' :& e) [String]

+ Bluefin.Internal.Examples: [queryDatabase] :: Application (e :: Effects) -> forall (e' :: Effects). () => String -> Int -> Eff (e' :& e) [String]

- Bluefin.Internal.Examples: [readFileImpl] :: FileSystem es -> forall e. FilePath -> Eff (e :& es) String

+ Bluefin.Internal.Examples: [readFileImpl] :: FileSystem (es :: Effects) -> forall (e :: Effects). () => FilePath -> Eff (e :& es) String

- Bluefin.Internal.Examples: [writeFileImpl] :: FileSystem es -> forall e. FilePath -> String -> Eff (e :& es) ()

+ Bluefin.Internal.Examples: [writeFileImpl] :: FileSystem (es :: Effects) -> forall (e :: Effects). () => FilePath -> String -> Eff (e :& es) ()

- Bluefin.Internal.Examples: action :: e :> es => FileSystem e -> Eff es String

+ Bluefin.Internal.Examples: action :: forall (e :: Effects) (es :: Effects). e :> es => FileSystem e -> Eff es String

- Bluefin.Internal.Examples: askLR :: e :> es => DynamicReader r e -> Eff es r

+ Bluefin.Internal.Examples: askLR :: forall (e :: Effects) (es :: Effects) r. e :> es => DynamicReader r e -> Eff es r

- Bluefin.Internal.Examples: awaitList :: e :> es => [a] -> IOE e -> (forall e1. Consume a e1 -> Eff (e1 :& es) ()) -> Eff es ()

+ Bluefin.Internal.Examples: awaitList :: forall (e :: Effects) (es :: Effects) a. e :> es => [a] -> IOE e -> (forall (e1 :: Effects). () => Consume a e1 -> Eff (e1 :& es) ()) -> Eff es ()

- Bluefin.Internal.Examples: awaitUsage :: (e1 :> es, e2 :> es) => IOE e1 -> (forall e. Consume () e -> Eff (e :& es) ()) -> Consume Int e2 -> Eff es ()

+ Bluefin.Internal.Examples: 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 ()

- Bluefin.Internal.Examples: data Application e

+ Bluefin.Internal.Examples: data Application (e :: Effects)

- Bluefin.Internal.Examples: data Counter2 e1 e2

+ Bluefin.Internal.Examples: data Counter2 (e1 :: Effects) (e2 :: Effects)

- Bluefin.Internal.Examples: data Counter3 e

+ Bluefin.Internal.Examples: data Counter3 (e :: Effects)

- Bluefin.Internal.Examples: data Counter4 e

+ Bluefin.Internal.Examples: data Counter4 (e :: Effects)

- Bluefin.Internal.Examples: data Counter5 e

+ Bluefin.Internal.Examples: data Counter5 (e :: Effects)

- Bluefin.Internal.Examples: data Counter6 e

+ Bluefin.Internal.Examples: data Counter6 (e :: Effects)

- Bluefin.Internal.Examples: data Counter7 e

+ Bluefin.Internal.Examples: data Counter7 (e :: Effects)

- Bluefin.Internal.Examples: data DynamicReader r e

+ Bluefin.Internal.Examples: data DynamicReader r (e :: Effects)

- Bluefin.Internal.Examples: data FileSystem es

+ Bluefin.Internal.Examples: data FileSystem (es :: Effects)

- Bluefin.Internal.Examples: doubleNestedForEach :: (forall e. Stream () e -> Eff (e :& es) ()) -> Eff es ()

+ Bluefin.Internal.Examples: doubleNestedForEach :: forall (es :: Effects). (forall (e :: Effects). () => Stream () e -> Eff (e :& es) ()) -> Eff es ()

- Bluefin.Internal.Examples: getCounter4 :: e :> es => Counter4 e -> String -> Eff es Int

+ Bluefin.Internal.Examples: getCounter4 :: forall (e :: Effects) (es :: Effects). e :> es => Counter4 e -> String -> Eff es Int

- Bluefin.Internal.Examples: getCounter5 :: e :> es => Counter5 e -> String -> Eff es Int

+ Bluefin.Internal.Examples: getCounter5 :: forall (e :: Effects) (es :: Effects). e :> es => Counter5 e -> String -> Eff es Int

- Bluefin.Internal.Examples: getCounter6 :: e :> es => Counter6 e -> String -> Eff es Int

+ Bluefin.Internal.Examples: getCounter6 :: forall (e :: Effects) (es :: Effects). e :> es => Counter6 e -> String -> Eff es Int

- Bluefin.Internal.Examples: getCounter7 :: e :> es => Counter7 e -> String -> Eff es Int

+ Bluefin.Internal.Examples: getCounter7 :: forall (e :: Effects) (es :: Effects). e :> es => Counter7 e -> String -> Eff es Int

- Bluefin.Internal.Examples: incCounter1 :: e :> es => Counter1 e -> Eff es ()

+ Bluefin.Internal.Examples: incCounter1 :: forall (e :: Effects) (es :: Effects). e :> es => Counter1 e -> Eff es ()

- Bluefin.Internal.Examples: incCounter2 :: (e1 :> es, e2 :> es) => Counter2 e1 e2 -> Eff es ()

+ Bluefin.Internal.Examples: incCounter2 :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects). (e1 :> es, e2 :> es) => Counter2 e1 e2 -> Eff es ()

- Bluefin.Internal.Examples: incCounter3 :: e :> es => Counter3 e -> Eff es ()

+ Bluefin.Internal.Examples: incCounter3 :: forall (e :: Effects) (es :: Effects). e :> es => Counter3 e -> Eff es ()

- Bluefin.Internal.Examples: incCounter3B :: e :> es => Counter3B e -> Eff es ()

+ Bluefin.Internal.Examples: incCounter3B :: forall (e :: Effects) (es :: Effects). e :> es => Counter3B e -> Eff es ()

- Bluefin.Internal.Examples: incCounter4 :: e :> es => Counter4 e -> Eff es ()

+ Bluefin.Internal.Examples: incCounter4 :: forall (e :: Effects) (es :: Effects). e :> es => Counter4 e -> Eff es ()

- Bluefin.Internal.Examples: incCounter5 :: e :> es => Counter5 e -> Eff es ()

+ Bluefin.Internal.Examples: incCounter5 :: forall (e :: Effects) (es :: Effects). e :> es => Counter5 e -> Eff es ()

- Bluefin.Internal.Examples: incCounter6 :: e :> es => Counter6 e -> Eff es ()

+ Bluefin.Internal.Examples: incCounter6 :: forall (e :: Effects) (es :: Effects). e :> es => Counter6 e -> Eff es ()

- Bluefin.Internal.Examples: incCounter7 :: (e :> es, e1 :> es) => Counter7 e -> Exception () e1 -> Eff es ()

+ Bluefin.Internal.Examples: incCounter7 :: forall (e :: Effects) (es :: Effects) (e1 :: Effects). (e :> es, e1 :> es) => Counter7 e -> Exception () e1 -> Eff es ()

- Bluefin.Internal.Examples: incrementReadLine :: (e1 :> es, e2 :> es, e3 :> es) => State Int e1 -> Exception String e2 -> IOE e3 -> Eff es ()

+ Bluefin.Internal.Examples: incrementReadLine :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) (e3 :: Effects). (e1 :> es, e2 :> es, e3 :> es) => State Int e1 -> Exception String e2 -> IOE e3 -> Eff es ()

- Bluefin.Internal.Examples: localLR :: e :> es => DynamicReader r e -> (r -> r) -> Eff es a -> Eff es a

+ Bluefin.Internal.Examples: localLR :: forall (e :: Effects) (es :: Effects) r a. e :> es => DynamicReader r e -> (r -> r) -> Eff es a -> Eff es a

- Bluefin.Internal.Examples: mapRec :: e :> es => (a -> b) -> (forall e1. Consume b e1 -> Eff (e1 :& es) ()) -> Consume a e -> Eff es ()

+ Bluefin.Internal.Examples: 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 ()

- Bluefin.Internal.Examples: myBail :: e :> es => MyHandle e -> Eff es r

+ Bluefin.Internal.Examples: myBail :: forall (e :: Effects) (es :: Effects) r. e :> es => MyHandle e -> Eff es r

- Bluefin.Internal.Examples: myInc :: e :> es => MyHandle e -> Eff es ()

+ Bluefin.Internal.Examples: myInc :: forall (e :: Effects) (es :: Effects). e :> es => MyHandle e -> Eff es ()

- Bluefin.Internal.Examples: newtype Counter1 e

+ Bluefin.Internal.Examples: newtype Counter1 (e :: Effects)

- Bluefin.Internal.Examples: newtype Counter3B e

+ Bluefin.Internal.Examples: newtype Counter3B (e :: Effects)

- Bluefin.Internal.Examples: polymorphicBracket :: st :> es => State (Integer, Bool) st -> Eff es () -> Eff es ()

+ Bluefin.Internal.Examples: polymorphicBracket :: forall (st :: Effects) (es :: Effects). st :> es => State (Integer, Bool) st -> Eff es () -> Eff es ()

- Bluefin.Internal.Examples: readFile :: e :> es => FileSystem e -> FilePath -> Eff es String

+ Bluefin.Internal.Examples: readFile :: forall (e :: Effects) (es :: Effects). e :> es => FileSystem e -> FilePath -> Eff es String

- Bluefin.Internal.Examples: runCounter1 :: (forall e. Counter1 e -> Eff (e :& es) r) -> Eff es Int

+ Bluefin.Internal.Examples: runCounter1 :: forall (es :: Effects) r. (forall (e :: Effects). () => Counter1 e -> Eff (e :& es) r) -> Eff es Int

- Bluefin.Internal.Examples: runCounter2 :: (forall e1 e2. Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) r) -> Eff es Int

+ Bluefin.Internal.Examples: runCounter2 :: forall (es :: Effects) r. (forall (e1 :: Effects) (e2 :: Effects). () => Counter2 e1 e2 -> Eff (e2 :& (e1 :& es)) r) -> Eff es Int

- Bluefin.Internal.Examples: runCounter3 :: (forall e. Counter3 e -> Eff (e :& es) r) -> Eff es Int

+ Bluefin.Internal.Examples: runCounter3 :: forall (es :: Effects) r. (forall (e :: Effects). () => Counter3 e -> Eff (e :& es) r) -> Eff es Int

- Bluefin.Internal.Examples: runCounter3B :: e1 :> es => IOE e1 -> (forall e. Counter3B e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal.Examples: runCounter3B :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => IOE e1 -> (forall (e :: Effects). () => Counter3B e -> Eff (e :& es) r) -> Eff es r

- Bluefin.Internal.Examples: runCounter4 :: e1 :> es => Stream String e1 -> (forall e. Counter4 e -> Eff (e :& es) r) -> Eff es Int

+ Bluefin.Internal.Examples: runCounter4 :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => Stream String e1 -> (forall (e :: Effects). () => Counter4 e -> Eff (e :& es) r) -> Eff es Int

- Bluefin.Internal.Examples: runCounter5 :: e1 :> es => Stream String e1 -> (forall e. Counter5 e -> Eff (e :& es) r) -> Eff es Int

+ Bluefin.Internal.Examples: runCounter5 :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => Stream String e1 -> (forall (e :: Effects). () => Counter5 e -> Eff (e :& es) r) -> Eff es Int

- Bluefin.Internal.Examples: runCounter6 :: e1 :> es => Stream String e1 -> (forall e. Counter6 e -> Eff (e :& es) r) -> Eff es Int

+ Bluefin.Internal.Examples: runCounter6 :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => Stream String e1 -> (forall (e :: Effects). () => Counter6 e -> Eff (e :& es) r) -> Eff es Int

- Bluefin.Internal.Examples: runCounter7 :: e1 :> es => Stream String e1 -> (forall e. Counter7 e -> Eff (e :& es) r) -> Eff es Int

+ Bluefin.Internal.Examples: runCounter7 :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => Stream String e1 -> (forall (e :: Effects). () => Counter7 e -> Eff (e :& es) r) -> Eff es Int

- Bluefin.Internal.Examples: runDynamicReader :: r -> (forall e. DynamicReader r e -> Eff (e :& es) a) -> Eff es a

+ Bluefin.Internal.Examples: runDynamicReader :: forall r (es :: Effects) a. r -> (forall (e :: Effects). () => DynamicReader r e -> Eff (e :& es) a) -> Eff es a

- Bluefin.Internal.Examples: 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

+ Bluefin.Internal.Examples: runFileSystemIO :: forall (e1 :: Effects) (e2 :: Effects) (es :: Effects) r. (e1 :> es, e2 :> es) => Exception String e1 -> IOE e2 -> (forall (e :: Effects). () => FileSystem e -> Eff (e :& es) r) -> Eff es r

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

+ Bluefin.Internal.Examples: runFileSystemPure :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => Exception String e1 -> [(FilePath, String)] -> (forall (e2 :: Effects). () => FileSystem e2 -> Eff (e2 :& es) r) -> Eff es r

- Bluefin.Internal.Examples: runMyHandle :: (forall e. MyHandle e -> Eff (e :& es) a) -> Eff es (Either String (a, Int))

+ Bluefin.Internal.Examples: runMyHandle :: forall (es :: Effects) a. (forall (e :: Effects). () => MyHandle e -> Eff (e :& es) a) -> Eff es (Either String (a, Int))

- Bluefin.Internal.Examples: takeRec :: e3 :> es => Int -> (forall e. Consume a e -> Eff (e :& es) ()) -> Consume a e3 -> Eff es ()

+ Bluefin.Internal.Examples: takeRec :: forall (e3 :: Effects) (es :: Effects) a. e3 :> es => Int -> (forall (e :: Effects). () => Consume a e -> Eff (e :& es) ()) -> Consume a e3 -> Eff es ()

- Bluefin.Internal.Examples: traverseRec :: e :> es => (a -> Eff es b) -> (forall e1. Consume b e1 -> Eff (e1 :& es) ()) -> Consume a e -> Eff es ()

+ Bluefin.Internal.Examples: 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 ()

- Bluefin.Internal.Examples: type MyHandle = Compound (State Int) (Exception String)

+ Bluefin.Internal.Examples: type MyHandle = Compound State Int Exception String

- Bluefin.Internal.Examples: while :: Eff es Bool -> Eff es a -> Eff es ()

+ Bluefin.Internal.Examples: while :: forall (es :: Effects) a. Eff es Bool -> Eff es a -> Eff es ()

- Bluefin.Internal.Examples: writeFile :: e :> es => FileSystem e -> FilePath -> String -> Eff es ()

+ Bluefin.Internal.Examples: writeFile :: forall (e :: Effects) (es :: Effects). e :> es => FileSystem e -> FilePath -> String -> Eff es ()

- Bluefin.Internal.Exception.Scoped: data Exception (e :: Type)

+ Bluefin.Internal.Exception.Scoped: data Exception e

- Bluefin.Internal.Key: eqKey :: forall a b. Key a -> Key b -> Maybe (a :~~: b)

+ Bluefin.Internal.Key: eqKey :: forall {k1} {k2} (a :: k1) (b :: k2). Key a -> Key b -> Maybe (a :~~: b)

- Bluefin.Internal.Key: newKey :: IO (Key a)

+ Bluefin.Internal.Key: newKey :: forall {k} (a :: k). IO (Key a)

- Bluefin.Internal.Pipes: (<-<) :: e1 :> es => (forall e. Proxy () b c' c e -> Eff (e :& es) r) -> (forall e. Proxy a' a () b e -> Eff (e :& es) r) -> Proxy a' a c' c e1 -> Eff es r

+ Bluefin.Internal.Pipes: (<-<) :: forall (e1 :: Effects) (es :: Effects) b c' c r a' a. e1 :> es => (forall (e :: Effects). () => Proxy () b c' c e -> Eff (e :& es) r) -> (forall (e :: Effects). () => Proxy a' a () b e -> Eff (e :& es) r) -> Proxy a' a c' c e1 -> Eff es r

- Bluefin.Internal.Pipes: (<~) :: e1 :> es => (b -> forall e. Proxy x' x c' c e -> Eff (e :& es) b') -> (a -> forall e. Proxy x' x b' b e -> Eff (e :& es) a') -> a -> Proxy x' x c' c e1 -> Eff es a'

+ Bluefin.Internal.Pipes: (<~) :: forall (e1 :: Effects) (es :: Effects) b x' x c' c b' a a'. e1 :> es => (b -> forall (e :: Effects). () => Proxy x' x c' c e -> Eff (e :& es) b') -> (a -> forall (e :: Effects). () => Proxy x' x b' b e -> Eff (e :& es) a') -> a -> Proxy x' x c' c e1 -> Eff es a'

- Bluefin.Internal.Pipes: (>->) :: e1 :> es => (forall e. Proxy a' a () b e -> Eff (e :& es) r) -> (forall e. Proxy () b c' c e -> Eff (e :& es) r) -> Proxy a' a c' c e1 -> Eff es r

+ Bluefin.Internal.Pipes: (>->) :: 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

- Bluefin.Internal.Pipes: (>~) :: e1 :> es => (forall e. Proxy a' a y' y e -> Eff (e :& es) b) -> (forall e. Proxy () b y' y e -> Eff (e :& es) c) -> Proxy a' a y' y e1 -> Eff es c

+ Bluefin.Internal.Pipes: (>~) :: forall (e1 :: Effects) (es :: Effects) a' a y' y b c. e1 :> es => (forall (e :: Effects). () => Proxy a' a y' y e -> Eff (e :& es) b) -> (forall (e :: Effects). () => Proxy () b y' y e -> Eff (e :& es) c) -> Proxy a' a y' y e1 -> Eff es c

- Bluefin.Internal.Pipes: (~<) :: e1 :> es => (forall e. Proxy () b y' y e -> Eff (e :& es) c) -> (forall e. Proxy a' a y' y e -> Eff (e :& es) b) -> Proxy a' a y' y e1 -> Eff es c

+ Bluefin.Internal.Pipes: (~<) :: forall (e1 :: Effects) (es :: Effects) b y' y c a' a. e1 :> es => (forall (e :: Effects). () => Proxy () b y' y e -> Eff (e :& es) c) -> (forall (e :: Effects). () => Proxy a' a y' y e -> Eff (e :& es) b) -> Proxy a' a y' y e1 -> Eff es c

- Bluefin.Internal.Pipes: (~>) :: e1 :> es => (a -> forall e. Proxy x' x b' b e -> Eff (e :& es) a') -> (b -> forall e. Proxy x' x c' c e -> Eff (e :& es) b') -> a -> Proxy x' x c' c e1 -> Eff es a'

+ Bluefin.Internal.Pipes: (~>) :: forall (e1 :: Effects) (es :: Effects) a x' x b' b a' c' c. e1 :> es => (a -> forall (e :: Effects). () => Proxy x' x b' b e -> Eff (e :& es) a') -> (b -> forall (e :: Effects). () => Proxy x' x c' c e -> Eff (e :& es) b') -> a -> Proxy x' x c' c e1 -> Eff es a'

- Bluefin.Internal.Pipes: MkProxy :: Coroutine a' a e -> Coroutine b b' e -> Proxy a' a b' b e

+ Bluefin.Internal.Pipes: MkProxy :: Coroutine a' a e -> Coroutine b b' e -> Proxy a' a b' b (e :: Effects)

- Bluefin.Internal.Pipes: await :: e :> es => Proxy () a y' y e -> Eff es a

+ Bluefin.Internal.Pipes: await :: forall (e :: Effects) (es :: Effects) a y' y. e :> es => Proxy () a y' y e -> Eff es a

- Bluefin.Internal.Pipes: cat :: Pipe a a e -> Eff (e :& es) r

+ Bluefin.Internal.Pipes: cat :: forall a (e :: Effects) (es :: Effects) r. Pipe a a e -> Eff (e :& es) r

- Bluefin.Internal.Pipes: data Proxy a' a b' b e

+ Bluefin.Internal.Pipes: data Proxy a' a b' b (e :: Effects)

- Bluefin.Internal.Pipes: drain :: e :> es => Proxy () b c' c e -> Eff es r

+ Bluefin.Internal.Pipes: drain :: forall (e :: Effects) (es :: Effects) b c' c r. e :> es => Proxy () b c' c e -> Eff es r

- Bluefin.Internal.Pipes: each :: Foldable f => f a -> Proxy x' x () a e -> Eff (e :& es) ()

+ Bluefin.Internal.Pipes: each :: forall f a x' x (e :: Effects) (es :: Effects). Foldable f => f a -> Proxy x' x () a e -> Eff (e :& es) ()

- Bluefin.Internal.Pipes: for :: e1 :> es => (forall e. Proxy x' x b' b e -> Eff (e :& es) a') -> (b -> forall e. Proxy x' x c' c e -> Eff (e :& es) b') -> Proxy x' x c' c e1 -> Eff es a'

+ Bluefin.Internal.Pipes: for :: forall (e1 :: Effects) (es :: Effects) x' x b' b a' c' c. e1 :> es => (forall (e :: Effects). () => Proxy x' x b' b e -> Eff (e :& es) a') -> (b -> forall (e :: Effects). () => Proxy x' x c' c e -> Eff (e :& es) b') -> Proxy x' x c' c e1 -> Eff es a'

- Bluefin.Internal.Pipes: map :: e :> es => (a -> b) -> Pipe a b e -> Eff es r

+ Bluefin.Internal.Pipes: map :: forall (e :: Effects) (es :: Effects) a b r. e :> es => (a -> b) -> Pipe a b e -> Eff es r

- Bluefin.Internal.Pipes: mapM :: e :> es => (a -> Eff es b) -> Pipe a b e -> Eff es r

+ Bluefin.Internal.Pipes: mapM :: forall (e :: Effects) (es :: Effects) a b r. e :> es => (a -> Eff es b) -> Pipe a b e -> Eff es r

- Bluefin.Internal.Pipes: mapM_ :: e :> es => (a -> Eff es ()) -> Proxy () a b b' e -> Eff es r

+ Bluefin.Internal.Pipes: mapM_ :: forall (e :: Effects) (es :: Effects) a b b' r. e :> es => (a -> Eff es ()) -> Proxy () a b b' e -> Eff es r

- Bluefin.Internal.Pipes: print :: (e2 :> es, e1 :> es, Show a) => IOE e1 -> Consumer a e2 -> Eff es r

+ Bluefin.Internal.Pipes: print :: forall (e2 :: Effects) (es :: Effects) (e1 :: Effects) a r. (e2 :> es, e1 :> es, Show a) => IOE e1 -> Consumer a e2 -> Eff es r

- Bluefin.Internal.Pipes: repeatM :: e :> es => Eff es a -> Proxy x' x () a e -> Eff es r

+ Bluefin.Internal.Pipes: repeatM :: forall (e :: Effects) (es :: Effects) a x' x r. e :> es => Eff es a -> Proxy x' x () a e -> Eff es r

- Bluefin.Internal.Pipes: replicateM :: e :> es => Int -> Eff es a -> Proxy x' x () a e -> Eff es ()

+ Bluefin.Internal.Pipes: replicateM :: forall (e :: Effects) (es :: Effects) a x' x. e :> es => Int -> Eff es a -> Proxy x' x () a e -> Eff es ()

- Bluefin.Internal.Pipes: reverseProxy :: Proxy a' a b' b e -> Proxy b b' a a' e

+ Bluefin.Internal.Pipes: reverseProxy :: forall a' a b' b (e :: Effects). Proxy a' a b' b e -> Proxy b b' a a' e

- Bluefin.Internal.Pipes: runEffect :: (forall e. Effect e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal.Pipes: runEffect :: forall (es :: Effects) r. (forall (e :: Effects). () => Effect e -> Eff (e :& es) r) -> Eff es r

- Bluefin.Internal.Pipes: stdinLn :: (e1 :> es, e2 :> es) => IOE e1 -> Producer String e2 -> Eff es r

+ Bluefin.Internal.Pipes: stdinLn :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) r. (e1 :> es, e2 :> es) => IOE e1 -> Producer String e2 -> Eff es r

- Bluefin.Internal.Pipes: stdoutLn :: (e1 :> es, e2 :> es) => IOE e1 -> Consumer String e2 -> Eff es r

+ Bluefin.Internal.Pipes: stdoutLn :: forall (e1 :: Effects) (es :: Effects) (e2 :: Effects) r. (e1 :> es, e2 :> es) => IOE e1 -> Consumer String e2 -> Eff es r

- Bluefin.Internal.Pipes: takeWhile' :: e :> es => (r -> Bool) -> Pipe r r e -> Eff es r

+ Bluefin.Internal.Pipes: takeWhile' :: forall (e :: Effects) (es :: Effects) r. e :> es => (r -> Bool) -> Pipe r r e -> Eff es r

- Bluefin.Internal.Pipes: unfoldr :: e :> es => (s -> Eff es (Either r (a, s))) -> s -> Proxy x1 x () a e -> Eff es r

+ Bluefin.Internal.Pipes: unfoldr :: forall (e :: Effects) (es :: Effects) s r a x1 x. e :> es => (s -> Eff es (Either r (a, s))) -> s -> Proxy x1 x () a e -> Eff es r

- Bluefin.Internal.Pipes: yield :: e :> es => Proxy x1 x () a e -> a -> Eff es ()

+ Bluefin.Internal.Pipes: yield :: forall (e :: Effects) (es :: Effects) x1 x a. e :> es => Proxy x1 x () a e -> a -> Eff es ()

- Bluefin.Internal.System.IO: UnsafeMkHandle :: Handle -> IOE e -> Handle e

+ Bluefin.Internal.System.IO: UnsafeMkHandle :: Handle -> IOE e -> Handle (e :: Effects)

- Bluefin.Internal.System.IO: data Handle e

+ Bluefin.Internal.System.IO: data Handle (e :: Effects)

- Bluefin.Internal.System.IO: data () => IOMode

+ Bluefin.Internal.System.IO: data IOMode

- Bluefin.Internal.System.IO: hFlush :: e :> es => Handle e -> Eff es ()

+ Bluefin.Internal.System.IO: hFlush :: forall (e :: Effects) (es :: Effects). e :> es => Handle e -> Eff es ()

- Bluefin.Internal.System.IO: hGetLine :: e :> es => Handle e -> Eff es String

+ Bluefin.Internal.System.IO: hGetLine :: forall (e :: Effects) (es :: Effects). e :> es => Handle e -> Eff es String

- Bluefin.Internal.System.IO: hIsEOF :: e :> es => Handle e -> Eff es Bool

+ Bluefin.Internal.System.IO: hIsEOF :: forall (e :: Effects) (es :: Effects). e :> es => Handle e -> Eff es Bool

- Bluefin.Internal.System.IO: hPutChar :: e :> es => Handle e -> Char -> Eff es ()

+ Bluefin.Internal.System.IO: hPutChar :: forall (e :: Effects) (es :: Effects). e :> es => Handle e -> Char -> Eff es ()

- Bluefin.Internal.System.IO: hPutStr :: e :> es => Handle e -> String -> Eff es ()

+ Bluefin.Internal.System.IO: hPutStr :: forall (e :: Effects) (es :: Effects). e :> es => Handle e -> String -> Eff es ()

- Bluefin.Internal.System.IO: hPutStrLn :: e :> es => Handle e -> String -> Eff es ()

+ Bluefin.Internal.System.IO: hPutStrLn :: forall (e :: Effects) (es :: Effects). e :> es => Handle e -> String -> Eff es ()

- Bluefin.Internal.System.IO: unsafeWithHandle :: e1 :> es => Handle e1 -> (Handle -> IO r) -> Eff es r

+ Bluefin.Internal.System.IO: unsafeWithHandle :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => Handle e1 -> (Handle -> IO r) -> Eff es r

- Bluefin.Internal.System.IO: withFile :: e1 :> es => IOE e1 -> FilePath -> IOMode -> (forall e. Handle e -> Eff (e :& es) r) -> Eff es r

+ Bluefin.Internal.System.IO: withFile :: forall (e1 :: Effects) (es :: Effects) r. e1 :> es => IOE e1 -> FilePath -> IOMode -> (forall (e :: Effects). () => Handle e -> Eff (e :& es) r) -> Eff es r

Files

CHANGELOG.md +11/−0
bluefin-internal.cabal +1/−1
src/Bluefin/Internal.hs +1/−1

CHANGELOG.md view

@@ -1,5 +1,13 @@+## 0.1.2.0++* Fix strictness of `Bluefin.State.put`. It was accidentally made lazy+  in 0.1.0.0.+ ## 0.1.1.0 +* WARNING: `Bluefin.State.put` is still lazy in this version.  It is+  fixed in 0.1.2.0.+ * Added `streamConsume`, `cycleToStream`, `takeConsume` (thanks to   @iteratee) @@ -8,6 +16,9 @@   `Bluefin.Internal.ConstEffect` to `Effects`  ## 0.1.0.0++* WARNING: `Bluefin.State.put` accidentally became lazy in this+  version.  It is fixed in 0.1.2.0.  * Implement `Exception` using `Eff` not naked `IO`

bluefin-internal.cabal view

@@ -1,6 +1,6 @@ cabal-version:      3.0 name:               bluefin-internal-version:            0.1.1.0+version:            0.1.2.0 license:            MIT license-file:       LICENSE author:             Tom Ellis

src/Bluefin/Internal.hs view

@@ -660,7 +660,7 @@   -- writing it to the state.   s ->   Eff es ()-put st s = unsafeProvideIO $ \io -> withStateInIO io st (flip writeIORef s)+put st s = unsafeProvideIO $ \io -> withStateInIO io st (flip writeIORef $! s)  -- | -- @