{-# LANGUAGE PostfixOperators, TypeFamilies #-}
{-# OPTIONS_HADDOCK show-extensions, prune #-}
----------------------------------------------------------------------
-- |
-- Module      :  ForSyDe.Atom.MoC
-- Copyright   :  (c) George Ungureanu, 2015-2017
-- License     :  BSD-style (see the file LICENSE)
-- 
-- Maintainer  :  ugeorge@kth.se
-- Stability   :  experimental
-- Portability :  portable
--
-- This module defines the Model of Computation (MoC) layer, and is concerned in
-- modeling the timing aspects of CPS. Its formal foundation is the tagged signal
-- model <ForSyDe-Atom.html#lee98 [Lee98]>, and it follows it as closely as it is
-- permitted by the host language, and with the adaptations required by the atom
-- approach.
--
-- The MoC layer is defining a similar DSL as the classic
-- <https://forsyde.github.io/forsyde-shallow/ ForSyDe> modeling framework, in the
-- sense that systems are described in terms of /networks/ of /processes/ operating on
-- /signals/, and processes are only allowed to be instantiated using a finite set of
-- /process constructors/. Process constructors capture its computational semantics
-- accodrding to its respective MoC. MoCs are classes of behaviors dictating the
-- semantics of execution and concurrency in a network of processes.
-- The MoCs currently implemented in ForSyDe-Atom are shown in the
-- <#i:MoC instances section>, and they can be used in designs by
-- importing their respective modules:
--
-- * "ForSyDe.Atom.MoC.CT"
-- * "ForSyDe.Atom.MoC.DE"
-- * "ForSyDe.Atom.MoC.SY"
-- * "ForSyDe.Atom.MoC.SDF"
--
-- __The documentation in this module covers the internals of the MoC layer. While reading through is useful to understand some of the reasoning behind the modeling framework, this API is less likely to be touched by the casual user than the ones exported by each MoC above. For user-friendly modeling APIs consult the respective sub-modules.__
--
-- MoCs are determined by a a signal's tag system. Based on how their tag systems are
-- defined ForSyDe identifies MoCs as:
--
-- * /timed/ where the tag system is a totally ordered set and, depending on the
--   abstraction level, \(t\in T\) might express a notion of physical time
--   (e.g. continuous time 'ForSyDe.Atom.MoC.CT.CT', discrete event
--   'ForSyDe.Atom.MoC.DE.DE') to the notion of precedence and causality
--   (e.g. synchronous 'ForSyDe.Atom.MoC.SY.SY');
--
-- * untimed, where T is a partially ordered set and \(t\in T\) is expressed in terms
--   of constraints on the tags in signals (e.g. dataflow, synchronous data flow
--   'ForSyDe.Atom.MoC.SDF.SDF').
----------------------------------------------------------------------

module ForSyDe.Atom.MoC(
  -- * Signals

  -- | <ForSyDe-Atom.html#lee98 [Lee98]> defines signals as ordered sets of events
  -- where each event is composed of a tag \(\in T\) and a value \(\in V\), where \(T\)
  -- defines a total or partial order. In ForSyDe a signal is defined as a sequence of
  -- events that enables processes to communicate and synchronize. Sequencing might
  -- infer an implicit total order of events, but more importantly it determines an
  -- order of evaluation, which is a key piece of a simulation engine.
  --
  -- In ForSyDe, sequencing is achieved using a 'Stream' data type, similar to the one
  -- described by <ForSyDe-Atom.html#reekie95 [Reekie95]>. In ForSyDe-Atom, signals
  -- are streams that carry events, where each type of event is identified by a type
  -- constructor. Hence the pseudo-Haskell definition for a signal would look like
  -- below, where @e@ is the type of an event which encodes a tag system through its
  -- type constructor, and is member of the 'MoC' class. Since, according to
  -- <ForSyDe-Atom.html#lee98 [Lee98]>, MoCs are defined by tag systems, we can state
  -- that any specific instance of a signal is describing (i.e. is bound to) a MoC.
  --
  -- > type Signal a = exists e . MoC e => Stream (e a) 

  Stream (..),

  -- | This module re-exports all utilities on streams. These utilities are meant to
  -- be used with plotters or testbenches, but should never be used in designs under
  -- tests, as they do not carry formal semantics.

  module ForSyDe.Atom.MoC.Stream,
  
  -- * Atoms

  -- | These are primitive process constructors capturing an elementary behavior. By
  -- themselves they are seldom used as-such, but rather as specific compositions of
  -- atom patterns. For the MoC layer, atoms are defined only as type signatures, and
  -- are overloaded by each instance of the 'MoC' type class, as follows:
  
  MoC(..),

  -- * Patterns

  -- | The atom patterns of the MoC layer are the process constructors used in regular
  -- designs. Notice that these constructors themselves are "hollow" and carry no
  -- semantics unless the atoms are overloaded with a certain MoC, i.e. are applied on
  -- signals of a certain MoC. Most MoC sub-modules will provide more user-friendly
  -- versions of these patterns, thus these ones will seldomly be used as-such. We
  -- export them mainly for documentation purpose, to show that all MoCs share the
  -- same structure for their process constructors
  --
  -- __IMPORTANT!!!__ see the <ForSyDe-Atom.html#naming_conv naming convention> rules
  -- on how to interpret, use and develop your own constructors.
  --
  -- The documentation of each pattern is aided by a mathematical and a graphical
  -- notation following some conventions for brevity:
  --
  -- * \(\mathcal{S}\) is used to denote a signal type (i.e. stream of events)
  -- 
  -- * the power notation is used to denote multiple signals, curried if input
  --   \(s^m=s_1\ s_2\ ...\ s_m\); respectively tupled if output
  --   \(s^n=(s_1,s_2,...,s_n)\). Currying between outputs and inputs is implicit.
  --
  -- * for improved readability we use the tupled mathematical notation for arguments.
  --
  -- * a single line represents a signal, a double line represents multiple signals.
  
  delay, (-&>-),
  
  comb11, comb12, comb13, comb14,
  comb21, comb22, comb23, comb24,
  comb31, comb32, comb33, comb34,
  comb41, comb42, comb43, comb44,
  comb51, comb52, comb53, comb54,
  comb61, comb62, comb63, comb64,
  comb71, comb72, comb73, comb74,
  comb81, comb82, comb83, comb84,

  reconfig11, reconfig12, reconfig13, reconfig14,
  reconfig21, reconfig22, reconfig23, reconfig24,
  reconfig31, reconfig32, reconfig33, reconfig34,
  reconfig41, reconfig42, reconfig43, reconfig44,
  reconfig51, reconfig52, reconfig53, reconfig54,
  reconfig61, reconfig62, reconfig63, reconfig64,
  reconfig71, reconfig72, reconfig73, reconfig74,
  reconfig81, reconfig82, reconfig83, reconfig84,

  state11, state12, state13, state14,
  state21, state22, state23, state24,
  state31, state32, state33, state34,
  state41, state42, state43, state44,

  stated01, stated02, stated03, stated04,
  stated11, stated12, stated13, stated14,
  stated21, stated22, stated23, stated24,
  stated31, stated32, stated33, stated34,
  stated41, stated42, stated43, stated44,
  
  moore11, moore12, moore13, moore14,
  moore21, moore22, moore23, moore24,
  moore31, moore32, moore33, moore34,
  moore41, moore42, moore43, moore44,

  mealy11, mealy12, mealy13, mealy14,
  mealy21, mealy22, mealy23, mealy24,
  mealy31, mealy32, mealy33, mealy34,
  mealy41, mealy42, mealy43, mealy44,

  -- * Utilities
  
  ctxt11, ctxt21, ctxt31, ctxt41, ctxt51, ctxt61, ctxt71, ctxt81, 
  ctxt12, ctxt22, ctxt32, ctxt42, ctxt52, ctxt62, ctxt72, ctxt82, 
  ctxt13, ctxt23, ctxt33, ctxt43, ctxt53, ctxt63, ctxt73, ctxt83, 
  ctxt14, ctxt24, ctxt34, ctxt44, ctxt54, ctxt64, ctxt74, ctxt84,
  warg, wres,

  arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
  
  (-*<), (-*<<), (-*<<<), (-*<<<<), (-*<<<<<), (-*<<<<<<), (-*<<<<<<<), (-*<<<<<<<<),
  )
  where

import ForSyDe.Atom.MoC.Stream
import ForSyDe.Atom.Utility.Tuple

-------------------------------------------------------
--                       ATOMS                       --
-------------------------------------------------------

infixl 5 -.-, -*-
infixl 3 -<-, -*, -&-

-- | This is a type class defining interfaces for the MoC layer atoms. Each model of
-- computation exposes its tag system through a unique event type which is an instance
-- of this class, defining \( T \times V \).
--
-- #context# To express all possible MoCs which can be described in this layer we need
-- to capture the most general form of their atoms. Depending on the execution regime
-- of a MoC, its atoms might or might not need additional parameters to determine the
-- behavior for evaluating each argument. These additional parameters we call, in
-- loose terms, as the /execution context/.
--
-- [execution context] Additional information which, paired with a function,
--   completely determines the behavior of a MoC atom (i.e. process).
--
-- \[
-- \Gamma \vdash \alpha^m \rightarrow \beta^n \simeq \Gamma_{\alpha,1} \times \alpha_1
-- \rightarrow ... \rightarrow \Gamma_{\alpha,m} \times \alpha_m \rightarrow
-- (\Gamma_{\beta,1}\times \beta_1) \times ... \times (\Gamma_{\beta,n}\times \beta_n)
-- \]
--
-- The left-hand side expression above shows the most general notation used to
-- describe a function with /m/ inputs of (possibly different) types \(\alpha\) and
-- /n/ outputs of (possibly different) types \(\beta\) executed in context
-- \(\Gamma\). The right-hand side expression shows that in ForSyDe-Atom context is
-- associated with each and every argument in order to enable the applicative
-- mechanisms. Depending on the MoC, \(\Gamma_{\alpha,i}\) would translate to e.g.:
--
-- \[
-- \Gamma_{\alpha,i} \in \begin{cases}
--   \emptyset, & \text{for all timed MoCs (e.g. SY, DE, CT)} \\
--   \mathbb{N}, & \text{for static variants of SDF}\\
--   \mathbb{N}^n, & \text{for CSDF}\\
--   S \times \mathbb{N} \rightarrow \mathbb{N}, & \text{where } S \text{ is a state space,} \\
--     & \text{in the most general case of untimed data flow}
-- \end{cases}
-- \]
--
-- One example of execution context is the consumption and production rates for
-- synchronous data flow MoCs (e.g. 'ForSyDe.Atom.MoC.SDF.SDF'). In this case the
-- passed functions are defined over /sequences/ or /partitions/ of events,
-- i.e. groupings of events with the same partial order in relation to a process
-- firing.
--
-- Although a more elegant approach of passing execution context would be using
-- type-level arithmetics, this is a non-trivial task to implement in Haskell. This is
-- why we chose the pragmatic approach of /pairing/ a context parameter per argument,
-- similar to the formula above, where:
--
-- * any function representing a partition of \(\alpha\) is operating on a recursive
--   type, namely a list \([\alpha]\).
--
-- * to aid in pairing contexts with each argument in a function, the general purpose
--   @ctxt@ utilities are provided (see 'ctxt22').
--
-- * this artifice is masked using the generic type families 'Fun' and 'Ret'.
class (Applicative e) => MoC e where

  -- | This is a type family alias \(^1\) for a context-bound function passed as an
  -- argument to a MoC atom. It can be regarded as an enhanced @->@ type operator,
  -- specific to each MoC.
  -- 
  -- \[ \Gamma_{\alpha,i} \times \alpha_i \rightarrow \beta \]
  --
  -- /\(^1\) While hiding the explicit definition of arguments, this/ /implementation
  -- choice certainly has its advantages in avoiding/ /unnecessary or redundant type
  -- constructors (see version 0.1.1 and/ /prior). Aliases are replaced at compile
  -- time, thus not affecting/ /run-time performance./
  type Fun e a b

  -- | Like 'Fun', this alias hides a context-bound value (e.g. function return). This
  -- alias is needed for utilities to extract clean context-free types (see '-*').
  -- 
  -- \[\Gamma_{\beta,i}\times \beta \]
  type Ret e b
  
  -- | The @func@ atom is mapping a function on values (in the presence of a context)
  -- to a signal, i.e. stream of tagged events.
  --
  -- <<fig/eqs-moc-atom-dot.png>>
  (-.-) :: Fun e a b -> Stream (e a) -> Stream (e b)
  
  -- | The @sync@ atom synchronizes two signals, one carrying functions on values (in
  -- the presence of a context), and the other containing values. During the
  -- synchronization it applies the function(s) carried by the former signal on the
  -- values carried by the latter. This atom defines a /relation/ between two signals,
  -- and a process created with it is monotonous, i.e. any new event in any of the
  -- input signals triggers a reaction at the output.
  -- 
  -- <<fig/eqs-moc-atom-star.png>>
  (-*-) :: Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
  
  -- | Artificial /utility/ which drops the context and/or partitioning yielding a
  -- clean signal type.
  --
  -- <<fig/eqs-moc-atom-post.png>>
  (-*)  :: Stream (e (Ret e b)) -> Stream (e b)

  -- | The @pre@ atom prepends the prefix of the left signal operand (i.e. the first
  -- event in timed MoCs, or the first /n/ events in untimed MoCs) at the beginning of
  -- the right signal operand \(^1\). This atom is necessary to ensure /complete
  -- partial order/ of a signal and assures the /least upper bound/ necessary for
  -- example in the evaluation of feedback loops <ForSyDe-Atom.html#lee98 [Lee98]>.
  --
  -- <<fig/eqs-moc-atom-pre.png>>
  --
  -- /\(^1\) this atom acts like the @pre@ operator in the synchronous language /
  -- /Lustre and for timed MoCs it behaves the same. For untimed MoCs though, the /
  -- /length of the prefix of a signal is assumed to be the length of a signal, /
  -- /since the API does not provide any other means to pass /n/ as a parameter./
  (-<-) :: Stream (e a) -> Stream (e a) -> Stream (e a)
   
  -- | The @phi@ atom manipulates the tags in a signal in a restrictive way which
  -- preserves /monotonicity/ and /continuity/ in a process
  -- <ForSyDe-Atom.html#lee98 [Lee98]>, namely by “phase-shifting” all tags in a
  -- signal with the appropriate metric corresponding to each MoC. Thus it preserves
  -- the characteristic function intact <ForSyDe-Atom.html#sander04 [Sander04]>.
  --
  -- <<fig/eqs-moc-atom-phi.png>>
  --
  -- The metric distance used for phase shifting is inferred from the prefix of the
  -- left signal operand, while right signal operand is the one being manipulated.
  (-&-) :: Stream (e a) -> Stream (e a) -> Stream (e a)


--------------------------------------------------------
--                      PATTERNS                      --
--------------------------------------------------------

infixl 3 -&>-
-- | <<fig/eqs-moc-pattern-delay.png>>
--   <<fig/moc-pattern-delay.png>>
--
-- The 'delay' process provides both initial token(s) and shifts the
-- phase of the signal. In other words, it "delays" a signal with
-- one or several events.
delay :: Stream (e a) -> Stream (e a) -> Stream (e a)
delay i :: Stream (e a)
i xs :: Stream (e a)
xs = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-<- (Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&- Stream (e a)
xs)

-- | Infix variant for 'delay'.
i :: Stream (e a)
i -&>- :: Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- xs :: Stream (e a)
xs = Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
delay Stream (e a)
i Stream (e a)
xs          

-- | #comb22f# /(*) to be read/ @a1 -> a2 -> (b1, b2)@ /where each/
-- /argument may be <#context wrapped along with a context>./
--
-- <<fig/eqs-moc-pattern-comb.png>>
-- <<fig/moc-pattern-comb.png>>
--
-- The @comb@ processes synchronizes multiple input signals and maps
-- combinatorial functions on the values they carry.
--
-- This module exports constructors of type @comb[1-8][1-4]@.
comb22 :: (MoC e)
       => (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2)))
       -- ^ combinational function (<#comb22f *>)
       -> Stream (e a1)                  -- ^ first input signal
       -> Stream (e a2)                  -- ^ second input signal
       -> (Stream (e b1), Stream (e b2)) -- ^ two output signals
comb11 :: Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
comb11 f :: Fun e a (Ret e b)
f s1 :: Stream (e a)
s1                      = (Fun e a (Ret e b)
f Fun e a (Ret e b) -> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb21 :: Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 f :: Fun e a (Fun e a (Ret e b))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2                   = (Fun e a (Fun e a (Ret e b))
f Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb31 :: Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 f :: Fun e a (Fun e a (Fun e a (Ret e b)))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Fun e a (Fun e a (Fun e a (Ret e b)))
f Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb41 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 f :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
f Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb51 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 f :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
f Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb61 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb61 f :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
f Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb71 :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb71 f :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
f Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb81 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb81 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7 s8 :: Stream (e a)
s8 = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
comb12 :: Fun e a (Ret e b1, Ret e b2)
-> Stream (e a) -> (Stream (e b1), Stream (e b2))
comb12 f :: Fun e a (Ret e b1, Ret e b2)
f s1 :: Stream (e a)
s1                      = (Fun e a (Ret e b1, Ret e b2)
f Fun e a (Ret e b1, Ret e b2)
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb22 :: Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
-> Stream (e a1) -> Stream (e a2) -> (Stream (e b1), Stream (e b2))
comb22 f :: Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
f s1 :: Stream (e a1)
s1 s2 :: Stream (e a2)
s2                   = (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
f Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
-> Stream (e a1) -> Stream (e (Fun e a2 (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a1)
s1 Stream (e (Fun e a2 (Ret e b1, Ret e b2)))
-> Stream (e a2) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a2)
s2 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb32 :: Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb32 f :: Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))
f Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb42 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb42 f :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
f Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb52 :: Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb52 f :: Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
f Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb62 :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb62 f :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
f Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb72 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb72 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb82 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> p
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb82 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: p
s7 s8 :: Stream (e a)
s8 = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
comb13 :: Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
comb13 f :: Fun e a (Ret e b, Ret e b, Ret e b)
f s1 :: Stream (e a)
s1                      = (Fun e a (Ret e b, Ret e b, Ret e b)
f Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb23 :: Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb23 f :: Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2                   = (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
f Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb33 :: Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb33 f :: Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
f Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb43 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb43 f :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
f Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb53 :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb53 f :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
f Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb63 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb63 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb73 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb73 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb83 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> p
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb83 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: p
s7 s8 :: Stream (e a)
s8 = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
comb14 :: Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb14 f :: Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
f s1 :: Stream (e a)
s1                      = (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
f Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
comb24 :: Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb24 f :: Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2                   = (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
f Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
comb34 :: Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb34 f :: Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
f Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
comb44 :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb44 f :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
f Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
comb54 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb54 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
comb64 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb64 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
comb74 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb74 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
comb84 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb84 f :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
f s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7 s8 :: Stream (e a)
s8 = (Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
f Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e
                    a
                    (Fun
                       e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
forall (e :: * -> *) a b.
MoC e =>
Fun e a b -> Stream (e a) -> Stream (e b)
-.- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)

-- |  #reconfig22f# /(*) to be read / @a1 -> a2 -> (b1, b2)@ /where each/
-- /argument may be <#context wrapped along with a context>./
--
-- <<fig/eqs-moc-pattern-reconfig.png>>
-- <<fig/moc-pattern-reconfig.png>>
--
-- The @reconfig@ processes constructs adaptive processes, whose
-- functional behavior "changes in time". Its first input is a signal
-- carrying functions which is synchronized with all the other input
-- signals. The output signal carry the results of mapping those
-- functions at each synchronization/firing point.
--
-- This library exports constructors of type @reconfig[1-8][1-4]@.
reconfig22 :: (MoC e)
       => Stream (e (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))))
       -- ^ signal carrying functions (<#reconfig22f *>)
       -> Stream (e a1)                  -- ^ first input signal
       -> Stream (e a2)                  -- ^ second input signal
       -> (Stream (e b1), Stream (e b2)) -- ^ two output signals
reconfig11 :: Stream (e (Fun e a (Ret e b))) -> Stream (e a) -> Stream (e b)
reconfig11 sf :: Stream (e (Fun e a (Ret e b)))
sf s1 :: Stream (e a)
s1                      = (Stream (e (Fun e a (Ret e b)))
sf Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig21 :: Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
reconfig21 sf :: Stream (e (Fun e a (Fun e a (Ret e b))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2                   = (Stream (e (Fun e a (Fun e a (Ret e b))))
sf Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig31 :: Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
reconfig31 sf :: Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
sf Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig41 :: Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
reconfig41 sf :: Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
sf Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig51 :: Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
reconfig51 sf :: Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
sf Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig61 :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
reconfig61 sf :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
sf Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig71 :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
reconfig71 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig81 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
reconfig81 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7 s8 :: Stream (e a)
s8 = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a) -> Stream (e (Fun e a (Fun e a (Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b)) -> Stream (e b)
forall (e :: * -> *) b.
MoC e =>
Stream (e (Ret e b)) -> Stream (e b)
-*)
reconfig12 :: Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> (Stream (e b1), Stream (e b2))
reconfig12 sf :: Stream (e (Fun e a (Ret e b1, Ret e b2)))
sf s1 :: Stream (e a)
s1                      = (Stream (e (Fun e a (Ret e b1, Ret e b2)))
sf Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig22 :: 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))
reconfig22 sf :: Stream (e (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))))
sf s1 :: Stream (e a1)
s1 s2 :: Stream (e a2)
s2                   = (Stream (e (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))))
sf Stream (e (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))))
-> Stream (e a1) -> Stream (e (Fun e a2 (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a1)
s1 Stream (e (Fun e a2 (Ret e b1, Ret e b2)))
-> Stream (e a2) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a2)
s2 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig32 :: Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
reconfig32 sf :: Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
sf Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig42 :: Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
reconfig42 sf :: Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
sf Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig52 :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
reconfig52 sf :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
sf Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig62 :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
reconfig62 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig72 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
reconfig72 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig82 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> p
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
reconfig82 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: p
s7 s8 :: Stream (e a)
s8 = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b1, Ret e b2)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a) -> Stream (e (Ret e b1, Ret e b2))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) b1 b2.
MoC e =>
Stream (e (Ret e b1, Ret e b2)) -> (Stream (e b1), Stream (e b2))
-*<)
reconfig13 :: Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
reconfig13 sf :: Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
sf s1 :: Stream (e a)
s1                      = (Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
sf Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig23 :: Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
reconfig23 sf :: Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2                   = (Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
sf Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig33 :: Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
reconfig33 sf :: Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
sf Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig43 :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
reconfig43 sf :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
sf Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig53 :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
reconfig53 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig63 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
reconfig63 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig73 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
reconfig73 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig83 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> p
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
reconfig83 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: p
s7 s8 :: Stream (e a)
s8 = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream
  (e (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a) -> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b))
-*<<)
reconfig14 :: Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig14 sf :: Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
sf s1 :: Stream (e a)
s1                      = (Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
sf Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
reconfig24 :: Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig24 sf :: Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2                   = (Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
sf Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
reconfig34 :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig34 sf :: Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3                = (Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
sf Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
reconfig44 :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig44 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4             = (Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
reconfig54 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig54 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5          = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
reconfig64 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig64 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6       = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
reconfig74 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig74 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7    = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)
reconfig84 :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e
                    a
                    (Fun
                       e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
reconfig84 sf :: Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e
                    a
                    (Fun
                       e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))))
sf s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 s5 :: Stream (e a)
s5 s6 :: Stream (e a)
s6 s7 :: Stream (e a)
s7 s8 :: Stream (e a)
s8 = (Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e
                    a
                    (Fun
                       e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))))
sf Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e
                    a
                    (Fun
                       e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e
                    a
                    (Fun
                       e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s1 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e
                 a
                 (Fun
                    e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s2 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s3 Stream
  (e (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s4 Stream
  (e (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream
     (e (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s5 Stream
  (e (Fun
        e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream
     (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s6 Stream (e (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s7 Stream (e (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a) -> Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
forall (e :: * -> *) a b.
MoC e =>
Stream (e (Fun e a b)) -> Stream (e a) -> Stream (e b)
-*- Stream (e a)
s8 Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) b b b b.
MoC e =>
Stream (e (Ret e b, Ret e b, Ret e b, Ret e b))
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
-*<<<)

-- | #state22ns# /(*) meaning / @st1 -> st2 -> a1 -> a2 -> (st1,st2)@
-- /where each argument may be <#context wrapped along with a context>./
--
-- #state22i# /(**) inferred from the prefixes of the signals passed/
-- /as arguments. See the documentation for '-<-' for an explanation./
--
-- <<fig/eqs-moc-pattern-state.png>>
-- <<fig/moc-pattern-state.png>>
--
-- The @state@ processes generate process networks corresponding to a
-- simple state machine with "un-latched" outputs like in the graph
-- above. In other words, the process starts with a state transition
-- and outputs the next state as the first event.
--
-- This library exports constructors of type @state[1-4][1-4]@.
state22 :: MoC e
        => Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
        -- ^ next state function (<#state22ns *>)
        -> (Stream (e st1), Stream (e st2))
        -- ^ initial state(s) (<#state22i **>)
        -> Stream (e a1)
        -- ^ first input signal
        -> Stream (e a2)
        -- ^ second input signal
        -> (Stream (e st1), Stream (e st2))
        -- ^ output signals mirroring the next state(s).
state11 :: Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
state11 ns :: Fun e a (Fun e a (Ret e b))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e b))
ns Stream (e a)
st Stream (e a)
s1 
  where st :: Stream (e a)
st               = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
Fun e a (Fun e a (Ret e b))
ns Stream (e a)
st Stream (e a)
s1 
state21 :: Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
state21 ns :: Fun e a (Fun e a (Fun e a (Ret e b)))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       =        Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e b)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
  where st :: Stream (e a)
st               = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
Fun e a (Fun e a (Fun e a (Ret e b)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
state31 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
state31 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
  where st :: Stream (e a)
st               = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
state41 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
state41 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
  where st :: Stream (e a)
st               = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
state12 :: Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
-> (Stream (e a), Stream (e a))
-> Stream (e a)
-> (Stream (e a), Stream (e a))
state12 ns :: Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2) s1 :: Stream (e a)
s1          = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2) = Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
forall (e :: * -> *) a a a b1 b2.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb32 Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
s1
                                     (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2)
                                 in  (Stream (e a)
ns1,Stream (e a)
ns2)
state22 :: 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))
state22 ns :: Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
ns (i1 :: Stream (e st1)
i1,i2 :: Stream (e st2)
i2) s1 :: Stream (e a1)
s1 s2 :: Stream (e a2)
s2       = let (ns1 :: Stream (e st1)
ns1,ns2 :: Stream (e st2)
ns2) = 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))
forall (e :: * -> *) a a a a b1 b2.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb42 Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
ns Stream (e st1)
st1 Stream (e st2)
st2 Stream (e a1)
s1 Stream (e a2)
s2
                                     (st1 :: Stream (e st1)
st1,st2 :: Stream (e st2)
st2) = (Stream (e st1)
i1 Stream (e st1) -> Stream (e st1) -> Stream (e st1)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e st1)
ns1, Stream (e st2)
i2 Stream (e st2) -> Stream (e st2) -> Stream (e st2)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e st2)
ns2)
                                 in  (Stream (e st1)
ns1,Stream (e st2)
ns2)
state32 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
-> (Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
state32 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2) = Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a b1 b2.
MoC e =>
Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb52 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
                                     (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2)
                                 in  (Stream (e a)
ns1,Stream (e a)
ns2)
state42 :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
-> (Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
state42 ns :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2) = Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a b1 b2.
MoC e =>
Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb62 Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
                                     (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2)
                                 in  (Stream (e a)
ns1,Stream (e a)
ns2)
state13 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
state13 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1          = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a b b b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb43 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1
                                        (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                    in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3)
state23 :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
state23 ns :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a b b b.
MoC e =>
Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb53 Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1 Stream (e a)
s2
                                        (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                    in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3)
state33 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
state33 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb63 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
                                        (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                    in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3)
state43 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
state43 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a a b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb73 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
                                        (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                    in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3)
state14 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
state14 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1          = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb54 Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1
                                           (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                       in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3,Stream (e a)
ns4)
state24 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
state24 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb64 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1 Stream (e a)
s2
                                           (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                       in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3,Stream (e a)
ns4)
state34 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
state34 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb74 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
                                           (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                       in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3,Stream (e a)
ns4)
state44 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
state44 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb84 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
                                           (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                       in  (Stream (e a)
ns1,Stream (e a)
ns2,Stream (e a)
ns3,Stream (e a)
ns4)

-- | 
-- #stated22ns# /(*) meaning / @st1 -> st2 -> a1 -> a2 -> (st1,st2)@
-- /where each argument may be <#context wrapped along with a context>./
--
-- #stated22i# /(**) inferred from the prefixes of the signals passed/
-- /as arguments. See the documentation for '-<-' for an explanation./
--
-- <<fig/eqs-moc-pattern-stated.png>>
-- <<fig/moc-pattern-stated.png>>
-- 
-- The @stated@ processes generate process networks corresponding to a
-- simple state machine with "latched" outputs like in the graph
-- above. As compared to 'state22', this process outputs the current
-- state, and the state transition is observed from the second
-- evaluation onwards. There exists a variant with 0 input signals, in
-- which case the process is a signal generator.
--
-- This library exports constructors of type @stated[0-4][1-4]@.
stated22 :: MoC e
        => Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
        -- ^ next state function (<#stated22ns *>)
        -> (Stream (e st1), Stream (e st2))
        -- ^ initial state(s) (<#stated22i **>)
        -> Stream (e a1)
        -- ^ first input signal
        -> Stream (e a2)
        -- ^ second input signal
        -> (Stream (e st1), Stream (e st2))
        -- ^ output signals mirroring the next state(s).
stated01 :: Fun e a (Ret e a) -> Stream (e a) -> Stream (e a)
stated01 ns :: Fun e a (Ret e a)
ns i :: Stream (e a)
i             = Stream (e a)
st 
  where st :: Stream (e a)
st                = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Ret e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a b.
MoC e =>
Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
comb11 Fun e a (Ret e a)
ns Stream (e a)
st 
stated11 :: Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
stated11 ns :: Fun e a (Fun e a (Ret e a))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1          = Stream (e a)
st
  where st :: Stream (e a)
st                = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1 
stated21 :: Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
stated21 ns :: Fun e a (Fun e a (Fun e a (Ret e a)))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       = Stream (e a)
st
  where st :: Stream (e a)
st                = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
stated31 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
stated31 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    = Stream (e a)
st
  where st :: Stream (e a)
st                = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
stated41 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
stated41 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 = Stream (e a)
st
  where st :: Stream (e a)
st                = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
stated02 :: Fun e a1 (Fun e a2 (Ret e a1, Ret e a2))
-> (Stream (e a1), Stream (e a2)) -> (Stream (e a1), Stream (e a2))
stated02 ns :: Fun e a1 (Fun e a2 (Ret e a1, Ret e a2))
ns (i1 :: Stream (e a1)
i1,i2 :: Stream (e a2)
i2)             = let (ns1 :: Stream (e a1)
ns1,ns2 :: Stream (e a2)
ns2) = Fun e a1 (Fun e a2 (Ret e a1, Ret e a2))
-> Stream (e a1) -> Stream (e a2) -> (Stream (e a1), Stream (e a2))
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))
comb22 Fun e a1 (Fun e a2 (Ret e a1, Ret e a2))
ns Stream (e a1)
st1 Stream (e a2)
st2
                                      (st1 :: Stream (e a1)
st1,st2 :: Stream (e a2)
st2) = (Stream (e a1)
i1 Stream (e a1) -> Stream (e a1) -> Stream (e a1)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a1)
ns1, Stream (e a2)
i2 Stream (e a2) -> Stream (e a2) -> Stream (e a2)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a2)
ns2)
                                  in  (Stream (e a1)
st1,Stream (e a2)
st2)
stated12 :: Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
-> (Stream (e a), Stream (e a))
-> Stream (e a)
-> (Stream (e a), Stream (e a))
stated12 ns :: Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2) s1 :: Stream (e a)
s1          = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2) = Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
forall (e :: * -> *) a a a b1 b2.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb32 Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
s1
                                      (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2)
                                  in  (Stream (e a)
st1,Stream (e a)
st2)
stated22 :: 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))
stated22 ns :: Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
ns (i1 :: Stream (e st1)
i1,i2 :: Stream (e st2)
i2) s1 :: Stream (e a1)
s1 s2 :: Stream (e a2)
s2       = let (ns1 :: Stream (e st1)
ns1,ns2 :: Stream (e st2)
ns2) = 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))
forall (e :: * -> *) a a a a b1 b2.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb42 Fun e st1 (Fun e st2 (Fun e a1 (Fun e a2 (Ret e st1, Ret e st2))))
ns Stream (e st1)
st1 Stream (e st2)
st2 Stream (e a1)
s1 Stream (e a2)
s2
                                      (st1 :: Stream (e st1)
st1,st2 :: Stream (e st2)
st2) = (Stream (e st1)
i1 Stream (e st1) -> Stream (e st1) -> Stream (e st1)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e st1)
ns1, Stream (e st2)
i2 Stream (e st2) -> Stream (e st2) -> Stream (e st2)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e st2)
ns2)
                                  in  (Stream (e st1)
st1,Stream (e st2)
st2)
stated32 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
-> (Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
stated32 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2) = Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a b1 b2.
MoC e =>
Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb52 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a)))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
                                      (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2)
                                  in  (Stream (e a)
st1,Stream (e a)
st2)
stated42 :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
-> (Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
stated42 ns :: Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2) = Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a b1 b2.
MoC e =>
Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb62 Fun
  e
  a
  (Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
                                      (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2)
                                  in  (Stream (e a)
st1,Stream (e a)
st2)
stated03 :: Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))
-> (Stream (e a), Stream (e a), Stream (e a))
-> (Stream (e a), Stream (e a), Stream (e a))
stated03 ns :: Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3)             = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a b b b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb33 Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3
                                         (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                     in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3)
