{-# LANGUAGE PostfixOperators #-}
{-# OPTIONS_HADDOCK hide #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  ForSyDe.MoC.CT.Lib
-- Copyright   :  (c) George Ungureanu, KTH/ICT/E 2015-2016
-- License     :  BSD-style (see the file LICENSE)
-- 
-- Maintainer  :  ugeorge@kth.se
-- Stability   :  experimental
-- Portability :  portable
--
-- This module provides a set of helpers for properly instantiating
-- process network patterns as process constructors.
-- 
-----------------------------------------------------------------------------
module ForSyDe.Atom.MoC.CT.Lib where

import qualified ForSyDe.Atom.MoC as MoC
import           ForSyDe.Atom.MoC.CT.Core
import           ForSyDe.Atom.Utility.Plot
import           ForSyDe.Atom.Utility.Tuple

------- DOCTEST SETUP -------

-- $setup
-- >>> import ForSyDe.Atom.MoC.Stream (takeS)
-- >>> import ForSyDe.Atom.MoC.Time as Time
-- >>> import ForSyDe.Atom.MoC.TimeStamp as TimeStamp
-- >>> let pi'  = TimeStamp.pi
-- >>> let exp' = Time.exp
-- >>> let sin' = Time.sin
-- >>> let cos' = Time.cos
-- >>> let cfg  = defaultCfg {xmax=10, rate=0.1}

------- DELAY -------

-- | The @delay@ process "delays" a signal with one
-- event. Instantiates the 'ForSyDe.Atom.MoC.delay' pattern. In the CT
-- MoC, this process can be interpreted as an ideal "delay line".
--
-- >>> let s  = infinite (sin') :: Signal Time
-- >>> let s' = delay 2 (\_ -> 0) s
-- >>> dumpDat $ prepare cfg {labels=["delay"]} $ s'
-- Dumped delay in ./fig
-- ["./fig/delay.dat"]
--
-- <<fig/moc-ct-pattern-delay.png>>
delay :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => ts   -- ^ time delay
      -> (tm -> a) -- ^ initial value
      -> SignalBase ts tm a    -- ^ input signal
      -> SignalBase ts tm a    -- ^ output signal

delay :: ts -> (tm -> a) -> SignalBase ts tm a -> SignalBase ts tm a
delay t :: ts
t v :: tm -> a
v = SignalBase ts tm a -> SignalBase ts tm a -> SignalBase ts tm a
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
MoC.delay ((ts, tm -> a) -> SignalBase ts tm a
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts
t, tm -> a
v))

-- | Similar to the previous, but this is the raw instantiation of the
-- 'ForSyDe.Atom.MoC.delay' pattern. It "borrows" the first event from
-- one signal and appends it at the head of another signal.
--
-- >>> let s  = infinite (sin') :: Signal Time
-- >>> let s' = signal [(0, \_ -> 0), (2, \_ -> 1)]
-- >>> dumpDat $ prepare cfg {labels=["delayp"]} $ delay' s' s
-- Dumped delayp in ./fig
-- ["./fig/delayp.dat"]
--
-- <<fig/moc-ct-pattern-delayp.png>>
delay' :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm a  -- ^ signal "borrowing" the initial event
      -> SignalBase ts tm a   -- ^ input signal
      -> SignalBase ts tm a   -- ^ output signal

delay' :: SignalBase ts tm a -> SignalBase ts tm a -> SignalBase ts tm a
delay' = SignalBase ts tm a -> SignalBase ts tm a -> SignalBase ts tm a
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
MoC.delay

------- COMB -------

-- | @comb@ processes map combinatorial functions on signals and take
-- care of synchronization between input signals. It instantiates the
-- @comb@ pattern (see 'ForSyDe.Atom.MoC.comb22').
-- 
-- Constructors: @comb[1-4][1-4]@.
--
-- >>> let s1 = infinite (sin') :: Signal Time
-- >>> let s2 = signal [(0,\_->0),(pi',\_->1),(2*pi',\_->0),(3*pi',\_->1)] :: Signal Time
-- >>> let o1 = comb11 (+1) s2
-- >>> let (o2_1, o2_2) = comb22 (\a b-> (a+b,a*b)) s1 s2
-- >>> dumpDat $ prepare cfg {labels=["comb11"]} o1  
-- Dumped comb11 in ./fig
-- ["./fig/comb11.dat"]
-- >>> dumpDat $ prepareL cfg {labels=["comb22-1","comb22-2"]} [o2_1, o2_2]
-- Dumped comb22-1, comb22-2 in ./fig
-- ["./fig/comb22-1.dat","./fig/comb22-2.dat"]
--
-- <<fig/moc-ct-pattern-comb.png>>
comb22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> (b1, b2)) -- ^ function on values
       -> SignalBase ts tm a1              -- ^ first input signal
       -> SignalBase ts tm a2              -- ^ second input signal
       -> (SignalBase ts tm b1, SignalBase ts tm b2) -- ^ two output signals
comb11 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> b1)
       -> SignalBase ts tm a1 -> SignalBase ts tm b1                                
comb12 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> (b1, b2))
       -> SignalBase ts tm a1 -> (SignalBase ts tm b1, SignalBase ts tm b2)                          
comb13 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> (b1, b2, b3))
       -> SignalBase ts tm a1 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                      
comb14 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> (b1, b2, b3, b4))
       -> SignalBase ts tm a1 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                  
comb21 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> b1)
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm b1                          
comb23 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> (b1, b2, b3))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                
comb24 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> (b1, b2, b3, b4))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)            
comb31 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> b1)
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm b1                    
comb32 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> (b1, b2))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> (SignalBase ts tm b1, SignalBase ts tm b2)              
comb33 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> (b1, b2, b3))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)          
comb34 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> (b1, b2, b3, b4))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)     
comb41 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> a4 -> b1)
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 -> SignalBase ts tm b1              
comb42 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> a4 -> (b1, b2))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 -> (SignalBase ts tm b1, SignalBase ts tm b2)        
comb43 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)    
comb44 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
       -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

