{-
Copyright EO/Polystat Development Team (c) 2023

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
      copyright notice, this list of conditions and the following
      disclaimer in the documentation and/or other materials provided
      with the distribution.

    * Neither the name of EO/Polystat Development Team nor the names of other
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-}

-- File generated by the BNF Converter (bnfc 2.9.5).

{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-- | The abstract syntax of language Syntax.

module Language.EO.Phi.Syntax.Abs where

import Prelude (String)
import qualified Prelude as C (Eq, Ord, Show, Read)
import qualified Data.String

import qualified Data.Data    as C (Data, Typeable)
import qualified GHC.Generics as C (Generic)

data Program = Program [Binding]
  deriving (Program -> Program -> Bool
(Program -> Program -> Bool)
-> (Program -> Program -> Bool) -> Eq Program
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Program -> Program -> Bool
== :: Program -> Program -> Bool
$c/= :: Program -> Program -> Bool
/= :: Program -> Program -> Bool
C.Eq, Eq Program
Eq Program =>
(Program -> Program -> Ordering)
-> (Program -> Program -> Bool)
-> (Program -> Program -> Bool)
-> (Program -> Program -> Bool)
-> (Program -> Program -> Bool)
-> (Program -> Program -> Program)
-> (Program -> Program -> Program)
-> Ord Program
Program -> Program -> Bool
Program -> Program -> Ordering
Program -> Program -> Program
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Program -> Program -> Ordering
compare :: Program -> Program -> Ordering
$c< :: Program -> Program -> Bool
< :: Program -> Program -> Bool
$c<= :: Program -> Program -> Bool
<= :: Program -> Program -> Bool
$c> :: Program -> Program -> Bool
> :: Program -> Program -> Bool
$c>= :: Program -> Program -> Bool
>= :: Program -> Program -> Bool
$cmax :: Program -> Program -> Program
max :: Program -> Program -> Program
$cmin :: Program -> Program -> Program
min :: Program -> Program -> Program
C.Ord, Int -> Program -> ShowS
[Program] -> ShowS
Program -> String
(Int -> Program -> ShowS)
-> (Program -> String) -> ([Program] -> ShowS) -> Show Program
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Program -> ShowS
showsPrec :: Int -> Program -> ShowS
$cshow :: Program -> String
show :: Program -> String
$cshowList :: [Program] -> ShowS
showList :: [Program] -> ShowS
C.Show, ReadPrec [Program]
ReadPrec Program
Int -> ReadS Program
ReadS [Program]
(Int -> ReadS Program)
-> ReadS [Program]
-> ReadPrec Program
-> ReadPrec [Program]
-> Read Program
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Program
readsPrec :: Int -> ReadS Program
$creadList :: ReadS [Program]
readList :: ReadS [Program]
$creadPrec :: ReadPrec Program
readPrec :: ReadPrec Program
$creadListPrec :: ReadPrec [Program]
readListPrec :: ReadPrec [Program]
C.Read, Typeable Program
Typeable Program =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Program -> c Program)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Program)
-> (Program -> Constr)
-> (Program -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Program))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Program))
-> ((forall b. Data b => b -> b) -> Program -> Program)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Program -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Program -> r)
-> (forall u. (forall d. Data d => d -> u) -> Program -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Program -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Program -> m Program)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Program -> m Program)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Program -> m Program)
-> Data Program
Program -> Constr
Program -> DataType
(forall b. Data b => b -> b) -> Program -> Program
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) -> Program -> u
forall u. (forall d. Data d => d -> u) -> Program -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Program -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Program -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Program -> m Program
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Program -> m Program
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Program
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program -> c Program
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Program)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Program)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program -> c Program
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Program -> c Program
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Program
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Program
$ctoConstr :: Program -> Constr
toConstr :: Program -> Constr
$cdataTypeOf :: Program -> DataType
dataTypeOf :: Program -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Program)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Program)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Program)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Program)
$cgmapT :: (forall b. Data b => b -> b) -> Program -> Program
gmapT :: (forall b. Data b => b -> b) -> Program -> Program
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Program -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Program -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Program -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Program -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Program -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Program -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Program -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Program -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Program -> m Program
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Program -> m Program
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Program -> m Program
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Program -> m Program
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Program -> m Program
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Program -> m Program
C.Data, C.Typeable, (forall x. Program -> Rep Program x)
-> (forall x. Rep Program x -> Program) -> Generic Program
forall x. Rep Program x -> Program
forall x. Program -> Rep Program x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Program -> Rep Program x
from :: forall x. Program -> Rep Program x
$cto :: forall x. Rep Program x -> Program
to :: forall x. Rep Program x -> Program
C.Generic)

data MetaId
    = MetaIdLabel LabelMetaId
    | MetaIdTail TailMetaId
    | MetaIdBindings BindingsMetaId
    | MetaIdObject ObjectMetaId
    | MetaIdBytes BytesMetaId
  deriving (MetaId -> MetaId -> Bool
(MetaId -> MetaId -> Bool)
-> (MetaId -> MetaId -> Bool) -> Eq MetaId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MetaId -> MetaId -> Bool
== :: MetaId -> MetaId -> Bool
$c/= :: MetaId -> MetaId -> Bool
/= :: MetaId -> MetaId -> Bool
C.Eq, Eq MetaId
Eq MetaId =>
(MetaId -> MetaId -> Ordering)
-> (MetaId -> MetaId -> Bool)
-> (MetaId -> MetaId -> Bool)
-> (MetaId -> MetaId -> Bool)
-> (MetaId -> MetaId -> Bool)
-> (MetaId -> MetaId -> MetaId)
-> (MetaId -> MetaId -> MetaId)
-> Ord MetaId
MetaId -> MetaId -> Bool
MetaId -> MetaId -> Ordering
MetaId -> MetaId -> MetaId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MetaId -> MetaId -> Ordering
compare :: MetaId -> MetaId -> Ordering
$c< :: MetaId -> MetaId -> Bool
< :: MetaId -> MetaId -> Bool
$c<= :: MetaId -> MetaId -> Bool
<= :: MetaId -> MetaId -> Bool
$c> :: MetaId -> MetaId -> Bool
> :: MetaId -> MetaId -> Bool
$c>= :: MetaId -> MetaId -> Bool
>= :: MetaId -> MetaId -> Bool
$cmax :: MetaId -> MetaId -> MetaId
max :: MetaId -> MetaId -> MetaId
$cmin :: MetaId -> MetaId -> MetaId
min :: MetaId -> MetaId -> MetaId
C.Ord, Int -> MetaId -> ShowS
[MetaId] -> ShowS
MetaId -> String
(Int -> MetaId -> ShowS)
-> (MetaId -> String) -> ([MetaId] -> ShowS) -> Show MetaId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MetaId -> ShowS
showsPrec :: Int -> MetaId -> ShowS
$cshow :: MetaId -> String
show :: MetaId -> String
$cshowList :: [MetaId] -> ShowS
showList :: [MetaId] -> ShowS
C.Show, ReadPrec [MetaId]
ReadPrec MetaId
Int -> ReadS MetaId
ReadS [MetaId]
(Int -> ReadS MetaId)
-> ReadS [MetaId]
-> ReadPrec MetaId
-> ReadPrec [MetaId]
-> Read MetaId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MetaId
readsPrec :: Int -> ReadS MetaId
$creadList :: ReadS [MetaId]
readList :: ReadS [MetaId]
$creadPrec :: ReadPrec MetaId
readPrec :: ReadPrec MetaId
$creadListPrec :: ReadPrec [MetaId]
readListPrec :: ReadPrec [MetaId]
C.Read, Typeable MetaId
Typeable MetaId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MetaId -> c MetaId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaId)
-> (MetaId -> Constr)
-> (MetaId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaId))
-> ((forall b. Data b => b -> b) -> MetaId -> MetaId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaId -> r)
-> (forall u. (forall d. Data d => d -> u) -> MetaId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MetaId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MetaId -> m MetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaId -> m MetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MetaId -> m MetaId)
-> Data MetaId
MetaId -> Constr
MetaId -> DataType
(forall b. Data b => b -> b) -> MetaId -> MetaId
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) -> MetaId -> u
forall u. (forall d. Data d => d -> u) -> MetaId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MetaId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MetaId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetaId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetaId -> c MetaId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetaId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetaId -> c MetaId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetaId -> c MetaId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetaId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetaId
$ctoConstr :: MetaId -> Constr
toConstr :: MetaId -> Constr
$cdataTypeOf :: MetaId -> DataType
dataTypeOf :: MetaId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetaId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetaId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MetaId)
$cgmapT :: (forall b. Data b => b -> b) -> MetaId -> MetaId
gmapT :: (forall b. Data b => b -> b) -> MetaId -> MetaId
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MetaId -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MetaId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MetaId -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MetaId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MetaId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MetaId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MetaId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MetaId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MetaId -> m MetaId
C.Data, C.Typeable, (forall x. MetaId -> Rep MetaId x)
-> (forall x. Rep MetaId x -> MetaId) -> Generic MetaId
forall x. Rep MetaId x -> MetaId
forall x. MetaId -> Rep MetaId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MetaId -> Rep MetaId x
from :: forall x. MetaId -> Rep MetaId x
$cto :: forall x. Rep MetaId x -> MetaId
to :: forall x. Rep MetaId x -> MetaId
C.Generic)

data Object
    = Formation [Binding]
    | Application Object [Binding]
    | ObjectDispatch Object Attribute
    | GlobalObject
    | ThisObject
    | Termination
    | MetaSubstThis Object Object
    | MetaContextualize Object Object
    | MetaObject ObjectMetaId
    | MetaTailContext Object TailMetaId
    | MetaFunction MetaFunctionName Object
  deriving (Object -> Object -> Bool
(Object -> Object -> Bool)
-> (Object -> Object -> Bool) -> Eq Object
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Object -> Object -> Bool
== :: Object -> Object -> Bool
$c/= :: Object -> Object -> Bool
/= :: Object -> Object -> Bool
C.Eq, Eq Object
Eq Object =>
(Object -> Object -> Ordering)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Bool)
-> (Object -> Object -> Object)
-> (Object -> Object -> Object)
-> Ord Object
Object -> Object -> Bool
Object -> Object -> Ordering
Object -> Object -> Object
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Object -> Object -> Ordering
compare :: Object -> Object -> Ordering
$c< :: Object -> Object -> Bool
< :: Object -> Object -> Bool
$c<= :: Object -> Object -> Bool
<= :: Object -> Object -> Bool
$c> :: Object -> Object -> Bool
> :: Object -> Object -> Bool
$c>= :: Object -> Object -> Bool
>= :: Object -> Object -> Bool
$cmax :: Object -> Object -> Object
max :: Object -> Object -> Object
$cmin :: Object -> Object -> Object
min :: Object -> Object -> Object
C.Ord, Int -> Object -> ShowS
[Object] -> ShowS
Object -> String
(Int -> Object -> ShowS)
-> (Object -> String) -> ([Object] -> ShowS) -> Show Object
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Object -> ShowS
showsPrec :: Int -> Object -> ShowS
$cshow :: Object -> String
show :: Object -> String
$cshowList :: [Object] -> ShowS
showList :: [Object] -> ShowS
C.Show, ReadPrec [Object]
ReadPrec Object
Int -> ReadS Object
ReadS [Object]
(Int -> ReadS Object)
-> ReadS [Object]
-> ReadPrec Object
-> ReadPrec [Object]
-> Read Object
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Object
readsPrec :: Int -> ReadS Object
$creadList :: ReadS [Object]
readList :: ReadS [Object]
$creadPrec :: ReadPrec Object
readPrec :: ReadPrec Object
$creadListPrec :: ReadPrec [Object]
readListPrec :: ReadPrec [Object]
C.Read, Typeable Object
Typeable Object =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Object -> c Object)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Object)
-> (Object -> Constr)
-> (Object -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Object))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object))
-> ((forall b. Data b => b -> b) -> Object -> Object)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Object -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Object -> r)
-> (forall u. (forall d. Data d => d -> u) -> Object -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Object -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Object -> m Object)
-> Data Object
Object -> Constr
Object -> DataType
(forall b. Data b => b -> b) -> Object -> Object
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) -> Object -> u
forall u. (forall d. Data d => d -> u) -> Object -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Object -> m Object
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Object -> c Object
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Object
$ctoConstr :: Object -> Constr
toConstr :: Object -> Constr
$cdataTypeOf :: Object -> DataType
dataTypeOf :: Object -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Object)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Object)
$cgmapT :: (forall b. Data b => b -> b) -> Object -> Object
gmapT :: (forall b. Data b => b -> b) -> Object -> Object
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Object -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Object -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Object -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Object -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Object -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Object -> m Object
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Object -> m Object
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Object -> m Object
C.Data, C.Typeable, (forall x. Object -> Rep Object x)
-> (forall x. Rep Object x -> Object) -> Generic Object
forall x. Rep Object x -> Object
forall x. Object -> Rep Object x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Object -> Rep Object x
from :: forall x. Object -> Rep Object x
$cto :: forall x. Rep Object x -> Object
to :: forall x. Rep Object x -> Object
C.Generic)

