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

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

-- | The abstract syntax of language Syntax.

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

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

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

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

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

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

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

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

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

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

-- | Get the start position of something.

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

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

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

instance HasPosition Term where
  hasPosition :: Term' BNFC'Position -> BNFC'Position
hasPosition = \case
    Var BNFC'Position
p VarIdent
_ -> BNFC'Position
p
    Pi BNFC'Position
p Pattern' BNFC'Position
_ Term' BNFC'Position
_ ScopedTerm' BNFC'Position
_ -> BNFC'Position
p
    Lam BNFC'Position
p Pattern' BNFC'Position
_ ScopedTerm' BNFC'Position
_ -> BNFC'Position
p
    App BNFC'Position
p Term' BNFC'Position
_ Term' BNFC'Position
_ -> BNFC'Position
p
    Product BNFC'Position
p Term' 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
    Universe BNFC'Position
p -> BNFC'Position
p

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

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