comb11 :: (a1 -> b1) -> SignalBase ts tm a1 -> SignalBase ts tm b1
comb11 = (a1 -> b1) -> SignalBase ts tm a1 -> SignalBase ts tm b1
forall (e :: * -> *) a b.
MoC e =>
Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
MoC.comb11 
comb12 :: (a1 -> (b1, b2))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
comb12 = (a1 -> (b1, b2))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a b1 b2.
MoC e =>
Fun e a (Ret e b1, Ret e b2)
-> Stream (e a) -> (Stream (e b1), Stream (e b2))
MoC.comb12 
comb13 :: (a1 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
comb13 = (a1 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a b1 b2 b3.
MoC e =>
Fun e a (Ret e b1, Ret e b2, Ret e b3)
-> Stream (e a) -> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.comb13 
comb14 :: (a1 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
comb14 = (a1 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a b1 b2 b3 b4.
MoC e =>
Fun e a (Ret e b1, Ret e b2, Ret e b3, Ret e b4)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.comb14 
comb21 :: (a1 -> a2 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
comb21 = (a1 -> a2 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 b.
MoC e =>
Fun e a1 (Fun e a2 (Ret e b))
-> Stream (e a1) -> Stream (e a2) -> Stream (e b)
MoC.comb21 
comb22 :: (a1 -> a2 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
comb22 = (a1 -> a2 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
-> Stream (e a1) -> Stream (e a2) -> (Stream (e b1), Stream (e b2))
MoC.comb22 
comb23 :: (a1 -> a2 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
comb23 = (a1 -> a2 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Ret e b1, Ret e b2, Ret e b3))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.comb23 
comb24 :: (a1 -> a2 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
comb24 = (a1 -> a2 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Ret e b1, Ret e b2, Ret e b3, Ret e b4))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.comb24 
comb31 :: (a1 -> a2 -> a3 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
comb31 = (a1 -> a2 -> a3 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e b)))
-> Stream (e a1) -> Stream (e a2) -> Stream (e a3) -> Stream (e b)
MoC.comb31 
comb32 :: (a1 -> a2 -> a3 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
comb32 = (a1 -> a2 -> a3 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2)))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2))
MoC.comb32 
comb33 :: (a1 -> a2 -> a3 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
comb33 = (a1 -> a2 -> a3 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2, Ret e b3)))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.comb33 
comb34 :: (a1 -> a2 -> a3 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
comb34 = (a1 -> a2 -> a3 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3 b4.
MoC e =>
Fun
  e a1 (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.comb34 
comb41 :: (a1 -> a2 -> a3 -> a4 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
comb41 = (a1 -> a2 -> a3 -> a4 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e b)
MoC.comb41 
comb42 :: (a1 -> a2 -> a3 -> a4 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
comb42 = (a1 -> a2 -> a3 -> a4 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2))
MoC.comb42 
comb43 :: (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
comb43 = (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3.
MoC e =>
Fun
  e
  a1
  (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2, Ret e b3))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.comb43 
comb44 :: (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
comb44 = (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3 b4.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2, Ret e b3, Ret e b4))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.comb44 

------- RECONFIG -------

-- | @reconfig@ creates a CT adaptive process where the first signal
-- carries functions and the other carry the arguments. It
-- instantiates the @reconfig@ atom pattern (see
-- 'ForSyDe.Atom.MoC.reconfig22').
--
-- Constructors: @reconfig[1-4][1-4]@.
--
-- >>> let s1 = infinite (sin') :: Signal Time
-- >>> let sf = signal [(0,\_->(*0)),(pi',\_->(+1)),(2*pi',\_->(*0)),(3*pi',\_->(+1))]
-- >>> dumpDat $ prepare cfg {labels=["reconfig"]} $ reconfig11 sf s1
-- Dumped reconfig in ./fig
-- ["./fig/reconfig.dat"]
reconfig22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm (a1 -> a2 -> (b1, b2))
           -- ^ signal carrying functions
           -> SignalBase ts tm a1
           -- ^ first input signal carrying arguments
           -> SignalBase ts tm a2
           -- ^ second input signal carrying arguments
           -> (SignalBase ts tm b1, SignalBase ts tm b2)
           -- ^ two output signals
reconfig11 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm (a1 -> b1)
           -> SignalBase ts tm a1
           -> SignalBase ts tm b1
reconfig12 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> (b1, b2))
           -> SignalBase ts tm a1
           -> (SignalBase ts tm b1, SignalBase ts tm b2)
reconfig13 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> (b1, b2, b3))
           -> SignalBase ts tm a1
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig14 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> (b1, b2, b3, b4))
           -> SignalBase ts tm a1
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)
reconfig21 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> b1)
           -> SignalBase ts tm a1 -> SignalBase ts tm a2
           -> SignalBase ts tm b1
reconfig23 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> (b1, b2, b3))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig24 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> (b1, b2, b3, b4))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)
reconfig31 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> b1)
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
           -> SignalBase ts tm b1
reconfig32 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> (b1, b2))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
           -> (SignalBase ts tm b1, SignalBase ts tm b2)
reconfig33 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> (b1, b2, b3))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig34 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> (b1, b2, b3, b4))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)
reconfig41 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> a4 -> b1)
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
           -> SignalBase ts tm b1
reconfig42 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> a4 -> (b1, b2))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
           -> (SignalBase ts tm b1, SignalBase ts tm b2)
