{-# LANGUAGE CPP                #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFunctor      #-}
{-# LANGUAGE NoImplicitPrelude  #-}
{-# LANGUAGE OverloadedStrings  #-}
module Bridge where

import           Prelude

import           Data.Data
import           Data.Text (Text)


-- | One specific and incomplete specifications of event-handlers geared
-- towards their use with JS.
data EventHandler a
    = OnKeyDown   !a
    | OnKeyUp     !a
    | OnKeyPress  !a
    | OnEnter     !a
    | OnFocus !a
    | OnBlur  !a
    | OnValueChange    !a
    | OnCheckedChange  !a
    | OnSelectedChange !a
    | OnSubmit         !a
    | OnClick       !a
    | OnDoubleClick !a
    | OnMouseDown   !a
    | OnMouseUp     !a
    | OnMouseMove   !a
    | OnMouseEnter  !a
    | OnMouseLeave  !a
    | OnMouseOver   !a
    | OnMouseOut    !a
    | OnScroll !a
    | OnWheel  !a

    -- TODO: Implement these
    -- OnCopy  ([File] -> IO a)
    -- OnCut   ([File] -> IO a)
    -- OnPaste ([File] -> IO a)

    -- TODO: Implement these.
    -- OnDrag      ([File] -> IO a)
    -- OnDragEnd   ([File] -> IO a)
    -- OnDragEnter ([File] -> IO a)
    -- OnDragExit  ([File] -> IO a)
    -- OnDragLeave ([File] -> IO a)
    -- OnDragOver  ([File] -> IO a)
    -- OnDragStart ([File] -> IO a)
    -- OnDrop      ([File] -> IO a)

    -- TODO: add more events.

#ifdef FAY
             deriving (Typeable, Data)
#else
             deriving (a -> EventHandler b -> EventHandler a
(a -> b) -> EventHandler a -> EventHandler b
(forall a b. (a -> b) -> EventHandler a -> EventHandler b)
-> (forall a b. a -> EventHandler b -> EventHandler a)
-> Functor EventHandler
forall a b. a -> EventHandler b -> EventHandler a
forall a b. (a -> b) -> EventHandler a -> EventHandler b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> EventHandler b -> EventHandler a
$c<$ :: forall a b. a -> EventHandler b -> EventHandler a
fmap :: (a -> b) -> EventHandler a -> EventHandler b
$cfmap :: forall a b. (a -> b) -> EventHandler a -> EventHandler b
Functor, Typeable, Typeable (EventHandler a)
DataType
Constr
Typeable (EventHandler a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EventHandler a -> c (EventHandler a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EventHandler a))
-> (EventHandler a -> Constr)
-> (EventHandler a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EventHandler a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EventHandler a)))
-> ((forall b. Data b => b -> b)
    -> EventHandler a -> EventHandler a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EventHandler a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EventHandler a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EventHandler a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EventHandler a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EventHandler a -> m (EventHandler a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EventHandler a -> m (EventHandler a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EventHandler a -> m (EventHandler a))
-> Data (EventHandler a)
EventHandler a -> DataType
EventHandler a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (EventHandler a))
(forall b. Data b => b -> b) -> EventHandler a -> EventHandler a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventHandler a -> c (EventHandler a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EventHandler a)
forall a. Data a => Typeable (EventHandler a)
forall a. Data a => EventHandler a -> DataType
forall a. Data a => EventHandler a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> EventHandler a -> EventHandler a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> EventHandler a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> EventHandler a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EventHandler a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventHandler a -> c (EventHandler a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EventHandler a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EventHandler a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> EventHandler a -> u
forall u. (forall d. Data d => d -> u) -> EventHandler a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EventHandler a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventHandler a -> c (EventHandler a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (EventHandler a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EventHandler a))
$cOnWheel :: Constr
$cOnScroll :: Constr
$cOnMouseOut :: Constr
$cOnMouseOver :: Constr
$cOnMouseLeave :: Constr
$cOnMouseEnter :: Constr
$cOnMouseMove :: Constr
$cOnMouseUp :: Constr
$cOnMouseDown :: Constr
$cOnDoubleClick :: Constr
$cOnClick :: Constr
$cOnSubmit :: Constr
$cOnSelectedChange :: Constr
$cOnCheckedChange :: Constr
$cOnValueChange :: Constr
$cOnBlur :: Constr
$cOnFocus :: Constr
$cOnEnter :: Constr
$cOnKeyPress :: Constr
$cOnKeyUp :: Constr
$cOnKeyDown :: Constr
$tEventHandler :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
gmapMp :: (forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
gmapM :: (forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> EventHandler a -> m (EventHandler a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> EventHandler a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> EventHandler a -> u
gmapQ :: (forall d. Data d => d -> u) -> EventHandler a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> EventHandler a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EventHandler a -> r
gmapT :: (forall b. Data b => b -> b) -> EventHandler a -> EventHandler a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> EventHandler a -> EventHandler a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EventHandler a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (EventHandler a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (EventHandler a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (EventHandler a))
dataTypeOf :: EventHandler a -> DataType
$cdataTypeOf :: forall a. Data a => EventHandler a -> DataType
toConstr :: EventHandler a -> Constr
$ctoConstr :: forall a. Data a => EventHandler a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EventHandler a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (EventHandler a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventHandler a -> c (EventHandler a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EventHandler a -> c (EventHandler a)
$cp1Data :: forall a. Data a => Typeable (EventHandler a)
Data)
#endif

data In a = PingPong
  | Send (Action a)
  | AskEvents
  deriving (Typeable (In a)
DataType
Constr
Typeable (In a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> In a -> c (In a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (In a))
-> (In a -> Constr)
-> (In a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (In a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (In a)))
-> ((forall b. Data b => b -> b) -> In a -> In a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r)
-> (forall u. (forall d. Data d => d -> u) -> In a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> In a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> In a -> m (In a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> In a -> m (In a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> In a -> m (In a))
-> Data (In a)
In a -> DataType
In a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (In a))
(forall b. Data b => b -> b) -> In a -> In a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> In a -> c (In a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (In a)
forall a. Data a => Typeable (In a)
forall a. Data a => In a -> DataType
forall a. Data a => In a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> In a -> In a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> In a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> In a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> In a -> m (In a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> In a -> m (In a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (In a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> In a -> c (In a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (In a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (In a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> In a -> u
forall u. (forall d. Data d => d -> u) -> In a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> In a -> m (In a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> In a -> m (In a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (In a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> In a -> c (In a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (In a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (In a))
$cAskEvents :: Constr
$cSend :: Constr
$cPingPong :: Constr
$tIn :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> In a -> m (In a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> In a -> m (In a)
gmapMp :: (forall d. Data d => d -> m d) -> In a -> m (In a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> In a -> m (In a)
gmapM :: (forall d. Data d => d -> m d) -> In a -> m (In a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> In a -> m (In a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> In a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> In a -> u
gmapQ :: (forall d. Data d => d -> u) -> In a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> In a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> In a -> r
gmapT :: (forall b. Data b => b -> b) -> In a -> In a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> In a -> In a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (In a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (In a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (In a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (In a))
dataTypeOf :: In a -> DataType
$cdataTypeOf :: forall a. Data a => In a -> DataType
toConstr :: In a -> Constr
$ctoConstr :: forall a. Data a => In a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (In a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (In a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> In a -> c (In a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> In a -> c (In a)
$cp1Data :: forall a. Data a => Typeable (In a)
Data, Typeable)

data Out a = EmptyCmd
  | ExecuteClient ClientId (ClientTask a) ExecuteStrategy
  deriving (Typeable (Out a)
DataType
Constr
Typeable (Out a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Out a -> c (Out a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Out a))
-> (Out a -> Constr)
-> (Out a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Out a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Out a)))
-> ((forall b. Data b => b -> b) -> Out a -> Out a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Out a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Out a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Out a -> m (Out a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Out a -> m (Out a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Out a -> m (Out a))
-> Data (Out a)
Out a -> DataType
Out a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Out a))
(forall b. Data b => b -> b) -> Out a -> Out a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Out a -> c (Out a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Out a)
forall a. Data a => Typeable (Out a)
forall a. Data a => Out a -> DataType
forall a. Data a => Out a -> Constr
forall a. Data a => (forall b. Data b => b -> b) -> Out a -> Out a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Out a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Out a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Out a -> m (Out a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Out a -> m (Out a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Out a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Out a -> c (Out a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Out a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Out a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Out a -> u
forall u. (forall d. Data d => d -> u) -> Out a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Out a -> m (Out a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Out a -> m (Out a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Out a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Out a -> c (Out a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Out a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Out a))
$cExecuteClient :: Constr
$cEmptyCmd :: Constr
$tOut :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Out a -> m (Out a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Out a -> m (Out a)
gmapMp :: (forall d. Data d => d -> m d) -> Out a -> m (Out a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Out a -> m (Out a)
gmapM :: (forall d. Data d => d -> m d) -> Out a -> m (Out a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Out a -> m (Out a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Out a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Out a -> u
gmapQ :: (forall d. Data d => d -> u) -> Out a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Out a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Out a -> r
gmapT :: (forall b. Data b => b -> b) -> Out a -> Out a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Out a -> Out a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Out a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Out a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Out a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Out a))
dataTypeOf :: Out a -> DataType
$cdataTypeOf :: forall a. Data a => Out a -> DataType
toConstr :: Out a -> Constr
$ctoConstr :: forall a. Data a => Out a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Out a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Out a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Out a -> c (Out a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Out a -> c (Out a)
$cp1Data :: forall a. Data a => Typeable (Out a)
Data, Typeable)

data ExecuteStrategy =
  ExecuteAll | ExecuteExcept
  deriving (Typeable ExecuteStrategy
DataType
Constr
Typeable ExecuteStrategy =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ExecuteStrategy -> c ExecuteStrategy)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExecuteStrategy)
-> (ExecuteStrategy -> Constr)
-> (ExecuteStrategy -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExecuteStrategy))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ExecuteStrategy))
-> ((forall b. Data b => b -> b)
    -> ExecuteStrategy -> ExecuteStrategy)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ExecuteStrategy -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ExecuteStrategy -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ExecuteStrategy -> m ExecuteStrategy)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExecuteStrategy -> m ExecuteStrategy)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExecuteStrategy -> m ExecuteStrategy)
-> Data ExecuteStrategy
ExecuteStrategy -> DataType
ExecuteStrategy -> Constr
(forall b. Data b => b -> b) -> ExecuteStrategy -> ExecuteStrategy
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecuteStrategy -> c ExecuteStrategy
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecuteStrategy
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ExecuteStrategy -> u
forall u. (forall d. Data d => d -> u) -> ExecuteStrategy -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecuteStrategy
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecuteStrategy -> c ExecuteStrategy
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExecuteStrategy)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExecuteStrategy)
$cExecuteExcept :: Constr
$cExecuteAll :: Constr
$tExecuteStrategy :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
gmapMp :: (forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
gmapM :: (forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ExecuteStrategy -> m ExecuteStrategy
gmapQi :: Int -> (forall d. Data d => d -> u) -> ExecuteStrategy -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ExecuteStrategy -> u
gmapQ :: (forall d. Data d => d -> u) -> ExecuteStrategy -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExecuteStrategy -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExecuteStrategy -> r
gmapT :: (forall b. Data b => b -> b) -> ExecuteStrategy -> ExecuteStrategy
$cgmapT :: (forall b. Data b => b -> b) -> ExecuteStrategy -> ExecuteStrategy
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExecuteStrategy)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExecuteStrategy)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ExecuteStrategy)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExecuteStrategy)
dataTypeOf :: ExecuteStrategy -> DataType
$cdataTypeOf :: ExecuteStrategy -> DataType
toConstr :: ExecuteStrategy -> Constr
$ctoConstr :: ExecuteStrategy -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecuteStrategy
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExecuteStrategy
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecuteStrategy -> c ExecuteStrategy
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExecuteStrategy -> c ExecuteStrategy
$cp1Data :: Typeable ExecuteStrategy
Data, Typeable, ExecuteStrategy -> ExecuteStrategy -> Bool
(ExecuteStrategy -> ExecuteStrategy -> Bool)
-> (ExecuteStrategy -> ExecuteStrategy -> Bool)
-> Eq ExecuteStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExecuteStrategy -> ExecuteStrategy -> Bool
$c/= :: ExecuteStrategy -> ExecuteStrategy -> Bool
== :: ExecuteStrategy -> ExecuteStrategy -> Bool
$c== :: ExecuteStrategy -> ExecuteStrategy -> Bool
Eq)

data ClientTask a = ClientTask
  { ClientTask a -> [RenderHtml]
executeRenderHtml :: [RenderHtml]
  , ClientTask a -> [CallbackAction a]
executeAction     :: [CallbackAction a]
  } deriving (Typeable (ClientTask a)
DataType
Constr
Typeable (ClientTask a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ClientTask a -> c (ClientTask a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ClientTask a))
-> (ClientTask a -> Constr)
-> (ClientTask a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ClientTask a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ClientTask a)))
-> ((forall b. Data b => b -> b) -> ClientTask a -> ClientTask a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClientTask a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClientTask a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ClientTask a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ClientTask a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a))
-> Data (ClientTask a)
ClientTask a -> DataType
ClientTask a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (ClientTask a))
(forall b. Data b => b -> b) -> ClientTask a -> ClientTask a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClientTask a -> c (ClientTask a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClientTask a)
forall a. Data a => Typeable (ClientTask a)
forall a. Data a => ClientTask a -> DataType
forall a. Data a => ClientTask a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ClientTask a -> ClientTask a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ClientTask a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ClientTask a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClientTask a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClientTask a -> c (ClientTask a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ClientTask a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClientTask a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ClientTask a -> u
forall u. (forall d. Data d => d -> u) -> ClientTask a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClientTask a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClientTask a -> c (ClientTask a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ClientTask a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClientTask a))
$cClientTask :: Constr
$tClientTask :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
gmapMp :: (forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
gmapM :: (forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ClientTask a -> m (ClientTask a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> ClientTask a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ClientTask a -> u
gmapQ :: (forall d. Data d => d -> u) -> ClientTask a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ClientTask a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClientTask a -> r
gmapT :: (forall b. Data b => b -> b) -> ClientTask a -> ClientTask a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ClientTask a -> ClientTask a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClientTask a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ClientTask a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (ClientTask a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ClientTask a))
dataTypeOf :: ClientTask a -> DataType
$cdataTypeOf :: forall a. Data a => ClientTask a -> DataType
toConstr :: ClientTask a -> Constr
$ctoConstr :: forall a. Data a => ClientTask a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClientTask a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ClientTask a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClientTask a -> c (ClientTask a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClientTask a -> c (ClientTask a)
$cp1Data :: forall a. Data a => Typeable (ClientTask a)
Data, Typeable)

data RenderHtml = AttachText ElementId HtmlText
  | AttachDOM ElementId HtmlText deriving (Typeable RenderHtml
DataType
Constr
Typeable RenderHtml =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RenderHtml -> c RenderHtml)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RenderHtml)
-> (RenderHtml -> Constr)
-> (RenderHtml -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RenderHtml))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RenderHtml))
-> ((forall b. Data b => b -> b) -> RenderHtml -> RenderHtml)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RenderHtml -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RenderHtml -> r)
-> (forall u. (forall d. Data d => d -> u) -> RenderHtml -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RenderHtml -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml)
-> Data RenderHtml
RenderHtml -> DataType
RenderHtml -> Constr
(forall b. Data b => b -> b) -> RenderHtml -> RenderHtml
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RenderHtml -> c RenderHtml
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RenderHtml
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RenderHtml -> u
forall u. (forall d. Data d => d -> u) -> RenderHtml -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RenderHtml -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RenderHtml -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RenderHtml
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RenderHtml -> c RenderHtml
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RenderHtml)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RenderHtml)
$cAttachDOM :: Constr
$cAttachText :: Constr
$tRenderHtml :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
gmapMp :: (forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
gmapM :: (forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RenderHtml -> m RenderHtml
gmapQi :: Int -> (forall d. Data d => d -> u) -> RenderHtml -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RenderHtml -> u
gmapQ :: (forall d. Data d => d -> u) -> RenderHtml -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RenderHtml -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RenderHtml -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RenderHtml -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RenderHtml -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RenderHtml -> r
gmapT :: (forall b. Data b => b -> b) -> RenderHtml -> RenderHtml
$cgmapT :: (forall b. Data b => b -> b) -> RenderHtml -> RenderHtml
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RenderHtml)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RenderHtml)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RenderHtml)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RenderHtml)
dataTypeOf :: RenderHtml -> DataType
$cdataTypeOf :: RenderHtml -> DataType
toConstr :: RenderHtml -> Constr
$ctoConstr :: RenderHtml -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RenderHtml
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RenderHtml
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RenderHtml -> c RenderHtml
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RenderHtml -> c RenderHtml
$cp1Data :: Typeable RenderHtml
Data, Typeable)

data CallbackAction a = CallbackAction (EventHandler a)
#ifdef FAY
  deriving (Typeable, Data)
#else
  deriving (Typeable, Typeable (CallbackAction a)
DataType
Constr
Typeable (CallbackAction a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> CallbackAction a
 -> c (CallbackAction a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CallbackAction a))
-> (CallbackAction a -> Constr)
-> (CallbackAction a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CallbackAction a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CallbackAction a)))
-> ((forall b. Data b => b -> b)
    -> CallbackAction a -> CallbackAction a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CallbackAction a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CallbackAction a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CallbackAction a -> m (CallbackAction a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CallbackAction a -> m (CallbackAction a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CallbackAction a -> m (CallbackAction a))
-> Data (CallbackAction a)
CallbackAction a -> DataType
CallbackAction a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (CallbackAction a))
(forall b. Data b => b -> b)
-> CallbackAction a -> CallbackAction a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallbackAction a -> c (CallbackAction a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallbackAction a)
forall a. Data a => Typeable (CallbackAction a)
forall a. Data a => CallbackAction a -> DataType
forall a. Data a => CallbackAction a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b)
-> CallbackAction a -> CallbackAction a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CallbackAction a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CallbackAction a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallbackAction a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallbackAction a -> c (CallbackAction a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CallbackAction a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallbackAction a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CallbackAction a -> u
forall u. (forall d. Data d => d -> u) -> CallbackAction a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallbackAction a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallbackAction a -> c (CallbackAction a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CallbackAction a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallbackAction a))
$cCallbackAction :: Constr
$tCallbackAction :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
gmapMp :: (forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
gmapM :: (forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> CallbackAction a -> m (CallbackAction a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> CallbackAction a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CallbackAction a -> u
gmapQ :: (forall d. Data d => d -> u) -> CallbackAction a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CallbackAction a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CallbackAction a -> r
gmapT :: (forall b. Data b => b -> b)
-> CallbackAction a -> CallbackAction a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b)
-> CallbackAction a -> CallbackAction a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallbackAction a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CallbackAction a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (CallbackAction a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CallbackAction a))
dataTypeOf :: CallbackAction a -> DataType
$cdataTypeOf :: forall a. Data a => CallbackAction a -> DataType
toConstr :: CallbackAction a -> Constr
$ctoConstr :: forall a. Data a => CallbackAction a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallbackAction a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CallbackAction a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallbackAction a -> c (CallbackAction a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CallbackAction a -> c (CallbackAction a)
$cp1Data :: forall a. Data a => Typeable (CallbackAction a)
Data)

instance Show a => Show (CallbackAction a) where
  show :: CallbackAction a -> String
show = CallbackAction a -> String
forall a. Show a => a -> String
show
#endif

data Action a = Action ElementId ActionType a
#ifdef FAY
  deriving (Typeable, Data)
#else
  deriving (Int -> Action a -> ShowS
[Action a] -> ShowS
Action a -> String
(Int -> Action a -> ShowS)
-> (Action a -> String) -> ([Action a] -> ShowS) -> Show (Action a)
forall a. Show a => Int -> Action a -> ShowS
forall a. Show a => [Action a] -> ShowS
forall a. Show a => Action a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Action a] -> ShowS
$cshowList :: forall a. Show a => [Action a] -> ShowS
show :: Action a -> String
$cshow :: forall a. Show a => Action a -> String
showsPrec :: Int -> Action a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Action a -> ShowS
Show, Typeable, Typeable (Action a)
DataType
Constr
Typeable (Action a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Action a -> c (Action a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Action a))
-> (Action a -> Constr)
-> (Action a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Action a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Action a)))
-> ((forall b. Data b => b -> b) -> Action a -> Action a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Action a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Action a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Action a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Action a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Action a -> m (Action a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Action a -> m (Action a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Action a -> m (Action a))
-> Data (Action a)
Action a -> DataType
Action a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Action a))
(forall b. Data b => b -> b) -> Action a -> Action a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Action a -> c (Action a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Action a)
forall a. Data a => Typeable (Action a)
forall a. Data a => Action a -> DataType
forall a. Data a => Action a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Action a -> Action a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Action a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Action a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Action a -> m (Action a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Action a -> m (Action a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Action a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Action a -> c (Action a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Action a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Action a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Action a -> u
forall u. (forall d. Data d => d -> u) -> Action a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Action a -> m (Action a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Action a -> m (Action a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Action a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Action a -> c (Action a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Action a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Action a))
$cAction :: Constr
$tAction :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Action a -> m (Action a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Action a -> m (Action a)
gmapMp :: (forall d. Data d => d -> m d) -> Action a -> m (Action a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Action a -> m (Action a)
gmapM :: (forall d. Data d => d -> m d) -> Action a -> m (Action a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Action a -> m (Action a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Action a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Action a -> u
gmapQ :: (forall d. Data d => d -> u) -> Action a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Action a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Action a -> r
gmapT :: (forall b. Data b => b -> b) -> Action a -> Action a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Action a -> Action a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Action a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Action a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Action a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Action a))
dataTypeOf :: Action a -> DataType
$cdataTypeOf :: forall a. Data a => Action a -> DataType
toConstr :: Action a -> Constr
$ctoConstr :: forall a. Data a => Action a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Action a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Action a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Action a -> c (Action a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Action a -> c (Action a)
$cp1Data :: forall a. Data a => Typeable (Action a)
Data)
#endif

{-elementId :: Action a -> ElementId
elementId (Action e _ _) = e

actionType :: Action a -> ActionType
actionType (Action _ a _) = a

actionCmd :: Action a -> a
actionCmd (Action _ _ c) = c

updateAction :: Action a -> a -> Action a
updateAction (Action e a _) c = Action e a c-}

data ActionType = RecordAction | ObjectAction | EnterAction
#ifdef FAY
  deriving (Typeable, Data)
#else
  deriving (Int -> ActionType -> ShowS
[ActionType] -> ShowS
ActionType -> String
(Int -> ActionType -> ShowS)
-> (ActionType -> String)
-> ([ActionType] -> ShowS)
-> Show ActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ActionType] -> ShowS
$cshowList :: [ActionType] -> ShowS
show :: ActionType -> String
$cshow :: ActionType -> String
showsPrec :: Int -> ActionType -> ShowS
$cshowsPrec :: Int -> ActionType -> ShowS
Show, Typeable, Typeable ActionType
DataType
Constr
Typeable ActionType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ActionType -> c ActionType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ActionType)
-> (ActionType -> Constr)
-> (ActionType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ActionType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ActionType))
-> ((forall b. Data b => b -> b) -> ActionType -> ActionType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ActionType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ActionType -> r)
-> (forall u. (forall d. Data d => d -> u) -> ActionType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ActionType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ActionType -> m ActionType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ActionType -> m ActionType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ActionType -> m ActionType)
-> Data ActionType
ActionType -> DataType
ActionType -> Constr
(forall b. Data b => b -> b) -> ActionType -> ActionType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ActionType -> c ActionType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ActionType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ActionType -> u
forall u. (forall d. Data d => d -> u) -> ActionType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ActionType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ActionType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ActionType -> m ActionType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ActionType -> m ActionType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ActionType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ActionType -> c ActionType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ActionType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ActionType)
$cEnterAction :: Constr
$cObjectAction :: Constr
$cRecordAction :: Constr
$tActionType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ActionType -> m ActionType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ActionType -> m ActionType
gmapMp :: (forall d. Data d => d -> m d) -> ActionType -> m ActionType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ActionType -> m ActionType
gmapM :: (forall d. Data d => d -> m d) -> ActionType -> m ActionType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ActionType -> m ActionType
gmapQi :: Int -> (forall d. Data d => d -> u) -> ActionType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ActionType -> u
gmapQ :: (forall d. Data d => d -> u) -> ActionType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ActionType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ActionType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ActionType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ActionType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ActionType -> r
gmapT :: (forall b. Data b => b -> b) -> ActionType -> ActionType
$cgmapT :: (forall b. Data b => b -> b) -> ActionType -> ActionType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ActionType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ActionType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ActionType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ActionType)
dataTypeOf :: ActionType -> DataType
$cdataTypeOf :: ActionType -> DataType
toConstr :: ActionType -> Constr
$ctoConstr :: ActionType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ActionType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ActionType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ActionType -> c ActionType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ActionType -> c ActionType
$cp1Data :: Typeable ActionType
Data)
#endif

type ElementId = Text

type HtmlText = Text

type ObjectId = Int

type AttrId = Int

type ClientId = Int

type RowNumber = Int

type RecordValue = Text

-- | Pretty-printer for command expected from Client.
ppIncomingCommand :: In a -> Text
ppIncomingCommand :: In a -> Text
ppIncomingCommand AskEvents = "AskEvents"
ppIncomingCommand (Send _)  = "SendObjectAction"
ppIncomingCommand PingPong  = "PingPong"