{-# LANGUAGE ScopedTypeVariables #-}
------------------------------------------------------------------------
-- |
-- Module      :  Data.Extensible.Struct
-- Copyright   :  (c) Fumiaki Kinoshita 2018
-- License     :  BSD3
--
-- Maintainer  :  Fumiaki Kinoshita <fumiexcel@gmail.com>
--
-- Extensible tangles
------------------------------------------------------------------------
module Data.Extensible.Tangle
  ( TangleT(..)
  , lasso
  , hitchAt
  , runTangleT
  , evalTangleT
  , runTangles
  ) where

import Control.Applicative
import Control.Monad.Trans.RWS.Strict
import Control.Monad.Trans.Class
import Data.Extensible.Class
import Data.Extensible.Field
import Data.Extensible.Product
import Data.Extensible.Internal.Rig
import Data.Extensible.Nullable
import Data.Extensible.Wrapper

-- | @'TangleT' h xs m@ is the monad of computations that may depend on the elements in 'xs'.
newtype TangleT xs h m a = TangleT
  { TangleT xs h m a
-> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
unTangleT :: RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a }
  deriving (a -> TangleT xs h m b -> TangleT xs h m a
(a -> b) -> TangleT xs h m a -> TangleT xs h m b
(forall a b. (a -> b) -> TangleT xs h m a -> TangleT xs h m b)
-> (forall a b. a -> TangleT xs h m b -> TangleT xs h m a)
-> Functor (TangleT xs h m)
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Functor m =>
a -> TangleT xs h m b -> TangleT xs h m a
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Functor m =>
(a -> b) -> TangleT xs h m a -> TangleT xs h m b
forall a b. a -> TangleT xs h m b -> TangleT xs h m a
forall a b. (a -> b) -> TangleT xs h m a -> TangleT xs h m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> TangleT xs h m b -> TangleT xs h m a
$c<$ :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Functor m =>
a -> TangleT xs h m b -> TangleT xs h m a
fmap :: (a -> b) -> TangleT xs h m a -> TangleT xs h m b
$cfmap :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Functor m =>
(a -> b) -> TangleT xs h m a -> TangleT xs h m b
Functor, Functor (TangleT xs h m)
a -> TangleT xs h m a
Functor (TangleT xs h m) =>
(forall a. a -> TangleT xs h m a)
-> (forall a b.
    TangleT xs h m (a -> b) -> TangleT xs h m a -> TangleT xs h m b)
-> (forall a b c.
    (a -> b -> c)
    -> TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m c)
-> (forall a b.
    TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b)
-> (forall a b.
    TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m a)
-> Applicative (TangleT xs h m)
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m a
TangleT xs h m (a -> b) -> TangleT xs h m a -> TangleT xs h m b
(a -> b -> c)
-> TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m c
forall a. a -> TangleT xs h m a
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *).
Monad m =>
Functor (TangleT xs h m)
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a.
Monad m =>
a -> TangleT xs h m a
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m a
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m (a -> b) -> TangleT xs h m a -> TangleT xs h m b
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m c
forall a b.
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m a
forall a b.
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
forall a b.
TangleT xs h m (a -> b) -> TangleT xs h m a -> TangleT xs h m b
forall a b c.
(a -> b -> c)
-> TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m a
$c<* :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m a
*> :: TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
$c*> :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
liftA2 :: (a -> b -> c)
-> TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m c
$cliftA2 :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b c.
Monad m =>
(a -> b -> c)
-> TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m c
<*> :: TangleT xs h m (a -> b) -> TangleT xs h m a -> TangleT xs h m b
$c<*> :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m (a -> b) -> TangleT xs h m a -> TangleT xs h m b
pure :: a -> TangleT xs h m a
$cpure :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a.
Monad m =>
a -> TangleT xs h m a
$cp1Applicative :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *).
Monad m =>
Functor (TangleT xs h m)
Applicative, Applicative (TangleT xs h m)
a -> TangleT xs h m a
Applicative (TangleT xs h m) =>
(forall a b.
 TangleT xs h m a -> (a -> TangleT xs h m b) -> TangleT xs h m b)
-> (forall a b.
    TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b)