reconfig43 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig44 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => SignalBase ts tm(a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
           -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

reconfig11 :: SignalBase ts tm (a1 -> b1)
-> SignalBase ts tm a1 -> SignalBase ts tm b1
reconfig11 = SignalBase ts tm (a1 -> b1)
-> SignalBase ts tm a1 -> SignalBase ts tm b1
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a (Ret e b))) -> Stream (e a) -> Stream (e b)
MoC.reconfig11 
reconfig12 :: SignalBase ts tm (a1 -> (b1, b2))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
reconfig12 = SignalBase ts tm (a1 -> (b1, b2))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a b1 b2.
MoC e =>
Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> (Stream (e b1), Stream (e b2))
MoC.reconfig12 
reconfig13 :: SignalBase ts tm (a1 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig13 = SignalBase ts tm (a1 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a b1 b2 b3.
MoC e =>
Stream (e (Fun e a (Ret e b1, Ret e b2, Ret e b3)))
-> Stream (e a) -> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.reconfig13 
reconfig14 :: SignalBase ts tm (a1 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
reconfig14 = SignalBase ts tm (a1 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a b1 b2 b3 b4.
MoC e =>
Stream (e (Fun e a (Ret e b1, Ret e b2, Ret e b3, Ret e b4)))
-> Stream (e a)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.reconfig14 
reconfig21 :: SignalBase ts tm (a1 -> a2 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
reconfig21 = SignalBase ts tm (a1 -> a2 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 b.
MoC e =>
Stream (e (Fun e a1 (Fun e a2 (Ret e b))))
-> Stream (e a1) -> Stream (e a2) -> Stream (e b)
MoC.reconfig21 
reconfig22 :: SignalBase ts tm (a1 -> a2 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
reconfig22 = SignalBase ts tm (a1 -> a2 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 b1 b2.
MoC e =>
Stream (e (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))))
-> Stream (e a1) -> Stream (e a2) -> (Stream (e b1), Stream (e b2))
MoC.reconfig22 
reconfig23 :: SignalBase ts tm (a1 -> a2 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig23 = SignalBase ts tm (a1 -> a2 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 b1 b2 b3.
MoC e =>
Stream (e (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2, Ret e b3))))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.reconfig23 
reconfig24 :: SignalBase ts tm (a1 -> a2 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
reconfig24 = SignalBase ts tm (a1 -> a2 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 b1 b2 b3 b4.
MoC e =>
Stream
  (e (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2, Ret e b3, Ret e b4))))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.reconfig24 
reconfig31 :: SignalBase ts tm (a1 -> a2 -> a3 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
reconfig31 = SignalBase ts tm (a1 -> a2 -> a3 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 b.
MoC e =>
Stream (e (Fun e a1 (Fun e a2 (Fun e a3 (Ret e b)))))
-> Stream (e a1) -> Stream (e a2) -> Stream (e a3) -> Stream (e b)
MoC.reconfig31 
reconfig32 :: SignalBase ts tm (a1 -> a2 -> a3 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
reconfig32 = SignalBase ts tm (a1 -> a2 -> a3 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 b1 b2.
MoC e =>
Stream (e (Fun e a1 (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2))
MoC.reconfig32 
reconfig33 :: SignalBase ts tm (a1 -> a2 -> a3 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig33 = SignalBase ts tm (a1 -> a2 -> a3 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3.
MoC e =>
Stream
  (e (Fun e a1 (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2, Ret e b3)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.reconfig33 
reconfig34 :: SignalBase ts tm (a1 -> a2 -> a3 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
reconfig34 = SignalBase ts tm (a1 -> a2 -> a3 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3 b4.
MoC e =>
Stream
  (e (Fun
        e
        a1
        (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.reconfig34 
reconfig41 :: SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
reconfig41 = SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 b.
MoC e =>
Stream (e (Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b))))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e b)
MoC.reconfig41 
reconfig42 :: SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
reconfig42 = SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2.
MoC e =>
Stream
  (e (Fun
        e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2))))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2))
MoC.reconfig42 
reconfig43 :: SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
reconfig43 = SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3.
MoC e =>
Stream
  (e (Fun
        e
        a1
        (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2, Ret e b3))))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.reconfig43 
reconfig44 :: SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
reconfig44 = SignalBase ts tm (a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3 b4.
MoC e =>
Stream
  (e (Fun
        e
        a1
        (Fun
           e
           a2
           (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2, Ret e b3, Ret e b4))))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.reconfig44 

------- CONSTANT -------

-- | A generator for a constant signal. As compared with the
-- 'ForSyDe.Atom.MoC.SY.constant2', it just constructs an infinite
-- signal with constant value (i.e. a signal with one event starting
-- from time 0).
--
-- Constructors: @constant[1-4]@.
--
-- >>> let ctsig = constant1 2 :: Signal Int
-- >>> dumpDat $ prepare cfg {labels=["constant"]} ctsig
-- Dumped constant in ./fig
-- ["./fig/constant.dat"]
--
-- <<fig/moc-ct-pattern-constant.png>>
constant2 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
          => (b1, b2)         -- ^ values to be repeated
          -> (SignalBase ts tm b1, SignalBase ts tm b2) -- ^ generated signals
constant1 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => b1 -> SignalBase ts tm b1                                
constant3 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
          => (b1, b2, b3)
          -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
constant4 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
          => (b1, b2, b3, b4)
          -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

constant1 :: b1 -> SignalBase ts tm b1
constant1 = (tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite ((tm -> b1) -> SignalBase ts tm b1)
-> (b1 -> tm -> b1) -> b1 -> SignalBase ts tm b1
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b1 -> tm -> b1
forall a b. a -> b -> a
const 
constant2 :: (b1, b2) -> (SignalBase ts tm b1, SignalBase ts tm b2)
constant2 = (b1 -> SignalBase ts tm b1, b2 -> SignalBase ts tm b2)
-> (b1, b2) -> (SignalBase ts tm b1, SignalBase ts tm b2)
forall a1 b1 a2 b2. (a1 -> b1, a2 -> b2) -> (a1, a2) -> (b1, b2)
($$) (b1 -> SignalBase ts tm b1
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1, b2 -> SignalBase ts tm b2
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1)
constant3 :: (b1, b2, b3)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
constant3 = (b1 -> SignalBase ts tm b1, b2 -> SignalBase ts tm b2,
 b3 -> SignalBase ts tm b3)
-> (b1, b2, b3)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall t1 a t2 b t3 c.
(t1 -> a, t2 -> b, t3 -> c) -> (t1, t2, t3) -> (a, b, c)
($$$) (b1 -> SignalBase ts tm b1
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1,b2 -> SignalBase ts tm b2
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1,b3 -> SignalBase ts tm b3
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1)
constant4 :: (b1, b2, b3, b4)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
constant4 = (b1 -> SignalBase ts tm b1, b2 -> SignalBase ts tm b2,
 b3 -> SignalBase ts tm b3, b4 -> SignalBase ts tm b4)
-> (b1, b2, b3, b4)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall t1 a t2 b t3 c t4 d.
(t1 -> a, t2 -> b, t3 -> c, t4 -> d)
-> (t1, t2, t3, t4) -> (a, b, c, d)
($$$$) (b1 -> SignalBase ts tm b1
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1,b2 -> SignalBase ts tm b2
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1,b3 -> SignalBase ts tm b3
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1,b4 -> SignalBase ts tm b4
forall ts tm b1.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
b1 -> SignalBase ts tm b1
constant1)


------- INFINITE -------

-- | A generator for an infinite signal. Similar to 'constant2'.
--
-- Constructors: @infinite[1-4]@.
--
-- >>> let (inf1, inf2) = infinite2 (sin', cos') :: (Signal Time, Signal Time)
-- >>> dumpDat $ prepareL cfg {labels=["infinite2-1", "infinite2-2"]} [inf1, inf2] 
-- Dumped infinite2-1, infinite2-2 in ./fig
-- ["./fig/infinite2-1.dat","./fig/infinite2-2.dat"]
--
-- <<fig/moc-ct-pattern-infinite.png>>
infinite2 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
          => (tm -> b1, tm -> b2)         -- ^ values to be repeated
          -> (SignalBase ts tm b1, SignalBase ts tm b2) -- ^ generated signals
infinite1 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
          => (tm -> b1) -> SignalBase ts tm b1                                
infinite3 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
          => (tm -> b1, tm -> b2, tm -> b3)
          -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
infinite4 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
          => (tm -> b1, tm -> b2, tm -> b3, tm -> b4)
          -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

infinite1 :: (tm -> b1) -> SignalBase ts tm b1
infinite1 = (tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite
infinite2 :: (tm -> b1, tm -> b2) -> (SignalBase ts tm b1, SignalBase ts tm b2)
infinite2 = ((tm -> b1) -> SignalBase ts tm b1,
 (tm -> b2) -> SignalBase ts tm b2)
-> (tm -> b1, tm -> b2)
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall a1 b1 a2 b2. (a1 -> b1, a2 -> b2) -> (a1, a2) -> (b1, b2)
($$) ((tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite, (tm -> b2) -> SignalBase ts tm b2
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite)
infinite3 :: (tm -> b1, tm -> b2, tm -> b3)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
infinite3 = ((tm -> b1) -> SignalBase ts tm b1,
 (tm -> b2) -> SignalBase ts tm b2,
 (tm -> b3) -> SignalBase ts tm b3)
-> (tm -> b1, tm -> b2, tm -> b3)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall t1 a t2 b t3 c.
(t1 -> a, t2 -> b, t3 -> c) -> (t1, t2, t3) -> (a, b, c)
($$$) ((tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite,(tm -> b2) -> SignalBase ts tm b2
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite,(tm -> b3) -> SignalBase ts tm b3
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite)
infinite4 :: (tm -> b1, tm -> b2, tm -> b3, tm -> b4)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
infinite4 = ((tm -> b1) -> SignalBase ts tm b1,
 (tm -> b2) -> SignalBase ts tm b2,
 (tm -> b3) -> SignalBase ts tm b3,
 (tm -> b4) -> SignalBase ts tm b4)
-> (tm -> b1, tm -> b2, tm -> b3, tm -> b4)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall t1 a t2 b t3 c t4 d.
(t1 -> a, t2 -> b, t3 -> c, t4 -> d)
-> (t1, t2, t3, t4) -> (a, b, c, d)
($$$$) ((tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite,(tm -> b2) -> SignalBase ts tm b2
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite,(tm -> b3) -> SignalBase ts tm b3
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite,(tm -> b4) -> SignalBase ts tm b4
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(tm -> a) -> SignalBase ts tm a
infinite)

------- GENERATE -------

-- | A signal generator based on a function and a kernel value. It
-- is actually an instantiation of the @stated0X@ constructor
-- (check 'ForSyDe.Atom.MoC.stated22').
--
-- Constructors: @generate[1-4]@.
--
-- >>> let { osc 0 = 1 ; osc 1 = 0 }
-- >>> let sg = generate1 osc (pi', \_->0) :: Signal Int
-- >>> dumpDat $ prepare cfg {labels=["generate"]} sg
-- Dumped generate in ./fig
-- ["./fig/generate.dat"]
--
-- <<fig/moc-ct-pattern-generate.png>>
--
-- Another example simulating an RC oscillator:
--
-- >>> let vs = 2                                -- Vs : supply voltage
-- >>> let r  = 100                              -- R : resistance
-- >>> let c  = 0.0005                           -- C : capacitance
-- >>> let vc t = vs * (1 - exp' (-t / (r * c))) -- Vc(t) : voltage charging through capacitor
-- >>> let ns v = vs + (-1 * v)                  -- next state : charging / discharging
-- >>> let rcOsc = generate1 ns (milisec 500, vc)
-- >>> dumpDat $ prepare cfg {labels=["rcosc"]} $ rcOsc
-- Dumped rcosc in ./fig
-- ["./fig/rcosc.dat"]
--
-- <<fig/moc-ct-pattern-generate1.png>>
generate2 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> (b1, b2))
          -- ^ function to generate next value
          -> ((ts, tm -> b1), (ts, tm -> b2))
          -- ^ kernel values tupled with their generation rate.
          -> (SignalBase ts tm b1, SignalBase ts tm b2) -- ^ generated signals
generate1 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b1) -> (ts, tm -> b1)
          -> SignalBase ts tm b1                                
generate3 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> (b1, b2, b3))
          -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
          -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                      
generate4 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> b4 -> (b1, b2, b3, b4))
          -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
          -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                  

generate1 :: (b1 -> b1) -> (ts, tm -> b1) -> SignalBase ts tm b1
generate1 ns :: b1 -> b1
ns i :: (ts, tm -> b1)
i = Fun (CT ts tm) b1 (Ret (CT ts tm) b1)
-> SignalBase ts tm b1 -> SignalBase ts tm b1
forall (e :: * -> *) a.
MoC e =>
Fun e a (Ret e a) -> Stream (e a) -> Stream (e a)
MoC.stated01 Fun (CT ts tm) b1 (Ret (CT ts tm) b1)
b1 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
generate2 :: (b1 -> b2 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
generate2 ns :: b1 -> b2 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun (CT ts tm) b2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1, Ret e a2))
-> (Stream (e a1), Stream (e a2)) -> (Stream (e a1), Stream (e a2))
MoC.stated02 Fun
  (CT ts tm)
  b1
  (Fun (CT ts tm) b2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))
b1 -> b2 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
generate3 :: (b1 -> b2 -> b3 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
generate3 ns :: b1 -> b2 -> b3 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1, Ret e a2, Ret e a3)))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.stated03 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))
b1 -> b2 -> b3 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
generate4 :: (b1 -> b2 -> b3 -> b4 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
generate4 ns :: b1 -> b2 -> b3 -> b4 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
            Ret (CT ts tm) b4))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun e a3 (Fun e a4 (Ret e a1, Ret e a2, Ret e a3, Ret e a4))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.stated04 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
            Ret (CT ts tm) b4))))
b1 -> b2 -> b3 -> b4 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)

------- STATED -------

-- | @stated@ is a state machine without an output decoder. It is an
-- instantiation of the @state@ MoC constructor (see
-- 'ForSyDe.Atom.MoC.stated22').
--
-- Constructors: @stated[1-4][1-4]@.
--
-- >>> let { osc 0 a = a; osc _ a = 0 }   
-- >>> let s1 = signal [(0,\_->1), (6,\_->0)] :: Signal Int
-- >>> dumpDat $ prepare cfg {labels=["stated"]} $ stated11 osc (1,\_->0) s1
-- Dumped stated in ./fig
-- ["./fig/stated.dat"]
--
-- <<fig/moc-ct-pattern-stated.png>>
stated22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> a1 -> a2 -> (b1, b2))
            -- ^ next state function
           -> ((ts, tm -> b1), (ts, tm -> b2))
           -- ^ initial state values tupled with their initial delay
            -> SignalBase ts tm a1
            -- ^ first input signal
            -> SignalBase ts tm a2
            -- ^ second input signal
            -> (SignalBase ts tm b1, SignalBase ts tm b2) -- ^ output signals
stated11 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> a1 -> b1)
         -> (ts, tm -> b1)
         -> SignalBase ts tm a1
         -> SignalBase ts tm b1 
stated12 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> a1 -> (b1, b2))
         -> ((ts, tm -> b1), (ts, tm -> b2))
         -> SignalBase ts tm a1
         -> (SignalBase ts tm b1, SignalBase ts tm b2) 
stated13 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> a1 -> (b1, b2, b3))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
         -> SignalBase ts tm a1
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3) 
stated14 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
         -> SignalBase ts tm a1
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4) 
stated21 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> a1 -> a2 -> b1)
         -> (ts, tm -> b1)
         -> SignalBase ts tm a1 -> SignalBase ts tm a2
         -> SignalBase ts tm b1 
