bluefin-internal 0.9.2.0 → 0.10.0.0

raw patch · 8 files changed

+165/−461 lines, 8 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• CHANGELOG.md +15/−0
• bluefin-internal.cabal +1/−2
• src/Bluefin/Internal.hs +112/−142
• src/Bluefin/Internal/CloneableHandle.hs +18/−18
• src/Bluefin/Internal/Exception.hs +2/−2
• src/Bluefin/Internal/GadtEffect.hs +5/−5
• src/Bluefin/Internal/Pipes.hs +0/−285
• src/Bluefin/Internal/Prim.hs +12/−7

@@ -1,3 +1,18 @@+# 0.10.0.0++* Make `Ask`, `AskCapability`, `Await`, `JumpTo`, `Modify`, `Request`,+  `ReturnEarly`, `Tell`, `Throw`, and `Yield` the canonical capability+  types; `Reader`, `HandleReader`, `Consume`, `Jump`, `State`, `Coroutine`,+  `EarlyReturn`, `Writer`, `Exception`, and `Stream` are now type synonyms.++* Move `Bluefin.Internal.Pipes` to `bluefin-examples`++* Remove unused failing stubs `connect` and `head'` from+  `Bluefin.Internal`++* Breaking change: separate `Prim`'s primitive state and capability+  scope type parameters+ # 0.9.2.0  * Bug fix: release `Reader` Vault keys when their handler scope exits.

@@ -1,6 +1,6 @@ cabal-version:      3.0 name:               bluefin-internal-version:            0.9.2.0+version:            0.10.0.0 license:            MIT license-file:       LICENSE author:             Tom Ellis@@ -96,7 +96,6 @@       Bluefin.Internal.GadtEffect,       Bluefin.Internal.Key,       Bluefin.Internal.OneWayCoercible,-      Bluefin.Internal.Pipes,       Bluefin.Internal.Prim,       Bluefin.Internal.System.IO,       Bluefin.Internal.Vault