data Binding
    = AlphaBinding Attribute Object
    | EmptyBinding Attribute
    | DeltaBinding Bytes
    | DeltaEmptyBinding
    | LambdaBinding Function
    | MetaBindings BindingsMetaId
    | MetaDeltaBinding BytesMetaId
  deriving (Binding -> Binding -> Bool
(Binding -> Binding -> Bool)
-> (Binding -> Binding -> Bool) -> Eq Binding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Binding -> Binding -> Bool
== :: Binding -> Binding -> Bool
$c/= :: Binding -> Binding -> Bool
/= :: Binding -> Binding -> Bool
C.Eq, Eq Binding
Eq Binding =>
(Binding -> Binding -> Ordering)
-> (Binding -> Binding -> Bool)
-> (Binding -> Binding -> Bool)
-> (Binding -> Binding -> Bool)
-> (Binding -> Binding -> Bool)
-> (Binding -> Binding -> Binding)
-> (Binding -> Binding -> Binding)
-> Ord Binding
Binding -> Binding -> Bool
Binding -> Binding -> Ordering
Binding -> Binding -> Binding
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Binding -> Binding -> Ordering
compare :: Binding -> Binding -> Ordering
$c< :: Binding -> Binding -> Bool
< :: Binding -> Binding -> Bool
$c<= :: Binding -> Binding -> Bool
<= :: Binding -> Binding -> Bool
$c> :: Binding -> Binding -> Bool
> :: Binding -> Binding -> Bool
$c>= :: Binding -> Binding -> Bool
>= :: Binding -> Binding -> Bool
$cmax :: Binding -> Binding -> Binding
max :: Binding -> Binding -> Binding
$cmin :: Binding -> Binding -> Binding
min :: Binding -> Binding -> Binding
C.Ord, Int -> Binding -> ShowS
[Binding] -> ShowS
Binding -> String
(Int -> Binding -> ShowS)
-> (Binding -> String) -> ([Binding] -> ShowS) -> Show Binding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Binding -> ShowS
showsPrec :: Int -> Binding -> ShowS
$cshow :: Binding -> String
show :: Binding -> String
$cshowList :: [Binding] -> ShowS
showList :: [Binding] -> ShowS
C.Show, ReadPrec [Binding]
ReadPrec Binding
Int -> ReadS Binding
ReadS [Binding]
(Int -> ReadS Binding)
-> ReadS [Binding]
-> ReadPrec Binding
-> ReadPrec [Binding]
-> Read Binding
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Binding
readsPrec :: Int -> ReadS Binding
$creadList :: ReadS [Binding]
readList :: ReadS [Binding]
$creadPrec :: ReadPrec Binding
readPrec :: ReadPrec Binding
$creadListPrec :: ReadPrec [Binding]
readListPrec :: ReadPrec [Binding]
C.Read, Typeable Binding
Typeable Binding =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Binding -> c Binding)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Binding)
-> (Binding -> Constr)
-> (Binding -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Binding))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding))
-> ((forall b. Data b => b -> b) -> Binding -> Binding)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Binding -> r)
-> (forall u. (forall d. Data d => d -> u) -> Binding -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Binding -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Binding -> m Binding)
-> Data Binding
Binding -> Constr
Binding -> DataType
(forall b. Data b => b -> b) -> Binding -> Binding
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) -> Binding -> u
forall u. (forall d. Data d => d -> u) -> Binding -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Binding
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding -> c Binding
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Binding)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding -> c Binding
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Binding -> c Binding
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Binding
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Binding
$ctoConstr :: Binding -> Constr
toConstr :: Binding -> Constr
$cdataTypeOf :: Binding -> DataType
dataTypeOf :: Binding -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Binding)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Binding)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Binding)
$cgmapT :: (forall b. Data b => b -> b) -> Binding -> Binding
gmapT :: (forall b. Data b => b -> b) -> Binding -> Binding
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Binding -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Binding -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Binding -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Binding -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binding -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Binding -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Binding -> m Binding
C.Data, C.Typeable, (forall x. Binding -> Rep Binding x)
-> (forall x. Rep Binding x -> Binding) -> Generic Binding
forall x. Rep Binding x -> Binding
forall x. Binding -> Rep Binding x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Binding -> Rep Binding x
from :: forall x. Binding -> Rep Binding x
$cto :: forall x. Rep Binding x -> Binding
to :: forall x. Rep Binding x -> Binding
C.Generic)

data Attribute
    = Phi
    | Rho
    | Label LabelId
    | Alpha AlphaIndex
    | MetaAttr LabelMetaId
  deriving (Attribute -> Attribute -> Bool
(Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool) -> Eq Attribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Attribute -> Attribute -> Bool
== :: Attribute -> Attribute -> Bool
$c/= :: Attribute -> Attribute -> Bool
/= :: Attribute -> Attribute -> Bool
C.Eq, Eq Attribute
Eq Attribute =>
(Attribute -> Attribute -> Ordering)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Attribute)
-> (Attribute -> Attribute -> Attribute)
-> Ord Attribute
Attribute -> Attribute -> Bool
Attribute -> Attribute -> Ordering
Attribute -> Attribute -> Attribute
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Attribute -> Attribute -> Ordering
compare :: Attribute -> Attribute -> Ordering
$c< :: Attribute -> Attribute -> Bool
< :: Attribute -> Attribute -> Bool
$c<= :: Attribute -> Attribute -> Bool
<= :: Attribute -> Attribute -> Bool
$c> :: Attribute -> Attribute -> Bool
> :: Attribute -> Attribute -> Bool
$c>= :: Attribute -> Attribute -> Bool
>= :: Attribute -> Attribute -> Bool
$cmax :: Attribute -> Attribute -> Attribute
max :: Attribute -> Attribute -> Attribute
$cmin :: Attribute -> Attribute -> Attribute
min :: Attribute -> Attribute -> Attribute
C.Ord, Int -> Attribute -> ShowS
[Attribute] -> ShowS
Attribute -> String
(Int -> Attribute -> ShowS)
-> (Attribute -> String)
-> ([Attribute] -> ShowS)
-> Show Attribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Attribute -> ShowS
showsPrec :: Int -> Attribute -> ShowS
$cshow :: Attribute -> String
show :: Attribute -> String
$cshowList :: [Attribute] -> ShowS
showList :: [Attribute] -> ShowS
C.Show, ReadPrec [Attribute]
ReadPrec Attribute
Int -> ReadS Attribute
ReadS [Attribute]
(Int -> ReadS Attribute)
-> ReadS [Attribute]
-> ReadPrec Attribute
-> ReadPrec [Attribute]
-> Read Attribute
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Attribute
readsPrec :: Int -> ReadS Attribute
$creadList :: ReadS [Attribute]
readList :: ReadS [Attribute]
$creadPrec :: ReadPrec Attribute
readPrec :: ReadPrec Attribute
$creadListPrec :: ReadPrec [Attribute]
readListPrec :: ReadPrec [Attribute]
C.Read, Typeable Attribute
Typeable Attribute =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Attribute -> c Attribute)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attribute)
-> (Attribute -> Constr)
-> (Attribute -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attribute))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute))
-> ((forall b. Data b => b -> b) -> Attribute -> Attribute)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute -> r)
-> (forall u. (forall d. Data d => d -> u) -> Attribute -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Attribute -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> Data Attribute
Attribute -> Constr
Attribute -> DataType
(forall b. Data b => b -> b) -> Attribute -> Attribute
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) -> Attribute -> u
forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
$ctoConstr :: Attribute -> Constr
toConstr :: Attribute -> Constr
$cdataTypeOf :: Attribute -> DataType
dataTypeOf :: Attribute -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
$cgmapT :: (forall b. Data b => b -> b) -> Attribute -> Attribute
gmapT :: (forall b. Data b => b -> b) -> Attribute -> Attribute
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attribute -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attribute -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
C.Data, C.Typeable, (forall x. Attribute -> Rep Attribute x)
-> (forall x. Rep Attribute x -> Attribute) -> Generic Attribute
forall x. Rep Attribute x -> Attribute
forall x. Attribute -> Rep Attribute x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Attribute -> Rep Attribute x
from :: forall x. Attribute -> Rep Attribute x
$cto :: forall x. Rep Attribute x -> Attribute
to :: forall x. Rep Attribute x -> Attribute
C.Generic)

data RuleAttribute = ObjectAttr Attribute | DeltaAttr | LambdaAttr
  deriving (RuleAttribute -> RuleAttribute -> Bool
(RuleAttribute -> RuleAttribute -> Bool)
-> (RuleAttribute -> RuleAttribute -> Bool) -> Eq RuleAttribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RuleAttribute -> RuleAttribute -> Bool
== :: RuleAttribute -> RuleAttribute -> Bool
$c/= :: RuleAttribute -> RuleAttribute -> Bool
/= :: RuleAttribute -> RuleAttribute -> Bool
C.Eq, Eq RuleAttribute
Eq RuleAttribute =>
(RuleAttribute -> RuleAttribute -> Ordering)
-> (RuleAttribute -> RuleAttribute -> Bool)
-> (RuleAttribute -> RuleAttribute -> Bool)
-> (RuleAttribute -> RuleAttribute -> Bool)
-> (RuleAttribute -> RuleAttribute -> Bool)
-> (RuleAttribute -> RuleAttribute -> RuleAttribute)
-> (RuleAttribute -> RuleAttribute -> RuleAttribute)
-> Ord RuleAttribute
RuleAttribute -> RuleAttribute -> Bool
RuleAttribute -> RuleAttribute -> Ordering
RuleAttribute -> RuleAttribute -> RuleAttribute
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RuleAttribute -> RuleAttribute -> Ordering
compare :: RuleAttribute -> RuleAttribute -> Ordering
$c< :: RuleAttribute -> RuleAttribute -> Bool
< :: RuleAttribute -> RuleAttribute -> Bool
$c<= :: RuleAttribute -> RuleAttribute -> Bool
<= :: RuleAttribute -> RuleAttribute -> Bool
$c> :: RuleAttribute -> RuleAttribute -> Bool
> :: RuleAttribute -> RuleAttribute -> Bool
$c>= :: RuleAttribute -> RuleAttribute -> Bool
>= :: RuleAttribute -> RuleAttribute -> Bool
$cmax :: RuleAttribute -> RuleAttribute -> RuleAttribute
max :: RuleAttribute -> RuleAttribute -> RuleAttribute
$cmin :: RuleAttribute -> RuleAttribute -> RuleAttribute
min :: RuleAttribute -> RuleAttribute -> RuleAttribute
C.Ord, Int -> RuleAttribute -> ShowS
[RuleAttribute] -> ShowS
RuleAttribute -> String
(Int -> RuleAttribute -> ShowS)
-> (RuleAttribute -> String)
-> ([RuleAttribute] -> ShowS)
-> Show RuleAttribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RuleAttribute -> ShowS
showsPrec :: Int -> RuleAttribute -> ShowS
$cshow :: RuleAttribute -> String
show :: RuleAttribute -> String
$cshowList :: [RuleAttribute] -> ShowS
showList :: [RuleAttribute] -> ShowS
C.Show, ReadPrec [RuleAttribute]
ReadPrec RuleAttribute
Int -> ReadS RuleAttribute
ReadS [RuleAttribute]
(Int -> ReadS RuleAttribute)
-> ReadS [RuleAttribute]
-> ReadPrec RuleAttribute
-> ReadPrec [RuleAttribute]
-> Read RuleAttribute
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RuleAttribute
readsPrec :: Int -> ReadS RuleAttribute
$creadList :: ReadS [RuleAttribute]
readList :: ReadS [RuleAttribute]
$creadPrec :: ReadPrec RuleAttribute
readPrec :: ReadPrec RuleAttribute
$creadListPrec :: ReadPrec [RuleAttribute]
readListPrec :: ReadPrec [RuleAttribute]
C.Read, Typeable RuleAttribute
Typeable RuleAttribute =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RuleAttribute -> c RuleAttribute)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RuleAttribute)
-> (RuleAttribute -> Constr)
-> (RuleAttribute -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RuleAttribute))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RuleAttribute))
-> ((forall b. Data b => b -> b) -> RuleAttribute -> RuleAttribute)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r)
-> (forall u. (forall d. Data d => d -> u) -> RuleAttribute -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RuleAttribute -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute)
-> Data RuleAttribute
RuleAttribute -> Constr
RuleAttribute -> DataType
(forall b. Data b => b -> b) -> RuleAttribute -> RuleAttribute
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) -> RuleAttribute -> u
forall u. (forall d. Data d => d -> u) -> RuleAttribute -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleAttribute
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleAttribute -> c RuleAttribute
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleAttribute)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RuleAttribute)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleAttribute -> c RuleAttribute
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RuleAttribute -> c RuleAttribute
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleAttribute
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RuleAttribute
$ctoConstr :: RuleAttribute -> Constr
toConstr :: RuleAttribute -> Constr
$cdataTypeOf :: RuleAttribute -> DataType
dataTypeOf :: RuleAttribute -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleAttribute)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RuleAttribute)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RuleAttribute)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RuleAttribute)
$cgmapT :: (forall b. Data b => b -> b) -> RuleAttribute -> RuleAttribute
gmapT :: (forall b. Data b => b -> b) -> RuleAttribute -> RuleAttribute
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RuleAttribute -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RuleAttribute -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RuleAttribute -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleAttribute -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RuleAttribute -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RuleAttribute -> m RuleAttribute
C.Data, C.Typeable, (forall x. RuleAttribute -> Rep RuleAttribute x)
-> (forall x. Rep RuleAttribute x -> RuleAttribute)
-> Generic RuleAttribute
forall x. Rep RuleAttribute x -> RuleAttribute
forall x. RuleAttribute -> Rep RuleAttribute x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RuleAttribute -> Rep RuleAttribute x
from :: forall x. RuleAttribute -> Rep RuleAttribute x
$cto :: forall x. Rep RuleAttribute x -> RuleAttribute
to :: forall x. Rep RuleAttribute x -> RuleAttribute
C.Generic)