stated23 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3) 
stated24 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4) 
stated31 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> a1 -> a2 -> a3 -> b1)
         -> (ts, tm -> b1)
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
         -> SignalBase ts tm b1 
stated32 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2))
         -> ((ts, tm -> b1), (ts, tm -> b2))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
         -> (SignalBase ts tm b1, SignalBase ts tm b2) 
stated33 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3) 
stated34 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4) 
stated41 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> a1 -> a2 -> a3 -> a4 -> b1)
         -> (ts, tm -> b1)
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
         -> SignalBase ts tm b1 
stated42 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2))
         -> ((ts, tm -> b1), (ts, tm -> b2))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
         -> (SignalBase ts tm b1, SignalBase ts tm b2) 
stated43 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3) 
stated44 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
         -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
         -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
         -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

stated11 :: (b1 -> a1 -> b1)
-> (ts, tm -> b1) -> SignalBase ts tm a1 -> SignalBase ts tm b1
stated11 ns :: b1 -> a1 -> b1
ns i :: (ts, tm -> b1)
i = Fun (CT ts tm) b1 (Fun (CT ts tm) a1 (Ret (CT ts tm) b1))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Stream (e a1) -> Stream (e a2) -> Stream (e a1)
MoC.stated11 Fun (CT ts tm) b1 (Fun (CT ts tm) a1 (Ret (CT ts tm) b1))
b1 -> a1 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
stated12 :: (b1 -> b2 -> a1 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
stated12 ns :: b1 -> b2 -> a1 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun (CT ts tm) a1 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1, Ret e a2)))
-> (Stream (e a1), Stream (e a2))
-> Stream (e a3)
-> (Stream (e a1), Stream (e a2))
MoC.stated12 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun (CT ts tm) a1 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))
b1 -> b2 -> a1 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
stated13 :: (b1 -> b2 -> b3 -> a1 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
stated13 ns :: b1 -> b2 -> b3 -> a1 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4.
MoC e =>
Fun
  e
  a1
  (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1, Ret e a2, Ret e a3))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.stated13 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))
b1 -> b2 -> b3 -> a1 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
stated14 :: (b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
stated14 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
               Ret (CT ts tm) b4)))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun e a4 (Fun e a5 (Ret e a1, Ret e a2, Ret e a3, Ret e a4)))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.stated14 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
               Ret (CT ts tm) b4)))))
b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)
stated21 :: (b1 -> a1 -> a2 -> b1)
-> (ts, tm -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
stated21 ns :: b1 -> a1 -> a2 -> b1
ns i :: (ts, tm -> b1)
i = Fun
  (CT ts tm)
  b1
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) b1)))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
-> Stream (e a1) -> Stream (e a2) -> Stream (e a3) -> Stream (e a1)
MoC.stated21 Fun
  (CT ts tm)
  b1
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) b1)))
b1 -> a1 -> a2 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
stated22 :: (b1 -> b2 -> a1 -> a2 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
stated22 ns :: b1 -> b2 -> a1 -> a2 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun (CT ts tm) a2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) st1 st2 a1 a2.
MoC e =>
Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
-> (Stream (e st1), Stream (e st2))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e st1), Stream (e st2))
MoC.stated22 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun (CT ts tm) a2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))
b1 -> b2 -> a1 -> a2 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
stated23 :: (b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
stated23 ns :: b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1, Ret e a2, Ret e a3)))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.stated23 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))
b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
stated24 :: (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
stated24 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                  Ret (CT ts tm) b4))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun e a5 (Fun e a6 (Ret e a1, Ret e a2, Ret e a3, Ret e a4))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> Stream (e a6)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.stated24 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                  Ret (CT ts tm) b4))))))
b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)
stated31 :: (b1 -> a1 -> a2 -> a3 -> b1)
-> (ts, tm -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
stated31 ns :: b1 -> a1 -> a2 -> a3 -> b1
ns i :: (ts, tm -> b1)
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) b1))))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a1)
MoC.stated31 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) b1))))
b1 -> a1 -> a2 -> a3 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
stated32 :: (b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
stated32 ns :: b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun (CT ts tm) a3 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 a5.
MoC e =>
Fun
  e
  a1
  (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1, Ret e a2)))))