stated13 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
stated13 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1          = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a b b b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb43 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1
                                         (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                     in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3)
stated23 :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
stated23 ns :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a b b b.
MoC e =>
Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb53 Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1 Stream (e a)
s2
                                         (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                     in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3)
stated33 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
stated33 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb63 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
                                         (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                     in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3)
stated43 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
-> (Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
stated43 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a a b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb73 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a)))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
                                         (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3)
                                     in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3)
stated04 :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
stated04 ns :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4)             = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb44 Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4
                                            (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                        in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3,Stream (e a)
st4)
stated14 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
stated14 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1          = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb54 Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1
                                            (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                        in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3,Stream (e a)
st4)
stated24 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
stated24 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb64 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1 Stream (e a)
s2
                                            (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                        in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3,Stream (e a)
st4)
stated34 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
stated34 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb74 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a)))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
                                            (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                        in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3,Stream (e a)
st4)
stated44 :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
stated44 ns :: Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
ns (i1 :: Stream (e a)
i1,i2 :: Stream (e a)
i2,i3 :: Stream (e a)
i3,i4 :: Stream (e a)
i4) s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 = let (ns1 :: Stream (e a)
ns1,ns2 :: Stream (e a)
ns2,ns3 :: Stream (e a)
ns3,ns4 :: Stream (e a)
ns4) = Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e a), Stream (e a), Stream (e a), Stream (e a))
forall (e :: * -> *) a a a a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb84 Fun
  e
  a
  (Fun
     e
     a
     (Fun
        e
        a
        (Fun
           e
           a
           (Fun
              e
              a
              (Fun
                 e a (Fun e a (Fun e a (Ret e a, Ret e a, Ret e a, Ret e a))))))))