data PeeledObject = PeeledObject ObjectHead [ObjectAction]
  deriving (PeeledObject -> PeeledObject -> Bool
(PeeledObject -> PeeledObject -> Bool)
-> (PeeledObject -> PeeledObject -> Bool) -> Eq PeeledObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PeeledObject -> PeeledObject -> Bool
== :: PeeledObject -> PeeledObject -> Bool
$c/= :: PeeledObject -> PeeledObject -> Bool
/= :: PeeledObject -> PeeledObject -> Bool
C.Eq, Eq PeeledObject
Eq PeeledObject =>
(PeeledObject -> PeeledObject -> Ordering)
-> (PeeledObject -> PeeledObject -> Bool)
-> (PeeledObject -> PeeledObject -> Bool)
-> (PeeledObject -> PeeledObject -> Bool)
-> (PeeledObject -> PeeledObject -> Bool)
-> (PeeledObject -> PeeledObject -> PeeledObject)
-> (PeeledObject -> PeeledObject -> PeeledObject)
-> Ord PeeledObject
PeeledObject -> PeeledObject -> Bool
PeeledObject -> PeeledObject -> Ordering
PeeledObject -> PeeledObject -> PeeledObject
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PeeledObject -> PeeledObject -> Ordering
compare :: PeeledObject -> PeeledObject -> Ordering
$c< :: PeeledObject -> PeeledObject -> Bool
< :: PeeledObject -> PeeledObject -> Bool
$c<= :: PeeledObject -> PeeledObject -> Bool
<= :: PeeledObject -> PeeledObject -> Bool
$c> :: PeeledObject -> PeeledObject -> Bool
> :: PeeledObject -> PeeledObject -> Bool
$c>= :: PeeledObject -> PeeledObject -> Bool
>= :: PeeledObject -> PeeledObject -> Bool
$cmax :: PeeledObject -> PeeledObject -> PeeledObject
max :: PeeledObject -> PeeledObject -> PeeledObject
$cmin :: PeeledObject -> PeeledObject -> PeeledObject
min :: PeeledObject -> PeeledObject -> PeeledObject
C.Ord, Int -> PeeledObject -> ShowS
[PeeledObject] -> ShowS
PeeledObject -> String
(Int -> PeeledObject -> ShowS)
-> (PeeledObject -> String)
-> ([PeeledObject] -> ShowS)
-> Show PeeledObject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PeeledObject -> ShowS
showsPrec :: Int -> PeeledObject -> ShowS
$cshow :: PeeledObject -> String
show :: PeeledObject -> String
$cshowList :: [PeeledObject] -> ShowS
showList :: [PeeledObject] -> ShowS
C.Show, ReadPrec [PeeledObject]
ReadPrec PeeledObject
Int -> ReadS PeeledObject
ReadS [PeeledObject]
(Int -> ReadS PeeledObject)
-> ReadS [PeeledObject]
-> ReadPrec PeeledObject
-> ReadPrec [PeeledObject]
-> Read PeeledObject
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PeeledObject
readsPrec :: Int -> ReadS PeeledObject
$creadList :: ReadS [PeeledObject]
readList :: ReadS [PeeledObject]
$creadPrec :: ReadPrec PeeledObject
readPrec :: ReadPrec PeeledObject
$creadListPrec :: ReadPrec [PeeledObject]
readListPrec :: ReadPrec [PeeledObject]
C.Read, Typeable PeeledObject
Typeable PeeledObject =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PeeledObject -> c PeeledObject)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PeeledObject)
-> (PeeledObject -> Constr)
-> (PeeledObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PeeledObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PeeledObject))
-> ((forall b. Data b => b -> b) -> PeeledObject -> PeeledObject)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PeeledObject -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PeeledObject -> r)
-> (forall u. (forall d. Data d => d -> u) -> PeeledObject -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PeeledObject -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject)
-> Data PeeledObject
PeeledObject -> Constr
PeeledObject -> DataType
(forall b. Data b => b -> b) -> PeeledObject -> PeeledObject
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) -> PeeledObject -> u
forall u. (forall d. Data d => d -> u) -> PeeledObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PeeledObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PeeledObject -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PeeledObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PeeledObject -> c PeeledObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PeeledObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PeeledObject)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PeeledObject -> c PeeledObject
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PeeledObject -> c PeeledObject
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PeeledObject
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PeeledObject
$ctoConstr :: PeeledObject -> Constr
toConstr :: PeeledObject -> Constr
$cdataTypeOf :: PeeledObject -> DataType
dataTypeOf :: PeeledObject -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PeeledObject)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PeeledObject)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PeeledObject)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PeeledObject)
$cgmapT :: (forall b. Data b => b -> b) -> PeeledObject -> PeeledObject
gmapT :: (forall b. Data b => b -> b) -> PeeledObject -> PeeledObject
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PeeledObject -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PeeledObject -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PeeledObject -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PeeledObject -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PeeledObject -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PeeledObject -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PeeledObject -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PeeledObject -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PeeledObject -> m PeeledObject
C.Data, C.Typeable, (forall x. PeeledObject -> Rep PeeledObject x)
-> (forall x. Rep PeeledObject x -> PeeledObject)
-> Generic PeeledObject
forall x. Rep PeeledObject x -> PeeledObject
forall x. PeeledObject -> Rep PeeledObject x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PeeledObject -> Rep PeeledObject x
from :: forall x. PeeledObject -> Rep PeeledObject x
$cto :: forall x. Rep PeeledObject x -> PeeledObject
to :: forall x. Rep PeeledObject x -> PeeledObject
C.Generic)

data ObjectHead
    = HeadFormation [Binding] | HeadGlobal | HeadThis | HeadTermination
  deriving (ObjectHead -> ObjectHead -> Bool
(ObjectHead -> ObjectHead -> Bool)
-> (ObjectHead -> ObjectHead -> Bool) -> Eq ObjectHead
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectHead -> ObjectHead -> Bool
== :: ObjectHead -> ObjectHead -> Bool
$c/= :: ObjectHead -> ObjectHead -> Bool
/= :: ObjectHead -> ObjectHead -> Bool
C.Eq, Eq ObjectHead
Eq ObjectHead =>
(ObjectHead -> ObjectHead -> Ordering)
-> (ObjectHead -> ObjectHead -> Bool)
-> (ObjectHead -> ObjectHead -> Bool)
-> (ObjectHead -> ObjectHead -> Bool)
-> (ObjectHead -> ObjectHead -> Bool)
-> (ObjectHead -> ObjectHead -> ObjectHead)
-> (ObjectHead -> ObjectHead -> ObjectHead)
-> Ord ObjectHead
ObjectHead -> ObjectHead -> Bool
ObjectHead -> ObjectHead -> Ordering
ObjectHead -> ObjectHead -> ObjectHead
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ObjectHead -> ObjectHead -> Ordering
compare :: ObjectHead -> ObjectHead -> Ordering
$c< :: ObjectHead -> ObjectHead -> Bool
< :: ObjectHead -> ObjectHead -> Bool
$c<= :: ObjectHead -> ObjectHead -> Bool
<= :: ObjectHead -> ObjectHead -> Bool
$c> :: ObjectHead -> ObjectHead -> Bool
> :: ObjectHead -> ObjectHead -> Bool
$c>= :: ObjectHead -> ObjectHead -> Bool
>= :: ObjectHead -> ObjectHead -> Bool
$cmax :: ObjectHead -> ObjectHead -> ObjectHead
max :: ObjectHead -> ObjectHead -> ObjectHead
$cmin :: ObjectHead -> ObjectHead -> ObjectHead
min :: ObjectHead -> ObjectHead -> ObjectHead
C.Ord, Int -> ObjectHead -> ShowS
[ObjectHead] -> ShowS
ObjectHead -> String
(Int -> ObjectHead -> ShowS)
-> (ObjectHead -> String)
-> ([ObjectHead] -> ShowS)
-> Show ObjectHead
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ObjectHead -> ShowS
showsPrec :: Int -> ObjectHead -> ShowS
$cshow :: ObjectHead -> String
show :: ObjectHead -> String
$cshowList :: [ObjectHead] -> ShowS
showList :: [ObjectHead] -> ShowS
C.Show, ReadPrec [ObjectHead]
ReadPrec ObjectHead
Int -> ReadS ObjectHead
ReadS [ObjectHead]
(Int -> ReadS ObjectHead)
-> ReadS [ObjectHead]
-> ReadPrec ObjectHead
-> ReadPrec [ObjectHead]
-> Read ObjectHead
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ObjectHead
readsPrec :: Int -> ReadS ObjectHead
$creadList :: ReadS [ObjectHead]
readList :: ReadS [ObjectHead]
$creadPrec :: ReadPrec ObjectHead
readPrec :: ReadPrec ObjectHead
$creadListPrec :: ReadPrec [ObjectHead]
readListPrec :: ReadPrec [ObjectHead]
C.Read, Typeable ObjectHead
Typeable ObjectHead =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ObjectHead -> c ObjectHead)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ObjectHead)
-> (ObjectHead -> Constr)
-> (ObjectHead -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ObjectHead))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ObjectHead))
-> ((forall b. Data b => b -> b) -> ObjectHead -> ObjectHead)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectHead -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectHead -> r)
-> (forall u. (forall d. Data d => d -> u) -> ObjectHead -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ObjectHead -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead)
-> Data ObjectHead
ObjectHead -> Constr
ObjectHead -> DataType
(forall b. Data b => b -> b) -> ObjectHead -> ObjectHead
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) -> ObjectHead -> u
forall u. (forall d. Data d => d -> u) -> ObjectHead -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectHead -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectHead -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectHead
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectHead -> c ObjectHead
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectHead)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjectHead)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectHead -> c ObjectHead
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectHead -> c ObjectHead
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectHead
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectHead
$ctoConstr :: ObjectHead -> Constr
toConstr :: ObjectHead -> Constr
$cdataTypeOf :: ObjectHead -> DataType
dataTypeOf :: ObjectHead -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectHead)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectHead)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjectHead)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ObjectHead)
$cgmapT :: (forall b. Data b => b -> b) -> ObjectHead -> ObjectHead
gmapT :: (forall b. Data b => b -> b) -> ObjectHead -> ObjectHead
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectHead -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectHead -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectHead -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectHead -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectHead -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectHead -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectHead -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectHead -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectHead -> m ObjectHead
C.Data, C.Typeable, (forall x. ObjectHead -> Rep ObjectHead x)
-> (forall x. Rep ObjectHead x -> ObjectHead) -> Generic ObjectHead
forall x. Rep ObjectHead x -> ObjectHead
forall x. ObjectHead -> Rep ObjectHead x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ObjectHead -> Rep ObjectHead x
from :: forall x. ObjectHead -> Rep ObjectHead x
$cto :: forall x. Rep ObjectHead x -> ObjectHead
to :: forall x. Rep ObjectHead x -> ObjectHead
C.Generic)