-> (Stream (e a1), Stream (e a2))
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e a1), Stream (e a2))
MoC.stated32 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun (CT ts tm) a3 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))))
b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
stated33 :: (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
stated33 ns :: b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun e a4 (Fun e a5 (Fun e a6 (Ret e a1, Ret e a2, Ret e a3))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e a6)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.stated33 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))))
b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
stated34 :: (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
stated34 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                     Ret (CT ts tm) b4)))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6 a7.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun
              e
              a5
              (Fun e a6 (Fun e a7 (Ret e a1, Ret e a2, Ret e a3, Ret e a4)))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> Stream (e a6)
-> Stream (e a7)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.stated34 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                     Ret (CT ts tm) b4)))))))
b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)
stated41 :: (b1 -> a1 -> a2 -> a3 -> a4 -> b1)
-> (ts, tm -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
stated41 ns :: b1 -> a1 -> a2 -> a3 -> a4 -> b1
ns i :: (ts, tm -> b1)
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) b1)))))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 a5.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e a1)
MoC.stated41 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) b1)))))
b1 -> a1 -> a2 -> a3 -> a4 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
stated42 :: (b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
stated42 ns :: b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Fun (CT ts tm) a4 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun e a3 (Fun e a4 (Fun e a5 (Fun e a6 (Ret e a1, Ret e a2))))))
-> (Stream (e a1), Stream (e a2))
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e a6)
-> (Stream (e a1), Stream (e a2))
MoC.stated42 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Fun (CT ts tm) a4 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))))
b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
stated43 :: (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
stated43 ns :: b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Fun
                    (CT ts tm)
                    a4
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6 a7.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun e a5 (Fun e a6 (Fun e a7 (Ret e a1, Ret e a2, Ret e a3)))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e a6)
-> Stream (e a7)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.stated43 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Fun
                    (CT ts tm)
                    a4
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))))
b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
stated44 :: (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
stated44 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Fun
                       (CT ts tm)
                       a4
                       (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                        Ret (CT ts tm) b4))))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6 a7 a8.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun
              e
              a5
              (Fun
                 e
                 a6
                 (Fun e a7 (Fun e a8 (Ret e a1, Ret e a2, Ret e a3, Ret e a4))))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> Stream (e a6)
-> Stream (e a7)
-> Stream (e a8)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.stated44 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Fun
                       (CT ts tm)
                       a4
                       (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                        Ret (CT ts tm) b4))))))))
b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)

------- STATE -------

-- | @state@ is a state machine without an output decoder, and the
-- state non-transparent. It is an instantiation of the @state@ MoC
-- constructor (see 'ForSyDe.Atom.MoC.state22').
--
-- Constructors: @state[1-4][1-4]@.
--
-- >>> let { osc 0 a = a; osc _ a = 0 }   
-- >>> let s1 = signal [(0,\_->1), (6,\_->0)] :: Signal Int
-- >>> dumpDat $ prepare cfg {labels=["state"]} $ state11 osc (1,\_->0) s1
-- Dumped state in ./fig
-- ["./fig/state.dat"]
--
-- <<fig/moc-ct-pattern-state.png>>                   
state22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> a1 -> a2 -> (b1, b2))
           -- ^ next state function
           -> ((ts, tm -> b1), (ts, tm -> b2))
           -- ^ initial state values tupled with their initial delay
           -> SignalBase ts tm a1
           -- ^ first input signal
           -> SignalBase ts tm a2
           -- ^ second input signal
           -> (SignalBase ts tm b1, SignalBase ts tm b2) -- ^ output signals
state11 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> a1 -> b1)
        -> (ts, tm -> b1)
        -> SignalBase ts tm a1
        -> SignalBase ts tm b1                                
state12 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> a1 -> (b1, b2)) 
        -> ((ts, tm -> b1), (ts, tm -> b2))
        -> SignalBase ts tm a1
        -> (SignalBase ts tm b1, SignalBase ts tm b2)                          
state13 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> b3 -> a1 -> (b1, b2, b3)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
        -> SignalBase ts tm a1
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                      
state14 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
        -> SignalBase ts tm a1 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                  
state21 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> a1 -> a2 -> b1)
        -> (ts, tm -> b1)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2
        -> SignalBase ts tm b1                          
state23 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                
state24 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
    => (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                     
state31 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> a1 -> a2 -> a3 -> b1)
        -> (ts, tm -> b1)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
        -> SignalBase ts tm b1                    
state32 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2)) 
        -> ((ts, tm -> b1), (ts, tm -> b2))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 
        -> (SignalBase ts tm b1, SignalBase ts tm b2)              
state33 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)          
state34 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)     
state41 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> a1 -> a2 -> a3 -> a4 -> b1)
        -> (ts, tm -> b1)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
        -> SignalBase ts tm b1
state42 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2)) 
        -> ((ts, tm -> b1), (ts, tm -> b2))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 
        -> (SignalBase ts tm b1, SignalBase ts tm b2)        
state43 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)    
state44 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)) 
        -> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

state11 :: (b1 -> a1 -> b1)
-> (ts, tm -> b1) -> SignalBase ts tm a1 -> SignalBase ts tm b1
state11 ns :: b1 -> a1 -> b1
ns i :: (ts, tm -> b1)
i = Fun (CT ts tm) b1 (Fun (CT ts tm) a1 (Ret (CT ts tm) b1))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 b.
(MoC e,
 Fun e a1 (Fun e a2 (Ret e a1)) ~ Fun e a1 (Fun e a2 (Ret e b))) =>
Fun e a1 (Fun e a2 (Ret e b))
-> Stream (e a1) -> Stream (e a2) -> Stream (e b)
MoC.state11 Fun (CT ts tm) b1 (Fun (CT ts tm) a1 (Ret (CT ts tm) b1))
b1 -> a1 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
state12 :: (b1 -> b2 -> a1 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
state12 ns :: b1 -> b2 -> a1 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun (CT ts tm) a1 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1, Ret e a2)))
-> (Stream (e a1), Stream (e a2))
-> Stream (e a3)
-> (Stream (e a1), Stream (e a2))
MoC.state12 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun (CT ts tm) a1 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))
b1 -> b2 -> a1 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
state13 :: (b1 -> b2 -> b3 -> a1 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
state13 ns :: b1 -> b2 -> b3 -> a1 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4.
MoC e =>
Fun
  e
  a1
  (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1, Ret e a2, Ret e a3))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.state13 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))
b1 -> b2 -> b3 -> a1 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
state14 :: (b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
state14 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
               Ret (CT ts tm) b4)))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun e a4 (Fun e a5 (Ret e a1, Ret e a2, Ret e a3, Ret e a4)))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.state14 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
               Ret (CT ts tm) b4)))))
b1 -> b2 -> b3 -> b4 -> a1 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)
state21 :: (b1 -> a1 -> a2 -> b1)
-> (ts, tm -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
state21 ns :: b1 -> a1 -> a2 -> b1
ns i :: (ts, tm -> b1)
i = Fun
  (CT ts tm)
  b1
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) b1)))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 b.
(MoC e,
 Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
 ~ Fun e a1 (Fun e a2 (Fun e a3 (Ret e b)))) =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e b)))
-> Stream (e a1) -> Stream (e a2) -> Stream (e a3) -> Stream (e b)
MoC.state21 Fun
  (CT ts tm)
  b1
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) b1)))
b1 -> a1 -> a2 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
state22 :: (b1 -> b2 -> a1 -> a2 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
state22 ns :: b1 -> b2 -> a1 -> a2 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun (CT ts tm) a2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) st1 st2 a1 a2.
MoC e =>
Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
-> (Stream (e st1), Stream (e st2))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e st1), Stream (e st2))
MoC.state22 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun (CT ts tm) a2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))
b1 -> b2 -> a1 -> a2 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
state23 :: (b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
state23 ns :: b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1, Ret e a2, Ret e a3)))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.state23 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))
b1 -> b2 -> b3 -> a1 -> a2 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
state24 :: (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
state24 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                  Ret (CT ts tm) b4))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun e a5 (Fun e a6 (Ret e a1, Ret e a2, Ret e a3, Ret e a4))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> Stream (e a6)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.state24 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                  Ret (CT ts tm) b4))))))
b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)
state31 :: (b1 -> a1 -> a2 -> a3 -> b1)
-> (ts, tm -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
state31 ns :: b1 -> a1 -> a2 -> a3 -> b1
ns i :: (ts, tm -> b1)
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) b1))))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 b.
(MoC e,
 Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
 ~ Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b))))) =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e b)