ns Stream (e a)
st1 Stream (e a)
st2 Stream (e a)
st3 Stream (e a)
st4 Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
                                            (st1 :: Stream (e a)
st1,st2 :: Stream (e a)
st2,st3 :: Stream (e a)
st3,st4 :: Stream (e a)
st4) = (Stream (e a)
i1 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns1, Stream (e a)
i2 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns2, Stream (e a)
i3 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns3, Stream (e a)
i4 Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Stream (e a)
ns4)
                                        in  (Stream (e a)
st1,Stream (e a)
st2,Stream (e a)
st3,Stream (e a)
st4)
                                            
-- | #moore22ns# /(*) meaning / @st -> a1 -> a2 -> st @ /where each/
-- /argument may be <#context wrapped along with a context>./
--
-- #moore22od# /(**) meaning / @st -> (b1, b2) @ /where each argument/
-- /may be <#context wrapped along with a context>./
--
-- #moore22i# /(***) inferred from the prefixes of the signals passed/
-- /as arguments. See the documentation for '-<-' for an explanation./
--
-- <<fig/eqs-moc-pattern-moore.png>>
-- <<fig/moc-pattern-moore.png>>
--
-- The @moore@ processes model Moore state machines.
--  
-- This library exports constructors of type @moore[1-4][1-4]@.
moore22 :: MoC e
        => Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
        -- ^ next state function (<#moore22ns *>)
        -> Fun e st (Ret e b1, Ret e b2)
        -- ^ output decoder (<#moore22od **>)
        -> Stream (e st)
        -- ^ initial state (<#moore22i ***>)
        -> Stream (e a1)
        -- ^ first input signal
        -> Stream (e a2)
        -- ^ second input signal
        -> (Stream (e b1), Stream (e b2))
        -- ^ output signals
moore11 :: Fun e a (Fun e a (Ret e a))
-> Fun e a (Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
moore11 ns :: Fun e a (Fun e a (Ret e a))
ns od :: Fun e a (Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a b.
MoC e =>
Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
comb11 Fun e a (Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1
moore12 :: Fun e a (Fun e a (Ret e a))
-> Fun e a (Ret e b1, Ret e b2)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
moore12 ns :: Fun e a (Fun e a (Ret e a))
ns od :: Fun e a (Ret e b1, Ret e b2)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Ret e b1, Ret e b2)
-> Stream (e a) -> (Stream (e b1), Stream (e 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))
comb12 Fun e a (Ret e b1, Ret e b2)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1
moore13 :: Fun e a (Fun e a (Ret e a))
-> Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
moore13 ns :: Fun e a (Fun e a (Ret e a))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
comb13 Fun e a (Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1
moore14 :: Fun e a (Fun e a (Ret e a))
-> Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
moore14 ns :: Fun e a (Fun e a (Ret e a))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb14 Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1
moore21 :: Fun e a (Fun e a (Fun e a (Ret e a)))
-> Fun e a (Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
moore21 ns :: Fun e a (Fun e a (Fun e a (Ret e a)))
ns od :: Fun e a (Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       =        Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a b.
MoC e =>
Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
comb11 Fun e a (Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
moore22 :: 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))
moore22 ns :: Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
ns od :: Fun e st (Ret e b1, Ret e b2)
od i :: Stream (e st)
i s1 :: Stream (e a1)
s1 s2 :: Stream (e a2)
s2       =        Fun e st (Ret e b1, Ret e b2)
-> Stream (e st) -> (Stream (e b1), Stream (e 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))
comb12 Fun e st (Ret e b1, Ret e b2)
od Stream (e st)
st
  where st :: Stream (e st)
st                  = Stream (e st)
i Stream (e st) -> Stream (e st) -> Stream (e st)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
-> Stream (e st) -> Stream (e a1) -> Stream (e a2) -> Stream (e st)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
ns Stream (e st)
st Stream (e a1)
s1 Stream (e a2)
s2
moore23 :: Fun e a (Fun e a (Fun e a (Ret e a)))
-> Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
moore23 ns :: Fun e a (Fun e a (Fun e a (Ret e a)))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       =        Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
comb13 Fun e a (Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
moore24 :: Fun e a (Fun e a (Fun e a (Ret e a)))
-> Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
moore24 ns :: Fun e a (Fun e a (Fun e a (Ret e a)))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       =        Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb14 Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
moore31 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun e a (Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
moore31 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun e a (Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a b.
MoC e =>
Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
comb11 Fun e a (Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
moore32 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun e a (Ret e b1, Ret e b2)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
moore32 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun e a (Ret e b1, Ret e b2)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Ret e b1, Ret e b2)
-> Stream (e a) -> (Stream (e b1), Stream (e 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))
comb12 Fun e a (Ret e b1, Ret e b2)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
moore33 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
moore33 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
comb13 Fun e a (Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
moore34 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
moore34 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb14 Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
moore41 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun e a (Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
moore41 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun e a (Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a b.
MoC e =>
Fun e a (Ret e b) -> Stream (e a) -> Stream (e b)
comb11 Fun e a (Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
moore42 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun e a (Ret e b1, Ret e b2)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
moore42 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun e a (Ret e b1, Ret e b2)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun e a (Ret e b1, Ret e b2)
-> Stream (e a) -> (Stream (e b1), Stream (e 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))
comb12 Fun e a (Ret e b1, Ret e b2)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
moore43 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
moore43 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b)
-> Stream (e a) -> (Stream (e b), Stream (e b), Stream (e b))
comb13 Fun e a (Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
moore44 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
moore44 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a b b b b.
MoC e =>
Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb14 Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)
od Stream (e a)
st
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4

-- | #mealy22ns# /(*) meaning / @st -> a1 -> a2 -> st @ /where each/
-- /argument may be <#context wrapped along with a context>./
--
-- #mealy22od# /(**) meaning / @st -> a1 -> a2 -> (b1, b2) @ /where/
-- /each argument may be <#context wrapped along with a context>./
--
-- #mealy22i# /(***) inferred from the prefixes of the signals passed/
-- /as arguments. See the documentation for '-<-' for an explanation./
--
-- <<fig/eqs-moc-pattern-mealy.png>>
-- <<fig/moc-pattern-mealy.png>>
--
-- The @mealy@ processes model Mealy state machines.
--  
-- This library exports constructors of type @mealy[1-4][1-4]@.
mealy22 :: MoC e
        => Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
        -- ^ next state function (<#mealy22ns *>)
        -> Fun e st (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2)))
        -- ^ output decoder (<#mealy22od **>)
        -> Stream (e st)
        -- ^ initial state (<#mealy22i ***>)
        -> Stream (e a1)
        -- ^ first input signal
        -> Stream (e a2)
        -- ^ second input signal
        -> (Stream (e b1), Stream (e b2))
        -- ^ output signals
mealy11 :: Fun e a (Fun e a (Ret e a))
-> Fun e a (Fun e a (Ret e b))
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
mealy11 ns :: Fun e a (Fun e a (Ret e a))
ns od :: Fun e a (Fun e a (Ret e b))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e b))
od Stream (e a)
st Stream (e a)
s1
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1
mealy12 :: 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))
mealy12 ns :: Fun e a1 (Fun e a2 (Ret e a1))
ns od :: Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
od i :: Stream (e a1)
i s1 :: Stream (e a2)
s1          =        Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
-> Stream (e a1) -> Stream (e a2) -> (Stream (e b1), Stream (e 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))
comb22 Fun e a1 (Fun e a2 (Ret e b1, Ret e b2))
od Stream (e a1)
st Stream (e a2)
s1
  where st :: Stream (e a1)
st                  = Stream (e a1)
i Stream (e a1) -> Stream (e a1) -> Stream (e a1)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a1 (Fun e a2 (Ret e a1))
-> Stream (e a1) -> Stream (e a2) -> Stream (e a1)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a1 (Fun e a2 (Ret e a1))
ns Stream (e a1)
st Stream (e a2)
s1
mealy13 :: Fun e a (Fun e a (Ret e a))
-> Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
mealy13 ns :: Fun e a (Fun e a (Ret e a))
ns od :: Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a b b b.
MoC e =>
Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb23 Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))
od Stream (e a)
st Stream (e a)
s1
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1
mealy14 :: Fun e a (Fun e a (Ret e a))
-> Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
mealy14 ns :: Fun e a (Fun e a (Ret e a))
ns od :: Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1          =        Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a b b b b.
MoC e =>
Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb24 Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))
od Stream (e a)
st Stream (e a)
s1
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Ret e a))
-> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a b.
MoC e =>
Fun e a (Fun e a (Ret e b))
-> Stream (e a) -> Stream (e a) -> Stream (e b)
comb21 Fun e a (Fun e a (Ret e a))
ns Stream (e a)
st Stream (e a)
s1
mealy21 :: Fun e a (Fun e a (Fun e a (Ret e a)))
-> Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
mealy21 ns :: Fun e a (Fun e a (Fun e a (Ret e a)))
ns od :: Fun e a (Fun e a (Fun e a (Ret e b)))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       =        Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e b)))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
mealy22 :: Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
-> Fun e st (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2)))
-> Stream (e st)
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2))
mealy22 ns :: Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
ns od :: Fun e st (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2)))
od i :: Stream (e st)
i s1 :: Stream (e a1)
s1 s2 :: Stream (e a2)
s2       =        Fun e st (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2)))
-> Stream (e st)
-> Stream (e a1)
-> Stream (e a2)
-> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) a a a b1 b2.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb32 Fun e st (Fun e a1 (Fun e a2 (Ret e b1, Ret e b2)))
od Stream (e st)
st Stream (e a1)
s1 Stream (e a2)
s2
  where st :: Stream (e st)