data ObjectAction
    = ActionApplication [Binding] | ActionDispatch Attribute
  deriving (ObjectAction -> ObjectAction -> Bool
(ObjectAction -> ObjectAction -> Bool)
-> (ObjectAction -> ObjectAction -> Bool) -> Eq ObjectAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectAction -> ObjectAction -> Bool
== :: ObjectAction -> ObjectAction -> Bool
$c/= :: ObjectAction -> ObjectAction -> Bool
/= :: ObjectAction -> ObjectAction -> Bool
C.Eq, Eq ObjectAction
Eq ObjectAction =>
(ObjectAction -> ObjectAction -> Ordering)
-> (ObjectAction -> ObjectAction -> Bool)
-> (ObjectAction -> ObjectAction -> Bool)
-> (ObjectAction -> ObjectAction -> Bool)
-> (ObjectAction -> ObjectAction -> Bool)
-> (ObjectAction -> ObjectAction -> ObjectAction)
-> (ObjectAction -> ObjectAction -> ObjectAction)
-> Ord ObjectAction
ObjectAction -> ObjectAction -> Bool
ObjectAction -> ObjectAction -> Ordering
ObjectAction -> ObjectAction -> ObjectAction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ObjectAction -> ObjectAction -> Ordering
compare :: ObjectAction -> ObjectAction -> Ordering
$c< :: ObjectAction -> ObjectAction -> Bool
< :: ObjectAction -> ObjectAction -> Bool
$c<= :: ObjectAction -> ObjectAction -> Bool
<= :: ObjectAction -> ObjectAction -> Bool
$c> :: ObjectAction -> ObjectAction -> Bool
> :: ObjectAction -> ObjectAction -> Bool
$c>= :: ObjectAction -> ObjectAction -> Bool
>= :: ObjectAction -> ObjectAction -> Bool
$cmax :: ObjectAction -> ObjectAction -> ObjectAction
max :: ObjectAction -> ObjectAction -> ObjectAction
$cmin :: ObjectAction -> ObjectAction -> ObjectAction
min :: ObjectAction -> ObjectAction -> ObjectAction
C.Ord, Int -> ObjectAction -> ShowS
[ObjectAction] -> ShowS
ObjectAction -> String
(Int -> ObjectAction -> ShowS)
-> (ObjectAction -> String)
-> ([ObjectAction] -> ShowS)
-> Show ObjectAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ObjectAction -> ShowS
showsPrec :: Int -> ObjectAction -> ShowS
$cshow :: ObjectAction -> String
show :: ObjectAction -> String
$cshowList :: [ObjectAction] -> ShowS
showList :: [ObjectAction] -> ShowS
C.Show, ReadPrec [ObjectAction]
ReadPrec ObjectAction
Int -> ReadS ObjectAction
ReadS [ObjectAction]
(Int -> ReadS ObjectAction)
-> ReadS [ObjectAction]
-> ReadPrec ObjectAction
-> ReadPrec [ObjectAction]
-> Read ObjectAction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ObjectAction
readsPrec :: Int -> ReadS ObjectAction
$creadList :: ReadS [ObjectAction]
readList :: ReadS [ObjectAction]
$creadPrec :: ReadPrec ObjectAction
readPrec :: ReadPrec ObjectAction
$creadListPrec :: ReadPrec [ObjectAction]
readListPrec :: ReadPrec [ObjectAction]
C.Read, Typeable ObjectAction
Typeable ObjectAction =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ObjectAction -> c ObjectAction)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ObjectAction)
-> (ObjectAction -> Constr)
-> (ObjectAction -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ObjectAction))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ObjectAction))
-> ((forall b. Data b => b -> b) -> ObjectAction -> ObjectAction)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectAction -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectAction -> r)
-> (forall u. (forall d. Data d => d -> u) -> ObjectAction -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ObjectAction -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction)
-> Data ObjectAction
ObjectAction -> Constr
ObjectAction -> DataType
(forall b. Data b => b -> b) -> ObjectAction -> ObjectAction
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) -> ObjectAction -> u
forall u. (forall d. Data d => d -> u) -> ObjectAction -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectAction -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectAction -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectAction
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectAction -> c ObjectAction
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectAction)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectAction)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectAction -> c ObjectAction
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectAction -> c ObjectAction
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectAction
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectAction
$ctoConstr :: ObjectAction -> Constr
toConstr :: ObjectAction -> Constr
$cdataTypeOf :: ObjectAction -> DataType
dataTypeOf :: ObjectAction -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectAction)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectAction)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectAction)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectAction)
$cgmapT :: (forall b. Data b => b -> b) -> ObjectAction -> ObjectAction
gmapT :: (forall b. Data b => b -> b) -> ObjectAction -> ObjectAction
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectAction -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectAction -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectAction -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectAction -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectAction -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectAction -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectAction -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectAction -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectAction -> m ObjectAction
C.Data, C.Typeable, (forall x. ObjectAction -> Rep ObjectAction x)
-> (forall x. Rep ObjectAction x -> ObjectAction)
-> Generic ObjectAction
forall x. Rep ObjectAction x -> ObjectAction
forall x. ObjectAction -> Rep ObjectAction x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ObjectAction -> Rep ObjectAction x
from :: forall x. ObjectAction -> Rep ObjectAction x
$cto :: forall x. Rep ObjectAction x -> ObjectAction
to :: forall x. Rep ObjectAction x -> ObjectAction
C.Generic)

newtype Bytes = Bytes String
  deriving (Bytes -> Bytes -> Bool
(Bytes -> Bytes -> Bool) -> (Bytes -> Bytes -> Bool) -> Eq Bytes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Bytes -> Bytes -> Bool
== :: Bytes -> Bytes -> Bool
$c/= :: Bytes -> Bytes -> Bool
/= :: Bytes -> Bytes -> Bool
C.Eq, Eq Bytes
Eq Bytes =>
(Bytes -> Bytes -> Ordering)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bytes)
-> (Bytes -> Bytes -> Bytes)
-> Ord Bytes
Bytes -> Bytes -> Bool
Bytes -> Bytes -> Ordering
Bytes -> Bytes -> Bytes
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Bytes -> Bytes -> Ordering
compare :: Bytes -> Bytes -> Ordering
$c< :: Bytes -> Bytes -> Bool
< :: Bytes -> Bytes -> Bool
$c<= :: Bytes -> Bytes -> Bool
<= :: Bytes -> Bytes -> Bool
$c> :: Bytes -> Bytes -> Bool
> :: Bytes -> Bytes -> Bool
$c>= :: Bytes -> Bytes -> Bool
>= :: Bytes -> Bytes -> Bool
$cmax :: Bytes -> Bytes -> Bytes
max :: Bytes -> Bytes -> Bytes
$cmin :: Bytes -> Bytes -> Bytes
min :: Bytes -> Bytes -> Bytes
C.Ord, Int -> Bytes -> ShowS
[Bytes] -> ShowS
Bytes -> String
(Int -> Bytes -> ShowS)
-> (Bytes -> String) -> ([Bytes] -> ShowS) -> Show Bytes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Bytes -> ShowS
showsPrec :: Int -> Bytes -> ShowS
$cshow :: Bytes -> String
show :: Bytes -> String
$cshowList :: [Bytes] -> ShowS
showList :: [Bytes] -> ShowS
C.Show, ReadPrec [Bytes]
ReadPrec Bytes
Int -> ReadS Bytes
ReadS [Bytes]
(Int -> ReadS Bytes)
-> ReadS [Bytes]
-> ReadPrec Bytes
-> ReadPrec [Bytes]
-> Read Bytes
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Bytes
readsPrec :: Int -> ReadS Bytes
$creadList :: ReadS [Bytes]
readList :: ReadS [Bytes]
$creadPrec :: ReadPrec Bytes
readPrec :: ReadPrec Bytes
$creadListPrec :: ReadPrec [Bytes]
readListPrec :: ReadPrec [Bytes]
C.Read, Typeable Bytes
Typeable Bytes =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Bytes -> c Bytes)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bytes)
-> (Bytes -> Constr)
-> (Bytes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bytes))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes))
-> ((forall b. Data b => b -> b) -> Bytes -> Bytes)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bytes -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> Data Bytes
Bytes -> Constr
Bytes -> DataType
(forall b. Data b => b -> b) -> Bytes -> Bytes
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) -> Bytes -> u
forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
$ctoConstr :: Bytes -> Constr
toConstr :: Bytes -> Constr
$cdataTypeOf :: Bytes -> DataType
dataTypeOf :: Bytes -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
$cgmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
C.Data, C.Typeable, (forall x. Bytes -> Rep Bytes x)
-> (forall x. Rep Bytes x -> Bytes) -> Generic Bytes
forall x. Rep Bytes x -> Bytes
forall x. Bytes -> Rep Bytes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Bytes -> Rep Bytes x
from :: forall x. Bytes -> Rep Bytes x
$cto :: forall x. Rep Bytes x -> Bytes
to :: forall x. Rep Bytes x -> Bytes
C.Generic, String -> Bytes
(String -> Bytes) -> IsString Bytes
forall a. (String -> a) -> IsString a
$cfromString :: String -> Bytes
fromString :: String -> Bytes
Data.String.IsString)

newtype Function = Function String
  deriving (Function -> Function -> Bool
(Function -> Function -> Bool)
-> (Function -> Function -> Bool) -> Eq Function
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Function -> Function -> Bool
== :: Function -> Function -> Bool
$c/= :: Function -> Function -> Bool
/= :: Function -> Function -> Bool
C.Eq, Eq Function
Eq Function =>
(Function -> Function -> Ordering)
-> (Function -> Function -> Bool)
-> (Function -> Function -> Bool)
-> (Function -> Function -> Bool)
-> (Function -> Function -> Bool)
-> (Function -> Function -> Function)
-> (Function -> Function -> Function)
-> Ord Function
Function -> Function -> Bool
Function -> Function -> Ordering
Function -> Function -> Function
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Function -> Function -> Ordering
compare :: Function -> Function -> Ordering
$c< :: Function -> Function -> Bool
< :: Function -> Function -> Bool
$c<= :: Function -> Function -> Bool
<= :: Function -> Function -> Bool
$c> :: Function -> Function -> Bool
> :: Function -> Function -> Bool
$c>= :: Function -> Function -> Bool
>= :: Function -> Function -> Bool
$cmax :: Function -> Function -> Function
max :: Function -> Function -> Function
$cmin :: Function -> Function -> Function
min :: Function -> Function -> Function
C.Ord, Int -> Function -> ShowS
[Function] -> ShowS
Function -> String
(Int -> Function -> ShowS)
-> (Function -> String) -> ([Function] -> ShowS) -> Show Function
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Function -> ShowS
showsPrec :: Int -> Function -> ShowS
$cshow :: Function -> String
show :: Function -> String
$cshowList :: [Function] -> ShowS
showList :: [Function] -> ShowS
C.Show, ReadPrec [Function]
ReadPrec Function
Int -> ReadS Function
ReadS [Function]
(Int -> ReadS Function)
-> ReadS [Function]
-> ReadPrec Function
-> ReadPrec [Function]
-> Read Function
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Function
readsPrec :: Int -> ReadS Function
$creadList :: ReadS [Function]
readList :: ReadS [Function]
$creadPrec :: ReadPrec Function
readPrec :: ReadPrec Function
$creadListPrec :: ReadPrec [Function]
readListPrec :: ReadPrec [Function]
C.Read, Typeable Function
Typeable Function =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Function -> c Function)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Function)
-> (Function -> Constr)
-> (Function -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Function))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Function))
-> ((forall b. Data b => b -> b) -> Function -> Function)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Function -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Function -> r)
-> (forall u. (forall d. Data d => d -> u) -> Function -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Function -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Function -> m Function)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Function -> m Function)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Function -> m Function)
-> Data Function
Function -> Constr
Function -> DataType
(forall b. Data b => b -> b) -> Function -> Function
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) -> Function -> u
forall u. (forall d. Data d => d -> u) -> Function -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Function -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Function -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Function -> m Function
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Function -> m Function
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Function
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Function -> c Function
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Function)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Function)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Function -> c Function
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Function -> c Function
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Function
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Function
$ctoConstr :: Function -> Constr
toConstr :: Function -> Constr
$cdataTypeOf :: Function -> DataType
dataTypeOf :: Function -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Function)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Function)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Function)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Function)
$cgmapT :: (forall b. Data b => b -> b) -> Function -> Function
gmapT :: (forall b. Data b => b -> b) -> Function -> Function
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Function -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Function -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Function -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Function -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Function -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Function -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Function -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Function -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Function -> m Function
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Function -> m Function
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Function -> m Function
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Function -> m Function
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Function -> m Function
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Function -> m Function
C.Data, C.Typeable, (forall x. Function -> Rep Function x)
-> (forall x. Rep Function x -> Function) -> Generic Function
forall x. Rep Function x -> Function
forall x. Function -> Rep Function x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Function -> Rep Function x
from :: forall x. Function -> Rep Function x
$cto :: forall x. Rep Function x -> Function
to :: forall x. Rep Function x -> Function
C.Generic, String -> Function
(String -> Function) -> IsString Function
forall a. (String -> a) -> IsString a
$cfromString :: String -> Function
fromString :: String -> Function
Data.String.IsString)