MoC.state31 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) b1))))
b1 -> a1 -> a2 -> a3 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
state32 :: (b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
state32 ns :: b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun (CT ts tm) a3 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 a5.
MoC e =>
Fun
  e
  a1
  (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1, Ret e a2)))))
-> (Stream (e a1), Stream (e a2))
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e a1), Stream (e a2))
MoC.state32 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun (CT ts tm) a3 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))))
b1 -> b2 -> a1 -> a2 -> a3 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
state33 :: (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
state33 ns :: b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun e a4 (Fun e a5 (Fun e a6 (Ret e a1, Ret e a2, Ret e a3))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e a6)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.state33 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))))
b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
state34 :: (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
state34 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                     Ret (CT ts tm) b4)))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6 a7.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun
              e
              a5
              (Fun e a6 (Fun e a7 (Ret e a1, Ret e a2, Ret e a3, Ret e a4)))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> Stream (e a6)
-> Stream (e a7)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.state34 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                     Ret (CT ts tm) b4)))))))
b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)
state41 :: (b1 -> a1 -> a2 -> a3 -> a4 -> b1)
-> (ts, tm -> b1)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
state41 ns :: b1 -> a1 -> a2 -> a3 -> a4 -> b1
ns i :: (ts, tm -> b1)
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) b1)))))
-> SignalBase ts tm b1
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 a5 b.
(MoC e,
 Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
 ~ Fun
     e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e b)))))) =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e b)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e b)
MoC.state41 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) b1)))))
b1 -> a1 -> a2 -> a3 -> a4 -> b1
ns ((ts, tm -> b1) -> SignalBase ts tm b1
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit  (ts, tm -> b1)
i)
state42 :: (b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
state42 ns :: b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2)
ns i :: ((ts, tm -> b1), (ts, tm -> b2))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Fun (CT ts tm) a4 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun e a3 (Fun e a4 (Fun e a5 (Fun e a6 (Ret e a1, Ret e a2))))))
-> (Stream (e a1), Stream (e a2))
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e a6)
-> (Stream (e a1), Stream (e a2))
MoC.state42 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Fun (CT ts tm) a4 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))))
b1 -> b2 -> a1 -> a2 -> a3 -> a4 -> (b1, b2)
ns (((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall ts tm a1 a2.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2))
-> (SignalBase ts tm a1, SignalBase ts tm a2)
unit2 ((ts, tm -> b1), (ts, tm -> b2))
i)
state43 :: (b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
state43 ns :: b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Fun
                    (CT ts tm)
                    a4
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6 a7.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun e a5 (Fun e a6 (Fun e a7 (Ret e a1, Ret e a2, Ret e a3)))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3))
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e a6)
-> Stream (e a7)
-> (Stream (e a1), Stream (e a2), Stream (e a3))
MoC.state43 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           a1
           (Fun
              (CT ts tm)
              a2
              (Fun
                 (CT ts tm)
                 a3
                 (Fun
                    (CT ts tm)
                    a4
                    (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))))
b1 -> b2 -> b3 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall ts tm a1 a2 a3.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
unit3 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3))
i)
state44 :: (b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
state44 ns :: b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)
ns i :: ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i = Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Fun
                       (CT ts tm)
                       a4
                       (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                        Ret (CT ts tm) b4))))))))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 a6 a7 a8.
MoC e =>
Fun
  e
  a1
  (Fun
     e
     a2
     (Fun
        e
        a3
        (Fun
           e
           a4
           (Fun
              e
              a5
              (Fun
                 e
                 a6
                 (Fun e a7 (Fun e a8 (Ret e a1, Ret e a2, Ret e a3, Ret e a4))))))))
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
-> Stream (e a5)
-> Stream (e a6)
-> Stream (e a7)
-> Stream (e a8)
-> (Stream (e a1), Stream (e a2), Stream (e a3), Stream (e a4))
MoC.state44 Fun
  (CT ts tm)
  b1
  (Fun
     (CT ts tm)
     b2
     (Fun
        (CT ts tm)
        b3
        (Fun
           (CT ts tm)
           b4
           (Fun
              (CT ts tm)
              a1
              (Fun
                 (CT ts tm)
                 a2
                 (Fun
                    (CT ts tm)
                    a3
                    (Fun
                       (CT ts tm)
                       a4
                       (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                        Ret (CT ts tm) b4))))))))
b1 -> b2 -> b3 -> b4 -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)
ns (((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall ts tm a1 a2 a3 a4.
(Num ts, Num tm, Ord ts) =>
((ts, tm -> a1), (ts, tm -> a2), (ts, tm -> a3), (ts, tm -> a4))
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
unit4 ((ts, tm -> b1), (ts, tm -> b2), (ts, tm -> b3), (ts, tm -> b4))
i)

------- MOORE -------

-- | @moore@ processes model Moore state machines. It is an
-- instantiation of the @moore@ MoC constructor (see
-- 'ForSyDe.Atom.MoC.moore22').
--
-- Constructors: @moore[1-4][1-4]@.
--
-- >>> let { osc 0 a = a; osc _ a = 0 }   
-- >>> let s1 = signal [(0,\_->1), (6,\_->0)] :: Signal Int
-- >>> dumpDat $ prepare cfg {labels=["moore"]} $ moore11 osc (*3) (1,\_->0) s1
-- Dumped moore in ./fig
-- ["./fig/moore.dat"]
--
-- <<fig/moc-ct-pattern-moore.png>>          
moore22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st)
           -- ^ next state function
           -> (st -> (b1, b2))
           -- ^ output decoder
           -> (ts, tm -> st)
           -- ^ initial state: tag and value
           -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> (SignalBase ts tm b1, SignalBase ts tm b2)
moore11 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st)
        -> (st -> b1)
        -> (ts, tm -> st)
        -> SignalBase ts tm a1
        -> SignalBase ts tm b1                                
moore12 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st)
        -> (st -> (b1, b2))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1
        -> (SignalBase ts tm b1, SignalBase ts tm b2)                          
moore13 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st)
        -> (st -> (b1, b2, b3))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                      
moore14 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st)
        -> (st -> (b1, b2, b3, b4))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                  
moore21 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st)
        -> (st -> b1)
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2
        -> SignalBase ts tm b1                          
moore23 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st)
        -> (st -> (b1, b2, b3))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                
moore24 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st)
        -> (st -> (b1, b2, b3, b4))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                     
moore31 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st)
        -> (st -> b1)
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
        -> SignalBase ts tm b1                    
moore32 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st)
        -> (st -> (b1, b2))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
        -> (SignalBase ts tm b1, SignalBase ts tm b2)              
moore33 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st)
        -> (st -> (b1, b2, b3))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)          
moore34 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st)
        -> (st -> (b1, b2, b3, b4))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)     
moore41 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st)
        -> (st -> b1)
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
        -> SignalBase ts tm b1              
moore42 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st)
        -> (st -> (b1, b2))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
        -> (SignalBase ts tm b1, SignalBase ts tm b2)        
moore43 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st)
        -> (st -> (b1, b2, b3))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)    
moore44 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st)
        -> (st -> (b1, b2, b3, b4))
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

moore11 :: (st -> a1 -> st)
-> (st -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm b1
moore11 ns :: st -> a1 -> st
ns od :: st -> b1
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 b.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Ret e b)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e b)
MoC.moore11 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1)
st -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore12 :: (st -> a1 -> st)
-> (st -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
moore12 ns :: st -> a1 -> st
ns od :: st -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Ret e b1, Ret e b2)
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2))
MoC.moore12 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
st -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore13 :: (st -> a1 -> st)
-> (st -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
moore13 ns :: st -> a1 -> st
ns od :: st -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3)
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.moore13 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
st -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore14 :: (st -> a1 -> st)
-> (st -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
moore14 ns :: st -> a1 -> st
ns od :: st -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
      Ret (CT ts tm) b4)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.moore14 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
   Ret (CT ts tm) b4)