st                  = Stream (e st)
i Stream (e st) -> Stream (e st) -> Stream (e st)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
-> Stream (e st) -> Stream (e a1) -> Stream (e a2) -> Stream (e st)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e st (Fun e a1 (Fun e a2 (Ret e st)))
ns Stream (e st)
st Stream (e a1)
s1 Stream (e a2)
s2
mealy23 :: Fun e a (Fun e a (Fun e a (Ret e a)))
-> Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
mealy23 ns :: Fun e a (Fun e a (Fun e a (Ret e a)))
ns od :: Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       =        Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a a b b b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb33 Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
mealy24 :: Fun e a (Fun e a (Fun e a (Ret e a)))
-> Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
mealy24 ns :: Fun e a (Fun e a (Fun e a (Ret e a)))
ns od :: Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2       =        Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a a b b b b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb34 Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Ret e a)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Ret e b)))
-> Stream (e a) -> Stream (e a) -> Stream (e a) -> Stream (e b)
comb31 Fun e a (Fun e a (Fun e a (Ret e a)))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2
mealy31 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
mealy31 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
mealy32 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
mealy32 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) a a a a b1 b2.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb42 Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
mealy33 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun
     e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
mealy33 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a a a b b b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb43 Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
mealy34 :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
mealy34 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns od :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3    =        Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb44 Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Ret e b))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb41 Fun e a (Fun e a (Fun e a (Fun e a (Ret e a))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3
mealy41 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
mealy41 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
mealy42 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun
     e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
mealy42 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
forall (e :: * -> *) a a a a a b1 b2.
MoC e =>
Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b1), Stream (e b2))
comb52 Fun
  e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b1, Ret e b2)))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
