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

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

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

type Pattern = Pattern' BNFC'Position
data Pattern' a
    = PatternWildcard a
    | PatternUnit a
    | PatternVar a (VarIdent' a)
    | 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 -> 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)
    | TypeUnit 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)
    | Unit 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' a)
    | Var a (VarIdent' a)
    | 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' a -> DeclUsedVars' a -> Term' a -> Command' a
commandPostulateNoParams :: forall a.
a -> VarIdent' a -> DeclUsedVars' a -> Term' a -> Command' a
commandPostulateNoParams = \ a
_a VarIdent' a
x DeclUsedVars' a
vars Term' a
ty -> forall a.
a
-> VarIdent' a
-> DeclUsedVars' a
-> [Param' a]
-> Term' a
-> Command' a
CommandPostulate a
_a VarIdent' a
x DeclUsedVars' a
vars [] Term' a
ty

commandVariable :: a -> VarIdent' a -> Term' a -> Command' a
commandVariable :: forall a. a -> VarIdent' a -> Term' a -> Command' a
commandVariable = \ a
_a VarIdent' a
name Term' a
term -> forall a. a -> [VarIdent' a] -> Term' a -> Command' a
CommandAssume a
_a [VarIdent' a
name] Term' a
term

commandVariables :: a -> [VarIdent' a] -> Term' a -> Command' a
commandVariables :: forall a. a -> [VarIdent' a] -> Term' a -> Command' a
commandVariables = \ a
_a [VarIdent' a]
names Term' a
term -> forall a. a -> [VarIdent' a] -> Term' a -> Command' a
CommandAssume a
_a [VarIdent' a]
names Term' a
term

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

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

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

noDeclUsedVars :: a -> DeclUsedVars' a
noDeclUsedVars :: forall a. a -> DeclUsedVars' a
noDeclUsedVars = \ a
_a -> forall a. a -> [VarIdent' a] -> DeclUsedVars' a
DeclUsedVars a
_a []

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

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

instance HasPosition VarIdent where
  hasPosition :: VarIdent -> BNFC'Position
hasPosition = \case
    VarIdent BNFC'Position
p VarIdentToken
_ -> 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
_ DeclUsedVars' BNFC'Position
_ [Param' BNFC'Position]
_ Term' BNFC'Position
_ -> BNFC'Position
p
    CommandAssume BNFC'Position
p [VarIdent]
_ Term' BNFC'Position
_ -> BNFC'Position
p
    CommandSection BNFC'Position
p SectionName' BNFC'Position
_ [Command' BNFC'Position]
_ SectionName' BNFC'Position
_ -> BNFC'Position
p
    CommandDefine BNFC'Position
p VarIdent
_ DeclUsedVars' BNFC'Position
_ [Param' BNFC'Position]
_ Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p

instance HasPosition DeclUsedVars where
  hasPosition :: DeclUsedVars' BNFC'Position -> BNFC'Position
hasPosition = \case
    DeclUsedVars BNFC'Position
p [VarIdent]
_ -> BNFC'Position
p

instance HasPosition SectionName where
  hasPosition :: SectionName' BNFC'Position -> BNFC'Position
hasPosition = \case
    NoSectionName BNFC'Position
p -> BNFC'Position
p
    SomeSectionName BNFC'Position
p VarIdent
_ -> BNFC'Position
p

instance HasPosition Pattern where
  hasPosition :: Pattern -> BNFC'Position
hasPosition = \case
    PatternWildcard BNFC'Position
p -> BNFC'Position
p
    PatternUnit 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
    TypeUnit BNFC'Position
p -> 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
    Unit BNFC'Position
p -> 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