-- Haskell data types for the abstract syntax.
-- Generated by the BNF converter.

{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternSynonyms #-}

-- | The abstract syntax of language BNFC.

module BNFC.Abs where

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

type Grammar = Grammar' BNFC'Position
data Grammar' a = Grammar a [Def' a]
  deriving (Grammar' a -> Grammar' a -> Bool
(Grammar' a -> Grammar' a -> Bool)
-> (Grammar' a -> Grammar' a -> Bool) -> Eq (Grammar' a)
forall a. Eq a => Grammar' a -> Grammar' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Grammar' a -> Grammar' a -> Bool
$c/= :: forall a. Eq a => Grammar' a -> Grammar' a -> Bool
== :: Grammar' a -> Grammar' a -> Bool
$c== :: forall a. Eq a => Grammar' a -> Grammar' a -> Bool
C.Eq, Eq (Grammar' a)
Eq (Grammar' a)
-> (Grammar' a -> Grammar' a -> Ordering)
-> (Grammar' a -> Grammar' a -> Bool)
-> (Grammar' a -> Grammar' a -> Bool)
-> (Grammar' a -> Grammar' a -> Bool)
-> (Grammar' a -> Grammar' a -> Bool)
-> (Grammar' a -> Grammar' a -> Grammar' a)
-> (Grammar' a -> Grammar' a -> Grammar' a)
-> Ord (Grammar' a)
Grammar' a -> Grammar' a -> Bool
Grammar' a -> Grammar' a -> Ordering
Grammar' a -> Grammar' a -> Grammar' 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 (Grammar' a)
forall a. Ord a => Grammar' a -> Grammar' a -> Bool
forall a. Ord a => Grammar' a -> Grammar' a -> Ordering
forall a. Ord a => Grammar' a -> Grammar' a -> Grammar' a
min :: Grammar' a -> Grammar' a -> Grammar' a
$cmin :: forall a. Ord a => Grammar' a -> Grammar' a -> Grammar' a
max :: Grammar' a -> Grammar' a -> Grammar' a
$cmax :: forall a. Ord a => Grammar' a -> Grammar' a -> Grammar' a
>= :: Grammar' a -> Grammar' a -> Bool
$c>= :: forall a. Ord a => Grammar' a -> Grammar' a -> Bool
> :: Grammar' a -> Grammar' a -> Bool
$c> :: forall a. Ord a => Grammar' a -> Grammar' a -> Bool
<= :: Grammar' a -> Grammar' a -> Bool
$c<= :: forall a. Ord a => Grammar' a -> Grammar' a -> Bool
< :: Grammar' a -> Grammar' a -> Bool
$c< :: forall a. Ord a => Grammar' a -> Grammar' a -> Bool
compare :: Grammar' a -> Grammar' a -> Ordering
$ccompare :: forall a. Ord a => Grammar' a -> Grammar' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Grammar' a)
C.Ord, Int -> Grammar' a -> ShowS
[Grammar' a] -> ShowS
Grammar' a -> String
(Int -> Grammar' a -> ShowS)
-> (Grammar' a -> String)
-> ([Grammar' a] -> ShowS)
-> Show (Grammar' a)
forall a. Show a => Int -> Grammar' a -> ShowS
forall a. Show a => [Grammar' a] -> ShowS
forall a. Show a => Grammar' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Grammar' a] -> ShowS
$cshowList :: forall a. Show a => [Grammar' a] -> ShowS
show :: Grammar' a -> String
$cshow :: forall a. Show a => Grammar' a -> String
showsPrec :: Int -> Grammar' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Grammar' a -> ShowS
C.Show, ReadPrec [Grammar' a]
ReadPrec (Grammar' a)
Int -> ReadS (Grammar' a)
ReadS [Grammar' a]
(Int -> ReadS (Grammar' a))
-> ReadS [Grammar' a]
-> ReadPrec (Grammar' a)
-> ReadPrec [Grammar' a]
-> Read (Grammar' a)
forall a. Read a => ReadPrec [Grammar' a]
forall a. Read a => ReadPrec (Grammar' a)
forall a. Read a => Int -> ReadS (Grammar' a)
forall a. Read a => ReadS [Grammar' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Grammar' a]
$creadListPrec :: forall a. Read a => ReadPrec [Grammar' a]
readPrec :: ReadPrec (Grammar' a)
$creadPrec :: forall a. Read a => ReadPrec (Grammar' a)
readList :: ReadS [Grammar' a]
$creadList :: forall a. Read a => ReadS [Grammar' a]
readsPrec :: Int -> ReadS (Grammar' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Grammar' a)
C.Read, a -> Grammar' b -> Grammar' a
(a -> b) -> Grammar' a -> Grammar' b
(forall a b. (a -> b) -> Grammar' a -> Grammar' b)
-> (forall a b. a -> Grammar' b -> Grammar' a) -> Functor Grammar'
forall a b. a -> Grammar' b -> Grammar' a
forall a b. (a -> b) -> Grammar' a -> Grammar' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Grammar' b -> Grammar' a
$c<$ :: forall a b. a -> Grammar' b -> Grammar' a
fmap :: (a -> b) -> Grammar' a -> Grammar' b
$cfmap :: forall a b. (a -> b) -> Grammar' a -> Grammar' b
C.Functor, Grammar' a -> Bool
(a -> m) -> Grammar' a -> m
(a -> b -> b) -> b -> Grammar' a -> b
(forall m. Monoid m => Grammar' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Grammar' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Grammar' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Grammar' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Grammar' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Grammar' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Grammar' a -> b)
-> (forall a. (a -> a -> a) -> Grammar' a -> a)
-> (forall a. (a -> a -> a) -> Grammar' a -> a)
-> (forall a. Grammar' a -> [a])
-> (forall a. Grammar' a -> Bool)
-> (forall a. Grammar' a -> Int)
-> (forall a. Eq a => a -> Grammar' a -> Bool)
-> (forall a. Ord a => Grammar' a -> a)
-> (forall a. Ord a => Grammar' a -> a)
-> (forall a. Num a => Grammar' a -> a)
-> (forall a. Num a => Grammar' a -> a)
-> Foldable Grammar'
forall a. Eq a => a -> Grammar' a -> Bool
forall a. Num a => Grammar' a -> a
forall a. Ord a => Grammar' a -> a
forall m. Monoid m => Grammar' m -> m
forall a. Grammar' a -> Bool
forall a. Grammar' a -> Int
forall a. Grammar' a -> [a]
forall a. (a -> a -> a) -> Grammar' a -> a
forall m a. Monoid m => (a -> m) -> Grammar' a -> m
forall b a. (b -> a -> b) -> b -> Grammar' a -> b
forall a b. (a -> b -> b) -> b -> Grammar' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Grammar' a -> a
$cproduct :: forall a. Num a => Grammar' a -> a
sum :: Grammar' a -> a
$csum :: forall a. Num a => Grammar' a -> a
minimum :: Grammar' a -> a
$cminimum :: forall a. Ord a => Grammar' a -> a
maximum :: Grammar' a -> a
$cmaximum :: forall a. Ord a => Grammar' a -> a
elem :: a -> Grammar' a -> Bool
$celem :: forall a. Eq a => a -> Grammar' a -> Bool
length :: Grammar' a -> Int
$clength :: forall a. Grammar' a -> Int
null :: Grammar' a -> Bool
$cnull :: forall a. Grammar' a -> Bool
toList :: Grammar' a -> [a]
$ctoList :: forall a. Grammar' a -> [a]
foldl1 :: (a -> a -> a) -> Grammar' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Grammar' a -> a
foldr1 :: (a -> a -> a) -> Grammar' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Grammar' a -> a
foldl' :: (b -> a -> b) -> b -> Grammar' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Grammar' a -> b
foldl :: (b -> a -> b) -> b -> Grammar' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Grammar' a -> b
foldr' :: (a -> b -> b) -> b -> Grammar' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Grammar' a -> b
foldr :: (a -> b -> b) -> b -> Grammar' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Grammar' a -> b
foldMap' :: (a -> m) -> Grammar' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Grammar' a -> m
foldMap :: (a -> m) -> Grammar' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Grammar' a -> m
fold :: Grammar' m -> m
$cfold :: forall m. Monoid m => Grammar' m -> m
C.Foldable, Functor Grammar'
Foldable Grammar'
Functor Grammar'
-> Foldable Grammar'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Grammar' a -> f (Grammar' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Grammar' (f a) -> f (Grammar' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Grammar' a -> m (Grammar' b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Grammar' (m a) -> m (Grammar' a))
-> Traversable Grammar'
(a -> f b) -> Grammar' a -> f (Grammar' b)
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 => Grammar' (m a) -> m (Grammar' a)
forall (f :: * -> *) a.
Applicative f =>
Grammar' (f a) -> f (Grammar' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Grammar' a -> m (Grammar' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Grammar' a -> f (Grammar' b)
sequence :: Grammar' (m a) -> m (Grammar' a)
$csequence :: forall (m :: * -> *) a. Monad m => Grammar' (m a) -> m (Grammar' a)
mapM :: (a -> m b) -> Grammar' a -> m (Grammar' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Grammar' a -> m (Grammar' b)
sequenceA :: Grammar' (f a) -> f (Grammar' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Grammar' (f a) -> f (Grammar' a)
traverse :: (a -> f b) -> Grammar' a -> f (Grammar' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Grammar' a -> f (Grammar' b)
$cp2Traversable :: Foldable Grammar'
$cp1Traversable :: Functor Grammar'
C.Traversable)

type Def = Def' BNFC'Position
data Def' a
    = Rule a (Label' a) (Cat' a) (RHS' a)
    | Comment a String
    | Comments a String String
    | Internal a (Label' a) (Cat' a) (RHS' a)
    | Token a Identifier (Reg' a)
    | PosToken a Identifier (Reg' a)
    | Entryp a [Cat' a]
    | Separator a (MinimumSize' a) (Cat' a) String
    | Terminator a (MinimumSize' a) (Cat' a) String
    | Delimiters a (Cat' a) String String (Separation' a) (MinimumSize' a)
    | Coercions a Identifier Integer
    | Rules a Identifier [RHS' a]
    | Function a Identifier [Arg' a] (Exp' a)
    | Layout a [String]
    | LayoutStop a [String]
    | LayoutTop a
  deriving (Def' a -> Def' a -> Bool
(Def' a -> Def' a -> Bool)
-> (Def' a -> Def' a -> Bool) -> Eq (Def' a)
forall a. Eq a => Def' a -> Def' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Def' a -> Def' a -> Bool
$c/= :: forall a. Eq a => Def' a -> Def' a -> Bool
== :: Def' a -> Def' a -> Bool
$c== :: forall a. Eq a => Def' a -> Def' a -> Bool
C.Eq, Eq (Def' a)
Eq (Def' a)
-> (Def' a -> Def' a -> Ordering)
-> (Def' a -> Def' a -> Bool)
-> (Def' a -> Def' a -> Bool)
-> (Def' a -> Def' a -> Bool)
-> (Def' a -> Def' a -> Bool)
-> (Def' a -> Def' a -> Def' a)
-> (Def' a -> Def' a -> Def' a)
-> Ord (Def' a)
Def' a -> Def' a -> Bool
Def' a -> Def' a -> Ordering
Def' a -> Def' a -> Def' 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 (Def' a)
forall a. Ord a => Def' a -> Def' a -> Bool
forall a. Ord a => Def' a -> Def' a -> Ordering
forall a. Ord a => Def' a -> Def' a -> Def' a
min :: Def' a -> Def' a -> Def' a
$cmin :: forall a. Ord a => Def' a -> Def' a -> Def' a
max :: Def' a -> Def' a -> Def' a
$cmax :: forall a. Ord a => Def' a -> Def' a -> Def' a
>= :: Def' a -> Def' a -> Bool
$c>= :: forall a. Ord a => Def' a -> Def' a -> Bool
> :: Def' a -> Def' a -> Bool
$c> :: forall a. Ord a => Def' a -> Def' a -> Bool
<= :: Def' a -> Def' a -> Bool
$c<= :: forall a. Ord a => Def' a -> Def' a -> Bool
< :: Def' a -> Def' a -> Bool
$c< :: forall a. Ord a => Def' a -> Def' a -> Bool
compare :: Def' a -> Def' a -> Ordering
$ccompare :: forall a. Ord a => Def' a -> Def' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Def' a)
C.Ord, Int -> Def' a -> ShowS
[Def' a] -> ShowS
Def' a -> String
(Int -> Def' a -> ShowS)
-> (Def' a -> String) -> ([Def' a] -> ShowS) -> Show (Def' a)
forall a. Show a => Int -> Def' a -> ShowS
forall a. Show a => [Def' a] -> ShowS
forall a. Show a => Def' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Def' a] -> ShowS
$cshowList :: forall a. Show a => [Def' a] -> ShowS
show :: Def' a -> String
$cshow :: forall a. Show a => Def' a -> String
showsPrec :: Int -> Def' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Def' a -> ShowS
C.Show, ReadPrec [Def' a]
ReadPrec (Def' a)
Int -> ReadS (Def' a)
ReadS [Def' a]
(Int -> ReadS (Def' a))
-> ReadS [Def' a]
-> ReadPrec (Def' a)
-> ReadPrec [Def' a]
-> Read (Def' a)
forall a. Read a => ReadPrec [Def' a]
forall a. Read a => ReadPrec (Def' a)
forall a. Read a => Int -> ReadS (Def' a)
forall a. Read a => ReadS [Def' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Def' a]
$creadListPrec :: forall a. Read a => ReadPrec [Def' a]
readPrec :: ReadPrec (Def' a)
$creadPrec :: forall a. Read a => ReadPrec (Def' a)
readList :: ReadS [Def' a]
$creadList :: forall a. Read a => ReadS [Def' a]
readsPrec :: Int -> ReadS (Def' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Def' a)
C.Read, a -> Def' b -> Def' a
(a -> b) -> Def' a -> Def' b
(forall a b. (a -> b) -> Def' a -> Def' b)
-> (forall a b. a -> Def' b -> Def' a) -> Functor Def'
forall a b. a -> Def' b -> Def' a
forall a b. (a -> b) -> Def' a -> Def' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Def' b -> Def' a
$c<$ :: forall a b. a -> Def' b -> Def' a
fmap :: (a -> b) -> Def' a -> Def' b
$cfmap :: forall a b. (a -> b) -> Def' a -> Def' b
C.Functor, Def' a -> Bool
(a -> m) -> Def' a -> m
(a -> b -> b) -> b -> Def' a -> b
(forall m. Monoid m => Def' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Def' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Def' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Def' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Def' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Def' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Def' a -> b)
-> (forall a. (a -> a -> a) -> Def' a -> a)
-> (forall a. (a -> a -> a) -> Def' a -> a)
-> (forall a. Def' a -> [a])
-> (forall a. Def' a -> Bool)
-> (forall a. Def' a -> Int)
-> (forall a. Eq a => a -> Def' a -> Bool)
-> (forall a. Ord a => Def' a -> a)
-> (forall a. Ord a => Def' a -> a)
-> (forall a. Num a => Def' a -> a)
-> (forall a. Num a => Def' a -> a)
-> Foldable Def'
forall a. Eq a => a -> Def' a -> Bool
forall a. Num a => Def' a -> a
forall a. Ord a => Def' a -> a
forall m. Monoid m => Def' m -> m
forall a. Def' a -> Bool
forall a. Def' a -> Int
forall a. Def' a -> [a]
forall a. (a -> a -> a) -> Def' a -> a
forall m a. Monoid m => (a -> m) -> Def' a -> m
forall b a. (b -> a -> b) -> b -> Def' a -> b
forall a b. (a -> b -> b) -> b -> Def' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Def' a -> a
$cproduct :: forall a. Num a => Def' a -> a
sum :: Def' a -> a
$csum :: forall a. Num a => Def' a -> a
minimum :: Def' a -> a
$cminimum :: forall a. Ord a => Def' a -> a
maximum :: Def' a -> a
$cmaximum :: forall a. Ord a => Def' a -> a
elem :: a -> Def' a -> Bool
$celem :: forall a. Eq a => a -> Def' a -> Bool
length :: Def' a -> Int
$clength :: forall a. Def' a -> Int
null :: Def' a -> Bool
$cnull :: forall a. Def' a -> Bool
toList :: Def' a -> [a]
$ctoList :: forall a. Def' a -> [a]
foldl1 :: (a -> a -> a) -> Def' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Def' a -> a
foldr1 :: (a -> a -> a) -> Def' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Def' a -> a
foldl' :: (b -> a -> b) -> b -> Def' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Def' a -> b
foldl :: (b -> a -> b) -> b -> Def' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Def' a -> b
foldr' :: (a -> b -> b) -> b -> Def' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Def' a -> b
foldr :: (a -> b -> b) -> b -> Def' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Def' a -> b
foldMap' :: (a -> m) -> Def' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Def' a -> m
foldMap :: (a -> m) -> Def' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Def' a -> m
fold :: Def' m -> m
$cfold :: forall m. Monoid m => Def' m -> m
C.Foldable, Functor Def'
Foldable Def'
Functor Def'
-> Foldable Def'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Def' a -> f (Def' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Def' (f a) -> f (Def' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Def' a -> m (Def' b))
-> (forall (m :: * -> *) a. Monad m => Def' (m a) -> m (Def' a))
-> Traversable Def'
(a -> f b) -> Def' a -> f (Def' b)
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 => Def' (m a) -> m (Def' a)
forall (f :: * -> *) a. Applicative f => Def' (f a) -> f (Def' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Def' a -> m (Def' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Def' a -> f (Def' b)
sequence :: Def' (m a) -> m (Def' a)
$csequence :: forall (m :: * -> *) a. Monad m => Def' (m a) -> m (Def' a)
mapM :: (a -> m b) -> Def' a -> m (Def' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Def' a -> m (Def' b)
sequenceA :: Def' (f a) -> f (Def' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Def' (f a) -> f (Def' a)
traverse :: (a -> f b) -> Def' a -> f (Def' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Def' a -> f (Def' b)
$cp2Traversable :: Foldable Def'
$cp1Traversable :: Functor Def'
C.Traversable)

type Item = Item' BNFC'Position
data Item' a = Terminal a String | NTerminal a (Cat' a)
  deriving (Item' a -> Item' a -> Bool
(Item' a -> Item' a -> Bool)
-> (Item' a -> Item' a -> Bool) -> Eq (Item' a)
forall a. Eq a => Item' a -> Item' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Item' a -> Item' a -> Bool
$c/= :: forall a. Eq a => Item' a -> Item' a -> Bool
== :: Item' a -> Item' a -> Bool
$c== :: forall a. Eq a => Item' a -> Item' a -> Bool
C.Eq, Eq (Item' a)
Eq (Item' a)
-> (Item' a -> Item' a -> Ordering)
-> (Item' a -> Item' a -> Bool)
-> (Item' a -> Item' a -> Bool)
-> (Item' a -> Item' a -> Bool)
-> (Item' a -> Item' a -> Bool)
-> (Item' a -> Item' a -> Item' a)
-> (Item' a -> Item' a -> Item' a)
-> Ord (Item' a)
Item' a -> Item' a -> Bool
Item' a -> Item' a -> Ordering
Item' a -> Item' a -> Item' 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 (Item' a)
forall a. Ord a => Item' a -> Item' a -> Bool
forall a. Ord a => Item' a -> Item' a -> Ordering
forall a. Ord a => Item' a -> Item' a -> Item' a
min :: Item' a -> Item' a -> Item' a
$cmin :: forall a. Ord a => Item' a -> Item' a -> Item' a
max :: Item' a -> Item' a -> Item' a
$cmax :: forall a. Ord a => Item' a -> Item' a -> Item' a
>= :: Item' a -> Item' a -> Bool
$c>= :: forall a. Ord a => Item' a -> Item' a -> Bool
> :: Item' a -> Item' a -> Bool
$c> :: forall a. Ord a => Item' a -> Item' a -> Bool
<= :: Item' a -> Item' a -> Bool
$c<= :: forall a. Ord a => Item' a -> Item' a -> Bool
< :: Item' a -> Item' a -> Bool
$c< :: forall a. Ord a => Item' a -> Item' a -> Bool
compare :: Item' a -> Item' a -> Ordering
$ccompare :: forall a. Ord a => Item' a -> Item' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Item' a)
C.Ord, Int -> Item' a -> ShowS
[Item' a] -> ShowS
Item' a -> String
(Int -> Item' a -> ShowS)
-> (Item' a -> String) -> ([Item' a] -> ShowS) -> Show (Item' a)
forall a. Show a => Int -> Item' a -> ShowS
forall a. Show a => [Item' a] -> ShowS
forall a. Show a => Item' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Item' a] -> ShowS
$cshowList :: forall a. Show a => [Item' a] -> ShowS
show :: Item' a -> String
$cshow :: forall a. Show a => Item' a -> String
showsPrec :: Int -> Item' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Item' a -> ShowS
C.Show, ReadPrec [Item' a]
ReadPrec (Item' a)
Int -> ReadS (Item' a)
ReadS [Item' a]
(Int -> ReadS (Item' a))
-> ReadS [Item' a]
-> ReadPrec (Item' a)
-> ReadPrec [Item' a]
-> Read (Item' a)
forall a. Read a => ReadPrec [Item' a]
forall a. Read a => ReadPrec (Item' a)
forall a. Read a => Int -> ReadS (Item' a)
forall a. Read a => ReadS [Item' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Item' a]
$creadListPrec :: forall a. Read a => ReadPrec [Item' a]
readPrec :: ReadPrec (Item' a)
$creadPrec :: forall a. Read a => ReadPrec (Item' a)
readList :: ReadS [Item' a]
$creadList :: forall a. Read a => ReadS [Item' a]
readsPrec :: Int -> ReadS (Item' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Item' a)
C.Read, a -> Item' b -> Item' a
(a -> b) -> Item' a -> Item' b
(forall a b. (a -> b) -> Item' a -> Item' b)
-> (forall a b. a -> Item' b -> Item' a) -> Functor Item'
forall a b. a -> Item' b -> Item' a
forall a b. (a -> b) -> Item' a -> Item' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Item' b -> Item' a
$c<$ :: forall a b. a -> Item' b -> Item' a
fmap :: (a -> b) -> Item' a -> Item' b
$cfmap :: forall a b. (a -> b) -> Item' a -> Item' b
C.Functor, Item' a -> Bool
(a -> m) -> Item' a -> m
(a -> b -> b) -> b -> Item' a -> b
(forall m. Monoid m => Item' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Item' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Item' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Item' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Item' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Item' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Item' a -> b)
-> (forall a. (a -> a -> a) -> Item' a -> a)
-> (forall a. (a -> a -> a) -> Item' a -> a)
-> (forall a. Item' a -> [a])
-> (forall a. Item' a -> Bool)
-> (forall a. Item' a -> Int)
-> (forall a. Eq a => a -> Item' a -> Bool)
-> (forall a. Ord a => Item' a -> a)
-> (forall a. Ord a => Item' a -> a)
-> (forall a. Num a => Item' a -> a)
-> (forall a. Num a => Item' a -> a)
-> Foldable Item'
forall a. Eq a => a -> Item' a -> Bool
forall a. Num a => Item' a -> a
forall a. Ord a => Item' a -> a
forall m. Monoid m => Item' m -> m
forall a. Item' a -> Bool
forall a. Item' a -> Int
forall a. Item' a -> [a]
forall a. (a -> a -> a) -> Item' a -> a
forall m a. Monoid m => (a -> m) -> Item' a -> m
forall b a. (b -> a -> b) -> b -> Item' a -> b
forall a b. (a -> b -> b) -> b -> Item' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Item' a -> a
$cproduct :: forall a. Num a => Item' a -> a
sum :: Item' a -> a
$csum :: forall a. Num a => Item' a -> a
minimum :: Item' a -> a
$cminimum :: forall a. Ord a => Item' a -> a
maximum :: Item' a -> a
$cmaximum :: forall a. Ord a => Item' a -> a
elem :: a -> Item' a -> Bool
$celem :: forall a. Eq a => a -> Item' a -> Bool
length :: Item' a -> Int
$clength :: forall a. Item' a -> Int
null :: Item' a -> Bool
$cnull :: forall a. Item' a -> Bool
toList :: Item' a -> [a]
$ctoList :: forall a. Item' a -> [a]
foldl1 :: (a -> a -> a) -> Item' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Item' a -> a
foldr1 :: (a -> a -> a) -> Item' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Item' a -> a
foldl' :: (b -> a -> b) -> b -> Item' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Item' a -> b
foldl :: (b -> a -> b) -> b -> Item' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Item' a -> b
foldr' :: (a -> b -> b) -> b -> Item' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Item' a -> b
foldr :: (a -> b -> b) -> b -> Item' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Item' a -> b
foldMap' :: (a -> m) -> Item' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Item' a -> m
foldMap :: (a -> m) -> Item' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Item' a -> m
fold :: Item' m -> m
$cfold :: forall m. Monoid m => Item' m -> m
C.Foldable, Functor Item'
Foldable Item'
Functor Item'
-> Foldable Item'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Item' a -> f (Item' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Item' (f a) -> f (Item' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Item' a -> m (Item' b))
-> (forall (m :: * -> *) a. Monad m => Item' (m a) -> m (Item' a))
-> Traversable Item'
(a -> f b) -> Item' a -> f (Item' b)
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 => Item' (m a) -> m (Item' a)
forall (f :: * -> *) a. Applicative f => Item' (f a) -> f (Item' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Item' a -> m (Item' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Item' a -> f (Item' b)
sequence :: Item' (m a) -> m (Item' a)
$csequence :: forall (m :: * -> *) a. Monad m => Item' (m a) -> m (Item' a)
mapM :: (a -> m b) -> Item' a -> m (Item' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Item' a -> m (Item' b)
sequenceA :: Item' (f a) -> f (Item' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Item' (f a) -> f (Item' a)
traverse :: (a -> f b) -> Item' a -> f (Item' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Item' a -> f (Item' b)
$cp2Traversable :: Foldable Item'
$cp1Traversable :: Functor Item'
C.Traversable)

type Cat = Cat' BNFC'Position
data Cat' a = ListCat a (Cat' a) | IdCat a Identifier
  deriving (Cat' a -> Cat' a -> Bool
(Cat' a -> Cat' a -> Bool)
-> (Cat' a -> Cat' a -> Bool) -> Eq (Cat' a)
forall a. Eq a => Cat' a -> Cat' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cat' a -> Cat' a -> Bool
$c/= :: forall a. Eq a => Cat' a -> Cat' a -> Bool
== :: Cat' a -> Cat' a -> Bool
$c== :: forall a. Eq a => Cat' a -> Cat' a -> Bool
C.Eq, Eq (Cat' a)
Eq (Cat' a)
-> (Cat' a -> Cat' a -> Ordering)
-> (Cat' a -> Cat' a -> Bool)
-> (Cat' a -> Cat' a -> Bool)
-> (Cat' a -> Cat' a -> Bool)
-> (Cat' a -> Cat' a -> Bool)
-> (Cat' a -> Cat' a -> Cat' a)
-> (Cat' a -> Cat' a -> Cat' a)
-> Ord (Cat' a)
Cat' a -> Cat' a -> Bool
Cat' a -> Cat' a -> Ordering
Cat' a -> Cat' a -> Cat' 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 (Cat' a)
forall a. Ord a => Cat' a -> Cat' a -> Bool
forall a. Ord a => Cat' a -> Cat' a -> Ordering
forall a. Ord a => Cat' a -> Cat' a -> Cat' a
min :: Cat' a -> Cat' a -> Cat' a
$cmin :: forall a. Ord a => Cat' a -> Cat' a -> Cat' a
max :: Cat' a -> Cat' a -> Cat' a
$cmax :: forall a. Ord a => Cat' a -> Cat' a -> Cat' a
>= :: Cat' a -> Cat' a -> Bool
$c>= :: forall a. Ord a => Cat' a -> Cat' a -> Bool
> :: Cat' a -> Cat' a -> Bool
$c> :: forall a. Ord a => Cat' a -> Cat' a -> Bool
<= :: Cat' a -> Cat' a -> Bool
$c<= :: forall a. Ord a => Cat' a -> Cat' a -> Bool
< :: Cat' a -> Cat' a -> Bool
$c< :: forall a. Ord a => Cat' a -> Cat' a -> Bool
compare :: Cat' a -> Cat' a -> Ordering
$ccompare :: forall a. Ord a => Cat' a -> Cat' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Cat' a)
C.Ord, Int -> Cat' a -> ShowS
[Cat' a] -> ShowS
Cat' a -> String
(Int -> Cat' a -> ShowS)
-> (Cat' a -> String) -> ([Cat' a] -> ShowS) -> Show (Cat' a)
forall a. Show a => Int -> Cat' a -> ShowS
forall a. Show a => [Cat' a] -> ShowS
forall a. Show a => Cat' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cat' a] -> ShowS
$cshowList :: forall a. Show a => [Cat' a] -> ShowS
show :: Cat' a -> String
$cshow :: forall a. Show a => Cat' a -> String
showsPrec :: Int -> Cat' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Cat' a -> ShowS
C.Show, ReadPrec [Cat' a]
ReadPrec (Cat' a)
Int -> ReadS (Cat' a)
ReadS [Cat' a]
(Int -> ReadS (Cat' a))
-> ReadS [Cat' a]
-> ReadPrec (Cat' a)
-> ReadPrec [Cat' a]
-> Read (Cat' a)
forall a. Read a => ReadPrec [Cat' a]
forall a. Read a => ReadPrec (Cat' a)
forall a. Read a => Int -> ReadS (Cat' a)
forall a. Read a => ReadS [Cat' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Cat' a]
$creadListPrec :: forall a. Read a => ReadPrec [Cat' a]
readPrec :: ReadPrec (Cat' a)
$creadPrec :: forall a. Read a => ReadPrec (Cat' a)
readList :: ReadS [Cat' a]
$creadList :: forall a. Read a => ReadS [Cat' a]
readsPrec :: Int -> ReadS (Cat' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Cat' a)
C.Read, a -> Cat' b -> Cat' a
(a -> b) -> Cat' a -> Cat' b
(forall a b. (a -> b) -> Cat' a -> Cat' b)
-> (forall a b. a -> Cat' b -> Cat' a) -> Functor Cat'
forall a b. a -> Cat' b -> Cat' a
forall a b. (a -> b) -> Cat' a -> Cat' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Cat' b -> Cat' a
$c<$ :: forall a b. a -> Cat' b -> Cat' a
fmap :: (a -> b) -> Cat' a -> Cat' b
$cfmap :: forall a b. (a -> b) -> Cat' a -> Cat' b
C.Functor, Cat' a -> Bool
(a -> m) -> Cat' a -> m
(a -> b -> b) -> b -> Cat' a -> b
(forall m. Monoid m => Cat' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Cat' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Cat' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Cat' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Cat' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Cat' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Cat' a -> b)
-> (forall a. (a -> a -> a) -> Cat' a -> a)
-> (forall a. (a -> a -> a) -> Cat' a -> a)
-> (forall a. Cat' a -> [a])
-> (forall a. Cat' a -> Bool)
-> (forall a. Cat' a -> Int)
-> (forall a. Eq a => a -> Cat' a -> Bool)
-> (forall a. Ord a => Cat' a -> a)
-> (forall a. Ord a => Cat' a -> a)
-> (forall a. Num a => Cat' a -> a)
-> (forall a. Num a => Cat' a -> a)
-> Foldable Cat'
forall a. Eq a => a -> Cat' a -> Bool
forall a. Num a => Cat' a -> a
forall a. Ord a => Cat' a -> a
forall m. Monoid m => Cat' m -> m
forall a. Cat' a -> Bool
forall a. Cat' a -> Int
forall a. Cat' a -> [a]
forall a. (a -> a -> a) -> Cat' a -> a
forall m a. Monoid m => (a -> m) -> Cat' a -> m
forall b a. (b -> a -> b) -> b -> Cat' a -> b
forall a b. (a -> b -> b) -> b -> Cat' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Cat' a -> a
$cproduct :: forall a. Num a => Cat' a -> a
sum :: Cat' a -> a
$csum :: forall a. Num a => Cat' a -> a
minimum :: Cat' a -> a
$cminimum :: forall a. Ord a => Cat' a -> a
maximum :: Cat' a -> a
$cmaximum :: forall a. Ord a => Cat' a -> a
elem :: a -> Cat' a -> Bool
$celem :: forall a. Eq a => a -> Cat' a -> Bool
length :: Cat' a -> Int
$clength :: forall a. Cat' a -> Int
null :: Cat' a -> Bool
$cnull :: forall a. Cat' a -> Bool
toList :: Cat' a -> [a]
$ctoList :: forall a. Cat' a -> [a]
foldl1 :: (a -> a -> a) -> Cat' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Cat' a -> a
foldr1 :: (a -> a -> a) -> Cat' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Cat' a -> a
foldl' :: (b -> a -> b) -> b -> Cat' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Cat' a -> b
foldl :: (b -> a -> b) -> b -> Cat' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Cat' a -> b
foldr' :: (a -> b -> b) -> b -> Cat' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Cat' a -> b
foldr :: (a -> b -> b) -> b -> Cat' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Cat' a -> b
foldMap' :: (a -> m) -> Cat' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Cat' a -> m
foldMap :: (a -> m) -> Cat' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Cat' a -> m
fold :: Cat' m -> m
$cfold :: forall m. Monoid m => Cat' m -> m
C.Foldable, Functor Cat'
Foldable Cat'
Functor Cat'
-> Foldable Cat'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Cat' a -> f (Cat' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Cat' (f a) -> f (Cat' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Cat' a -> m (Cat' b))
-> (forall (m :: * -> *) a. Monad m => Cat' (m a) -> m (Cat' a))
-> Traversable Cat'
(a -> f b) -> Cat' a -> f (Cat' b)
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 => Cat' (m a) -> m (Cat' a)
forall (f :: * -> *) a. Applicative f => Cat' (f a) -> f (Cat' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Cat' a -> m (Cat' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Cat' a -> f (Cat' b)
sequence :: Cat' (m a) -> m (Cat' a)
$csequence :: forall (m :: * -> *) a. Monad m => Cat' (m a) -> m (Cat' a)
mapM :: (a -> m b) -> Cat' a -> m (Cat' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Cat' a -> m (Cat' b)
sequenceA :: Cat' (f a) -> f (Cat' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Cat' (f a) -> f (Cat' a)
traverse :: (a -> f b) -> Cat' a -> f (Cat' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Cat' a -> f (Cat' b)
$cp2Traversable :: Foldable Cat'
$cp1Traversable :: Functor Cat'
C.Traversable)

type Label = Label' BNFC'Position
data Label' a
    = Id a Identifier | Wild a | ListEmpty a | ListCons a | ListOne a
  deriving (Label' a -> Label' a -> Bool
(Label' a -> Label' a -> Bool)
-> (Label' a -> Label' a -> Bool) -> Eq (Label' a)
forall a. Eq a => Label' a -> Label' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Label' a -> Label' a -> Bool
$c/= :: forall a. Eq a => Label' a -> Label' a -> Bool
== :: Label' a -> Label' a -> Bool
$c== :: forall a. Eq a => Label' a -> Label' a -> Bool
C.Eq, Eq (Label' a)
Eq (Label' a)
-> (Label' a -> Label' a -> Ordering)
-> (Label' a -> Label' a -> Bool)
-> (Label' a -> Label' a -> Bool)
-> (Label' a -> Label' a -> Bool)
-> (Label' a -> Label' a -> Bool)
-> (Label' a -> Label' a -> Label' a)
-> (Label' a -> Label' a -> Label' a)
-> Ord (Label' a)
Label' a -> Label' a -> Bool
Label' a -> Label' a -> Ordering
Label' a -> Label' a -> Label' 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 (Label' a)
forall a. Ord a => Label' a -> Label' a -> Bool
forall a. Ord a => Label' a -> Label' a -> Ordering
forall a. Ord a => Label' a -> Label' a -> Label' a
min :: Label' a -> Label' a -> Label' a
$cmin :: forall a. Ord a => Label' a -> Label' a -> Label' a
max :: Label' a -> Label' a -> Label' a
$cmax :: forall a. Ord a => Label' a -> Label' a -> Label' a
>= :: Label' a -> Label' a -> Bool
$c>= :: forall a. Ord a => Label' a -> Label' a -> Bool
> :: Label' a -> Label' a -> Bool
$c> :: forall a. Ord a => Label' a -> Label' a -> Bool
<= :: Label' a -> Label' a -> Bool
$c<= :: forall a. Ord a => Label' a -> Label' a -> Bool
< :: Label' a -> Label' a -> Bool
$c< :: forall a. Ord a => Label' a -> Label' a -> Bool
compare :: Label' a -> Label' a -> Ordering
$ccompare :: forall a. Ord a => Label' a -> Label' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Label' a)
C.Ord, Int -> Label' a -> ShowS
[Label' a] -> ShowS
Label' a -> String
(Int -> Label' a -> ShowS)
-> (Label' a -> String) -> ([Label' a] -> ShowS) -> Show (Label' a)
forall a. Show a => Int -> Label' a -> ShowS
forall a. Show a => [Label' a] -> ShowS
forall a. Show a => Label' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Label' a] -> ShowS
$cshowList :: forall a. Show a => [Label' a] -> ShowS
show :: Label' a -> String
$cshow :: forall a. Show a => Label' a -> String
showsPrec :: Int -> Label' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Label' a -> ShowS
C.Show, ReadPrec [Label' a]
ReadPrec (Label' a)
Int -> ReadS (Label' a)
ReadS [Label' a]
(Int -> ReadS (Label' a))
-> ReadS [Label' a]
-> ReadPrec (Label' a)
-> ReadPrec [Label' a]
-> Read (Label' a)
forall a. Read a => ReadPrec [Label' a]
forall a. Read a => ReadPrec (Label' a)
forall a. Read a => Int -> ReadS (Label' a)
forall a. Read a => ReadS [Label' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Label' a]
$creadListPrec :: forall a. Read a => ReadPrec [Label' a]
readPrec :: ReadPrec (Label' a)
$creadPrec :: forall a. Read a => ReadPrec (Label' a)
readList :: ReadS [Label' a]
$creadList :: forall a. Read a => ReadS [Label' a]
readsPrec :: Int -> ReadS (Label' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Label' a)
C.Read, a -> Label' b -> Label' a
(a -> b) -> Label' a -> Label' b
(forall a b. (a -> b) -> Label' a -> Label' b)
-> (forall a b. a -> Label' b -> Label' a) -> Functor Label'
forall a b. a -> Label' b -> Label' a
forall a b. (a -> b) -> Label' a -> Label' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Label' b -> Label' a
$c<$ :: forall a b. a -> Label' b -> Label' a
fmap :: (a -> b) -> Label' a -> Label' b
$cfmap :: forall a b. (a -> b) -> Label' a -> Label' b
C.Functor, Label' a -> Bool
(a -> m) -> Label' a -> m
(a -> b -> b) -> b -> Label' a -> b
(forall m. Monoid m => Label' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Label' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Label' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Label' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Label' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Label' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Label' a -> b)
-> (forall a. (a -> a -> a) -> Label' a -> a)
-> (forall a. (a -> a -> a) -> Label' a -> a)
-> (forall a. Label' a -> [a])
-> (forall a. Label' a -> Bool)
-> (forall a. Label' a -> Int)
-> (forall a. Eq a => a -> Label' a -> Bool)
-> (forall a. Ord a => Label' a -> a)
-> (forall a. Ord a => Label' a -> a)
-> (forall a. Num a => Label' a -> a)
-> (forall a. Num a => Label' a -> a)
-> Foldable Label'
forall a. Eq a => a -> Label' a -> Bool
forall a. Num a => Label' a -> a
forall a. Ord a => Label' a -> a
forall m. Monoid m => Label' m -> m
forall a. Label' a -> Bool
forall a. Label' a -> Int
forall a. Label' a -> [a]
forall a. (a -> a -> a) -> Label' a -> a
forall m a. Monoid m => (a -> m) -> Label' a -> m
forall b a. (b -> a -> b) -> b -> Label' a -> b
forall a b. (a -> b -> b) -> b -> Label' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Label' a -> a
$cproduct :: forall a. Num a => Label' a -> a
sum :: Label' a -> a
$csum :: forall a. Num a => Label' a -> a
minimum :: Label' a -> a
$cminimum :: forall a. Ord a => Label' a -> a
maximum :: Label' a -> a
$cmaximum :: forall a. Ord a => Label' a -> a
elem :: a -> Label' a -> Bool
$celem :: forall a. Eq a => a -> Label' a -> Bool
length :: Label' a -> Int
$clength :: forall a. Label' a -> Int
null :: Label' a -> Bool
$cnull :: forall a. Label' a -> Bool
toList :: Label' a -> [a]
$ctoList :: forall a. Label' a -> [a]
foldl1 :: (a -> a -> a) -> Label' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Label' a -> a
foldr1 :: (a -> a -> a) -> Label' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Label' a -> a
foldl' :: (b -> a -> b) -> b -> Label' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Label' a -> b
foldl :: (b -> a -> b) -> b -> Label' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Label' a -> b
foldr' :: (a -> b -> b) -> b -> Label' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Label' a -> b
foldr :: (a -> b -> b) -> b -> Label' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Label' a -> b
foldMap' :: (a -> m) -> Label' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Label' a -> m
foldMap :: (a -> m) -> Label' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Label' a -> m
fold :: Label' m -> m
$cfold :: forall m. Monoid m => Label' m -> m
C.Foldable, Functor Label'
Foldable Label'
Functor Label'
-> Foldable Label'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Label' a -> f (Label' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Label' (f a) -> f (Label' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Label' a -> m (Label' b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Label' (m a) -> m (Label' a))
-> Traversable Label'
(a -> f b) -> Label' a -> f (Label' b)
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 => Label' (m a) -> m (Label' a)
forall (f :: * -> *) a.
Applicative f =>
Label' (f a) -> f (Label' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Label' a -> m (Label' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Label' a -> f (Label' b)
sequence :: Label' (m a) -> m (Label' a)
$csequence :: forall (m :: * -> *) a. Monad m => Label' (m a) -> m (Label' a)
mapM :: (a -> m b) -> Label' a -> m (Label' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Label' a -> m (Label' b)
sequenceA :: Label' (f a) -> f (Label' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Label' (f a) -> f (Label' a)
traverse :: (a -> f b) -> Label' a -> f (Label' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Label' a -> f (Label' b)
$cp2Traversable :: Foldable Label'
$cp1Traversable :: Functor Label'
C.Traversable)

type Arg = Arg' BNFC'Position
data Arg' a = Arg a Identifier
  deriving (Arg' a -> Arg' a -> Bool
(Arg' a -> Arg' a -> Bool)
-> (Arg' a -> Arg' a -> Bool) -> Eq (Arg' a)
forall a. Eq a => Arg' a -> Arg' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Arg' a -> Arg' a -> Bool
$c/= :: forall a. Eq a => Arg' a -> Arg' a -> Bool
== :: Arg' a -> Arg' a -> Bool
$c== :: forall a. Eq a => Arg' a -> Arg' a -> Bool
C.Eq, Eq (Arg' a)
Eq (Arg' a)
-> (Arg' a -> Arg' a -> Ordering)
-> (Arg' a -> Arg' a -> Bool)
-> (Arg' a -> Arg' a -> Bool)
-> (Arg' a -> Arg' a -> Bool)
-> (Arg' a -> Arg' a -> Bool)
-> (Arg' a -> Arg' a -> Arg' a)
-> (Arg' a -> Arg' a -> Arg' a)
-> Ord (Arg' a)
Arg' a -> Arg' a -> Bool
Arg' a -> Arg' a -> Ordering
Arg' a -> Arg' a -> Arg' 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 (Arg' a)
forall a. Ord a => Arg' a -> Arg' a -> Bool
forall a. Ord a => Arg' a -> Arg' a -> Ordering
forall a. Ord a => Arg' a -> Arg' a -> Arg' a
min :: Arg' a -> Arg' a -> Arg' a
$cmin :: forall a. Ord a => Arg' a -> Arg' a -> Arg' a
max :: Arg' a -> Arg' a -> Arg' a
$cmax :: forall a. Ord a => Arg' a -> Arg' a -> Arg' a
>= :: Arg' a -> Arg' a -> Bool
$c>= :: forall a. Ord a => Arg' a -> Arg' a -> Bool
> :: Arg' a -> Arg' a -> Bool
$c> :: forall a. Ord a => Arg' a -> Arg' a -> Bool
<= :: Arg' a -> Arg' a -> Bool
$c<= :: forall a. Ord a => Arg' a -> Arg' a -> Bool
< :: Arg' a -> Arg' a -> Bool
$c< :: forall a. Ord a => Arg' a -> Arg' a -> Bool
compare :: Arg' a -> Arg' a -> Ordering
$ccompare :: forall a. Ord a => Arg' a -> Arg' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Arg' a)
C.Ord, Int -> Arg' a -> ShowS
[Arg' a] -> ShowS
Arg' a -> String
(Int -> Arg' a -> ShowS)
-> (Arg' a -> String) -> ([Arg' a] -> ShowS) -> Show (Arg' a)
forall a. Show a => Int -> Arg' a -> ShowS
forall a. Show a => [Arg' a] -> ShowS
forall a. Show a => Arg' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Arg' a] -> ShowS
$cshowList :: forall a. Show a => [Arg' a] -> ShowS
show :: Arg' a -> String
$cshow :: forall a. Show a => Arg' a -> String
showsPrec :: Int -> Arg' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Arg' a -> ShowS
C.Show, ReadPrec [Arg' a]
ReadPrec (Arg' a)
Int -> ReadS (Arg' a)
ReadS [Arg' a]
(Int -> ReadS (Arg' a))
-> ReadS [Arg' a]
-> ReadPrec (Arg' a)
-> ReadPrec [Arg' a]
-> Read (Arg' a)
forall a. Read a => ReadPrec [Arg' a]
forall a. Read a => ReadPrec (Arg' a)
forall a. Read a => Int -> ReadS (Arg' a)
forall a. Read a => ReadS [Arg' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Arg' a]
$creadListPrec :: forall a. Read a => ReadPrec [Arg' a]
readPrec :: ReadPrec (Arg' a)
$creadPrec :: forall a. Read a => ReadPrec (Arg' a)
readList :: ReadS [Arg' a]
$creadList :: forall a. Read a => ReadS [Arg' a]
readsPrec :: Int -> ReadS (Arg' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Arg' a)
C.Read, a -> Arg' b -> Arg' a
(a -> b) -> Arg' a -> Arg' b
(forall a b. (a -> b) -> Arg' a -> Arg' b)
-> (forall a b. a -> Arg' b -> Arg' a) -> Functor Arg'
forall a b. a -> Arg' b -> Arg' a
forall a b. (a -> b) -> Arg' a -> Arg' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Arg' b -> Arg' a
$c<$ :: forall a b. a -> Arg' b -> Arg' a
fmap :: (a -> b) -> Arg' a -> Arg' b
$cfmap :: forall a b. (a -> b) -> Arg' a -> Arg' b
C.Functor, Arg' a -> Bool
(a -> m) -> Arg' a -> m
(a -> b -> b) -> b -> Arg' a -> b
(forall m. Monoid m => Arg' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Arg' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Arg' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Arg' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Arg' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Arg' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Arg' a -> b)
-> (forall a. (a -> a -> a) -> Arg' a -> a)
-> (forall a. (a -> a -> a) -> Arg' a -> a)
-> (forall a. Arg' a -> [a])
-> (forall a. Arg' a -> Bool)
-> (forall a. Arg' a -> Int)
-> (forall a. Eq a => a -> Arg' a -> Bool)
-> (forall a. Ord a => Arg' a -> a)
-> (forall a. Ord a => Arg' a -> a)
-> (forall a. Num a => Arg' a -> a)
-> (forall a. Num a => Arg' a -> a)
-> Foldable Arg'
forall a. Eq a => a -> Arg' a -> Bool
forall a. Num a => Arg' a -> a
forall a. Ord a => Arg' a -> a
forall m. Monoid m => Arg' m -> m
forall a. Arg' a -> Bool
forall a. Arg' a -> Int
forall a. Arg' a -> [a]
forall a. (a -> a -> a) -> Arg' a -> a
forall m a. Monoid m => (a -> m) -> Arg' a -> m
forall b a. (b -> a -> b) -> b -> Arg' a -> b
forall a b. (a -> b -> b) -> b -> Arg' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Arg' a -> a
$cproduct :: forall a. Num a => Arg' a -> a
sum :: Arg' a -> a
$csum :: forall a. Num a => Arg' a -> a
minimum :: Arg' a -> a
$cminimum :: forall a. Ord a => Arg' a -> a
maximum :: Arg' a -> a
$cmaximum :: forall a. Ord a => Arg' a -> a
elem :: a -> Arg' a -> Bool
$celem :: forall a. Eq a => a -> Arg' a -> Bool
length :: Arg' a -> Int
$clength :: forall a. Arg' a -> Int
null :: Arg' a -> Bool
$cnull :: forall a. Arg' a -> Bool
toList :: Arg' a -> [a]
$ctoList :: forall a. Arg' a -> [a]
foldl1 :: (a -> a -> a) -> Arg' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Arg' a -> a
foldr1 :: (a -> a -> a) -> Arg' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Arg' a -> a
foldl' :: (b -> a -> b) -> b -> Arg' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Arg' a -> b
foldl :: (b -> a -> b) -> b -> Arg' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Arg' a -> b
foldr' :: (a -> b -> b) -> b -> Arg' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Arg' a -> b
foldr :: (a -> b -> b) -> b -> Arg' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Arg' a -> b
foldMap' :: (a -> m) -> Arg' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Arg' a -> m
foldMap :: (a -> m) -> Arg' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Arg' a -> m
fold :: Arg' m -> m
$cfold :: forall m. Monoid m => Arg' m -> m
C.Foldable, Functor Arg'
Foldable Arg'
Functor Arg'
-> Foldable Arg'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Arg' a -> f (Arg' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Arg' (f a) -> f (Arg' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Arg' a -> m (Arg' b))
-> (forall (m :: * -> *) a. Monad m => Arg' (m a) -> m (Arg' a))
-> Traversable Arg'
(a -> f b) -> Arg' a -> f (Arg' b)
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 => Arg' (m a) -> m (Arg' a)
forall (f :: * -> *) a. Applicative f => Arg' (f a) -> f (Arg' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Arg' a -> m (Arg' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Arg' a -> f (Arg' b)
sequence :: Arg' (m a) -> m (Arg' a)
$csequence :: forall (m :: * -> *) a. Monad m => Arg' (m a) -> m (Arg' a)
mapM :: (a -> m b) -> Arg' a -> m (Arg' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Arg' a -> m (Arg' b)
sequenceA :: Arg' (f a) -> f (Arg' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Arg' (f a) -> f (Arg' a)
traverse :: (a -> f b) -> Arg' a -> f (Arg' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Arg' a -> f (Arg' b)
$cp2Traversable :: Foldable Arg'
$cp1Traversable :: Functor Arg'
C.Traversable)

type Separation = Separation' BNFC'Position
data Separation' a
    = SepNone a | SepTerm a String | SepSepar a String
  deriving (Separation' a -> Separation' a -> Bool
(Separation' a -> Separation' a -> Bool)
-> (Separation' a -> Separation' a -> Bool) -> Eq (Separation' a)
forall a. Eq a => Separation' a -> Separation' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Separation' a -> Separation' a -> Bool
$c/= :: forall a. Eq a => Separation' a -> Separation' a -> Bool
== :: Separation' a -> Separation' a -> Bool
$c== :: forall a. Eq a => Separation' a -> Separation' a -> Bool
C.Eq, Eq (Separation' a)
Eq (Separation' a)
-> (Separation' a -> Separation' a -> Ordering)
-> (Separation' a -> Separation' a -> Bool)
-> (Separation' a -> Separation' a -> Bool)
-> (Separation' a -> Separation' a -> Bool)
-> (Separation' a -> Separation' a -> Bool)
-> (Separation' a -> Separation' a -> Separation' a)
-> (Separation' a -> Separation' a -> Separation' a)
-> Ord (Separation' a)
Separation' a -> Separation' a -> Bool
Separation' a -> Separation' a -> Ordering
Separation' a -> Separation' a -> Separation' 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 (Separation' a)
forall a. Ord a => Separation' a -> Separation' a -> Bool
forall a. Ord a => Separation' a -> Separation' a -> Ordering
forall a. Ord a => Separation' a -> Separation' a -> Separation' a
min :: Separation' a -> Separation' a -> Separation' a
$cmin :: forall a. Ord a => Separation' a -> Separation' a -> Separation' a
max :: Separation' a -> Separation' a -> Separation' a
$cmax :: forall a. Ord a => Separation' a -> Separation' a -> Separation' a
>= :: Separation' a -> Separation' a -> Bool
$c>= :: forall a. Ord a => Separation' a -> Separation' a -> Bool
> :: Separation' a -> Separation' a -> Bool
$c> :: forall a. Ord a => Separation' a -> Separation' a -> Bool
<= :: Separation' a -> Separation' a -> Bool
$c<= :: forall a. Ord a => Separation' a -> Separation' a -> Bool
< :: Separation' a -> Separation' a -> Bool
$c< :: forall a. Ord a => Separation' a -> Separation' a -> Bool
compare :: Separation' a -> Separation' a -> Ordering
$ccompare :: forall a. Ord a => Separation' a -> Separation' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Separation' a)
C.Ord, Int -> Separation' a -> ShowS
[Separation' a] -> ShowS
Separation' a -> String
(Int -> Separation' a -> ShowS)
-> (Separation' a -> String)
-> ([Separation' a] -> ShowS)
-> Show (Separation' a)
forall a. Show a => Int -> Separation' a -> ShowS
forall a. Show a => [Separation' a] -> ShowS
forall a. Show a => Separation' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Separation' a] -> ShowS
$cshowList :: forall a. Show a => [Separation' a] -> ShowS
show :: Separation' a -> String
$cshow :: forall a. Show a => Separation' a -> String
showsPrec :: Int -> Separation' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Separation' a -> ShowS
C.Show, ReadPrec [Separation' a]
ReadPrec (Separation' a)
Int -> ReadS (Separation' a)
ReadS [Separation' a]
(Int -> ReadS (Separation' a))
-> ReadS [Separation' a]
-> ReadPrec (Separation' a)
-> ReadPrec [Separation' a]
-> Read (Separation' a)
forall a. Read a => ReadPrec [Separation' a]
forall a. Read a => ReadPrec (Separation' a)
forall a. Read a => Int -> ReadS (Separation' a)
forall a. Read a => ReadS [Separation' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Separation' a]
$creadListPrec :: forall a. Read a => ReadPrec [Separation' a]
readPrec :: ReadPrec (Separation' a)
$creadPrec :: forall a. Read a => ReadPrec (Separation' a)
readList :: ReadS [Separation' a]
$creadList :: forall a. Read a => ReadS [Separation' a]
readsPrec :: Int -> ReadS (Separation' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Separation' a)
C.Read, a -> Separation' b -> Separation' a
(a -> b) -> Separation' a -> Separation' b
(forall a b. (a -> b) -> Separation' a -> Separation' b)
-> (forall a b. a -> Separation' b -> Separation' a)
-> Functor Separation'
forall a b. a -> Separation' b -> Separation' a
forall a b. (a -> b) -> Separation' a -> Separation' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Separation' b -> Separation' a
$c<$ :: forall a b. a -> Separation' b -> Separation' a
fmap :: (a -> b) -> Separation' a -> Separation' b
$cfmap :: forall a b. (a -> b) -> Separation' a -> Separation' b
C.Functor, Separation' a -> Bool
(a -> m) -> Separation' a -> m
(a -> b -> b) -> b -> Separation' a -> b
(forall m. Monoid m => Separation' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Separation' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Separation' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Separation' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Separation' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Separation' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Separation' a -> b)
-> (forall a. (a -> a -> a) -> Separation' a -> a)
-> (forall a. (a -> a -> a) -> Separation' a -> a)
-> (forall a. Separation' a -> [a])
-> (forall a. Separation' a -> Bool)
-> (forall a. Separation' a -> Int)
-> (forall a. Eq a => a -> Separation' a -> Bool)
-> (forall a. Ord a => Separation' a -> a)
-> (forall a. Ord a => Separation' a -> a)
-> (forall a. Num a => Separation' a -> a)
-> (forall a. Num a => Separation' a -> a)
-> Foldable Separation'
forall a. Eq a => a -> Separation' a -> Bool
forall a. Num a => Separation' a -> a
forall a. Ord a => Separation' a -> a
forall m. Monoid m => Separation' m -> m
forall a. Separation' a -> Bool
forall a. Separation' a -> Int
forall a. Separation' a -> [a]
forall a. (a -> a -> a) -> Separation' a -> a
forall m a. Monoid m => (a -> m) -> Separation' a -> m
forall b a. (b -> a -> b) -> b -> Separation' a -> b
forall a b. (a -> b -> b) -> b -> Separation' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Separation' a -> a
$cproduct :: forall a. Num a => Separation' a -> a
sum :: Separation' a -> a
$csum :: forall a. Num a => Separation' a -> a
minimum :: Separation' a -> a
$cminimum :: forall a. Ord a => Separation' a -> a
maximum :: Separation' a -> a
$cmaximum :: forall a. Ord a => Separation' a -> a
elem :: a -> Separation' a -> Bool
$celem :: forall a. Eq a => a -> Separation' a -> Bool
length :: Separation' a -> Int
$clength :: forall a. Separation' a -> Int
null :: Separation' a -> Bool
$cnull :: forall a. Separation' a -> Bool
toList :: Separation' a -> [a]
$ctoList :: forall a. Separation' a -> [a]
foldl1 :: (a -> a -> a) -> Separation' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Separation' a -> a
foldr1 :: (a -> a -> a) -> Separation' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Separation' a -> a
foldl' :: (b -> a -> b) -> b -> Separation' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Separation' a -> b
foldl :: (b -> a -> b) -> b -> Separation' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Separation' a -> b
foldr' :: (a -> b -> b) -> b -> Separation' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Separation' a -> b
foldr :: (a -> b -> b) -> b -> Separation' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Separation' a -> b
foldMap' :: (a -> m) -> Separation' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Separation' a -> m
foldMap :: (a -> m) -> Separation' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Separation' a -> m
fold :: Separation' m -> m
$cfold :: forall m. Monoid m => Separation' m -> m
C.Foldable, Functor Separation'
Foldable Separation'
Functor Separation'
-> Foldable Separation'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Separation' a -> f (Separation' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Separation' (f a) -> f (Separation' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Separation' a -> m (Separation' b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Separation' (m a) -> m (Separation' a))
-> Traversable Separation'
(a -> f b) -> Separation' a -> f (Separation' b)
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 =>
Separation' (m a) -> m (Separation' a)
forall (f :: * -> *) a.
Applicative f =>
Separation' (f a) -> f (Separation' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Separation' a -> m (Separation' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Separation' a -> f (Separation' b)
sequence :: Separation' (m a) -> m (Separation' a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Separation' (m a) -> m (Separation' a)
mapM :: (a -> m b) -> Separation' a -> m (Separation' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Separation' a -> m (Separation' b)
sequenceA :: Separation' (f a) -> f (Separation' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Separation' (f a) -> f (Separation' a)
traverse :: (a -> f b) -> Separation' a -> f (Separation' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Separation' a -> f (Separation' b)
$cp2Traversable :: Foldable Separation'
$cp1Traversable :: Functor Separation'
C.Traversable)

type Exp = Exp' BNFC'Position
data Exp' a
    = Cons a (Exp' a) (Exp' a)
    | App a Identifier [Exp' a]
    | Var a Identifier
    | LitInteger a Integer
    | LitChar a Char
    | LitString a String
    | LitDouble a Double
    | List a [Exp' a]
  deriving (Exp' a -> Exp' a -> Bool
(Exp' a -> Exp' a -> Bool)
-> (Exp' a -> Exp' a -> Bool) -> Eq (Exp' a)
forall a. Eq a => Exp' a -> Exp' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Exp' a -> Exp' a -> Bool
$c/= :: forall a. Eq a => Exp' a -> Exp' a -> Bool
== :: Exp' a -> Exp' a -> Bool
$c== :: forall a. Eq a => Exp' a -> Exp' a -> Bool
C.Eq, Eq (Exp' a)
Eq (Exp' a)
-> (Exp' a -> Exp' a -> Ordering)
-> (Exp' a -> Exp' a -> Bool)
-> (Exp' a -> Exp' a -> Bool)
-> (Exp' a -> Exp' a -> Bool)
-> (Exp' a -> Exp' a -> Bool)
-> (Exp' a -> Exp' a -> Exp' a)
-> (Exp' a -> Exp' a -> Exp' a)
-> Ord (Exp' a)
Exp' a -> Exp' a -> Bool
Exp' a -> Exp' a -> Ordering
Exp' a -> Exp' a -> Exp' 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 (Exp' a)
forall a. Ord a => Exp' a -> Exp' a -> Bool
forall a. Ord a => Exp' a -> Exp' a -> Ordering
forall a. Ord a => Exp' a -> Exp' a -> Exp' a
min :: Exp' a -> Exp' a -> Exp' a
$cmin :: forall a. Ord a => Exp' a -> Exp' a -> Exp' a
max :: Exp' a -> Exp' a -> Exp' a
$cmax :: forall a. Ord a => Exp' a -> Exp' a -> Exp' a
>= :: Exp' a -> Exp' a -> Bool
$c>= :: forall a. Ord a => Exp' a -> Exp' a -> Bool
> :: Exp' a -> Exp' a -> Bool
$c> :: forall a. Ord a => Exp' a -> Exp' a -> Bool
<= :: Exp' a -> Exp' a -> Bool
$c<= :: forall a. Ord a => Exp' a -> Exp' a -> Bool
< :: Exp' a -> Exp' a -> Bool
$c< :: forall a. Ord a => Exp' a -> Exp' a -> Bool
compare :: Exp' a -> Exp' a -> Ordering
$ccompare :: forall a. Ord a => Exp' a -> Exp' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Exp' a)
C.Ord, Int -> Exp' a -> ShowS
[Exp' a] -> ShowS
Exp' a -> String
(Int -> Exp' a -> ShowS)
-> (Exp' a -> String) -> ([Exp' a] -> ShowS) -> Show (Exp' a)
forall a. Show a => Int -> Exp' a -> ShowS
forall a. Show a => [Exp' a] -> ShowS
forall a. Show a => Exp' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Exp' a] -> ShowS
$cshowList :: forall a. Show a => [Exp' a] -> ShowS
show :: Exp' a -> String
$cshow :: forall a. Show a => Exp' a -> String
showsPrec :: Int -> Exp' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Exp' a -> ShowS
C.Show, ReadPrec [Exp' a]
ReadPrec (Exp' a)
Int -> ReadS (Exp' a)
ReadS [Exp' a]
(Int -> ReadS (Exp' a))
-> ReadS [Exp' a]
-> ReadPrec (Exp' a)
-> ReadPrec [Exp' a]
-> Read (Exp' a)
forall a. Read a => ReadPrec [Exp' a]
forall a. Read a => ReadPrec (Exp' a)
forall a. Read a => Int -> ReadS (Exp' a)
forall a. Read a => ReadS [Exp' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Exp' a]
$creadListPrec :: forall a. Read a => ReadPrec [Exp' a]
readPrec :: ReadPrec (Exp' a)
$creadPrec :: forall a. Read a => ReadPrec (Exp' a)
readList :: ReadS [Exp' a]
$creadList :: forall a. Read a => ReadS [Exp' a]
readsPrec :: Int -> ReadS (Exp' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Exp' a)
C.Read, a -> Exp' b -> Exp' a
(a -> b) -> Exp' a -> Exp' b
(forall a b. (a -> b) -> Exp' a -> Exp' b)
-> (forall a b. a -> Exp' b -> Exp' a) -> Functor Exp'
forall a b. a -> Exp' b -> Exp' a
forall a b. (a -> b) -> Exp' a -> Exp' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Exp' b -> Exp' a
$c<$ :: forall a b. a -> Exp' b -> Exp' a
fmap :: (a -> b) -> Exp' a -> Exp' b
$cfmap :: forall a b. (a -> b) -> Exp' a -> Exp' b
C.Functor, Exp' a -> Bool
(a -> m) -> Exp' a -> m
(a -> b -> b) -> b -> Exp' a -> b
(forall m. Monoid m => Exp' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Exp' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Exp' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Exp' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Exp' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Exp' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Exp' a -> b)
-> (forall a. (a -> a -> a) -> Exp' a -> a)
-> (forall a. (a -> a -> a) -> Exp' a -> a)
-> (forall a. Exp' a -> [a])
-> (forall a. Exp' a -> Bool)
-> (forall a. Exp' a -> Int)
-> (forall a. Eq a => a -> Exp' a -> Bool)
-> (forall a. Ord a => Exp' a -> a)
-> (forall a. Ord a => Exp' a -> a)
-> (forall a. Num a => Exp' a -> a)
-> (forall a. Num a => Exp' a -> a)
-> Foldable Exp'
forall a. Eq a => a -> Exp' a -> Bool
forall a. Num a => Exp' a -> a
forall a. Ord a => Exp' a -> a
forall m. Monoid m => Exp' m -> m
forall a. Exp' a -> Bool
forall a. Exp' a -> Int
forall a. Exp' a -> [a]
forall a. (a -> a -> a) -> Exp' a -> a
forall m a. Monoid m => (a -> m) -> Exp' a -> m
forall b a. (b -> a -> b) -> b -> Exp' a -> b
forall a b. (a -> b -> b) -> b -> Exp' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Exp' a -> a
$cproduct :: forall a. Num a => Exp' a -> a
sum :: Exp' a -> a
$csum :: forall a. Num a => Exp' a -> a
minimum :: Exp' a -> a
$cminimum :: forall a. Ord a => Exp' a -> a
maximum :: Exp' a -> a
$cmaximum :: forall a. Ord a => Exp' a -> a
elem :: a -> Exp' a -> Bool
$celem :: forall a. Eq a => a -> Exp' a -> Bool
length :: Exp' a -> Int
$clength :: forall a. Exp' a -> Int
null :: Exp' a -> Bool
$cnull :: forall a. Exp' a -> Bool
toList :: Exp' a -> [a]
$ctoList :: forall a. Exp' a -> [a]
foldl1 :: (a -> a -> a) -> Exp' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Exp' a -> a
foldr1 :: (a -> a -> a) -> Exp' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Exp' a -> a
foldl' :: (b -> a -> b) -> b -> Exp' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Exp' a -> b
foldl :: (b -> a -> b) -> b -> Exp' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Exp' a -> b
foldr' :: (a -> b -> b) -> b -> Exp' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Exp' a -> b
foldr :: (a -> b -> b) -> b -> Exp' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Exp' a -> b
foldMap' :: (a -> m) -> Exp' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Exp' a -> m
foldMap :: (a -> m) -> Exp' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Exp' a -> m
fold :: Exp' m -> m
$cfold :: forall m. Monoid m => Exp' m -> m
C.Foldable, Functor Exp'
Foldable Exp'
Functor Exp'
-> Foldable Exp'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Exp' a -> f (Exp' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Exp' (f a) -> f (Exp' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Exp' a -> m (Exp' b))
-> (forall (m :: * -> *) a. Monad m => Exp' (m a) -> m (Exp' a))
-> Traversable Exp'
(a -> f b) -> Exp' a -> f (Exp' b)
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 => Exp' (m a) -> m (Exp' a)
forall (f :: * -> *) a. Applicative f => Exp' (f a) -> f (Exp' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Exp' a -> m (Exp' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Exp' a -> f (Exp' b)
sequence :: Exp' (m a) -> m (Exp' a)
$csequence :: forall (m :: * -> *) a. Monad m => Exp' (m a) -> m (Exp' a)
mapM :: (a -> m b) -> Exp' a -> m (Exp' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Exp' a -> m (Exp' b)
sequenceA :: Exp' (f a) -> f (Exp' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Exp' (f a) -> f (Exp' a)
traverse :: (a -> f b) -> Exp' a -> f (Exp' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Exp' a -> f (Exp' b)
$cp2Traversable :: Foldable Exp'
$cp1Traversable :: Functor Exp'
C.Traversable)

type RHS = RHS' BNFC'Position
data RHS' a = RHS a [Item' a]
  deriving (RHS' a -> RHS' a -> Bool
(RHS' a -> RHS' a -> Bool)
-> (RHS' a -> RHS' a -> Bool) -> Eq (RHS' a)
forall a. Eq a => RHS' a -> RHS' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RHS' a -> RHS' a -> Bool
$c/= :: forall a. Eq a => RHS' a -> RHS' a -> Bool
== :: RHS' a -> RHS' a -> Bool
$c== :: forall a. Eq a => RHS' a -> RHS' a -> Bool
C.Eq, Eq (RHS' a)
Eq (RHS' a)
-> (RHS' a -> RHS' a -> Ordering)
-> (RHS' a -> RHS' a -> Bool)
-> (RHS' a -> RHS' a -> Bool)
-> (RHS' a -> RHS' a -> Bool)
-> (RHS' a -> RHS' a -> Bool)
-> (RHS' a -> RHS' a -> RHS' a)
-> (RHS' a -> RHS' a -> RHS' a)
-> Ord (RHS' a)
RHS' a -> RHS' a -> Bool
RHS' a -> RHS' a -> Ordering
RHS' a -> RHS' a -> RHS' 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 (RHS' a)
forall a. Ord a => RHS' a -> RHS' a -> Bool
forall a. Ord a => RHS' a -> RHS' a -> Ordering
forall a. Ord a => RHS' a -> RHS' a -> RHS' a
min :: RHS' a -> RHS' a -> RHS' a
$cmin :: forall a. Ord a => RHS' a -> RHS' a -> RHS' a
max :: RHS' a -> RHS' a -> RHS' a
$cmax :: forall a. Ord a => RHS' a -> RHS' a -> RHS' a
>= :: RHS' a -> RHS' a -> Bool
$c>= :: forall a. Ord a => RHS' a -> RHS' a -> Bool
> :: RHS' a -> RHS' a -> Bool
$c> :: forall a. Ord a => RHS' a -> RHS' a -> Bool
<= :: RHS' a -> RHS' a -> Bool
$c<= :: forall a. Ord a => RHS' a -> RHS' a -> Bool
< :: RHS' a -> RHS' a -> Bool
$c< :: forall a. Ord a => RHS' a -> RHS' a -> Bool
compare :: RHS' a -> RHS' a -> Ordering
$ccompare :: forall a. Ord a => RHS' a -> RHS' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (RHS' a)
C.Ord, Int -> RHS' a -> ShowS
[RHS' a] -> ShowS
RHS' a -> String
(Int -> RHS' a -> ShowS)
-> (RHS' a -> String) -> ([RHS' a] -> ShowS) -> Show (RHS' a)
forall a. Show a => Int -> RHS' a -> ShowS
forall a. Show a => [RHS' a] -> ShowS
forall a. Show a => RHS' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RHS' a] -> ShowS
$cshowList :: forall a. Show a => [RHS' a] -> ShowS
show :: RHS' a -> String
$cshow :: forall a. Show a => RHS' a -> String
showsPrec :: Int -> RHS' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> RHS' a -> ShowS
C.Show, ReadPrec [RHS' a]
ReadPrec (RHS' a)
Int -> ReadS (RHS' a)
ReadS [RHS' a]
(Int -> ReadS (RHS' a))
-> ReadS [RHS' a]
-> ReadPrec (RHS' a)
-> ReadPrec [RHS' a]
-> Read (RHS' a)
forall a. Read a => ReadPrec [RHS' a]
forall a. Read a => ReadPrec (RHS' a)
forall a. Read a => Int -> ReadS (RHS' a)
forall a. Read a => ReadS [RHS' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RHS' a]
$creadListPrec :: forall a. Read a => ReadPrec [RHS' a]
readPrec :: ReadPrec (RHS' a)
$creadPrec :: forall a. Read a => ReadPrec (RHS' a)
readList :: ReadS [RHS' a]
$creadList :: forall a. Read a => ReadS [RHS' a]
readsPrec :: Int -> ReadS (RHS' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (RHS' a)
C.Read, a -> RHS' b -> RHS' a
(a -> b) -> RHS' a -> RHS' b
(forall a b. (a -> b) -> RHS' a -> RHS' b)
-> (forall a b. a -> RHS' b -> RHS' a) -> Functor RHS'
forall a b. a -> RHS' b -> RHS' a
forall a b. (a -> b) -> RHS' a -> RHS' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> RHS' b -> RHS' a
$c<$ :: forall a b. a -> RHS' b -> RHS' a
fmap :: (a -> b) -> RHS' a -> RHS' b
$cfmap :: forall a b. (a -> b) -> RHS' a -> RHS' b
C.Functor, RHS' a -> Bool
(a -> m) -> RHS' a -> m
(a -> b -> b) -> b -> RHS' a -> b
(forall m. Monoid m => RHS' m -> m)
-> (forall m a. Monoid m => (a -> m) -> RHS' a -> m)
-> (forall m a. Monoid m => (a -> m) -> RHS' a -> m)
-> (forall a b. (a -> b -> b) -> b -> RHS' a -> b)
-> (forall a b. (a -> b -> b) -> b -> RHS' a -> b)
-> (forall b a. (b -> a -> b) -> b -> RHS' a -> b)
-> (forall b a. (b -> a -> b) -> b -> RHS' a -> b)
-> (forall a. (a -> a -> a) -> RHS' a -> a)
-> (forall a. (a -> a -> a) -> RHS' a -> a)
-> (forall a. RHS' a -> [a])
-> (forall a. RHS' a -> Bool)
-> (forall a. RHS' a -> Int)
-> (forall a. Eq a => a -> RHS' a -> Bool)
-> (forall a. Ord a => RHS' a -> a)
-> (forall a. Ord a => RHS' a -> a)
-> (forall a. Num a => RHS' a -> a)
-> (forall a. Num a => RHS' a -> a)
-> Foldable RHS'
forall a. Eq a => a -> RHS' a -> Bool
forall a. Num a => RHS' a -> a
forall a. Ord a => RHS' a -> a
forall m. Monoid m => RHS' m -> m
forall a. RHS' a -> Bool
forall a. RHS' a -> Int
forall a. RHS' a -> [a]
forall a. (a -> a -> a) -> RHS' a -> a
forall m a. Monoid m => (a -> m) -> RHS' a -> m
forall b a. (b -> a -> b) -> b -> RHS' a -> b
forall a b. (a -> b -> b) -> b -> RHS' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: RHS' a -> a
$cproduct :: forall a. Num a => RHS' a -> a
sum :: RHS' a -> a
$csum :: forall a. Num a => RHS' a -> a
minimum :: RHS' a -> a
$cminimum :: forall a. Ord a => RHS' a -> a
maximum :: RHS' a -> a
$cmaximum :: forall a. Ord a => RHS' a -> a
elem :: a -> RHS' a -> Bool
$celem :: forall a. Eq a => a -> RHS' a -> Bool
length :: RHS' a -> Int
$clength :: forall a. RHS' a -> Int
null :: RHS' a -> Bool
$cnull :: forall a. RHS' a -> Bool
toList :: RHS' a -> [a]
$ctoList :: forall a. RHS' a -> [a]
foldl1 :: (a -> a -> a) -> RHS' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RHS' a -> a
foldr1 :: (a -> a -> a) -> RHS' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> RHS' a -> a
foldl' :: (b -> a -> b) -> b -> RHS' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RHS' a -> b
foldl :: (b -> a -> b) -> b -> RHS' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RHS' a -> b
foldr' :: (a -> b -> b) -> b -> RHS' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RHS' a -> b
foldr :: (a -> b -> b) -> b -> RHS' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> RHS' a -> b
foldMap' :: (a -> m) -> RHS' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RHS' a -> m
foldMap :: (a -> m) -> RHS' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RHS' a -> m
fold :: RHS' m -> m
$cfold :: forall m. Monoid m => RHS' m -> m
C.Foldable, Functor RHS'
Foldable RHS'
Functor RHS'
-> Foldable RHS'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> RHS' a -> f (RHS' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    RHS' (f a) -> f (RHS' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> RHS' a -> m (RHS' b))
-> (forall (m :: * -> *) a. Monad m => RHS' (m a) -> m (RHS' a))
-> Traversable RHS'
(a -> f b) -> RHS' a -> f (RHS' b)
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 => RHS' (m a) -> m (RHS' a)
forall (f :: * -> *) a. Applicative f => RHS' (f a) -> f (RHS' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RHS' a -> m (RHS' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RHS' a -> f (RHS' b)
sequence :: RHS' (m a) -> m (RHS' a)
$csequence :: forall (m :: * -> *) a. Monad m => RHS' (m a) -> m (RHS' a)
mapM :: (a -> m b) -> RHS' a -> m (RHS' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RHS' a -> m (RHS' b)
sequenceA :: RHS' (f a) -> f (RHS' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => RHS' (f a) -> f (RHS' a)
traverse :: (a -> f b) -> RHS' a -> f (RHS' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RHS' a -> f (RHS' b)
$cp2Traversable :: Foldable RHS'
$cp1Traversable :: Functor RHS'
C.Traversable)

type MinimumSize = MinimumSize' BNFC'Position
data MinimumSize' a = MNonEmpty a | MEmpty a
  deriving (MinimumSize' a -> MinimumSize' a -> Bool
(MinimumSize' a -> MinimumSize' a -> Bool)
-> (MinimumSize' a -> MinimumSize' a -> Bool)
-> Eq (MinimumSize' a)
forall a. Eq a => MinimumSize' a -> MinimumSize' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MinimumSize' a -> MinimumSize' a -> Bool
$c/= :: forall a. Eq a => MinimumSize' a -> MinimumSize' a -> Bool
== :: MinimumSize' a -> MinimumSize' a -> Bool
$c== :: forall a. Eq a => MinimumSize' a -> MinimumSize' a -> Bool
C.Eq, Eq (MinimumSize' a)
Eq (MinimumSize' a)
-> (MinimumSize' a -> MinimumSize' a -> Ordering)
-> (MinimumSize' a -> MinimumSize' a -> Bool)
-> (MinimumSize' a -> MinimumSize' a -> Bool)
-> (MinimumSize' a -> MinimumSize' a -> Bool)
-> (MinimumSize' a -> MinimumSize' a -> Bool)
-> (MinimumSize' a -> MinimumSize' a -> MinimumSize' a)
-> (MinimumSize' a -> MinimumSize' a -> MinimumSize' a)
-> Ord (MinimumSize' a)
MinimumSize' a -> MinimumSize' a -> Bool
MinimumSize' a -> MinimumSize' a -> Ordering
MinimumSize' a -> MinimumSize' a -> MinimumSize' 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 (MinimumSize' a)
forall a. Ord a => MinimumSize' a -> MinimumSize' a -> Bool
forall a. Ord a => MinimumSize' a -> MinimumSize' a -> Ordering
forall a.
Ord a =>
MinimumSize' a -> MinimumSize' a -> MinimumSize' a
min :: MinimumSize' a -> MinimumSize' a -> MinimumSize' a
$cmin :: forall a.
Ord a =>
MinimumSize' a -> MinimumSize' a -> MinimumSize' a
max :: MinimumSize' a -> MinimumSize' a -> MinimumSize' a
$cmax :: forall a.
Ord a =>
MinimumSize' a -> MinimumSize' a -> MinimumSize' a
>= :: MinimumSize' a -> MinimumSize' a -> Bool
$c>= :: forall a. Ord a => MinimumSize' a -> MinimumSize' a -> Bool
> :: MinimumSize' a -> MinimumSize' a -> Bool
$c> :: forall a. Ord a => MinimumSize' a -> MinimumSize' a -> Bool
<= :: MinimumSize' a -> MinimumSize' a -> Bool
$c<= :: forall a. Ord a => MinimumSize' a -> MinimumSize' a -> Bool
< :: MinimumSize' a -> MinimumSize' a -> Bool
$c< :: forall a. Ord a => MinimumSize' a -> MinimumSize' a -> Bool
compare :: MinimumSize' a -> MinimumSize' a -> Ordering
$ccompare :: forall a. Ord a => MinimumSize' a -> MinimumSize' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (MinimumSize' a)
C.Ord, Int -> MinimumSize' a -> ShowS
[MinimumSize' a] -> ShowS
MinimumSize' a -> String
(Int -> MinimumSize' a -> ShowS)
-> (MinimumSize' a -> String)
-> ([MinimumSize' a] -> ShowS)
-> Show (MinimumSize' a)
forall a. Show a => Int -> MinimumSize' a -> ShowS
forall a. Show a => [MinimumSize' a] -> ShowS
forall a. Show a => MinimumSize' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MinimumSize' a] -> ShowS
$cshowList :: forall a. Show a => [MinimumSize' a] -> ShowS
show :: MinimumSize' a -> String
$cshow :: forall a. Show a => MinimumSize' a -> String
showsPrec :: Int -> MinimumSize' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> MinimumSize' a -> ShowS
C.Show, ReadPrec [MinimumSize' a]
ReadPrec (MinimumSize' a)
Int -> ReadS (MinimumSize' a)
ReadS [MinimumSize' a]
(Int -> ReadS (MinimumSize' a))
-> ReadS [MinimumSize' a]
-> ReadPrec (MinimumSize' a)
-> ReadPrec [MinimumSize' a]
-> Read (MinimumSize' a)
forall a. Read a => ReadPrec [MinimumSize' a]
forall a. Read a => ReadPrec (MinimumSize' a)
forall a. Read a => Int -> ReadS (MinimumSize' a)
forall a. Read a => ReadS [MinimumSize' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MinimumSize' a]
$creadListPrec :: forall a. Read a => ReadPrec [MinimumSize' a]
readPrec :: ReadPrec (MinimumSize' a)
$creadPrec :: forall a. Read a => ReadPrec (MinimumSize' a)
readList :: ReadS [MinimumSize' a]
$creadList :: forall a. Read a => ReadS [MinimumSize' a]
readsPrec :: Int -> ReadS (MinimumSize' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (MinimumSize' a)
C.Read, a -> MinimumSize' b -> MinimumSize' a
(a -> b) -> MinimumSize' a -> MinimumSize' b
(forall a b. (a -> b) -> MinimumSize' a -> MinimumSize' b)
-> (forall a b. a -> MinimumSize' b -> MinimumSize' a)
-> Functor MinimumSize'
forall a b. a -> MinimumSize' b -> MinimumSize' a
forall a b. (a -> b) -> MinimumSize' a -> MinimumSize' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> MinimumSize' b -> MinimumSize' a
$c<$ :: forall a b. a -> MinimumSize' b -> MinimumSize' a
fmap :: (a -> b) -> MinimumSize' a -> MinimumSize' b
$cfmap :: forall a b. (a -> b) -> MinimumSize' a -> MinimumSize' b
C.Functor, MinimumSize' a -> Bool
(a -> m) -> MinimumSize' a -> m
(a -> b -> b) -> b -> MinimumSize' a -> b
(forall m. Monoid m => MinimumSize' m -> m)
-> (forall m a. Monoid m => (a -> m) -> MinimumSize' a -> m)
-> (forall m a. Monoid m => (a -> m) -> MinimumSize' a -> m)
-> (forall a b. (a -> b -> b) -> b -> MinimumSize' a -> b)
-> (forall a b. (a -> b -> b) -> b -> MinimumSize' a -> b)
-> (forall b a. (b -> a -> b) -> b -> MinimumSize' a -> b)
-> (forall b a. (b -> a -> b) -> b -> MinimumSize' a -> b)
-> (forall a. (a -> a -> a) -> MinimumSize' a -> a)
-> (forall a. (a -> a -> a) -> MinimumSize' a -> a)
-> (forall a. MinimumSize' a -> [a])
-> (forall a. MinimumSize' a -> Bool)
-> (forall a. MinimumSize' a -> Int)
-> (forall a. Eq a => a -> MinimumSize' a -> Bool)
-> (forall a. Ord a => MinimumSize' a -> a)
-> (forall a. Ord a => MinimumSize' a -> a)
-> (forall a. Num a => MinimumSize' a -> a)
-> (forall a. Num a => MinimumSize' a -> a)
-> Foldable MinimumSize'
forall a. Eq a => a -> MinimumSize' a -> Bool
forall a. Num a => MinimumSize' a -> a
forall a. Ord a => MinimumSize' a -> a
forall m. Monoid m => MinimumSize' m -> m
forall a. MinimumSize' a -> Bool
forall a. MinimumSize' a -> Int
forall a. MinimumSize' a -> [a]
forall a. (a -> a -> a) -> MinimumSize' a -> a
forall m a. Monoid m => (a -> m) -> MinimumSize' a -> m
forall b a. (b -> a -> b) -> b -> MinimumSize' a -> b
forall a b. (a -> b -> b) -> b -> MinimumSize' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: MinimumSize' a -> a
$cproduct :: forall a. Num a => MinimumSize' a -> a
sum :: MinimumSize' a -> a
$csum :: forall a. Num a => MinimumSize' a -> a
minimum :: MinimumSize' a -> a
$cminimum :: forall a. Ord a => MinimumSize' a -> a
maximum :: MinimumSize' a -> a
$cmaximum :: forall a. Ord a => MinimumSize' a -> a
elem :: a -> MinimumSize' a -> Bool
$celem :: forall a. Eq a => a -> MinimumSize' a -> Bool
length :: MinimumSize' a -> Int
$clength :: forall a. MinimumSize' a -> Int
null :: MinimumSize' a -> Bool
$cnull :: forall a. MinimumSize' a -> Bool
toList :: MinimumSize' a -> [a]
$ctoList :: forall a. MinimumSize' a -> [a]
foldl1 :: (a -> a -> a) -> MinimumSize' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> MinimumSize' a -> a
foldr1 :: (a -> a -> a) -> MinimumSize' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> MinimumSize' a -> a
foldl' :: (b -> a -> b) -> b -> MinimumSize' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> MinimumSize' a -> b
foldl :: (b -> a -> b) -> b -> MinimumSize' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> MinimumSize' a -> b
foldr' :: (a -> b -> b) -> b -> MinimumSize' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> MinimumSize' a -> b
foldr :: (a -> b -> b) -> b -> MinimumSize' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> MinimumSize' a -> b
foldMap' :: (a -> m) -> MinimumSize' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> MinimumSize' a -> m
foldMap :: (a -> m) -> MinimumSize' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> MinimumSize' a -> m
fold :: MinimumSize' m -> m
$cfold :: forall m. Monoid m => MinimumSize' m -> m
C.Foldable, Functor MinimumSize'
Foldable MinimumSize'
Functor MinimumSize'
-> Foldable MinimumSize'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> MinimumSize' a -> f (MinimumSize' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    MinimumSize' (f a) -> f (MinimumSize' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MinimumSize' a -> m (MinimumSize' b))
-> (forall (m :: * -> *) a.
    Monad m =>
    MinimumSize' (m a) -> m (MinimumSize' a))
-> Traversable MinimumSize'
(a -> f b) -> MinimumSize' a -> f (MinimumSize' b)
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 =>
MinimumSize' (m a) -> m (MinimumSize' a)
forall (f :: * -> *) a.
Applicative f =>
MinimumSize' (f a) -> f (MinimumSize' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MinimumSize' a -> m (MinimumSize' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MinimumSize' a -> f (MinimumSize' b)
sequence :: MinimumSize' (m a) -> m (MinimumSize' a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
MinimumSize' (m a) -> m (MinimumSize' a)
mapM :: (a -> m b) -> MinimumSize' a -> m (MinimumSize' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MinimumSize' a -> m (MinimumSize' b)
sequenceA :: MinimumSize' (f a) -> f (MinimumSize' a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
MinimumSize' (f a) -> f (MinimumSize' a)
traverse :: (a -> f b) -> MinimumSize' a -> f (MinimumSize' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MinimumSize' a -> f (MinimumSize' b)
$cp2Traversable :: Foldable MinimumSize'
$cp1Traversable :: Functor MinimumSize'
C.Traversable)

type Reg = Reg' BNFC'Position
data Reg' a
    = RAlt a (Reg' a) (Reg' a)
    | RMinus a (Reg' a) (Reg' a)
    | RSeq a (Reg' a) (Reg' a)
    | RStar a (Reg' a)
    | RPlus a (Reg' a)
    | ROpt a (Reg' a)
    | REps a
    | RChar a Char
    | RAlts a String
    | RSeqs a String
    | RDigit a
    | RLetter a
    | RUpper a
    | RLower a
    | RAny a
  deriving (Reg' a -> Reg' a -> Bool
(Reg' a -> Reg' a -> Bool)
-> (Reg' a -> Reg' a -> Bool) -> Eq (Reg' a)
forall a. Eq a => Reg' a -> Reg' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Reg' a -> Reg' a -> Bool
$c/= :: forall a. Eq a => Reg' a -> Reg' a -> Bool
== :: Reg' a -> Reg' a -> Bool
$c== :: forall a. Eq a => Reg' a -> Reg' a -> Bool
C.Eq, Eq (Reg' a)
Eq (Reg' a)
-> (Reg' a -> Reg' a -> Ordering)
-> (Reg' a -> Reg' a -> Bool)
-> (Reg' a -> Reg' a -> Bool)
-> (Reg' a -> Reg' a -> Bool)
-> (Reg' a -> Reg' a -> Bool)
-> (Reg' a -> Reg' a -> Reg' a)
-> (Reg' a -> Reg' a -> Reg' a)
-> Ord (Reg' a)
Reg' a -> Reg' a -> Bool
Reg' a -> Reg' a -> Ordering
Reg' a -> Reg' a -> Reg' 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 (Reg' a)
forall a. Ord a => Reg' a -> Reg' a -> Bool
forall a. Ord a => Reg' a -> Reg' a -> Ordering
forall a. Ord a => Reg' a -> Reg' a -> Reg' a
min :: Reg' a -> Reg' a -> Reg' a
$cmin :: forall a. Ord a => Reg' a -> Reg' a -> Reg' a
max :: Reg' a -> Reg' a -> Reg' a
$cmax :: forall a. Ord a => Reg' a -> Reg' a -> Reg' a
>= :: Reg' a -> Reg' a -> Bool
$c>= :: forall a. Ord a => Reg' a -> Reg' a -> Bool
> :: Reg' a -> Reg' a -> Bool
$c> :: forall a. Ord a => Reg' a -> Reg' a -> Bool
<= :: Reg' a -> Reg' a -> Bool
$c<= :: forall a. Ord a => Reg' a -> Reg' a -> Bool
< :: Reg' a -> Reg' a -> Bool
$c< :: forall a. Ord a => Reg' a -> Reg' a -> Bool
compare :: Reg' a -> Reg' a -> Ordering
$ccompare :: forall a. Ord a => Reg' a -> Reg' a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Reg' a)
C.Ord, Int -> Reg' a -> ShowS
[Reg' a] -> ShowS
Reg' a -> String
(Int -> Reg' a -> ShowS)
-> (Reg' a -> String) -> ([Reg' a] -> ShowS) -> Show (Reg' a)
forall a. Show a => Int -> Reg' a -> ShowS
forall a. Show a => [Reg' a] -> ShowS
forall a. Show a => Reg' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Reg' a] -> ShowS
$cshowList :: forall a. Show a => [Reg' a] -> ShowS
show :: Reg' a -> String
$cshow :: forall a. Show a => Reg' a -> String
showsPrec :: Int -> Reg' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Reg' a -> ShowS
C.Show, ReadPrec [Reg' a]
ReadPrec (Reg' a)
Int -> ReadS (Reg' a)
ReadS [Reg' a]
(Int -> ReadS (Reg' a))
-> ReadS [Reg' a]
-> ReadPrec (Reg' a)
-> ReadPrec [Reg' a]
-> Read (Reg' a)
forall a. Read a => ReadPrec [Reg' a]
forall a. Read a => ReadPrec (Reg' a)
forall a. Read a => Int -> ReadS (Reg' a)
forall a. Read a => ReadS [Reg' a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Reg' a]
$creadListPrec :: forall a. Read a => ReadPrec [Reg' a]
readPrec :: ReadPrec (Reg' a)
$creadPrec :: forall a. Read a => ReadPrec (Reg' a)
readList :: ReadS [Reg' a]
$creadList :: forall a. Read a => ReadS [Reg' a]
readsPrec :: Int -> ReadS (Reg' a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Reg' a)
C.Read, a -> Reg' b -> Reg' a
(a -> b) -> Reg' a -> Reg' b
(forall a b. (a -> b) -> Reg' a -> Reg' b)
-> (forall a b. a -> Reg' b -> Reg' a) -> Functor Reg'
forall a b. a -> Reg' b -> Reg' a
forall a b. (a -> b) -> Reg' a -> Reg' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Reg' b -> Reg' a
$c<$ :: forall a b. a -> Reg' b -> Reg' a
fmap :: (a -> b) -> Reg' a -> Reg' b
$cfmap :: forall a b. (a -> b) -> Reg' a -> Reg' b
C.Functor, Reg' a -> Bool
(a -> m) -> Reg' a -> m
(a -> b -> b) -> b -> Reg' a -> b
(forall m. Monoid m => Reg' m -> m)
-> (forall m a. Monoid m => (a -> m) -> Reg' a -> m)
-> (forall m a. Monoid m => (a -> m) -> Reg' a -> m)
-> (forall a b. (a -> b -> b) -> b -> Reg' a -> b)
-> (forall a b. (a -> b -> b) -> b -> Reg' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Reg' a -> b)
-> (forall b a. (b -> a -> b) -> b -> Reg' a -> b)
-> (forall a. (a -> a -> a) -> Reg' a -> a)
-> (forall a. (a -> a -> a) -> Reg' a -> a)
-> (forall a. Reg' a -> [a])
-> (forall a. Reg' a -> Bool)
-> (forall a. Reg' a -> Int)
-> (forall a. Eq a => a -> Reg' a -> Bool)
-> (forall a. Ord a => Reg' a -> a)
-> (forall a. Ord a => Reg' a -> a)
-> (forall a. Num a => Reg' a -> a)
-> (forall a. Num a => Reg' a -> a)
-> Foldable Reg'
forall a. Eq a => a -> Reg' a -> Bool
forall a. Num a => Reg' a -> a
forall a. Ord a => Reg' a -> a
forall m. Monoid m => Reg' m -> m
forall a. Reg' a -> Bool
forall a. Reg' a -> Int
forall a. Reg' a -> [a]
forall a. (a -> a -> a) -> Reg' a -> a
forall m a. Monoid m => (a -> m) -> Reg' a -> m
forall b a. (b -> a -> b) -> b -> Reg' a -> b
forall a b. (a -> b -> b) -> b -> Reg' a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: Reg' a -> a
$cproduct :: forall a. Num a => Reg' a -> a
sum :: Reg' a -> a
$csum :: forall a. Num a => Reg' a -> a
minimum :: Reg' a -> a
$cminimum :: forall a. Ord a => Reg' a -> a
maximum :: Reg' a -> a
$cmaximum :: forall a. Ord a => Reg' a -> a
elem :: a -> Reg' a -> Bool
$celem :: forall a. Eq a => a -> Reg' a -> Bool
length :: Reg' a -> Int
$clength :: forall a. Reg' a -> Int
null :: Reg' a -> Bool
$cnull :: forall a. Reg' a -> Bool
toList :: Reg' a -> [a]
$ctoList :: forall a. Reg' a -> [a]
foldl1 :: (a -> a -> a) -> Reg' a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Reg' a -> a
foldr1 :: (a -> a -> a) -> Reg' a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Reg' a -> a
foldl' :: (b -> a -> b) -> b -> Reg' a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Reg' a -> b
foldl :: (b -> a -> b) -> b -> Reg' a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Reg' a -> b
foldr' :: (a -> b -> b) -> b -> Reg' a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Reg' a -> b
foldr :: (a -> b -> b) -> b -> Reg' a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Reg' a -> b
foldMap' :: (a -> m) -> Reg' a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Reg' a -> m
foldMap :: (a -> m) -> Reg' a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Reg' a -> m
fold :: Reg' m -> m
$cfold :: forall m. Monoid m => Reg' m -> m
C.Foldable, Functor Reg'
Foldable Reg'
Functor Reg'
-> Foldable Reg'
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Reg' a -> f (Reg' b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Reg' (f a) -> f (Reg' a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Reg' a -> m (Reg' b))
-> (forall (m :: * -> *) a. Monad m => Reg' (m a) -> m (Reg' a))
-> Traversable Reg'
(a -> f b) -> Reg' a -> f (Reg' b)
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 => Reg' (m a) -> m (Reg' a)
forall (f :: * -> *) a. Applicative f => Reg' (f a) -> f (Reg' a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Reg' a -> m (Reg' b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Reg' a -> f (Reg' b)
sequence :: Reg' (m a) -> m (Reg' a)
$csequence :: forall (m :: * -> *) a. Monad m => Reg' (m a) -> m (Reg' a)
mapM :: (a -> m b) -> Reg' a -> m (Reg' b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Reg' a -> m (Reg' b)
sequenceA :: Reg' (f a) -> f (Reg' a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Reg' (f a) -> f (Reg' a)
traverse :: (a -> f b) -> Reg' a -> f (Reg' b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Reg' a -> f (Reg' b)
$cp2Traversable :: Foldable Reg'
$cp1Traversable :: Functor Reg'
C.Traversable)

newtype Identifier = Identifier ((C.Int, C.Int), String)
  deriving (Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c== :: Identifier -> Identifier -> Bool
C.Eq, Eq Identifier
Eq Identifier
-> (Identifier -> Identifier -> Ordering)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Identifier)
-> (Identifier -> Identifier -> Identifier)
-> Ord Identifier
Identifier -> Identifier -> Bool
Identifier -> Identifier -> Ordering
Identifier -> Identifier -> Identifier
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Identifier -> Identifier -> Identifier
$cmin :: Identifier -> Identifier -> Identifier
max :: Identifier -> Identifier -> Identifier
$cmax :: Identifier -> Identifier -> Identifier
>= :: Identifier -> Identifier -> Bool
$c>= :: Identifier -> Identifier -> Bool
> :: Identifier -> Identifier -> Bool
$c> :: Identifier -> Identifier -> Bool
<= :: Identifier -> Identifier -> Bool
$c<= :: Identifier -> Identifier -> Bool
< :: Identifier -> Identifier -> Bool
$c< :: Identifier -> Identifier -> Bool
compare :: Identifier -> Identifier -> Ordering
$ccompare :: Identifier -> Identifier -> Ordering
$cp1Ord :: Eq Identifier
C.Ord, Int -> Identifier -> ShowS
[Identifier] -> ShowS
Identifier -> String
(Int -> Identifier -> ShowS)
-> (Identifier -> String)
-> ([Identifier] -> ShowS)
-> Show Identifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Identifier] -> ShowS
$cshowList :: [Identifier] -> ShowS
show :: Identifier -> String
$cshow :: Identifier -> String
showsPrec :: Int -> Identifier -> ShowS
$cshowsPrec :: Int -> Identifier -> ShowS
C.Show, ReadPrec [Identifier]
ReadPrec Identifier
Int -> ReadS Identifier
ReadS [Identifier]
(Int -> ReadS Identifier)
-> ReadS [Identifier]
-> ReadPrec Identifier
-> ReadPrec [Identifier]
-> Read Identifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Identifier]
$creadListPrec :: ReadPrec [Identifier]
readPrec :: ReadPrec Identifier
$creadPrec :: ReadPrec Identifier
readList :: ReadS [Identifier]
$creadList :: ReadS [Identifier]
readsPrec :: Int -> ReadS Identifier
$creadsPrec :: Int -> ReadS Identifier
C.Read)

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

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

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

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

-- | Get the start position of something.

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

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

instance HasPosition Def where
  hasPosition :: Def' BNFC'Position -> BNFC'Position
hasPosition = \case
    Rule BNFC'Position
p Label' BNFC'Position
_ Cat' BNFC'Position
_ RHS' BNFC'Position
_ -> BNFC'Position
p
    Comment BNFC'Position
p String
_ -> BNFC'Position
p
    Comments BNFC'Position
p String
_ String
_ -> BNFC'Position
p
    Internal BNFC'Position
p Label' BNFC'Position
_ Cat' BNFC'Position
_ RHS' BNFC'Position
_ -> BNFC'Position
p
    Token BNFC'Position
p Identifier
_ Reg' BNFC'Position
_ -> BNFC'Position
p
    PosToken BNFC'Position
p Identifier
_ Reg' BNFC'Position
_ -> BNFC'Position
p
    Entryp BNFC'Position
p [Cat' BNFC'Position]
_ -> BNFC'Position
p
    Separator BNFC'Position
p MinimumSize' BNFC'Position
_ Cat' BNFC'Position
_ String
_ -> BNFC'Position
p
    Terminator BNFC'Position
p MinimumSize' BNFC'Position
_ Cat' BNFC'Position
_ String
_ -> BNFC'Position
p
    Delimiters BNFC'Position
p Cat' BNFC'Position
_ String
_ String
_ Separation' BNFC'Position
_ MinimumSize' BNFC'Position
_ -> BNFC'Position
p
    Coercions BNFC'Position
p Identifier
_ Integer
_ -> BNFC'Position
p
    Rules BNFC'Position
p Identifier
_ [RHS' BNFC'Position]
_ -> BNFC'Position
p
    Function BNFC'Position
p Identifier
_ [Arg' BNFC'Position]
_ Exp' BNFC'Position
_ -> BNFC'Position
p
    Layout BNFC'Position
p [String]
_ -> BNFC'Position
p
    LayoutStop BNFC'Position
p [String]
_ -> BNFC'Position
p
    LayoutTop BNFC'Position
p -> BNFC'Position
p

instance HasPosition Item where
  hasPosition :: Item -> BNFC'Position
hasPosition = \case
    Terminal BNFC'Position
p String
_ -> BNFC'Position
p
    NTerminal BNFC'Position
p Cat' BNFC'Position
_ -> BNFC'Position
p

instance HasPosition Cat where
  hasPosition :: Cat' BNFC'Position -> BNFC'Position
hasPosition = \case
    ListCat BNFC'Position
p Cat' BNFC'Position
_ -> BNFC'Position
p
    IdCat BNFC'Position
p Identifier
_ -> BNFC'Position
p

instance HasPosition Label where
  hasPosition :: Label' BNFC'Position -> BNFC'Position
hasPosition = \case
    Id BNFC'Position
p Identifier
_ -> BNFC'Position
p
    Wild BNFC'Position
p -> BNFC'Position
p
    ListEmpty BNFC'Position
p -> BNFC'Position
p
    ListCons BNFC'Position
p -> BNFC'Position
p
    ListOne BNFC'Position
p -> BNFC'Position
p

instance HasPosition Arg where
  hasPosition :: Arg' BNFC'Position -> BNFC'Position
hasPosition = \case
    Arg BNFC'Position
p Identifier
_ -> BNFC'Position
p

instance HasPosition Separation where
  hasPosition :: Separation' BNFC'Position -> BNFC'Position
hasPosition = \case
    SepNone BNFC'Position
p -> BNFC'Position
p
    SepTerm BNFC'Position
p String
_ -> BNFC'Position
p
    SepSepar BNFC'Position
p String
_ -> BNFC'Position
p

instance HasPosition Exp where
  hasPosition :: Exp' BNFC'Position -> BNFC'Position
hasPosition = \case
    Cons BNFC'Position
p Exp' BNFC'Position
_ Exp' BNFC'Position
_ -> BNFC'Position
p
    App BNFC'Position
p Identifier
_ [Exp' BNFC'Position]
_ -> BNFC'Position
p
    Var BNFC'Position
p Identifier
_ -> BNFC'Position
p
    LitInteger BNFC'Position
p Integer
_ -> BNFC'Position
p
    LitChar BNFC'Position
p Char
_ -> BNFC'Position
p
    LitString BNFC'Position
p String
_ -> BNFC'Position
p
    LitDouble BNFC'Position
p Double
_ -> BNFC'Position
p
    List BNFC'Position
p [Exp' BNFC'Position]
_ -> BNFC'Position
p

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

instance HasPosition MinimumSize where
  hasPosition :: MinimumSize' BNFC'Position -> BNFC'Position
hasPosition = \case
    MNonEmpty BNFC'Position
p -> BNFC'Position
p
    MEmpty BNFC'Position
p -> BNFC'Position
p

instance HasPosition Reg where
  hasPosition :: Reg' BNFC'Position -> BNFC'Position
hasPosition = \case
    RAlt BNFC'Position
p Reg' BNFC'Position
_ Reg' BNFC'Position
_ -> BNFC'Position
p
    RMinus BNFC'Position
p Reg' BNFC'Position
_ Reg' BNFC'Position
_ -> BNFC'Position
p
    RSeq BNFC'Position
p Reg' BNFC'Position
_ Reg' BNFC'Position
_ -> BNFC'Position
p
    RStar BNFC'Position
p Reg' BNFC'Position
_ -> BNFC'Position
p
    RPlus BNFC'Position
p Reg' BNFC'Position
_ -> BNFC'Position
p
    ROpt BNFC'Position
p Reg' BNFC'Position
_ -> BNFC'Position
p
    REps BNFC'Position
p -> BNFC'Position
p
    RChar BNFC'Position
p Char
_ -> BNFC'Position
p
    RAlts BNFC'Position
p String
_ -> BNFC'Position
p
    RSeqs BNFC'Position
p String
_ -> BNFC'Position
p
    RDigit BNFC'Position
p -> BNFC'Position
p
    RLetter BNFC'Position
p -> BNFC'Position
p
    RUpper BNFC'Position
p -> BNFC'Position
p
    RLower BNFC'Position
p -> BNFC'Position
p
    RAny BNFC'Position
p -> BNFC'Position
p

instance HasPosition Identifier where
  hasPosition :: Identifier -> BNFC'Position
hasPosition (Identifier ((Int, Int)
p, String
_)) = (Int, Int) -> BNFC'Position
forall a. a -> Maybe a
C.Just (Int, Int)
p