mealy43 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
mealy43 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a a a a b b b.
MoC e =>
Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b))
comb53 Fun
  e
  a
  (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b)))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
mealy44 :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Fun
     e
     a
     (Fun
        e
        a
        (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
mealy44 ns :: Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns od :: Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
od i :: Stream (e a)
i s1 :: Stream (e a)
s1 s2 :: Stream (e a)
s2 s3 :: Stream (e a)
s3 s4 :: Stream (e a)
s4 =        Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
forall (e :: * -> *) a a a a a b b b b.
MoC e =>
Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> (Stream (e b), Stream (e b), Stream (e b), Stream (e b))
comb54 Fun
  e
  a
  (Fun
     e
     a
     (Fun e a (Fun e a (Fun e a (Ret e b, Ret e b, Ret e b, Ret e b)))))
od Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4
  where st :: Stream (e a)
st                  = Stream (e a)
i Stream (e a) -> Stream (e a) -> Stream (e a)
forall (e :: * -> *) a.
MoC e =>
Stream (e a) -> Stream (e a) -> Stream (e a)
-&>- Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
forall (e :: * -> *) a a a a a b.
MoC e =>
Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e b)))))
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e a)
-> Stream (e b)
comb51 Fun e a (Fun e a (Fun e a (Fun e a (Fun e a (Ret e a)))))
ns Stream (e a)
st Stream (e a)
s1 Stream (e a)
s2 Stream (e a)
s3 Stream (e a)
s4