st -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore21 :: (st -> a1 -> a2 -> st)
-> (st -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
moore21 ns :: st -> a1 -> a2 -> st
ns od :: st -> b1
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
-> Fun e a1 (Ret e b)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e b)
MoC.moore21 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1)
st -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore22 :: (st -> a1 -> a2 -> st)
-> (st -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
moore22 ns :: st -> a1 -> a2 -> st
ns od :: st -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) st a1 a2 b1 b2.
MoC e =>
Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
-> Fun e st (Ret e b1, Ret e b2)
-> Stream (e st)
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2))
MoC.moore22 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
st -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore23 :: (st -> a1 -> a2 -> st)
-> (st -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
moore23 ns :: st -> a1 -> a2 -> st
ns od :: st -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.moore23 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
st -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore24 :: (st -> a1 -> a2 -> st)
-> (st -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
moore24 ns :: st -> a1 -> a2 -> st
ns od :: st -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
      Ret (CT ts tm) b4)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.moore24 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
   Ret (CT ts tm) b4)
st -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore31 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
moore31 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> b1
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun e a1 (Ret e b)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e b)
MoC.moore31 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1)
st -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore32 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
moore32 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun e a1 (Ret e b1, Ret e b2)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2))
MoC.moore32 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
st -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore33 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
moore33 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.moore33 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
st -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore34 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
moore34 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
      Ret (CT ts tm) b4)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.moore34 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
   Ret (CT ts tm) b4)
st -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore41 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
moore41 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> b1
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 a5 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun e a1 (Ret e b)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e b)
MoC.moore41 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1)
st -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore42 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
moore42 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 a5 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun e a1 (Ret e b1, Ret e b2)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e b1), Stream (e b2))
MoC.moore42 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun (CT ts tm) st (Ret (CT ts tm) b1, Ret (CT ts tm) b2)
st -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore43 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
moore43 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.moore43 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)
st -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
moore44 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
moore44 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun
     (CT ts tm)
     st
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
      Ret (CT ts tm) b4)
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun e a1 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.moore44 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun
  (CT ts tm)
  st
  (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
   Ret (CT ts tm) b4)
st -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)

------- MEALY -------

-- | @mealy@ processes model Mealy state machines. It is an
-- instantiation of the @mealy@ MoC constructor
-- (see 'ForSyDe.Atom.MoC.mealy22').
--
-- Constructors: @mealy[1-4][1-4]@.
--
-- >>> let { osc (-1) _ = 1; osc 1 _ = (-1) } 
-- >>> let s1 = infinite sin'
-- >>> dumpDat $ prepare cfg {labels=["mealy"]} $ mealy11 osc (*) (pi',\_->1) s1
-- Dumped mealy in ./fig
-- ["./fig/mealy.dat"]
--
-- <<fig/moc-ct-pattern-mealy.png>>
mealy22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st)
        -- ^ next state function
        -> (st -> a1 -> a2 -> (b1, b2))
        -- ^ outpt decoder
        -> (ts, tm -> st)
        -- ^ initial state: tag and value
        -> SignalBase ts tm a1 -> SignalBase ts tm a2
        -> (SignalBase ts tm b1, SignalBase ts tm b2)
mealy11 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st) 
        -> (st -> a1 -> b1) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1
        -> SignalBase ts tm b1                                
mealy12 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st) 
        -> (st -> a1 -> (b1, b2)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 
        -> (SignalBase ts tm b1, SignalBase ts tm b2)                          
mealy13 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st) 
        -> (st -> a1 -> (b1, b2, b3)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                      
mealy14 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> st) 
        -> (st -> a1 -> (b1, b2, b3, b4)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                  
mealy21 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st) 
        -> (st -> a1 -> a2 -> b1) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2
        -> SignalBase ts tm b1                          
mealy23 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st) 
        -> (st -> a1 -> a2 -> (b1, b2, b3)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)                
mealy24 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> st) 
        -> (st -> a1 -> a2 -> (b1, b2, b3, b4)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)                     
mealy31 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st) 
        -> (st -> a1 -> a2 -> a3 -> b1) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
        -> SignalBase ts tm b1  
mealy32 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st) 
        -> (st -> a1 -> a2 -> a3 -> (b1, b2)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 
        -> (SignalBase ts tm b1, SignalBase ts tm b2)              
mealy33 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st) 
        -> (st -> a1 -> a2 -> a3 -> (b1, b2, b3)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)          
mealy34 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> st) 
        -> (st -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)     
mealy41 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st) 
        -> (st -> a1 -> a2 -> a3 -> a4 -> b1) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
        -> SignalBase ts tm b1
mealy42 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st) 
        -> (st -> a1 -> a2 -> a3 -> a4 -> (b1, b2)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 
        -> (SignalBase ts tm b1, SignalBase ts tm b2)        
mealy43 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st) 
        -> (st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)    
mealy44 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
        => (st -> a1 -> a2 -> a3 -> a4 -> st) 
        -> (st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)) 
        -> (ts, tm -> st)
        -> SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4 
        -> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3, SignalBase ts tm b4)

mealy11 :: (st -> a1 -> st)
-> (st -> a1 -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm b1
mealy11 ns :: st -> a1 -> st
ns od :: st -> a1 -> b1
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) b1))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 b.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Fun e a2 (Ret e b))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e b)
MoC.mealy11 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) b1))
st -> a1 -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy12 :: (st -> a1 -> st)
-> (st -> a1 -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
mealy12 ns :: st -> a1 -> st
ns od :: st -> a1 -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun
     (CT ts tm)
     st
     (Fun (CT ts tm) a1 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2))
MoC.mealy12 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))
st -> a1 -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy13 :: (st -> a1 -> st)
-> (st -> a1 -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
mealy13 ns :: st -> a1 -> st
ns od :: st -> a1 -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Fun e a2 (Ret e b1, Ret e b2, Ret e b3))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.mealy13 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))
st -> a1 -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy14 :: (st -> a1 -> st)
-> (st -> a1 -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
mealy14 ns :: st -> a1 -> st
ns od :: st -> a1 -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
         Ret (CT ts tm) b4))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Ret e a1))
-> Fun e a1 (Fun e a2 (Ret e b1, Ret e b2, Ret e b3, Ret e b4))
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.mealy14 Fun (CT ts tm) st (Fun (CT ts tm) a1 (Ret (CT ts tm) st))
st -> a1 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
      Ret (CT ts tm) b4))
st -> a1 -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy21 :: (st -> a1 -> a2 -> st)
-> (st -> a1 -> a2 -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
mealy21 ns :: st -> a1 -> a2 -> st
ns od :: st -> a1 -> a2 -> b1
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun
     (CT ts tm)
     st
     (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) b1)))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
-> Fun e a1 (Fun e a2 (Fun e a3 (Ret e b)))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e b)
MoC.mealy21 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) b1)))
st -> a1 -> a2 -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy22 :: (st -> a1 -> a2 -> st)
-> (st -> a1 -> a2 -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
mealy22 ns :: st -> a1 -> a2 -> st
ns od :: st -> a1 -> a2 -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun (CT ts tm) a2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) st a1 a2 b1 b2.
MoC e =>
Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
-> Fun e st (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2)))
-> Stream (e st)
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2))
MoC.mealy22 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))
st -> a1 -> a2 -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy23 :: (st -> a1 -> a2 -> st)
-> (st -> a1 -> a2 -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
mealy23 ns :: st -> a1 -> a2 -> st
ns od :: st -> a1 -> a2 -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
-> Fun e a1 (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2, Ret e b3)))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.mealy23 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))
st -> a1 -> a2 -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy24 :: (st -> a1 -> a2 -> st)
-> (st -> a1 -> a2 -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
mealy24 ns :: st -> a1 -> a2 -> st
ns od :: st -> a1 -> a2 -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
            Ret (CT ts tm) b4)))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Ret e a1)))
