{-# LANGUAGE BlockArguments, LambdaCase, TupleSections #-}
{-# LANGUAGE PatternSynonyms, ViewPatterns #-}
{-# LANGUAGE TypeOperators, ConstraintKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,
	UndecidableInstances #-}
{-# OPTIONS_GHC -Wall -fno-warn-tabs #-}

module Control.Moffy.Internal.React (
	-- * Class
	Adjustable, Updatable,
	-- * Constraint Synonym
	Firstable,
	-- * Function
	adjust, first_, par) where

import Control.Arrow ((***))
import Control.Monad.Freer.Par (
	pattern Pure, pattern (:=<<), (=<<<), app, appPar )
import Control.Moffy.Internal.React.Type (
	React, Rct(..), EvOccs, CollapsableOccurred, ThreadId, never )
import Data.Type.Set ((:+:))
import Data.OneOrMore (Expandable, Mergeable, expand, merge)
import Data.Or (Or(..))

import Data.OneOrMoreApp (collapse)

---------------------------------------------------------------------------

-- * FIRST
-- * ADJUST
-- * PAR
-- * UPDATABLE

---------------------------------------------------------------------------
-- FIRST
---------------------------------------------------------------------------

type Firstable es es' a b = (
	Updatable a b, Adjustable es (es :+: es'), Adjustable es' (es :+: es'),
	((es :+: es') :+: (es :+: es')) ~ (es :+: es'),
	Mergeable (es :+: es') (es :+: es') (es :+: es') )

first_ :: Firstable es es' a b =>
	React s (es :+: es') (ThreadId, ThreadId) ->
	React s es a -> React s es' b -> React s (es :+: es') (Or a b)
first_ :: forall (es :: Set (*)) (es' :: Set (*)) a b s.
Firstable es es' a b =>
React s (es :+: es') (ThreadId, ThreadId)
-> React s es a -> React s es' b -> React s (es :+: es') (Or a b)
first_ React s (Merge es es') (ThreadId, ThreadId)
ft (forall (es :: Set (*)) (es' :: Set (*)) s a.
Adjustable es es' =>
React s es a -> React s es' a
adjust -> React s (Merge es es') a
l) (forall (es :: Set (*)) (es' :: Set (*)) s a.
Adjustable es es' =>
React s es a -> React s es' a
adjust -> React s (Merge es es') b
r) = (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b (es :: Set (*)) s.
(Updatable a b, Mergeable es es es, (es :+: es) ~ es) =>
React s es (ThreadId, ThreadId)
-> React s es a
-> React s es b
-> React s es (React s es a, React s es b)
par React s (Merge es es') (ThreadId, ThreadId)
ft React s (Merge es es') a
l React s (Merge es es') b
r) \case
	(Pure a
x, Pure b
y) -> forall a b. a -> b -> Or a b
LR a
x b
y; (Pure a
x, React s (Merge es es') b
_) -> forall a b. a -> Or a b
L a
x; (React s (Merge es es') a
_, Pure b
y) -> forall a b. b -> Or a b
R b
y
	(Fun s FTCQueue TaggableFun (Rct (Merge es es')) x a
_ :=<< Rct (Merge es es') x
_, Fun s FTCQueue TaggableFun (Rct (Merge es es')) x b
_:=<< Rct (Merge es es') x
_) -> forall a. HasCallStack => [Char] -> a
error [Char]
"never occur"

---------------------------------------------------------------------------
-- ADJUST
---------------------------------------------------------------------------

class Adjustable es es' where adjust :: React s es a -> React s es' a
instance Adjustable es es where adjust :: forall s a. React s es a -> React s es a
adjust = forall a. a -> a
id
instance {-# OVERLAPPABLE #-} (Expandable es es', CollapsableOccurred es' es) =>
	Adjustable es es' where adjust :: forall s a. React s es a -> React s es' a
adjust = forall (es :: Set (*)) (es' :: Set (*)) s a.
(Expandable es es', CollapsableOccurred es' es) =>
React s es a -> React s es' a
adj

adj :: (Expandable es es', CollapsableOccurred es' es) =>
	React s es a -> React s es' a
adj :: forall (es :: Set (*)) (es' :: Set (*)) s a.
(Expandable es es', CollapsableOccurred es' es) =>
React s es a -> React s es' a
adj = \case
	Pure a
x -> forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x; Fun s FTCQueue TaggableFun (Rct es) x a
_ :=<< Rct es x
Never -> forall s (es :: Set (*)) a. React s es a
never
	Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Rct es x
GetThreadId -> forall (es :: Set (*)) (es' :: Set (*)) s a.
(Expandable es es', CollapsableOccurred es' es) =>
React s es a -> React s es' a
adj forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app`) forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) a s (t :: * -> *) b.
(Sequence sq, Funable f) =>
(a -> Freer s sq f t b) -> t a -> Freer s sq f t b
=<<< forall (es :: Set (*)). Rct es ThreadId
GetThreadId
	r :: React s es a
r@(Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Await EvReqs es
e) ->
		forall (es :: Set (*)) (es' :: Set (*)) s a.
(Expandable es es', CollapsableOccurred es' es) =>
React s es a -> React s es' a
adj forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> (a -> b) -> Maybe a -> b
maybe React s es a
r (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app`) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (as :: Set (*)) (as' :: Set (*)) (f :: * -> *).
Collapsable as as' =>
OneOrMoreApp ('SetApp f as) -> Maybe (OneOrMoreApp ('SetApp f as'))
collapse forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) a s (t :: * -> *) b.
(Sequence sq, Funable f) =>
(a -> Freer s sq f t b) -> t a -> Freer s sq f t b
=<<< forall (es :: Set (*)).
EvReqs es -> Rct es (OneOrMoreApp (Occurred :$: es))
Await (forall (as :: Set (*)) (as' :: Set (*)).
Expandable as as' =>
OneOrMore as -> OneOrMore as'
expand EvReqs es
e)

---------------------------------------------------------------------------
-- PAR
---------------------------------------------------------------------------

par :: (Updatable a b, Mergeable es es es, (es :+: es) ~ es) =>
	React s es (ThreadId, ThreadId) ->
	React s es a -> React s es b -> React s es (React s es a, React s es b)
par :: forall a b (es :: Set (*)) s.
(Updatable a b, Mergeable es es es, (es :+: es) ~ es) =>
React s es (ThreadId, ThreadId)
-> React s es a
-> React s es b
-> React s es (React s es a, React s es b)
par React s es (ThreadId, ThreadId)
ft React s es a
l React s es b
r = case (React s es a
l, React s es b
r) of
	(Pure a
_, React s es b
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure (React s es a
l, React s es b
r); (React s es a
_, Pure b
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure (React s es a
l, React s es b
r)
	(Fun s FTCQueue TaggableFun (Rct es) x a
_ :=<< Rct es x
Never, Fun s FTCQueue TaggableFun (Rct es) x b
_ :=<< Rct es x
Never) -> forall s (es :: Set (*)) a. React s es a
never
	(Fun s FTCQueue TaggableFun (Rct es) x a
_ :=<< Rct es x
Never, React s es b
_) -> (forall s (es :: Set (*)) a. React s es a
never ,) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> React s es b
r
	(React s es a
_, Fun s FTCQueue TaggableFun (Rct es) x b
_ :=<< Rct es x
Never) -> (, forall s (es :: Set (*)) a. React s es a
never) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> React s es a
l
	(Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Rct es x
GetThreadId, Fun s FTCQueue TaggableFun (Rct es) x b
c' :=<< Rct es x
GetThreadId) ->
		forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (forall a b (es :: Set (*)) s.
(Updatable a b, Mergeable es es es, (es :+: es) ~ es) =>
React s es (ThreadId, ThreadId)
-> React s es a
-> React s es b
-> React s es (React s es a, React s es b)
par React s es (ThreadId, ThreadId)
ft) forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
app Fun s FTCQueue TaggableFun (Rct es) x a
c forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
app Fun s FTCQueue TaggableFun (Rct es) x b
c') forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< React s es (ThreadId, ThreadId)
ft
	(Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Rct es x
GetThreadId, React s es b
_) -> forall a b c. (a -> b -> c) -> b -> a -> c
flip (forall a b (es :: Set (*)) s.
(Updatable a b, Mergeable es es es, (es :+: es) ~ es) =>
React s es (ThreadId, ThreadId)
-> React s es a
-> React s es b
-> React s es (React s es a, React s es b)
par React s es (ThreadId, ThreadId)
ft) React s es b
r forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
app Fun s FTCQueue TaggableFun (Rct es) x a
c forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< React s es (ThreadId, ThreadId)
ft
	(React s es a
_, Fun s FTCQueue TaggableFun (Rct es) x b
c' :=<< Rct es x
GetThreadId) -> forall a b (es :: Set (*)) s.
(Updatable a b, Mergeable es es es, (es :+: es) ~ es) =>
React s es (ThreadId, ThreadId)
-> React s es a
-> React s es b
-> React s es (React s es a, React s es b)
par React s es (ThreadId, ThreadId)
ft React s es a
l forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
app Fun s FTCQueue TaggableFun (Rct es) x b
c' forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< React s es (ThreadId, ThreadId)
ft
	(Fun s FTCQueue TaggableFun (Rct es) x a
_ :=<< Await EvReqs es
el, Fun s FTCQueue TaggableFun (Rct es) x b
_ :=<< Await EvReqs es
er) -> React s es (ThreadId, ThreadId)
ft forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \(ThreadId
t, ThreadId
u) ->
		forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (forall a b (es :: Set (*)) s.
(Updatable a b, Mergeable es es es, (es :+: es) ~ es) =>
React s es (ThreadId, ThreadId)
-> React s es a
-> React s es b
-> React s es (React s es a, React s es b)
par React s es (ThreadId, ThreadId)
ft)
			forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b s (es :: Set (*)).
Updatable a b =>
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update React s es a
l ThreadId
t React s es b
r ThreadId
u forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) a s (t :: * -> *) b.
(Sequence sq, Funable f) =>
(a -> Freer s sq f t b) -> t a -> Freer s sq f t b
=<<< forall (es :: Set (*)).
EvReqs es -> Rct es (OneOrMoreApp (Occurred :$: es))
Await (EvReqs es
el forall (as :: Set (*)) (as' :: Set (*)).
Mergeable as as' (as :+: as') =>
OneOrMore as -> OneOrMore as' -> OneOrMore (as :+: as')
`merge` EvReqs es
er)

---------------------------------------------------------------------------
-- UPDATABLE
---------------------------------------------------------------------------

class Updatable a b where
	update :: React s es a -> ThreadId -> React s es b -> ThreadId ->
		EvOccs es -> (React s es a, React s es b)

instance Updatable a a where
	update :: forall s (es :: Set (*)).
React s es a
-> ThreadId
-> React s es a
-> ThreadId
-> EvOccs es
-> (React s es a, React s es a)
update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Rct es x
GetThreadId) ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x a
c' :=<< Rct es x
GetThreadId) ThreadId
u EvOccs es
x =
		forall a b s (es :: Set (*)).
Updatable a b =>
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
t) ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x a
c' forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
u) ThreadId
u EvOccs es
x
	update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Rct es x
GetThreadId) ThreadId
t Freer s FTCQueue TaggableFun (Rct es) a
r ThreadId
u EvOccs es
x = forall a b s (es :: Set (*)).
Updatable a b =>
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
t) ThreadId
t Freer s FTCQueue TaggableFun (Rct es) a
r ThreadId
u EvOccs es
x
	update Freer s FTCQueue TaggableFun (Rct es) a
l ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x a
c' :=<< Rct es x
GetThreadId) ThreadId
u EvOccs es
x = forall a b s (es :: Set (*)).
Updatable a b =>
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update Freer s FTCQueue TaggableFun (Rct es) a
l ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x a
c' forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
u) ThreadId
u EvOccs es
x
	update l :: Freer s FTCQueue TaggableFun (Rct es) a
l@(Fun s FTCQueue TaggableFun (Rct es) x a
_ :=<< Rct es x
Never) ThreadId
_ (Fun s FTCQueue TaggableFun (Rct es) x a
c' :=<< Await EvReqs es
_) ThreadId
_ EvOccs es
x = (Freer s FTCQueue TaggableFun (Rct es) a
l, Fun s FTCQueue TaggableFun (Rct es) x a
c' forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` EvOccs es
x)
	update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Await EvReqs es
_) ThreadId
_ r :: Freer s FTCQueue TaggableFun (Rct es) a
r@(Fun s FTCQueue TaggableFun (Rct es) x a
_ :=<< Rct es x
Never) ThreadId
_ EvOccs es
x = (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` EvOccs es
x, Freer s FTCQueue TaggableFun (Rct es) a
r)
	update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Await EvReqs es
_) ThreadId
_ (Fun s FTCQueue TaggableFun (Rct es) x a
c' :=<< Await EvReqs es
_) ThreadId
_ EvOccs es
x = forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f, Taggable f) =>
Fun s sq f t a b
-> Fun s sq f t a b -> a -> (Freer s sq f t b, Freer s sq f t b)
appPar Fun s FTCQueue TaggableFun (Rct es) x a
c Fun s FTCQueue TaggableFun (Rct es) x a
c' EvOccs es
x
	update Freer s FTCQueue TaggableFun (Rct es) a
l ThreadId
_ Freer s FTCQueue TaggableFun (Rct es) a
r ThreadId
_ EvOccs es
_ = (Freer s FTCQueue TaggableFun (Rct es) a
l, Freer s FTCQueue TaggableFun (Rct es) a
r)

instance {-# OVERLAPPABLE #-} Updatable a b where
	update :: forall s (es :: Set (*)).
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Rct es x
GetThreadId) ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x b
c' :=<< Rct es x
GetThreadId) ThreadId
u EvOccs es
x =
		forall a b s (es :: Set (*)).
Updatable a b =>
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
t) ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x b
c' forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
u) ThreadId
u EvOccs es
x
	update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Rct es x
GetThreadId) ThreadId
t Freer s FTCQueue TaggableFun (Rct es) b
r ThreadId
u EvOccs es
x = forall a b s (es :: Set (*)).
Updatable a b =>
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
t) ThreadId
t Freer s FTCQueue TaggableFun (Rct es) b
r ThreadId
u EvOccs es
x
	update Freer s FTCQueue TaggableFun (Rct es) a
l ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x b
c' :=<< Rct es x
GetThreadId) ThreadId
u EvOccs es
x = forall a b s (es :: Set (*)).
Updatable a b =>
React s es a
-> ThreadId
-> React s es b
-> ThreadId
-> EvOccs es
-> (React s es a, React s es b)
update Freer s FTCQueue TaggableFun (Rct es) a
l ThreadId
t (Fun s FTCQueue TaggableFun (Rct es) x b
c' forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` ThreadId
u) ThreadId
u EvOccs es
x
	update l :: Freer s FTCQueue TaggableFun (Rct es) a
l@(Fun s FTCQueue TaggableFun (Rct es) x a
_ :=<< Rct es x
Never) ThreadId
_ (Fun s FTCQueue TaggableFun (Rct es) x b
c' :=<< Await EvReqs es
_) ThreadId
_ EvOccs es
x = (Freer s FTCQueue TaggableFun (Rct es) a
l, Fun s FTCQueue TaggableFun (Rct es) x b
c' forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` EvOccs es
x)
	update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Await EvReqs es
_) ThreadId
_ r :: Freer s FTCQueue TaggableFun (Rct es) b
r@(Fun s FTCQueue TaggableFun (Rct es) x b
_ :=<< Rct es x
Never) ThreadId
_ EvOccs es
x = (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` EvOccs es
x, Freer s FTCQueue TaggableFun (Rct es) b
r)
	update (Fun s FTCQueue TaggableFun (Rct es) x a
c :=<< Await EvReqs es
_) ThreadId
_ (Fun s FTCQueue TaggableFun (Rct es) x b
c' :=<< Await EvReqs es
_) ThreadId
_ EvOccs es
x = (Fun s FTCQueue TaggableFun (Rct es) x a
c forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` EvOccs es
x, Fun s FTCQueue TaggableFun (Rct es) x b
c' forall (sq :: (* -> * -> *) -> * -> * -> *)
       (f :: (* -> *) -> * -> * -> *) s (t :: * -> *) a b.
(Sequence sq, Funable f) =>
Fun s sq f t a b -> a -> Freer s sq f t b
`app` EvOccs es
x)
	update Freer s FTCQueue TaggableFun (Rct es) a
l ThreadId
_ Freer s FTCQueue TaggableFun (Rct es) b
r ThreadId
_ EvOccs es
_ = (Freer s FTCQueue TaggableFun (Rct es) a
l, Freer s FTCQueue TaggableFun (Rct es) b
r)