---------------------------------------------------------
--                      UTILITIES                      --
---------------------------------------------------------

-- Attaches a context parameter to a function argument (e.g
-- consumption rates in SDF). Used as kernel function in defining
-- e.g. 'ctxt22'.
warg :: c -> (a -> b) -> (c, a -> b)
warg :: c -> (a -> b) -> (c, a -> b)
warg c :: c
c f :: a -> b
f = (c
c, \x :: a
x -> a -> b
f a
x)

-- Attaches a context parameter to a function's result (e.g
-- production rates in SDF). Used as kernel function in defining
-- e.g. 'ctxt22'.
wres :: p -> b -> (p, b)
wres :: p -> b -> (p, b)
wres p :: p
p x :: b
x = (p
p, b
x)

-- | \[
-- \mathtt{ctxt} (\Gamma_{\alpha}, \Gamma_{\beta}, \alpha^m \rightarrow \beta^n) = \Gamma \vdash \alpha^m \rightarrow \beta^n 
-- \]
--
-- Wraps a function with the <#context context> needed by some MoCs for their
-- constructors (e.g. rates in SDF).
--
-- This library exports wrappers of type @ctxt[1-8][1-4]@.
ctxt22 :: (ctxa, ctxa)  -- ^ argument contexts (e.g. consumption rates in SDF)
       -> (ctxb, ctxb)  -- ^ result contexts (e.g. production rates in SDF)
       -> (a1 -> a2 -> (b1, b2))
          -- ^ function on values/partitions of values
       -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
          -- ^ context-wrapped form of the previous function

ctxt11 :: c -> p -> (a -> b) -> (c, a -> (p, b))
ctxt11 (c
c1)                      p :: p
p f :: a -> b
f = c -> (a -> (p, b)) -> (c, a -> (p, b))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (p, b)) -> (c, a -> (p, b)))
-> (a -> (p, b)) -> (c, a -> (p, b))
forall a b. (a -> b) -> a -> b
$ p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p (b -> (p, b)) -> (a -> b) -> a -> (p, b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f
ctxt21 :: (c, c) -> p -> (a -> a -> b) -> (c, a -> (c, a -> (p, b)))
ctxt21 (c1 :: c
c1,c2 :: c
c2)                   p :: p
p f :: a -> a -> b
f = c -> (a -> (c, a -> (p, b))) -> (c, a -> (c, a -> (p, b)))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (p, b))) -> (c, a -> (c, a -> (p, b))))
-> (a -> (c, a -> (p, b))) -> (c, a -> (c, a -> (p, b)))
forall a b. (a -> b) -> a -> b
$ c -> p -> (a -> b) -> (c, a -> (p, b))
forall c p a b. c -> p -> (a -> b) -> (c, a -> (p, b))
ctxt11  c
c2 p
p ((a -> b) -> (c, a -> (p, b)))
-> (a -> a -> b) -> a -> (c, a -> (p, b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> b
f
ctxt31 :: (c, c, c)
-> p -> (a -> a -> a -> b) -> (c, a -> (c, a -> (c, a -> (p, b))))
ctxt31 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3)                p :: p
p f :: a -> a -> a -> b
f = c
-> (a -> (c, a -> (c, a -> (p, b))))
-> (c, a -> (c, a -> (c, a -> (p, b))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (c, a -> (p, b))))
 -> (c, a -> (c, a -> (c, a -> (p, b)))))
-> (a -> (c, a -> (c, a -> (p, b))))
-> (c, a -> (c, a -> (c, a -> (p, b))))
forall a b. (a -> b) -> a -> b
$ (c, c) -> p -> (a -> a -> b) -> (c, a -> (c, a -> (p, b)))
forall c c p a a b.
(c, c) -> p -> (a -> a -> b) -> (c, a -> (c, a -> (p, b)))
ctxt21 (c
c2,c
c3) p
p ((a -> a -> b) -> (c, a -> (c, a -> (p, b))))
-> (a -> a -> a -> b) -> a -> (c, a -> (c, a -> (p, b)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> b
f
ctxt41 :: (c, c, c, c)
-> p
-> (a -> a -> a -> a -> b)
-> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))
ctxt41 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4)             p :: p
p f :: a -> a -> a -> a -> b
f = c
-> (a -> (c, a -> (c, a -> (c, a -> (p, b)))))
-> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (c, a -> (c, a -> (p, b)))))
 -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