-> Fun
     e a1 (Fun e a2 (Fun e a3 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.mealy24 Fun
  (CT ts tm)
  st
  (Fun (CT ts tm) a1 (Fun (CT ts tm) a2 (Ret (CT ts tm) st)))
st -> a1 -> a2 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
         Ret (CT ts tm) b4)))
st -> a1 -> a2 -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy31 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> a1 -> a2 -> a3 -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
mealy31 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> a1 -> a2 -> a3 -> b1
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) b1))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e b)
MoC.mealy31 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) b1))))
st -> a1 -> a2 -> a3 -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy32 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> a1 -> a2 -> a3 -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
mealy32 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> a1 -> a2 -> a3 -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun (CT ts tm) a3 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2))
MoC.mealy32 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Ret (CT ts tm) b1, Ret (CT ts tm) b2))))
st -> a1 -> a2 -> a3 -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy33 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> a1 -> a2 -> a3 -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
mealy33 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> a1 -> a2 -> a3 -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun
     e
     a1
     (Fun e a2 (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2, Ret e b3))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.mealy33 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun
           (CT ts tm)
           a3
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3))))
st -> a1 -> a2 -> a3 -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy34 :: (st -> a1 -> a2 -> a3 -> st)
-> (st -> a1 -> a2 -> a3 -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
mealy34 ns :: st -> a1 -> a2 -> a3 -> st
ns od :: st -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
               Ret (CT ts tm) b4))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Ret e a1))))
-> Fun
     e
     a1
     (Fun
        e
        a2
        (Fun e a3 (Fun e a4 (Ret e b1, Ret e b2, Ret e b3, Ret e b4))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.mealy34 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun (CT ts tm) a2 (Fun (CT ts tm) a3 (Ret (CT ts tm) st))))
st -> a1 -> a2 -> a3 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun
           (CT ts tm)
           a3
           (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
            Ret (CT ts tm) b4))))
st -> a1 -> a2 -> a3 -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy41 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> a1 -> a2 -> a3 -> a4 -> b1)
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
mealy41 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> a1 -> a2 -> a3 -> a4 -> b1
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) b1)))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> SignalBase ts tm b1
forall (e :: * -> *) a1 a2 a3 a4 a5 b.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e b)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> Stream (e b)
MoC.mealy41 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) b1)))))
st -> a1 -> a2 -> a3 -> a4 -> b1
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy42 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> a1 -> a2 -> a3 -> a4 -> (b1, b2))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
mealy42 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> a1 -> a2 -> a3 -> a4 -> (b1, b2)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Fun (CT ts tm) a4 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2)
forall (e :: * -> *) a1 a2 a3 a4 a5 b1 b2.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun
     e
     a1
     (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e b1, Ret e b2)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e b1), Stream (e b2))
MoC.mealy42 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun
           (CT ts tm)
           a3
           (Fun (CT ts tm) a4 (Ret (CT ts tm) b1, Ret (CT ts tm) b2)))))
st -> a1 -> a2 -> a3 -> a4 -> (b1, b2)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy43 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
mealy43 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Fun
                 (CT ts tm)
                 a4
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
forall (e :: * -> *) a1 a2 a3 a4 a5 b1 b2 b3.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun
     e
     a1
     (Fun
        e
        a2
        (Fun e a3 (Fun e a4 (Fun e a5 (Ret e b1, Ret e b2, Ret e b3)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e b1), Stream (e b2), Stream (e b3))
MoC.mealy43 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun
           (CT ts tm)
           a3
           (Fun
              (CT ts tm)
              a4
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3)))))
st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)
mealy44 :: (st -> a1 -> a2 -> a3 -> a4 -> st)
-> (st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> (ts, tm -> st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
mealy44 ns :: st -> a1 -> a2 -> a3 -> a4 -> st
ns od :: st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)
od i :: (ts, tm -> st)
i = Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
-> Fun
     (CT ts tm)
     st
     (Fun
        (CT ts tm)
        a1
        (Fun
           (CT ts tm)
           a2
           (Fun
              (CT ts tm)
              a3
              (Fun
                 (CT ts tm)
                 a4
                 (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
                  Ret (CT ts tm) b4)))))
-> Stream (CT ts tm st)
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
forall (e :: * -> *) a1 a2 a3 a4 a5 b1 b2 b3 b4.
MoC e =>
Fun e a1 (Fun e a2 (Fun e a3 (Fun e a4 (Fun e a5 (Ret e a1)))))
-> Fun
     e
     a1
     (Fun
        e
        a2
        (Fun
           e
           a3
           (Fun e a4 (Fun e a5 (Ret e b1, Ret e b2, Ret e b3, Ret e b4)))))
-> Stream (e a1)
-> Stream (e a2)
-> Stream (e a3)
-> Stream (e a4)
-> Stream (e a5)
-> (Stream (e b1), Stream (e b2), Stream (e b3), Stream (e b4))
MoC.mealy44 Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun (CT ts tm) a3 (Fun (CT ts tm) a4 (Ret (CT ts tm) st)))))
st -> a1 -> a2 -> a3 -> a4 -> st
ns Fun
  (CT ts tm)
  st
  (Fun
     (CT ts tm)
     a1
     (Fun
        (CT ts tm)
        a2
        (Fun
           (CT ts tm)
           a3
           (Fun
              (CT ts tm)
              a4
              (Ret (CT ts tm) b1, Ret (CT ts tm) b2, Ret (CT ts tm) b3,
               Ret (CT ts tm) b4)))))
st -> a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4)
od ((ts, tm -> st) -> Stream (CT ts tm st)
forall ts tm a.
(Num ts, Num tm, Ord ts) =>
(ts, tm -> a) -> SignalBase ts tm a
unit (ts, tm -> st)
i)

------- SYNC -------

-- | @sync@ synchronizes multiple signals, so that they have the same
-- set of tags, and consequently, the same number of events. It
-- instantiates the @comb@ atom pattern (see
-- 'ForSyDe.Atom.MoC.comb22').
--
-- Constructors: @sync[1-4]@.
sync2 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
      => SignalBase ts tm a1                    -- ^ first input signal
      -> SignalBase ts tm a2                    -- ^ second input signal
      -> (SignalBase ts tm a1, SignalBase ts tm a2)       -- ^ two output signals
sync3 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
      => SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3
      -> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)             
sync4 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) 
      => SignalBase ts tm a1 -> SignalBase ts tm a2 -> SignalBase ts tm a3 -> SignalBase ts tm a4
      -> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3, SignalBase ts tm a4)

sync2 :: SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm a1, SignalBase ts tm a2)
sync2 = (a1 -> a2 -> (a1, a2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm a1, SignalBase ts tm a2)
forall ts tm a1 a2 b1 b2.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
(a1 -> a2 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
comb22 (,)
sync3 :: SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
sync3 = (a1 -> a2 -> a3 -> (a1, a2, a3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3)
forall ts tm a1 a2 a3 b1 b2 b3.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
(a1 -> a2 -> a3 -> (b1, b2, b3))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3)
comb33 (,,)
sync4 :: SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
sync4 = (a1 -> a2 -> a3 -> a4 -> (a1, a2, a3, a4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm a1, SignalBase ts tm a2, SignalBase ts tm a3,
    SignalBase ts tm a4)
forall ts tm a1 a2 a3 a4 b1 b2 b3 b4.
(Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm) =>
(a1 -> a2 -> a3 -> a4 -> (b1, b2, b3, b4))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> SignalBase ts tm a3
-> SignalBase ts tm a4
-> (SignalBase ts tm b1, SignalBase ts tm b2, SignalBase ts tm b3,
    SignalBase ts tm b4)
comb44 (,,,)