{- |
   Module     : Polysemy.Methodology.Composite
   License    : MIT
   Maintainer : dan.firth@homotopic.tech
   Stability  : experimental

Functions for combining polysemy-methodology with composite.
-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE BlockArguments      #-}
{-# LANGUAGE DataKinds           #-}
{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE LambdaCase          #-}
{-# LANGUAGE GADTs               #-}
{-# LANGUAGE PolyKinds           #-}
{-# LANGUAGE RankNTypes          #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE TypeOperators       #-}
module Polysemy.Methodology.Composite (
  runMethodologyRmap
, runCoRecMethodologyAsCases
, runCoRecMethodologyAsCases'
, diffractMethodology
, diffractMethodology'
, runInputCase'
, pickCoRecConstructor
, separateRecInitial
, separateRecInitial'
, stripRecInitial
, endRecInitial
, runRecInitialAsInputCompose
, runRecInitialAsInputCompose'
, separateRecTerminal
, separateRecTerminal'
, stripRecTerminal
, endRecTerminal
, fmapCMethodology
, fmapCMethodology'
) where

import Control.Arrow
import Composite.CoRecord
import Data.Vinyl
import Data.Vinyl.Functor
import Polysemy
import Polysemy.Extra
import Polysemy.Input
import Polysemy.Methodology

-- | Run a `Methodology` between two `Rec`s according to a natural transformation
-- between the interpretation functors.
--
-- @since 0.1.4.0
runMethodologyRmap :: forall f g xs r a. RMap xs =>
                      (forall y. f y -> g y)
                   -> Sem (Methodology (Rec f xs) (Rec g xs) ': r) a
                   -> Sem r a
runMethodologyRmap :: (forall (y :: u). f y -> g y)
-> Sem (Methodology (Rec f xs) (Rec g xs) : r) a -> Sem r a
runMethodologyRmap forall (y :: u). f y -> g y
f = (Rec f xs -> Rec g xs)
-> Sem (Methodology (Rec f xs) (Rec g xs) : r) a -> Sem r a
forall b c (r :: [(* -> *) -> * -> *]) a.
(b -> c) -> Sem (Methodology b c : r) a -> Sem r a
runMethodologyPure ((forall (y :: u). f y -> g y) -> Rec f xs -> Rec g xs
forall u (rs :: [u]) (f :: u -> *) (g :: u -> *).
RMap rs =>
(forall (x :: u). f x -> g x) -> Rec f rs -> Rec g rs
rmap forall (y :: u). f y -> g y
f)
{-# INLINE runMethodologyRmap #-}

-- | Run a `Methodology` from a `CoRec` to an `Input` of `Cases'`. You can then use `Polysemy.Vinyl.separateRecInput` and `Polysemy.Vinyl.stripRecInput`
-- to deal with the cases individually.
--
-- @since 0.1.0.0
runCoRecMethodologyAsCases :: forall f zs c x xs r a.
                              (zs ~ (x ': xs), RecApplicative zs, Members '[Input (Cases' f zs c)] r)
                           => Sem (Methodology (CoRec f zs) c ': r) a
                              -- ^ The Methodology to decompose.
                           -> Sem r a
runCoRecMethodologyAsCases :: Sem (Methodology (CoRec f zs) c : r) a -> Sem r a
runCoRecMethodologyAsCases = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology (CoRec f zs) c (Sem rInitial) x -> Sem r x)
-> Sem (Methodology (CoRec f zs) c : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e "interpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Process b -> do
    Cases' f zs c
x <- forall (r :: [(* -> *) -> * -> *]).
MemberWithError (Input (Cases' f zs c)) r =>
Sem r (Cases' f zs c)
forall i (r :: [(* -> *) -> * -> *]).
MemberWithError (Input i) r =>
Sem r i
input @(Cases' f zs c)
    c -> Sem r c
forall (m :: * -> *) a. Monad m => a -> m a
return (c -> Sem r c) -> c -> Sem r c
forall a b. (a -> b) -> a -> b
$ Cases' f (x : xs) c -> CoRec f (x : xs) -> c
forall a (r :: a) (rs :: [a]) (f :: a -> *) b.
RecApplicative (r : rs) =>
Cases' f (r : rs) b -> CoRec f (r : rs) -> b
foldCoRec Cases' f zs c
Cases' f (x : xs) c
x CoRec f (x : xs)
b
{-# INLINE runCoRecMethodologyAsCases #-}

-- | Reinterpreting version of `runCoRecMethodologyAsCases`.
--
--
-- @since 0.1.0.0
runCoRecMethodologyAsCases' :: forall f zs c x xs r a.
                               (zs ~ (x ': xs), RecApplicative zs)
                            => Sem (Methodology (CoRec f zs) c ': r) a
                               -- ^ The Methodology to decompose.
                            -> Sem (Input (Cases' f zs c) ': r) a
runCoRecMethodologyAsCases' :: Sem (Methodology (CoRec f zs) c : r) a
-> Sem (Input (Cases' f zs c) : r) a
runCoRecMethodologyAsCases' = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology (CoRec f zs) c (Sem rInitial) x
 -> Sem (Input (Cases' f zs c) : r) x)
-> Sem (Methodology (CoRec f zs) c : r) a
-> Sem (Input (Cases' f zs c) : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : r) a
reinterpret \case
  Process b -> do
    Cases' f zs c
x <- forall (r :: [(* -> *) -> * -> *]).
MemberWithError (Input (Cases' f zs c)) r =>
Sem r (Cases' f zs c)
forall i (r :: [(* -> *) -> * -> *]).
MemberWithError (Input i) r =>
Sem r i
input @(Cases' f zs c)
    c -> Sem (Input (Cases' f zs c) : r) c
forall (m :: * -> *) a. Monad m => a -> m a
return (c -> Sem (Input (Cases' f zs c) : r) c)
-> c -> Sem (Input (Cases' f zs c) : r) c
forall a b. (a -> b) -> a -> b
$ Cases' f (x : xs) c -> CoRec f (x : xs) -> c
forall a (r :: a) (rs :: [a]) (f :: a -> *) b.
RecApplicative (r : rs) =>
Cases' f (r : rs) b -> CoRec f (r : rs) -> b
foldCoRec Cases' f zs c
Cases' f (x : xs) c
x CoRec f (x : xs)
b
{-# INLINE runCoRecMethodologyAsCases' #-}

-- | Diffraction is a combination of a `cutMethodology'`, an `mconcatMethodology'` and a `runCoRecMethodologyAsCases`.
--
-- This effectively allows you to make several ad-hoc constructors for d and fully consumes the second half of the cut.
-- This turns out to be quite a good way to start a simple pipeline.
--
-- @since 0.1.0.0
diffractMethodology :: forall b f zs d x xs r a.
                       (Monoid d, zs ~ (x ': xs)
                      , RecApplicative zs
                      , Members '[ Methodology b [CoRec f zs]
                                 , Input (Cases' f zs d)] r)
                    => Sem (Methodology b d ': r) a
                       -- ^ The Methodology to decompose.
                    -> Sem r a
diffractMethodology :: Sem (Methodology b d : r) a -> Sem r a
diffractMethodology = forall (r :: [(* -> *) -> * -> *]) a.
Sem (Methodology b d : r) a
-> Sem
     (Methodology b [CoRec f zs] : Methodology [CoRec f zs] d : r) a
forall b c d (r :: [(* -> *) -> * -> *]) a.
Sem (Methodology b d : r) a
-> Sem (Methodology b c : Methodology c d : r) a
cutMethodology' @b @[CoRec f zs] @d
                  (Sem (Methodology b d : r) a
 -> Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology [CoRec f (x : xs)] d : r)
      a)
-> (Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology [CoRec f (x : xs)] d : r)
      a
    -> Sem r a)
-> Sem (Methodology b d : r) a
-> Sem r a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> (forall (m :: [(* -> *) -> * -> *]) x.
 Sem (Methodology [CoRec f (x : xs)] d : m) x
 -> Sem (Methodology (CoRec f (x : xs)) d : m) x)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology [CoRec f (x : xs)] d : r)
     a
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology (CoRec f (x : xs)) d : r)
     a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
(forall (m :: [(* -> *) -> * -> *]) x.
 Sem (e2 : m) x -> Sem (e3 : m) x)
-> Sem (e1 : e2 : r) a -> Sem (e1 : e3 : r) a
reinterpretUnder forall (m :: [(* -> *) -> * -> *]) x.
Sem (Methodology [CoRec f (x : xs)] d : m) x
-> Sem (Methodology (CoRec f (x : xs)) d : m) x
forall (f :: * -> *) b c (r :: [(* -> *) -> * -> *]) a.
(Monoid c, Traversable f) =>
Sem (Methodology (f b) c : r) a -> Sem (Methodology b c : r) a
mconcatMethodology'
                  (Sem
   (Methodology b [CoRec f (x : xs)]
      : Methodology [CoRec f (x : xs)] d : r)
   a
 -> Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology (CoRec f (x : xs)) d : r)
      a)
-> (Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology (CoRec f (x : xs)) d : r)
      a
    -> Sem r a)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology [CoRec f (x : xs)] d : r)
     a
-> Sem r a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> (forall (m :: [(* -> *) -> * -> *]) x.
 Sem (Methodology (CoRec f (x : xs)) d : m) x
 -> Sem (Input (Cases' f (x : xs) d) : m) x)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology (CoRec f (x : xs)) d : r)
     a
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Input (Cases' f (x : xs) d) : r)
     a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
(forall (m :: [(* -> *) -> * -> *]) x.
 Sem (e2 : m) x -> Sem (e3 : m) x)
-> Sem (e1 : e2 : r) a -> Sem (e1 : e3 : r) a
reinterpretUnder forall (m :: [(* -> *) -> * -> *]) x.
Sem (Methodology (CoRec f (x : xs)) d : m) x
-> Sem (Input (Cases' f (x : xs) d) : m) x
forall u (f :: u -> *) (zs :: [u]) c (x :: u) (xs :: [u])
       (r :: [(* -> *) -> * -> *]) a.
(zs ~ (x : xs), RecApplicative zs) =>
Sem (Methodology (CoRec f zs) c : r) a
-> Sem (Input (Cases' f zs c) : r) a
runCoRecMethodologyAsCases'
                  (Sem
   (Methodology b [CoRec f (x : xs)]
      : Methodology (CoRec f (x : xs)) d : r)
   a
 -> Sem
      (Methodology b [CoRec f (x : xs)]
         : Input (Cases' f (x : xs) d) : r)
      a)
-> (Sem
      (Methodology b [CoRec f (x : xs)]
         : Input (Cases' f (x : xs) d) : r)
      a
    -> Sem r a)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology (CoRec f (x : xs)) d : r)
     a
-> Sem r a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem
  (Methodology b [CoRec f (x : xs)]
     : Input (Cases' f (x : xs) d) : r)
  a
-> Sem (Input (Cases' f (x : xs) d) : r) a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
Member e r =>
Sem (e : r) a -> Sem r a
subsume (Sem
   (Methodology b [CoRec f (x : xs)]
      : Input (Cases' f (x : xs) d) : r)
   a
 -> Sem (Input (Cases' f (x : xs) d) : r) a)
-> (Sem (Input (Cases' f (x : xs) d) : r) a -> Sem r a)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Input (Cases' f (x : xs) d) : r)
     a
-> Sem r a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (Input (Cases' f (x : xs) d) : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
Member e r =>
Sem (e : r) a -> Sem r a
subsume
{-# INLINE diffractMethodology #-}

-- | Reinterpreting version of `diffractMethodology`.
--
-- @since 0.1.0.0
diffractMethodology' :: forall b f zs d x xs r a.
                        (Monoid d, zs ~ (x ': xs), RecApplicative zs)
                     => Sem (Methodology b d ': r) a
                        -- ^ The Methodology to decompose.
                     -> Sem (Methodology b [CoRec f zs] ': Input (Cases' f zs d) ': r) a
diffractMethodology' :: Sem (Methodology b d : r) a
-> Sem (Methodology b [CoRec f zs] : Input (Cases' f zs d) : r) a
diffractMethodology' = forall (r :: [(* -> *) -> * -> *]) a.
Sem (Methodology b d : r) a
-> Sem
     (Methodology b [CoRec f zs] : Methodology [CoRec f zs] d : r) a
forall b c d (r :: [(* -> *) -> * -> *]) a.
Sem (Methodology b d : r) a
-> Sem (Methodology b c : Methodology c d : r) a
cutMethodology' @b @[CoRec f zs] @d
                   (Sem (Methodology b d : r) a
 -> Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology [CoRec f (x : xs)] d : r)
      a)
-> (Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology [CoRec f (x : xs)] d : r)
      a
    -> Sem
         (Methodology b [CoRec f (x : xs)]
            : Input (Cases' f (x : xs) d) : r)
         a)
-> Sem (Methodology b d : r) a
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Input (Cases' f (x : xs) d) : r)
     a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> (forall (m :: [(* -> *) -> * -> *]) x.
 Sem (Methodology [CoRec f (x : xs)] d : m) x
 -> Sem (Methodology (CoRec f (x : xs)) d : m) x)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology [CoRec f (x : xs)] d : r)
     a
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology (CoRec f (x : xs)) d : r)
     a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
(forall (m :: [(* -> *) -> * -> *]) x.
 Sem (e2 : m) x -> Sem (e3 : m) x)
-> Sem (e1 : e2 : r) a -> Sem (e1 : e3 : r) a
reinterpretUnder forall (m :: [(* -> *) -> * -> *]) x.
Sem (Methodology [CoRec f (x : xs)] d : m) x
-> Sem (Methodology (CoRec f (x : xs)) d : m) x
forall (f :: * -> *) b c (r :: [(* -> *) -> * -> *]) a.
(Monoid c, Traversable f) =>
Sem (Methodology (f b) c : r) a -> Sem (Methodology b c : r) a
mconcatMethodology'
                   (Sem
   (Methodology b [CoRec f (x : xs)]
      : Methodology [CoRec f (x : xs)] d : r)
   a
 -> Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology (CoRec f (x : xs)) d : r)
      a)
-> (Sem
      (Methodology b [CoRec f (x : xs)]
         : Methodology (CoRec f (x : xs)) d : r)
      a
    -> Sem
         (Methodology b [CoRec f (x : xs)]
            : Input (Cases' f (x : xs) d) : r)
         a)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology [CoRec f (x : xs)] d : r)
     a
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Input (Cases' f (x : xs) d) : r)
     a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> (forall (m :: [(* -> *) -> * -> *]) x.
 Sem (Methodology (CoRec f (x : xs)) d : m) x
 -> Sem (Input (Cases' f (x : xs) d) : m) x)
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Methodology (CoRec f (x : xs)) d : r)
     a
-> Sem
     (Methodology b [CoRec f (x : xs)]
        : Input (Cases' f (x : xs) d) : r)
     a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
(forall (m :: [(* -> *) -> * -> *]) x.
 Sem (e2 : m) x -> Sem (e3 : m) x)
-> Sem (e1 : e2 : r) a -> Sem (e1 : e3 : r) a
reinterpretUnder forall (m :: [(* -> *) -> * -> *]) x.
Sem (Methodology (CoRec f (x : xs)) d : m) x
-> Sem (Input (Cases' f (x : xs) d) : m) x
forall u (f :: u -> *) (zs :: [u]) c (x :: u) (xs :: [u])
       (r :: [(* -> *) -> * -> *]) a.
(zs ~ (x : xs), RecApplicative zs) =>
Sem (Methodology (CoRec f zs) c : r) a
-> Sem (Input (Cases' f zs c) : r) a
runCoRecMethodologyAsCases'
{-# INLINE diffractMethodology' #-}

-- | Run a `Case'` using `runInputConst` and a function eliminating the `Case'`.
--
-- @since 0.1.1.0
runInputCase' :: forall b f t r a.
                 (f b -> t)
              -> Sem (Input (Case' f t b) ': r) a
              -> Sem r a
runInputCase' :: (f b -> t) -> Sem (Input (Case' f t b) : r) a -> Sem r a
runInputCase' f b -> t
f = Case' f t b -> Sem (Input (Case' f t b) : r) a -> Sem r a
forall i (r :: [(* -> *) -> * -> *]) a.
i -> Sem (Input i : r) a -> Sem r a
runInputConst ((f b -> t) -> Case' f t b
forall k (f :: k -> *) b (a :: k). (f a -> b) -> Case' f b a
Case' f b -> t
f)
{-# INLINE runInputCase' #-}

-- | Take a `Methodology` into a `CoRec` and choose a constructor.
--
-- @since 0.1.4.0
pickCoRecConstructor :: forall x f b xs r a. x ∈ xs =>
                        Sem (Methodology b (CoRec f xs) ': r) a
                     -> Sem (Methodology b (f x) ': r) a
pickCoRecConstructor :: Sem (Methodology b (CoRec f xs) : r) a
-> Sem (Methodology b (f x) : r) a
pickCoRecConstructor = Sem (Methodology b (CoRec f xs) : r) a
-> Sem (Methodology b (f x) : Methodology (f x) (CoRec f xs) : r) a
forall b c d (r :: [(* -> *) -> * -> *]) a.
Sem (Methodology b d : r) a
-> Sem (Methodology b c : Methodology c d : r) a
cutMethodology'
                   (Sem (Methodology b (CoRec f xs) : r) a
 -> Sem
      (Methodology b (f x) : Methodology (f x) (CoRec f xs) : r) a)
-> (Sem
      (Methodology b (f x) : Methodology (f x) (CoRec f xs) : r) a
    -> Sem (Methodology b (f x) : r) a)
-> Sem (Methodology b (CoRec f xs) : r) a
-> Sem (Methodology b (f x) : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Sem (Methodology b (f x) : Methodology (f x) (CoRec f xs) : r) a
-> Sem (Methodology (f x) (CoRec f xs) : Methodology b (f x) : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
Sem (e1 : e2 : r) a -> Sem (e2 : e1 : r) a
rotateEffects2
                   (Sem (Methodology b (f x) : Methodology (f x) (CoRec f xs) : r) a
 -> Sem
      (Methodology (f x) (CoRec f xs) : Methodology b (f x) : r) a)
-> (Sem
      (Methodology (f x) (CoRec f xs) : Methodology b (f x) : r) a
    -> Sem (Methodology b (f x) : r) a)
-> Sem (Methodology b (f x) : Methodology (f x) (CoRec f xs) : r) a
-> Sem (Methodology b (f x) : r) a
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> (f x -> CoRec f xs)
-> Sem (Methodology (f x) (CoRec f xs) : Methodology b (f x) : r) a
-> Sem (Methodology b (f x) : r) a
forall b c (r :: [(* -> *) -> * -> *]) a.
(b -> c) -> Sem (Methodology b c : r) a -> Sem r a
runMethodologyPure f x -> CoRec f xs
forall u (r :: u) (b :: [u]) (a :: u -> *).
(r ∈ b) =>
a r -> CoRec a b
CoVal
{-# INLINE pickCoRecConstructor #-}

-- | Factor a `Methodology` with a `Rec` in the result by a `Methodology` to the first variable.
--
-- @since 0.1.3.0
separateRecInitial :: forall b f x xs r a.
                      Members '[Methodology b (f x), Methodology b (Rec f xs)] r
                   => Sem (Methodology b (Rec f (x ': xs)) ': r) a
                      -- ^ The Methodology to decompose.
                   -> Sem r a
separateRecInitial :: Sem (Methodology b (Rec f (x : xs)) : r) a -> Sem r a
separateRecInitial = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology b (Rec f (x : xs)) (Sem rInitial) x -> Sem r x)
-> Sem (Methodology b (Rec f (x : xs)) : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e "interpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Process b -> do
    f x
k   <- b -> Sem r (f x)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @b @(f x) b
b
    Rec f xs
k'  <- b -> Sem r (Rec f xs)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @b @(Rec f xs) b
b
    Rec f (x : xs) -> Sem r (Rec f (x : xs))
forall (m :: * -> *) a. Monad m => a -> m a
return (Rec f (x : xs) -> Sem r (Rec f (x : xs)))
-> Rec f (x : xs) -> Sem r (Rec f (x : xs))
forall a b. (a -> b) -> a -> b
$ f x
k f x -> Rec f xs -> Rec f (x : xs)
forall u (a :: u -> *) (r :: u) (rs :: [u]).
a r -> Rec a rs -> Rec a (r : rs)
:& Rec f xs
k'
{-# INLINE separateRecInitial #-}

-- | Reinterpreting version of `separateRecInitial`. This assumes you want to handle
-- the separated case first.
--
-- @since 0.1.3.0
separateRecInitial' :: forall b f x xs r a.
                       Sem (Methodology b (Rec f (x ': xs)) ': r) a
                    -> Sem (Methodology b (f x) ': Methodology b (Rec f xs)': r) a
separateRecInitial' :: Sem (Methodology b (Rec f (x : xs)) : r) a
-> Sem (Methodology b (f x) : Methodology b (Rec f xs) : r) a
separateRecInitial' = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology b (Rec f (x : xs)) (Sem rInitial) x
 -> Sem (Methodology b (f x) : Methodology b (Rec f xs) : r) x)
-> Sem (Methodology b (Rec f (x : xs)) : r) a
-> Sem (Methodology b (f x) : Methodology b (Rec f xs) : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret2" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : e3 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : e3 : r) a
reinterpret2 \case
  Process b -> do
    f x
k   <- b -> Sem (Methodology b (f x) : Methodology b (Rec f xs) : r) (f x)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @b @(f x) b
b
    Rec f xs
k'  <- Sem (Methodology b (Rec f xs) : r) (Rec f xs)
-> Sem
     (Methodology b (f x) : Methodology b (Rec f xs) : r) (Rec f xs)
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
Sem r a -> Sem (e : r) a
raise (Sem (Methodology b (Rec f xs) : r) (Rec f xs)
 -> Sem
      (Methodology b (f x) : Methodology b (Rec f xs) : r) (Rec f xs))
-> Sem (Methodology b (Rec f xs) : r) (Rec f xs)
-> Sem
     (Methodology b (f x) : Methodology b (Rec f xs) : r) (Rec f xs)
forall a b. (a -> b) -> a -> b
$ b -> Sem (Methodology b (Rec f xs) : r) (Rec f xs)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @b @(Rec f xs) b
b
    Rec f (x : xs)
-> Sem
     (Methodology b (f x) : Methodology b (Rec f xs) : r)
     (Rec f (x : xs))
forall (m :: * -> *) a. Monad m => a -> m a
return (Rec f (x : xs)
 -> Sem
      (Methodology b (f x) : Methodology b (Rec f xs) : r)
      (Rec f (x : xs)))
-> Rec f (x : xs)
-> Sem
     (Methodology b (f x) : Methodology b (Rec f xs) : r)
     (Rec f (x : xs))
forall a b. (a -> b) -> a -> b
$ f x
k f x -> Rec f xs -> Rec f (x : xs)
forall u (a :: u -> *) (r :: u) (rs :: [u]).
a r -> Rec a rs -> Rec a (r : rs)
:& Rec f xs
k'
{-# INLINE separateRecInitial' #-}

-- | Like `separateRecInitial`, but reinterprets the rest of the `Rec` whilst pushing
-- the separated `Methodology` into the stack. Useful for exhausting the `Rec` and
-- dealing with the cases later.
--
-- @since 0.1.3.0
stripRecInitial :: forall b f x xs r a.
                   Members '[Methodology b (f x)] (Methodology b (Rec f xs) ': r)
                => Sem (Methodology b (Rec f (x ': xs)) ': r) a
                -> Sem (Methodology b (Rec f xs)': r) a
stripRecInitial :: Sem (Methodology b (Rec f (x : xs)) : r) a
-> Sem (Methodology b (Rec f xs) : r) a
stripRecInitial = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology b (Rec f (x : xs)) (Sem rInitial) x
 -> Sem (Methodology b (Rec f xs) : r) x)
-> Sem (Methodology b (Rec f (x : xs)) : r) a
-> Sem (Methodology b (Rec f xs) : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : r) a
reinterpret \case
  Process b -> do
    f x
k   <- b -> Sem (Methodology b (Rec f xs) : r) (f x)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @b @(f x) b
b
    Rec f xs
k'  <- b -> Sem (Methodology b (Rec f xs) : r) (Rec f xs)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @b @(Rec f xs) b
b
    Rec f (x : xs)
-> Sem (Methodology b (Rec f xs) : r) (Rec f (x : xs))
forall (m :: * -> *) a. Monad m => a -> m a
return (Rec f (x : xs)
 -> Sem (Methodology b (Rec f xs) : r) (Rec f (x : xs)))
-> Rec f (x : xs)
-> Sem (Methodology b (Rec f xs) : r) (Rec f (x : xs))
forall a b. (a -> b) -> a -> b
$ f x
k f x -> Rec f xs -> Rec f (x : xs)
forall u (a :: u -> *) (r :: u) (rs :: [u]).
a r -> Rec a rs -> Rec a (r : rs)
:& Rec f xs
k'
{-# INLINE stripRecInitial #-}

-- | Discard a depleted `Methodology` into a `Rec` by returning `RNil`.
--
-- @since 0.1.3.0
endRecInitial :: Sem (Methodology b (Rec f '[]) ': r) a -> Sem r a
endRecInitial :: Sem (Methodology b (Rec f '[]) : r) a -> Sem r a
endRecInitial = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology b (Rec f '[]) (Sem rInitial) x -> Sem r x)
-> Sem (Methodology b (Rec f '[]) : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e "interpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Process _ -> Rec f '[] -> Sem r (Rec f '[])
forall (m :: * -> *) a. Monad m => a -> m a
return Rec f '[]
forall u (a :: u -> *). Rec a '[]
RNil
{-# INLINE endRecInitial #-}

-- | Run a `Methodology` into a `Rec` as an `Input` over a `(->)` functor.
--
-- @since 0.1.3.0
runRecInitialAsInputCompose :: forall b f xs r a. (RMap xs,
                               Members '[ Input (Rec (Compose ((->) b) f) xs)] r)
                            => Sem (Methodology b (Rec f xs) ': r) a
                            -> Sem r a
runRecInitialAsInputCompose :: Sem (Methodology b (Rec f xs) : r) a -> Sem r a
runRecInitialAsInputCompose = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology b (Rec f xs) (Sem rInitial) x -> Sem r x)
-> Sem (Methodology b (Rec f xs) : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e "interpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Process b -> do
    Rec (Compose ((->) b) f) xs
z <- forall (r :: [(* -> *) -> * -> *]).
MemberWithError (Input (Rec (Compose ((->) b) f) xs)) r =>
Sem r (Rec (Compose ((->) b) f) xs)
forall i (r :: [(* -> *) -> * -> *]).
MemberWithError (Input i) r =>
Sem r i
input @(Rec (Compose ((->) b) f) xs)
    Rec f xs -> Sem r (Rec f xs)
forall (m :: * -> *) a. Monad m => a -> m a
return (Rec f xs -> Sem r (Rec f xs)) -> Rec f xs -> Sem r (Rec f xs)
forall a b. (a -> b) -> a -> b
$ (forall (x :: u). Compose ((->) b) f x -> f x)
-> Rec (Compose ((->) b) f) xs -> Rec f xs
forall u (rs :: [u]) (f :: u -> *) (g :: u -> *).
RMap rs =>
(forall (x :: u). f x -> g x) -> Rec f rs -> Rec g rs
rmap (((b -> f x) -> b -> f x
forall a b. (a -> b) -> a -> b
$ b
b) ((b -> f x) -> f x)
-> (Compose ((->) b) f x -> b -> f x)
-> Compose ((->) b) f x
-> f x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose ((->) b) f x -> b -> f x
forall l (f :: l -> *) k (g :: k -> l) (x :: k).
Compose f g x -> f (g x)
getCompose) Rec (Compose ((->) b) f) xs
z
{-# INLINE runRecInitialAsInputCompose #-}

-- | Reinterpreting version of `runRecInitialAsInputCompose`.
--
-- @since 0.1.3.0
runRecInitialAsInputCompose' :: forall b f xs r a. (RMap xs)
                             => Sem (Methodology b (Rec f xs) ': r) a
                             -> Sem (Input (Rec (Compose ((->) b) f) xs) ': r) a
runRecInitialAsInputCompose' :: Sem (Methodology b (Rec f xs) : r) a
-> Sem (Input (Rec (Compose ((->) b) f) xs) : r) a
runRecInitialAsInputCompose' = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology b (Rec f xs) (Sem rInitial) x
 -> Sem (Input (Rec (Compose ((->) b) f) xs) : r) x)
-> Sem (Methodology b (Rec f xs) : r) a
-> Sem (Input (Rec (Compose ((->) b) f) xs) : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : r) a
reinterpret \case
  Process b -> do
    Rec (Compose ((->) b) f) xs
z <- forall (r :: [(* -> *) -> * -> *]).
MemberWithError (Input (Rec (Compose ((->) b) f) xs)) r =>
Sem r (Rec (Compose ((->) b) f) xs)
forall i (r :: [(* -> *) -> * -> *]).
MemberWithError (Input i) r =>
Sem r i
input @(Rec (Compose ((->) b) f) xs)
    Rec f xs
-> Sem (Input (Rec (Compose ((->) b) f) xs) : r) (Rec f xs)
forall (m :: * -> *) a. Monad m => a -> m a
return (Rec f xs
 -> Sem (Input (Rec (Compose ((->) b) f) xs) : r) (Rec f xs))
-> Rec f xs
-> Sem (Input (Rec (Compose ((->) b) f) xs) : r) (Rec f xs)
forall a b. (a -> b) -> a -> b
$ (forall (x :: u). Compose ((->) b) f x -> f x)
-> Rec (Compose ((->) b) f) xs -> Rec f xs
forall u (rs :: [u]) (f :: u -> *) (g :: u -> *).
RMap rs =>
(forall (x :: u). f x -> g x) -> Rec f rs -> Rec g rs
rmap (((b -> f x) -> b -> f x
forall a b. (a -> b) -> a -> b
$ b
b) ((b -> f x) -> f x)
-> (Compose ((->) b) f x -> b -> f x)
-> Compose ((->) b) f x
-> f x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose ((->) b) f x -> b -> f x
forall l (f :: l -> *) k (g :: k -> l) (x :: k).
Compose f g x -> f (g x)
getCompose) Rec (Compose ((->) b) f) xs
z
{-# INLINE runRecInitialAsInputCompose' #-}

-- | Factor a `Methodology` from a `Rec` by a `Methodology` from the first variable.
--
-- since @0.1.3.0
separateRecTerminal :: forall x c f xs r a. (Monoid c,
                       Members '[Methodology (f x) c, Methodology (Rec f xs) c] r)
                    => Sem (Methodology (Rec f (x ': xs)) c ': r) a
                    -> Sem r a
separateRecTerminal :: Sem (Methodology (Rec f (x : xs)) c : r) a -> Sem r a
separateRecTerminal = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology (Rec f (x : xs)) c (Sem rInitial) x -> Sem r x)
-> Sem (Methodology (Rec f (x : xs)) c : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e "interpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Process (b :& bs) -> do
    c
k   <- f x -> Sem r c
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(f x) f x
f r
b
    c
k'  <- Rec f xs -> Sem r c
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(Rec f xs) @c Rec f xs
Rec f rs
bs
    c -> Sem r c
forall (m :: * -> *) a. Monad m => a -> m a
return (c -> Sem r c) -> c -> Sem r c
forall a b. (a -> b) -> a -> b
$ c
k c -> c -> c
forall a. Semigroup a => a -> a -> a
<> c
k'
{-# INLINE separateRecTerminal #-}

-- | Reinterpreted version of `separateRecTerminal`.
--
-- since @0.1.3.0
separateRecTerminal' :: forall x c f xs r a. Monoid c
                     => Sem (Methodology (Rec f (x ': xs)) c ': r) a
                     -> Sem (Methodology (f x) c ': Methodology (Rec f xs) c ': r) a
separateRecTerminal' :: Sem (Methodology (Rec f (x : xs)) c : r) a
-> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) a
separateRecTerminal' = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology (Rec f (x : xs)) c (Sem rInitial) x
 -> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) x)
-> Sem (Methodology (Rec f (x : xs)) c : r) a
-> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (e3 :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret2" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : e3 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : e3 : r) a
reinterpret2 \case
  Process (b :& bs) -> do
    c
k   <- f x -> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) c
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(f x) f x
f r
b
    c
k'  <- Sem (Methodology (Rec f xs) c : r) c
-> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) c
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
Sem r a -> Sem (e : r) a
raise (Sem (Methodology (Rec f xs) c : r) c
 -> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) c)
-> Sem (Methodology (Rec f xs) c : r) c
-> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) c
forall a b. (a -> b) -> a -> b
$ Rec f xs -> Sem (Methodology (Rec f xs) c : r) c
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(Rec f xs) @c Rec f xs
Rec f rs
bs
    c -> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) c
forall (m :: * -> *) a. Monad m => a -> m a
return (c -> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) c)
-> c -> Sem (Methodology (f x) c : Methodology (Rec f xs) c : r) c
forall a b. (a -> b) -> a -> b
$ c
k c -> c -> c
forall a. Semigroup a => a -> a -> a
<> c
k'
{-# INLINE separateRecTerminal' #-}

-- | Like `separateRecTerminal, but reinterprets the rest of the `Rec` whilst pushing
-- the separated `Methodology` into the stack. Useful for exhausting the `Rec` and
-- dealing with the cases later.
--
-- since @0.1.3.0
stripRecTerminal :: forall x c f xs r a. (Monoid c,
                    Members '[Methodology (f x) c] (Methodology (Rec f xs) c ': r))
                 => Sem (Methodology (Rec f (x ': xs)) c ': r) a
                 -> Sem (Methodology (Rec f xs) c ': r) a
stripRecTerminal :: Sem (Methodology (Rec f (x : xs)) c : r) a
-> Sem (Methodology (Rec f xs) c : r) a
stripRecTerminal = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology (Rec f (x : xs)) c (Sem rInitial) x
 -> Sem (Methodology (Rec f xs) c : r) x)
-> Sem (Methodology (Rec f (x : xs)) c : r) a
-> Sem (Methodology (Rec f xs) c : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : r) a
reinterpret \case
  Process (b :& bs) -> do
    c
k   <- f x -> Sem (Methodology (Rec f xs) c : r) c
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(f x) f x
f r
b
    c
k'  <- Rec f xs -> Sem (Methodology (Rec f xs) c : r) c
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(Rec f xs) @c Rec f xs
Rec f rs
bs
    c -> Sem (Methodology (Rec f xs) c : r) c
forall (m :: * -> *) a. Monad m => a -> m a
return (c -> Sem (Methodology (Rec f xs) c : r) c)
-> c -> Sem (Methodology (Rec f xs) c : r) c
forall a b. (a -> b) -> a -> b
$ c
k c -> c -> c
forall a. Semigroup a => a -> a -> a
<> c
k'
{-# INLINE stripRecTerminal #-}

-- | Discard a depleted `Methodology` fom a `Rec` by returning `mempty`.
--
-- @since 0.1.3.0
endRecTerminal :: Monoid b => Sem (Methodology (Rec f '[]) b ': r) a -> Sem r a
endRecTerminal :: Sem (Methodology (Rec f '[]) b : r) a -> Sem r a
endRecTerminal = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology (Rec f '[]) b (Sem rInitial) x -> Sem r x)
-> Sem (Methodology (Rec f '[]) b : r) a -> Sem r a
forall (e :: (* -> *) -> * -> *) (r :: [(* -> *) -> * -> *]) a.
FirstOrder e "interpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e (Sem rInitial) x -> Sem r x)
-> Sem (e : r) a -> Sem r a
interpret \case
  Process _ -> x -> Sem r x
forall (m :: * -> *) a. Monad m => a -> m a
return x
forall a. Monoid a => a
mempty
{-# INLINE endRecTerminal #-}

-- | Like `fmapMethodology`, but used with a `Compose`d functor to strip the top
-- layer from the functor.
--
-- @since 0.1.4.0
fmapCMethodology :: forall f g h b c r a. Traversable f =>
                     Sem (Methodology ((f :. g) b) ((f :. h) c) ': r) a
                  -> Sem (Methodology (g b) (h c) ': r) a
fmapCMethodology :: Sem (Methodology ((:.) f g b) ((:.) f h c) : r) a
-> Sem (Methodology (g b) (h c) : r) a
fmapCMethodology = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology ((:.) f g b) ((:.) f h c) (Sem rInitial) x
 -> Sem (Methodology (g b) (h c) : r) x)
-> Sem (Methodology ((:.) f g b) ((:.) f h c) : r) a
-> Sem (Methodology (g b) (h c) : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : r) a
reinterpret \case
  Process b -> f (h c) -> (:.) f h c
forall l k (f :: l -> *) (g :: k -> l) (x :: k).
f (g x) -> Compose f g x
Compose (f (h c) -> (:.) f h c)
-> Sem (Methodology (g b) (h c) : r) (f (h c))
-> Sem (Methodology (g b) (h c) : r) ((:.) f h c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (g b -> Sem (Methodology (g b) (h c) : r) (h c))
-> f (g b) -> Sem (Methodology (g b) (h c) : r) (f (h c))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology (g b) (h c)) r =>
g b -> Sem r (h c)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(g b) @(h c)) ((:.) f g b -> f (g b)
forall l (f :: l -> *) k (g :: k -> l) (x :: k).
Compose f g x -> f (g x)
getCompose (:.) f g b
b)
{-# INLINE fmapCMethodology #-}

-- | Reinterpreting version of `fmapCMethodology`.
--
-- @since 0.1.4.0
fmapCMethodology' :: forall f g h b c r a. Traversable f =>
                     Sem (Methodology ((f :. g) b) ((f :. h) c) ': r) a
                  -> Sem (Methodology (g b) (h c) ': r) a
fmapCMethodology' :: Sem (Methodology ((:.) f g b) ((:.) f h c) : r) a
-> Sem (Methodology (g b) (h c) : r) a
fmapCMethodology' = (forall (rInitial :: [(* -> *) -> * -> *]) x.
 Methodology ((:.) f g b) ((:.) f h c) (Sem rInitial) x
 -> Sem (Methodology (g b) (h c) : r) x)
-> Sem (Methodology ((:.) f g b) ((:.) f h c) : r) a
-> Sem (Methodology (g b) (h c) : r) a
forall (e1 :: (* -> *) -> * -> *) (e2 :: (* -> *) -> * -> *)
       (r :: [(* -> *) -> * -> *]) a.
FirstOrder e1 "reinterpret" =>
(forall (rInitial :: [(* -> *) -> * -> *]) x.
 e1 (Sem rInitial) x -> Sem (e2 : r) x)
-> Sem (e1 : r) a -> Sem (e2 : r) a
reinterpret \case
  Process b -> f (h c) -> (:.) f h c
forall l k (f :: l -> *) (g :: k -> l) (x :: k).
f (g x) -> Compose f g x
Compose (f (h c) -> (:.) f h c)
-> Sem (Methodology (g b) (h c) : r) (f (h c))
-> Sem (Methodology (g b) (h c) : r) ((:.) f h c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (g b -> Sem (Methodology (g b) (h c) : r) (h c))
-> f (g b) -> Sem (Methodology (g b) (h c) : r) (f (h c))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology (g b) (h c)) r =>
g b -> Sem r (h c)
forall b c (r :: [(* -> *) -> * -> *]).
MemberWithError (Methodology b c) r =>
b -> Sem r c
process @(g b) @(h c)) ((:.) f g b -> f (g b)
forall l (f :: l -> *) k (g :: k -> l) (x :: k).
Compose f g x -> f (g x)
getCompose (:.) f g b
b)
{-# INLINE fmapCMethodology' #-}