-> (a -> (c, a -> (c, a -> (c, a -> (p, b)))))
-> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))
forall a b. (a -> b) -> a -> b
$ (c, c, c)
-> p -> (a -> a -> a -> b) -> (c, a -> (c, a -> (c, a -> (p, b))))
forall c c c p a a a b.
(c, c, c)
-> p -> (a -> a -> a -> b) -> (c, a -> (c, a -> (c, a -> (p, b))))
ctxt31 (c
c2,c
c3,c
c4) p
p ((a -> a -> a -> b) -> (c, a -> (c, a -> (c, a -> (p, b)))))
-> (a -> a -> a -> a -> b)
-> a
-> (c, a -> (c, a -> (c, a -> (p, b))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> b
f
ctxt51 :: (c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> b)
-> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
ctxt51 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5)          p :: p
p f :: a -> a -> a -> a -> a -> b
f = c
-> (a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
-> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
 -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
-> (a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
-> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c)
-> p
-> (a -> a -> a -> a -> b)
-> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))
forall c c c c p a a a a b.
(c, c, c, c)
-> p
-> (a -> a -> a -> a -> b)
-> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))
ctxt41 (c
c2,c
c3,c
c4,c
c5) p
p ((a -> a -> a -> a -> b)
 -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
-> (a -> a -> a -> a -> a -> b)
-> a
-> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> b
f
ctxt61 :: (c, c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> a -> b)
-> (c,
    a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
ctxt61 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: c
c6)       p :: p
p f :: a -> a -> a -> a -> a -> a -> b
f = c
-> (a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
-> (c,
    a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
 -> (c,
     a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
-> (a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
-> (c,
    a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> b)
-> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
forall c c c c c p a a a a a b.
(c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> b)
-> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
ctxt51 (c
c2,c
c3,c
c4,c
c5,c
c6) p
p ((a -> a -> a -> a -> a -> b)
 -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
-> (a -> a -> a -> a -> a -> a -> b)
-> a
-> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a -> b
f
ctxt71 :: (c, c, c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> a -> a -> b)
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
ctxt71 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: c
c6,c7 :: c
c7)    p :: p
p f :: a -> a -> a -> a -> a -> a -> a -> b
f = c
-> (a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
 -> (c,
     a
     -> (c,
         a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
-> (a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> a -> b)
-> (c,
    a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
forall c c c c c c p a a a a a a b.
(c, c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> a -> b)
-> (c,
    a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
ctxt61 (c
c2,c
c3,c
c4,c
c5,c
c6,c
c7) p
p ((a -> a -> a -> a -> a -> a -> b)
 -> (c,
     a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
-> (a -> a -> a -> a -> a -> a -> a -> b)
-> a
-> (c,
    a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a -> a -> b
f
ctxt81 :: (c, c, c, c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> a -> a -> a -> b)
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
ctxt81 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: c
c6,c7 :: c
c7,c8 :: c
c8) p :: p
p f :: a -> a -> a -> a -> a -> a -> a -> a -> b
f = c
-> (a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c,
          a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))))
-> (a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> a -> a -> b)
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
forall c c c c c c c p a a a a a a a b.
(c, c, c, c, c, c, c)
-> p
-> (a -> a -> a -> a -> a -> a -> a -> b)
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
ctxt71 (c
c2,c
c3,c
c4,c
c5,c
c6,c
c7,c
c8) p
p ((a -> a -> a -> a -> a -> a -> a -> b)
 -> (c,
     a
     -> (c,
         a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b)))))))))
-> (a -> a -> a -> a -> a -> a -> a -> a -> b)
-> a
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> (c, a -> (c, a -> (p, b))))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a -> a -> a -> b
f

ctxt12 :: c -> (p, p) -> (a -> (b, b)) -> (c, a -> ((p, b), (p, b)))
ctxt12 (c
c1)                 (p1 :: p
p1,p2 :: p
p2) f :: a -> (b, b)
f = c -> (a -> ((p, b), (p, b))) -> (c, a -> ((p, b), (p, b)))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> ((p, b), (p, b))) -> (c, a -> ((p, b), (p, b))))
-> (a -> ((p, b), (p, b))) -> (c, a -> ((p, b), (p, b)))
forall a b. (a -> b) -> a -> b
$ (b -> (p, b), b -> (p, b)) -> (b, b) -> ((p, b), (p, b))
forall a1 b1 a2 b2. (a1 -> b1, a2 -> b2) -> (a1, a2) -> (b1, b2)
($$) (p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p1, p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p2) ((b, b) -> ((p, b), (p, b)))
-> (a -> (b, b)) -> a -> ((p, b), (p, b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, b)
f
ctxt22 :: (ctxa, ctxa)
-> (ctxb, ctxb)
-> (a1 -> a2 -> (b1, b2))
-> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
ctxt22 (c1 :: ctxa
c1,c2 :: ctxa
c2)                   ps :: (ctxb, ctxb)
ps f :: a1 -> a2 -> (b1, b2)
f = ctxa
-> (a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
-> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg ctxa
c1 ((a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
 -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
-> (a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
-> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
forall a b. (a -> b) -> a -> b
$ ctxa
-> (ctxb, ctxb)
-> (a2 -> (b1, b2))
-> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))
forall c p p a b b.
c -> (p, p) -> (a -> (b, b)) -> (c, a -> ((p, b), (p, b)))
ctxt12  ctxa
c2 (ctxb, ctxb)
ps ((a2 -> (b1, b2)) -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
-> (a1 -> a2 -> (b1, b2))
-> a1
-> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a1 -> a2 -> (b1, b2)
f
ctxt32 :: (c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a1 -> a2 -> (b1, b2))
-> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
ctxt32 (c1 :: c
c1,c2 :: ctxa
c2,c3 :: ctxa
c3)                ps :: (ctxb, ctxb)
ps f :: a -> a1 -> a2 -> (b1, b2)
f = c
-> (a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
-> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
 -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
-> (a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
-> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
forall a b. (a -> b) -> a -> b
$ (ctxa, ctxa)
-> (ctxb, ctxb)
-> (a1 -> a2 -> (b1, b2))
-> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
forall ctxa ctxb a1 a2 b1 b2.
(ctxa, ctxa)
-> (ctxb, ctxb)
-> (a1 -> a2 -> (b1, b2))
-> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
ctxt22 (ctxa
c2,ctxa
c3) (ctxb, ctxb)
ps ((a1 -> a2 -> (b1, b2))
 -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
-> (a -> a1 -> a2 -> (b1, b2))
-> a
-> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a1 -> a2 -> (b1, b2)
f
ctxt42 :: (c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
ctxt42 (c1 :: c
c1,c2 :: c
c2,c3 :: ctxa
c3,c4 :: ctxa
c4)             ps :: (ctxb, ctxb)
ps f :: a -> a -> a1 -> a2 -> (b1, b2)
f = c
-> (a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
-> (c,
    a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
 -> (c,
     a
     -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
-> (a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
-> (c,
    a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
forall a b. (a -> b) -> a -> b
$ (c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a1 -> a2 -> (b1, b2))
-> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
forall c ctxa ctxb a a1 a2 b1 b2.
(c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a1 -> a2 -> (b1, b2))
-> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
ctxt32 (c
c2,ctxa
c3,ctxa
c4) (ctxb, ctxb)
ps ((a -> a1 -> a2 -> (b1, b2))
 -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
-> (a -> a -> a1 -> a2 -> (b1, b2))
-> a
-> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a1 -> a2 -> (b1, b2)
f
ctxt52 :: (c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
ctxt52 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: ctxa
c4,c5 :: ctxa
c5)          ps :: (ctxb, ctxb)
ps f :: a -> a -> a -> a1 -> a2 -> (b1, b2)
f = c
-> (a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
-> (c,
    a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
-> (a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
-> (c,
    a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
forall a b. (a -> b) -> a -> b
$ (c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
forall c c ctxa ctxb a a a1 a2 b1 b2.
(c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
ctxt42 (c
c2,c
c3,ctxa
c4,ctxa
c5) (ctxb, ctxb)
ps ((a -> a -> a1 -> a2 -> (b1, b2))
 -> (c,
     a
     -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
-> (a -> a -> a -> a1 -> a2 -> (b1, b2))
-> a
-> (c,
    a
    -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a1 -> a2 -> (b1, b2)
f
ctxt62 :: (c, c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
ctxt62 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: ctxa
c5,c6 :: ctxa
c6)       ps :: (ctxb, ctxb)
ps f :: a -> a -> a -> a -> a1 -> a2 -> (b1, b2)
f = c
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c,
          a
          -> (c,
              a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
forall c c c ctxa ctxb a a a a1 a2 b1 b2.
(c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
ctxt52 (c
c2,c
c3,c
c4,ctxa
c5,ctxa
c6) (ctxb, ctxb)
ps ((a -> a -> a -> a1 -> a2 -> (b1, b2))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
-> (a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> a
-> (c,
    a
    -> (c,
        a
        -> (c, a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a1 -> a2 -> (b1, b2)
f
ctxt72 :: (c, c, c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
ctxt72 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: ctxa
c6,c7 :: ctxa
c7)    ps :: (ctxb, ctxb)
ps f :: a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2)
f = c
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c,
          a
          -> (c,
              a
              -> (c,
                  a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a
                 -> (c,
                     a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
forall c c c c ctxa ctxb a a a a a1 a2 b1 b2.
(c, c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
ctxt62 (c
c2,c
c3,c
c4,c
c5,ctxa
c6,ctxa
c7) (ctxb, ctxb)
ps ((a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
-> (a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> a
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2)
f
ctxt82 :: (c, c, c, c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a
                    -> (c,
                        a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
ctxt82 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: c
c6,c7 :: ctxa
c7,c8 :: ctxa
c8) ps :: (ctxb, ctxb)
ps f :: a -> a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2)
f = c
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a
                    -> (c,
                        a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a
                    -> (c,
                        a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c,
          a
          -> (c,
              a
              -> (c,
                  a
                  -> (c,
                      a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a
                 -> (c,
                     a
                     -> (c,
                         a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))))
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a
                    -> (c,
                        a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a
                    -> (c,
                        a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
forall c c c c c ctxa ctxb a a a a a a1 a2 b1 b2.
(c, c, c, c, c, ctxa, ctxa)
-> (ctxb, ctxb)
-> (a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
ctxt72 (c
c2,c
c3,c
c4,c
c5,c
c6,ctxa
c7,ctxa
c8) (ctxb, ctxb)
ps ((a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a
                 -> (c,
                     a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2))))))))))
-> (a -> a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2))
-> a
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (ctxa, a1 -> (ctxa, a2 -> ((ctxb, b1), (ctxb, b2)))))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a -> a1 -> a2 -> (b1, b2)
f

ctxt13 :: c
-> (p, p, p)
-> (a -> (b, b, b))
-> (c, a -> ((p, b), (p, b), (p, b)))
ctxt13 (c
c1)              (p1 :: p
p1,p2 :: p
p2,p3 :: p
p3) f :: a -> (b, b, b)
f = c
-> (a -> ((p, b), (p, b), (p, b)))
-> (c, a -> ((p, b), (p, b), (p, b)))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> ((p, b), (p, b), (p, b)))
 -> (c, a -> ((p, b), (p, b), (p, b))))
-> (a -> ((p, b), (p, b), (p, b)))
-> (c, a -> ((p, b), (p, b), (p, b)))
forall a b. (a -> b) -> a -> b
$ (b -> (p, b), b -> (p, b), b -> (p, b))
-> (b, b, b) -> ((p, b), (p, b), (p, b))
forall t1 a t2 b t3 c.
(t1 -> a, t2 -> b, t3 -> c) -> (t1, t2, t3) -> (a, b, c)
($$$) (p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p1, p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p2, p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p3) ((b, b, b) -> ((p, b), (p, b), (p, b)))
-> (a -> (b, b, b)) -> a -> ((p, b), (p, b), (p, b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, b, b)
f
ctxt23 :: (c, c)
-> (p, p, p)
-> (a -> a -> (b, b, b))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))
ctxt23 (c1 :: c
c1,c2 :: c
c2)                   ps :: (p, p, p)
ps f :: a -> a -> (b, b, b)
f = c
-> (a -> (c, a -> ((p, b), (p, b), (p, b))))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> ((p, b), (p, b), (p, b))))
 -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
-> (a -> (c, a -> ((p, b), (p, b), (p, b))))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))
forall a b. (a -> b) -> a -> b
$ c
-> (p, p, p)
-> (a -> (b, b, b))
-> (c, a -> ((p, b), (p, b), (p, b)))
forall c p p p a b b b.
c
-> (p, p, p)
-> (a -> (b, b, b))
-> (c, a -> ((p, b), (p, b), (p, b)))
ctxt13  c
c2 (p, p, p)
ps ((a -> (b, b, b)) -> (c, a -> ((p, b), (p, b), (p, b))))
-> (a -> a -> (b, b, b)) -> a -> (c, a -> ((p, b), (p, b), (p, b)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> (b, b, b)
f
ctxt33 :: (c, c, c)
-> (p, p, p)
-> (a -> a -> a -> (b, b, b))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
ctxt33 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3)                ps :: (p, p, p)
ps f :: a -> a -> a -> (b, b, b)
f = c
-> (a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
 -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
-> (a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
forall a b. (a -> b) -> a -> b
$ (c, c)
-> (p, p, p)
-> (a -> a -> (b, b, b))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))
forall c c p p p a a b b b.
(c, c)
-> (p, p, p)
-> (a -> a -> (b, b, b))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))
ctxt23 (c
c2,c
c3) (p, p, p)
ps ((a -> a -> (b, b, b))
 -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
-> (a -> a -> a -> (b, b, b))
-> a
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> (b, b, b)
f
ctxt43 :: (c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> (b, b, b))
-> (c, a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
ctxt43 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4)             ps :: (p, p, p)
ps f :: a -> a -> a -> a -> (b, b, b)
f = c
-> (a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
-> (c, a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
 -> (c,
     a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
-> (a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
-> (c, a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c)
-> (p, p, p)
-> (a -> a -> a -> (b, b, b))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
forall c c c p p p a a a b b b.
(c, c, c)
-> (p, p, p)
-> (a -> a -> a -> (b, b, b))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
ctxt33 (c
c2,c
c3,c
c4) (p, p, p)
ps ((a -> a -> a -> (b, b, b))
 -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
-> (a -> a -> a -> a -> (b, b, b))
-> a
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> (b, b, b)
f
ctxt53 :: (c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
ctxt53 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5)          ps :: (p, p, p)
ps f :: a -> a -> a -> a -> a -> (b, b, b)
f = c
-> (a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
 -> (c,
     a
     -> (c,
         a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
-> (a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> (b, b, b))
-> (c, a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
forall c c c c p p p a a a a b b b.
(c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> (b, b, b))
-> (c, a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
ctxt43 (c
c2,c
c3,c
c4,c
c5) (p, p, p)
ps ((a -> a -> a -> a -> (b, b, b))
 -> (c,
     a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
-> (a -> a -> a -> a -> a -> (b, b, b))
-> a
-> (c, a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> (b, b, b)
f
ctxt63 :: (c, c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
ctxt63 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: c
c6)       ps :: (p, p, p)
ps f :: a -> a -> a -> a -> a -> a -> (b, b, b)
f = c
-> (a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c,
          a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
-> (a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
forall c c c c c p p p a a a a a b b b.
(c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
ctxt53 (c
c2,c
c3,c
c4,c
c5,c
c6) (p, p, p)
ps ((a -> a -> a -> a -> a -> (b, b, b))
 -> (c,
     a
     -> (c,
         a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
-> (a -> a -> a -> a -> a -> a -> (b, b, b))
-> a
-> (c,
    a
    -> (c,
        a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a -> (b, b, b)
f
ctxt73 :: (c, c, c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
ctxt73 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: c
c6,c7 :: c
c7)    ps :: (p, p, p)
ps f :: a -> a -> a -> a -> a -> a -> a -> (b, b, b)
f = c
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c,
          a
          -> (c,
              a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
forall c c c c c c p p p a a a a a a b b b.
(c, c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
ctxt63 (c
c2,c
c3,c
c4,c
c5,c
c6,c
c7) (p, p, p)
ps ((a -> a -> a -> a -> a -> a -> (b, b, b))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
-> (a -> a -> a -> a -> a -> a -> a -> (b, b, b))
-> a
-> (c,
    a
    -> (c,
        a
        -> (c,
            a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a -> a -> (b, b, b)
f
ctxt83 :: (c, c, c, c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
ctxt83 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3,c4 :: c
c4,c5 :: c
c5,c6 :: c
c6,c7 :: c
c7,c8 :: c
c8) ps :: (p, p, p)
ps f :: a -> a -> a -> a -> a -> a -> a -> a -> (b, b, b)
f = c
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a
  -> (c,
      a
      -> (c,
          a
          -> (c,
              a
              -> (c,
                  a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a
                 -> (c,
                     a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))))
-> (a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a
                -> (c,
                    a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
forall a b. (a -> b) -> a -> b
$ (c, c, c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
forall c c c c c c c p p p a a a a a a a b b b.
(c, c, c, c, c, c, c)
-> (p, p, p)
-> (a -> a -> a -> a -> a -> a -> a -> (b, b, b))
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
ctxt73 (c
c2,c
c3,c
c4,c
c5,c
c6,c
c7,c
c8) (p, p, p)
ps ((a -> a -> a -> a -> a -> a -> a -> (b, b, b))
 -> (c,
     a
     -> (c,
         a
         -> (c,
             a
             -> (c,
                 a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b))))))))))
-> (a -> a -> a -> a -> a -> a -> a -> a -> (b, b, b))
-> a
-> (c,
    a
    -> (c,
        a
        -> (c,
            a
            -> (c,
                a -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b)))))))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> a -> a -> a -> a -> a -> (b, b, b)
f

ctxt14 :: c
-> (p, p, p, p)
-> (a -> (b, b, b, b))
-> (c, a -> ((p, b), (p, b), (p, b), (p, b)))
ctxt14 (c
c1)           (p1 :: p
p1,p2 :: p
p2,p3 :: p
p3,p4 :: p
p4) f :: a -> (b, b, b, b)
f = c
-> (a -> ((p, b), (p, b), (p, b), (p, b)))
-> (c, a -> ((p, b), (p, b), (p, b), (p, b)))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> ((p, b), (p, b), (p, b), (p, b)))
 -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
-> (a -> ((p, b), (p, b), (p, b), (p, b)))
-> (c, a -> ((p, b), (p, b), (p, b), (p, b)))
forall a b. (a -> b) -> a -> b
$ (b -> (p, b), b -> (p, b), b -> (p, b), b -> (p, b))
-> (b, b, b, b) -> ((p, b), (p, b), (p, b), (p, b))
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)
($$$$) (p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p1, p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p2, p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p3, p -> b -> (p, b)
forall p b. p -> b -> (p, b)
wres p
p4) ((b, b, b, b) -> ((p, b), (p, b), (p, b), (p, b)))
-> (a -> (b, b, b, b)) -> a -> ((p, b), (p, b), (p, b), (p, b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, b, b, b)
f
ctxt24 :: (c, c)
-> (p, p, p, p)
-> (a -> a -> (b, b, b, b))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
ctxt24 (c1 :: c
c1,c2 :: c
c2)                   ps :: (p, p, p, p)
ps f :: a -> a -> (b, b, b, b)
f = c
-> (a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
 -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
-> (a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
forall a b. (a -> b) -> a -> b
$ c
-> (p, p, p, p)
-> (a -> (b, b, b, b))
-> (c, a -> ((p, b), (p, b), (p, b), (p, b)))
forall c p p p p a b b b b.
c
-> (p, p, p, p)
-> (a -> (b, b, b, b))
-> (c, a -> ((p, b), (p, b), (p, b), (p, b)))
ctxt14  c
c2 (p, p, p, p)
ps ((a -> (b, b, b, b)) -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
-> (a -> a -> (b, b, b, b))
-> a
-> (c, a -> ((p, b), (p, b), (p, b), (p, b)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> (b, b, b, b)
f
ctxt34 :: (c, c, c)
-> (p, p, p, p)
-> (a -> a -> a -> (b, b, b, b))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
ctxt34 (c1 :: c
c1,c2 :: c
c2,c3 :: c
c3)                ps :: (p, p, p, p)
ps f :: a -> a -> a -> (b, b, b, b)
f = c
-> (a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
forall c a b. c -> (a -> b) -> (c, a -> b)
warg c
c1 ((a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
 -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))))
-> (a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
-> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
forall a b. (a -> b) -> a -> b
$ (c, c)
-> (p, p, p, p)
-> (a -> a -> (b, b, b, b))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
forall c c p p p p a a b b b b.
(c, c)
-> (p, p, p, p)
-> (a -> a -> (b, b, b, b))
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
ctxt24 (c
c2,c
c3) (p, p, p, p)
ps ((a -> a -> (b, b, b, b))
 -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b)))))
-> (a -> a -> a -> (b, b, b, b))
-> a
-> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a -> (b, b, b, b)
f
ctxt44 :: (c, c, c, c)
-> (p, p, p, p)
-> (a -> a -> a -> a -> (b, b, b, b))
-> (c,
    a
    -> (c, a -> (c, a -> (c, a -> ((p, b), (p, b), (p, b), (p, b))))))