-> (forall a. a -> TangleT xs h m a)
-> Monad (TangleT xs h m)
TangleT xs h m a -> (a -> TangleT xs h m b) -> TangleT xs h m b
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
forall a. a -> TangleT xs h m a
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *).
Monad m =>
Applicative (TangleT xs h m)
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a.
Monad m =>
a -> TangleT xs h m a
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> (a -> TangleT xs h m b) -> TangleT xs h m b
forall a b.
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
forall a b.
TangleT xs h m a -> (a -> TangleT xs h m b) -> TangleT xs h m b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> TangleT xs h m a
$creturn :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a.
Monad m =>
a -> TangleT xs h m a
>> :: TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
$c>> :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> TangleT xs h m b -> TangleT xs h m b
>>= :: TangleT xs h m a -> (a -> TangleT xs h m b) -> TangleT xs h m b
$c>>= :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a b.
Monad m =>
TangleT xs h m a -> (a -> TangleT xs h m b) -> TangleT xs h m b
$cp1Monad :: forall k (xs :: [k]) (h :: k -> *) (m :: * -> *).
Monad m =>
Applicative (TangleT xs h m)
Monad)
{-# DEPRECATED TangleT "Use the tangle package instead" #-}

instance MonadTrans (TangleT xs h) where
  lift :: m a -> TangleT xs h m a
lift = RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
-> TangleT xs h m a
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a.
RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
-> TangleT xs h m a
TangleT (RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
 -> TangleT xs h m a)
-> (m a
    -> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a)
-> m a
-> TangleT xs h m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a
-> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift

instance (Monad m, Semigroup a) => Semigroup (TangleT xs h m a) where
  <> :: TangleT xs h m a -> TangleT xs h m a -> TangleT xs h m a
(<>) = (a -> a -> a)
-> TangleT xs h m a -> TangleT xs h m a -> TangleT xs h m a
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>)

instance (Monad m, Monoid a) => Monoid (TangleT xs h m a) where
  mempty :: TangleT xs h m a
mempty = a -> TangleT xs h m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty
  mappend :: TangleT xs h m a -> TangleT xs h m a -> TangleT xs h m a
mappend = TangleT xs h m a -> TangleT xs h m a -> TangleT xs h m a
forall a. Semigroup a => a -> a -> a
(<>)

