{-# LANGUAGE AllowAmbiguousTypes  #-}
{-# LANGUAGE UndecidableInstances #-}
-- |
-- Module      : DynamicPipeline.Flow
-- Copyright   : (c) 2021 Juan Pablo Royo Sales
--
-- License     : BSD3
-- Maintainer  : juanpablo.royo@gmail.com
-- Stability   : experimental
-- Portability : GHC
--
module DynamicPipeline.Flow 
    ( Eof,
      Sink,
      Generator,
      Source,
      Channel,
      type (:>>)(..),
      type (:<+>)(..),
      ChanIn,
      ChanOut,
      ChanOutIn,
      ChansFilter,
      ChanWriteSource,
      ChanReadWriteGen,
      ChanReadOut,
      MkCh(..),
      MkChans(..),
      ExpandGenToCh, 
      ExpandSinkToCh,
      ExpandSourceToCh,
      ExpandFilterToCh,
      AllChans,
      FilterChans,
      inGenOut,
      makeChans,
      getFilterChannels
    ) where

import           Control.Lens                             hiding ((<|))
import           Data.Foldable                            as F
import           Data.HList
import           Data.HList.Labelable
import           DynamicPipeline.Channel
import           Relude                                   as R

-- | 'Source' contains the 'Source' Stage its Channels definitions in the DP definition Flow.
-- 
-- @ a ~ 'Channel' @
data Source (a :: Type)

-- | 'Generator' contains the 'Generator' Stage its Channels definitions in the DP definition Flow.
-- 
-- @ a ~ 'Channel' @
data Generator (a :: Type)

-- | 'Sink' contains the 'Sink' Stage end of Flow of DP definition.
data Sink

-- |'Eof' is the __End of Channel__ mark in the DP Definition Flow
data Eof

-- |'Channel' is the Container Type of /Open Union Type/ which is going to be defined with ':<+>'.
--
-- @ a ~ (Type ':<+>' Type ':<+>' ... ':<+>' Eof) @
data Channel (a :: Type)

-- | This is the Type level function of the /Open Union Type/ for Channels. 
-- 
-- Channels forms an /Open Union Type/ in each stage because according to __DPP__ we can have multiple /In/ and /Out/ Channels 
-- in a Single Stage. 
--
-- 'Eof' should be the last Channel of the /Open Union Type/ to indicate termination of the Grammar.
--
-- @ chann1 ~ Type @
--
-- @ chann2 ~ Type @
data chann1 :<+> chann2 = chann1 :<+> chann2
 deriving (Typeable, (chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool
((chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool)
-> ((chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool)
-> Eq (chann1 :<+> chann2)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall chann1 chann2.
(Eq chann1, Eq chann2) =>
(chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool
/= :: (chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool
$c/= :: forall chann1 chann2.
(Eq chann1, Eq chann2) =>
(chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool
== :: (chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool
$c== :: forall chann1 chann2.
(Eq chann1, Eq chann2) =>
(chann1 :<+> chann2) -> (chann1 :<+> chann2) -> Bool
Eq, Int -> (chann1 :<+> chann2) -> ShowS
[chann1 :<+> chann2] -> ShowS
(chann1 :<+> chann2) -> String
(Int -> (chann1 :<+> chann2) -> ShowS)
-> ((chann1 :<+> chann2) -> String)
-> ([chann1 :<+> chann2] -> ShowS)
-> Show (chann1 :<+> chann2)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall chann1 chann2.
(Show chann1, Show chann2) =>
Int -> (chann1 :<+> chann2) -> ShowS
forall chann1 chann2.
(Show chann1, Show chann2) =>
[chann1 :<+> chann2] -> ShowS
forall chann1 chann2.
(Show chann1, Show chann2) =>
(chann1 :<+> chann2) -> String
showList :: [chann1 :<+> chann2] -> ShowS
$cshowList :: forall chann1 chann2.
(Show chann1, Show chann2) =>
[chann1 :<+> chann2] -> ShowS
show :: (chann1 :<+> chann2) -> String
$cshow :: forall chann1 chann2.
(Show chann1, Show chann2) =>
(chann1 :<+> chann2) -> String
showsPrec :: Int -> (chann1 :<+> chann2) -> ShowS
$cshowsPrec :: forall chann1 chann2.
(Show chann1, Show chann2) =>
Int -> (chann1 :<+> chann2) -> ShowS
Show, a -> (chann1 :<+> b) -> chann1 :<+> a
(a -> b) -> (chann1 :<+> a) -> chann1 :<+> b
(forall a b. (a -> b) -> (chann1 :<+> a) -> chann1 :<+> b)
-> (forall a b. a -> (chann1 :<+> b) -> chann1 :<+> a)
-> Functor ((:<+>) chann1)
forall a b. a -> (chann1 :<+> b) -> chann1 :<+> a
forall a b. (a -> b) -> (chann1 :<+> a) -> chann1 :<+> b
forall chann1 a b. a -> (chann1 :<+> b) -> chann1 :<+> a
forall chann1 a b. (a -> b) -> (chann1 :<+> a) -> chann1 :<+> b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> (chann1 :<+> b) -> chann1 :<+> a
$c<$ :: forall chann1 a b. a -> (chann1 :<+> b) -> chann1 :<+> a
fmap :: (a -> b) -> (chann1 :<+> a) -> chann1 :<+> b
$cfmap :: forall chann1 a b. (a -> b) -> (chann1 :<+> a) -> chann1 :<+> b
Functor, Functor ((:<+>) chann1)
Foldable ((:<+>) chann1)
(Functor ((:<+>) chann1), Foldable ((:<+>) chann1)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> (chann1 :<+> a) -> f (chann1 :<+> b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    (chann1 :<+> f a) -> f (chann1 :<+> a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> (chann1 :<+> a) -> m (chann1 :<+> b))
-> (forall (m :: * -> *) a.
    Monad m =>
    (chann1 :<+> m a) -> m (chann1 :<+> a))
-> Traversable ((:<+>) chann1)
(a -> f b) -> (chann1 :<+> a) -> f (chann1 :<+> b)
forall chann1. Functor ((:<+>) chann1)
forall chann1. Foldable ((:<+>) chann1)
forall chann1 (m :: * -> *) a.
Monad m =>
(chann1 :<+> m a) -> m (chann1 :<+> a)
forall chann1 (f :: * -> *) a.
Applicative f =>
(chann1 :<+> f a) -> f (chann1 :<+> a)
forall chann1 (m :: * -> *) a b.
Monad m =>
(a -> m b) -> (chann1 :<+> a) -> m (chann1 :<+> b)
forall chann1 (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (chann1 :<+> a) -> f (chann1 :<+> b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
(chann1 :<+> m a) -> m (chann1 :<+> a)
forall (f :: * -> *) a.
Applicative f =>
(chann1 :<+> f a) -> f (chann1 :<+> a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> (chann1 :<+> a) -> m (chann1 :<+> b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (chann1 :<+> a) -> f (chann1 :<+> b)
sequence :: (chann1 :<+> m a) -> m (chann1 :<+> a)
$csequence :: forall chann1 (m :: * -> *) a.
Monad m =>
(chann1 :<+> m a) -> m (chann1 :<+> a)
mapM :: (a -> m b) -> (chann1 :<+> a) -> m (chann1 :<+> b)
$cmapM :: forall chann1 (m :: * -> *) a b.
Monad m =>
(a -> m b) -> (chann1 :<+> a) -> m (chann1 :<+> b)
sequenceA :: (chann1 :<+> f a) -> f (chann1 :<+> a)
$csequenceA :: forall chann1 (f :: * -> *) a.
Applicative f =>
(chann1 :<+> f a) -> f (chann1 :<+> a)
traverse :: (a -> f b) -> (chann1 :<+> a) -> f (chann1 :<+> b)
$ctraverse :: forall chann1 (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (chann1 :<+> a) -> f (chann1 :<+> b)
$cp2Traversable :: forall chann1. Foldable ((:<+>) chann1)
$cp1Traversable :: forall chann1. Functor ((:<+>) chann1)
Traversable, (chann1 :<+> a) -> Bool
(a -> m) -> (chann1 :<+> a) -> m
(a -> b -> b) -> b -> (chann1 :<+> a) -> b
(forall m. Monoid m => (chann1 :<+> m) -> m)
-> (forall m a. Monoid m => (a -> m) -> (chann1 :<+> a) -> m)
-> (forall m a. Monoid m => (a -> m) -> (chann1 :<+> a) -> m)
-> (forall a b. (a -> b -> b) -> b -> (chann1 :<+> a) -> b)
-> (forall a b. (a -> b -> b) -> b -> (chann1 :<+> a) -> b)
-> (forall b a. (b -> a -> b) -> b -> (chann1 :<+> a) -> b)
-> (forall b a. (b -> a -> b) -> b -> (chann1 :<+> a) -> b)
-> (forall a. (a -> a -> a) -> (chann1 :<+> a) -> a)
-> (forall a. (a -> a -> a) -> (chann1 :<+> a) -> a)
-> (forall a. (chann1 :<+> a) -> [a])
-> (forall a. (chann1 :<+> a) -> Bool)
-> (forall a. (chann1 :<+> a) -> Int)
-> (forall a. Eq a => a -> (chann1 :<+> a) -> Bool)
-> (forall a. Ord a => (chann1 :<+> a) -> a)
-> (forall a. Ord a => (chann1 :<+> a) -> a)
-> (forall a. Num a => (chann1 :<+> a) -> a)
-> (forall a. Num a => (chann1 :<+> a) -> a)
-> Foldable ((:<+>) chann1)
forall a. Eq a => a -> (chann1 :<+> a) -> Bool
forall a. Num a => (chann1 :<+> a) -> a
forall a. Ord a => (chann1 :<+> a) -> a
forall m. Monoid m => (chann1 :<+> m) -> m
forall a. (chann1 :<+> a) -> Bool
forall a. (chann1 :<+> a) -> Int
forall a. (chann1 :<+> a) -> [a]
forall a. (a -> a -> a) -> (chann1 :<+> a) -> a
forall chann1 a. Eq a => a -> (chann1 :<+> a) -> Bool
forall chann1 a. Num a => (chann1 :<+> a) -> a
forall chann1 a. Ord a => (chann1 :<+> a) -> a
forall m a. Monoid m => (a -> m) -> (chann1 :<+> a) -> m
forall chann1 m. Monoid m => (chann1 :<+> m) -> m
forall chann1 a. (chann1 :<+> a) -> Bool
forall chann1 a. (chann1 :<+> a) -> Int
forall chann1 a. (chann1 :<+> a) -> [a]
forall b a. (b -> a -> b) -> b -> (chann1 :<+> a) -> b
forall a b. (a -> b -> b) -> b -> (chann1 :<+> a) -> b
forall chann1 a. (a -> a -> a) -> (chann1 :<+> a) -> a
forall chann1 m a. Monoid m => (a -> m) -> (chann1 :<+> a) -> m
forall chann1 b a. (b -> a -> b) -> b -> (chann1 :<+> a) -> b
forall chann1 a b. (a -> b -> b) -> b -> (chann1 :<+> a) -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: (chann1 :<+> a) -> a
$cproduct :: forall chann1 a. Num a => (chann1 :<+> a) -> a
sum :: (chann1 :<+> a) -> a
$csum :: forall chann1 a. Num a => (chann1 :<+> a) -> a
minimum :: (chann1 :<+> a) -> a
$cminimum :: forall chann1 a. Ord a => (chann1 :<+> a) -> a
maximum :: (chann1 :<+> a) -> a
$cmaximum :: forall chann1 a. Ord a => (chann1 :<+> a) -> a
elem :: a -> (chann1 :<+> a) -> Bool
$celem :: forall chann1 a. Eq a => a -> (chann1 :<+> a) -> Bool
length :: (chann1 :<+> a) -> Int
$clength :: forall chann1 a. (chann1 :<+> a) -> Int
null :: (chann1 :<+> a) -> Bool
$cnull :: forall chann1 a. (chann1 :<+> a) -> Bool
toList :: (chann1 :<+> a) -> [a]
$ctoList :: forall chann1 a. (chann1 :<+> a) -> [a]
foldl1 :: (a -> a -> a) -> (chann1 :<+> a) -> a
$cfoldl1 :: forall chann1 a. (a -> a -> a) -> (chann1 :<+> a) -> a
foldr1 :: (a -> a -> a) -> (chann1 :<+> a) -> a
$cfoldr1 :: forall chann1 a. (a -> a -> a) -> (chann1 :<+> a) -> a
foldl' :: (b -> a -> b) -> b -> (chann1 :<+> a) -> b
$cfoldl' :: forall chann1 b a. (b -> a -> b) -> b -> (chann1 :<+> a) -> b
foldl :: (b -> a -> b) -> b -> (chann1 :<+> a) -> b
$cfoldl :: forall chann1 b a. (b -> a -> b) -> b -> (chann1 :<+> a) -> b
foldr' :: (a -> b -> b) -> b -> (chann1 :<+> a) -> b
$cfoldr' :: forall chann1 a b. (a -> b -> b) -> b -> (chann1 :<+> a) -> b
foldr :: (a -> b -> b) -> b -> (chann1 :<+> a) -> b
$cfoldr :: forall chann1 a b. (a -> b -> b) -> b -> (chann1 :<+> a) -> b
foldMap' :: (a -> m) -> (chann1 :<+> a) -> m
$cfoldMap' :: forall chann1 m a. Monoid m => (a -> m) -> (chann1 :<+> a) -> m
foldMap :: (a -> m) -> (chann1 :<+> a) -> m
$cfoldMap :: forall chann1 m a. Monoid m => (a -> m) -> (chann1 :<+> a) -> m
fold :: (chann1 :<+> m) -> m
$cfold :: forall chann1 m. Monoid m => (chann1 :<+> m) -> m
Foldable, chann1 :<+> chann2
(chann1 :<+> chann2)
-> (chann1 :<+> chann2) -> Bounded (chann1 :<+> chann2)
forall a. a -> a -> Bounded a
forall chann1 chann2.
(Bounded chann1, Bounded chann2) =>
chann1 :<+> chann2
maxBound :: chann1 :<+> chann2
$cmaxBound :: forall chann1 chann2.
(Bounded chann1, Bounded chann2) =>
chann1 :<+> chann2
minBound :: chann1 :<+> chann2
$cminBound :: forall chann1 chann2.
(Bounded chann1, Bounded chann2) =>
chann1 :<+> chann2
Bounded)
infixr 5 :<+>

-- | This is the Type level function of the /Open Union Type/ for Stages. 
-- 
-- This should have the form:
--
-- @ 'Source' ('Channel' ..) ':>>' 'Generator' ('Channel' ..) ':>>' 'Sink' @
data a :>> b = a :>> b
  deriving (Typeable, (a :>> b) -> (a :>> b) -> Bool
((a :>> b) -> (a :>> b) -> Bool)
-> ((a :>> b) -> (a :>> b) -> Bool) -> Eq (a :>> b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b. (Eq a, Eq b) => (a :>> b) -> (a :>> b) -> Bool
/= :: (a :>> b) -> (a :>> b) -> Bool
$c/= :: forall a b. (Eq a, Eq b) => (a :>> b) -> (a :>> b) -> Bool
== :: (a :>> b) -> (a :>> b) -> Bool
$c== :: forall a b. (Eq a, Eq b) => (a :>> b) -> (a :>> b) -> Bool
Eq, Int -> (a :>> b) -> ShowS
[a :>> b] -> ShowS
(a :>> b) -> String
(Int -> (a :>> b) -> ShowS)
-> ((a :>> b) -> String) -> ([a :>> b] -> ShowS) -> Show (a :>> b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show a, Show b) => Int -> (a :>> b) -> ShowS
forall a b. (Show a, Show b) => [a :>> b] -> ShowS
forall a b. (Show a, Show b) => (a :>> b) -> String
showList :: [a :>> b] -> ShowS
$cshowList :: forall a b. (Show a, Show b) => [a :>> b] -> ShowS
show :: (a :>> b) -> String
$cshow :: forall a b. (Show a, Show b) => (a :>> b) -> String
showsPrec :: Int -> (a :>> b) -> ShowS
$cshowsPrec :: forall a b. (Show a, Show b) => Int -> (a :>> b) -> ShowS
Show, a -> (a :>> b) -> a :>> a
(a -> b) -> (a :>> a) -> a :>> b
(forall a b. (a -> b) -> (a :>> a) -> a :>> b)
-> (forall a b. a -> (a :>> b) -> a :>> a) -> Functor ((:>>) a)
forall a b. a -> (a :>> b) -> a :>> a
forall a b. (a -> b) -> (a :>> a) -> a :>> b
forall a a b. a -> (a :>> b) -> a :>> a
forall a a b. (a -> b) -> (a :>> a) -> a :>> b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> (a :>> b) -> a :>> a
$c<$ :: forall a a b. a -> (a :>> b) -> a :>> a
fmap :: (a -> b) -> (a :>> a) -> a :>> b
$cfmap :: forall a a b. (a -> b) -> (a :>> a) -> a :>> b
Functor, Functor ((:>>) a)
Foldable ((:>>) a)
(Functor ((:>>) a), Foldable ((:>>) a)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> (a :>> a) -> f (a :>> b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    (a :>> f a) -> f (a :>> a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> (a :>> a) -> m (a :>> b))
-> (forall (m :: * -> *) a. Monad m => (a :>> m a) -> m (a :>> a))
-> Traversable ((:>>) a)
(a -> f b) -> (a :>> a) -> f (a :>> b)
forall a. Functor ((:>>) a)
forall a. Foldable ((:>>) a)
forall a (m :: * -> *) a. Monad m => (a :>> m a) -> m (a :>> a)
forall a (f :: * -> *) a.
Applicative f =>
(a :>> f a) -> f (a :>> a)
forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> (a :>> a) -> m (a :>> b)
forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (a :>> a) -> f (a :>> b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => (a :>> m a) -> m (a :>> a)
forall (f :: * -> *) a. Applicative f => (a :>> f a) -> f (a :>> a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> (a :>> a) -> m (a :>> b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (a :>> a) -> f (a :>> b)
sequence :: (a :>> m a) -> m (a :>> a)
$csequence :: forall a (m :: * -> *) a. Monad m => (a :>> m a) -> m (a :>> a)
mapM :: (a -> m b) -> (a :>> a) -> m (a :>> b)
$cmapM :: forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> (a :>> a) -> m (a :>> b)
sequenceA :: (a :>> f a) -> f (a :>> a)
$csequenceA :: forall a (f :: * -> *) a.
Applicative f =>
(a :>> f a) -> f (a :>> a)
traverse :: (a -> f b) -> (a :>> a) -> f (a :>> b)
$ctraverse :: forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> (a :>> a) -> f (a :>> b)
$cp2Traversable :: forall a. Foldable ((:>>) a)
$cp1Traversable :: forall a. Functor ((:>>) a)
Traversable, (a :>> a) -> Bool
(a -> m) -> (a :>> a) -> m
(a -> b -> b) -> b -> (a :>> a) -> b
(forall m. Monoid m => (a :>> m) -> m)
-> (forall m a. Monoid m => (a -> m) -> (a :>> a) -> m)
-> (forall m a. Monoid m => (a -> m) -> (a :>> a) -> m)
-> (forall a b. (a -> b -> b) -> b -> (a :>> a) -> b)
-> (forall a b. (a -> b -> b) -> b -> (a :>> a) -> b)
-> (forall b a. (b -> a -> b) -> b -> (a :>> a) -> b)
-> (forall b a. (b -> a -> b) -> b -> (a :>> a) -> b)
-> (forall a. (a -> a -> a) -> (a :>> a) -> a)
-> (forall a. (a -> a -> a) -> (a :>> a) -> a)
-> (forall a. (a :>> a) -> [a])
-> (forall a. (a :>> a) -> Bool)
-> (forall a. (a :>> a) -> Int)
-> (forall a. Eq a => a -> (a :>> a) -> Bool)
-> (forall a. Ord a => (a :>> a) -> a)
-> (forall a. Ord a => (a :>> a) -> a)
-> (forall a. Num a => (a :>> a) -> a)
-> (forall a. Num a => (a :>> a) -> a)
-> Foldable ((:>>) a)
forall a. Eq a => a -> (a :>> a) -> Bool
forall a. Num a => (a :>> a) -> a
forall a. Ord a => (a :>> a) -> a
forall m. Monoid m => (a :>> m) -> m
forall a. (a :>> a) -> Bool
forall a. (a :>> a) -> Int
forall a. (a :>> a) -> [a]
forall a. (a -> a -> a) -> (a :>> a) -> a
forall a a. Eq a => a -> (a :>> a) -> Bool
forall a a. Num a => (a :>> a) -> a
forall a a. Ord a => (a :>> a) -> a
forall m a. Monoid m => (a -> m) -> (a :>> a) -> m
forall a m. Monoid m => (a :>> m) -> m
forall a a. (a :>> a) -> Bool
forall a a. (a :>> a) -> Int
forall a a. (a :>> a) -> [a]
forall b a. (b -> a -> b) -> b -> (a :>> a) -> b
forall a b. (a -> b -> b) -> b -> (a :>> a) -> b
forall a a. (a -> a -> a) -> (a :>> a) -> a
forall a m a. Monoid m => (a -> m) -> (a :>> a) -> m
forall a b a. (b -> a -> b) -> b -> (a :>> a) -> b
forall a a b. (a -> b -> b) -> b -> (a :>> a) -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: (a :>> a) -> a
$cproduct :: forall a a. Num a => (a :>> a) -> a
sum :: (a :>> a) -> a
$csum :: forall a a. Num a => (a :>> a) -> a
minimum :: (a :>> a) -> a
$cminimum :: forall a a. Ord a => (a :>> a) -> a
maximum :: (a :>> a) -> a
$cmaximum :: forall a a. Ord a => (a :>> a) -> a
elem :: a -> (a :>> a) -> Bool
$celem :: forall a a. Eq a => a -> (a :>> a) -> Bool
length :: (a :>> a) -> Int
$clength :: forall a a. (a :>> a) -> Int
null :: (a :>> a) -> Bool
$cnull :: forall a a. (a :>> a) -> Bool
toList :: (a :>> a) -> [a]
$ctoList :: forall a a. (a :>> a) -> [a]
foldl1 :: (a -> a -> a) -> (a :>> a) -> a
$cfoldl1 :: forall a a. (a -> a -> a) -> (a :>> a) -> a
foldr1 :: (a -> a -> a) -> (a :>> a) -> a
$cfoldr1 :: forall a a. (a -> a -> a) -> (a :>> a) -> a
foldl' :: (b -> a -> b) -> b -> (a :>> a) -> b
$cfoldl' :: forall a b a. (b -> a -> b) -> b -> (a :>> a) -> b
foldl :: (b -> a -> b) -> b -> (a :>> a) -> b
$cfoldl :: forall a b a. (b -> a -> b) -> b -> (a :>> a) -> b
foldr' :: (a -> b -> b) -> b -> (a :>> a) -> b
$cfoldr' :: forall a a b. (a -> b -> b) -> b -> (a :>> a) -> b
foldr :: (a -> b -> b) -> b -> (a :>> a) -> b
$cfoldr :: forall a a b. (a -> b -> b) -> b -> (a :>> a) -> b
foldMap' :: (a -> m) -> (a :>> a) -> m
$cfoldMap' :: forall a m a. Monoid m => (a -> m) -> (a :>> a) -> m
foldMap :: (a -> m) -> (a :>> a) -> m
$cfoldMap :: forall a m a. Monoid m => (a -> m) -> (a :>> a) -> m
fold :: (a :>> m) -> m
$cfold :: forall a m. Monoid m => (a :>> m) -> m
Foldable, a :>> b
(a :>> b) -> (a :>> b) -> Bounded (a :>> b)
forall a. a -> a -> Bounded a
forall a b. (Bounded a, Bounded b) => a :>> b
maxBound :: a :>> b
$cmaxBound :: forall a b. (Bounded a, Bounded b) => a :>> b
minBound :: a :>> b
$cminBound :: forall a b. (Bounded a, Bounded b) => a :>> b
Bounded)
infixr 5 :>>

-- Internal Data Types for expanding function based on Channel definitions
{-# WARNING ChanIn "INTERNAL USE" #-}
data ChanIn (a :: Type)
{-# WARNING ChanOut "INTERNAL USE" #-}
data ChanOut (a :: Type)
{-# WARNING ChanOutIn "INTERNAL USE" #-}
data ChanOutIn (a :: Type) (b :: Type)
{-# WARNING ChansFilter "INTERNAL USE" #-}
data ChansFilter (a :: Type)
{-# WARNING ChanWriteSource "INTERNAL USE" #-}
data ChanWriteSource (a :: Type)
{-# WARNING ChanReadWriteGen "INTERNAL USE" #-}
data ChanReadWriteGen (a :: Type)
{-# WARNING ChanReadOut "INTERNAL USE" #-}
data ChanReadOut (a :: Type)

-- Type encoding for Building Chans. Only for internal use in the Associated Type Family and combinators of MkCh and MkChans
-- For accessing Dynamic Indexed Records of Channels
{-# WARNING inLabel "INTERNAL USE" #-}
inLabel :: Label "Source"
inLabel :: Label "Source"
inLabel = Label "Source"
forall k (l :: k). Label l
Label

{-# WARNING genLabel "INTERNAL USE" #-}
genLabel :: Label "generator"
genLabel :: Label "generator"
genLabel = Label "generator"
forall k (l :: k). Label l
Label

{-# WARNING outLabel "INTERNAL USE" #-}
outLabel :: Label "Sink"
outLabel :: Label "Sink"
outLabel = Label "Sink"
forall k (l :: k). Label l
Label

{-# WARNING inChLabel "INTERNAL USE" #-}
inChLabel :: Label "in-ch"
inChLabel :: Label "in-ch"
inChLabel = Label "in-ch"
forall k (l :: k). Label l
Label

{-# WARNING outChLabel "INTERNAL USE" #-}
outChLabel :: Label "out-ch"
outChLabel :: Label "out-ch"
outChLabel = Label "out-ch"
forall k (l :: k). Label l
Label

-- Associated Type Family: Building Source and Sink Channels
{-# WARNING MkCh "INTERNAL USE" #-}
class MkCh (a :: Type) where
  type HChI a :: [Type]
  type HChO a :: [Type]
  mkCh :: Proxy a -> IO (HList (HChI a), HList (HChO a))

instance MkCh more => MkCh (a :<+> more) where
  type HChI (a :<+> more) = WriteChannel a ': HChI more
  type HChO (a :<+> more) = ReadChannel a ': HChO more
  mkCh :: Proxy (a :<+> more)
-> IO (HList (HChI (a :<+> more)), HList (HChO (a :<+> more)))
mkCh _ = do
    (i :: WriteChannel a
i, o :: ReadChannel a
o) <- IO (WriteChannel a, ReadChannel a)
forall a. IO (WriteChannel a, ReadChannel a)
newChannel @a
    (il :: HList (HChI more)
il, ol :: HList (HChO more)
ol) <- Proxy more -> IO (HList (HChI more), HList (HChO more))
forall a. MkCh a => Proxy a -> IO (HList (HChI a), HList (HChO a))
mkCh (Proxy more
forall k (t :: k). Proxy t
Proxy @more)
    (HList (WriteChannel a : HChI more),
 HList (ReadChannel a : HChO more))
-> IO
     (HList (WriteChannel a : HChI more),
      HList (ReadChannel a : HChO more))
forall (m :: * -> *) a. Monad m => a -> m a
return (WriteChannel a
i WriteChannel a
-> HList (HChI more)
-> HExtendR (WriteChannel a) (HList (HChI more))
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. HList (HChI more)
il, ReadChannel a
o ReadChannel a
-> HList (HChO more)
-> HExtendR (ReadChannel a) (HList (HChO more))
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. HList (HChO more)
ol)

instance MkCh Eof where
  type HChI Eof = '[]
  type HChO Eof = '[]
  mkCh :: Proxy Eof -> IO (HList (HChI Eof), HList (HChO Eof))
mkCh _ = (HList '[], HList '[]) -> IO (HList '[], HList '[])
forall (m :: * -> *) a. Monad m => a -> m a
return (HList '[]
HNil, HList '[]
HNil)

-- Type Family Defunctionalization to Expand Source, Generator and Sinks to its own HList Channel types.
{-# WARNING ExpandToHList "INTERNAL USE" #-}
type family ExpandToHList (a :: Type) (param :: Type) :: [Type]
type instance ExpandToHList (ChanWriteSource ( Source (Channel inToGen)
                                          :>> Generator (Channel genToOut)
                                          :>> Sink )
                            ) _ = HChI inToGen

type instance ExpandToHList (ChanReadWriteGen ( Source (Channel inToGen)
                                            :>> Generator (Channel genToOut)
                                            :>> Sink)
                            ) filter = filter ': HAppendListR (HChO inToGen) (HChI genToOut)

type instance ExpandToHList (ChanReadOut ( Source (Channel inToGen)
                                       :>> Generator (Channel genToOut)
                                       :>> Sink )
                            ) filter = HChO genToOut

{-# WARNING ExpandSourceToCh "INTERNAL USE" #-}
type ExpandSourceToCh a = ExpandToHList (ChanWriteSource a) Void
{-# WARNING ExpandGenToCh "INTERNAL USE" #-}
type ExpandGenToCh a filter = ExpandToHList (ChanReadWriteGen a) filter
{-# WARNING ExpandFilterToCh "INTERNAL USE" #-}
type ExpandFilterToCh a param = ExpandGenToCh a param
{-# WARNING ExpandSinkToCh "INTERNAL USE" #-}
type ExpandSinkToCh a = ExpandToHList (ChanReadOut a) Void

-- Class for building Channels base on a DP Definition on `a` Type
{-# WARNING MkChans "INTERNAL USE" #-}
class MkChans (a :: Type) where
  type HChan a :: Type
  mkChans :: Proxy a -> IO (HChan a)

-- Instance for Building Channels for all the Chain Source :>> Generator :>> Sink
instance ( MkCh inToGen
         , MkCh genToOut)
    => MkChans (Source (Channel inToGen) :>> Generator (Channel genToOut) :>> Sink) where

  type HChan (Source (Channel inToGen) :>> Generator (Channel genToOut) :>> Sink)
    = Record '[ Tagged "Source" (Record '[ Tagged "in-ch" (HList (HChI inToGen))
                                        , Tagged "out-ch" (HList (HChO inToGen))
                                        ]
                        )
       , Tagged "generator" (Record '[ Tagged "in-ch" (HList (HChI genToOut))
                                     , Tagged "out-ch" (HList (HChO genToOut))
                                     ]
                            )
       , Tagged "Sink" (Record '[ Tagged "in-ch" (HList (HChI genToOut))])
       ]

  mkChans :: Proxy
  (Source (Channel inToGen)
   :>> (Generator (Channel genToOut) :>> Sink))
-> IO
     (HChan
        (Source (Channel inToGen)
         :>> (Generator (Channel genToOut) :>> Sink)))
mkChans _ =  do
    (ii :: HList (HChI inToGen)
ii, io :: HList (HChO inToGen)
io) <- Proxy inToGen -> IO (HList (HChI inToGen), HList (HChO inToGen))
forall a. MkCh a => Proxy a -> IO (HList (HChI a), HList (HChO a))
mkCh (Proxy inToGen
forall k (t :: k). Proxy t
Proxy @inToGen)
    (gi :: HList (HChI genToOut)
gi, go :: HList (HChO genToOut)
go) <- Proxy genToOut -> IO (HList (HChI genToOut), HList (HChO genToOut))
forall a. MkCh a => Proxy a -> IO (HList (HChI a), HList (HChO a))
mkCh (Proxy genToOut
forall k (t :: k). Proxy t
Proxy @genToOut)
    (oi :: HList (HChI genToOut)
oi, _)  <- Proxy genToOut -> IO (HList (HChI genToOut), HList (HChO genToOut))
forall a. MkCh a => Proxy a -> IO (HList (HChI a), HList (HChO a))
mkCh (Proxy genToOut
forall k (t :: k). Proxy t
Proxy @genToOut)
    Record
  '[Tagged
      "Source"
      (Record
         '[Tagged "in-ch" (HList (HChI inToGen)),
           Tagged "out-ch" (HList (HChO inToGen))]),
    Tagged
      "generator"
      (Record
         '[Tagged "in-ch" (HList (HChI genToOut)),
           Tagged "out-ch" (HList (HChO genToOut))]),
    Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])]
-> IO
     (Record
        '[Tagged
            "Source"
            (Record
               '[Tagged "in-ch" (HList (HChI inToGen)),
                 Tagged "out-ch" (HList (HChO inToGen))]),
          Tagged
            "generator"
            (Record
               '[Tagged "in-ch" (HList (HChI genToOut)),
                 Tagged "out-ch" (HList (HChO genToOut))]),
          Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])])
forall (m :: * -> *) a. Monad m => a -> m a
return (Record
   '[Tagged
       "Source"
       (Record
          '[Tagged "in-ch" (HList (HChI inToGen)),
            Tagged "out-ch" (HList (HChO inToGen))]),
     Tagged
       "generator"
       (Record
          '[Tagged "in-ch" (HList (HChI genToOut)),
            Tagged "out-ch" (HList (HChO genToOut))]),
     Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])]
 -> IO
      (Record
         '[Tagged
             "Source"
             (Record
                '[Tagged "in-ch" (HList (HChI inToGen)),
                  Tagged "out-ch" (HList (HChO inToGen))]),
           Tagged
             "generator"
             (Record
                '[Tagged "in-ch" (HList (HChI genToOut)),
                  Tagged "out-ch" (HList (HChO genToOut))]),
           Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])]))
-> Record
     '[Tagged
         "Source"
         (Record
            '[Tagged "in-ch" (HList (HChI inToGen)),
              Tagged "out-ch" (HList (HChO inToGen))]),
       Tagged
         "generator"
         (Record
            '[Tagged "in-ch" (HList (HChI genToOut)),
              Tagged "out-ch" (HList (HChO genToOut))]),
       Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])]
-> IO
     (Record
        '[Tagged
            "Source"
            (Record
               '[Tagged "in-ch" (HList (HChI inToGen)),
                 Tagged "out-ch" (HList (HChO inToGen))]),
          Tagged
            "generator"
            (Record
               '[Tagged "in-ch" (HList (HChI genToOut)),
                 Tagged "out-ch" (HList (HChO genToOut))]),
          Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])])
forall a b. (a -> b) -> a -> b
$ (Label "Source"
inLabel Label "Source"
-> Record
     '[Tagged "in-ch" (HList (HChI inToGen)),
       Tagged "out-ch" (HList (HChO inToGen))]
-> Tagged
     "Source"
     (Record
        '[Tagged "in-ch" (HList (HChI inToGen)),
          Tagged "out-ch" (HList (HChO inToGen))])
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. (Label "in-ch"
inChLabel Label "in-ch"
-> HList (HChI inToGen) -> Tagged "in-ch" (HList (HChI inToGen))
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. HList (HChI inToGen)
ii Tagged "in-ch" (HList (HChI inToGen))
-> Record '[Tagged "out-ch" (HList (HChO inToGen))]
-> HExtendR
     (Tagged "in-ch" (HList (HChI inToGen)))
     (Record '[Tagged "out-ch" (HList (HChO inToGen))])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. Label "out-ch"
outChLabel Label "out-ch"
-> HList (HChO inToGen) -> Tagged "out-ch" (HList (HChO inToGen))
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. HList (HChO inToGen)
io Tagged "out-ch" (HList (HChO inToGen))
-> Record '[]
-> HExtendR (Tagged "out-ch" (HList (HChO inToGen))) (Record '[])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. Record '[]
emptyRecord))
              Tagged
  "Source"
  (Record
     '[Tagged "in-ch" (HList (HChI inToGen)),
       Tagged "out-ch" (HList (HChO inToGen))])
-> Record
     '[Tagged
         "generator"
         (Record
            '[Tagged "in-ch" (HList (HChI genToOut)),
              Tagged "out-ch" (HList (HChO genToOut))]),
       Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])]
-> HExtendR
     (Tagged
        "Source"
        (Record
           '[Tagged "in-ch" (HList (HChI inToGen)),
             Tagged "out-ch" (HList (HChO inToGen))]))
     (Record
        '[Tagged
            "generator"
            (Record
               '[Tagged "in-ch" (HList (HChI genToOut)),
                 Tagged "out-ch" (HList (HChO genToOut))]),
          Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*.
              (Label "generator"
genLabel Label "generator"
-> Record
     '[Tagged "in-ch" (HList (HChI genToOut)),
       Tagged "out-ch" (HList (HChO genToOut))]
-> Tagged
     "generator"
     (Record
        '[Tagged "in-ch" (HList (HChI genToOut)),
          Tagged "out-ch" (HList (HChO genToOut))])
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. (Label "in-ch"
inChLabel Label "in-ch"
-> HList (HChI genToOut) -> Tagged "in-ch" (HList (HChI genToOut))
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. HList (HChI genToOut)
gi Tagged "in-ch" (HList (HChI genToOut))
-> Record '[Tagged "out-ch" (HList (HChO genToOut))]
-> HExtendR
     (Tagged "in-ch" (HList (HChI genToOut)))
     (Record '[Tagged "out-ch" (HList (HChO genToOut))])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. Label "out-ch"
outChLabel Label "out-ch"
-> HList (HChO genToOut) -> Tagged "out-ch" (HList (HChO genToOut))
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. HList (HChO genToOut)
go Tagged "out-ch" (HList (HChO genToOut))
-> Record '[]
-> HExtendR (Tagged "out-ch" (HList (HChO genToOut))) (Record '[])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. Record '[]
emptyRecord))
              Tagged
  "generator"
  (Record
     '[Tagged "in-ch" (HList (HChI genToOut)),
       Tagged "out-ch" (HList (HChO genToOut))])
-> Record
     '[Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])]
-> HExtendR
     (Tagged
        "generator"
        (Record
           '[Tagged "in-ch" (HList (HChI genToOut)),
             Tagged "out-ch" (HList (HChO genToOut))]))
     (Record
        '[Tagged
            "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*.
              (Label "Sink"
outLabel Label "Sink"
-> Record '[Tagged "in-ch" (HList (HChI genToOut))]
-> Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. (Label "in-ch"
inChLabel Label "in-ch"
-> HList (HChI genToOut) -> Tagged "in-ch" (HList (HChI genToOut))
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. HList (HChI genToOut)
oi Tagged "in-ch" (HList (HChI genToOut))
-> Record '[]
-> HExtendR (Tagged "in-ch" (HList (HChI genToOut))) (Record '[])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. Record '[]
emptyRecord))
              Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))])