newtype LabelId = LabelId String
  deriving (LabelId -> LabelId -> Bool
(LabelId -> LabelId -> Bool)
-> (LabelId -> LabelId -> Bool) -> Eq LabelId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LabelId -> LabelId -> Bool
== :: LabelId -> LabelId -> Bool
$c/= :: LabelId -> LabelId -> Bool
/= :: LabelId -> LabelId -> Bool
C.Eq, Eq LabelId
Eq LabelId =>
(LabelId -> LabelId -> Ordering)
-> (LabelId -> LabelId -> Bool)
-> (LabelId -> LabelId -> Bool)
-> (LabelId -> LabelId -> Bool)
-> (LabelId -> LabelId -> Bool)
-> (LabelId -> LabelId -> LabelId)
-> (LabelId -> LabelId -> LabelId)
-> Ord LabelId
LabelId -> LabelId -> Bool
LabelId -> LabelId -> Ordering
LabelId -> LabelId -> LabelId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LabelId -> LabelId -> Ordering
compare :: LabelId -> LabelId -> Ordering
$c< :: LabelId -> LabelId -> Bool
< :: LabelId -> LabelId -> Bool
$c<= :: LabelId -> LabelId -> Bool
<= :: LabelId -> LabelId -> Bool
$c> :: LabelId -> LabelId -> Bool
> :: LabelId -> LabelId -> Bool
$c>= :: LabelId -> LabelId -> Bool
>= :: LabelId -> LabelId -> Bool
$cmax :: LabelId -> LabelId -> LabelId
max :: LabelId -> LabelId -> LabelId
$cmin :: LabelId -> LabelId -> LabelId
min :: LabelId -> LabelId -> LabelId
C.Ord, Int -> LabelId -> ShowS
[LabelId] -> ShowS
LabelId -> String
(Int -> LabelId -> ShowS)
-> (LabelId -> String) -> ([LabelId] -> ShowS) -> Show LabelId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LabelId -> ShowS
showsPrec :: Int -> LabelId -> ShowS
$cshow :: LabelId -> String
show :: LabelId -> String
$cshowList :: [LabelId] -> ShowS
showList :: [LabelId] -> ShowS
C.Show, ReadPrec [LabelId]
ReadPrec LabelId
Int -> ReadS LabelId
ReadS [LabelId]
(Int -> ReadS LabelId)
-> ReadS [LabelId]
-> ReadPrec LabelId
-> ReadPrec [LabelId]
-> Read LabelId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LabelId
readsPrec :: Int -> ReadS LabelId
$creadList :: ReadS [LabelId]
readList :: ReadS [LabelId]
$creadPrec :: ReadPrec LabelId
readPrec :: ReadPrec LabelId
$creadListPrec :: ReadPrec [LabelId]
readListPrec :: ReadPrec [LabelId]
C.Read, Typeable LabelId
Typeable LabelId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LabelId -> c LabelId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LabelId)
-> (LabelId -> Constr)
-> (LabelId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LabelId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LabelId))
-> ((forall b. Data b => b -> b) -> LabelId -> LabelId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LabelId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LabelId -> r)
-> (forall u. (forall d. Data d => d -> u) -> LabelId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> LabelId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LabelId -> m LabelId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LabelId -> m LabelId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LabelId -> m LabelId)
-> Data LabelId
LabelId -> Constr
LabelId -> DataType
(forall b. Data b => b -> b) -> LabelId -> LabelId
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) -> LabelId -> u
forall u. (forall d. Data d => d -> u) -> LabelId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LabelId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LabelId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LabelId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LabelId -> c LabelId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LabelId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LabelId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LabelId -> c LabelId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LabelId -> c LabelId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LabelId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LabelId
$ctoConstr :: LabelId -> Constr
toConstr :: LabelId -> Constr
$cdataTypeOf :: LabelId -> DataType
dataTypeOf :: LabelId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LabelId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LabelId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LabelId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LabelId)
$cgmapT :: (forall b. Data b => b -> b) -> LabelId -> LabelId
gmapT :: (forall b. Data b => b -> b) -> LabelId -> LabelId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LabelId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LabelId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LabelId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LabelId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LabelId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LabelId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LabelId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LabelId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelId -> m LabelId
C.Data, C.Typeable, (forall x. LabelId -> Rep LabelId x)
-> (forall x. Rep LabelId x -> LabelId) -> Generic LabelId
forall x. Rep LabelId x -> LabelId
forall x. LabelId -> Rep LabelId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LabelId -> Rep LabelId x
from :: forall x. LabelId -> Rep LabelId x
$cto :: forall x. Rep LabelId x -> LabelId
to :: forall x. Rep LabelId x -> LabelId
C.Generic, String -> LabelId
(String -> LabelId) -> IsString LabelId
forall a. (String -> a) -> IsString a
$cfromString :: String -> LabelId
fromString :: String -> LabelId
Data.String.IsString)

newtype AlphaIndex = AlphaIndex String
  deriving (AlphaIndex -> AlphaIndex -> Bool
(AlphaIndex -> AlphaIndex -> Bool)
-> (AlphaIndex -> AlphaIndex -> Bool) -> Eq AlphaIndex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AlphaIndex -> AlphaIndex -> Bool
== :: AlphaIndex -> AlphaIndex -> Bool
$c/= :: AlphaIndex -> AlphaIndex -> Bool
/= :: AlphaIndex -> AlphaIndex -> Bool
C.Eq, Eq AlphaIndex
Eq AlphaIndex =>
(AlphaIndex -> AlphaIndex -> Ordering)
-> (AlphaIndex -> AlphaIndex -> Bool)
-> (AlphaIndex -> AlphaIndex -> Bool)
-> (AlphaIndex -> AlphaIndex -> Bool)
-> (AlphaIndex -> AlphaIndex -> Bool)
-> (AlphaIndex -> AlphaIndex -> AlphaIndex)
-> (AlphaIndex -> AlphaIndex -> AlphaIndex)
-> Ord AlphaIndex
AlphaIndex -> AlphaIndex -> Bool
AlphaIndex -> AlphaIndex -> Ordering
AlphaIndex -> AlphaIndex -> AlphaIndex
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AlphaIndex -> AlphaIndex -> Ordering
compare :: AlphaIndex -> AlphaIndex -> Ordering
$c< :: AlphaIndex -> AlphaIndex -> Bool
< :: AlphaIndex -> AlphaIndex -> Bool
$c<= :: AlphaIndex -> AlphaIndex -> Bool
<= :: AlphaIndex -> AlphaIndex -> Bool
$c> :: AlphaIndex -> AlphaIndex -> Bool
> :: AlphaIndex -> AlphaIndex -> Bool
$c>= :: AlphaIndex -> AlphaIndex -> Bool
>= :: AlphaIndex -> AlphaIndex -> Bool
$cmax :: AlphaIndex -> AlphaIndex -> AlphaIndex
max :: AlphaIndex -> AlphaIndex -> AlphaIndex
$cmin :: AlphaIndex -> AlphaIndex -> AlphaIndex
min :: AlphaIndex -> AlphaIndex -> AlphaIndex
C.Ord, Int -> AlphaIndex -> ShowS
[AlphaIndex] -> ShowS
AlphaIndex -> String
(Int -> AlphaIndex -> ShowS)
-> (AlphaIndex -> String)
-> ([AlphaIndex] -> ShowS)
-> Show AlphaIndex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AlphaIndex -> ShowS
showsPrec :: Int -> AlphaIndex -> ShowS
$cshow :: AlphaIndex -> String
show :: AlphaIndex -> String
$cshowList :: [AlphaIndex] -> ShowS
showList :: [AlphaIndex] -> ShowS
C.Show, ReadPrec [AlphaIndex]
ReadPrec AlphaIndex
Int -> ReadS AlphaIndex
ReadS [AlphaIndex]
(Int -> ReadS AlphaIndex)
-> ReadS [AlphaIndex]
-> ReadPrec AlphaIndex
-> ReadPrec [AlphaIndex]
-> Read AlphaIndex
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AlphaIndex
readsPrec :: Int -> ReadS AlphaIndex
$creadList :: ReadS [AlphaIndex]
readList :: ReadS [AlphaIndex]
$creadPrec :: ReadPrec AlphaIndex
readPrec :: ReadPrec AlphaIndex
$creadListPrec :: ReadPrec [AlphaIndex]
readListPrec :: ReadPrec [AlphaIndex]
C.Read, Typeable AlphaIndex
Typeable AlphaIndex =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AlphaIndex -> c AlphaIndex)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AlphaIndex)
-> (AlphaIndex -> Constr)
-> (AlphaIndex -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AlphaIndex))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AlphaIndex))
-> ((forall b. Data b => b -> b) -> AlphaIndex -> AlphaIndex)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r)
-> (forall u. (forall d. Data d => d -> u) -> AlphaIndex -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AlphaIndex -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex)
-> Data AlphaIndex
AlphaIndex -> Constr
AlphaIndex -> DataType
(forall b. Data b => b -> b) -> AlphaIndex -> AlphaIndex
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) -> AlphaIndex -> u
forall u. (forall d. Data d => d -> u) -> AlphaIndex -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlphaIndex
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlphaIndex -> c AlphaIndex
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlphaIndex)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlphaIndex)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlphaIndex -> c AlphaIndex
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AlphaIndex -> c AlphaIndex
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlphaIndex
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AlphaIndex
$ctoConstr :: AlphaIndex -> Constr
toConstr :: AlphaIndex -> Constr
$cdataTypeOf :: AlphaIndex -> DataType
dataTypeOf :: AlphaIndex -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlphaIndex)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AlphaIndex)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlphaIndex)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AlphaIndex)
$cgmapT :: (forall b. Data b => b -> b) -> AlphaIndex -> AlphaIndex
gmapT :: (forall b. Data b => b -> b) -> AlphaIndex -> AlphaIndex
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AlphaIndex -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AlphaIndex -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AlphaIndex -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlphaIndex -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AlphaIndex -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AlphaIndex -> m AlphaIndex
C.Data, C.Typeable, (forall x. AlphaIndex -> Rep AlphaIndex x)
-> (forall x. Rep AlphaIndex x -> AlphaIndex) -> Generic AlphaIndex
forall x. Rep AlphaIndex x -> AlphaIndex
forall x. AlphaIndex -> Rep AlphaIndex x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AlphaIndex -> Rep AlphaIndex x
from :: forall x. AlphaIndex -> Rep AlphaIndex x
$cto :: forall x. Rep AlphaIndex x -> AlphaIndex
to :: forall x. Rep AlphaIndex x -> AlphaIndex
C.Generic, String -> AlphaIndex
(String -> AlphaIndex) -> IsString AlphaIndex
forall a. (String -> a) -> IsString a
$cfromString :: String -> AlphaIndex
fromString :: String -> AlphaIndex
Data.String.IsString)