@@ -226,7 +226,7 @@   liftBaseWith = withRunInIO   restoreM = pure -instance (e <: es) => MonadFail (EffReader (Exception String e) es) where+instance (e <: es) => MonadFail (EffReader (Throw String e) es) where   fail = MkEffReader . flip throw  hoistReader ::@@ -267,8 +267,8 @@ -- `Either String` and then applying `either (throw f) pure`. withMonadFail ::   (e <: es) =>-  -- | @Exception@ to @throw@ on @fail@-  Exception String e ->+  -- | @Throw@ to @throw@ on @fail@+  Throw String e ->   -- | 'MonadFail' operation   (forall m. (MonadFail m) => m r) ->   -- | @MonadFail@ operation run in @Eff@@@ -346,41 +346,41 @@ type role StateSource nominal  -- | Capability to throw an exception of type @exn@-newtype Exception exn (e :: Effects)+newtype Throw exn (e :: Effects)   = MkException (forall a. exn -> Eff e a)-  deriving (Handle) via OneWayCoercibleHandle (Exception exn)+  deriving (Handle) via OneWayCoercibleHandle (Throw exn) -type role Exception representational nominal+type role Throw representational nominal -instance (e <: es) => OneWayCoercible (Exception ex e) (Exception ex es) where+instance (e <: es) => OneWayCoercible (Throw ex e) (Throw ex es) where   oneWayCoercibleImpl = oneWayCoercible  -- | Capability to modify a reference to an @s@-newtype State s (e :: Effects) = UnsafeMkState (IORef s)-  deriving (Handle) via OneWayCoercibleHandle (State s)+newtype Modify s (e :: Effects) = UnsafeMkState (IORef s)+  deriving (Handle) via OneWayCoercibleHandle (Modify s) -type role State representational nominal+type role Modify representational nominal -instance (e <: es) => OneWayCoercible (State s e) (State s es) where+instance (e <: es) => OneWayCoercible (Modify s e) (Modify s es) where   oneWayCoercibleImpl = oneWayCoercible  -- | Capability to yield a value of type @a@ and then await a value of -- type @b@ in response.-newtype Coroutine a b (e :: Effects) = MkCoroutine (a -> Eff e b)-  deriving (Handle) via OneWayCoercibleHandle (Coroutine a b)+newtype Request a b (e :: Effects) = MkCoroutine (a -> Eff e b)+  deriving (Handle) via OneWayCoercibleHandle (Request a b) -instance (e <: es) => OneWayCoercible (Coroutine a b e) (Coroutine a b es) where+instance (e <: es) => OneWayCoercible (Request a b e) (Request a b es) where   oneWayCoercibleImpl = oneWayCoercible  -- | Capability to yield values of type @a@.  It is implemented as a -- 'Bluefin.Capability.Request' capability that can yield values of -- type @a@ and then await values of type @()@.-type Stream a = Coroutine a ()+type Yield a = Request a () -type Consume a = Coroutine () a+type Await a = Request () a  -- | Every Bluefin capability should have an instance of class @Handle@.--- Built-in capabilities, such as 'Exception', 'State' and 'IOE', come with+-- Built-in capabilities, such as 'Throw', 'Modify' and 'IOE', come with -- @Handle@ instances. -- -- You should define a @Handle@ instance for each capability that you@@ -392,8 +392,8 @@ -- @ -- data Application e = MkApplication --   { queryDatabase :: String -> Int -> Eff e [String],---     applicationState :: State (Int, Bool) e,---     logger :: Stream String e+--     applicationState :: Modify (Int, Bool) e,+--     logger :: Yield String e --   } --   deriving (Generic) --   deriving (Handle) via 'OneWayCoercibleHandle' Application@@ -586,11 +586,11 @@ -- | For defining 'OneWayCoercible' instances for newtypes. Example: -- -- @--- newtype Random g e = Random (State g e)+-- newtype Random g e = Random (Modify g e) --   deriving (Handle) via OneWayCoercibleHandle (Random g) -- -- instance (e \<: es) => OneWayCoercible (Random g e) (Random g es) where---   oneWayCoercibleImpl = oneWayCoercibleNewtypeHandle @(State g)+--   oneWayCoercibleImpl = oneWayCoercibleNewtypeHandle @(Modify g) -- @ oneWayCoercibleNewtypeHandle ::   forall h1 h2 e es.@@ -755,7 +755,7 @@ -- @ throw ::   (e <: es) =>-  Exception ex e ->+  Throw ex e ->   -- | Value to throw   ex ->   Eff es a@@ -785,7 +785,7 @@ -- @ try ::   forall exn (es :: Effects) a.-  (forall e. Exception exn e -> Eff (e :& es) a) ->+  (forall e. Throw exn e -> Eff (e :& es) a) ->   -- | @Left@ if the exception was thrown, @Right@ otherwise   Eff es (Either exn a) try f =@@ -805,7 +805,7 @@   forall exn (es :: Effects) a.   -- | If the exception is thrown, apply this handler   (exn -> Eff es a) ->-  (forall e. Exception exn e -> Eff (e :& es) a) ->+  (forall e. Throw exn e -> Eff (e :& es) a) ->   Eff es a handle h f =   try f >>= \case@@ -815,7 +815,7 @@ -- | 'handle', but with the argument order swapped catch ::   forall exn (es :: Effects) a.-  (forall e. Exception exn e -> Eff (e :& es) a) ->+  (forall e. Throw exn e -> Eff (e :& es) a) ->   -- | If the exception is thrown, apply this handler   (exn -> Eff es a) ->   Eff es a@@ -855,7 +855,7 @@   forall ex es e1 e2 r.   (e1 <: es, e2 <: es, Control.Exception.Exception ex) =>   IOE e1 ->-  Exception ex e2 ->+  Throw ex e2 ->   Eff es r ->   -- | ͘   Eff es r@@ -922,7 +922,7 @@ withStateInIO ::   (e1 <: es, e2 <: es) =>   IOE e1 ->-  State s e2 ->+  Modify s e2 ->   (IORef s -> IO r) ->   Eff es r withStateInIO io (UnsafeMkState r) k = effIO io (k r)@@ -936,7 +936,7 @@ -- @ get ::   (e <: es) =>-  State s e ->+  Modify s e ->   -- | The current value of the state   Eff es s get st = unsafeProvideIO $ \io -> withStateInIO io st readIORef@@ -950,7 +950,7 @@ -- @ put ::   (e <: es) =>-  State s e ->+  Modify s e ->   -- | The new value of the state.  The new value is forced before   -- writing it to the state.   s ->@@ -965,7 +965,7 @@ -- @ modify ::   (e <: es) =>-  State s e ->+  Modify s e ->   -- | Apply this function to the state.  The new value of the state   -- is forced before writing it to the state.   (s -> s) ->@@ -984,10 +984,10 @@ --   n <- 'newState' source 5 --   total <- newState source 0 -----   'withJump' $ \\done -> forever $ do---     n' <- 'Bluefin.State.get' n---     'Bluefin.State.modify' total (+ n')---     when (n' == 0) $ 'Bluefin.Jump.jumpTo' done+--   'withJumpTo' $ \\done -> forever $ do+--     n' <- 'Bluefin.Capability.Modify.get' n+--     'Bluefin.Capability.Modify.modify' total (+ n')+--     when (n' == 0) $ 'Bluefin.Capability.JumpTo.jumpTo' done --     modify n (subtract 1) -- --   get total@@ -1005,10 +1005,10 @@ --   n <- 'newState' source 5 --   total <- newState source 0 -----   'Bluefin.Jump.withJump' $ \\done -> forever $ do---     n' <- 'Bluefin.State.get' n---     'Bluefin.State.modify' total (+ n')---     when (n' == 0) $ 'Bluefin.Jump.jumpTo' done+--   'Bluefin.Capability.JumpTo.withJumpTo' $ \\done -> forever $ do+--     n' <- 'Bluefin.Capability.Modify.get' n+--     'Bluefin.Capability.Modify.modify' total (+ n')+--     when (n' == 0) $ 'Bluefin.Capability.JumpTo.jumpTo' done --     modify n (subtract 1) -- --   get total@@ -1020,7 +1020,7 @@   -- | The initial value for the state capability   s ->   -- | A new state capability-  Eff es (State s e)+  Eff es (Modify s e) newState StateSource s = unsafeProvideIO $ \io -> do   fmap UnsafeMkState (effIO io (newIORef s)) @@ -1035,7 +1035,7 @@   -- | Initial state   s ->   -- | Stateful computation-  (forall e. State s e -> Eff (e :& es) a) ->+  (forall e. Modify s e -> Eff (e :& es) a) ->   -- | Result and final state   Eff es (a, s) runState s f = do@@ -1066,7 +1066,7 @@ -- @ yield ::   (e1 <: es) =>-  Stream a e1 ->+  Yield a e1 ->   -- | Yield this value from the stream   a ->   Eff es ()@@ -1093,7 +1093,7 @@ -- ([0, 0, 1, 10, 2, 20, 3, 30], ()) -- @ forEach ::-  (forall e1. Coroutine a b e1 -> Eff (e1 :& es) r) ->+  (forall e1. Request a b e1 -> Eff (e1 :& es) r) ->   -- | Apply this effectful function for each element of the coroutine   (a -> Eff es b) ->   Eff es r@@ -1127,7 +1127,7 @@   (Foldable t, e1 <: es) =>   -- | Yield all these values from the stream   t a ->-  Stream a e1 ->+  Yield a e1 ->   Eff es () inFoldable t = for_ t . yield @@ -1141,8 +1141,8 @@ enumerate ::   (e2 <: es) =>   -- | ͘-  (forall e1. Stream a e1 -> Eff (e1 :& es) r) ->-  Stream (Int, a) e2 ->+  (forall e1. Yield a e1 -> Eff (e1 :& es) r) ->+  Yield (Int, a) e2 ->   Eff es r enumerate s = enumerateFrom 0 s @@ -1157,8 +1157,8 @@   (e2 <: es) =>   -- | Initial value   Int ->-  (forall e1. Stream a e1 -> Eff (e1 :& es) r) ->-  Stream (Int, a) e2 ->+  (forall e1. Yield a e1 -> Eff (e1 :& es) r) ->+  Yield (Int, a) e2 ->   Eff es r enumerateFrom n ss st =   evalState n $ \i -> forEach (useImplUnder . ss) $ \s -> do@@ -1180,10 +1180,10 @@   Eff es r consumeEach k e = forEach k (\() -> e) -await :: (e <: es) => Consume a e -> Eff es a+await :: (e <: es) => Await a e -> Eff es a await r = yieldCoroutine r () -type EarlyReturn = Exception+type ReturnEarly = Throw  -- | Run an 'Eff' action with the ability to return early to this -- point.  In the language of exceptions, 'withEarlyReturn' installs@@ -1214,7 +1214,7 @@ -- @ returnEarly ::   (e <: es) =>-  EarlyReturn r e ->+  ReturnEarly r e ->   -- | Return early to the handler, with this value.   r ->   Eff es a@@ -1231,7 +1231,7 @@   -- | Initial state   s ->   -- | Stateful computation-  (forall e. State s e -> Eff (e :& es) a) ->+  (forall e. Modify s e -> Eff (e :& es) a) ->   -- | Result   Eff es a evalState s f = fmap fst (runState s f)@@ -1247,7 +1247,7 @@   -- | Initial state   s ->   -- | Stateful computation-  (forall e. State s e -> Eff (e :& es) (s -> a)) ->+  (forall e. Modify s e -> Eff (e :& es) (s -> a)) ->   -- | Result   Eff es a withState s f = do@@ -1300,10 +1300,10 @@   Eff es r withC2 c f = withCompound c (\_ i -> f i) -putC :: forall ss es e. (ss <: es) => Compound e (State Int) ss -> Int -> Eff es ()+putC :: forall ss es e. (ss <: es) => Compound e (Modify Int) ss -> Int -> Eff es () putC c i = withC2 c (\h -> put h i) -getC :: forall ss es e. (ss <: es) => Compound e (State Int) ss -> Eff es Int+getC :: forall ss es e. (ss <: es) => Compound e (Modify Int) ss -> Eff es Int getC c = withC2 c (\h -> get h)  -- TODO: Make this (s1 <: es, s2 <: es), like withC@@ -1327,7 +1327,7 @@ -- ([1,2,100], ()) -- @ yieldToList ::-  (forall e1. Stream a e1 -> Eff (e1 :& es) r) ->+  (forall e1. Yield a e1 -> Eff (e1 :& es) r) ->   -- | Yielded elements and final result   Eff es ([a], r) yieldToList f = do@@ -1350,8 +1350,8 @@ -- 3 -- @ withYieldToList ::-  -- | Stream computation-  (forall e. Stream a e -> Eff (e :& es) ([a] -> r)) ->+  -- | Yield computation+  (forall e. Yield a e -> Eff (e :& es) ([a] -> r)) ->   -- | Result   Eff es r withYieldToList f = do@@ -1370,11 +1370,11 @@ -- ([100,2,1], ()) -- @ yieldToReverseList ::-  (forall e. Stream a e -> Eff (e :& es) r) ->+  (forall e. Yield a e -> Eff (e :& es) r) ->   -- | Yielded elements in reverse order, and final result   Eff es ([a], r) yieldToReverseList f = do-  evalState [] $ \(s :: State lo st) -> do+  evalState [] $ \(s :: Modify lo st) -> do     r <- forEach (useImplUnder . f) $ \i ->       modify s (i :)     as <- get s@@ -1386,8 +1386,8 @@   -- stream for which this function returns @Just@   (a -> Maybe b) ->   -- | Input stream-  (forall e1. Stream a e1 -> Eff (e1 :& es) r) ->-  Stream b e2 ->+  (forall e1. Yield a e1 -> Eff (e1 :& es) r) ->+  Yield b e2 ->   Eff es r mapMaybe f s y = forEach s $ \a -> do   case f a of@@ -1398,8 +1398,8 @@ catMaybes ::   (e2 <: es) =>   -- | Input stream-  (forall e1. Stream (Maybe a) e1 -> Eff (e1 :& es) r) ->-  Stream a e2 ->+  (forall e1. Yield (Maybe a) e1 -> Eff (e1 :& es) r) ->+  Yield a e2 ->   Eff es r catMaybes s y = mapMaybe id s y @@ -1414,7 +1414,7 @@ cycleToStream ::   (Foldable f, e1 <: es) =>   f a ->-  Stream a e1 ->+  Yield a e1 ->   -- | ͘   Eff es () cycleToStream f y = do@@ -1442,7 +1442,7 @@       await source >>= yield sink       loop (c - 1) -type Jump = EarlyReturn ()+type JumpTo = ReturnEarly ()  -- | -- @@@ -1450,10 +1450,10 @@ --   n <- 'newState' source 5 --   total <- newState source 0 -----   'Bluefin.Jump.withJump' $ \\done -> forever $ do---     n' <- 'Bluefin.State.get' n---     'Bluefin.State.modify' total (+ n')---     when (n' == 0) $ 'Bluefin.Jump.jumpTo' done+--   'Bluefin.Capability.JumpTo.withJumpTo' $ \\done -> forever $ do+--     n' <- 'Bluefin.Capability.Modify.get' n+--     'Bluefin.Capability.Modify.modify' total (+ n')+--     when (n' == 0) $ 'Bluefin.Capability.JumpTo.jumpTo' done --     modify n (subtract 1) -- --   get total@@ -1471,10 +1471,10 @@ --   n <- 'newState' source 5 --   total <- newState source 0 -----   'Bluefin.Jump.withJump' $ \\done -> forever $ do---     n' <- 'Bluefin.State.get' n---     'Bluefin.State.modify' total (+ n')---     when (n' == 0) $ 'Bluefin.Jump.jumpTo' done+--   'Bluefin.Capability.JumpTo.withJumpTo' $ \\done -> forever $ do+--     n' <- 'Bluefin.Capability.Modify.get' n+--     'Bluefin.Capability.Modify.modify' total (+ n')+--     when (n' == 0) $ 'Bluefin.Capability.JumpTo.jumpTo' done --     modify n (subtract 1) -- --   get total@@ -1482,12 +1482,12 @@ -- @ jumpTo ::   (e <: es) =>-  Jump e ->+  JumpTo e ->   -- | ͘   Eff es a jumpTo tag = throw tag () -unwrap :: (e <: es) => Jump e -> Maybe a -> Eff es a+unwrap :: (e <: es) => JumpTo e -> Maybe a -> Eff es a unwrap j = \case   Nothing -> jumpTo j   Just a -> pure a@@ -1553,40 +1553,10 @@   Eff es a unsafeProvideIO eff = useImplIn eff MkIOE -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)-    )-connect _ _ = error "connect unimplemented, sorry"--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)-    )-head' c = do-  r <- connect c (\a _ -> pure a) @_ @es-  pure $ case r of-    Right r' -> Right r'-    Left (l, _) -> Left l--newtype Writer w e = Writer (Stream w e)-  deriving (Handle) via OneWayCoercibleHandle (Writer w)+newtype Tell w e = Tell (Yield w e)+  deriving (Handle) via OneWayCoercibleHandle (Tell w) -instance (e <: es) => OneWayCoercible (Writer w e) (Writer w es) where+instance (e <: es) => OneWayCoercible (Tell w e) (Tell w es) where   oneWayCoercibleImpl = oneWayCoercible  -- |@@ -1602,7 +1572,7 @@   (forall e. Writer w e -> Eff (e :& es) r) ->   Eff es (r, w) runWriter f = runState mempty $ \st -> do-  forEach (useImplUnder . f . Writer) $ \ww -> do+  forEach (useImplUnder . f . Tell) $ \ww -> do     modify st (<> ww)  -- |@@ -1635,20 +1605,20 @@ -- @ tell ::   (e <: es) =>-  Writer w e ->+  Tell w e ->   -- | ͘   w ->   Eff es ()-tell (Writer y) = yield y+tell (Tell y) = yield y -type Reader :: Type -> Effects -> Type-newtype Reader r e = MkReader (Vault.Key r)-  deriving (Handle) via OneWayCoercibleHandle (Reader r)+type Ask :: Type -> Effects -> Type+newtype Ask r e = MkReader (Vault.Key r)+  deriving (Handle) via OneWayCoercibleHandle (Ask r) -instance (e <: es) => OneWayCoercible (Reader r e) (Reader r es) where+instance (e <: es) => OneWayCoercible (Ask r e) (Ask r es) where   oneWayCoercibleImpl = oneWayCoercible -type role Reader representational nominal+type role Ask representational nominal  runReader ::   -- | Initial value for @Reader@.@@ -1683,7 +1653,7 @@ ask ::   (e <: es) =>   -- | ͘-  Reader r e ->+  Ask r e ->   Eff es r ask (MkReader k) = UnsafeMkEff $ \vault -> do   v <- readIORef vault@@ -1705,17 +1675,17 @@ -- | Read the value modified by a function asks ::   (e <: es) =>-  Reader r e ->+  Ask r e ->   -- | Read the value modified by this function   (r -> a) ->   Eff es a asks r f = fmap f (ask r) --- | Locally override the value in the @Reader@. It will be restored+-- | Locally override the value in the @Ask@. It will be restored -- when the @local@ block ends. local ::   (e1 <: es) =>-  Reader r e1 ->+  Ask r e1 ->   -- | In the body, the reader value is modified by this function.   (r -> r) ->   -- | Body@@ -1728,8 +1698,8 @@     (\() -> writeIORef vault orig)     (\() -> case k of UnsafeMkEff m -> m env) -newtype HandleReader h e = UnsafeMkHandleReader (Reader (h e) e)-  deriving (Handle) via OneWayCoercibleHandle (HandleReader h)+newtype AskCapability h e = UnsafeMkHandleReader (Ask (h e) e)+  deriving (Handle) via OneWayCoercibleHandle (AskCapability h)  -- In general this is really tremendously unsafe because we could take -- an `HandleReader h e`, map it to `HandleReader h es`, write an `h@@ -1787,14 +1757,14 @@   -- | ͘   Eff es r runHandleReader h k = do-  runReader (mapHandle h) $ \(st :: Reader (h es) e) -> do+  runReader (mapHandle h) $ \(st :: Ask (h es) e) -> do     let oneWayCoerceH :: OneWayCoercion (h es) (h (e :& es))         oneWayCoerceH = oneWayCoercion      let coerceH :: Coercion (h es) (h (e :& es))         coerceH = unsafeCoercionOfOneWayCoercion oneWayCoerceH -    let mapS :: Reader (h es) e' -> Reader (h (e :& es)) e'+    let mapS :: Ask (h es) e' -> Ask (h (e :& es)) e'         mapS = case coerceH of Coercion -> coerce      let h' :: HandleReader h (e :& es)@@ -1804,7 +1774,7 @@      useImplIn k h' -instance (e <: es) => OneWayCoercible (HandleReader h e) (HandleReader h es) where+instance (e <: es) => OneWayCoercible (AskCapability h e) (AskCapability h es) where   oneWayCoercibleImpl = unsafeOneWayCoercible  newtype ConstEffect r (e :: Effects) = MkConstEffect r@@ -1822,33 +1792,33 @@  -- Capbility synonyms -type Ask = Reader+type Reader = Ask -type AskCapability = HandleReader+type HandleReader = AskCapability  -- | Capability to await values of type @a@-type Await a = Consume a+type Consume a = Await a -type JumpTo = Jump+type Jump = JumpTo  -- | Capability to yield a value of type @a@ and then await a value of -- type @b@ in response.-type Request = Coroutine+type Coroutine = Request -type ReturnEarly = EarlyReturn+type EarlyReturn r = ReturnEarly r  -- | Capability to modify a reference to an @s@-type Modify = State+type State = Modify -type Tell = Writer+type Writer = Tell  -- | Capability to throw an exception of type @exn@-type Throw = Exception+type Exception = Throw  -- | Capability to yield values of type @a@.  It is implemented as a -- 'Bluefin.Capability.Request' capability that can yield values of -- type @a@ and then await values of type @()@.-type Yield a = Stream a+type Stream a = Yield a  runAsk ::   -- | Initial value for @Ask@.@@ -1881,7 +1851,7 @@ -- | 'awaitYield' is 'Bluefin.Capability.Request.connectRequests' -- specialized to @Await@ and @Yield@, which is the most common case. awaitYield ::-  -- | Starts running first. Each 'await' from the @Consume@ ...+  -- | Starts running first. Each 'await' from the @Await@ ...   (forall e. Await a e -> Eff (e :& es) r) ->   -- | ... receives the value 'yield'ed from the @Yield@   (forall e. Yield a e -> Eff (e :& es) r) ->@@ -1930,7 +1900,7 @@ -- 42 -- @ ignoreYield ::-  (forall e1. Stream a e1 -> Eff (e1 :& es) r) ->+  (forall e1. Yield a e1 -> Eff (e1 :& es) r) ->   -- | ͘   Eff es r ignoreYield = ignoreStream@@ -1964,7 +1934,7 @@ -- "Returned early with 5" -- @ withReturnEarly ::-  (forall e. EarlyReturn r e -> Eff (e :& es) r) ->+  (forall e. ReturnEarly r e -> Eff (e :& es) r) ->   -- | ͘   Eff es r withReturnEarly = withEarlyReturn@@ -2055,7 +2025,7 @@ runAskCapability ::   (e1 <: es, Handle h) =>   h e1 ->-  (forall e. HandleReader h e -> Eff (e :& es) r) ->+  (forall e. AskCapability h e -> Eff (e :& es) r) ->   -- | ͘   Eff es r runAskCapability = runHandleReader@@ -2064,7 +2034,7 @@ -- a future version.  Use 'asksCapability' instead. askCapability ::   (e <: es, Handle h) =>-  HandleReader h e ->+  AskCapability h e ->   -- | ͘   Eff es (h es) askCapability = askHandle@@ -2092,10 +2062,10 @@ --   n <- 'newState' source 5 --   total <- newState source 0 -----   'Bluefin.JumpTo.withJumpTo' $ \\done -> forever $ do+--   'Bluefin.Capability.JumpTo.withJumpTo' $ \\done -> forever $ do --     n' <- 'Bluefin.Capability.Modify.get' n --     'Bluefin.Capability.Modify.modify' total (+ n')---     when (n' == 0) $ 'Bluefin.JumpTo.jumpTo' done+--     when (n' == 0) $ 'Bluefin.Capability.JumpTo.jumpTo' done --     modify n (subtract 1) -- --   get total

@@ -77,34 +77,34 @@ hcIOE = MkHandleCloner $ \io k -> do   useImplIn k (mapHandle io) --- | Cloning a @State@ copies its contents to a new @State@.  Changes+-- | Cloning a @Modify@ copies its contents to a new @Modify@.  Changes -- to one will not effect the other.-instance CloneableHandle (State s) where+instance CloneableHandle (Modify s) where   cloneableHandleImpl = MkCloneableHandleD hcState -hcState :: HandleCloner (State s) (State s) e+hcState :: HandleCloner (Modify s) (Modify s) e hcState = MkHandleCloner $ \st k -> do   s <- get st   evalState s $ \st' ->     useImplIn k (mapHandle st') -instance CloneableHandle (Exception a) where+instance CloneableHandle (Throw a) where   cloneableHandleImpl = MkCloneableHandleD hcException -hcException :: HandleCloner (Exception ex) (Exception ex) e+hcException :: HandleCloner (Throw ex) (Throw ex) e hcException = MkHandleCloner $ \ex k -> do   useImplIn k (mapHandle ex) -instance CloneableHandle (Reader r) where+instance CloneableHandle (Ask r) where   cloneableHandleImpl = MkCloneableHandleD hcReader -hcReader :: HandleCloner (Reader r) (Reader r) e+hcReader :: HandleCloner (Ask r) (Ask r) e hcReader = MkHandleCloner $ \r k -> do   useImplIn k (mapHandle r) --- | Cloning a @HandleReader@ copies its contents to a new--- @HandleReader@.  Changes to one will not effect the other.-instance (CloneableHandle h) => CloneableHandle (HandleReader h) where+-- | Cloning an @AskCapability@ copies its contents to a new+-- @AskCapability@.  Changes to one will not effect the other.+instance (CloneableHandle h) => CloneableHandle (AskCapability h) where   cloneableHandleImpl = MkCloneableHandleD hcHandleReader  cloneHandleClass ::@@ -115,7 +115,7 @@ cloneHandleClass =   cloneHandle2 (case cloneableHandleImpl of MkCloneableHandleD c' -> c') -hcHandleReader :: (CloneableHandle h) => HandleCloner (HandleReader h) (HandleReader h) e+hcHandleReader :: (CloneableHandle h) => HandleCloner (AskCapability h) (AskCapability h) e hcHandleReader = MkHandleCloner $ \hr k -> do   asksHandle hr $ \h -> do     cloneHandleClass h $ \h' -> do@@ -123,18 +123,18 @@         useImplIn k (mapHandle hr')  instance-  (TypeError (Text "Coroutine cannot be cloned. Perhaps you want an STM channel?")) =>-  CloneableHandle (Coroutine a b)+  (TypeError (Text "Request cannot be cloned. Perhaps you want an STM channel?")) =>+  CloneableHandle (Request a b)   where   cloneableHandleImpl =-    error "instance CloneableHandle (Coroutine a b) not implemented"+    error "instance CloneableHandle (Request a b) not implemented"  instance-  (TypeError (Text "Writer cannot be cloned. Perhaps you want an STM channel?")) =>-  CloneableHandle (Writer w)+  (TypeError (Text "Tell cannot be cloned. Perhaps you want an STM channel?")) =>+  CloneableHandle (Tell w)   where   cloneableHandleImpl =-    error "instance CloneableHandle (Writer a) not implemented"+    error "instance CloneableHandle (Tell a) not implemented"  newtype (h1 :~> h2) es = MkArrow (forall e. h1 e -> h2 (e :& es)) @@ -254,7 +254,7 @@ -- example: -- -- @--- data MyHandle e = MkMyHandle ('Bluefin.Exception.Exception' String e) ('Bluefin.State.State' Int e)+-- data MyHandle e = MkMyHandle ('Bluefin.Capability.Throw.Throw' String e) ('Bluefin.Capability.Modify.Modify' Int e) --   deriving ('Bluefin.Compound.Generic', 'Generic1') --   deriving ('Bluefin.Compound.Handle') via t'Bluefin.Compound.OneWayCoercibleHandle' MyHandle --   deriving ('CloneableHandle') via 'GenericCloneableHandle' MyHandle