-- | Hitch an element associated to the 'FieldName' through a wrapper.
lasso :: forall k v m h xs. (Monad m, Lookup xs k v, Wrapper h)
  => FieldName k -> TangleT xs h m (Repr h (k ':> v))
lasso :: FieldName k -> TangleT xs h m (Repr h (k ':> v))
lasso _ = Optic'
  (->) (Const (Repr h (k ':> v))) (h (k ':> v)) (Repr h (k ':> v))
-> h (k ':> v) -> Repr h (k ':> v)
forall a s. Optic' (->) (Const a) s a -> s -> a
view Optic'
  (->) (Const (Repr h (k ':> v))) (h (k ':> v)) (Repr h (k ':> v))
forall k (h :: k -> *) (f :: * -> *) (p :: * -> * -> *) (v :: k).
(Wrapper h, Functor f, Profunctor p) =>
Optic' p f (h v) (Repr h v)
_Wrapper (h (k ':> v) -> Repr h (k ':> v))
-> TangleT xs h m (h (k ':> v))
-> TangleT xs h m (Repr h (k ':> v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Membership xs (k ':> v) -> TangleT xs h m (h (k ':> v))
forall k (m :: * -> *) (xs :: [k]) (x :: k) (h :: k -> *).
Monad m =>
Membership xs x -> TangleT xs h m (h x)
hitchAt (Membership xs (k ':> v)
forall k k1 (xs :: [Assoc k k1]) (k2 :: k) (v :: k1).
Lookup xs k2 v =>
Membership xs (k2 ':> v)
association :: Membership xs (k ':> v))
{-# INLINE lasso #-}
{-# DEPRECATED lasso "Use the tangle package instead" #-}

-- | Take a value from the tangles. The result is memoized.
hitchAt :: Monad m => Membership xs x -> TangleT xs h m (h x)
hitchAt :: Membership xs x -> TangleT xs h m (h x)
hitchAt k :: Membership xs x
k = RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x)
-> TangleT xs h m (h x)
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a.
RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
-> TangleT xs h m a
TangleT (RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x)
 -> TangleT xs h m (h x))
-> RWST
     (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x)
-> TangleT xs h m (h x)
forall a b. (a -> b) -> a -> b
$ do
  xs :& Nullable h
mem <- RWST
  (xs :& Comp (TangleT xs h m) h)
  ()
  (xs :& Nullable h)
  m
  (xs :& Nullable h)
forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m s
get
  case Nullable h x -> Maybe (h x)
forall k (h :: k -> *) (x :: k). Nullable h x -> Maybe (h x)
getNullable (Nullable h x -> Maybe (h x)) -> Nullable h x -> Maybe (h x)
forall a b. (a -> b) -> a -> b
$ Membership xs x -> (xs :& Nullable h) -> Nullable h x
forall k (xs :: [k]) (x :: k) (h :: k -> *).
Membership xs x -> (xs :& h) -> h x
hlookup Membership xs x
k xs :& Nullable h
mem of
    Just a :: h x
a -> h x
-> RWST
     (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x)
forall (m :: * -> *) a. Monad m => a -> m a
return h x
a
    Nothing -> do
      xs :& Comp (TangleT xs h m) h
tangles <- RWST
  (xs :& Comp (TangleT xs h m) h)
  ()
  (xs :& Nullable h)
  m
  (xs :& Comp (TangleT xs h m) h)
forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m r
ask
      h x
a <- TangleT xs h m (h x)
-> RWST
     (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x)
forall k (xs :: [k]) (h :: k -> *) (m :: * -> *) a.
TangleT xs h m a
-> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
unTangleT (TangleT xs h m (h x)
 -> RWST
      (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x))
-> TangleT xs h m (h x)
-> RWST
     (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x)
forall a b. (a -> b) -> a -> b
$ Comp (TangleT xs h m) h x -> TangleT xs h m (h x)
forall j (f :: j -> *) i (g :: i -> j) (a :: i).
Comp f g a -> f (g a)
getComp (Comp (TangleT xs h m) h x -> TangleT xs h m (h x))
-> Comp (TangleT xs h m) h x -> TangleT xs h m (h x)
forall a b. (a -> b) -> a -> b
$ Membership xs x
-> (xs :& Comp (TangleT xs h m) h) -> Comp (TangleT xs h m) h x
forall k (xs :: [k]) (x :: k) (h :: k -> *).
Membership xs x -> (xs :& h) -> h x
hlookup Membership xs x
k xs :& Comp (TangleT xs h m) h
tangles
      ((xs :& Nullable h) -> xs :& Nullable h)
-> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m ()
forall w (m :: * -> *) s r.
(Monoid w, Monad m) =>
(s -> s) -> RWST r w s m ()
modify (((xs :& Nullable h) -> xs :& Nullable h)
 -> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m ())
-> ((xs :& Nullable h) -> xs :& Nullable h)
-> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m ()
forall a b. (a -> b) -> a -> b
$ Optic
  (->)
  Identity
  (xs :& Nullable h)
  (xs :& Nullable h)
  (Nullable h x)
  (Nullable h x)
-> (Nullable h x -> Nullable h x)
-> (xs :& Nullable h)
-> xs :& Nullable h
forall s t a b. Optic (->) Identity s t a b -> (a -> b) -> s -> t
over (Membership xs x
-> Optic
     (->)
     Identity
     (xs :& Nullable h)
     (xs :& Nullable h)
     (Nullable h x)
     (Nullable h x)
forall k (f :: * -> *) (p :: * -> * -> *)
       (t :: [k] -> (k -> *) -> *) (xs :: [k]) (h :: k -> *) (x :: k).
(Extensible f p t, ExtensibleConstr t xs h x) =>
Membership xs x -> Optic' p f (t xs h) (h x)
pieceAt Membership xs x
k) ((Nullable h x -> Nullable h x)
 -> (xs :& Nullable h) -> xs :& Nullable h)
-> (Nullable h x -> Nullable h x)
-> (xs :& Nullable h)
-> xs :& Nullable h
forall a b. (a -> b) -> a -> b
$ Nullable h x -> Nullable h x -> Nullable h x
forall a b. a -> b -> a
const (Nullable h x -> Nullable h x -> Nullable h x)
-> Nullable h x -> Nullable h x -> Nullable h x
forall a b. (a -> b) -> a -> b
$ Maybe (h x) -> Nullable h x
forall k (h :: k -> *) (x :: k). Maybe (h x) -> Nullable h x
Nullable (Maybe (h x) -> Nullable h x) -> Maybe (h x) -> Nullable h x
forall a b. (a -> b) -> a -> b
$ h x -> Maybe (h x)
forall a. a -> Maybe a
Just h x
a
      h x
-> RWST
     (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m (h x)
forall (m :: * -> *) a. Monad m => a -> m a
return h x
a
{-# DEPRECATED hitchAt "Use the tangle package instead" #-}

-- | Run a 'TangleT' action and return the result and the calculated values.
runTangleT :: Monad m
  => xs :& Comp (TangleT xs h m) h
  -> xs :& Nullable h
  -> TangleT xs h m a
  -> m (a, xs :& Nullable h)
runTangleT :: (xs :& Comp (TangleT xs h m) h)
-> (xs :& Nullable h)
-> TangleT xs h m a
-> m (a, xs :& Nullable h)
runTangleT tangles :: xs :& Comp (TangleT xs h m) h
tangles rec0 :: xs :& Nullable h
rec0 (TangleT m :: RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
m) = (\(a :: a
a, s :: xs :& Nullable h
s, _) -> (a
a, xs :& Nullable h
s))
  ((a, xs :& Nullable h, ()) -> (a, xs :& Nullable h))
-> m (a, xs :& Nullable h, ()) -> m (a, xs :& Nullable h)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
-> (xs :& Comp (TangleT xs h m) h)
-> (xs :& Nullable h)
-> m (a, xs :& Nullable h, ())
forall r w s (m :: * -> *) a.
RWST r w s m a -> r -> s -> m (a, s, w)
runRWST RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
m xs :& Comp (TangleT xs h m) h
tangles xs :& Nullable h
rec0
{-# INLINE runTangleT #-}
{-# DEPRECATED runTangleT "Use the tangle package instead" #-}

-- | Run a 'TangleT' action.
evalTangleT :: Monad m
  => xs :& Comp (TangleT xs h m) h
  -> xs :& Nullable h
  -> TangleT xs h m a
  -> m a
evalTangleT :: (xs :& Comp (TangleT xs h m) h)
-> (xs :& Nullable h) -> TangleT xs h m a -> m a
evalTangleT tangles :: xs :& Comp (TangleT xs h m) h
tangles rec0 :: xs :& Nullable h
rec0 (TangleT m :: RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
m) = (a, ()) -> a
forall a b. (a, b) -> a
fst ((a, ()) -> a) -> m (a, ()) -> m a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
-> (xs :& Comp (TangleT xs h m) h)
-> (xs :& Nullable h)
-> m (a, ())
forall (m :: * -> *) r w s a.
Monad m =>
RWST r w s m a -> r -> s -> m (a, w)
evalRWST RWST (xs :& Comp (TangleT xs h m) h) () (xs :& Nullable h) m a
m xs :& Comp (TangleT xs h m) h
tangles xs :& Nullable h
rec0
{-# INLINE evalTangleT #-}
{-# DEPRECATED evalTangleT "Use the tangle package instead" #-}

-- | Run tangles and collect all the results as a 'Record'.
runTangles :: Monad m
  => xs :& Comp (TangleT xs h m) h
  -> xs :& Nullable h
  -> m (xs :& h)
runTangles :: (xs :& Comp (TangleT xs h m) h)
-> (xs :& Nullable h) -> m (xs :& h)
runTangles ts :: xs :& Comp (TangleT xs h m) h
ts vs :: xs :& Nullable h
vs = (xs :& Comp (TangleT xs h m) h)
-> (xs :& Nullable h) -> TangleT xs h m (xs :& h) -> m (xs :& h)
forall k (m :: * -> *) (xs :: [k]) (h :: k -> *) a.
Monad m =>
(xs :& Comp (TangleT xs h m) h)
-> (xs :& Nullable h) -> TangleT xs h m a -> m a
evalTangleT xs :& Comp (TangleT xs h m) h
ts xs :& Nullable h
vs (TangleT xs h m (xs :& h) -> m (xs :& h))
-> TangleT xs h m (xs :& h) -> m (xs :& h)
forall a b. (a -> b) -> a -> b
$ (forall (x :: k).
 Membership xs x -> Nullable h x -> TangleT xs h m (h x))
-> (xs :& Nullable h) -> TangleT xs h m (xs :& h)
forall k (f :: * -> *) (xs :: [k]) (g :: k -> *) (h :: k -> *).
Applicative f =>
(forall (x :: k). Membership xs x -> g x -> f (h x))
-> (xs :& g) -> f (xs :& h)
htraverseWithIndex (TangleT xs h m (h x) -> Nullable h x -> TangleT xs h m (h x)
forall a b. a -> b -> a
const (TangleT xs h m (h x) -> Nullable h x -> TangleT xs h m (h x))
-> (Membership xs x -> TangleT xs h m (h x))
-> Membership xs x
-> Nullable h x
-> TangleT xs h m (h x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Membership xs x -> TangleT xs h m (h x)
forall k (m :: * -> *) (xs :: [k]) (x :: k) (h :: k -> *).
Monad m =>
Membership xs x -> TangleT xs h m (h x)
hitchAt) xs :& Nullable h
vs
{-# INLINE runTangles #-}