-> Record '[]
-> HExtendR
     (Tagged "Sink" (Record '[Tagged "in-ch" (HList (HChI genToOut))]))
     (Record '[])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*.
              Record '[]
emptyRecord

-- Instance for Building Only Channels for Filters on each Generator action
instance MkCh inToGen
    => MkChans (ChansFilter (Source (Channel inToGen) :>> Generator (Channel genToOut) :>> Sink)) where

  type HChan (ChansFilter (Source (Channel inToGen) :>> Generator (Channel genToOut) :>> Sink))
    = Record '[ Tagged "in-ch" (HList (HChO inToGen))
              , Tagged "out-ch" (HList (HChI inToGen))
              ]

  mkChans :: Proxy
  (ChansFilter
     (Source (Channel inToGen)
      :>> (Generator (Channel genToOut) :>> Sink)))
-> IO
     (HChan
        (ChansFilter
           (Source (Channel inToGen)
            :>> (Generator (Channel genToOut) :>> Sink))))
mkChans _ =  do
    (writes' :: HList (HChI inToGen)
writes', reads' :: HList (HChO inToGen)
reads') <- Proxy inToGen -> IO (HList (HChI inToGen), HList (HChO inToGen))
forall a. MkCh a => Proxy a -> IO (HList (HChI a), HList (HChO a))
mkCh (Proxy inToGen
forall k (t :: k). Proxy t
Proxy @inToGen)
    Record
  '[Tagged "in-ch" (HList (HChO inToGen)),
    Tagged "out-ch" (HList (HChI inToGen))]
-> IO
     (Record
        '[Tagged "in-ch" (HList (HChO inToGen)),
          Tagged "out-ch" (HList (HChI inToGen))])
forall (m :: * -> *) a. Monad m => a -> m a
return (Record
   '[Tagged "in-ch" (HList (HChO inToGen)),
     Tagged "out-ch" (HList (HChI inToGen))]
 -> IO
      (Record
         '[Tagged "in-ch" (HList (HChO inToGen)),
           Tagged "out-ch" (HList (HChI inToGen))]))