@@ -7,7 +7,7 @@  import Bluefin.Internal   ( Eff,-    Exception (..),+    Throw (..),     Handle,     OneWayCoercibleHandle (..),     effIO,@@ -156,7 +156,7 @@   forall ex r a es.   (r -> ex -> Eff es a) ->   -- | ͘-  MakeExceptions r a (Exception ex) es+  MakeExceptions r a (Throw ex) es catchWithResource f = MkMakeExceptions $ unsafeProvideIO $ \io -> do   scopedEx <- effIO io (SE.newException @ex)   let hk = MkHandledKey scopedEx (flip f)

@@ -6,7 +6,7 @@   ( Eff,     Effects,     Handle,-    HandleReader,+    AskCapability,     OneWayCoercibleHandle (..),     localHandle,     mapHandle,@@ -69,7 +69,7 @@ --   forall es e1 e2 r. --   (e1 \<: es, e2 \<: es) => --   t'Bluefin.IO.IOE' e1 ->---   t'Bluefin.Exception.Exception' t'Control.Exception.IOException' e2 ->+--   t'Bluefin.Capability.Throw.Throw' t'Control.Exception.IOException' e2 -> --   (forall e. 'Send' FileSystem e -> Eff (e :& es) r) -> --   Eff es r -- runFileSystem io ex = 'interpret' $ \\case@@ -129,7 +129,7 @@ -- augmentOp2Interpose :: --   (e1 \<: es, e2 \<: es) => --   IOE e2 ->---   t'Bluefin.HandleReader.HandleReader' (Send E) e1 ->+--   t'Bluefin.Capability.AskCapability.AskCapability' (Send E) e1 -> --   Eff es r -> --   Eff es r -- augmentOp2Interpose io = 'interpose' $ \\fc -> \\case@@ -149,7 +149,7 @@ -- augmentOp2Interpose :: --   (e1 \<: es, e2 \<: es) => --   IOE e2 ->---   t'Bluefin.HandleReader.HandleReader' (Send E) e1 ->+--   t'Bluefin.Capability.AskCapability.AskCapability' (Send E) e1 -> --   Eff es r -> --   Eff es r -- augmentOp2Interpose io = 'interpose' $ \\fc -> \\case@@ -162,7 +162,7 @@   -- the original effect handler, which is passed as the argument   (Send f es -> EffectHandler f es) ->   -- | Original effect handler-  HandleReader (Send f) e1 ->+  AskCapability (Send f) e1 ->   -- | Within this block, @send@ has the implementation given above.   Eff es r ->   Eff es r

@@ -1,285 +0,0 @@-module Bluefin.Internal.Pipes where--import Bluefin.Internal-  ( Coroutine,-    Eff,-    IOE,-    effIO,-    evalState,-    forEach,-    get,-    mapHandle,-    put,-    receiveStream,-    returnEarly,-    useImpl,-    useImplIn,-    withReturnEarly,-    yieldCoroutine,-    (:&),-    type (<:),-  )-import Bluefin.Internal qualified-import Control.Monad (forever)-import Data.Foldable (for_)-import Data.Void (Void, absurd)-import Prelude hiding (break, print, takeWhile)-import Prelude qualified--data Proxy a' a b' b e = MkProxy (Coroutine a' a e) (Coroutine b b' e)--type Pipe a = Proxy () a ()--type Producer = Proxy Void () ()--type Consumer a = Pipe a Void--type Effect = Producer Void--infixl 7 >->--(>->) ::-  (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-(>->) k1 k2 (MkProxy c1 c2) =-  receiveStream-    (\c -> useImplIn k2 (MkProxy (mapHandle c) (mapHandle c2)))-    (\s -> useImplIn k1 (MkProxy (mapHandle c1) (mapHandle s)))--infixr 7 <-<--(<-<) ::-  (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-k1 <-< k2 = k2 >-> k1--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'-for k1 k2 (MkProxy c1 c2) =-  forEach (\bk -> useImplIn k1 (MkProxy (mapHandle c1) (mapHandle bk))) $ \b_ ->-    useImplIn (k2 b_) (MkProxy (mapHandle c1) (mapHandle c2))--infixr 4 ~>--(~>) ::-  (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'-(k1 ~> k2) a = for (k1 a) k2--infixl 4 <~--(<~) ::-  (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'-k2 <~ k1 = k1 ~> k2--reverseProxy :: Proxy a' a b' b e -> Proxy b b' a a' e-reverseProxy (MkProxy c1 c2) = MkProxy c2 c1--infixl 5 >~--(>~) ::-  (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-(>~) k1 k2 p =-  for-    ( \p1 ->-        k2 (reverseProxy p1)-    )-    (\() p1 -> k1 (reverseProxy p1))-    (reverseProxy p)--infixr 5 ~<--(~<) ::-  (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-(~<) k1 k2 = (>~) k2 k1--cat :: Pipe a a e -> Eff (e :& es) r-cat (MkProxy c1 c2) = forever $ do-  a <- yieldCoroutine c1 ()-  yieldCoroutine c2 a--runEffect ::-  (forall e. Effect e -> Eff (e :& es) r) ->-  -- | ͘-  Eff es r-runEffect k =-  forEach-    ( \c1 ->-        forEach-          ( \c2 ->-              useImplIn-                k-                (MkProxy (mapHandle c1) (mapHandle c2))-          )-          absurd-    )-    absurd--yield ::-  (e <: es) =>-  Proxy x1 x () a e ->-  a ->-  -- | ͘-  Eff es ()-yield (MkProxy _ c) = Bluefin.Internal.yield c--await :: (e <: es) => Proxy () a y' y e -> Eff es a-await (MkProxy c _) = yieldCoroutine c ()---- | @pipe@'s 'next' doesn't exist in Bluefin-next :: ()-next = ()--each ::-  (Foldable f) =>-  f a ->-  Proxy x' x () a e ->-  -- | ͘-  Eff (e :& es) ()-each f p = for_ f (yield p)--repeatM ::-  (e <: es) =>-  Eff es a ->-  Proxy x' x () a e ->-  -- | ͘-  Eff es r-repeatM e p = forever $ do-  a <- e-  yield p a--replicateM ::-  (e <: es) =>-  Int ->-  Eff es a ->-  Proxy x' x () a e ->-  -- | ͘-  Eff es ()-replicateM n e p = for_ [0 .. n] $ \_ -> do-  a <- e-  yield p a--print ::-  (e2 <: es, e1 <: es, Show a) =>-  IOE e1 ->-  Consumer a e2 ->-  -- | ͘-  Eff es r-print io p = forever $ do-  a <- await p-  effIO io (Prelude.print a)--unfoldr ::-  (e <: es) =>-  (s -> Eff es (Either r (a, s))) ->-  s ->-  Proxy x1 x () a e ->-  -- | ͘-  Eff es r-unfoldr next_ sInit p =-  withReturnEarly $ \break -> evalState sInit $ \ss -> forever $ do-    s <- get ss-    useImpl (next_ s) >>= \case-      Left r -> returnEarly break r-      Right (a, s') -> do-        put ss s'-        yield p a--mapM_ ::-  (e <: es) =>-  (a -> Eff es ()) ->-  Proxy () a b b' e ->-  -- | ͘-  Eff es r-mapM_ f = for cat (\a _ -> useImpl (f a))--drain ::-  (e <: es) =>-  Proxy () b c' c e ->-  -- | ͘-  Eff es r-drain = for cat (\_ _ -> pure ())--map ::-  (e <: es) =>-  (a -> b) ->-  Pipe a b e ->-  -- | ͘-  Eff es r-map f = for cat (\a p1 -> yield p1 (f a))--mapM ::-  (e <: es) =>-  (a -> Eff es b) ->-  Pipe a b e ->-  -- | ͘-  Eff es r-mapM f = for cat $ \a p -> do-  b_ <- useImpl (f a)-  yield p b_--takeWhile' ::-  (e <: es) =>-  (r -> Bool) ->-  Pipe r r e ->-  -- | ͘-  Eff es r-takeWhile' predicate p = withReturnEarly $ \early -> forever $ do-  a <- await p-  if predicate a-    then yield p a-    else returnEarly early a--stdinLn ::-  (e1 <: es, e2 <: es) =>-  IOE e1 ->-  Producer String e2 ->-  -- | ͘-  Eff es r-stdinLn io c = forever $ do-  line <- effIO io getLine-  yield c line--stdoutLn ::-  (e1 <: es, e2 <: es) =>-  IOE e1 ->-  Consumer String e2 ->-  -- | ͘-  Eff es r-stdoutLn io c = forever $ do-  line <- await c-  effIO io (putStrLn line)

@@ -1,5 +1,6 @@ {-# LANGUAGE DerivingVia #-} {-# LANGUAGE MagicHash #-}+{-# LANGUAGE RoleAnnotations #-} {-# LANGUAGE UnboxedTuples #-}  module Bluefin.Internal.Prim where@@ -21,19 +22,23 @@     unsafeOneWayCoercible,   ) import Control.Monad.Primitive qualified as P+import Data.Kind (Type) import GHC.Exts (State#) import Unsafe.Coerce (unsafeCoerce) -data Prim (e :: Effects) = UnsafeMkPrim-  deriving (Handle) via OneWayCoercibleHandle Prim+type Prim :: Effects -> Effects -> Type+data Prim e1 e2 = UnsafeMkPrim+  deriving (Handle) via OneWayCoercibleHandle (Prim e1) +type role Prim nominal nominal+ data PrimStateEff (es :: Effects) -instance (e <: es) => OneWayCoercible (Prim e) (Prim es) where+instance (e2 <: es) => OneWayCoercible (Prim e1 e2) (Prim e1 es) where   oneWayCoercibleImpl = unsafeOneWayCoercible  runPrim ::-  (forall e. Prim e -> Eff (e :& es) r) ->+  (forall e. Prim e e -> Eff (e :& es) r) ->   -- | ͘   Eff es r runPrim k = makeOp (k UnsafeMkPrim)@@ -44,9 +49,9 @@ unsafeCoerceStateM = unsafeCoerce  primitive ::-  forall e1 es a.-  (e1 <: es) =>-  Prim e1 ->+  forall e1 e2 es a.+  (e2 <: es) =>+  Prim e1 e2 ->   (State# (PrimStateEff e1) -> (# State# (PrimStateEff e1), a #)) ->   -- | ͘   Eff es a