{-# 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,
      FeedbackChannel,
      type (:=>)(..),
      type (:<+>)(..),
      ChanIn,
      ChanInIn,
      ChanOut,
      ChanOutIn,
      ChansFilter,
      ChanWriteSource,
      ChanReadWriteGen,
      ChanReadOut,
      ChanRecord(..),
      InOutChan(..),
      MkCh(..),
      MkChans(..),
      ExpandGenToCh, 
      ExpandSinkToCh,
      ExpandSourceToCh,
      ExpandFilterToCh,
      inGenOut,
      toHList, 
      makeChans,
      makeChansF,
      getFilterChannels
    ) where

import           Control.Lens                             hiding ((<|))
import           Data.Foldable                            as F
import           Data.HList
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)

-- |'FeedbackChannel' is the Container Type of /Open Union Type/ which is going to be defined with ':<+>' and indicates that this
-- | Channel is for feedback to Source
--
-- @ a ~ (Type ':<+>' Type ':<+>' ... ':<+>' Eof) @
data FeedbackChannel (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 ChanInIn "INTERNAL USE" #-}
data ChanInIn (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) = ReadChannel a ': HChI more
  type HChO (a :<+> more) = WriteChannel a ': HChO more
  mkCh :: Proxy (a :<+> more)
-> IO (HList (HChI (a :<+> more)), HList (HChO (a :<+> more)))
mkCh _ = do
    (o :: WriteChannel a
o, i :: ReadChannel a
i) <- 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 (ReadChannel a : HChI more),
 HList (WriteChannel a : HChO more))
-> IO
     (HList (ReadChannel a : HChI more),
      HList (WriteChannel a : HChO more))
forall (m :: * -> *) a. Monad m => a -> m a
return (ReadChannel a
i ReadChannel a
-> HList (HChI more)
-> HExtendR (ReadChannel a) (HList (HChI more))
forall e l. HExtend e l => e -> l -> HExtendR e l
.*. HList (HChI more)
il, WriteChannel a
o WriteChannel a
-> HList (HChO more)
-> HExtendR (WriteChannel 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 )
                            ) _ = HChO inToGen
type instance ExpandToHList (ChanWriteSource ( Source (Channel inToGen)
                                          :=> Generator (Channel genToOut)
                                          :=> FeedbackChannel toSource
                                          :=> Sink )
                            ) _ = HAppendListR (HChI toSource) (HChO inToGen)

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

type instance ExpandToHList (ChanReadOut ( Source (Channel inToGen)
                                       :=> Generator (Channel genToOut)
                                       :=> Sink )
                            ) filter = HChI genToOut
type instance ExpandToHList (ChanReadOut ( Source (Channel inToGen)
                                       :=> Generator (Channel genToOut)
                                       :=> FeedbackChannel toSource
                                       :=> Sink )
                            ) filter = HChI 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

data InOutChan lr lw = InOutChan
  { InOutChan lr lw -> HList lr
_iocReadChans  :: HList lr
  , InOutChan lr lw -> HList lw
_iocWriteChans :: HList lw
  }

toHList :: HAppendList lr lw => InOutChan lr lw -> HList (HAppendListR lr lw)
toHList :: InOutChan lr lw -> HList (HAppendListR lr lw)
toHList InOutChan{..} = HList lr
_iocReadChans HList lr -> HList lw -> HAppendR (HList lr) (HList lw)
forall l1 l2. HAppend l1 l2 => l1 -> l2 -> HAppendR l1 l2
`hAppend` HList lw
_iocWriteChans

data ChanRecord slr slw glr glw silr silw = ChanRecord
  { ChanRecord slr slw glr glw silr silw -> InOutChan slr slw
_crSource :: InOutChan slr slw
  , ChanRecord slr slw glr glw silr silw -> InOutChan glr glw
_crGenerator :: InOutChan glr glw
  , ChanRecord slr slw glr glw silr silw -> InOutChan silr silw
_crSink :: InOutChan silr silw
  }