newtype LabelMetaId = LabelMetaId String
  deriving (LabelMetaId -> LabelMetaId -> Bool
(LabelMetaId -> LabelMetaId -> Bool)
-> (LabelMetaId -> LabelMetaId -> Bool) -> Eq LabelMetaId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LabelMetaId -> LabelMetaId -> Bool
== :: LabelMetaId -> LabelMetaId -> Bool
$c/= :: LabelMetaId -> LabelMetaId -> Bool
/= :: LabelMetaId -> LabelMetaId -> Bool
C.Eq, Eq LabelMetaId
Eq LabelMetaId =>
(LabelMetaId -> LabelMetaId -> Ordering)
-> (LabelMetaId -> LabelMetaId -> Bool)
-> (LabelMetaId -> LabelMetaId -> Bool)
-> (LabelMetaId -> LabelMetaId -> Bool)
-> (LabelMetaId -> LabelMetaId -> Bool)
-> (LabelMetaId -> LabelMetaId -> LabelMetaId)
-> (LabelMetaId -> LabelMetaId -> LabelMetaId)
-> Ord LabelMetaId
LabelMetaId -> LabelMetaId -> Bool
LabelMetaId -> LabelMetaId -> Ordering
LabelMetaId -> LabelMetaId -> LabelMetaId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LabelMetaId -> LabelMetaId -> Ordering
compare :: LabelMetaId -> LabelMetaId -> Ordering
$c< :: LabelMetaId -> LabelMetaId -> Bool
< :: LabelMetaId -> LabelMetaId -> Bool
$c<= :: LabelMetaId -> LabelMetaId -> Bool
<= :: LabelMetaId -> LabelMetaId -> Bool
$c> :: LabelMetaId -> LabelMetaId -> Bool
> :: LabelMetaId -> LabelMetaId -> Bool
$c>= :: LabelMetaId -> LabelMetaId -> Bool
>= :: LabelMetaId -> LabelMetaId -> Bool
$cmax :: LabelMetaId -> LabelMetaId -> LabelMetaId
max :: LabelMetaId -> LabelMetaId -> LabelMetaId
$cmin :: LabelMetaId -> LabelMetaId -> LabelMetaId
min :: LabelMetaId -> LabelMetaId -> LabelMetaId
C.Ord, Int -> LabelMetaId -> ShowS
[LabelMetaId] -> ShowS
LabelMetaId -> String
(Int -> LabelMetaId -> ShowS)
-> (LabelMetaId -> String)
-> ([LabelMetaId] -> ShowS)
-> Show LabelMetaId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LabelMetaId -> ShowS
showsPrec :: Int -> LabelMetaId -> ShowS
$cshow :: LabelMetaId -> String
show :: LabelMetaId -> String
$cshowList :: [LabelMetaId] -> ShowS
showList :: [LabelMetaId] -> ShowS
C.Show, ReadPrec [LabelMetaId]
ReadPrec LabelMetaId
Int -> ReadS LabelMetaId
ReadS [LabelMetaId]
(Int -> ReadS LabelMetaId)
-> ReadS [LabelMetaId]
-> ReadPrec LabelMetaId
-> ReadPrec [LabelMetaId]
-> Read LabelMetaId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LabelMetaId
readsPrec :: Int -> ReadS LabelMetaId
$creadList :: ReadS [LabelMetaId]
readList :: ReadS [LabelMetaId]
$creadPrec :: ReadPrec LabelMetaId
readPrec :: ReadPrec LabelMetaId
$creadListPrec :: ReadPrec [LabelMetaId]
readListPrec :: ReadPrec [LabelMetaId]
C.Read, Typeable LabelMetaId
Typeable LabelMetaId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LabelMetaId -> c LabelMetaId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LabelMetaId)
-> (LabelMetaId -> Constr)
-> (LabelMetaId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LabelMetaId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LabelMetaId))
-> ((forall b. Data b => b -> b) -> LabelMetaId -> LabelMetaId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r)
-> (forall u. (forall d. Data d => d -> u) -> LabelMetaId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LabelMetaId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId)
-> Data LabelMetaId
LabelMetaId -> Constr
LabelMetaId -> DataType
(forall b. Data b => b -> b) -> LabelMetaId -> LabelMetaId
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) -> LabelMetaId -> u
forall u. (forall d. Data d => d -> u) -> LabelMetaId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LabelMetaId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LabelMetaId -> c LabelMetaId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LabelMetaId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LabelMetaId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LabelMetaId -> c LabelMetaId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LabelMetaId -> c LabelMetaId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LabelMetaId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LabelMetaId
$ctoConstr :: LabelMetaId -> Constr
toConstr :: LabelMetaId -> Constr
$cdataTypeOf :: LabelMetaId -> DataType
dataTypeOf :: LabelMetaId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LabelMetaId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LabelMetaId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LabelMetaId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LabelMetaId)
$cgmapT :: (forall b. Data b => b -> b) -> LabelMetaId -> LabelMetaId
gmapT :: (forall b. Data b => b -> b) -> LabelMetaId -> LabelMetaId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LabelMetaId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LabelMetaId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LabelMetaId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LabelMetaId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LabelMetaId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LabelMetaId -> m LabelMetaId
C.Data, C.Typeable, (forall x. LabelMetaId -> Rep LabelMetaId x)
-> (forall x. Rep LabelMetaId x -> LabelMetaId)
-> Generic LabelMetaId
forall x. Rep LabelMetaId x -> LabelMetaId
forall x. LabelMetaId -> Rep LabelMetaId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LabelMetaId -> Rep LabelMetaId x
from :: forall x. LabelMetaId -> Rep LabelMetaId x
$cto :: forall x. Rep LabelMetaId x -> LabelMetaId
to :: forall x. Rep LabelMetaId x -> LabelMetaId
C.Generic, String -> LabelMetaId
(String -> LabelMetaId) -> IsString LabelMetaId
forall a. (String -> a) -> IsString a
$cfromString :: String -> LabelMetaId
fromString :: String -> LabelMetaId
Data.String.IsString)

newtype TailMetaId = TailMetaId String
  deriving (TailMetaId -> TailMetaId -> Bool
(TailMetaId -> TailMetaId -> Bool)
-> (TailMetaId -> TailMetaId -> Bool) -> Eq TailMetaId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TailMetaId -> TailMetaId -> Bool
== :: TailMetaId -> TailMetaId -> Bool
$c/= :: TailMetaId -> TailMetaId -> Bool
/= :: TailMetaId -> TailMetaId -> Bool
C.Eq, Eq TailMetaId
Eq TailMetaId =>
(TailMetaId -> TailMetaId -> Ordering)
-> (TailMetaId -> TailMetaId -> Bool)
-> (TailMetaId -> TailMetaId -> Bool)
-> (TailMetaId -> TailMetaId -> Bool)
-> (TailMetaId -> TailMetaId -> Bool)
-> (TailMetaId -> TailMetaId -> TailMetaId)
-> (TailMetaId -> TailMetaId -> TailMetaId)
-> Ord TailMetaId
TailMetaId -> TailMetaId -> Bool
TailMetaId -> TailMetaId -> Ordering
TailMetaId -> TailMetaId -> TailMetaId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TailMetaId -> TailMetaId -> Ordering
compare :: TailMetaId -> TailMetaId -> Ordering
$c< :: TailMetaId -> TailMetaId -> Bool
< :: TailMetaId -> TailMetaId -> Bool
$c<= :: TailMetaId -> TailMetaId -> Bool
<= :: TailMetaId -> TailMetaId -> Bool
$c> :: TailMetaId -> TailMetaId -> Bool
> :: TailMetaId -> TailMetaId -> Bool
$c>= :: TailMetaId -> TailMetaId -> Bool
>= :: TailMetaId -> TailMetaId -> Bool
$cmax :: TailMetaId -> TailMetaId -> TailMetaId
max :: TailMetaId -> TailMetaId -> TailMetaId
$cmin :: TailMetaId -> TailMetaId -> TailMetaId
min :: TailMetaId -> TailMetaId -> TailMetaId
C.Ord, Int -> TailMetaId -> ShowS
[TailMetaId] -> ShowS
TailMetaId -> String
(Int -> TailMetaId -> ShowS)
-> (TailMetaId -> String)
-> ([TailMetaId] -> ShowS)
-> Show TailMetaId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TailMetaId -> ShowS
showsPrec :: Int -> TailMetaId -> ShowS
$cshow :: TailMetaId -> String
show :: TailMetaId -> String
$cshowList :: [TailMetaId] -> ShowS
showList :: [TailMetaId] -> ShowS
C.Show, ReadPrec [TailMetaId]
ReadPrec TailMetaId
Int -> ReadS TailMetaId
ReadS [TailMetaId]
(Int -> ReadS TailMetaId)
-> ReadS [TailMetaId]
-> ReadPrec TailMetaId
-> ReadPrec [TailMetaId]
-> Read TailMetaId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TailMetaId
readsPrec :: Int -> ReadS TailMetaId
$creadList :: ReadS [TailMetaId]
readList :: ReadS [TailMetaId]
$creadPrec :: ReadPrec TailMetaId
readPrec :: ReadPrec TailMetaId
$creadListPrec :: ReadPrec [TailMetaId]
readListPrec :: ReadPrec [TailMetaId]
C.Read, Typeable TailMetaId
Typeable TailMetaId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TailMetaId -> c TailMetaId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TailMetaId)
-> (TailMetaId -> Constr)
-> (TailMetaId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TailMetaId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TailMetaId))
-> ((forall b. Data b => b -> b) -> TailMetaId -> TailMetaId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TailMetaId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TailMetaId -> r)
-> (forall u. (forall d. Data d => d -> u) -> TailMetaId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TailMetaId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId)
-> Data TailMetaId
TailMetaId -> Constr
TailMetaId -> DataType
(forall b. Data b => b -> b) -> TailMetaId -> TailMetaId
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) -> TailMetaId -> u
forall u. (forall d. Data d => d -> u) -> TailMetaId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TailMetaId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TailMetaId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailMetaId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailMetaId -> c TailMetaId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TailMetaId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TailMetaId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailMetaId -> c TailMetaId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TailMetaId -> c TailMetaId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailMetaId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TailMetaId
$ctoConstr :: TailMetaId -> Constr
toConstr :: TailMetaId -> Constr
$cdataTypeOf :: TailMetaId -> DataType
dataTypeOf :: TailMetaId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TailMetaId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TailMetaId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TailMetaId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TailMetaId)
$cgmapT :: (forall b. Data b => b -> b) -> TailMetaId -> TailMetaId
gmapT :: (forall b. Data b => b -> b) -> TailMetaId -> TailMetaId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TailMetaId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TailMetaId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TailMetaId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TailMetaId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TailMetaId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TailMetaId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TailMetaId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TailMetaId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TailMetaId -> m TailMetaId
C.Data, C.Typeable, (forall x. TailMetaId -> Rep TailMetaId x)
-> (forall x. Rep TailMetaId x -> TailMetaId) -> Generic TailMetaId
forall x. Rep TailMetaId x -> TailMetaId
forall x. TailMetaId -> Rep TailMetaId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TailMetaId -> Rep TailMetaId x
from :: forall x. TailMetaId -> Rep TailMetaId x
$cto :: forall x. Rep TailMetaId x -> TailMetaId
to :: forall x. Rep TailMetaId x -> TailMetaId
C.Generic, String -> TailMetaId
(String -> TailMetaId) -> IsString TailMetaId
forall a. (String -> a) -> IsString a
$cfromString :: String -> TailMetaId
fromString :: String -> TailMetaId
Data.String.IsString)

