{-# LANGUAGE PostfixOperators #-}
{-# OPTIONS_HADDOCK hide #-}
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
delay :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> ts
-> (tm -> a)
-> SignalBase ts tm a
-> SignalBase ts tm a
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))
delay' :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> 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
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
comb22 :: (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)
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
reconfig22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> SignalBase ts tm (a1 -> a2 -> (b1, b2))
-> SignalBase ts tm a1
-> SignalBase ts tm a2
-> (SignalBase ts tm b1, SignalBase ts tm b2)
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
constant2 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> (b1, b2)
-> (SignalBase ts tm b1, SignalBase ts tm b2)
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)
infinite2 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> (tm -> b1, tm -> b2)
-> (SignalBase ts tm b1, SignalBase ts tm b2)
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)
generate2 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> (b1 -> b2 -> (b1, b2))
-> ((ts, tm -> b1), (ts, tm -> b2))
-> (SignalBase ts tm b1, SignalBase ts tm b2)
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)
stated22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> (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)
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)
state22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> (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)
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)
moore22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> (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)
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)
mealy22 :: (Num ts, Real ts, Ord ts, Eq ts, Num tm, Fractional tm, Ord tm)
=> (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)
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