-- 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)
      = ChanRecord '[] (HChO inToGen) (HChI inToGen) (HChO genToOut) (HChI genToOut) '[]

  mkChans :: Proxy
  (Source (Channel inToGen)
   :=> (Generator (Channel genToOut) :=> Sink))
-> IO
     (HChan
        (Source (Channel inToGen)
         :=> (Generator (Channel genToOut) :=> Sink)))
mkChans _ =  do
    (rs :: HList (HChI inToGen)
rs, ws :: HList (HChO inToGen)
ws) <- 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)
    (rg :: HList (HChI genToOut)
rg, wg :: HList (HChO genToOut)
wg) <- 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)
    ChanRecord
  '[]
  (HChO inToGen)
  (HChI inToGen)
  (HChO genToOut)
  (HChI genToOut)
  '[]
-> IO
     (ChanRecord
        '[]
        (HChO inToGen)
        (HChI inToGen)
        (HChO genToOut)
        (HChI genToOut)
        '[])
forall (m :: * -> *) a. Monad m => a -> m a
return (ChanRecord
   '[]
   (HChO inToGen)
   (HChI inToGen)
   (HChO genToOut)
   (HChI genToOut)
   '[]
 -> IO
      (ChanRecord
         '[]
         (HChO inToGen)
         (HChI inToGen)
         (HChO genToOut)
         (HChI genToOut)
         '[]))
-> ChanRecord
     '[]
     (HChO inToGen)
     (HChI inToGen)
     (HChO genToOut)
     (HChI genToOut)
     '[]
-> IO
     (ChanRecord
        '[]
        (HChO inToGen)
        (HChI inToGen)
        (HChO genToOut)
        (HChI genToOut)
        '[])
forall a b. (a -> b) -> a -> b
$ ChanRecord :: forall (slr :: [*]) (slw :: [*]) (glr :: [*]) (glw :: [*])
       (silr :: [*]) (silw :: [*]).
InOutChan slr slw
-> InOutChan glr glw
-> InOutChan silr silw
-> ChanRecord slr slw glr glw silr silw
ChanRecord
      { _crSource :: InOutChan '[] (HChO inToGen)
_crSource = HList '[] -> HList (HChO inToGen) -> InOutChan '[] (HChO inToGen)
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan HList '[]
HNil HList (HChO inToGen)
ws
      , _crGenerator :: InOutChan (HChI inToGen) (HChO genToOut)
_crGenerator = HList (HChI inToGen)
-> HList (HChO genToOut)
-> InOutChan (HChI inToGen) (HChO genToOut)
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan HList (HChI inToGen)
rs HList (HChO genToOut)
wg
      , _crSink :: InOutChan (HChI genToOut) '[]
_crSink = HList (HChI genToOut) -> HList '[] -> InOutChan (HChI genToOut) '[]
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan HList (HChI genToOut)
rg HList '[]
HNil
      }

instance ( MkCh inToGen
         , MkCh genToOut
         , MkCh toSource
         , HAppendList (HChO genToOut) (HChO toSource))
    => MkChans (Source (Channel inToGen) :=> Generator (Channel genToOut) :=> FeedbackChannel toSource :=> Sink) where

  type HChan (Source (Channel inToGen) :=> Generator (Channel genToOut) :=> FeedbackChannel toSource :=> Sink)
    = ChanRecord (HChI toSource) (HChO inToGen) 
                 (HChI inToGen) (HAppendListR (HChO genToOut) (HChO toSource)) 
                 (HChI genToOut) '[]

  mkChans :: Proxy
  (Source (Channel inToGen)
   :=> (Generator (Channel genToOut)
        :=> (FeedbackChannel toSource :=> Sink)))
-> IO
     (HChan
        (Source (Channel inToGen)
         :=> (Generator (Channel genToOut)
              :=> (FeedbackChannel toSource :=> Sink))))
mkChans _ =  do
    (rf :: HList (HChI toSource)
rf, wf :: HList (HChO toSource)
wf) <- Proxy toSource -> IO (HList (HChI toSource), HList (HChO toSource))
forall a. MkCh a => Proxy a -> IO (HList (HChI a), HList (HChO a))
mkCh (Proxy toSource
forall k (t :: k). Proxy t
Proxy @toSource)
    (rs :: HList (HChI inToGen)
rs, ws :: HList (HChO inToGen)
ws) <- 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)
    (rg :: HList (HChI genToOut)
rg, wg :: HList (HChO genToOut)
wg) <- 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)
    ChanRecord
  (HChI toSource)
  (HChO inToGen)
  (HChI inToGen)
  (HAppendListR (HChO genToOut) (HChO toSource))
  (HChI genToOut)
  '[]
-> IO
     (ChanRecord
        (HChI toSource)
        (HChO inToGen)
        (HChI inToGen)
        (HAppendListR (HChO genToOut) (HChO toSource))
        (HChI genToOut)
        '[])
forall (m :: * -> *) a. Monad m => a -> m a
return (ChanRecord
   (HChI toSource)
   (HChO inToGen)
   (HChI inToGen)
   (HAppendListR (HChO genToOut) (HChO toSource))
   (HChI genToOut)
   '[]
 -> IO
      (ChanRecord
         (HChI toSource)
         (HChO inToGen)
         (HChI inToGen)
         (HAppendListR (HChO genToOut) (HChO toSource))
         (HChI genToOut)
         '[]))
-> ChanRecord
     (HChI toSource)
     (HChO inToGen)
     (HChI inToGen)
     (HAppendListR (HChO genToOut) (HChO toSource))
     (HChI genToOut)
     '[]
-> IO
     (ChanRecord
        (HChI toSource)
        (HChO inToGen)
        (HChI inToGen)
        (HAppendListR (HChO genToOut) (HChO toSource))
        (HChI genToOut)
        '[])
forall a b. (a -> b) -> a -> b
$ ChanRecord :: forall (slr :: [*]) (slw :: [*]) (glr :: [*]) (glw :: [*])
       (silr :: [*]) (silw :: [*]).
InOutChan slr slw
-> InOutChan glr glw
-> InOutChan silr silw
-> ChanRecord slr slw glr glw silr silw
ChanRecord
      { _crSource :: InOutChan (HChI toSource) (HChO inToGen)
_crSource = HList (HChI toSource)
-> HList (HChO inToGen) -> InOutChan (HChI toSource) (HChO inToGen)
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan HList (HChI toSource)
rf HList (HChO inToGen)
ws
      , _crGenerator :: InOutChan
  (HChI inToGen) (HAppendListR (HChO genToOut) (HChO toSource))
_crGenerator = HList (HChI inToGen)
-> HList (HAppendListR (HChO genToOut) (HChO toSource))
-> InOutChan
     (HChI inToGen) (HAppendListR (HChO genToOut) (HChO toSource))
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan HList (HChI inToGen)
rs (HList (HChO genToOut)
wg HList (HChO genToOut)
-> HList (HChO toSource)
-> HAppendR (HList (HChO genToOut)) (HList (HChO toSource))
forall l1 l2. HAppend l1 l2 => l1 -> l2 -> HAppendR l1 l2
`hAppend` HList (HChO toSource)
wf)
      , _crSink :: InOutChan (HChI genToOut) '[]
_crSink = HList (HChI genToOut) -> HList '[] -> InOutChan (HChI genToOut) '[]
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan HList (HChI genToOut)
rg HList '[]
HNil
      }

-- 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))
      = InOutChan (HChI inToGen) (HChO inToGen)

  mkChans :: Proxy
  (ChansFilter
     (Source (Channel inToGen)
      :=> (Generator (Channel genToOut) :=> Sink)))
-> IO
     (HChan
        (ChansFilter
           (Source (Channel inToGen)
            :=> (Generator (Channel genToOut) :=> Sink))))
mkChans _ =  (HList (HChI inToGen)
 -> HList (HChO inToGen) -> InOutChan (HChI inToGen) (HChO inToGen))
-> (HList (HChI inToGen), HList (HChO inToGen))
-> InOutChan (HChI inToGen) (HChO inToGen)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry HList (HChI inToGen)
-> HList (HChO inToGen) -> InOutChan (HChI inToGen) (HChO inToGen)
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan ((HList (HChI inToGen), HList (HChO inToGen))
 -> InOutChan (HChI inToGen) (HChO inToGen))
-> IO (HList (HChI inToGen), HList (HChO inToGen))
-> IO (InOutChan (HChI inToGen) (HChO inToGen))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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)

instance ( MkCh inToGen
         )
    => MkChans (ChansFilter (Source (Channel inToGen) :=> Generator (Channel genToOut) :=> FeedbackChannel toSource :=> Sink)) where

  type HChan (ChansFilter (Source (Channel inToGen) :=> Generator (Channel genToOut) :=> FeedbackChannel toSource :=> Sink))
    = InOutChan (HChI inToGen) (HChO inToGen)

  mkChans :: Proxy
  (ChansFilter
     (Source (Channel inToGen)
      :=> (Generator (Channel genToOut)
           :=> (FeedbackChannel toSource :=> Sink))))
-> IO
     (HChan
        (ChansFilter
           (Source (Channel inToGen)
            :=> (Generator (Channel genToOut)
                 :=> (FeedbackChannel toSource :=> Sink)))))
mkChans _ =  (HList (HChI inToGen)
 -> HList (HChO inToGen) -> InOutChan (HChI inToGen) (HChO inToGen))
-> (HList (HChI inToGen), HList (HChO inToGen))
-> InOutChan (HChI inToGen) (HChO inToGen)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry HList (HChI inToGen)
-> HList (HChO inToGen) -> InOutChan (HChI inToGen) (HChO inToGen)
forall (lr :: [*]) (lw :: [*]).
HList lr -> HList lw -> InOutChan lr lw
InOutChan ((HList (HChI inToGen), HList (HChO inToGen))
 -> InOutChan (HChI inToGen) (HChO inToGen))
-> IO (HList (HChI inToGen), HList (HChO inToGen))
-> IO (InOutChan (HChI inToGen) (HChO inToGen))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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)


{-# WARNING makeChans "INTERNAL USE" #-}
{-# INLINE makeChans #-}
makeChans :: forall (a :: Type) slr slw glr glw silr silw. (MkChans a, HChan a ~ ChanRecord slr slw glr glw silr silw) => IO (ChanRecord slr slw glr glw silr silw)
makeChans :: IO (ChanRecord slr slw glr glw silr silw)
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)

{-# WARNING makeChansF "INTERNAL USE" #-}
{-# INLINE makeChansF #-}
makeChansF :: forall (a :: Type) flr flw. (MkChans a, HChan a ~ InOutChan flr flw) => IO (InOutChan flr flw)
makeChansF :: IO (InOutChan flr flw)
makeChansF = 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 :: HAppendList slr slw => ChanRecord slr slw _ _ _ _ -> HList (HAppendListR slr slw)
sourceChans :: ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR slr slw)
sourceChans = InOutChan slr slw -> HList (HAppendListR slr slw)
forall (lr :: [*]) (lw :: [*]).
HAppendList lr lw =>
InOutChan lr lw -> HList (HAppendListR lr lw)
toHList (InOutChan slr slw -> HList (HAppendListR slr slw))
-> (ChanRecord slr slw glr glw silr silw -> InOutChan slr slw)
-> ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR slr slw)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChanRecord slr slw glr glw silr silw -> InOutChan slr slw
forall (slr :: [*]) (slw :: [*]) (glr :: [*]) (glw :: [*])
       (silr :: [*]) (silw :: [*]).
ChanRecord slr slw glr glw silr silw -> InOutChan slr slw
_crSource

{-# WARNING generatorChans "INTERNAL USE" #-}
{-# INLINE generatorChans #-}
generatorChans :: HAppendList glr glw => ChanRecord _ _ glr glw _ _ -> HList (HAppendListR glr glw)
generatorChans :: ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR glr glw)
generatorChans = InOutChan glr glw -> HList (HAppendListR glr glw)
forall (lr :: [*]) (lw :: [*]).
HAppendList lr lw =>
InOutChan lr lw -> HList (HAppendListR lr lw)
toHList (InOutChan glr glw -> HList (HAppendListR glr glw))
-> (ChanRecord slr slw glr glw silr silw -> InOutChan glr glw)
-> ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR glr glw)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChanRecord slr slw glr glw silr silw -> InOutChan glr glw
forall (slr :: [*]) (slw :: [*]) (glr :: [*]) (glw :: [*])
       (silr :: [*]) (silw :: [*]).
ChanRecord slr slw glr glw silr silw -> InOutChan glr glw
_crGenerator


{-# WARNING sinkChans "INTERNAL USE" #-}
{-# INLINE sinkChans #-}
sinkChans :: HAppendList silr silw => ChanRecord _ _ _ _ silr silw -> HList (HAppendListR silr silw)
sinkChans :: ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR silr silw)
sinkChans = InOutChan silr silw -> HList (HAppendListR silr silw)
forall (lr :: [*]) (lw :: [*]).
HAppendList lr lw =>
InOutChan lr lw -> HList (HAppendListR lr lw)
toHList (InOutChan silr silw -> HList (HAppendListR silr silw))
-> (ChanRecord slr slw glr glw silr silw -> InOutChan silr silw)
-> ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR silr silw)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChanRecord slr slw glr glw silr silw -> InOutChan silr silw
forall (slr :: [*]) (slw :: [*]) (glr :: [*]) (glw :: [*])
       (silr :: [*]) (silw :: [*]).
ChanRecord slr slw glr glw silr silw -> InOutChan silr silw
_crSink

{-# WARNING inGenOut "INTERNAL USE" #-}
{-# INLINE inGenOut #-}
inGenOut :: (HAppendList slr slw, HAppendList glr glw, HAppendList silr silw) => ChanRecord slr slw glr glw silr silw -> (HList (HAppendListR slr slw), HList (HAppendListR glr glw), HList (HAppendListR silr silw))
inGenOut :: ChanRecord slr slw glr glw silr silw
-> (HList (HAppendListR slr slw), HList (HAppendListR glr glw),
    HList (HAppendListR silr silw))
inGenOut ch :: ChanRecord slr slw glr glw silr silw
ch = (ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR slr slw)
forall (slr :: [*]) (slw :: [*]) (glr :: [*]) (glw :: [*])
       (silr :: [*]) (silw :: [*]).
HAppendList slr slw =>
ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR slr slw)
sourceChans ChanRecord slr slw glr glw silr silw
ch, ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR glr glw)
forall (glr :: [*]) (glw :: [*]) (slr :: [*]) (slw :: [*])
       (silr :: [*]) (silw :: [*]).
HAppendList glr glw =>
ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR glr glw)
generatorChans ChanRecord slr slw glr glw silr silw
ch, ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR silr silw)
forall (silr :: [*]) (silw :: [*]) (slr :: [*]) (slw :: [*])
       (glr :: [*]) (glw :: [*]).
HAppendList silr silw =>
ChanRecord slr slw glr glw silr silw
-> HList (HAppendListR silr silw)
sinkChans ChanRecord slr slw glr glw silr silw
ch)

{-# WARNING getFilterChannels "INTERNAL USE" #-}
{-# INLINE getFilterChannels #-}
getFilterChannels :: InOutChan lr lw -> (HList lr, HList lw)
getFilterChannels :: InOutChan lr lw -> (HList lr, HList lw)
getFilterChannels InOutChan{..} = (HList lr
_iocReadChans, HList lw
_iocWriteChans)