newtype BindingsMetaId = BindingsMetaId String
  deriving (BindingsMetaId -> BindingsMetaId -> Bool
(BindingsMetaId -> BindingsMetaId -> Bool)
-> (BindingsMetaId -> BindingsMetaId -> Bool) -> Eq BindingsMetaId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BindingsMetaId -> BindingsMetaId -> Bool
== :: BindingsMetaId -> BindingsMetaId -> Bool
$c/= :: BindingsMetaId -> BindingsMetaId -> Bool
/= :: BindingsMetaId -> BindingsMetaId -> Bool
C.Eq, Eq BindingsMetaId
Eq BindingsMetaId =>
(BindingsMetaId -> BindingsMetaId -> Ordering)
-> (BindingsMetaId -> BindingsMetaId -> Bool)
-> (BindingsMetaId -> BindingsMetaId -> Bool)
-> (BindingsMetaId -> BindingsMetaId -> Bool)
-> (BindingsMetaId -> BindingsMetaId -> Bool)
-> (BindingsMetaId -> BindingsMetaId -> BindingsMetaId)
-> (BindingsMetaId -> BindingsMetaId -> BindingsMetaId)
-> Ord BindingsMetaId
BindingsMetaId -> BindingsMetaId -> Bool
BindingsMetaId -> BindingsMetaId -> Ordering
BindingsMetaId -> BindingsMetaId -> BindingsMetaId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BindingsMetaId -> BindingsMetaId -> Ordering
compare :: BindingsMetaId -> BindingsMetaId -> Ordering
$c< :: BindingsMetaId -> BindingsMetaId -> Bool
< :: BindingsMetaId -> BindingsMetaId -> Bool
$c<= :: BindingsMetaId -> BindingsMetaId -> Bool
<= :: BindingsMetaId -> BindingsMetaId -> Bool
$c> :: BindingsMetaId -> BindingsMetaId -> Bool
> :: BindingsMetaId -> BindingsMetaId -> Bool
$c>= :: BindingsMetaId -> BindingsMetaId -> Bool
>= :: BindingsMetaId -> BindingsMetaId -> Bool
$cmax :: BindingsMetaId -> BindingsMetaId -> BindingsMetaId
max :: BindingsMetaId -> BindingsMetaId -> BindingsMetaId
$cmin :: BindingsMetaId -> BindingsMetaId -> BindingsMetaId
min :: BindingsMetaId -> BindingsMetaId -> BindingsMetaId
C.Ord, Int -> BindingsMetaId -> ShowS
[BindingsMetaId] -> ShowS
BindingsMetaId -> String
(Int -> BindingsMetaId -> ShowS)
-> (BindingsMetaId -> String)
-> ([BindingsMetaId] -> ShowS)
-> Show BindingsMetaId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BindingsMetaId -> ShowS
showsPrec :: Int -> BindingsMetaId -> ShowS
$cshow :: BindingsMetaId -> String
show :: BindingsMetaId -> String
$cshowList :: [BindingsMetaId] -> ShowS
showList :: [BindingsMetaId] -> ShowS
C.Show, ReadPrec [BindingsMetaId]
ReadPrec BindingsMetaId
Int -> ReadS BindingsMetaId
ReadS [BindingsMetaId]
(Int -> ReadS BindingsMetaId)
-> ReadS [BindingsMetaId]
-> ReadPrec BindingsMetaId
-> ReadPrec [BindingsMetaId]
-> Read BindingsMetaId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BindingsMetaId
readsPrec :: Int -> ReadS BindingsMetaId
$creadList :: ReadS [BindingsMetaId]
readList :: ReadS [BindingsMetaId]
$creadPrec :: ReadPrec BindingsMetaId
readPrec :: ReadPrec BindingsMetaId
$creadListPrec :: ReadPrec [BindingsMetaId]
readListPrec :: ReadPrec [BindingsMetaId]
C.Read, Typeable BindingsMetaId
Typeable BindingsMetaId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BindingsMetaId -> c BindingsMetaId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BindingsMetaId)
-> (BindingsMetaId -> Constr)
-> (BindingsMetaId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BindingsMetaId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BindingsMetaId))
-> ((forall b. Data b => b -> b)
    -> BindingsMetaId -> BindingsMetaId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BindingsMetaId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BindingsMetaId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BindingsMetaId -> m BindingsMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BindingsMetaId -> m BindingsMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BindingsMetaId -> m BindingsMetaId)
-> Data BindingsMetaId
BindingsMetaId -> Constr
BindingsMetaId -> DataType
(forall b. Data b => b -> b) -> BindingsMetaId -> BindingsMetaId
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) -> BindingsMetaId -> u
forall u. (forall d. Data d => d -> u) -> BindingsMetaId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BindingsMetaId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BindingsMetaId -> c BindingsMetaId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BindingsMetaId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BindingsMetaId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BindingsMetaId -> c BindingsMetaId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BindingsMetaId -> c BindingsMetaId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BindingsMetaId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BindingsMetaId
$ctoConstr :: BindingsMetaId -> Constr
toConstr :: BindingsMetaId -> Constr
$cdataTypeOf :: BindingsMetaId -> DataType
dataTypeOf :: BindingsMetaId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BindingsMetaId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BindingsMetaId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BindingsMetaId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BindingsMetaId)
$cgmapT :: (forall b. Data b => b -> b) -> BindingsMetaId -> BindingsMetaId
gmapT :: (forall b. Data b => b -> b) -> BindingsMetaId -> BindingsMetaId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BindingsMetaId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BindingsMetaId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BindingsMetaId -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BindingsMetaId -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BindingsMetaId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BindingsMetaId -> m BindingsMetaId
C.Data, C.Typeable, (forall x. BindingsMetaId -> Rep BindingsMetaId x)
-> (forall x. Rep BindingsMetaId x -> BindingsMetaId)
-> Generic BindingsMetaId
forall x. Rep BindingsMetaId x -> BindingsMetaId
forall x. BindingsMetaId -> Rep BindingsMetaId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BindingsMetaId -> Rep BindingsMetaId x
from :: forall x. BindingsMetaId -> Rep BindingsMetaId x
$cto :: forall x. Rep BindingsMetaId x -> BindingsMetaId
to :: forall x. Rep BindingsMetaId x -> BindingsMetaId
C.Generic, String -> BindingsMetaId
(String -> BindingsMetaId) -> IsString BindingsMetaId
forall a. (String -> a) -> IsString a
$cfromString :: String -> BindingsMetaId
fromString :: String -> BindingsMetaId
Data.String.IsString)

newtype ObjectMetaId = ObjectMetaId String
  deriving (ObjectMetaId -> ObjectMetaId -> Bool
(ObjectMetaId -> ObjectMetaId -> Bool)
-> (ObjectMetaId -> ObjectMetaId -> Bool) -> Eq ObjectMetaId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectMetaId -> ObjectMetaId -> Bool
== :: ObjectMetaId -> ObjectMetaId -> Bool
$c/= :: ObjectMetaId -> ObjectMetaId -> Bool
/= :: ObjectMetaId -> ObjectMetaId -> Bool
C.Eq, Eq ObjectMetaId
Eq ObjectMetaId =>
(ObjectMetaId -> ObjectMetaId -> Ordering)
-> (ObjectMetaId -> ObjectMetaId -> Bool)
-> (ObjectMetaId -> ObjectMetaId -> Bool)
-> (ObjectMetaId -> ObjectMetaId -> Bool)
-> (ObjectMetaId -> ObjectMetaId -> Bool)
-> (ObjectMetaId -> ObjectMetaId -> ObjectMetaId)
-> (ObjectMetaId -> ObjectMetaId -> ObjectMetaId)
-> Ord ObjectMetaId
ObjectMetaId -> ObjectMetaId -> Bool
ObjectMetaId -> ObjectMetaId -> Ordering
ObjectMetaId -> ObjectMetaId -> ObjectMetaId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ObjectMetaId -> ObjectMetaId -> Ordering
compare :: ObjectMetaId -> ObjectMetaId -> Ordering
$c< :: ObjectMetaId -> ObjectMetaId -> Bool
< :: ObjectMetaId -> ObjectMetaId -> Bool
$c<= :: ObjectMetaId -> ObjectMetaId -> Bool
<= :: ObjectMetaId -> ObjectMetaId -> Bool
$c> :: ObjectMetaId -> ObjectMetaId -> Bool
> :: ObjectMetaId -> ObjectMetaId -> Bool
$c>= :: ObjectMetaId -> ObjectMetaId -> Bool
>= :: ObjectMetaId -> ObjectMetaId -> Bool
$cmax :: ObjectMetaId -> ObjectMetaId -> ObjectMetaId
max :: ObjectMetaId -> ObjectMetaId -> ObjectMetaId
$cmin :: ObjectMetaId -> ObjectMetaId -> ObjectMetaId
min :: ObjectMetaId -> ObjectMetaId -> ObjectMetaId
C.Ord, Int -> ObjectMetaId -> ShowS
[ObjectMetaId] -> ShowS
ObjectMetaId -> String
(Int -> ObjectMetaId -> ShowS)
-> (ObjectMetaId -> String)
-> ([ObjectMetaId] -> ShowS)
-> Show ObjectMetaId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ObjectMetaId -> ShowS
showsPrec :: Int -> ObjectMetaId -> ShowS
$cshow :: ObjectMetaId -> String
show :: ObjectMetaId -> String
$cshowList :: [ObjectMetaId] -> ShowS
showList :: [ObjectMetaId] -> ShowS
C.Show, ReadPrec [ObjectMetaId]
ReadPrec ObjectMetaId
Int -> ReadS ObjectMetaId
ReadS [ObjectMetaId]
(Int -> ReadS ObjectMetaId)
-> ReadS [ObjectMetaId]
-> ReadPrec ObjectMetaId
-> ReadPrec [ObjectMetaId]
-> Read ObjectMetaId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ObjectMetaId
readsPrec :: Int -> ReadS ObjectMetaId
$creadList :: ReadS [ObjectMetaId]
readList :: ReadS [ObjectMetaId]
$creadPrec :: ReadPrec ObjectMetaId
readPrec :: ReadPrec ObjectMetaId
$creadListPrec :: ReadPrec [ObjectMetaId]
readListPrec :: ReadPrec [ObjectMetaId]
C.Read, Typeable ObjectMetaId
Typeable ObjectMetaId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ObjectMetaId -> c ObjectMetaId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ObjectMetaId)
-> (ObjectMetaId -> Constr)
-> (ObjectMetaId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ObjectMetaId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ObjectMetaId))
-> ((forall b. Data b => b -> b) -> ObjectMetaId -> ObjectMetaId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r)
-> (forall u. (forall d. Data d => d -> u) -> ObjectMetaId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ObjectMetaId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId)
-> Data ObjectMetaId
ObjectMetaId -> Constr
ObjectMetaId -> DataType
(forall b. Data b => b -> b) -> ObjectMetaId -> ObjectMetaId
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) -> ObjectMetaId -> u
forall u. (forall d. Data d => d -> u) -> ObjectMetaId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectMetaId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectMetaId -> c ObjectMetaId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectMetaId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectMetaId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectMetaId -> c ObjectMetaId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ObjectMetaId -> c ObjectMetaId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectMetaId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ObjectMetaId
$ctoConstr :: ObjectMetaId -> Constr
toConstr :: ObjectMetaId -> Constr
$cdataTypeOf :: ObjectMetaId -> DataType
dataTypeOf :: ObjectMetaId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectMetaId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ObjectMetaId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectMetaId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ObjectMetaId)
$cgmapT :: (forall b. Data b => b -> b) -> ObjectMetaId -> ObjectMetaId
gmapT :: (forall b. Data b => b -> b) -> ObjectMetaId -> ObjectMetaId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ObjectMetaId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectMetaId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ObjectMetaId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectMetaId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ObjectMetaId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ObjectMetaId -> m ObjectMetaId
C.Data, C.Typeable, (forall x. ObjectMetaId -> Rep ObjectMetaId x)
-> (forall x. Rep ObjectMetaId x -> ObjectMetaId)
-> Generic ObjectMetaId
forall x. Rep ObjectMetaId x -> ObjectMetaId
forall x. ObjectMetaId -> Rep ObjectMetaId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ObjectMetaId -> Rep ObjectMetaId x
from :: forall x. ObjectMetaId -> Rep ObjectMetaId x
$cto :: forall x. Rep ObjectMetaId x -> ObjectMetaId
to :: forall x. Rep ObjectMetaId x -> ObjectMetaId
C.Generic, String -> ObjectMetaId
(String -> ObjectMetaId) -> IsString ObjectMetaId
forall a. (String -> a) -> IsString a
$cfromString :: String -> ObjectMetaId
fromString :: String -> ObjectMetaId
Data.String.IsString)

