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

{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternSynonyms #-}

-- | The abstract syntax of language Syntax.

module Language.Rzk.Syntax.Abs where

import Prelude (String)
import qualified Prelude as C
  ( Eq, Ord, Show, Read
  , Functor, Foldable, Traversable
  , Int, Maybe(..)
  )
import qualified Data.String

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

type Module = Module' BNFC'Position
data Module' a = Module a (LanguageDecl' a) [Command' a]
  deriving (Module' a -> Module' a -> Bool
forall a. Eq a => Module' a -> Module' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Module' a -> Module' a -> Bool
$c/= :: forall a. Eq a => Module' a -> Module' a -> Bool
== :: Module' a -> Module' a -> Bool
$c== :: forall a. Eq a => Module' a -> Module' a -> Bool
C.Eq, Module' a -> Module' a -> Bool
Module' a -> Module' a -> Ordering
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
forall {a}. Ord a => Eq (Module' a)
forall a. Ord a => Module' a -> Module' a -> Bool
forall a. Ord a => Module' a -> Module' a -> Ordering
forall a. Ord a => Module' a -> Module' a -> Module' a
min :: Module' a -> Module' a -> Module' a
$cmin :: forall a. Ord a => Module' a -> Module' a -> Module' a
max :: Module' a -> Module' a -> Module' a
$cmax :: forall a. Ord a => Module' a -> Module' a -> Module' a
>= :: Module' a -> Module' a -> Bool
$c>= :: forall a. Ord a => Module' a -> Module' a -> Bool
> :: Module' a -> Module' a -> Bool
$c> :: forall a. Ord a => Module' a -> Module' a -> Bool
<= :: Module' a -> Module' a -> Bool
$c<= :: forall a. Ord a => Module' a -> Module' a -> Bool
< :: Module' a -> Module' a -> Bool
$c< :: forall a. Ord a => Module' a -> Module' a -> Bool
compare :: Module' a -> Module' a -> Ordering
$ccompare :: forall a. Ord a => Module' a -> Module' a -> Ordering
C.Ord, Int -> Module' a -> ShowS
forall a. Show a => Int -> Module' a -> ShowS
forall a. Show a => [Module' a] -> ShowS
forall a. Show a => Module' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Module' a] -> ShowS
$cshowList :: forall a. Show a => [Module' a] -> ShowS
show :: Module' a -> String
$cshow :: forall a. Show a => Module' a -> String
showsPrec :: Int -> Module' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Module' a -> ShowS
C.Show, ReadPrec [Module' a]
ReadPrec (Module' a)
ReadS [Module' a]
forall a. Read a => ReadPrec [Module' a]
forall a. Read a => ReadPrec (Module' a)
forall a. Read a => Int -> ReadS (Module' a)
forall a. Read a => ReadS [Module' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Module' a]
$creadListPrec :: forall a. Read a => ReadPrec [Module' a]
readPrec :: ReadPrec (Module' a)
$creadPrec :: forall a. Read a => ReadPrec (Module' a)
readList :: ReadS [Module' a]
$creadList :: forall a. Read a => ReadS [Module' a]
readsPrec :: Int -> ReadS (Module' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Module' a)
C.Read, forall a b. a -> Module' b -> Module' a
forall a b. (a -> b) -> Module' a -> Module' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Module' b -> Module' a
$c<$ :: forall a b. a -> Module' b -> Module' a
fmap :: forall a b. (a -> b) -> Module' a -> Module' b
$cfmap :: forall a b. (a -> b) -> Module' a -> Module' b
C.Functor, forall a. Eq a => a -> Module' a -> Bool
forall a. Num a => Module' a -> a
forall a. Ord a => Module' a -> a
forall m. Monoid m => Module' m -> m
forall a. Module' a -> Bool
forall a. Module' a -> Int
forall a. Module' a -> [a]
forall a. (a -> a -> a) -> Module' a -> a
forall m a. Monoid m => (a -> m) -> Module' a -> m
forall b a. (b -> a -> b) -> b -> Module' a -> b
forall a b. (a -> b -> b) -> b -> Module' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Module' a -> a
$cproduct :: forall a. Num a => Module' a -> a
sum :: forall a. Num a => Module' a -> a
$csum :: forall a. Num a => Module' a -> a
minimum :: forall a. Ord a => Module' a -> a
$cminimum :: forall a. Ord a => Module' a -> a
maximum :: forall a. Ord a => Module' a -> a
$cmaximum :: forall a. Ord a => Module' a -> a
elem :: forall a. Eq a => a -> Module' a -> Bool
$celem :: forall a. Eq a => a -> Module' a -> Bool
length :: forall a. Module' a -> Int
$clength :: forall a. Module' a -> Int
null :: forall a. Module' a -> Bool
$cnull :: forall a. Module' a -> Bool
toList :: forall a. Module' a -> [a]
$ctoList :: forall a. Module' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Module' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Module' a -> a
foldr1 :: forall a. (a -> a -> a) -> Module' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Module' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Module' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Module' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Module' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Module' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Module' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Module' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Module' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Module' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Module' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Module' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Module' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Module' a -> m
fold :: forall m. Monoid m => Module' m -> m
$cfold :: forall m. Monoid m => Module' m -> m
C.Foldable, Functor Module'
Foldable Module'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Module' (m a) -> m (Module' a)
forall (f :: * -> *) a.
Applicative f =>
Module' (f a) -> f (Module' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module' a -> m (Module' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module' a -> f (Module' b)
sequence :: forall (m :: * -> *) a. Monad m => Module' (m a) -> m (Module' a)
$csequence :: forall (m :: * -> *) a. Monad m => Module' (m a) -> m (Module' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module' a -> m (Module' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module' a -> m (Module' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Module' (f a) -> f (Module' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Module' (f a) -> f (Module' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module' a -> f (Module' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module' a -> f (Module' b)
C.Traversable, Module' a -> DataType
Module' a -> Constr
forall {a}. Data a => Typeable (Module' a)
forall a. Data a => Module' a -> DataType
forall a. Data a => Module' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Module' a -> Module' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Module' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Module' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module' a -> c (Module' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Module' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Module' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module' a -> c (Module' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Module' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Module' a -> m (Module' a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Module' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Module' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Module' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Module' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Module' a -> r
gmapT :: (forall b. Data b => b -> b) -> Module' a -> Module' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Module' a -> Module' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Module' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Module' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Module' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Module' a))
dataTypeOf :: Module' a -> DataType
$cdataTypeOf :: forall a. Data a => Module' a -> DataType
toConstr :: Module' a -> Constr
$ctoConstr :: forall a. Data a => Module' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Module' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module' a -> c (Module' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module' a -> c (Module' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Module' a) x -> Module' a
forall a x. Module' a -> Rep (Module' a) x
$cto :: forall a x. Rep (Module' a) x -> Module' a
$cfrom :: forall a x. Module' a -> Rep (Module' a) x
C.Generic)

type LanguageDecl = LanguageDecl' BNFC'Position
data LanguageDecl' a = LanguageDecl a (Language' a)
  deriving (LanguageDecl' a -> LanguageDecl' a -> Bool
forall a. Eq a => LanguageDecl' a -> LanguageDecl' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LanguageDecl' a -> LanguageDecl' a -> Bool
$c/= :: forall a. Eq a => LanguageDecl' a -> LanguageDecl' a -> Bool
== :: LanguageDecl' a -> LanguageDecl' a -> Bool
$c== :: forall a. Eq a => LanguageDecl' a -> LanguageDecl' a -> Bool
C.Eq, LanguageDecl' a -> LanguageDecl' a -> Bool
LanguageDecl' a -> LanguageDecl' a -> Ordering
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
forall {a}. Ord a => Eq (LanguageDecl' a)
forall a. Ord a => LanguageDecl' a -> LanguageDecl' a -> Bool
forall a. Ord a => LanguageDecl' a -> LanguageDecl' a -> Ordering
forall a.
Ord a =>
LanguageDecl' a -> LanguageDecl' a -> LanguageDecl' a
min :: LanguageDecl' a -> LanguageDecl' a -> LanguageDecl' a
$cmin :: forall a.
Ord a =>
LanguageDecl' a -> LanguageDecl' a -> LanguageDecl' a
max :: LanguageDecl' a -> LanguageDecl' a -> LanguageDecl' a
$cmax :: forall a.
Ord a =>
LanguageDecl' a -> LanguageDecl' a -> LanguageDecl' a
>= :: LanguageDecl' a -> LanguageDecl' a -> Bool
$c>= :: forall a. Ord a => LanguageDecl' a -> LanguageDecl' a -> Bool
> :: LanguageDecl' a -> LanguageDecl' a -> Bool
$c> :: forall a. Ord a => LanguageDecl' a -> LanguageDecl' a -> Bool
<= :: LanguageDecl' a -> LanguageDecl' a -> Bool
$c<= :: forall a. Ord a => LanguageDecl' a -> LanguageDecl' a -> Bool
< :: LanguageDecl' a -> LanguageDecl' a -> Bool
$c< :: forall a. Ord a => LanguageDecl' a -> LanguageDecl' a -> Bool
compare :: LanguageDecl' a -> LanguageDecl' a -> Ordering
$ccompare :: forall a. Ord a => LanguageDecl' a -> LanguageDecl' a -> Ordering
C.Ord, Int -> LanguageDecl' a -> ShowS
forall a. Show a => Int -> LanguageDecl' a -> ShowS
forall a. Show a => [LanguageDecl' a] -> ShowS
forall a. Show a => LanguageDecl' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LanguageDecl' a] -> ShowS
$cshowList :: forall a. Show a => [LanguageDecl' a] -> ShowS
show :: LanguageDecl' a -> String
$cshow :: forall a. Show a => LanguageDecl' a -> String
showsPrec :: Int -> LanguageDecl' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> LanguageDecl' a -> ShowS
C.Show, ReadPrec [LanguageDecl' a]
ReadPrec (LanguageDecl' a)
ReadS [LanguageDecl' a]
forall a. Read a => ReadPrec [LanguageDecl' a]
forall a. Read a => ReadPrec (LanguageDecl' a)
forall a. Read a => Int -> ReadS (LanguageDecl' a)
forall a. Read a => ReadS [LanguageDecl' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LanguageDecl' a]
$creadListPrec :: forall a. Read a => ReadPrec [LanguageDecl' a]
readPrec :: ReadPrec (LanguageDecl' a)
$creadPrec :: forall a. Read a => ReadPrec (LanguageDecl' a)
readList :: ReadS [LanguageDecl' a]
$creadList :: forall a. Read a => ReadS [LanguageDecl' a]
readsPrec :: Int -> ReadS (LanguageDecl' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (LanguageDecl' a)
C.Read, forall a b. a -> LanguageDecl' b -> LanguageDecl' a
forall a b. (a -> b) -> LanguageDecl' a -> LanguageDecl' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> LanguageDecl' b -> LanguageDecl' a
$c<$ :: forall a b. a -> LanguageDecl' b -> LanguageDecl' a
fmap :: forall a b. (a -> b) -> LanguageDecl' a -> LanguageDecl' b
$cfmap :: forall a b. (a -> b) -> LanguageDecl' a -> LanguageDecl' b
C.Functor, forall a. Eq a => a -> LanguageDecl' a -> Bool
forall a. Num a => LanguageDecl' a -> a
forall a. Ord a => LanguageDecl' a -> a
forall m. Monoid m => LanguageDecl' m -> m
forall a. LanguageDecl' a -> Bool
forall a. LanguageDecl' a -> Int
forall a. LanguageDecl' a -> [a]
forall a. (a -> a -> a) -> LanguageDecl' a -> a
forall m a. Monoid m => (a -> m) -> LanguageDecl' a -> m
forall b a. (b -> a -> b) -> b -> LanguageDecl' a -> b
forall a b. (a -> b -> b) -> b -> LanguageDecl' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => LanguageDecl' a -> a
$cproduct :: forall a. Num a => LanguageDecl' a -> a
sum :: forall a. Num a => LanguageDecl' a -> a
$csum :: forall a. Num a => LanguageDecl' a -> a
minimum :: forall a. Ord a => LanguageDecl' a -> a
$cminimum :: forall a. Ord a => LanguageDecl' a -> a
maximum :: forall a. Ord a => LanguageDecl' a -> a
$cmaximum :: forall a. Ord a => LanguageDecl' a -> a
elem :: forall a. Eq a => a -> LanguageDecl' a -> Bool
$celem :: forall a. Eq a => a -> LanguageDecl' a -> Bool
length :: forall a. LanguageDecl' a -> Int
$clength :: forall a. LanguageDecl' a -> Int
null :: forall a. LanguageDecl' a -> Bool
$cnull :: forall a. LanguageDecl' a -> Bool
toList :: forall a. LanguageDecl' a -> [a]
$ctoList :: forall a. LanguageDecl' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> LanguageDecl' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> LanguageDecl' a -> a
foldr1 :: forall a. (a -> a -> a) -> LanguageDecl' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> LanguageDecl' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> LanguageDecl' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> LanguageDecl' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> LanguageDecl' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> LanguageDecl' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> LanguageDecl' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> LanguageDecl' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> LanguageDecl' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> LanguageDecl' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> LanguageDecl' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> LanguageDecl' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> LanguageDecl' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> LanguageDecl' a -> m
fold :: forall m. Monoid m => LanguageDecl' m -> m
$cfold :: forall m. Monoid m => LanguageDecl' m -> m
C.Foldable, Functor LanguageDecl'
Foldable LanguageDecl'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
LanguageDecl' (m a) -> m (LanguageDecl' a)
forall (f :: * -> *) a.
Applicative f =>
LanguageDecl' (f a) -> f (LanguageDecl' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LanguageDecl' a -> m (LanguageDecl' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LanguageDecl' a -> f (LanguageDecl' b)
sequence :: forall (m :: * -> *) a.
Monad m =>
LanguageDecl' (m a) -> m (LanguageDecl' a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
LanguageDecl' (m a) -> m (LanguageDecl' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LanguageDecl' a -> m (LanguageDecl' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LanguageDecl' a -> m (LanguageDecl' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
LanguageDecl' (f a) -> f (LanguageDecl' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
LanguageDecl' (f a) -> f (LanguageDecl' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LanguageDecl' a -> f (LanguageDecl' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LanguageDecl' a -> f (LanguageDecl' b)
C.Traversable, LanguageDecl' a -> DataType
LanguageDecl' a -> Constr
forall {a}. Data a => Typeable (LanguageDecl' a)
forall a. Data a => LanguageDecl' a -> DataType
forall a. Data a => LanguageDecl' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> LanguageDecl' a -> LanguageDecl' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> LanguageDecl' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> LanguageDecl' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LanguageDecl' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LanguageDecl' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LanguageDecl' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LanguageDecl' a -> c (LanguageDecl' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LanguageDecl' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LanguageDecl' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LanguageDecl' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LanguageDecl' a -> c (LanguageDecl' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LanguageDecl' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> LanguageDecl' a -> m (LanguageDecl' a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LanguageDecl' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> LanguageDecl' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> LanguageDecl' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> LanguageDecl' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LanguageDecl' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LanguageDecl' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LanguageDecl' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LanguageDecl' a -> r
gmapT :: (forall b. Data b => b -> b) -> LanguageDecl' a -> LanguageDecl' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> LanguageDecl' a -> LanguageDecl' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LanguageDecl' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (LanguageDecl' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (LanguageDecl' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (LanguageDecl' a))
dataTypeOf :: LanguageDecl' a -> DataType
$cdataTypeOf :: forall a. Data a => LanguageDecl' a -> DataType
toConstr :: LanguageDecl' a -> Constr
$ctoConstr :: forall a. Data a => LanguageDecl' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LanguageDecl' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (LanguageDecl' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LanguageDecl' a -> c (LanguageDecl' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LanguageDecl' a -> c (LanguageDecl' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (LanguageDecl' a) x -> LanguageDecl' a
forall a x. LanguageDecl' a -> Rep (LanguageDecl' a) x
$cto :: forall a x. Rep (LanguageDecl' a) x -> LanguageDecl' a
$cfrom :: forall a x. LanguageDecl' a -> Rep (LanguageDecl' a) x
C.Generic)

type Language = Language' BNFC'Position
data Language' a = Rzk1 a
  deriving (Language' a -> Language' a -> Bool
forall a. Eq a => Language' a -> Language' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Language' a -> Language' a -> Bool
$c/= :: forall a. Eq a => Language' a -> Language' a -> Bool
== :: Language' a -> Language' a -> Bool
$c== :: forall a. Eq a => Language' a -> Language' a -> Bool
C.Eq, Language' a -> Language' a -> Bool
Language' a -> Language' a -> Ordering
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
forall {a}. Ord a => Eq (Language' a)
forall a. Ord a => Language' a -> Language' a -> Bool
forall a. Ord a => Language' a -> Language' a -> Ordering
forall a. Ord a => Language' a -> Language' a -> Language' a
min :: Language' a -> Language' a -> Language' a
$cmin :: forall a. Ord a => Language' a -> Language' a -> Language' a
max :: Language' a -> Language' a -> Language' a
$cmax :: forall a. Ord a => Language' a -> Language' a -> Language' a
>= :: Language' a -> Language' a -> Bool
$c>= :: forall a. Ord a => Language' a -> Language' a -> Bool
> :: Language' a -> Language' a -> Bool
$c> :: forall a. Ord a => Language' a -> Language' a -> Bool
<= :: Language' a -> Language' a -> Bool
$c<= :: forall a. Ord a => Language' a -> Language' a -> Bool
< :: Language' a -> Language' a -> Bool
$c< :: forall a. Ord a => Language' a -> Language' a -> Bool
compare :: Language' a -> Language' a -> Ordering
$ccompare :: forall a. Ord a => Language' a -> Language' a -> Ordering
C.Ord, Int -> Language' a -> ShowS
forall a. Show a => Int -> Language' a -> ShowS
forall a. Show a => [Language' a] -> ShowS
forall a. Show a => Language' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Language' a] -> ShowS
$cshowList :: forall a. Show a => [Language' a] -> ShowS
show :: Language' a -> String
$cshow :: forall a. Show a => Language' a -> String
showsPrec :: Int -> Language' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Language' a -> ShowS
C.Show, ReadPrec [Language' a]
ReadPrec (Language' a)
ReadS [Language' a]
forall a. Read a => ReadPrec [Language' a]
forall a. Read a => ReadPrec (Language' a)
forall a. Read a => Int -> ReadS (Language' a)
forall a. Read a => ReadS [Language' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Language' a]
$creadListPrec :: forall a. Read a => ReadPrec [Language' a]
readPrec :: ReadPrec (Language' a)
$creadPrec :: forall a. Read a => ReadPrec (Language' a)
readList :: ReadS [Language' a]
$creadList :: forall a. Read a => ReadS [Language' a]
readsPrec :: Int -> ReadS (Language' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Language' a)
C.Read, forall a b. a -> Language' b -> Language' a
forall a b. (a -> b) -> Language' a -> Language' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Language' b -> Language' a
$c<$ :: forall a b. a -> Language' b -> Language' a
fmap :: forall a b. (a -> b) -> Language' a -> Language' b
$cfmap :: forall a b. (a -> b) -> Language' a -> Language' b
C.Functor, forall a. Eq a => a -> Language' a -> Bool
forall a. Num a => Language' a -> a
forall a. Ord a => Language' a -> a
forall m. Monoid m => Language' m -> m
forall a. Language' a -> Bool
forall a. Language' a -> Int
forall a. Language' a -> [a]
forall a. (a -> a -> a) -> Language' a -> a
forall m a. Monoid m => (a -> m) -> Language' a -> m
forall b a. (b -> a -> b) -> b -> Language' a -> b
forall a b. (a -> b -> b) -> b -> Language' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Language' a -> a
$cproduct :: forall a. Num a => Language' a -> a
sum :: forall a. Num a => Language' a -> a
$csum :: forall a. Num a => Language' a -> a
minimum :: forall a. Ord a => Language' a -> a
$cminimum :: forall a. Ord a => Language' a -> a
maximum :: forall a. Ord a => Language' a -> a
$cmaximum :: forall a. Ord a => Language' a -> a
elem :: forall a. Eq a => a -> Language' a -> Bool
$celem :: forall a. Eq a => a -> Language' a -> Bool
length :: forall a. Language' a -> Int
$clength :: forall a. Language' a -> Int
null :: forall a. Language' a -> Bool
$cnull :: forall a. Language' a -> Bool
toList :: forall a. Language' a -> [a]
$ctoList :: forall a. Language' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Language' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Language' a -> a
foldr1 :: forall a. (a -> a -> a) -> Language' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Language' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Language' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Language' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Language' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Language' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Language' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Language' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Language' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Language' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Language' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Language' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Language' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Language' a -> m
fold :: forall m. Monoid m => Language' m -> m
$cfold :: forall m. Monoid m => Language' m -> m
C.Foldable, Functor Language'
Foldable Language'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Language' (m a) -> m (Language' a)
forall (f :: * -> *) a.
Applicative f =>
Language' (f a) -> f (Language' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Language' a -> m (Language' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Language' a -> f (Language' b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Language' (m a) -> m (Language' a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Language' (m a) -> m (Language' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Language' a -> m (Language' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Language' a -> m (Language' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Language' (f a) -> f (Language' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Language' (f a) -> f (Language' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Language' a -> f (Language' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Language' a -> f (Language' b)
C.Traversable, Language' a -> DataType
Language' a -> Constr
forall {a}. Data a => Typeable (Language' a)
forall a. Data a => Language' a -> DataType
forall a. Data a => Language' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Language' a -> Language' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Language' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Language' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Language' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Language' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Language' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Language' a -> c (Language' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Language' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Language' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Language' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Language' a -> c (Language' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Language' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Language' a -> m (Language' a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Language' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Language' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Language' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Language' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Language' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Language' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Language' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Language' a -> r
gmapT :: (forall b. Data b => b -> b) -> Language' a -> Language' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Language' a -> Language' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Language' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Language' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Language' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Language' a))
dataTypeOf :: Language' a -> DataType
$cdataTypeOf :: forall a. Data a => Language' a -> DataType
toConstr :: Language' a -> Constr
$ctoConstr :: forall a. Data a => Language' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Language' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Language' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Language' a -> c (Language' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Language' a -> c (Language' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Language' a) x -> Language' a
forall a x. Language' a -> Rep (Language' a) x
$cto :: forall a x. Rep (Language' a) x -> Language' a
$cfrom :: forall a x. Language' a -> Rep (Language' a) x
C.Generic)

type Command = Command' BNFC'Position
data Command' a
    = CommandSetOption a String String
    | CommandUnsetOption a String
    | CommandCheck a (Term' a) (Term' a)
    | CommandCompute a (Term' a)
    | CommandComputeWHNF a (Term' a)
    | CommandComputeNF a (Term' a)
    | CommandPostulate a VarIdent [Param' a] (Term' a)
    | CommandDefine a VarIdent [Param' a] (Term' a) (Term' a)
  deriving (Command' a -> Command' a -> Bool
forall a. Eq a => Command' a -> Command' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Command' a -> Command' a -> Bool
$c/= :: forall a. Eq a => Command' a -> Command' a -> Bool
== :: Command' a -> Command' a -> Bool
$c== :: forall a. Eq a => Command' a -> Command' a -> Bool
C.Eq, Command' a -> Command' a -> Ordering
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
forall {a}. Ord a => Eq (Command' a)
forall a. Ord a => Command' a -> Command' a -> Bool
forall a. Ord a => Command' a -> Command' a -> Ordering
forall a. Ord a => Command' a -> Command' a -> Command' a
min :: Command' a -> Command' a -> Command' a
$cmin :: forall a. Ord a => Command' a -> Command' a -> Command' a
max :: Command' a -> Command' a -> Command' a
$cmax :: forall a. Ord a => Command' a -> Command' a -> Command' a
>= :: Command' a -> Command' a -> Bool
$c>= :: forall a. Ord a => Command' a -> Command' a -> Bool
> :: Command' a -> Command' a -> Bool
$c> :: forall a. Ord a => Command' a -> Command' a -> Bool
<= :: Command' a -> Command' a -> Bool
$c<= :: forall a. Ord a => Command' a -> Command' a -> Bool
< :: Command' a -> Command' a -> Bool
$c< :: forall a. Ord a => Command' a -> Command' a -> Bool
compare :: Command' a -> Command' a -> Ordering
$ccompare :: forall a. Ord a => Command' a -> Command' a -> Ordering
C.Ord, Int -> Command' a -> ShowS
forall a. Show a => Int -> Command' a -> ShowS
forall a. Show a => [Command' a] -> ShowS
forall a. Show a => Command' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Command' a] -> ShowS
$cshowList :: forall a. Show a => [Command' a] -> ShowS
show :: Command' a -> String
$cshow :: forall a. Show a => Command' a -> String
showsPrec :: Int -> Command' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Command' a -> ShowS
C.Show, ReadPrec [Command' a]
ReadPrec (Command' a)
ReadS [Command' a]
forall a. Read a => ReadPrec [Command' a]
forall a. Read a => ReadPrec (Command' a)
forall a. Read a => Int -> ReadS (Command' a)
forall a. Read a => ReadS [Command' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Command' a]
$creadListPrec :: forall a. Read a => ReadPrec [Command' a]
readPrec :: ReadPrec (Command' a)
$creadPrec :: forall a. Read a => ReadPrec (Command' a)
readList :: ReadS [Command' a]
$creadList :: forall a. Read a => ReadS [Command' a]
readsPrec :: Int -> ReadS (Command' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Command' a)
C.Read, forall a b. a -> Command' b -> Command' a
forall a b. (a -> b) -> Command' a -> Command' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Command' b -> Command' a
$c<$ :: forall a b. a -> Command' b -> Command' a
fmap :: forall a b. (a -> b) -> Command' a -> Command' b
$cfmap :: forall a b. (a -> b) -> Command' a -> Command' b
C.Functor, forall a. Eq a => a -> Command' a -> Bool
forall a. Num a => Command' a -> a
forall a. Ord a => Command' a -> a
forall m. Monoid m => Command' m -> m
forall a. Command' a -> Bool
forall a. Command' a -> Int
forall a. Command' a -> [a]
forall a. (a -> a -> a) -> Command' a -> a
forall m a. Monoid m => (a -> m) -> Command' a -> m
forall b a. (b -> a -> b) -> b -> Command' a -> b
forall a b. (a -> b -> b) -> b -> Command' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Command' a -> a
$cproduct :: forall a. Num a => Command' a -> a
sum :: forall a. Num a => Command' a -> a
$csum :: forall a. Num a => Command' a -> a
minimum :: forall a. Ord a => Command' a -> a
$cminimum :: forall a. Ord a => Command' a -> a
maximum :: forall a. Ord a => Command' a -> a
$cmaximum :: forall a. Ord a => Command' a -> a
elem :: forall a. Eq a => a -> Command' a -> Bool
$celem :: forall a. Eq a => a -> Command' a -> Bool
length :: forall a. Command' a -> Int
$clength :: forall a. Command' a -> Int
null :: forall a. Command' a -> Bool
$cnull :: forall a. Command' a -> Bool
toList :: forall a. Command' a -> [a]
$ctoList :: forall a. Command' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Command' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Command' a -> a
foldr1 :: forall a. (a -> a -> a) -> Command' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Command' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Command' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Command' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Command' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Command' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Command' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Command' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Command' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Command' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Command' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Command' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Command' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Command' a -> m
fold :: forall m. Monoid m => Command' m -> m
$cfold :: forall m. Monoid m => Command' m -> m
C.Foldable, Functor Command'
Foldable Command'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Command' (m a) -> m (Command' a)
forall (f :: * -> *) a.
Applicative f =>
Command' (f a) -> f (Command' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Command' a -> m (Command' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Command' a -> f (Command' b)
sequence :: forall (m :: * -> *) a. Monad m => Command' (m a) -> m (Command' a)
$csequence :: forall (m :: * -> *) a. Monad m => Command' (m a) -> m (Command' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Command' a -> m (Command' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Command' a -> m (Command' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Command' (f a) -> f (Command' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Command' (f a) -> f (Command' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Command' a -> f (Command' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Command' a -> f (Command' b)
C.Traversable, Command' a -> DataType
Command' a -> Constr
forall {a}. Data a => Typeable (Command' a)
forall a. Data a => Command' a -> DataType
forall a. Data a => Command' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Command' a -> Command' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Command' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Command' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Command' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Command' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Command' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command' a -> c (Command' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Command' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Command' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Command' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command' a -> c (Command' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Command' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Command' a -> m (Command' a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Command' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Command' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Command' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Command' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Command' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Command' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Command' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Command' a -> r
gmapT :: (forall b. Data b => b -> b) -> Command' a -> Command' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Command' a -> Command' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Command' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Command' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Command' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Command' a))
dataTypeOf :: Command' a -> DataType
$cdataTypeOf :: forall a. Data a => Command' a -> DataType
toConstr :: Command' a -> Constr
$ctoConstr :: forall a. Data a => Command' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Command' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Command' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command' a -> c (Command' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Command' a -> c (Command' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Command' a) x -> Command' a
forall a x. Command' a -> Rep (Command' a) x
$cto :: forall a x. Rep (Command' a) x -> Command' a
$cfrom :: forall a x. Command' a -> Rep (Command' a) x
C.Generic)

type Pattern = Pattern' BNFC'Position
data Pattern' a
    = PatternWildcard a
    | PatternVar a VarIdent
    | PatternPair a (Pattern' a) (Pattern' a)
  deriving (Pattern' a -> Pattern' a -> Bool
forall a. Eq a => Pattern' a -> Pattern' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pattern' a -> Pattern' a -> Bool
$c/= :: forall a. Eq a => Pattern' a -> Pattern' a -> Bool
== :: Pattern' a -> Pattern' a -> Bool
$c== :: forall a. Eq a => Pattern' a -> Pattern' a -> Bool
C.Eq, Pattern' a -> Pattern' a -> Bool
Pattern' a -> Pattern' a -> Ordering
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
forall {a}. Ord a => Eq (Pattern' a)
forall a. Ord a => Pattern' a -> Pattern' a -> Bool
forall a. Ord a => Pattern' a -> Pattern' a -> Ordering
forall a. Ord a => Pattern' a -> Pattern' a -> Pattern' a
min :: Pattern' a -> Pattern' a -> Pattern' a
$cmin :: forall a. Ord a => Pattern' a -> Pattern' a -> Pattern' a
max :: Pattern' a -> Pattern' a -> Pattern' a
$cmax :: forall a. Ord a => Pattern' a -> Pattern' a -> Pattern' a
>= :: Pattern' a -> Pattern' a -> Bool
$c>= :: forall a. Ord a => Pattern' a -> Pattern' a -> Bool
> :: Pattern' a -> Pattern' a -> Bool
$c> :: forall a. Ord a => Pattern' a -> Pattern' a -> Bool
<= :: Pattern' a -> Pattern' a -> Bool
$c<= :: forall a. Ord a => Pattern' a -> Pattern' a -> Bool
< :: Pattern' a -> Pattern' a -> Bool
$c< :: forall a. Ord a => Pattern' a -> Pattern' a -> Bool
compare :: Pattern' a -> Pattern' a -> Ordering
$ccompare :: forall a. Ord a => Pattern' a -> Pattern' a -> Ordering
C.Ord, Int -> Pattern' a -> ShowS
forall a. Show a => Int -> Pattern' a -> ShowS
forall a. Show a => [Pattern' a] -> ShowS
forall a. Show a => Pattern' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pattern' a] -> ShowS
$cshowList :: forall a. Show a => [Pattern' a] -> ShowS
show :: Pattern' a -> String
$cshow :: forall a. Show a => Pattern' a -> String
showsPrec :: Int -> Pattern' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Pattern' a -> ShowS
C.Show, ReadPrec [Pattern' a]
ReadPrec (Pattern' a)
ReadS [Pattern' a]
forall a. Read a => ReadPrec [Pattern' a]
forall a. Read a => ReadPrec (Pattern' a)
forall a. Read a => Int -> ReadS (Pattern' a)
forall a. Read a => ReadS [Pattern' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Pattern' a]
$creadListPrec :: forall a. Read a => ReadPrec [Pattern' a]
readPrec :: ReadPrec (Pattern' a)
$creadPrec :: forall a. Read a => ReadPrec (Pattern' a)
readList :: ReadS [Pattern' a]
$creadList :: forall a. Read a => ReadS [Pattern' a]
readsPrec :: Int -> ReadS (Pattern' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Pattern' a)
C.Read, forall a b. a -> Pattern' b -> Pattern' a
forall a b. (a -> b) -> Pattern' a -> Pattern' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Pattern' b -> Pattern' a
$c<$ :: forall a b. a -> Pattern' b -> Pattern' a
fmap :: forall a b. (a -> b) -> Pattern' a -> Pattern' b
$cfmap :: forall a b. (a -> b) -> Pattern' a -> Pattern' b
C.Functor, forall a. Eq a => a -> Pattern' a -> Bool
forall a. Num a => Pattern' a -> a
forall a. Ord a => Pattern' a -> a
forall m. Monoid m => Pattern' m -> m
forall a. Pattern' a -> Bool
forall a. Pattern' a -> Int
forall a. Pattern' a -> [a]
forall a. (a -> a -> a) -> Pattern' a -> a
forall m a. Monoid m => (a -> m) -> Pattern' a -> m
forall b a. (b -> a -> b) -> b -> Pattern' a -> b
forall a b. (a -> b -> b) -> b -> Pattern' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Pattern' a -> a
$cproduct :: forall a. Num a => Pattern' a -> a
sum :: forall a. Num a => Pattern' a -> a
$csum :: forall a. Num a => Pattern' a -> a
minimum :: forall a. Ord a => Pattern' a -> a
$cminimum :: forall a. Ord a => Pattern' a -> a
maximum :: forall a. Ord a => Pattern' a -> a
$cmaximum :: forall a. Ord a => Pattern' a -> a
elem :: forall a. Eq a => a -> Pattern' a -> Bool
$celem :: forall a. Eq a => a -> Pattern' a -> Bool
length :: forall a. Pattern' a -> Int
$clength :: forall a. Pattern' a -> Int
null :: forall a. Pattern' a -> Bool
$cnull :: forall a. Pattern' a -> Bool
toList :: forall a. Pattern' a -> [a]
$ctoList :: forall a. Pattern' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Pattern' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Pattern' a -> a
foldr1 :: forall a. (a -> a -> a) -> Pattern' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Pattern' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Pattern' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Pattern' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Pattern' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Pattern' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Pattern' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Pattern' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Pattern' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Pattern' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Pattern' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Pattern' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Pattern' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Pattern' a -> m
fold :: forall m. Monoid m => Pattern' m -> m
$cfold :: forall m. Monoid m => Pattern' m -> m
C.Foldable, Functor Pattern'
Foldable Pattern'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Pattern' (m a) -> m (Pattern' a)
forall (f :: * -> *) a.
Applicative f =>
Pattern' (f a) -> f (Pattern' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Pattern' a -> m (Pattern' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Pattern' a -> f (Pattern' b)
sequence :: forall (m :: * -> *) a. Monad m => Pattern' (m a) -> m (Pattern' a)
$csequence :: forall (m :: * -> *) a. Monad m => Pattern' (m a) -> m (Pattern' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Pattern' a -> m (Pattern' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Pattern' a -> m (Pattern' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Pattern' (f a) -> f (Pattern' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Pattern' (f a) -> f (Pattern' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Pattern' a -> f (Pattern' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Pattern' a -> f (Pattern' b)
C.Traversable, Pattern' a -> DataType
Pattern' a -> Constr
forall {a}. Data a => Typeable (Pattern' a)
forall a. Data a => Pattern' a -> DataType
forall a. Data a => Pattern' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Pattern' a -> Pattern' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Pattern' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Pattern' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pattern' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pattern' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Pattern' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Pattern' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Pattern' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
gmapT :: (forall b. Data b => b -> b) -> Pattern' a -> Pattern' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Pattern' a -> Pattern' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pattern' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pattern' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
dataTypeOf :: Pattern' a -> DataType
$cdataTypeOf :: forall a. Data a => Pattern' a -> DataType
toConstr :: Pattern' a -> Constr
$ctoConstr :: forall a. Data a => Pattern' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Pattern' a) x -> Pattern' a
forall a x. Pattern' a -> Rep (Pattern' a) x
$cto :: forall a x. Rep (Pattern' a) x -> Pattern' a
$cfrom :: forall a x. Pattern' a -> Rep (Pattern' a) x
C.Generic)

type Param = Param' BNFC'Position
data Param' a
    = ParamPattern a (Pattern' a)
    | ParamPatternType a [Pattern' a] (Term' a)
    | ParamPatternShape a (Pattern' a) (Term' a) (Term' a)
  deriving (Param' a -> Param' a -> Bool
forall a. Eq a => Param' a -> Param' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Param' a -> Param' a -> Bool
$c/= :: forall a. Eq a => Param' a -> Param' a -> Bool
== :: Param' a -> Param' a -> Bool
$c== :: forall a. Eq a => Param' a -> Param' a -> Bool
C.Eq, Param' a -> Param' a -> Bool
Param' a -> Param' a -> Ordering
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
forall {a}. Ord a => Eq (Param' a)
forall a. Ord a => Param' a -> Param' a -> Bool
forall a. Ord a => Param' a -> Param' a -> Ordering
forall a. Ord a => Param' a -> Param' a -> Param' a
min :: Param' a -> Param' a -> Param' a
$cmin :: forall a. Ord a => Param' a -> Param' a -> Param' a
max :: Param' a -> Param' a -> Param' a
$cmax :: forall a. Ord a => Param' a -> Param' a -> Param' a
>= :: Param' a -> Param' a -> Bool
$c>= :: forall a. Ord a => Param' a -> Param' a -> Bool
> :: Param' a -> Param' a -> Bool
$c> :: forall a. Ord a => Param' a -> Param' a -> Bool
<= :: Param' a -> Param' a -> Bool
$c<= :: forall a. Ord a => Param' a -> Param' a -> Bool
< :: Param' a -> Param' a -> Bool
$c< :: forall a. Ord a => Param' a -> Param' a -> Bool
compare :: Param' a -> Param' a -> Ordering
$ccompare :: forall a. Ord a => Param' a -> Param' a -> Ordering
C.Ord, Int -> Param' a -> ShowS
forall a. Show a => Int -> Param' a -> ShowS
forall a. Show a => [Param' a] -> ShowS
forall a. Show a => Param' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Param' a] -> ShowS
$cshowList :: forall a. Show a => [Param' a] -> ShowS
show :: Param' a -> String
$cshow :: forall a. Show a => Param' a -> String
showsPrec :: Int -> Param' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Param' a -> ShowS
C.Show, ReadPrec [Param' a]
ReadPrec (Param' a)
ReadS [Param' a]
forall a. Read a => ReadPrec [Param' a]
forall a. Read a => ReadPrec (Param' a)
forall a. Read a => Int -> ReadS (Param' a)
forall a. Read a => ReadS [Param' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Param' a]
$creadListPrec :: forall a. Read a => ReadPrec [Param' a]
readPrec :: ReadPrec (Param' a)
$creadPrec :: forall a. Read a => ReadPrec (Param' a)
readList :: ReadS [Param' a]
$creadList :: forall a. Read a => ReadS [Param' a]
readsPrec :: Int -> ReadS (Param' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Param' a)
C.Read, forall a b. a -> Param' b -> Param' a
forall a b. (a -> b) -> Param' a -> Param' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Param' b -> Param' a
$c<$ :: forall a b. a -> Param' b -> Param' a
fmap :: forall a b. (a -> b) -> Param' a -> Param' b
$cfmap :: forall a b. (a -> b) -> Param' a -> Param' b
C.Functor, forall a. Eq a => a -> Param' a -> Bool
forall a. Num a => Param' a -> a
forall a. Ord a => Param' a -> a
forall m. Monoid m => Param' m -> m
forall a. Param' a -> Bool
forall a. Param' a -> Int
forall a. Param' a -> [a]
forall a. (a -> a -> a) -> Param' a -> a
forall m a. Monoid m => (a -> m) -> Param' a -> m
forall b a. (b -> a -> b) -> b -> Param' a -> b
forall a b. (a -> b -> b) -> b -> Param' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Param' a -> a
$cproduct :: forall a. Num a => Param' a -> a
sum :: forall a. Num a => Param' a -> a
$csum :: forall a. Num a => Param' a -> a
minimum :: forall a. Ord a => Param' a -> a
$cminimum :: forall a. Ord a => Param' a -> a
maximum :: forall a. Ord a => Param' a -> a
$cmaximum :: forall a. Ord a => Param' a -> a
elem :: forall a. Eq a => a -> Param' a -> Bool
$celem :: forall a. Eq a => a -> Param' a -> Bool
length :: forall a. Param' a -> Int
$clength :: forall a. Param' a -> Int
null :: forall a. Param' a -> Bool
$cnull :: forall a. Param' a -> Bool
toList :: forall a. Param' a -> [a]
$ctoList :: forall a. Param' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Param' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Param' a -> a
foldr1 :: forall a. (a -> a -> a) -> Param' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Param' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Param' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Param' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Param' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Param' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Param' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Param' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Param' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Param' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Param' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Param' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Param' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Param' a -> m
fold :: forall m. Monoid m => Param' m -> m
$cfold :: forall m. Monoid m => Param' m -> m
C.Foldable, Functor Param'
Foldable Param'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Param' (m a) -> m (Param' a)
forall (f :: * -> *) a.
Applicative f =>
Param' (f a) -> f (Param' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Param' a -> m (Param' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Param' a -> f (Param' b)
sequence :: forall (m :: * -> *) a. Monad m => Param' (m a) -> m (Param' a)
$csequence :: forall (m :: * -> *) a. Monad m => Param' (m a) -> m (Param' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Param' a -> m (Param' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Param' a -> m (Param' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Param' (f a) -> f (Param' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Param' (f a) -> f (Param' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Param' a -> f (Param' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Param' a -> f (Param' b)
C.Traversable, Param' a -> DataType
Param' a -> Constr
forall {a}. Data a => Typeable (Param' a)
forall a. Data a => Param' a -> DataType
forall a. Data a => Param' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Param' a -> Param' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Param' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Param' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Param' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Param' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Param' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Param' a -> c (Param' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Param' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Param' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Param' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Param' a -> c (Param' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Param' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Param' a -> m (Param' a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Param' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Param' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Param' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Param' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Param' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Param' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Param' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Param' a -> r
gmapT :: (forall b. Data b => b -> b) -> Param' a -> Param' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Param' a -> Param' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Param' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Param' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Param' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Param' a))
dataTypeOf :: Param' a -> DataType
$cdataTypeOf :: forall a. Data a => Param' a -> DataType
toConstr :: Param' a -> Constr
$ctoConstr :: forall a. Data a => Param' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Param' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Param' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Param' a -> c (Param' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Param' a -> c (Param' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Param' a) x -> Param' a
forall a x. Param' a -> Rep (Param' a) x
$cto :: forall a x. Rep (Param' a) x -> Param' a
$cfrom :: forall a x. Param' a -> Rep (Param' a) x
C.Generic)

type ParamDecl = ParamDecl' BNFC'Position
data ParamDecl' a
    = ParamType a (Term' a)
    | ParamWildcardType a (Term' a)
    | ParamVarType a (Pattern' a) (Term' a)
    | ParamVarShape a (Pattern' a) (Term' a) (Term' a)
  deriving (ParamDecl' a -> ParamDecl' a -> Bool
forall a. Eq a => ParamDecl' a -> ParamDecl' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ParamDecl' a -> ParamDecl' a -> Bool
$c/= :: forall a. Eq a => ParamDecl' a -> ParamDecl' a -> Bool
== :: ParamDecl' a -> ParamDecl' a -> Bool
$c== :: forall a. Eq a => ParamDecl' a -> ParamDecl' a -> Bool
C.Eq, ParamDecl' a -> ParamDecl' a -> Ordering
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
forall {a}. Ord a => Eq (ParamDecl' a)
forall a. Ord a => ParamDecl' a -> ParamDecl' a -> Bool
forall a. Ord a => ParamDecl' a -> ParamDecl' a -> Ordering
forall a. Ord a => ParamDecl' a -> ParamDecl' a -> ParamDecl' a
min :: ParamDecl' a -> ParamDecl' a -> ParamDecl' a
$cmin :: forall a. Ord a => ParamDecl' a -> ParamDecl' a -> ParamDecl' a
max :: ParamDecl' a -> ParamDecl' a -> ParamDecl' a
$cmax :: forall a. Ord a => ParamDecl' a -> ParamDecl' a -> ParamDecl' a
>= :: ParamDecl' a -> ParamDecl' a -> Bool
$c>= :: forall a. Ord a => ParamDecl' a -> ParamDecl' a -> Bool
> :: ParamDecl' a -> ParamDecl' a -> Bool
$c> :: forall a. Ord a => ParamDecl' a -> ParamDecl' a -> Bool
<= :: ParamDecl' a -> ParamDecl' a -> Bool
$c<= :: forall a. Ord a => ParamDecl' a -> ParamDecl' a -> Bool
< :: ParamDecl' a -> ParamDecl' a -> Bool
$c< :: forall a. Ord a => ParamDecl' a -> ParamDecl' a -> Bool
compare :: ParamDecl' a -> ParamDecl' a -> Ordering
$ccompare :: forall a. Ord a => ParamDecl' a -> ParamDecl' a -> Ordering
C.Ord, Int -> ParamDecl' a -> ShowS
forall a. Show a => Int -> ParamDecl' a -> ShowS
forall a. Show a => [ParamDecl' a] -> ShowS
forall a. Show a => ParamDecl' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ParamDecl' a] -> ShowS
$cshowList :: forall a. Show a => [ParamDecl' a] -> ShowS
show :: ParamDecl' a -> String
$cshow :: forall a. Show a => ParamDecl' a -> String
showsPrec :: Int -> ParamDecl' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ParamDecl' a -> ShowS
C.Show, ReadPrec [ParamDecl' a]
ReadPrec (ParamDecl' a)
ReadS [ParamDecl' a]
forall a. Read a => ReadPrec [ParamDecl' a]
forall a. Read a => ReadPrec (ParamDecl' a)
forall a. Read a => Int -> ReadS (ParamDecl' a)
forall a. Read a => ReadS [ParamDecl' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ParamDecl' a]
$creadListPrec :: forall a. Read a => ReadPrec [ParamDecl' a]
readPrec :: ReadPrec (ParamDecl' a)
$creadPrec :: forall a. Read a => ReadPrec (ParamDecl' a)
readList :: ReadS [ParamDecl' a]
$creadList :: forall a. Read a => ReadS [ParamDecl' a]
readsPrec :: Int -> ReadS (ParamDecl' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (ParamDecl' a)
C.Read, forall a b. a -> ParamDecl' b -> ParamDecl' a
forall a b. (a -> b) -> ParamDecl' a -> ParamDecl' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ParamDecl' b -> ParamDecl' a
$c<$ :: forall a b. a -> ParamDecl' b -> ParamDecl' a
fmap :: forall a b. (a -> b) -> ParamDecl' a -> ParamDecl' b
$cfmap :: forall a b. (a -> b) -> ParamDecl' a -> ParamDecl' b
C.Functor, forall a. Eq a => a -> ParamDecl' a -> Bool
forall a. Num a => ParamDecl' a -> a
forall a. Ord a => ParamDecl' a -> a
forall m. Monoid m => ParamDecl' m -> m
forall a. ParamDecl' a -> Bool
forall a. ParamDecl' a -> Int
forall a. ParamDecl' a -> [a]
forall a. (a -> a -> a) -> ParamDecl' a -> a
forall m a. Monoid m => (a -> m) -> ParamDecl' a -> m
forall b a. (b -> a -> b) -> b -> ParamDecl' a -> b
forall a b. (a -> b -> b) -> b -> ParamDecl' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ParamDecl' a -> a
$cproduct :: forall a. Num a => ParamDecl' a -> a
sum :: forall a. Num a => ParamDecl' a -> a
$csum :: forall a. Num a => ParamDecl' a -> a
minimum :: forall a. Ord a => ParamDecl' a -> a
$cminimum :: forall a. Ord a => ParamDecl' a -> a
maximum :: forall a. Ord a => ParamDecl' a -> a
$cmaximum :: forall a. Ord a => ParamDecl' a -> a
elem :: forall a. Eq a => a -> ParamDecl' a -> Bool
$celem :: forall a. Eq a => a -> ParamDecl' a -> Bool
length :: forall a. ParamDecl' a -> Int
$clength :: forall a. ParamDecl' a -> Int
null :: forall a. ParamDecl' a -> Bool
$cnull :: forall a. ParamDecl' a -> Bool
toList :: forall a. ParamDecl' a -> [a]
$ctoList :: forall a. ParamDecl' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ParamDecl' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ParamDecl' a -> a
foldr1 :: forall a. (a -> a -> a) -> ParamDecl' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ParamDecl' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ParamDecl' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ParamDecl' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ParamDecl' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ParamDecl' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ParamDecl' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ParamDecl' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ParamDecl' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ParamDecl' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ParamDecl' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ParamDecl' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ParamDecl' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ParamDecl' a -> m
fold :: forall m. Monoid m => ParamDecl' m -> m
$cfold :: forall m. Monoid m => ParamDecl' m -> m
C.Foldable, Functor ParamDecl'
Foldable ParamDecl'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
ParamDecl' (m a) -> m (ParamDecl' a)
forall (f :: * -> *) a.
Applicative f =>
ParamDecl' (f a) -> f (ParamDecl' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParamDecl' a -> m (ParamDecl' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParamDecl' a -> f (ParamDecl' b)
sequence :: forall (m :: * -> *) a.
Monad m =>
ParamDecl' (m a) -> m (ParamDecl' a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ParamDecl' (m a) -> m (ParamDecl' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParamDecl' a -> m (ParamDecl' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ParamDecl' a -> m (ParamDecl' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ParamDecl' (f a) -> f (ParamDecl' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ParamDecl' (f a) -> f (ParamDecl' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParamDecl' a -> f (ParamDecl' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ParamDecl' a -> f (ParamDecl' b)
C.Traversable, ParamDecl' a -> DataType
ParamDecl' a -> Constr
forall {a}. Data a => Typeable (ParamDecl' a)
forall a. Data a => ParamDecl' a -> DataType
forall a. Data a => ParamDecl' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> ParamDecl' a -> ParamDecl' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ParamDecl' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ParamDecl' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParamDecl' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParamDecl' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParamDecl' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParamDecl' a -> c (ParamDecl' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ParamDecl' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParamDecl' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParamDecl' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParamDecl' a -> c (ParamDecl' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ParamDecl' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ParamDecl' a -> m (ParamDecl' a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ParamDecl' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ParamDecl' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ParamDecl' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ParamDecl' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParamDecl' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ParamDecl' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParamDecl' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ParamDecl' a -> r
gmapT :: (forall b. Data b => b -> b) -> ParamDecl' a -> ParamDecl' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ParamDecl' a -> ParamDecl' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParamDecl' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ParamDecl' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ParamDecl' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ParamDecl' a))
dataTypeOf :: ParamDecl' a -> DataType
$cdataTypeOf :: forall a. Data a => ParamDecl' a -> DataType
toConstr :: ParamDecl' a -> Constr
$ctoConstr :: forall a. Data a => ParamDecl' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParamDecl' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ParamDecl' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParamDecl' a -> c (ParamDecl' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ParamDecl' a -> c (ParamDecl' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ParamDecl' a) x -> ParamDecl' a
forall a x. ParamDecl' a -> Rep (ParamDecl' a) x
$cto :: forall a x. Rep (ParamDecl' a) x -> ParamDecl' a
$cfrom :: forall a x. ParamDecl' a -> Rep (ParamDecl' a) x
C.Generic)

type Restriction = Restriction' BNFC'Position
data Restriction' a = Restriction a (Term' a) (Term' a)
  deriving (Restriction' a -> Restriction' a -> Bool
forall a. Eq a => Restriction' a -> Restriction' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Restriction' a -> Restriction' a -> Bool
$c/= :: forall a. Eq a => Restriction' a -> Restriction' a -> Bool
== :: Restriction' a -> Restriction' a -> Bool
$c== :: forall a. Eq a => Restriction' a -> Restriction' a -> Bool
C.Eq, Restriction' a -> Restriction' a -> Bool
Restriction' a -> Restriction' a -> Ordering
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
forall {a}. Ord a => Eq (Restriction' a)
forall a. Ord a => Restriction' a -> Restriction' a -> Bool
forall a. Ord a => Restriction' a -> Restriction' a -> Ordering
forall a.
Ord a =>
Restriction' a -> Restriction' a -> Restriction' a
min :: Restriction' a -> Restriction' a -> Restriction' a
$cmin :: forall a.
Ord a =>
Restriction' a -> Restriction' a -> Restriction' a
max :: Restriction' a -> Restriction' a -> Restriction' a
$cmax :: forall a.
Ord a =>
Restriction' a -> Restriction' a -> Restriction' a
>= :: Restriction' a -> Restriction' a -> Bool
$c>= :: forall a. Ord a => Restriction' a -> Restriction' a -> Bool
> :: Restriction' a -> Restriction' a -> Bool
$c> :: forall a. Ord a => Restriction' a -> Restriction' a -> Bool
<= :: Restriction' a -> Restriction' a -> Bool
$c<= :: forall a. Ord a => Restriction' a -> Restriction' a -> Bool
< :: Restriction' a -> Restriction' a -> Bool
$c< :: forall a. Ord a => Restriction' a -> Restriction' a -> Bool
compare :: Restriction' a -> Restriction' a -> Ordering
$ccompare :: forall a. Ord a => Restriction' a -> Restriction' a -> Ordering
C.Ord, Int -> Restriction' a -> ShowS
forall a. Show a => Int -> Restriction' a -> ShowS
forall a. Show a => [Restriction' a] -> ShowS
forall a. Show a => Restriction' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Restriction' a] -> ShowS
$cshowList :: forall a. Show a => [Restriction' a] -> ShowS
show :: Restriction' a -> String
$cshow :: forall a. Show a => Restriction' a -> String
showsPrec :: Int -> Restriction' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Restriction' a -> ShowS
C.Show, ReadPrec [Restriction' a]
ReadPrec (Restriction' a)
ReadS [Restriction' a]
forall a. Read a => ReadPrec [Restriction' a]
forall a. Read a => ReadPrec (Restriction' a)
forall a. Read a => Int -> ReadS (Restriction' a)
forall a. Read a => ReadS [Restriction' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Restriction' a]
$creadListPrec :: forall a. Read a => ReadPrec [Restriction' a]
readPrec :: ReadPrec (Restriction' a)
$creadPrec :: forall a. Read a => ReadPrec (Restriction' a)
readList :: ReadS [Restriction' a]
$creadList :: forall a. Read a => ReadS [Restriction' a]
readsPrec :: Int -> ReadS (Restriction' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Restriction' a)
C.Read, forall a b. a -> Restriction' b -> Restriction' a
forall a b. (a -> b) -> Restriction' a -> Restriction' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Restriction' b -> Restriction' a
$c<$ :: forall a b. a -> Restriction' b -> Restriction' a
fmap :: forall a b. (a -> b) -> Restriction' a -> Restriction' b
$cfmap :: forall a b. (a -> b) -> Restriction' a -> Restriction' b
C.Functor, forall a. Eq a => a -> Restriction' a -> Bool
forall a. Num a => Restriction' a -> a
forall a. Ord a => Restriction' a -> a
forall m. Monoid m => Restriction' m -> m
forall a. Restriction' a -> Bool
forall a. Restriction' a -> Int
forall a. Restriction' a -> [a]
forall a. (a -> a -> a) -> Restriction' a -> a
forall m a. Monoid m => (a -> m) -> Restriction' a -> m
forall b a. (b -> a -> b) -> b -> Restriction' a -> b
forall a b. (a -> b -> b) -> b -> Restriction' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Restriction' a -> a
$cproduct :: forall a. Num a => Restriction' a -> a
sum :: forall a. Num a => Restriction' a -> a
$csum :: forall a. Num a => Restriction' a -> a
minimum :: forall a. Ord a => Restriction' a -> a
$cminimum :: forall a. Ord a => Restriction' a -> a
maximum :: forall a. Ord a => Restriction' a -> a
$cmaximum :: forall a. Ord a => Restriction' a -> a
elem :: forall a. Eq a => a -> Restriction' a -> Bool
$celem :: forall a. Eq a => a -> Restriction' a -> Bool
length :: forall a. Restriction' a -> Int
$clength :: forall a. Restriction' a -> Int
null :: forall a. Restriction' a -> Bool
$cnull :: forall a. Restriction' a -> Bool
toList :: forall a. Restriction' a -> [a]
$ctoList :: forall a. Restriction' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Restriction' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Restriction' a -> a
foldr1 :: forall a. (a -> a -> a) -> Restriction' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Restriction' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Restriction' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Restriction' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Restriction' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Restriction' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Restriction' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Restriction' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Restriction' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Restriction' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Restriction' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Restriction' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Restriction' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Restriction' a -> m
fold :: forall m. Monoid m => Restriction' m -> m
$cfold :: forall m. Monoid m => Restriction' m -> m
C.Foldable, Functor Restriction'
Foldable Restriction'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
Restriction' (m a) -> m (Restriction' a)
forall (f :: * -> *) a.
Applicative f =>
Restriction' (f a) -> f (Restriction' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Restriction' a -> m (Restriction' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Restriction' a -> f (Restriction' b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Restriction' (m a) -> m (Restriction' a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Restriction' (m a) -> m (Restriction' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Restriction' a -> m (Restriction' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Restriction' a -> m (Restriction' b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Restriction' (f a) -> f (Restriction' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Restriction' (f a) -> f (Restriction' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Restriction' a -> f (Restriction' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Restriction' a -> f (Restriction' b)
C.Traversable, Restriction' a -> DataType
Restriction' a -> Constr
forall {a}. Data a => Typeable (Restriction' a)
forall a. Data a => Restriction' a -> DataType
forall a. Data a => Restriction' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Restriction' a -> Restriction' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Restriction' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Restriction' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Restriction' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Restriction' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Restriction' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Restriction' a -> c (Restriction' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Restriction' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Restriction' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Restriction' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Restriction' a -> c (Restriction' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Restriction' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d)
-> Restriction' a -> m (Restriction' a)
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Restriction' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Restriction' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Restriction' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Restriction' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Restriction' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Restriction' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Restriction' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Restriction' a -> r
gmapT :: (forall b. Data b => b -> b) -> Restriction' a -> Restriction' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Restriction' a -> Restriction' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Restriction' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Restriction' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Restriction' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Restriction' a))
dataTypeOf :: Restriction' a -> DataType
$cdataTypeOf :: forall a. Data a => Restriction' a -> DataType
toConstr :: Restriction' a -> Constr
$ctoConstr :: forall a. Data a => Restriction' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Restriction' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Restriction' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Restriction' a -> c (Restriction' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Restriction' a -> c (Restriction' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Restriction' a) x -> Restriction' a
forall a x. Restriction' a -> Rep (Restriction' a) x
$cto :: forall a x. Rep (Restriction' a) x -> Restriction' a
$cfrom :: forall a x. Restriction' a -> Rep (Restriction' a) x
C.Generic)

type Term = Term' BNFC'Position
data Term' a
    = Universe a
    | UniverseCube a
    | UniverseTope a
    | CubeUnit a
    | CubeUnitStar a
    | Cube2 a
    | Cube2_0 a
    | Cube2_1 a
    | CubeProduct a (Term' a) (Term' a)
    | TopeTop a
    | TopeBottom a
    | TopeEQ a (Term' a) (Term' a)
    | TopeLEQ a (Term' a) (Term' a)
    | TopeAnd a (Term' a) (Term' a)
    | TopeOr a (Term' a) (Term' a)
    | RecBottom a
    | RecOr a [Restriction' a]
    | TypeFun a (ParamDecl' a) (Term' a)
    | TypeSigma a (Pattern' a) (Term' a) (Term' a)
    | TypeId a (Term' a) (Term' a) (Term' a)
    | TypeIdSimple a (Term' a) (Term' a)
    | TypeRestricted a (Term' a) [Restriction' a]
    | App a (Term' a) (Term' a)
    | Lambda a [Param' a] (Term' a)
    | Pair a (Term' a) (Term' a)
    | First a (Term' a)
    | Second a (Term' a)
    | Refl a
    | ReflTerm a (Term' a)
    | ReflTermType a (Term' a) (Term' a)
    | IdJ a (Term' a) (Term' a) (Term' a) (Term' a) (Term' a) (Term' a)
    | Hole a HoleIdent
    | Var a VarIdent
    | TypeAsc a (Term' a) (Term' a)
  deriving (Term' a -> Term' a -> Bool
forall a. Eq a => Term' a -> Term' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Term' a -> Term' a -> Bool
$c/= :: forall a. Eq a => Term' a -> Term' a -> Bool
== :: Term' a -> Term' a -> Bool
$c== :: forall a. Eq a => Term' a -> Term' a -> Bool
C.Eq, Term' a -> Term' a -> Ordering
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
forall {a}. Ord a => Eq (Term' a)
forall a. Ord a => Term' a -> Term' a -> Bool
forall a. Ord a => Term' a -> Term' a -> Ordering
forall a. Ord a => Term' a -> Term' a -> Term' a
min :: Term' a -> Term' a -> Term' a
$cmin :: forall a. Ord a => Term' a -> Term' a -> Term' a
max :: Term' a -> Term' a -> Term' a
$cmax :: forall a. Ord a => Term' a -> Term' a -> Term' a
>= :: Term' a -> Term' a -> Bool
$c>= :: forall a. Ord a => Term' a -> Term' a -> Bool
> :: Term' a -> Term' a -> Bool
$c> :: forall a. Ord a => Term' a -> Term' a -> Bool
<= :: Term' a -> Term' a -> Bool
$c<= :: forall a. Ord a => Term' a -> Term' a -> Bool
< :: Term' a -> Term' a -> Bool
$c< :: forall a. Ord a => Term' a -> Term' a -> Bool
compare :: Term' a -> Term' a -> Ordering
$ccompare :: forall a. Ord a => Term' a -> Term' a -> Ordering
C.Ord, Int -> Term' a -> ShowS
forall a. Show a => Int -> Term' a -> ShowS
forall a. Show a => [Term' a] -> ShowS
forall a. Show a => Term' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Term' a] -> ShowS
$cshowList :: forall a. Show a => [Term' a] -> ShowS
show :: Term' a -> String
$cshow :: forall a. Show a => Term' a -> String
showsPrec :: Int -> Term' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Term' a -> ShowS
C.Show, ReadPrec [Term' a]
ReadPrec (Term' a)
ReadS [Term' a]
forall a. Read a => ReadPrec [Term' a]
forall a. Read a => ReadPrec (Term' a)
forall a. Read a => Int -> ReadS (Term' a)
forall a. Read a => ReadS [Term' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Term' a]
$creadListPrec :: forall a. Read a => ReadPrec [Term' a]
readPrec :: ReadPrec (Term' a)
$creadPrec :: forall a. Read a => ReadPrec (Term' a)
readList :: ReadS [Term' a]
$creadList :: forall a. Read a => ReadS [Term' a]
readsPrec :: Int -> ReadS (Term' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Term' a)
C.Read, forall a b. a -> Term' b -> Term' a
forall a b. (a -> b) -> Term' a -> Term' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Term' b -> Term' a
$c<$ :: forall a b. a -> Term' b -> Term' a
fmap :: forall a b. (a -> b) -> Term' a -> Term' b
$cfmap :: forall a b. (a -> b) -> Term' a -> Term' b
C.Functor, forall a. Eq a => a -> Term' a -> Bool
forall a. Num a => Term' a -> a
forall a. Ord a => Term' a -> a
forall m. Monoid m => Term' m -> m
forall a. Term' a -> Bool
forall a. Term' a -> Int
forall a. Term' a -> [a]
forall a. (a -> a -> a) -> Term' a -> a
forall m a. Monoid m => (a -> m) -> Term' a -> m
forall b a. (b -> a -> b) -> b -> Term' a -> b
forall a b. (a -> b -> b) -> b -> Term' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Term' a -> a
$cproduct :: forall a. Num a => Term' a -> a
sum :: forall a. Num a => Term' a -> a
$csum :: forall a. Num a => Term' a -> a
minimum :: forall a. Ord a => Term' a -> a
$cminimum :: forall a. Ord a => Term' a -> a
maximum :: forall a. Ord a => Term' a -> a
$cmaximum :: forall a. Ord a => Term' a -> a
elem :: forall a. Eq a => a -> Term' a -> Bool
$celem :: forall a. Eq a => a -> Term' a -> Bool
length :: forall a. Term' a -> Int
$clength :: forall a. Term' a -> Int
null :: forall a. Term' a -> Bool
$cnull :: forall a. Term' a -> Bool
toList :: forall a. Term' a -> [a]
$ctoList :: forall a. Term' a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Term' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Term' a -> a
foldr1 :: forall a. (a -> a -> a) -> Term' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Term' a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Term' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Term' a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Term' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Term' a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Term' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Term' a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Term' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Term' a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Term' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Term' a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Term' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Term' a -> m
fold :: forall m. Monoid m => Term' m -> m
$cfold :: forall m. Monoid m => Term' m -> m
C.Foldable, Functor Term'
Foldable Term'
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Term' (m a) -> m (Term' a)
forall (f :: * -> *) a. Applicative f => Term' (f a) -> f (Term' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Term' a -> m (Term' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Term' a -> f (Term' b)
sequence :: forall (m :: * -> *) a. Monad m => Term' (m a) -> m (Term' a)
$csequence :: forall (m :: * -> *) a. Monad m => Term' (m a) -> m (Term' a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Term' a -> m (Term' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Term' a -> m (Term' b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Term' (f a) -> f (Term' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Term' (f a) -> f (Term' a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Term' a -> f (Term' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Term' a -> f (Term' b)
C.Traversable, Term' a -> DataType
Term' a -> Constr
forall {a}. Data a => Typeable (Term' a)
forall a. Data a => Term' a -> DataType
forall a. Data a => Term' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Term' a -> Term' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Term' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Term' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' a -> c (Term' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' a -> c (Term' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' a))
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Term' a -> m (Term' a)
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Term' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Term' a -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Term' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Term' a -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Term' a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Term' a -> r
gmapT :: (forall b. Data b => b -> b) -> Term' a -> Term' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Term' a -> Term' a
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Term' a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Term' a))
dataTypeOf :: Term' a -> DataType
$cdataTypeOf :: forall a. Data a => Term' a -> DataType
toConstr :: Term' a -> Constr
$ctoConstr :: forall a. Data a => Term' a -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Term' a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' a -> c (Term' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Term' a -> c (Term' a)
C.Data, C.Typeable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Term' a) x -> Term' a
forall a x. Term' a -> Rep (Term' a) x
$cto :: forall a x. Rep (Term' a) x -> Term' a
$cfrom :: forall a x. Term' a -> Rep (Term' a) x
C.Generic)

commandPostulateNoParams :: a -> VarIdent -> Term' a -> Command' a
commandPostulateNoParams :: forall a. a -> VarIdent -> Term' a -> Command' a
commandPostulateNoParams = \ a
_a VarIdent
x Term' a
ty -> forall a. a -> VarIdent -> [Param' a] -> Term' a -> Command' a
CommandPostulate a
_a VarIdent
x [] Term' a
ty

commandDefineNoParams :: a -> VarIdent -> Term' a -> Term' a -> Command' a
commandDefineNoParams :: forall a. a -> VarIdent -> Term' a -> Term' a -> Command' a
commandDefineNoParams = \ a
_a VarIdent
x Term' a
ty Term' a
term -> forall a.
a -> VarIdent -> [Param' a] -> Term' a -> Term' a -> Command' a
CommandDefine a
_a VarIdent
x [] Term' a
ty Term' a
term

commandDef :: a -> VarIdent -> [Param' a] -> Term' a -> Term' a -> Command' a
commandDef :: forall a.
a -> VarIdent -> [Param' a] -> Term' a -> Term' a -> Command' a
commandDef = \ a
_a VarIdent
x [Param' a]
params Term' a
ty Term' a
term -> forall a.
a -> VarIdent -> [Param' a] -> Term' a -> Term' a -> Command' a
CommandDefine a
_a VarIdent
x [Param' a]
params Term' a
ty Term' a
term

commandDefNoParams :: a -> VarIdent -> Term' a -> Term' a -> Command' a
commandDefNoParams :: forall a. a -> VarIdent -> Term' a -> Term' a -> Command' a
commandDefNoParams = \ a
_a VarIdent
x Term' a
ty Term' a
term -> forall a.
a -> VarIdent -> [Param' a] -> Term' a -> Term' a -> Command' a
CommandDefine a
_a VarIdent
x [] Term' a
ty Term' a
term

paramVarType :: a -> VarIdent -> Term' a -> ParamDecl' a
paramVarType :: forall a. a -> VarIdent -> Term' a -> ParamDecl' a
paramVarType = \ a
_a VarIdent
var Term' a
cube -> forall a. a -> Pattern' a -> Term' a -> ParamDecl' a
ParamVarType a
_a (forall a. a -> VarIdent -> Pattern' a
PatternVar a
_a VarIdent
var) Term' a
cube

paramVarShape :: a -> Pattern' a -> Term' a -> Term' a -> ParamDecl' a
paramVarShape :: forall a. a -> Pattern' a -> Term' a -> Term' a -> ParamDecl' a
paramVarShape = \ a
_a Pattern' a
pat Term' a
cube Term' a
tope -> forall a. a -> Pattern' a -> Term' a -> Term' a -> ParamDecl' a
ParamVarShape a
_a Pattern' a
pat Term' a
cube Term' a
tope

recOr :: a -> Term' a -> Term' a -> Term' a -> Term' a -> Term' a
recOr :: forall a. a -> Term' a -> Term' a -> Term' a -> Term' a -> Term' a
recOr = \ a
_a Term' a
psi Term' a
phi Term' a
a Term' a
b -> forall a. a -> [Restriction' a] -> Term' a
RecOr a
_a [forall a. a -> Term' a -> Term' a -> Restriction' a
Restriction a
_a Term' a
psi Term' a
a, forall a. a -> Term' a -> Term' a -> Restriction' a
Restriction a
_a Term' a
phi Term' a
b]

typeExtension :: a -> ParamDecl' a -> Term' a -> Term' a
typeExtension :: forall a. a -> ParamDecl' a -> Term' a -> Term' a
typeExtension = \ a
_a ParamDecl' a
param Term' a
ret -> forall a. a -> ParamDecl' a -> Term' a -> Term' a
TypeFun a
_a ParamDecl' a
param Term' a
ret

unicode_TypeFun :: a -> ParamDecl' a -> Term' a -> Term' a
unicode_TypeFun :: forall a. a -> ParamDecl' a -> Term' a -> Term' a
unicode_TypeFun = \ a
_a ParamDecl' a
arg Term' a
ret -> forall a. a -> ParamDecl' a -> Term' a -> Term' a
TypeFun a
_a ParamDecl' a
arg Term' a
ret

unicode_TypeSigma :: a -> Pattern' a -> Term' a -> Term' a -> Term' a
unicode_TypeSigma :: forall a. a -> Pattern' a -> Term' a -> Term' a -> Term' a
unicode_TypeSigma = \ a
_a Pattern' a
pat Term' a
fst Term' a
snd -> forall a. a -> Pattern' a -> Term' a -> Term' a -> Term' a
TypeSigma a
_a Pattern' a
pat Term' a
fst Term' a
snd

unicode_TypeSigmaAlt :: a -> Pattern' a -> Term' a -> Term' a -> Term' a
unicode_TypeSigmaAlt :: forall a. a -> Pattern' a -> Term' a -> Term' a -> Term' a
unicode_TypeSigmaAlt = \ a
_a Pattern' a
pat Term' a
fst Term' a
snd -> forall a. a -> Pattern' a -> Term' a -> Term' a -> Term' a
TypeSigma a
_a Pattern' a
pat Term' a
fst Term' a
snd

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

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

-- | Start position (line, column) of something.

type BNFC'Position = C.Maybe (C.Int, C.Int)

pattern BNFC'NoPosition :: BNFC'Position
pattern $bBNFC'NoPosition :: BNFC'Position
$mBNFC'NoPosition :: forall {r}. BNFC'Position -> ((# #) -> r) -> ((# #) -> r) -> r
BNFC'NoPosition = C.Nothing

pattern BNFC'Position :: C.Int -> C.Int -> BNFC'Position
pattern $bBNFC'Position :: Int -> Int -> BNFC'Position
$mBNFC'Position :: forall {r}. BNFC'Position -> (Int -> Int -> r) -> ((# #) -> r) -> r
BNFC'Position line col = C.Just (line, col)

-- | Get the start position of something.

class HasPosition a where
  hasPosition :: a -> BNFC'Position

instance HasPosition Module where
  hasPosition :: Module -> BNFC'Position
hasPosition = \case
    Module BNFC'Position
p LanguageDecl' BNFC'Position
_ [Command' BNFC'Position]
_ -> BNFC'Position
p

instance HasPosition LanguageDecl where
  hasPosition :: LanguageDecl' BNFC'Position -> BNFC'Position
hasPosition = \case
    LanguageDecl BNFC'Position
p Language' BNFC'Position
_ -> BNFC'Position
p

instance HasPosition Language where
  hasPosition :: Language' BNFC'Position -> BNFC'Position
hasPosition = \case
    Rzk1 BNFC'Position
p -> BNFC'Position
p

instance HasPosition Command where
  hasPosition :: Command' BNFC'Position -> BNFC'Position
hasPosition = \case
    CommandSetOption BNFC'Position
p String
_ String
_ -> BNFC'Position
p
    CommandUnsetOption BNFC'Position
p String
_ -> BNFC'Position
p
    CommandCheck BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    CommandCompute BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    CommandComputeWHNF BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    CommandComputeNF BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    CommandPostulate BNFC'Position
p VarIdent
_ [Param' BNFC'Position]
_ Term' BNFC'Position
_ -> BNFC'Position
p
    CommandDefine BNFC'Position
p VarIdent
_ [Param' BNFC'Position]
_ Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p

instance HasPosition Pattern where
  hasPosition :: Pattern -> BNFC'Position
hasPosition = \case
    PatternWildcard BNFC'Position
p -> BNFC'Position
p
    PatternVar BNFC'Position
p VarIdent
_ -> BNFC'Position
p
    PatternPair BNFC'Position
p Pattern
_ Pattern
_ -> BNFC'Position
p

instance HasPosition Param where
  hasPosition :: Param' BNFC'Position -> BNFC'Position
hasPosition = \case
    ParamPattern BNFC'Position
p Pattern
_ -> BNFC'Position
p
    ParamPatternType BNFC'Position
p [Pattern]
_ Term' BNFC'Position
_ -> BNFC'Position
p
    ParamPatternShape BNFC'Position
p Pattern
_ Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p

instance HasPosition ParamDecl where
  hasPosition :: ParamDecl -> BNFC'Position
hasPosition = \case
    ParamType BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    ParamWildcardType BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    ParamVarType BNFC'Position
p Pattern
_ Term' BNFC'Position
_ -> BNFC'Position
p
    ParamVarShape BNFC'Position
p Pattern
_ Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p

instance HasPosition Restriction where
  hasPosition :: Restriction -> BNFC'Position
hasPosition = \case
    Restriction BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p

instance HasPosition Term where
  hasPosition :: Term' BNFC'Position -> BNFC'Position
hasPosition = \case
    Universe BNFC'Position
p -> BNFC'Position
p
    UniverseCube BNFC'Position
p -> BNFC'Position
p
    UniverseTope BNFC'Position
p -> BNFC'Position
p
    CubeUnit BNFC'Position
p -> BNFC'Position
p
    CubeUnitStar BNFC'Position
p -> BNFC'Position
p
    Cube2 BNFC'Position
p -> BNFC'Position
p
    Cube2_0 BNFC'Position
p -> BNFC'Position
p
    Cube2_1 BNFC'Position
p -> BNFC'Position
p
    CubeProduct BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TopeTop BNFC'Position
p -> BNFC'Position
p
    TopeBottom BNFC'Position
p -> BNFC'Position
p
    TopeEQ BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TopeLEQ BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TopeAnd BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TopeOr BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    RecBottom BNFC'Position
p -> BNFC'Position
p
    RecOr BNFC'Position
p [Restriction]
_ -> BNFC'Position
p
    TypeFun BNFC'Position
p ParamDecl
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TypeSigma BNFC'Position
p Pattern
_ Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TypeId BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TypeIdSimple BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    TypeRestricted BNFC'Position
p Term' BNFC'Position
_ [Restriction]
_ -> BNFC'Position
p
    App BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    Lambda BNFC'Position
p [Param' BNFC'Position]
_ Term' BNFC'Position
_ -> BNFC'Position
p
    Pair BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    First BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    Second BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    Refl BNFC'Position
p -> BNFC'Position
p
    ReflTerm BNFC'Position
p Term' BNFC'Position
_ -> BNFC'Position
p
    ReflTermType BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    IdJ BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ Term' BNFC'Position
_ Term' BNFC'Position
_ Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    Hole BNFC'Position
p HoleIdent
_ -> BNFC'Position
p
    Var BNFC'Position
p VarIdent
_ -> BNFC'Position
p
    TypeAsc BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p