-> Record
     '[Tagged "in-ch" (HList (HChO inToGen)),
       Tagged "out-ch" (HList (HChI inToGen))]
-> IO
     (Record
        '[Tagged "in-ch" (HList (HChO inToGen)),
          Tagged "out-ch" (HList (HChI inToGen))])
forall a b. (a -> b) -> a -> b
$ HList
  '[Tagged "in-ch" (HList (HChO inToGen)),
    Tagged "out-ch" (HList (HChI inToGen))]
-> Record
     '[Tagged "in-ch" (HList (HChO inToGen)),
       Tagged "out-ch" (HList (HChI inToGen))]
forall (r :: [*]). HRLabelSet r => HList r -> Record r
mkRecord (Label "in-ch"
inChLabel Label "in-ch"
-> HList (HChO inToGen) -> Tagged "in-ch" (HList (HChO inToGen))
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. HList (HChO inToGen)
reads' Tagged "in-ch" (HList (HChO inToGen))
-> HList '[Tagged "out-ch" (HList (HChI inToGen))]
-> HExtendR
     (Tagged "in-ch" (HList (HChO inToGen)))
     (HList '[Tagged "out-ch" (HList (HChI inToGen))])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. Label "out-ch"
outChLabel Label "out-ch"
-> HList (HChI inToGen) -> Tagged "out-ch" (HList (HChI inToGen))
forall k (l :: k) v. Label l -> v -> Tagged l v
.=. HList (HChI inToGen)
writes' Tagged "out-ch" (HList (HChI inToGen))
-> HList '[]
-> HExtendR (Tagged "out-ch" (HList (HChI inToGen))) (HList '[])
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. HList '[]
HNil)


{-# WARNING makeChans "INTERNAL USE" #-}
{-# INLINE makeChans #-}
makeChans :: forall (a :: Type). MkChans a => IO (HChan a)
makeChans :: IO (HChan a)
makeChans = Proxy a -> IO (HChan a)
forall a. MkChans a => Proxy a -> IO (HChan a)
mkChans (Proxy a
forall k (t :: k). Proxy t
Proxy @a)

-- Ugly Dynamic Indexed Record Viewer to generate specific list of channels
{-# WARNING sourceChans "INTERNAL USE" #-}
{-# INLINE sourceChans #-}
sourceChans :: ( LabeledOpticF (LabelableTy r1) (Const t1)
              , LabeledOpticP (LabelableTy r1) (->)
              , LabeledOpticTo (LabelableTy r1) "in-ch" (->)
              , LabeledOpticF (LabelableTy r2) (Const t1)
              , LabeledOpticP (LabelableTy r2) (->)
              , LabeledOpticTo (LabelableTy r2) "Source" (->)
              , Labelable "in-ch" r1 s t2 t1 t1
              , Labelable "Source" r2 t3 t3 (r1 s) (r1 t2))
           => r2 t3 -> t1
sourceChans :: r2 t3 -> t1
sourceChans = let inl :: (r1 s -> Const t1 (r1 t2)) -> r2 t3 -> Const t1 (r2 t3)
inl  = Label "Source" -> LabeledOptic "Source" r2 t3 t3 (r1 s) (r1 t2)
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "Source"
inLabel
                  inch :: (t1 -> Const t1 t1) -> r1 s -> Const t1 (r1 t2)
inch = Label "in-ch" -> LabeledOptic "in-ch" r1 s t2 t1 t1
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "in-ch"
inChLabel
               in Getting t1 (r2 t3) t1 -> r2 t3 -> t1
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((r1 s -> Const t1 (r1 t2)) -> r2 t3 -> Const t1 (r2 t3)
inl ((r1 s -> Const t1 (r1 t2)) -> r2 t3 -> Const t1 (r2 t3))
-> ((t1 -> Const t1 t1) -> r1 s -> Const t1 (r1 t2))
-> Getting t1 (r2 t3) t1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t1 -> Const t1 t1) -> r1 s -> Const t1 (r1 t2)
inch)

{-# WARNING generatorChans "INTERNAL USE" #-}
{-# INLINE generatorChans #-}
generatorChans :: ( LabeledOpticF (LabelableTy r1) (Const (HList l1))
                  , LabeledOpticP (LabelableTy r1) (->)
                  , LabeledOpticTo (LabelableTy r1) "out-ch" (->)
                  , LabeledOpticF (LabelableTy r2) (Const (HList l2))
                  , LabeledOpticP (LabelableTy r2) (->)
                  , LabeledOpticTo (LabelableTy r2) "in-ch" (->)
                  , LabeledOpticF (LabelableTy r3) (Const (HList l2))
                  , LabeledOpticP (LabelableTy r3) (->)
                  , LabeledOpticTo (LabelableTy r3) "generator" (->)
                  , LabeledOpticF (LabelableTy r3) (Const (HList l1))
                  , LabeledOpticTo (LabelableTy r3) "Source" (->)
                  , HAppendList l1 l2
                  , Labelable "generator" r3 t1 t1 (r2 s1) (r2 t2)
                  , Labelable "in-ch" r2 s1 t2 (HList l2) (HList l2)
                  , Labelable "Source" r3 t1 t1 (r1 s2) (r1 t3)
                  , Labelable "out-ch" r1 s2 t3 (HList l1) (HList l1))
               => r3 t1 -> HList (HAppendListR l1 l2)
generatorChans :: r3 t1 -> HList (HAppendListR l1 l2)
generatorChans ch :: r3 t1
ch = let inl :: (r1 s2 -> Const (HList l1) (r1 t3))
-> r3 t1 -> Const (HList l1) (r3 t1)
inl  = Label "Source" -> LabeledOptic "Source" r3 t1 t1 (r1 s2) (r1 t3)
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "Source"
inLabel
                        genl :: (r2 s1 -> Const (HList l2) (r2 t2))
-> r3 t1 -> Const (HList l2) (r3 t1)
genl  = Label "generator"
-> LabeledOptic "generator" r3 t1 t1 (r2 s1) (r2 t2)
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "generator"
genLabel
                        inch :: (HList l2 -> Const (HList l2) (HList l2))
-> r2 s1 -> Const (HList l2) (r2 t2)
inch = Label "in-ch"
-> LabeledOptic "in-ch" r2 s1 t2 (HList l2) (HList l2)
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "in-ch"
inChLabel
                        outch :: (HList l1 -> Const (HList l1) (HList l1))
-> r1 s2 -> Const (HList l1) (r1 t3)
outch = Label "out-ch"
-> LabeledOptic "out-ch" r1 s2 t3 (HList l1) (HList l1)
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "out-ch"
outChLabel
                        outsIn :: HList l1
outsIn = Getting (HList l1) (r3 t1) (HList l1) -> r3 t1 -> HList l1
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((r1 s2 -> Const (HList l1) (r1 t3))
-> r3 t1 -> Const (HList l1) (r3 t1)
inl ((r1 s2 -> Const (HList l1) (r1 t3))
 -> r3 t1 -> Const (HList l1) (r3 t1))
-> ((HList l1 -> Const (HList l1) (HList l1))
    -> r1 s2 -> Const (HList l1) (r1 t3))
-> Getting (HList l1) (r3 t1) (HList l1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HList l1 -> Const (HList l1) (HList l1))
-> r1 s2 -> Const (HList l1) (r1 t3)
outch) r3 t1
ch
                        insGen :: HList l2
insGen = Getting (HList l2) (r3 t1) (HList l2) -> r3 t1 -> HList l2
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((r2 s1 -> Const (HList l2) (r2 t2))
-> r3 t1 -> Const (HList l2) (r3 t1)
genl ((r2 s1 -> Const (HList l2) (r2 t2))
 -> r3 t1 -> Const (HList l2) (r3 t1))
-> ((HList l2 -> Const (HList l2) (HList l2))
    -> r2 s1 -> Const (HList l2) (r2 t2))
-> Getting (HList l2) (r3 t1) (HList l2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HList l2 -> Const (HList l2) (HList l2))
-> r2 s1 -> Const (HList l2) (r2 t2)
inch) r3 t1
ch
                     in HList l1
outsIn HList l1 -> HList l2 -> HList (HAppendListR l1 l2)
forall (l1 :: [*]) (l2 :: [*]).
HAppendList l1 l2 =>
HList l1 -> HList l2 -> HList (HAppendListR l1 l2)
`hAppendList` HList l2
insGen

{-# WARNING sinkChans "INTERNAL USE" #-}
{-# INLINE sinkChans #-}
sinkChans :: ( LabeledOpticF (LabelableTy r1) (Const t1)
               , LabeledOpticP (LabelableTy r1) (->)
               , LabeledOpticTo (LabelableTy r1) "out-ch" (->)
               , LabeledOpticF (LabelableTy r2) (Const t1)
               , LabeledOpticP (LabelableTy r2) (->)
               , LabeledOpticTo (LabelableTy r2) "generator" (->)
               , Labelable "generator" r2 t2 t2 (r1 s) (r1 t3)
               , Labelable "out-ch" r1 s t3 t1 t1)
            => r2 t2 -> t1
sinkChans :: r2 t2 -> t1
sinkChans = let genl :: (r1 s -> Const t1 (r1 t3)) -> r2 t2 -> Const t1 (r2 t2)
genl  = Label "generator"
-> LabeledOptic "generator" r2 t2 t2 (r1 s) (r1 t3)
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "generator"
genLabel
                outch :: (t1 -> Const t1 t1) -> r1 s -> Const t1 (r1 t3)
outch = Label "out-ch" -> LabeledOptic "out-ch" r1 s t3 t1 t1
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "out-ch"
outChLabel
             in Getting t1 (r2 t2) t1 -> r2 t2 -> t1
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((r1 s -> Const t1 (r1 t3)) -> r2 t2 -> Const t1 (r2 t2)
genl ((r1 s -> Const t1 (r1 t3)) -> r2 t2 -> Const t1 (r2 t2))
-> ((t1 -> Const t1 t1) -> r1 s -> Const t1 (r1 t3))
-> Getting t1 (r2 t2) t1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t1 -> Const t1 t1) -> r1 s -> Const t1 (r1 t3)
outch)

{-# WARNING AllChans "INTERNAL USE" #-}
type AllChans r2 r3 l1 r4 l2 t2 s t1 s2 t5 l3 l4 = (LabeledOpticTo (LabelableTy r2) "in-ch" (->),
            LabeledOpticF (LabelableTy r3) (Const (HList l3)),
            LabeledOpticP (LabelableTy r3) (->),
            LabeledOpticTo (LabelableTy r3) "Source" (->),
            LabeledOpticF (LabelableTy r2) (Const (HList l1)),
            LabeledOpticP (LabelableTy r2) (->),
            LabeledOpticTo (LabelableTy r2) "out-ch" (->),
            LabeledOpticTo (LabelableTy r4) "in-ch" (->),
            LabeledOpticF (LabelableTy r3) (Const (HList l2)),
            LabeledOpticTo (LabelableTy r3) "generator" (->),
            LabeledOpticF (LabelableTy r3) (Const (HList l1)),
            LabeledOpticF (LabelableTy r2) (Const (HList l3)),
            LabeledOpticF (LabelableTy r4) (Const (HList l4)),
            LabeledOpticP (LabelableTy r4) (->),
            LabeledOpticTo (LabelableTy r4) "out-ch" (->),
            LabeledOpticF (LabelableTy r3) (Const (HList l4)),
            LabeledOpticF (LabelableTy r4) (Const (HList l2)),
            HAppendList l1 l2, Labelable "generator" r3 t2 t2 (r4 s) (r4 t1),
            Labelable "in-ch" r2 s2 t5 (HList l3) (HList l3),
            Labelable "in-ch" r4 s t1 (HList l2) (HList l2),
            Labelable "Source" r3 t2 t2 (r2 s2) (r2 t5),
            Labelable "out-ch" r2 s2 t5 (HList l1) (HList l1),
            Labelable "out-ch" r4 s t1 (HList l4) (HList l4))

{-# WARNING inGenOut "INTERNAL USE" #-}
{-# INLINE inGenOut #-}
inGenOut :: AllChans r2 r3 l1 r4 l2 t2 s t1 s2 t5 l3 l4 => r3 t2 -> (HList l3, HList (HAppendListR l1 l2), HList l4)
inGenOut :: r3 t2 -> (HList l3, HList (HAppendListR l1 l2), HList l4)
inGenOut ch :: r3 t2
ch = (r3 t2 -> HList l3
forall (r1 :: [*] -> *) t1 (r2 :: [*] -> *) (s :: [*]) (t2 :: [*])
       (t3 :: [*]).
(LabeledOpticF (LabelableTy r1) (Const t1),
 LabeledOpticP (LabelableTy r1) (->),
 LabeledOpticTo (LabelableTy r1) "in-ch" (->),
 LabeledOpticF (LabelableTy r2) (Const t1),
 LabeledOpticP (LabelableTy r2) (->),
 LabeledOpticTo (LabelableTy r2) "Source" (->),
 Labelable "in-ch" r1 s t2 t1 t1,
 Labelable "Source" r2 t3 t3 (r1 s) (r1 t2)) =>
r2 t3 -> t1
sourceChans r3 t2
ch, r3 t2 -> HList (HAppendListR l1 l2)
forall (r1 :: [*] -> *) (l1 :: [*]) (r2 :: [*] -> *) (l2 :: [*])
       (r3 :: [*] -> *) (t1 :: [*]) (s1 :: [*]) (t2 :: [*]) (s2 :: [*])
       (t3 :: [*]).
(LabeledOpticF (LabelableTy r1) (Const (HList l1)),
 LabeledOpticP (LabelableTy r1) (->),
 LabeledOpticTo (LabelableTy r1) "out-ch" (->),
 LabeledOpticF (LabelableTy r2) (Const (HList l2)),
 LabeledOpticP (LabelableTy r2) (->),
 LabeledOpticTo (LabelableTy r2) "in-ch" (->),
 LabeledOpticF (LabelableTy r3) (Const (HList l2)),
 LabeledOpticP (LabelableTy r3) (->),
 LabeledOpticTo (LabelableTy r3) "generator" (->),
 LabeledOpticF (LabelableTy r3) (Const (HList l1)),
 LabeledOpticTo (LabelableTy r3) "Source" (->), HAppendList l1 l2,
 Labelable "generator" r3 t1 t1 (r2 s1) (r2 t2),
 Labelable "in-ch" r2 s1 t2 (HList l2) (HList l2),
 Labelable "Source" r3 t1 t1 (r1 s2) (r1 t3),
 Labelable "out-ch" r1 s2 t3 (HList l1) (HList l1)) =>
r3 t1 -> HList (HAppendListR l1 l2)
generatorChans r3 t2
ch, r3 t2 -> HList l4
forall (r1 :: [*] -> *) t1 (r2 :: [*] -> *) (t2 :: [*]) (s :: [*])
       (t3 :: [*]).
(LabeledOpticF (LabelableTy r1) (Const t1),
 LabeledOpticP (LabelableTy r1) (->),
 LabeledOpticTo (LabelableTy r1) "out-ch" (->),
 LabeledOpticF (LabelableTy r2) (Const t1),
 LabeledOpticP (LabelableTy r2) (->),
 LabeledOpticTo (LabelableTy r2) "generator" (->),
 Labelable "generator" r2 t2 t2 (r1 s) (r1 t3),
 Labelable "out-ch" r1 s t3 t1 t1) =>
r2 t2 -> t1
sinkChans r3 t2
ch)


{-# WARNING FilterChans "INTERNAL USE" #-}
type FilterChans r b t a = (LabeledOpticF (LabelableTy r) (Const b),
                            LabeledOpticTo (LabelableTy r) "out-ch" (->),
                            Labelable "out-ch" r t t b b,
                            LabeledOpticF (LabelableTy r) (Const a),
                            LabeledOpticP (LabelableTy r) (->),
                            LabeledOpticTo (LabelableTy r) "in-ch" (->),
                            Labelable "in-ch" r t t a a)

{-# WARNING getFilterChannels "INTERNAL USE" #-}
{-# INLINE getFilterChannels #-}
getFilterChannels :: FilterChans r b t a => r t -> (a, b)
getFilterChannels :: r t -> (a, b)
getFilterChannels ch :: r t
ch =
   let inch :: (a -> Const a a) -> r t -> Const a (r t)
inch = Label "in-ch" -> LabeledOptic "in-ch" r t t a a
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "in-ch"
inChLabel
       outch :: (b -> Const b b) -> r t -> Const b (r t)
outch = Label "out-ch" -> LabeledOptic "out-ch" r t t b b
forall k (x :: k) (r :: [*] -> *) (s :: [*]) (t :: [*]) a b.
Labelable x r s t a b =>
Label x -> LabeledOptic x r s t a b
hLens' Label "out-ch"
outChLabel
       reads' :: a
reads' = r t
chr t -> ((a -> Const a a) -> r t -> Const a (r t)) -> a
forall s a. s -> Getting a s a -> a
^.(a -> Const a a) -> r t -> Const a (r t)
inch
       writes' :: b
writes' = r t
chr t -> ((b -> Const b b) -> r t -> Const b (r t)) -> b
forall s a. s -> Getting a s a -> a
^.(b -> Const b b) -> r t -> Const b (r t)
outch
    in (a
reads', b
writes')