newtype BytesMetaId = BytesMetaId String
  deriving (BytesMetaId -> BytesMetaId -> Bool
(BytesMetaId -> BytesMetaId -> Bool)
-> (BytesMetaId -> BytesMetaId -> Bool) -> Eq BytesMetaId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BytesMetaId -> BytesMetaId -> Bool
== :: BytesMetaId -> BytesMetaId -> Bool
$c/= :: BytesMetaId -> BytesMetaId -> Bool
/= :: BytesMetaId -> BytesMetaId -> Bool
C.Eq, Eq BytesMetaId
Eq BytesMetaId =>
(BytesMetaId -> BytesMetaId -> Ordering)
-> (BytesMetaId -> BytesMetaId -> Bool)
-> (BytesMetaId -> BytesMetaId -> Bool)
-> (BytesMetaId -> BytesMetaId -> Bool)
-> (BytesMetaId -> BytesMetaId -> Bool)
-> (BytesMetaId -> BytesMetaId -> BytesMetaId)
-> (BytesMetaId -> BytesMetaId -> BytesMetaId)
-> Ord BytesMetaId
BytesMetaId -> BytesMetaId -> Bool
BytesMetaId -> BytesMetaId -> Ordering
BytesMetaId -> BytesMetaId -> BytesMetaId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BytesMetaId -> BytesMetaId -> Ordering
compare :: BytesMetaId -> BytesMetaId -> Ordering
$c< :: BytesMetaId -> BytesMetaId -> Bool
< :: BytesMetaId -> BytesMetaId -> Bool
$c<= :: BytesMetaId -> BytesMetaId -> Bool
<= :: BytesMetaId -> BytesMetaId -> Bool
$c> :: BytesMetaId -> BytesMetaId -> Bool
> :: BytesMetaId -> BytesMetaId -> Bool
$c>= :: BytesMetaId -> BytesMetaId -> Bool
>= :: BytesMetaId -> BytesMetaId -> Bool
$cmax :: BytesMetaId -> BytesMetaId -> BytesMetaId
max :: BytesMetaId -> BytesMetaId -> BytesMetaId
$cmin :: BytesMetaId -> BytesMetaId -> BytesMetaId
min :: BytesMetaId -> BytesMetaId -> BytesMetaId
C.Ord, Int -> BytesMetaId -> ShowS
[BytesMetaId] -> ShowS
BytesMetaId -> String
(Int -> BytesMetaId -> ShowS)
-> (BytesMetaId -> String)
-> ([BytesMetaId] -> ShowS)
-> Show BytesMetaId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BytesMetaId -> ShowS
showsPrec :: Int -> BytesMetaId -> ShowS
$cshow :: BytesMetaId -> String
show :: BytesMetaId -> String
$cshowList :: [BytesMetaId] -> ShowS
showList :: [BytesMetaId] -> ShowS
C.Show, ReadPrec [BytesMetaId]
ReadPrec BytesMetaId
Int -> ReadS BytesMetaId
ReadS [BytesMetaId]
(Int -> ReadS BytesMetaId)
-> ReadS [BytesMetaId]
-> ReadPrec BytesMetaId
-> ReadPrec [BytesMetaId]
-> Read BytesMetaId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BytesMetaId
readsPrec :: Int -> ReadS BytesMetaId
$creadList :: ReadS [BytesMetaId]
readList :: ReadS [BytesMetaId]
$creadPrec :: ReadPrec BytesMetaId
readPrec :: ReadPrec BytesMetaId
$creadListPrec :: ReadPrec [BytesMetaId]
readListPrec :: ReadPrec [BytesMetaId]
C.Read, Typeable BytesMetaId
Typeable BytesMetaId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BytesMetaId -> c BytesMetaId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BytesMetaId)
-> (BytesMetaId -> Constr)
-> (BytesMetaId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BytesMetaId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BytesMetaId))
-> ((forall b. Data b => b -> b) -> BytesMetaId -> BytesMetaId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r)
-> (forall u. (forall d. Data d => d -> u) -> BytesMetaId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BytesMetaId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId)
-> Data BytesMetaId
BytesMetaId -> Constr
BytesMetaId -> DataType
(forall b. Data b => b -> b) -> BytesMetaId -> BytesMetaId
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) -> BytesMetaId -> u
forall u. (forall d. Data d => d -> u) -> BytesMetaId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BytesMetaId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BytesMetaId -> c BytesMetaId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BytesMetaId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BytesMetaId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BytesMetaId -> c BytesMetaId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BytesMetaId -> c BytesMetaId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BytesMetaId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BytesMetaId
$ctoConstr :: BytesMetaId -> Constr
toConstr :: BytesMetaId -> Constr
$cdataTypeOf :: BytesMetaId -> DataType
dataTypeOf :: BytesMetaId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BytesMetaId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BytesMetaId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BytesMetaId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BytesMetaId)
$cgmapT :: (forall b. Data b => b -> b) -> BytesMetaId -> BytesMetaId
gmapT :: (forall b. Data b => b -> b) -> BytesMetaId -> BytesMetaId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BytesMetaId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BytesMetaId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BytesMetaId -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BytesMetaId -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BytesMetaId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesMetaId -> m BytesMetaId
C.Data, C.Typeable, (forall x. BytesMetaId -> Rep BytesMetaId x)
-> (forall x. Rep BytesMetaId x -> BytesMetaId)
-> Generic BytesMetaId
forall x. Rep BytesMetaId x -> BytesMetaId
forall x. BytesMetaId -> Rep BytesMetaId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BytesMetaId -> Rep BytesMetaId x
from :: forall x. BytesMetaId -> Rep BytesMetaId x
$cto :: forall x. Rep BytesMetaId x -> BytesMetaId
to :: forall x. Rep BytesMetaId x -> BytesMetaId
C.Generic, String -> BytesMetaId
(String -> BytesMetaId) -> IsString BytesMetaId
forall a. (String -> a) -> IsString a
$cfromString :: String -> BytesMetaId
fromString :: String -> BytesMetaId
Data.String.IsString)

newtype MetaFunctionName = MetaFunctionName String
  deriving (MetaFunctionName -> MetaFunctionName -> Bool
(MetaFunctionName -> MetaFunctionName -> Bool)
-> (MetaFunctionName -> MetaFunctionName -> Bool)
-> Eq MetaFunctionName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MetaFunctionName -> MetaFunctionName -> Bool
== :: MetaFunctionName -> MetaFunctionName -> Bool
$c/= :: MetaFunctionName -> MetaFunctionName -> Bool
/= :: MetaFunctionName -> MetaFunctionName -> Bool
C.Eq, Eq MetaFunctionName
Eq MetaFunctionName =>
(MetaFunctionName -> MetaFunctionName -> Ordering)
-> (MetaFunctionName -> MetaFunctionName -> Bool)
-> (MetaFunctionName -> MetaFunctionName -> Bool)
-> (MetaFunctionName -> MetaFunctionName -> Bool)
-> (MetaFunctionName -> MetaFunctionName -> Bool)
-> (MetaFunctionName -> MetaFunctionName -> MetaFunctionName)
-> (MetaFunctionName -> MetaFunctionName -> MetaFunctionName)
-> Ord MetaFunctionName
MetaFunctionName -> MetaFunctionName -> Bool
MetaFunctionName -> MetaFunctionName -> Ordering
MetaFunctionName -> MetaFunctionName -> MetaFunctionName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MetaFunctionName -> MetaFunctionName -> Ordering
compare :: MetaFunctionName -> MetaFunctionName -> Ordering
$c< :: MetaFunctionName -> MetaFunctionName -> Bool
< :: MetaFunctionName -> MetaFunctionName -> Bool
$c<= :: MetaFunctionName -> MetaFunctionName -> Bool
<= :: MetaFunctionName -> MetaFunctionName -> Bool
$c> :: MetaFunctionName -> MetaFunctionName -> Bool
> :: MetaFunctionName -> MetaFunctionName -> Bool
$c>= :: MetaFunctionName -> MetaFunctionName -> Bool
>= :: MetaFunctionName -> MetaFunctionName -> Bool
$cmax :: MetaFunctionName -> MetaFunctionName -> MetaFunctionName
max :: MetaFunctionName -> MetaFunctionName -> MetaFunctionName
$cmin :: MetaFunctionName -> MetaFunctionName -> MetaFunctionName
min :: MetaFunctionName -> MetaFunctionName -> MetaFunctionName
C.Ord, Int -> MetaFunctionName -> ShowS
[MetaFunctionName] -> ShowS
MetaFunctionName -> String
(Int -> MetaFunctionName -> ShowS)
-> (MetaFunctionName -> String)
-> ([MetaFunctionName] -> ShowS)
-> Show MetaFunctionName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MetaFunctionName -> ShowS
showsPrec :: Int -> MetaFunctionName -> ShowS
$cshow :: MetaFunctionName -> String
show :: MetaFunctionName -> String
$cshowList :: [MetaFunctionName] -> ShowS
showList :: [MetaFunctionName] -> ShowS
C.Show, ReadPrec [MetaFunctionName]
ReadPrec MetaFunctionName
Int -> ReadS MetaFunctionName
ReadS [MetaFunctionName]
(Int -> ReadS MetaFunctionName)
-> ReadS [MetaFunctionName]
-> ReadPrec MetaFunctionName
-> ReadPrec [MetaFunctionName]
-> Read MetaFunctionName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MetaFunctionName
readsPrec :: Int -> ReadS MetaFunctionName
$creadList :: ReadS [MetaFunctionName]
readList :: ReadS [MetaFunctionName]
$creadPrec :: ReadPrec MetaFunctionName
readPrec :: ReadPrec MetaFunctionName
$creadListPrec :: ReadPrec [MetaFunctionName]
readListPrec :: ReadPrec [MetaFunctionName]
C.Read, Typeable MetaFunctionName
Typeable MetaFunctionName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MetaFunctionName -> c MetaFunctionName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetaFunctionName)
-> (MetaFunctionName -> Constr)
-> (MetaFunctionName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetaFunctionName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MetaFunctionName))
-> ((forall b. Data b => b -> b)
    -> MetaFunctionName -> MetaFunctionName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MetaFunctionName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MetaFunctionName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MetaFunctionName -> m MetaFunctionName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MetaFunctionName -> m MetaFunctionName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MetaFunctionName -> m MetaFunctionName)
-> Data MetaFunctionName
MetaFunctionName -> Constr
MetaFunctionName -> DataType
(forall b. Data b => b -> b)
-> MetaFunctionName -> MetaFunctionName
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) -> MetaFunctionName -> u
forall u. (forall d. Data d => d -> u) -> MetaFunctionName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetaFunctionName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetaFunctionName -> c MetaFunctionName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetaFunctionName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetaFunctionName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetaFunctionName -> c MetaFunctionName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetaFunctionName -> c MetaFunctionName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetaFunctionName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetaFunctionName
$ctoConstr :: MetaFunctionName -> Constr
toConstr :: MetaFunctionName -> Constr
$cdataTypeOf :: MetaFunctionName -> DataType
dataTypeOf :: MetaFunctionName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetaFunctionName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetaFunctionName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetaFunctionName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetaFunctionName)
$cgmapT :: (forall b. Data b => b -> b)
-> MetaFunctionName -> MetaFunctionName
gmapT :: (forall b. Data b => b -> b)
-> MetaFunctionName -> MetaFunctionName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetaFunctionName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MetaFunctionName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MetaFunctionName -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MetaFunctionName -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MetaFunctionName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetaFunctionName -> m MetaFunctionName
C.Data, C.Typeable, (forall x. MetaFunctionName -> Rep MetaFunctionName x)
-> (forall x. Rep MetaFunctionName x -> MetaFunctionName)
-> Generic MetaFunctionName
forall x. Rep MetaFunctionName x -> MetaFunctionName
forall x. MetaFunctionName -> Rep MetaFunctionName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MetaFunctionName -> Rep MetaFunctionName x
from :: forall x. MetaFunctionName -> Rep MetaFunctionName x
$cto :: forall x. Rep MetaFunctionName x -> MetaFunctionName
to :: forall x. Rep MetaFunctionName x -> MetaFunctionName
C.Generic, String -> MetaFunctionName
(String -> MetaFunctionName) -> IsString MetaFunctionName
forall a. (String -> a) -> IsString a
$cfromString :: String -> MetaFunctionName
fromString :: String -> MetaFunctionName
Data.String.IsString)