-- | This module contains data types for the entire PureScript surface language. Every
-- token is represented in the tree, and every token is annotated with
-- whitespace and comments (both leading and trailing). This means one can write
-- an exact printer so that `print . parse = id`. Every constructor is laid out
-- with tokens in left-to-right order. The core productions are given a slot for
-- arbitrary annotations, however this is not used by the parser.

module Language.PureScript.CST.Types where

import Prelude

import Data.List.NonEmpty (NonEmpty)
import Data.Text (Text)
import Data.Void (Void)
import GHC.Generics (Generic)
import Language.PureScript.Names qualified as N
import Language.PureScript.Roles qualified as R
import Language.PureScript.PSString (PSString)

data SourcePos = SourcePos
  { SourcePos -> Int
srcLine :: {-# UNPACK #-} !Int
  , SourcePos -> Int
srcColumn :: {-# UNPACK #-} !Int
  } deriving (Int -> SourcePos -> ShowS
[SourcePos] -> ShowS
SourcePos -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SourcePos] -> ShowS
$cshowList :: [SourcePos] -> ShowS
show :: SourcePos -> String
$cshow :: SourcePos -> String
showsPrec :: Int -> SourcePos -> ShowS
$cshowsPrec :: Int -> SourcePos -> ShowS
Show, SourcePos -> SourcePos -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SourcePos -> SourcePos -> Bool
$c/= :: SourcePos -> SourcePos -> Bool
== :: SourcePos -> SourcePos -> Bool
$c== :: SourcePos -> SourcePos -> Bool
Eq, Eq SourcePos
SourcePos -> SourcePos -> Bool
SourcePos -> SourcePos -> Ordering
SourcePos -> SourcePos -> SourcePos
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 :: SourcePos -> SourcePos -> SourcePos
$cmin :: SourcePos -> SourcePos -> SourcePos
max :: SourcePos -> SourcePos -> SourcePos
$cmax :: SourcePos -> SourcePos -> SourcePos
>= :: SourcePos -> SourcePos -> Bool
$c>= :: SourcePos -> SourcePos -> Bool
> :: SourcePos -> SourcePos -> Bool
$c> :: SourcePos -> SourcePos -> Bool
<= :: SourcePos -> SourcePos -> Bool
$c<= :: SourcePos -> SourcePos -> Bool
< :: SourcePos -> SourcePos -> Bool
$c< :: SourcePos -> SourcePos -> Bool
compare :: SourcePos -> SourcePos -> Ordering
$ccompare :: SourcePos -> SourcePos -> Ordering
Ord, forall x. Rep SourcePos x -> SourcePos
forall x. SourcePos -> Rep SourcePos x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SourcePos x -> SourcePos
$cfrom :: forall x. SourcePos -> Rep SourcePos x
Generic)

data SourceRange = SourceRange
  { SourceRange -> SourcePos
srcStart :: !SourcePos
  , SourceRange -> SourcePos
srcEnd :: !SourcePos
  } deriving (Int -> SourceRange -> ShowS
[SourceRange] -> ShowS
SourceRange -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SourceRange] -> ShowS
$cshowList :: [SourceRange] -> ShowS
show :: SourceRange -> String
$cshow :: SourceRange -> String
showsPrec :: Int -> SourceRange -> ShowS
$cshowsPrec :: Int -> SourceRange -> ShowS
Show, SourceRange -> SourceRange -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SourceRange -> SourceRange -> Bool
$c/= :: SourceRange -> SourceRange -> Bool
== :: SourceRange -> SourceRange -> Bool
$c== :: SourceRange -> SourceRange -> Bool
Eq, Eq SourceRange
SourceRange -> SourceRange -> Bool
SourceRange -> SourceRange -> Ordering
SourceRange -> SourceRange -> SourceRange
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 :: SourceRange -> SourceRange -> SourceRange
$cmin :: SourceRange -> SourceRange -> SourceRange
max :: SourceRange -> SourceRange -> SourceRange
$cmax :: SourceRange -> SourceRange -> SourceRange
>= :: SourceRange -> SourceRange -> Bool
$c>= :: SourceRange -> SourceRange -> Bool
> :: SourceRange -> SourceRange -> Bool
$c> :: SourceRange -> SourceRange -> Bool
<= :: SourceRange -> SourceRange -> Bool
$c<= :: SourceRange -> SourceRange -> Bool
< :: SourceRange -> SourceRange -> Bool
$c< :: SourceRange -> SourceRange -> Bool
compare :: SourceRange -> SourceRange -> Ordering
$ccompare :: SourceRange -> SourceRange -> Ordering
Ord, forall x. Rep SourceRange x -> SourceRange
forall x. SourceRange -> Rep SourceRange x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SourceRange x -> SourceRange
$cfrom :: forall x. SourceRange -> Rep SourceRange x
Generic)

data Comment l
  = Comment !Text
  | Space {-# UNPACK #-} !Int
  | Line !l
  deriving (Int -> Comment l -> ShowS
forall l. Show l => Int -> Comment l -> ShowS
forall l. Show l => [Comment l] -> ShowS
forall l. Show l => Comment l -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Comment l] -> ShowS
$cshowList :: forall l. Show l => [Comment l] -> ShowS
show :: Comment l -> String
$cshow :: forall l. Show l => Comment l -> String
showsPrec :: Int -> Comment l -> ShowS
$cshowsPrec :: forall l. Show l => Int -> Comment l -> ShowS
Show, Comment l -> Comment l -> Bool
forall l. Eq l => Comment l -> Comment l -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Comment l -> Comment l -> Bool
$c/= :: forall l. Eq l => Comment l -> Comment l -> Bool
== :: Comment l -> Comment l -> Bool
$c== :: forall l. Eq l => Comment l -> Comment l -> Bool
Eq, Comment l -> Comment l -> Bool
Comment l -> Comment l -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {l}. Ord l => Eq (Comment l)
forall l. Ord l => Comment l -> Comment l -> Bool
forall l. Ord l => Comment l -> Comment l -> Ordering
forall l. Ord l => Comment l -> Comment l -> Comment l
min :: Comment l -> Comment l -> Comment l
$cmin :: forall l. Ord l => Comment l -> Comment l -> Comment l
max :: Comment l -> Comment l -> Comment l
$cmax :: forall l. Ord l => Comment l -> Comment l -> Comment l
>= :: Comment l -> Comment l -> Bool
$c>= :: forall l. Ord l => Comment l -> Comment l -> Bool
> :: Comment l -> Comment l -> Bool
$c> :: forall l. Ord l => Comment l -> Comment l -> Bool
<= :: Comment l -> Comment l -> Bool
$c<= :: forall l. Ord l => Comment l -> Comment l -> Bool
< :: Comment l -> Comment l -> Bool
$c< :: forall l. Ord l => Comment l -> Comment l -> Bool
compare :: Comment l -> Comment l -> Ordering
$ccompare :: forall l. Ord l => Comment l -> Comment l -> Ordering
Ord, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall l x. Rep (Comment l) x -> Comment l
forall l x. Comment l -> Rep (Comment l) x
$cto :: forall l x. Rep (Comment l) x -> Comment l
$cfrom :: forall l x. Comment l -> Rep (Comment l) x
Generic, forall a b. a -> Comment b -> Comment a
forall a b. (a -> b) -> Comment a -> Comment b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Comment b -> Comment a
$c<$ :: forall a b. a -> Comment b -> Comment a
fmap :: forall a b. (a -> b) -> Comment a -> Comment b
$cfmap :: forall a b. (a -> b) -> Comment a -> Comment b
Functor)

data LineFeed = LF | CRLF
  deriving (Int -> LineFeed -> ShowS
[LineFeed] -> ShowS
LineFeed -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LineFeed] -> ShowS
$cshowList :: [LineFeed] -> ShowS
show :: LineFeed -> String
$cshow :: LineFeed -> String
showsPrec :: Int -> LineFeed -> ShowS
$cshowsPrec :: Int -> LineFeed -> ShowS
Show, LineFeed -> LineFeed -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LineFeed -> LineFeed -> Bool
$c/= :: LineFeed -> LineFeed -> Bool
== :: LineFeed -> LineFeed -> Bool
$c== :: LineFeed -> LineFeed -> Bool
Eq, Eq LineFeed
LineFeed -> LineFeed -> Bool
LineFeed -> LineFeed -> Ordering
LineFeed -> LineFeed -> LineFeed
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 :: LineFeed -> LineFeed -> LineFeed
$cmin :: LineFeed -> LineFeed -> LineFeed
max :: LineFeed -> LineFeed -> LineFeed
$cmax :: LineFeed -> LineFeed -> LineFeed
>= :: LineFeed -> LineFeed -> Bool
$c>= :: LineFeed -> LineFeed -> Bool
> :: LineFeed -> LineFeed -> Bool
$c> :: LineFeed -> LineFeed -> Bool
<= :: LineFeed -> LineFeed -> Bool
$c<= :: LineFeed -> LineFeed -> Bool
< :: LineFeed -> LineFeed -> Bool
$c< :: LineFeed -> LineFeed -> Bool
compare :: LineFeed -> LineFeed -> Ordering
$ccompare :: LineFeed -> LineFeed -> Ordering
Ord, forall x. Rep LineFeed x -> LineFeed
forall x. LineFeed -> Rep LineFeed x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LineFeed x -> LineFeed
$cfrom :: forall x. LineFeed -> Rep LineFeed x
Generic)

data TokenAnn = TokenAnn
  { TokenAnn -> SourceRange
tokRange :: !SourceRange
  , TokenAnn -> [Comment LineFeed]
tokLeadingComments :: ![Comment LineFeed]
  , TokenAnn -> [Comment Void]
tokTrailingComments :: ![Comment Void]
  } deriving (Int -> TokenAnn -> ShowS
[TokenAnn] -> ShowS
TokenAnn -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TokenAnn] -> ShowS
$cshowList :: [TokenAnn] -> ShowS
show :: TokenAnn -> String
$cshow :: TokenAnn -> String
showsPrec :: Int -> TokenAnn -> ShowS
$cshowsPrec :: Int -> TokenAnn -> ShowS
Show, TokenAnn -> TokenAnn -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TokenAnn -> TokenAnn -> Bool
$c/= :: TokenAnn -> TokenAnn -> Bool
== :: TokenAnn -> TokenAnn -> Bool
$c== :: TokenAnn -> TokenAnn -> Bool
Eq, Eq TokenAnn
TokenAnn -> TokenAnn -> Bool
TokenAnn -> TokenAnn -> Ordering
TokenAnn -> TokenAnn -> TokenAnn
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 :: TokenAnn -> TokenAnn -> TokenAnn
$cmin :: TokenAnn -> TokenAnn -> TokenAnn
max :: TokenAnn -> TokenAnn -> TokenAnn
$cmax :: TokenAnn -> TokenAnn -> TokenAnn
>= :: TokenAnn -> TokenAnn -> Bool
$c>= :: TokenAnn -> TokenAnn -> Bool
> :: TokenAnn -> TokenAnn -> Bool
$c> :: TokenAnn -> TokenAnn -> Bool
<= :: TokenAnn -> TokenAnn -> Bool
$c<= :: TokenAnn -> TokenAnn -> Bool
< :: TokenAnn -> TokenAnn -> Bool
$c< :: TokenAnn -> TokenAnn -> Bool
compare :: TokenAnn -> TokenAnn -> Ordering
$ccompare :: TokenAnn -> TokenAnn -> Ordering
Ord, forall x. Rep TokenAnn x -> TokenAnn
forall x. TokenAnn -> Rep TokenAnn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TokenAnn x -> TokenAnn
$cfrom :: forall x. TokenAnn -> Rep TokenAnn x
Generic)

data SourceStyle = ASCII | Unicode
  deriving (Int -> SourceStyle -> ShowS
[SourceStyle] -> ShowS
SourceStyle -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SourceStyle] -> ShowS
$cshowList :: [SourceStyle] -> ShowS
show :: SourceStyle -> String
$cshow :: SourceStyle -> String
showsPrec :: Int -> SourceStyle -> ShowS
$cshowsPrec :: Int -> SourceStyle -> ShowS
Show, SourceStyle -> SourceStyle -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SourceStyle -> SourceStyle -> Bool
$c/= :: SourceStyle -> SourceStyle -> Bool
== :: SourceStyle -> SourceStyle -> Bool
$c== :: SourceStyle -> SourceStyle -> Bool
Eq, Eq SourceStyle
SourceStyle -> SourceStyle -> Bool
SourceStyle -> SourceStyle -> Ordering
SourceStyle -> SourceStyle -> SourceStyle
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 :: SourceStyle -> SourceStyle -> SourceStyle
$cmin :: SourceStyle -> SourceStyle -> SourceStyle
max :: SourceStyle -> SourceStyle -> SourceStyle
$cmax :: SourceStyle -> SourceStyle -> SourceStyle
>= :: SourceStyle -> SourceStyle -> Bool
$c>= :: SourceStyle -> SourceStyle -> Bool
> :: SourceStyle -> SourceStyle -> Bool
$c> :: SourceStyle -> SourceStyle -> Bool
<= :: SourceStyle -> SourceStyle -> Bool
$c<= :: SourceStyle -> SourceStyle -> Bool
< :: SourceStyle -> SourceStyle -> Bool
$c< :: SourceStyle -> SourceStyle -> Bool
compare :: SourceStyle -> SourceStyle -> Ordering
$ccompare :: SourceStyle -> SourceStyle -> Ordering
Ord, forall x. Rep SourceStyle x -> SourceStyle
forall x. SourceStyle -> Rep SourceStyle x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SourceStyle x -> SourceStyle
$cfrom :: forall x. SourceStyle -> Rep SourceStyle x
Generic)

data Token
  = TokLeftParen
  | TokRightParen
  | TokLeftBrace
  | TokRightBrace
  | TokLeftSquare
  | TokRightSquare
  | TokLeftArrow !SourceStyle
  | TokRightArrow !SourceStyle
  | TokRightFatArrow !SourceStyle
  | TokDoubleColon !SourceStyle
  | TokForall !SourceStyle
  | TokEquals
  | TokPipe
  | TokTick
  | TokDot
  | TokComma
  | TokUnderscore
  | TokBackslash
  | TokLowerName ![Text] !Text
  | TokUpperName ![Text] !Text
  | TokOperator ![Text] !Text
  | TokSymbolName ![Text] !Text
  | TokSymbolArr !SourceStyle
  | TokHole !Text
  | TokChar !Text !Char
  | TokString !Text !PSString
  | TokRawString !Text
  | TokInt !Text !Integer
  | TokNumber !Text !Double
  | TokLayoutStart
  | TokLayoutSep
  | TokLayoutEnd
  | TokEof
  deriving (Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Token] -> ShowS
$cshowList :: [Token] -> ShowS
show :: Token -> String
$cshow :: Token -> String
showsPrec :: Int -> Token -> ShowS
$cshowsPrec :: Int -> Token -> ShowS
Show, Token -> Token -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c== :: Token -> Token -> Bool
Eq, Eq Token
Token -> Token -> Bool
Token -> Token -> Ordering
Token -> Token -> Token
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 :: Token -> Token -> Token
$cmin :: Token -> Token -> Token
max :: Token -> Token -> Token
$cmax :: Token -> Token -> Token
>= :: Token -> Token -> Bool
$c>= :: Token -> Token -> Bool
> :: Token -> Token -> Bool
$c> :: Token -> Token -> Bool
<= :: Token -> Token -> Bool
$c<= :: Token -> Token -> Bool
< :: Token -> Token -> Bool
$c< :: Token -> Token -> Bool
compare :: Token -> Token -> Ordering
$ccompare :: Token -> Token -> Ordering
Ord, forall x. Rep Token x -> Token
forall x. Token -> Rep Token x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Token x -> Token
$cfrom :: forall x. Token -> Rep Token x
Generic)

data SourceToken = SourceToken
  { SourceToken -> TokenAnn
tokAnn :: !TokenAnn
  , SourceToken -> Token
tokValue :: !Token
  } deriving (Int -> SourceToken -> ShowS
[SourceToken] -> ShowS
SourceToken -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SourceToken] -> ShowS
$cshowList :: [SourceToken] -> ShowS
show :: SourceToken -> String
$cshow :: SourceToken -> String
showsPrec :: Int -> SourceToken -> ShowS
$cshowsPrec :: Int -> SourceToken -> ShowS
Show, SourceToken -> SourceToken -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SourceToken -> SourceToken -> Bool
$c/= :: SourceToken -> SourceToken -> Bool
== :: SourceToken -> SourceToken -> Bool
$c== :: SourceToken -> SourceToken -> Bool
Eq, Eq SourceToken
SourceToken -> SourceToken -> Bool
SourceToken -> SourceToken -> Ordering
SourceToken -> SourceToken -> SourceToken
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 :: SourceToken -> SourceToken -> SourceToken
$cmin :: SourceToken -> SourceToken -> SourceToken
max :: SourceToken -> SourceToken -> SourceToken
$cmax :: SourceToken -> SourceToken -> SourceToken
>= :: SourceToken -> SourceToken -> Bool
$c>= :: SourceToken -> SourceToken -> Bool
> :: SourceToken -> SourceToken -> Bool
$c> :: SourceToken -> SourceToken -> Bool
<= :: SourceToken -> SourceToken -> Bool
$c<= :: SourceToken -> SourceToken -> Bool
< :: SourceToken -> SourceToken -> Bool
$c< :: SourceToken -> SourceToken -> Bool
compare :: SourceToken -> SourceToken -> Ordering
$ccompare :: SourceToken -> SourceToken -> Ordering
Ord, forall x. Rep SourceToken x -> SourceToken
forall x. SourceToken -> Rep SourceToken x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SourceToken x -> SourceToken
$cfrom :: forall x. SourceToken -> Rep SourceToken x
Generic)

data Ident = Ident
  { Ident -> Text
getIdent :: Text
  } deriving (Int -> Ident -> ShowS
[Ident] -> ShowS
Ident -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ident] -> ShowS
$cshowList :: [Ident] -> ShowS
show :: Ident -> String
$cshow :: Ident -> String
showsPrec :: Int -> Ident -> ShowS
$cshowsPrec :: Int -> Ident -> ShowS
Show, Ident -> Ident -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ident -> Ident -> Bool
$c/= :: Ident -> Ident -> Bool
== :: Ident -> Ident -> Bool
$c== :: Ident -> Ident -> Bool
Eq, Eq Ident
Ident -> Ident -> Bool
Ident -> Ident -> Ordering
Ident -> Ident -> Ident
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 :: Ident -> Ident -> Ident
$cmin :: Ident -> Ident -> Ident
max :: Ident -> Ident -> Ident
$cmax :: Ident -> Ident -> Ident
>= :: Ident -> Ident -> Bool
$c>= :: Ident -> Ident -> Bool
> :: Ident -> Ident -> Bool
$c> :: Ident -> Ident -> Bool
<= :: Ident -> Ident -> Bool
$c<= :: Ident -> Ident -> Bool
< :: Ident -> Ident -> Bool
$c< :: Ident -> Ident -> Bool
compare :: Ident -> Ident -> Ordering
$ccompare :: Ident -> Ident -> Ordering
Ord, forall x. Rep Ident x -> Ident
forall x. Ident -> Rep Ident x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Ident x -> Ident
$cfrom :: forall x. Ident -> Rep Ident x
Generic)

data Name a = Name
  { forall a. Name a -> SourceToken
nameTok :: SourceToken
  , forall a. Name a -> a
nameValue :: a
  } deriving (Int -> Name a -> ShowS
forall a. Show a => Int -> Name a -> ShowS
forall a. Show a => [Name a] -> ShowS
forall a. Show a => Name a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name a] -> ShowS
$cshowList :: forall a. Show a => [Name a] -> ShowS
show :: Name a -> String
$cshow :: forall a. Show a => Name a -> String
showsPrec :: Int -> Name a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Name a -> ShowS
Show, Name a -> Name a -> Bool
forall a. Eq a => Name a -> Name a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name a -> Name a -> Bool
$c/= :: forall a. Eq a => Name a -> Name a -> Bool
== :: Name a -> Name a -> Bool
$c== :: forall a. Eq a => Name a -> Name a -> Bool
Eq, Name a -> Name a -> Bool
Name a -> Name a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Name a)
forall a. Ord a => Name a -> Name a -> Bool
forall a. Ord a => Name a -> Name a -> Ordering
forall a. Ord a => Name a -> Name a -> Name a
min :: Name a -> Name a -> Name a
$cmin :: forall a. Ord a => Name a -> Name a -> Name a
max :: Name a -> Name a -> Name a
$cmax :: forall a. Ord a => Name a -> Name a -> Name a
>= :: Name a -> Name a -> Bool
$c>= :: forall a. Ord a => Name a -> Name a -> Bool
> :: Name a -> Name a -> Bool
$c> :: forall a. Ord a => Name a -> Name a -> Bool
<= :: Name a -> Name a -> Bool
$c<= :: forall a. Ord a => Name a -> Name a -> Bool
< :: Name a -> Name a -> Bool
$c< :: forall a. Ord a => Name a -> Name a -> Bool
compare :: Name a -> Name a -> Ordering
$ccompare :: forall a. Ord a => Name a -> Name a -> Ordering
Ord, forall a b. a -> Name b -> Name a
forall a b. (a -> b) -> Name a -> Name b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Name b -> Name a
$c<$ :: forall a b. a -> Name b -> Name a
fmap :: forall a b. (a -> b) -> Name a -> Name b
$cfmap :: forall a b. (a -> b) -> Name a -> Name b
Functor, forall a. Eq a => a -> Name a -> Bool
forall a. Num a => Name a -> a
forall a. Ord a => Name a -> a
forall m. Monoid m => Name m -> m
forall a. Name a -> Bool
forall a. Name a -> Int
forall a. Name a -> [a]
forall a. (a -> a -> a) -> Name a -> a
forall m a. Monoid m => (a -> m) -> Name a -> m
forall b a. (b -> a -> b) -> b -> Name a -> b
forall a b. (a -> b -> b) -> b -> Name a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Name a -> a
$cproduct :: forall a. Num a => Name a -> a
sum :: forall a. Num a => Name a -> a
$csum :: forall a. Num a => Name a -> a
minimum :: forall a. Ord a => Name a -> a
$cminimum :: forall a. Ord a => Name a -> a
maximum :: forall a. Ord a => Name a -> a
$cmaximum :: forall a. Ord a => Name a -> a
elem :: forall a. Eq a => a -> Name a -> Bool
$celem :: forall a. Eq a => a -> Name a -> Bool
length :: forall a. Name a -> Int
$clength :: forall a. Name a -> Int
null :: forall a. Name a -> Bool
$cnull :: forall a. Name a -> Bool
toList :: forall a. Name a -> [a]
$ctoList :: forall a. Name a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Name a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Name a -> a
foldr1 :: forall a. (a -> a -> a) -> Name a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Name a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Name a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Name a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Name a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Name a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Name a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Name a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Name a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Name a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Name a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Name a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Name a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Name a -> m
fold :: forall m. Monoid m => Name m -> m
$cfold :: forall m. Monoid m => Name m -> m
Foldable, Functor Name
Foldable Name
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 => Name (m a) -> m (Name a)
forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Name a -> m (Name b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Name a -> f (Name b)
sequence :: forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
$csequence :: forall (m :: * -> *) a. Monad m => Name (m a) -> m (Name a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Name a -> m (Name b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Name a -> m (Name b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Name (f a) -> f (Name a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Name a -> f (Name b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Name a -> f (Name b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Name a) x -> Name a
forall a x. Name a -> Rep (Name a) x
$cto :: forall a x. Rep (Name a) x -> Name a
$cfrom :: forall a x. Name a -> Rep (Name a) x
Generic)

data QualifiedName a = QualifiedName
  { forall a. QualifiedName a -> SourceToken
qualTok :: SourceToken
  , forall a. QualifiedName a -> Maybe ModuleName
qualModule :: Maybe N.ModuleName
  , forall a. QualifiedName a -> a
qualName :: a
  } deriving (Int -> QualifiedName a -> ShowS
forall a. Show a => Int -> QualifiedName a -> ShowS
forall a. Show a => [QualifiedName a] -> ShowS
forall a. Show a => QualifiedName a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QualifiedName a] -> ShowS
$cshowList :: forall a. Show a => [QualifiedName a] -> ShowS
show :: QualifiedName a -> String
$cshow :: forall a. Show a => QualifiedName a -> String
showsPrec :: Int -> QualifiedName a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> QualifiedName a -> ShowS
Show, QualifiedName a -> QualifiedName a -> Bool
forall a. Eq a => QualifiedName a -> QualifiedName a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QualifiedName a -> QualifiedName a -> Bool
$c/= :: forall a. Eq a => QualifiedName a -> QualifiedName a -> Bool
== :: QualifiedName a -> QualifiedName a -> Bool
$c== :: forall a. Eq a => QualifiedName a -> QualifiedName a -> Bool
Eq, QualifiedName a -> QualifiedName a -> Bool
QualifiedName a -> QualifiedName a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (QualifiedName a)
forall a. Ord a => QualifiedName a -> QualifiedName a -> Bool
forall a. Ord a => QualifiedName a -> QualifiedName a -> Ordering
forall a.
Ord a =>
QualifiedName a -> QualifiedName a -> QualifiedName a
min :: QualifiedName a -> QualifiedName a -> QualifiedName a
$cmin :: forall a.
Ord a =>
QualifiedName a -> QualifiedName a -> QualifiedName a
max :: QualifiedName a -> QualifiedName a -> QualifiedName a
$cmax :: forall a.
Ord a =>
QualifiedName a -> QualifiedName a -> QualifiedName a
>= :: QualifiedName a -> QualifiedName a -> Bool
$c>= :: forall a. Ord a => QualifiedName a -> QualifiedName a -> Bool
> :: QualifiedName a -> QualifiedName a -> Bool
$c> :: forall a. Ord a => QualifiedName a -> QualifiedName a -> Bool
<= :: QualifiedName a -> QualifiedName a -> Bool
$c<= :: forall a. Ord a => QualifiedName a -> QualifiedName a -> Bool
< :: QualifiedName a -> QualifiedName a -> Bool
$c< :: forall a. Ord a => QualifiedName a -> QualifiedName a -> Bool
compare :: QualifiedName a -> QualifiedName a -> Ordering
$ccompare :: forall a. Ord a => QualifiedName a -> QualifiedName a -> Ordering
Ord, forall a b. a -> QualifiedName b -> QualifiedName a
forall a b. (a -> b) -> QualifiedName a -> QualifiedName b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> QualifiedName b -> QualifiedName a
$c<$ :: forall a b. a -> QualifiedName b -> QualifiedName a
fmap :: forall a b. (a -> b) -> QualifiedName a -> QualifiedName b
$cfmap :: forall a b. (a -> b) -> QualifiedName a -> QualifiedName b
Functor, forall a. Eq a => a -> QualifiedName a -> Bool
forall a. Num a => QualifiedName a -> a
forall a. Ord a => QualifiedName a -> a
forall m. Monoid m => QualifiedName m -> m
forall a. QualifiedName a -> Bool
forall a. QualifiedName a -> Int
forall a. QualifiedName a -> [a]
forall a. (a -> a -> a) -> QualifiedName a -> a
forall m a. Monoid m => (a -> m) -> QualifiedName a -> m
forall b a. (b -> a -> b) -> b -> QualifiedName a -> b
forall a b. (a -> b -> b) -> b -> QualifiedName a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => QualifiedName a -> a
$cproduct :: forall a. Num a => QualifiedName a -> a
sum :: forall a. Num a => QualifiedName a -> a
$csum :: forall a. Num a => QualifiedName a -> a
minimum :: forall a. Ord a => QualifiedName a -> a
$cminimum :: forall a. Ord a => QualifiedName a -> a
maximum :: forall a. Ord a => QualifiedName a -> a
$cmaximum :: forall a. Ord a => QualifiedName a -> a
elem :: forall a. Eq a => a -> QualifiedName a -> Bool
$celem :: forall a. Eq a => a -> QualifiedName a -> Bool
length :: forall a. QualifiedName a -> Int
$clength :: forall a. QualifiedName a -> Int
null :: forall a. QualifiedName a -> Bool
$cnull :: forall a. QualifiedName a -> Bool
toList :: forall a. QualifiedName a -> [a]
$ctoList :: forall a. QualifiedName a -> [a]
foldl1 :: forall a. (a -> a -> a) -> QualifiedName a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> QualifiedName a -> a
foldr1 :: forall a. (a -> a -> a) -> QualifiedName a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> QualifiedName a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> QualifiedName a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> QualifiedName a -> b
foldl :: forall b a. (b -> a -> b) -> b -> QualifiedName a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> QualifiedName a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> QualifiedName a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> QualifiedName a -> b
foldr :: forall a b. (a -> b -> b) -> b -> QualifiedName a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> QualifiedName a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> QualifiedName a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> QualifiedName a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> QualifiedName a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> QualifiedName a -> m
fold :: forall m. Monoid m => QualifiedName m -> m
$cfold :: forall m. Monoid m => QualifiedName m -> m
Foldable, Functor QualifiedName
Foldable QualifiedName
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 =>
QualifiedName (m a) -> m (QualifiedName a)
forall (f :: * -> *) a.
Applicative f =>
QualifiedName (f a) -> f (QualifiedName a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualifiedName a -> m (QualifiedName b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualifiedName a -> f (QualifiedName b)
sequence :: forall (m :: * -> *) a.
Monad m =>
QualifiedName (m a) -> m (QualifiedName a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
QualifiedName (m a) -> m (QualifiedName a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualifiedName a -> m (QualifiedName b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QualifiedName a -> m (QualifiedName b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
QualifiedName (f a) -> f (QualifiedName a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
QualifiedName (f a) -> f (QualifiedName a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualifiedName a -> f (QualifiedName b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QualifiedName a -> f (QualifiedName b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (QualifiedName a) x -> QualifiedName a
forall a x. QualifiedName a -> Rep (QualifiedName a) x
$cto :: forall a x. Rep (QualifiedName a) x -> QualifiedName a
$cfrom :: forall a x. QualifiedName a -> Rep (QualifiedName a) x
Generic)

data Label = Label
  { Label -> SourceToken
lblTok :: SourceToken
  , Label -> PSString
lblName :: PSString
  } deriving (Int -> Label -> ShowS
[Label] -> ShowS
Label -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Label] -> ShowS
$cshowList :: [Label] -> ShowS
show :: Label -> String
$cshow :: Label -> String
showsPrec :: Int -> Label -> ShowS
$cshowsPrec :: Int -> Label -> ShowS
Show, Label -> Label -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Label -> Label -> Bool
$c/= :: Label -> Label -> Bool
== :: Label -> Label -> Bool
$c== :: Label -> Label -> Bool
Eq, Eq Label
Label -> Label -> Bool
Label -> Label -> Ordering
Label -> Label -> Label
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 :: Label -> Label -> Label
$cmin :: Label -> Label -> Label
max :: Label -> Label -> Label
$cmax :: Label -> Label -> Label
>= :: Label -> Label -> Bool
$c>= :: Label -> Label -> Bool
> :: Label -> Label -> Bool
$c> :: Label -> Label -> Bool
<= :: Label -> Label -> Bool
$c<= :: Label -> Label -> Bool
< :: Label -> Label -> Bool
$c< :: Label -> Label -> Bool
compare :: Label -> Label -> Ordering
$ccompare :: Label -> Label -> Ordering
Ord, forall x. Rep Label x -> Label
forall x. Label -> Rep Label x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Label x -> Label
$cfrom :: forall x. Label -> Rep Label x
Generic)

data Wrapped a = Wrapped
  { forall a. Wrapped a -> SourceToken
wrpOpen :: SourceToken
  , forall a. Wrapped a -> a
wrpValue :: a
  , forall a. Wrapped a -> SourceToken
wrpClose :: SourceToken
  } deriving (Int -> Wrapped a -> ShowS
forall a. Show a => Int -> Wrapped a -> ShowS
forall a. Show a => [Wrapped a] -> ShowS
forall a. Show a => Wrapped a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Wrapped a] -> ShowS
$cshowList :: forall a. Show a => [Wrapped a] -> ShowS
show :: Wrapped a -> String
$cshow :: forall a. Show a => Wrapped a -> String
showsPrec :: Int -> Wrapped a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Wrapped a -> ShowS
Show, Wrapped a -> Wrapped a -> Bool
forall a. Eq a => Wrapped a -> Wrapped a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Wrapped a -> Wrapped a -> Bool
$c/= :: forall a. Eq a => Wrapped a -> Wrapped a -> Bool
== :: Wrapped a -> Wrapped a -> Bool
$c== :: forall a. Eq a => Wrapped a -> Wrapped a -> Bool
Eq, Wrapped a -> Wrapped a -> Bool
Wrapped a -> Wrapped a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Wrapped a)
forall a. Ord a => Wrapped a -> Wrapped a -> Bool
forall a. Ord a => Wrapped a -> Wrapped a -> Ordering
forall a. Ord a => Wrapped a -> Wrapped a -> Wrapped a
min :: Wrapped a -> Wrapped a -> Wrapped a
$cmin :: forall a. Ord a => Wrapped a -> Wrapped a -> Wrapped a
max :: Wrapped a -> Wrapped a -> Wrapped a
$cmax :: forall a. Ord a => Wrapped a -> Wrapped a -> Wrapped a
>= :: Wrapped a -> Wrapped a -> Bool
$c>= :: forall a. Ord a => Wrapped a -> Wrapped a -> Bool
> :: Wrapped a -> Wrapped a -> Bool
$c> :: forall a. Ord a => Wrapped a -> Wrapped a -> Bool
<= :: Wrapped a -> Wrapped a -> Bool
$c<= :: forall a. Ord a => Wrapped a -> Wrapped a -> Bool
< :: Wrapped a -> Wrapped a -> Bool
$c< :: forall a. Ord a => Wrapped a -> Wrapped a -> Bool
compare :: Wrapped a -> Wrapped a -> Ordering
$ccompare :: forall a. Ord a => Wrapped a -> Wrapped a -> Ordering
Ord, forall a b. a -> Wrapped b -> Wrapped a
forall a b. (a -> b) -> Wrapped a -> Wrapped b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Wrapped b -> Wrapped a
$c<$ :: forall a b. a -> Wrapped b -> Wrapped a
fmap :: forall a b. (a -> b) -> Wrapped a -> Wrapped b
$cfmap :: forall a b. (a -> b) -> Wrapped a -> Wrapped b
Functor, forall a. Eq a => a -> Wrapped a -> Bool
forall a. Num a => Wrapped a -> a
forall a. Ord a => Wrapped a -> a
forall m. Monoid m => Wrapped m -> m
forall a. Wrapped a -> Bool
forall a. Wrapped a -> Int
forall a. Wrapped a -> [a]
forall a. (a -> a -> a) -> Wrapped a -> a
forall m a. Monoid m => (a -> m) -> Wrapped a -> m
forall b a. (b -> a -> b) -> b -> Wrapped a -> b
forall a b. (a -> b -> b) -> b -> Wrapped a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Wrapped a -> a
$cproduct :: forall a. Num a => Wrapped a -> a
sum :: forall a. Num a => Wrapped a -> a
$csum :: forall a. Num a => Wrapped a -> a
minimum :: forall a. Ord a => Wrapped a -> a
$cminimum :: forall a. Ord a => Wrapped a -> a
maximum :: forall a. Ord a => Wrapped a -> a
$cmaximum :: forall a. Ord a => Wrapped a -> a
elem :: forall a. Eq a => a -> Wrapped a -> Bool
$celem :: forall a. Eq a => a -> Wrapped a -> Bool
length :: forall a. Wrapped a -> Int
$clength :: forall a. Wrapped a -> Int
null :: forall a. Wrapped a -> Bool
$cnull :: forall a. Wrapped a -> Bool
toList :: forall a. Wrapped a -> [a]
$ctoList :: forall a. Wrapped a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Wrapped a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Wrapped a -> a
foldr1 :: forall a. (a -> a -> a) -> Wrapped a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Wrapped a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Wrapped a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Wrapped a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Wrapped a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Wrapped a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Wrapped a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Wrapped a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Wrapped a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Wrapped a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Wrapped a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Wrapped a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Wrapped a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Wrapped a -> m
fold :: forall m. Monoid m => Wrapped m -> m
$cfold :: forall m. Monoid m => Wrapped m -> m
Foldable, Functor Wrapped
Foldable Wrapped
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 => Wrapped (m a) -> m (Wrapped a)
forall (f :: * -> *) a.
Applicative f =>
Wrapped (f a) -> f (Wrapped a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Wrapped a -> m (Wrapped b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Wrapped a -> f (Wrapped b)
sequence :: forall (m :: * -> *) a. Monad m => Wrapped (m a) -> m (Wrapped a)
$csequence :: forall (m :: * -> *) a. Monad m => Wrapped (m a) -> m (Wrapped a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Wrapped a -> m (Wrapped b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Wrapped a -> m (Wrapped b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Wrapped (f a) -> f (Wrapped a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Wrapped (f a) -> f (Wrapped a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Wrapped a -> f (Wrapped b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Wrapped a -> f (Wrapped b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Wrapped a) x -> Wrapped a
forall a x. Wrapped a -> Rep (Wrapped a) x
$cto :: forall a x. Rep (Wrapped a) x -> Wrapped a
$cfrom :: forall a x. Wrapped a -> Rep (Wrapped a) x
Generic)

data Separated a = Separated
  { forall a. Separated a -> a
sepHead :: a
  , forall a. Separated a -> [(SourceToken, a)]
sepTail :: [(SourceToken, a)]
  } deriving (Int -> Separated a -> ShowS
forall a. Show a => Int -> Separated a -> ShowS
forall a. Show a => [Separated a] -> ShowS
forall a. Show a => Separated a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Separated a] -> ShowS
$cshowList :: forall a. Show a => [Separated a] -> ShowS
show :: Separated a -> String
$cshow :: forall a. Show a => Separated a -> String
showsPrec :: Int -> Separated a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Separated a -> ShowS
Show, Separated a -> Separated a -> Bool
forall a. Eq a => Separated a -> Separated a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Separated a -> Separated a -> Bool
$c/= :: forall a. Eq a => Separated a -> Separated a -> Bool
== :: Separated a -> Separated a -> Bool
$c== :: forall a. Eq a => Separated a -> Separated a -> Bool
Eq, Separated a -> Separated a -> Bool
Separated a -> Separated a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Separated a)
forall a. Ord a => Separated a -> Separated a -> Bool
forall a. Ord a => Separated a -> Separated a -> Ordering
forall a. Ord a => Separated a -> Separated a -> Separated a
min :: Separated a -> Separated a -> Separated a
$cmin :: forall a. Ord a => Separated a -> Separated a -> Separated a
max :: Separated a -> Separated a -> Separated a
$cmax :: forall a. Ord a => Separated a -> Separated a -> Separated a
>= :: Separated a -> Separated a -> Bool
$c>= :: forall a. Ord a => Separated a -> Separated a -> Bool
> :: Separated a -> Separated a -> Bool
$c> :: forall a. Ord a => Separated a -> Separated a -> Bool
<= :: Separated a -> Separated a -> Bool
$c<= :: forall a. Ord a => Separated a -> Separated a -> Bool
< :: Separated a -> Separated a -> Bool
$c< :: forall a. Ord a => Separated a -> Separated a -> Bool
compare :: Separated a -> Separated a -> Ordering
$ccompare :: forall a. Ord a => Separated a -> Separated a -> Ordering
Ord, forall a b. a -> Separated b -> Separated a
forall a b. (a -> b) -> Separated a -> Separated b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Separated b -> Separated a
$c<$ :: forall a b. a -> Separated b -> Separated a
fmap :: forall a b. (a -> b) -> Separated a -> Separated b
$cfmap :: forall a b. (a -> b) -> Separated a -> Separated b
Functor, forall a. Eq a => a -> Separated a -> Bool
forall a. Num a => Separated a -> a
forall a. Ord a => Separated a -> a
forall m. Monoid m => Separated m -> m
forall a. Separated a -> Bool
forall a. Separated a -> Int
forall a. Separated a -> [a]
forall a. (a -> a -> a) -> Separated a -> a
forall m a. Monoid m => (a -> m) -> Separated a -> m
forall b a. (b -> a -> b) -> b -> Separated a -> b
forall a b. (a -> b -> b) -> b -> Separated a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Separated a -> a
$cproduct :: forall a. Num a => Separated a -> a
sum :: forall a. Num a => Separated a -> a
$csum :: forall a. Num a => Separated a -> a
minimum :: forall a. Ord a => Separated a -> a
$cminimum :: forall a. Ord a => Separated a -> a
maximum :: forall a. Ord a => Separated a -> a
$cmaximum :: forall a. Ord a => Separated a -> a
elem :: forall a. Eq a => a -> Separated a -> Bool
$celem :: forall a. Eq a => a -> Separated a -> Bool
length :: forall a. Separated a -> Int
$clength :: forall a. Separated a -> Int
null :: forall a. Separated a -> Bool
$cnull :: forall a. Separated a -> Bool
toList :: forall a. Separated a -> [a]
$ctoList :: forall a. Separated a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Separated a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Separated a -> a
foldr1 :: forall a. (a -> a -> a) -> Separated a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Separated a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Separated a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Separated a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Separated a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Separated a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Separated a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Separated a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Separated a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Separated a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Separated a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Separated a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Separated a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Separated a -> m
fold :: forall m. Monoid m => Separated m -> m
$cfold :: forall m. Monoid m => Separated m -> m
Foldable, Functor Separated
Foldable Separated
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 =>
Separated (m a) -> m (Separated a)
forall (f :: * -> *) a.
Applicative f =>
Separated (f a) -> f (Separated a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Separated a -> m (Separated b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Separated a -> f (Separated b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Separated (m a) -> m (Separated a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Separated (m a) -> m (Separated a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Separated a -> m (Separated b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Separated a -> m (Separated b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Separated (f a) -> f (Separated a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Separated (f a) -> f (Separated a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Separated a -> f (Separated b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Separated a -> f (Separated b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Separated a) x -> Separated a
forall a x. Separated a -> Rep (Separated a) x
$cto :: forall a x. Rep (Separated a) x -> Separated a
$cfrom :: forall a x. Separated a -> Rep (Separated a) x
Generic)

data Labeled a b = Labeled
  { forall a b. Labeled a b -> a
lblLabel :: a
  , forall a b. Labeled a b -> SourceToken
lblSep :: SourceToken
  , forall a b. Labeled a b -> b
lblValue  :: b
  } deriving (Int -> Labeled a b -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show a, Show b) => Int -> Labeled a b -> ShowS
forall a b. (Show a, Show b) => [Labeled a b] -> ShowS
forall a b. (Show a, Show b) => Labeled a b -> String
showList :: [Labeled a b] -> ShowS
$cshowList :: forall a b. (Show a, Show b) => [Labeled a b] -> ShowS
show :: Labeled a b -> String
$cshow :: forall a b. (Show a, Show b) => Labeled a b -> String
showsPrec :: Int -> Labeled a b -> ShowS
$cshowsPrec :: forall a b. (Show a, Show b) => Int -> Labeled a b -> ShowS
Show, Labeled a b -> Labeled a b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b. (Eq a, Eq b) => Labeled a b -> Labeled a b -> Bool
/= :: Labeled a b -> Labeled a b -> Bool
$c/= :: forall a b. (Eq a, Eq b) => Labeled a b -> Labeled a b -> Bool
== :: Labeled a b -> Labeled a b -> Bool
$c== :: forall a b. (Eq a, Eq b) => Labeled a b -> Labeled a b -> Bool
Eq, Labeled a b -> Labeled a b -> Bool
Labeled a b -> Labeled a b -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a} {b}. (Ord a, Ord b) => Eq (Labeled a b)
forall a b. (Ord a, Ord b) => Labeled a b -> Labeled a b -> Bool
forall a b.
(Ord a, Ord b) =>
Labeled a b -> Labeled a b -> Ordering
forall a b.
(Ord a, Ord b) =>
Labeled a b -> Labeled a b -> Labeled a b
min :: Labeled a b -> Labeled a b -> Labeled a b
$cmin :: forall a b.
(Ord a, Ord b) =>
Labeled a b -> Labeled a b -> Labeled a b
max :: Labeled a b -> Labeled a b -> Labeled a b
$cmax :: forall a b.
(Ord a, Ord b) =>
Labeled a b -> Labeled a b -> Labeled a b
>= :: Labeled a b -> Labeled a b -> Bool
$c>= :: forall a b. (Ord a, Ord b) => Labeled a b -> Labeled a b -> Bool
> :: Labeled a b -> Labeled a b -> Bool
$c> :: forall a b. (Ord a, Ord b) => Labeled a b -> Labeled a b -> Bool
<= :: Labeled a b -> Labeled a b -> Bool
$c<= :: forall a b. (Ord a, Ord b) => Labeled a b -> Labeled a b -> Bool
< :: Labeled a b -> Labeled a b -> Bool
$c< :: forall a b. (Ord a, Ord b) => Labeled a b -> Labeled a b -> Bool
compare :: Labeled a b -> Labeled a b -> Ordering
$ccompare :: forall a b.
(Ord a, Ord b) =>
Labeled a b -> Labeled a b -> Ordering
Ord, forall a b. a -> Labeled a b -> Labeled a a
forall a b. (a -> b) -> Labeled a a -> Labeled a b
forall a a b. a -> Labeled a b -> Labeled a a
forall a a b. (a -> b) -> Labeled a a -> Labeled a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Labeled a b -> Labeled a a
$c<$ :: forall a a b. a -> Labeled a b -> Labeled a a
fmap :: forall a b. (a -> b) -> Labeled a a -> Labeled a b
$cfmap :: forall a a b. (a -> b) -> Labeled a a -> Labeled a b
Functor, forall a. Labeled a a -> Bool
forall a a. Eq a => a -> Labeled a a -> Bool
forall a a. Num a => Labeled a a -> a
forall a a. Ord a => Labeled a a -> a
forall m a. Monoid m => (a -> m) -> Labeled a a -> m
forall a m. Monoid m => Labeled a m -> m
forall a a. Labeled a a -> Bool
forall a a. Labeled a a -> Int
forall a a. Labeled a a -> [a]
forall a b. (a -> b -> b) -> b -> Labeled a a -> b
forall a a. (a -> a -> a) -> Labeled a a -> a
forall a m a. Monoid m => (a -> m) -> Labeled a a -> m
forall a b a. (b -> a -> b) -> b -> Labeled a a -> b
forall a a b. (a -> b -> b) -> b -> Labeled a a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Labeled a a -> a
$cproduct :: forall a a. Num a => Labeled a a -> a
sum :: forall a. Num a => Labeled a a -> a
$csum :: forall a a. Num a => Labeled a a -> a
minimum :: forall a. Ord a => Labeled a a -> a
$cminimum :: forall a a. Ord a => Labeled a a -> a
maximum :: forall a. Ord a => Labeled a a -> a
$cmaximum :: forall a a. Ord a => Labeled a a -> a
elem :: forall a. Eq a => a -> Labeled a a -> Bool
$celem :: forall a a. Eq a => a -> Labeled a a -> Bool
length :: forall a. Labeled a a -> Int
$clength :: forall a a. Labeled a a -> Int
null :: forall a. Labeled a a -> Bool
$cnull :: forall a a. Labeled a a -> Bool
toList :: forall a. Labeled a a -> [a]
$ctoList :: forall a a. Labeled a a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Labeled a a -> a
$cfoldl1 :: forall a a. (a -> a -> a) -> Labeled a a -> a
foldr1 :: forall a. (a -> a -> a) -> Labeled a a -> a
$cfoldr1 :: forall a a. (a -> a -> a) -> Labeled a a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Labeled a a -> b
$cfoldl' :: forall a b a. (b -> a -> b) -> b -> Labeled a a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Labeled a a -> b
$cfoldl :: forall a b a. (b -> a -> b) -> b -> Labeled a a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Labeled a a -> b
$cfoldr' :: forall a a b. (a -> b -> b) -> b -> Labeled a a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Labeled a a -> b
$cfoldr :: forall a a b. (a -> b -> b) -> b -> Labeled a a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Labeled a a -> m
$cfoldMap' :: forall a m a. Monoid m => (a -> m) -> Labeled a a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Labeled a a -> m
$cfoldMap :: forall a m a. Monoid m => (a -> m) -> Labeled a a -> m
fold :: forall m. Monoid m => Labeled a m -> m
$cfold :: forall a m. Monoid m => Labeled a m -> m
Foldable, forall a. Functor (Labeled a)
forall a. Foldable (Labeled a)
forall a (m :: * -> *) a.
Monad m =>
Labeled a (m a) -> m (Labeled a a)
forall a (f :: * -> *) a.
Applicative f =>
Labeled a (f a) -> f (Labeled a a)
forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Labeled a a -> m (Labeled a b)
forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Labeled a a -> f (Labeled a 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 (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Labeled a a -> f (Labeled a b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Labeled a (m a) -> m (Labeled a a)
$csequence :: forall a (m :: * -> *) a.
Monad m =>
Labeled a (m a) -> m (Labeled a a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Labeled a a -> m (Labeled a b)
$cmapM :: forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Labeled a a -> m (Labeled a b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Labeled a (f a) -> f (Labeled a a)
$csequenceA :: forall a (f :: * -> *) a.
Applicative f =>
Labeled a (f a) -> f (Labeled a a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Labeled a a -> f (Labeled a b)
$ctraverse :: forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Labeled a a -> f (Labeled a b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a b x. Rep (Labeled a b) x -> Labeled a b
forall a b x. Labeled a b -> Rep (Labeled a b) x
$cto :: forall a b x. Rep (Labeled a b) x -> Labeled a b
$cfrom :: forall a b x. Labeled a b -> Rep (Labeled a b) x
Generic)

type Delimited a = Wrapped (Maybe (Separated a))
type DelimitedNonEmpty a = Wrapped (Separated a)

data OneOrDelimited a
  = One a
  | Many (DelimitedNonEmpty a)
  deriving (Int -> OneOrDelimited a -> ShowS
forall a. Show a => Int -> OneOrDelimited a -> ShowS
forall a. Show a => [OneOrDelimited a] -> ShowS
forall a. Show a => OneOrDelimited a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OneOrDelimited a] -> ShowS
$cshowList :: forall a. Show a => [OneOrDelimited a] -> ShowS
show :: OneOrDelimited a -> String
$cshow :: forall a. Show a => OneOrDelimited a -> String
showsPrec :: Int -> OneOrDelimited a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> OneOrDelimited a -> ShowS
Show, OneOrDelimited a -> OneOrDelimited a -> Bool
forall a. Eq a => OneOrDelimited a -> OneOrDelimited a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OneOrDelimited a -> OneOrDelimited a -> Bool
$c/= :: forall a. Eq a => OneOrDelimited a -> OneOrDelimited a -> Bool
== :: OneOrDelimited a -> OneOrDelimited a -> Bool
$c== :: forall a. Eq a => OneOrDelimited a -> OneOrDelimited a -> Bool
Eq, OneOrDelimited a -> OneOrDelimited a -> Bool
OneOrDelimited a -> OneOrDelimited a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (OneOrDelimited a)
forall a. Ord a => OneOrDelimited a -> OneOrDelimited a -> Bool
forall a. Ord a => OneOrDelimited a -> OneOrDelimited a -> Ordering
forall a.
Ord a =>
OneOrDelimited a -> OneOrDelimited a -> OneOrDelimited a
min :: OneOrDelimited a -> OneOrDelimited a -> OneOrDelimited a
$cmin :: forall a.
Ord a =>
OneOrDelimited a -> OneOrDelimited a -> OneOrDelimited a
max :: OneOrDelimited a -> OneOrDelimited a -> OneOrDelimited a
$cmax :: forall a.
Ord a =>
OneOrDelimited a -> OneOrDelimited a -> OneOrDelimited a
>= :: OneOrDelimited a -> OneOrDelimited a -> Bool
$c>= :: forall a. Ord a => OneOrDelimited a -> OneOrDelimited a -> Bool
> :: OneOrDelimited a -> OneOrDelimited a -> Bool
$c> :: forall a. Ord a => OneOrDelimited a -> OneOrDelimited a -> Bool
<= :: OneOrDelimited a -> OneOrDelimited a -> Bool
$c<= :: forall a. Ord a => OneOrDelimited a -> OneOrDelimited a -> Bool
< :: OneOrDelimited a -> OneOrDelimited a -> Bool
$c< :: forall a. Ord a => OneOrDelimited a -> OneOrDelimited a -> Bool
compare :: OneOrDelimited a -> OneOrDelimited a -> Ordering
$ccompare :: forall a. Ord a => OneOrDelimited a -> OneOrDelimited a -> Ordering
Ord, forall a b. a -> OneOrDelimited b -> OneOrDelimited a
forall a b. (a -> b) -> OneOrDelimited a -> OneOrDelimited b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> OneOrDelimited b -> OneOrDelimited a
$c<$ :: forall a b. a -> OneOrDelimited b -> OneOrDelimited a
fmap :: forall a b. (a -> b) -> OneOrDelimited a -> OneOrDelimited b
$cfmap :: forall a b. (a -> b) -> OneOrDelimited a -> OneOrDelimited b
Functor, forall a. Eq a => a -> OneOrDelimited a -> Bool
forall a. Num a => OneOrDelimited a -> a
forall a. Ord a => OneOrDelimited a -> a
forall m. Monoid m => OneOrDelimited m -> m
forall a. OneOrDelimited a -> Bool
forall a. OneOrDelimited a -> Int
forall a. OneOrDelimited a -> [a]
forall a. (a -> a -> a) -> OneOrDelimited a -> a
forall m a. Monoid m => (a -> m) -> OneOrDelimited a -> m
forall b a. (b -> a -> b) -> b -> OneOrDelimited a -> b
forall a b. (a -> b -> b) -> b -> OneOrDelimited a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => OneOrDelimited a -> a
$cproduct :: forall a. Num a => OneOrDelimited a -> a
sum :: forall a. Num a => OneOrDelimited a -> a
$csum :: forall a. Num a => OneOrDelimited a -> a
minimum :: forall a. Ord a => OneOrDelimited a -> a
$cminimum :: forall a. Ord a => OneOrDelimited a -> a
maximum :: forall a. Ord a => OneOrDelimited a -> a
$cmaximum :: forall a. Ord a => OneOrDelimited a -> a
elem :: forall a. Eq a => a -> OneOrDelimited a -> Bool
$celem :: forall a. Eq a => a -> OneOrDelimited a -> Bool
length :: forall a. OneOrDelimited a -> Int
$clength :: forall a. OneOrDelimited a -> Int
null :: forall a. OneOrDelimited a -> Bool
$cnull :: forall a. OneOrDelimited a -> Bool
toList :: forall a. OneOrDelimited a -> [a]
$ctoList :: forall a. OneOrDelimited a -> [a]
foldl1 :: forall a. (a -> a -> a) -> OneOrDelimited a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> OneOrDelimited a -> a
foldr1 :: forall a. (a -> a -> a) -> OneOrDelimited a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> OneOrDelimited a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> OneOrDelimited a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> OneOrDelimited a -> b
foldl :: forall b a. (b -> a -> b) -> b -> OneOrDelimited a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> OneOrDelimited a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> OneOrDelimited a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> OneOrDelimited a -> b
foldr :: forall a b. (a -> b -> b) -> b -> OneOrDelimited a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> OneOrDelimited a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> OneOrDelimited a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> OneOrDelimited a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> OneOrDelimited a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> OneOrDelimited a -> m
fold :: forall m. Monoid m => OneOrDelimited m -> m
$cfold :: forall m. Monoid m => OneOrDelimited m -> m
Foldable, Functor OneOrDelimited
Foldable OneOrDelimited
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 =>
OneOrDelimited (m a) -> m (OneOrDelimited a)
forall (f :: * -> *) a.
Applicative f =>
OneOrDelimited (f a) -> f (OneOrDelimited a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OneOrDelimited a -> m (OneOrDelimited b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OneOrDelimited a -> f (OneOrDelimited b)
sequence :: forall (m :: * -> *) a.
Monad m =>
OneOrDelimited (m a) -> m (OneOrDelimited a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
OneOrDelimited (m a) -> m (OneOrDelimited a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OneOrDelimited a -> m (OneOrDelimited b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OneOrDelimited a -> m (OneOrDelimited b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
OneOrDelimited (f a) -> f (OneOrDelimited a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
OneOrDelimited (f a) -> f (OneOrDelimited a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OneOrDelimited a -> f (OneOrDelimited b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OneOrDelimited a -> f (OneOrDelimited b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (OneOrDelimited a) x -> OneOrDelimited a
forall a x. OneOrDelimited a -> Rep (OneOrDelimited a) x
$cto :: forall a x. Rep (OneOrDelimited a) x -> OneOrDelimited a
$cfrom :: forall a x. OneOrDelimited a -> Rep (OneOrDelimited a) x
Generic)

data Type a
  = TypeVar a (Name Ident)
  | TypeConstructor a (QualifiedName (N.ProperName 'N.TypeName))
  | TypeWildcard a SourceToken
  | TypeHole a (Name Ident)
  | TypeString a SourceToken PSString
  | TypeInt a (Maybe SourceToken) SourceToken Integer
  | TypeRow a (Wrapped (Row a))
  | TypeRecord a (Wrapped (Row a))
  | TypeForall a SourceToken (NonEmpty (TypeVarBinding a)) SourceToken (Type a)
  | TypeKinded a (Type a) SourceToken (Type a)
  | TypeApp a (Type a) (Type a)
  | TypeOp a (Type a) (QualifiedName (N.OpName 'N.TypeOpName)) (Type a)
  | TypeOpName a (QualifiedName (N.OpName 'N.TypeOpName))
  | TypeArr a (Type a) SourceToken (Type a)
  | TypeArrName a SourceToken
  | TypeConstrained a (Constraint a) SourceToken (Type a)
  | TypeParens a (Wrapped (Type a))
  | TypeUnaryRow a SourceToken (Type a)
  deriving (Int -> Type a -> ShowS
forall a. Show a => Int -> Type a -> ShowS
forall a. Show a => [Type a] -> ShowS
forall a. Show a => Type a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Type a] -> ShowS
$cshowList :: forall a. Show a => [Type a] -> ShowS
show :: Type a -> String
$cshow :: forall a. Show a => Type a -> String
showsPrec :: Int -> Type a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Type a -> ShowS
Show, Type a -> Type a -> Bool
forall a. Eq a => Type a -> Type a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type a -> Type a -> Bool
$c/= :: forall a. Eq a => Type a -> Type a -> Bool
== :: Type a -> Type a -> Bool
$c== :: forall a. Eq a => Type a -> Type a -> Bool
Eq, Type a -> Type a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Type a)
forall a. Ord a => Type a -> Type a -> Bool
forall a. Ord a => Type a -> Type a -> Ordering
forall a. Ord a => Type a -> Type a -> Type a
min :: Type a -> Type a -> Type a
$cmin :: forall a. Ord a => Type a -> Type a -> Type a
max :: Type a -> Type a -> Type a
$cmax :: forall a. Ord a => Type a -> Type a -> Type a
>= :: Type a -> Type a -> Bool
$c>= :: forall a. Ord a => Type a -> Type a -> Bool
> :: Type a -> Type a -> Bool
$c> :: forall a. Ord a => Type a -> Type a -> Bool
<= :: Type a -> Type a -> Bool
$c<= :: forall a. Ord a => Type a -> Type a -> Bool
< :: Type a -> Type a -> Bool
$c< :: forall a. Ord a => Type a -> Type a -> Bool
compare :: Type a -> Type a -> Ordering
$ccompare :: forall a. Ord a => Type a -> Type a -> Ordering
Ord, forall a b. a -> Type b -> Type a
forall a b. (a -> b) -> Type a -> Type b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Type b -> Type a
$c<$ :: forall a b. a -> Type b -> Type a
fmap :: forall a b. (a -> b) -> Type a -> Type b
$cfmap :: forall a b. (a -> b) -> Type a -> Type b
Functor, forall a. Eq a => a -> Type a -> Bool
forall a. Num a => Type a -> a
forall a. Ord a => Type a -> a
forall m. Monoid m => Type m -> m
forall a. Type a -> Bool
forall a. Type a -> Int
forall a. Type a -> [a]
forall a. (a -> a -> a) -> Type a -> a
forall m a. Monoid m => (a -> m) -> Type a -> m
forall b a. (b -> a -> b) -> b -> Type a -> b
forall a b. (a -> b -> b) -> b -> Type a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Type a -> a
$cproduct :: forall a. Num a => Type a -> a
sum :: forall a. Num a => Type a -> a
$csum :: forall a. Num a => Type a -> a
minimum :: forall a. Ord a => Type a -> a
$cminimum :: forall a. Ord a => Type a -> a
maximum :: forall a. Ord a => Type a -> a
$cmaximum :: forall a. Ord a => Type a -> a
elem :: forall a. Eq a => a -> Type a -> Bool
$celem :: forall a. Eq a => a -> Type a -> Bool
length :: forall a. Type a -> Int
$clength :: forall a. Type a -> Int
null :: forall a. Type a -> Bool
$cnull :: forall a. Type a -> Bool
toList :: forall a. Type a -> [a]
$ctoList :: forall a. Type a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Type a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Type a -> a
foldr1 :: forall a. (a -> a -> a) -> Type a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Type a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Type a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Type a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Type a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Type a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Type a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Type a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Type a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Type a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Type a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Type a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Type a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Type a -> m
fold :: forall m. Monoid m => Type m -> m
$cfold :: forall m. Monoid m => Type m -> m
Foldable, Functor Type
Foldable Type
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 => Type (m a) -> m (Type a)
forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Type a -> m (Type b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Type a -> f (Type b)
sequence :: forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
$csequence :: forall (m :: * -> *) a. Monad m => Type (m a) -> m (Type a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Type a -> m (Type b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Type a -> m (Type b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Type (f a) -> f (Type a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Type a -> f (Type b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Type a -> f (Type b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Type a) x -> Type a
forall a x. Type a -> Rep (Type a) x
$cto :: forall a x. Rep (Type a) x -> Type a
$cfrom :: forall a x. Type a -> Rep (Type a) x
Generic)

data TypeVarBinding a
  = TypeVarKinded (Wrapped (Labeled (Maybe SourceToken, Name Ident) (Type a)))
  | TypeVarName (Maybe SourceToken, Name Ident)
  deriving (Int -> TypeVarBinding a -> ShowS
forall a. Show a => Int -> TypeVarBinding a -> ShowS
forall a. Show a => [TypeVarBinding a] -> ShowS
forall a. Show a => TypeVarBinding a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeVarBinding a] -> ShowS
$cshowList :: forall a. Show a => [TypeVarBinding a] -> ShowS
show :: TypeVarBinding a -> String
$cshow :: forall a. Show a => TypeVarBinding a -> String
showsPrec :: Int -> TypeVarBinding a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> TypeVarBinding a -> ShowS
Show, TypeVarBinding a -> TypeVarBinding a -> Bool
forall a. Eq a => TypeVarBinding a -> TypeVarBinding a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeVarBinding a -> TypeVarBinding a -> Bool
$c/= :: forall a. Eq a => TypeVarBinding a -> TypeVarBinding a -> Bool
== :: TypeVarBinding a -> TypeVarBinding a -> Bool
$c== :: forall a. Eq a => TypeVarBinding a -> TypeVarBinding a -> Bool
Eq, TypeVarBinding a -> TypeVarBinding a -> Bool
TypeVarBinding a -> TypeVarBinding a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (TypeVarBinding a)
forall a. Ord a => TypeVarBinding a -> TypeVarBinding a -> Bool
forall a. Ord a => TypeVarBinding a -> TypeVarBinding a -> Ordering
forall a.
Ord a =>
TypeVarBinding a -> TypeVarBinding a -> TypeVarBinding a
min :: TypeVarBinding a -> TypeVarBinding a -> TypeVarBinding a
$cmin :: forall a.
Ord a =>
TypeVarBinding a -> TypeVarBinding a -> TypeVarBinding a
max :: TypeVarBinding a -> TypeVarBinding a -> TypeVarBinding a
$cmax :: forall a.
Ord a =>
TypeVarBinding a -> TypeVarBinding a -> TypeVarBinding a
>= :: TypeVarBinding a -> TypeVarBinding a -> Bool
$c>= :: forall a. Ord a => TypeVarBinding a -> TypeVarBinding a -> Bool
> :: TypeVarBinding a -> TypeVarBinding a -> Bool
$c> :: forall a. Ord a => TypeVarBinding a -> TypeVarBinding a -> Bool
<= :: TypeVarBinding a -> TypeVarBinding a -> Bool
$c<= :: forall a. Ord a => TypeVarBinding a -> TypeVarBinding a -> Bool
< :: TypeVarBinding a -> TypeVarBinding a -> Bool
$c< :: forall a. Ord a => TypeVarBinding a -> TypeVarBinding a -> Bool
compare :: TypeVarBinding a -> TypeVarBinding a -> Ordering
$ccompare :: forall a. Ord a => TypeVarBinding a -> TypeVarBinding a -> Ordering
Ord, forall a b. a -> TypeVarBinding b -> TypeVarBinding a
forall a b. (a -> b) -> TypeVarBinding a -> TypeVarBinding b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> TypeVarBinding b -> TypeVarBinding a
$c<$ :: forall a b. a -> TypeVarBinding b -> TypeVarBinding a
fmap :: forall a b. (a -> b) -> TypeVarBinding a -> TypeVarBinding b
$cfmap :: forall a b. (a -> b) -> TypeVarBinding a -> TypeVarBinding b
Functor, forall a. Eq a => a -> TypeVarBinding a -> Bool
forall a. Num a => TypeVarBinding a -> a
forall a. Ord a => TypeVarBinding a -> a
forall m. Monoid m => TypeVarBinding m -> m
forall a. TypeVarBinding a -> Bool
forall a. TypeVarBinding a -> Int
forall a. TypeVarBinding a -> [a]
forall a. (a -> a -> a) -> TypeVarBinding a -> a
forall m a. Monoid m => (a -> m) -> TypeVarBinding a -> m
forall b a. (b -> a -> b) -> b -> TypeVarBinding a -> b
forall a b. (a -> b -> b) -> b -> TypeVarBinding a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => TypeVarBinding a -> a
$cproduct :: forall a. Num a => TypeVarBinding a -> a
sum :: forall a. Num a => TypeVarBinding a -> a
$csum :: forall a. Num a => TypeVarBinding a -> a
minimum :: forall a. Ord a => TypeVarBinding a -> a
$cminimum :: forall a. Ord a => TypeVarBinding a -> a
maximum :: forall a. Ord a => TypeVarBinding a -> a
$cmaximum :: forall a. Ord a => TypeVarBinding a -> a
elem :: forall a. Eq a => a -> TypeVarBinding a -> Bool
$celem :: forall a. Eq a => a -> TypeVarBinding a -> Bool
length :: forall a. TypeVarBinding a -> Int
$clength :: forall a. TypeVarBinding a -> Int
null :: forall a. TypeVarBinding a -> Bool
$cnull :: forall a. TypeVarBinding a -> Bool
toList :: forall a. TypeVarBinding a -> [a]
$ctoList :: forall a. TypeVarBinding a -> [a]
foldl1 :: forall a. (a -> a -> a) -> TypeVarBinding a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> TypeVarBinding a -> a
foldr1 :: forall a. (a -> a -> a) -> TypeVarBinding a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> TypeVarBinding a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> TypeVarBinding a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> TypeVarBinding a -> b
foldl :: forall b a. (b -> a -> b) -> b -> TypeVarBinding a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> TypeVarBinding a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> TypeVarBinding a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> TypeVarBinding a -> b
foldr :: forall a b. (a -> b -> b) -> b -> TypeVarBinding a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> TypeVarBinding a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> TypeVarBinding a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> TypeVarBinding a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> TypeVarBinding a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> TypeVarBinding a -> m
fold :: forall m. Monoid m => TypeVarBinding m -> m
$cfold :: forall m. Monoid m => TypeVarBinding m -> m
Foldable, Functor TypeVarBinding
Foldable TypeVarBinding
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 =>
TypeVarBinding (m a) -> m (TypeVarBinding a)
forall (f :: * -> *) a.
Applicative f =>
TypeVarBinding (f a) -> f (TypeVarBinding a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeVarBinding a -> m (TypeVarBinding b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeVarBinding a -> f (TypeVarBinding b)
sequence :: forall (m :: * -> *) a.
Monad m =>
TypeVarBinding (m a) -> m (TypeVarBinding a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
TypeVarBinding (m a) -> m (TypeVarBinding a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeVarBinding a -> m (TypeVarBinding b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TypeVarBinding a -> m (TypeVarBinding b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TypeVarBinding (f a) -> f (TypeVarBinding a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
TypeVarBinding (f a) -> f (TypeVarBinding a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeVarBinding a -> f (TypeVarBinding b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TypeVarBinding a -> f (TypeVarBinding b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (TypeVarBinding a) x -> TypeVarBinding a
forall a x. TypeVarBinding a -> Rep (TypeVarBinding a) x
$cto :: forall a x. Rep (TypeVarBinding a) x -> TypeVarBinding a
$cfrom :: forall a x. TypeVarBinding a -> Rep (TypeVarBinding a) x
Generic)

data Constraint a
  = Constraint a (QualifiedName (N.ProperName 'N.ClassName)) [Type a]
  | ConstraintParens a (Wrapped (Constraint a))
  deriving (Int -> Constraint a -> ShowS
forall a. Show a => Int -> Constraint a -> ShowS
forall a. Show a => [Constraint a] -> ShowS
forall a. Show a => Constraint a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Constraint a] -> ShowS
$cshowList :: forall a. Show a => [Constraint a] -> ShowS
show :: Constraint a -> String
$cshow :: forall a. Show a => Constraint a -> String
showsPrec :: Int -> Constraint a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Constraint a -> ShowS
Show, Constraint a -> Constraint a -> Bool
forall a. Eq a => Constraint a -> Constraint a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Constraint a -> Constraint a -> Bool
$c/= :: forall a. Eq a => Constraint a -> Constraint a -> Bool
== :: Constraint a -> Constraint a -> Bool
$c== :: forall a. Eq a => Constraint a -> Constraint a -> Bool
Eq, Constraint a -> Constraint a -> Bool
Constraint a -> Constraint a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Constraint a)
forall a. Ord a => Constraint a -> Constraint a -> Bool
forall a. Ord a => Constraint a -> Constraint a -> Ordering
forall a. Ord a => Constraint a -> Constraint a -> Constraint a
min :: Constraint a -> Constraint a -> Constraint a
$cmin :: forall a. Ord a => Constraint a -> Constraint a -> Constraint a
max :: Constraint a -> Constraint a -> Constraint a
$cmax :: forall a. Ord a => Constraint a -> Constraint a -> Constraint a
>= :: Constraint a -> Constraint a -> Bool
$c>= :: forall a. Ord a => Constraint a -> Constraint a -> Bool
> :: Constraint a -> Constraint a -> Bool
$c> :: forall a. Ord a => Constraint a -> Constraint a -> Bool
<= :: Constraint a -> Constraint a -> Bool
$c<= :: forall a. Ord a => Constraint a -> Constraint a -> Bool
< :: Constraint a -> Constraint a -> Bool
$c< :: forall a. Ord a => Constraint a -> Constraint a -> Bool
compare :: Constraint a -> Constraint a -> Ordering
$ccompare :: forall a. Ord a => Constraint a -> Constraint a -> Ordering
Ord, forall a b. a -> Constraint b -> Constraint a
forall a b. (a -> b) -> Constraint a -> Constraint b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Constraint b -> Constraint a
$c<$ :: forall a b. a -> Constraint b -> Constraint a
fmap :: forall a b. (a -> b) -> Constraint a -> Constraint b
$cfmap :: forall a b. (a -> b) -> Constraint a -> Constraint b
Functor, forall a. Eq a => a -> Constraint a -> Bool
forall a. Num a => Constraint a -> a
forall a. Ord a => Constraint a -> a
forall m. Monoid m => Constraint m -> m
forall a. Constraint a -> Bool
forall a. Constraint a -> Int
forall a. Constraint a -> [a]
forall a. (a -> a -> a) -> Constraint a -> a
forall m a. Monoid m => (a -> m) -> Constraint a -> m
forall b a. (b -> a -> b) -> b -> Constraint a -> b
forall a b. (a -> b -> b) -> b -> Constraint a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Constraint a -> a
$cproduct :: forall a. Num a => Constraint a -> a
sum :: forall a. Num a => Constraint a -> a
$csum :: forall a. Num a => Constraint a -> a
minimum :: forall a. Ord a => Constraint a -> a
$cminimum :: forall a. Ord a => Constraint a -> a
maximum :: forall a. Ord a => Constraint a -> a
$cmaximum :: forall a. Ord a => Constraint a -> a
elem :: forall a. Eq a => a -> Constraint a -> Bool
$celem :: forall a. Eq a => a -> Constraint a -> Bool
length :: forall a. Constraint a -> Int
$clength :: forall a. Constraint a -> Int
null :: forall a. Constraint a -> Bool
$cnull :: forall a. Constraint a -> Bool
toList :: forall a. Constraint a -> [a]
$ctoList :: forall a. Constraint a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Constraint a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Constraint a -> a
foldr1 :: forall a. (a -> a -> a) -> Constraint a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Constraint a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Constraint a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Constraint a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Constraint a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Constraint a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Constraint a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Constraint a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Constraint a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Constraint a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Constraint a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Constraint a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Constraint a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Constraint a -> m
fold :: forall m. Monoid m => Constraint m -> m
$cfold :: forall m. Monoid m => Constraint m -> m
Foldable, Functor Constraint
Foldable Constraint
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 =>
Constraint (m a) -> m (Constraint a)
forall (f :: * -> *) a.
Applicative f =>
Constraint (f a) -> f (Constraint a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Constraint a -> m (Constraint b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Constraint a -> f (Constraint b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Constraint (m a) -> m (Constraint a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Constraint (m a) -> m (Constraint a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Constraint a -> m (Constraint b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Constraint a -> m (Constraint b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Constraint (f a) -> f (Constraint a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Constraint (f a) -> f (Constraint a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Constraint a -> f (Constraint b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Constraint a -> f (Constraint b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Constraint a) x -> Constraint a
forall a x. Constraint a -> Rep (Constraint a) x
$cto :: forall a x. Rep (Constraint a) x -> Constraint a
$cfrom :: forall a x. Constraint a -> Rep (Constraint a) x
Generic)

data Row a = Row
  { forall a. Row a -> Maybe (Separated (Labeled Label (Type a)))
rowLabels :: Maybe (Separated (Labeled Label (Type a)))
  , forall a. Row a -> Maybe (SourceToken, Type a)
rowTail :: Maybe (SourceToken, Type a)
  } deriving (Int -> Row a -> ShowS
forall a. Show a => Int -> Row a -> ShowS
forall a. Show a => [Row a] -> ShowS
forall a. Show a => Row a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Row a] -> ShowS
$cshowList :: forall a. Show a => [Row a] -> ShowS
show :: Row a -> String
$cshow :: forall a. Show a => Row a -> String
showsPrec :: Int -> Row a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Row a -> ShowS
Show, Row a -> Row a -> Bool
forall a. Eq a => Row a -> Row a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Row a -> Row a -> Bool
$c/= :: forall a. Eq a => Row a -> Row a -> Bool
== :: Row a -> Row a -> Bool
$c== :: forall a. Eq a => Row a -> Row a -> Bool
Eq, Row a -> Row a -> Bool
Row a -> Row a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Row a)
forall a. Ord a => Row a -> Row a -> Bool
forall a. Ord a => Row a -> Row a -> Ordering
forall a. Ord a => Row a -> Row a -> Row a
min :: Row a -> Row a -> Row a
$cmin :: forall a. Ord a => Row a -> Row a -> Row a
max :: Row a -> Row a -> Row a
$cmax :: forall a. Ord a => Row a -> Row a -> Row a
>= :: Row a -> Row a -> Bool
$c>= :: forall a. Ord a => Row a -> Row a -> Bool
> :: Row a -> Row a -> Bool
$c> :: forall a. Ord a => Row a -> Row a -> Bool
<= :: Row a -> Row a -> Bool
$c<= :: forall a. Ord a => Row a -> Row a -> Bool
< :: Row a -> Row a -> Bool
$c< :: forall a. Ord a => Row a -> Row a -> Bool
compare :: Row a -> Row a -> Ordering
$ccompare :: forall a. Ord a => Row a -> Row a -> Ordering
Ord, forall a b. a -> Row b -> Row a
forall a b. (a -> b) -> Row a -> Row b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Row b -> Row a
$c<$ :: forall a b. a -> Row b -> Row a
fmap :: forall a b. (a -> b) -> Row a -> Row b
$cfmap :: forall a b. (a -> b) -> Row a -> Row b
Functor, forall a. Eq a => a -> Row a -> Bool
forall a. Num a => Row a -> a
forall a. Ord a => Row a -> a
forall m. Monoid m => Row m -> m
forall a. Row a -> Bool
forall a. Row a -> Int
forall a. Row a -> [a]
forall a. (a -> a -> a) -> Row a -> a
forall m a. Monoid m => (a -> m) -> Row a -> m
forall b a. (b -> a -> b) -> b -> Row a -> b
forall a b. (a -> b -> b) -> b -> Row a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Row a -> a
$cproduct :: forall a. Num a => Row a -> a
sum :: forall a. Num a => Row a -> a
$csum :: forall a. Num a => Row a -> a
minimum :: forall a. Ord a => Row a -> a
$cminimum :: forall a. Ord a => Row a -> a
maximum :: forall a. Ord a => Row a -> a
$cmaximum :: forall a. Ord a => Row a -> a
elem :: forall a. Eq a => a -> Row a -> Bool
$celem :: forall a. Eq a => a -> Row a -> Bool
length :: forall a. Row a -> Int
$clength :: forall a. Row a -> Int
null :: forall a. Row a -> Bool
$cnull :: forall a. Row a -> Bool
toList :: forall a. Row a -> [a]
$ctoList :: forall a. Row a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Row a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Row a -> a
foldr1 :: forall a. (a -> a -> a) -> Row a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Row a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Row a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Row a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Row a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Row a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Row a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Row a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Row a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Row a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Row a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Row a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Row a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Row a -> m
fold :: forall m. Monoid m => Row m -> m
$cfold :: forall m. Monoid m => Row m -> m
Foldable, Functor Row
Foldable Row
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 => Row (m a) -> m (Row a)
forall (f :: * -> *) a. Applicative f => Row (f a) -> f (Row a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Row a -> m (Row b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Row a -> f (Row b)
sequence :: forall (m :: * -> *) a. Monad m => Row (m a) -> m (Row a)
$csequence :: forall (m :: * -> *) a. Monad m => Row (m a) -> m (Row a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Row a -> m (Row b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Row a -> m (Row b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Row (f a) -> f (Row a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Row (f a) -> f (Row a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Row a -> f (Row b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Row a -> f (Row b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Row a) x -> Row a
forall a x. Row a -> Rep (Row a) x
$cto :: forall a x. Rep (Row a) x -> Row a
$cfrom :: forall a x. Row a -> Rep (Row a) x
Generic)

data Module a = Module
  { forall a. Module a -> a
modAnn :: a
  , forall a. Module a -> SourceToken
modKeyword :: SourceToken
  , forall a. Module a -> Name ModuleName
modNamespace :: Name N.ModuleName
  , forall a. Module a -> Maybe (DelimitedNonEmpty (Export a))
modExports :: Maybe (DelimitedNonEmpty (Export a))
  , forall a. Module a -> SourceToken
modWhere :: SourceToken
  , forall a. Module a -> [ImportDecl a]
modImports :: [ImportDecl a]
  , forall a. Module a -> [Declaration a]
modDecls :: [Declaration a]
  , forall a. Module a -> [Comment LineFeed]
modTrailingComments :: [Comment LineFeed]
  } deriving (Int -> Module a -> ShowS
forall a. Show a => Int -> Module a -> ShowS
forall a. Show a => [Module a] -> ShowS
forall a. Show a => Module a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Module a] -> ShowS
$cshowList :: forall a. Show a => [Module a] -> ShowS
show :: Module a -> String
$cshow :: forall a. Show a => Module a -> String
showsPrec :: Int -> Module a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Module a -> ShowS
Show, Module a -> Module a -> Bool
forall a. Eq a => Module a -> Module a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Module a -> Module a -> Bool
$c/= :: forall a. Eq a => Module a -> Module a -> Bool
== :: Module a -> Module a -> Bool
$c== :: forall a. Eq a => Module a -> Module a -> Bool
Eq, Module a -> Module a -> Bool
Module a -> Module a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Module a)
forall a. Ord a => Module a -> Module a -> Bool
forall a. Ord a => Module a -> Module a -> Ordering
forall a. Ord a => Module a -> Module a -> Module a
min :: Module a -> Module a -> Module a
$cmin :: forall a. Ord a => Module a -> Module a -> Module a
max :: Module a -> Module a -> Module a
$cmax :: forall a. Ord a => Module a -> Module a -> Module a
>= :: Module a -> Module a -> Bool
$c>= :: forall a. Ord a => Module a -> Module a -> Bool
> :: Module a -> Module a -> Bool
$c> :: forall a. Ord a => Module a -> Module a -> Bool
<= :: Module a -> Module a -> Bool
$c<= :: forall a. Ord a => Module a -> Module a -> Bool
< :: Module a -> Module a -> Bool
$c< :: forall a. Ord a => Module a -> Module a -> Bool
compare :: Module a -> Module a -> Ordering
$ccompare :: forall a. Ord a => Module a -> Module a -> Ordering
Ord, forall a b. a -> Module b -> Module a
forall a b. (a -> b) -> Module a -> Module b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Module b -> Module a
$c<$ :: forall a b. a -> Module b -> Module a
fmap :: forall a b. (a -> b) -> Module a -> Module b
$cfmap :: forall a b. (a -> b) -> Module a -> Module b
Functor, forall a. Eq a => a -> Module a -> Bool
forall a. Num a => Module a -> a
forall a. Ord a => Module a -> a
forall m. Monoid m => Module m -> m
forall a. Module a -> Bool
forall a. Module a -> Int
forall a. Module a -> [a]
forall a. (a -> a -> a) -> Module a -> a
forall m a. Monoid m => (a -> m) -> Module a -> m
forall b a. (b -> a -> b) -> b -> Module a -> b
forall a b. (a -> b -> b) -> b -> Module a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Module a -> a
$cproduct :: forall a. Num a => Module a -> a
sum :: forall a. Num a => Module a -> a
$csum :: forall a. Num a => Module a -> a
minimum :: forall a. Ord a => Module a -> a
$cminimum :: forall a. Ord a => Module a -> a
maximum :: forall a. Ord a => Module a -> a
$cmaximum :: forall a. Ord a => Module a -> a
elem :: forall a. Eq a => a -> Module a -> Bool
$celem :: forall a. Eq a => a -> Module a -> Bool
length :: forall a. Module a -> Int
$clength :: forall a. Module a -> Int
null :: forall a. Module a -> Bool
$cnull :: forall a. Module a -> Bool
toList :: forall a. Module a -> [a]
$ctoList :: forall a. Module a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Module a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Module a -> a
foldr1 :: forall a. (a -> a -> a) -> Module a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Module a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Module a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Module a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Module a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Module a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Module a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Module a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Module a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Module a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Module a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Module a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Module a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Module a -> m
fold :: forall m. Monoid m => Module m -> m
$cfold :: forall m. Monoid m => Module m -> m
Foldable, Functor Module
Foldable Module
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
forall (f :: * -> *) a.
Applicative f =>
Module (f a) -> f (Module a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module a -> m (Module b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module a -> f (Module b)
sequence :: forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
$csequence :: forall (m :: * -> *) a. Monad m => Module (m a) -> m (Module a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module a -> m (Module b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Module a -> m (Module b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Module (f a) -> f (Module a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Module (f a) -> f (Module a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module a -> f (Module b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Module a -> f (Module b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Module a) x -> Module a
forall a x. Module a -> Rep (Module a) x
$cto :: forall a x. Rep (Module a) x -> Module a
$cfrom :: forall a x. Module a -> Rep (Module a) x
Generic)

data Export a
  = ExportValue a (Name Ident)
  | ExportOp a (Name (N.OpName 'N.ValueOpName))
  | ExportType a (Name (N.ProperName 'N.TypeName)) (Maybe (DataMembers a))
  | ExportTypeOp a SourceToken (Name (N.OpName 'N.TypeOpName))
  | ExportClass a SourceToken (Name (N.ProperName 'N.ClassName))
  | ExportModule a SourceToken (Name N.ModuleName)
  deriving (Int -> Export a -> ShowS
forall a. Show a => Int -> Export a -> ShowS
forall a. Show a => [Export a] -> ShowS
forall a. Show a => Export a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Export a] -> ShowS
$cshowList :: forall a. Show a => [Export a] -> ShowS
show :: Export a -> String
$cshow :: forall a. Show a => Export a -> String
showsPrec :: Int -> Export a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Export a -> ShowS
Show, Export a -> Export a -> Bool
forall a. Eq a => Export a -> Export a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Export a -> Export a -> Bool
$c/= :: forall a. Eq a => Export a -> Export a -> Bool
== :: Export a -> Export a -> Bool
$c== :: forall a. Eq a => Export a -> Export a -> Bool
Eq, Export a -> Export a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Export a)
forall a. Ord a => Export a -> Export a -> Bool
forall a. Ord a => Export a -> Export a -> Ordering
forall a. Ord a => Export a -> Export a -> Export a
min :: Export a -> Export a -> Export a
$cmin :: forall a. Ord a => Export a -> Export a -> Export a
max :: Export a -> Export a -> Export a
$cmax :: forall a. Ord a => Export a -> Export a -> Export a
>= :: Export a -> Export a -> Bool
$c>= :: forall a. Ord a => Export a -> Export a -> Bool
> :: Export a -> Export a -> Bool
$c> :: forall a. Ord a => Export a -> Export a -> Bool
<= :: Export a -> Export a -> Bool
$c<= :: forall a. Ord a => Export a -> Export a -> Bool
< :: Export a -> Export a -> Bool
$c< :: forall a. Ord a => Export a -> Export a -> Bool
compare :: Export a -> Export a -> Ordering
$ccompare :: forall a. Ord a => Export a -> Export a -> Ordering
Ord, forall a b. a -> Export b -> Export a
forall a b. (a -> b) -> Export a -> Export b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Export b -> Export a
$c<$ :: forall a b. a -> Export b -> Export a
fmap :: forall a b. (a -> b) -> Export a -> Export b
$cfmap :: forall a b. (a -> b) -> Export a -> Export b
Functor, forall a. Eq a => a -> Export a -> Bool
forall a. Num a => Export a -> a
forall a. Ord a => Export a -> a
forall m. Monoid m => Export m -> m
forall a. Export a -> Bool
forall a. Export a -> Int
forall a. Export a -> [a]
forall a. (a -> a -> a) -> Export a -> a
forall m a. Monoid m => (a -> m) -> Export a -> m
forall b a. (b -> a -> b) -> b -> Export a -> b
forall a b. (a -> b -> b) -> b -> Export a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Export a -> a
$cproduct :: forall a. Num a => Export a -> a
sum :: forall a. Num a => Export a -> a
$csum :: forall a. Num a => Export a -> a
minimum :: forall a. Ord a => Export a -> a
$cminimum :: forall a. Ord a => Export a -> a
maximum :: forall a. Ord a => Export a -> a
$cmaximum :: forall a. Ord a => Export a -> a
elem :: forall a. Eq a => a -> Export a -> Bool
$celem :: forall a. Eq a => a -> Export a -> Bool
length :: forall a. Export a -> Int
$clength :: forall a. Export a -> Int
null :: forall a. Export a -> Bool
$cnull :: forall a. Export a -> Bool
toList :: forall a. Export a -> [a]
$ctoList :: forall a. Export a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Export a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Export a -> a
foldr1 :: forall a. (a -> a -> a) -> Export a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Export a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Export a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Export a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Export a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Export a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Export a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Export a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Export a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Export a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Export a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Export a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Export a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Export a -> m
fold :: forall m. Monoid m => Export m -> m
$cfold :: forall m. Monoid m => Export m -> m
Foldable, Functor Export
Foldable Export
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 => Export (m a) -> m (Export a)
forall (f :: * -> *) a.
Applicative f =>
Export (f a) -> f (Export a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Export a -> m (Export b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Export a -> f (Export b)
sequence :: forall (m :: * -> *) a. Monad m => Export (m a) -> m (Export a)
$csequence :: forall (m :: * -> *) a. Monad m => Export (m a) -> m (Export a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Export a -> m (Export b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Export a -> m (Export b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Export (f a) -> f (Export a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Export (f a) -> f (Export a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Export a -> f (Export b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Export a -> f (Export b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Export a) x -> Export a
forall a x. Export a -> Rep (Export a) x
$cto :: forall a x. Rep (Export a) x -> Export a
$cfrom :: forall a x. Export a -> Rep (Export a) x
Generic)

data DataMembers a
  = DataAll a SourceToken
  | DataEnumerated a (Delimited (Name (N.ProperName 'N.ConstructorName)))
  deriving (Int -> DataMembers a -> ShowS
forall a. Show a => Int -> DataMembers a -> ShowS
forall a. Show a => [DataMembers a] -> ShowS
forall a. Show a => DataMembers a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataMembers a] -> ShowS
$cshowList :: forall a. Show a => [DataMembers a] -> ShowS
show :: DataMembers a -> String
$cshow :: forall a. Show a => DataMembers a -> String
showsPrec :: Int -> DataMembers a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DataMembers a -> ShowS
Show, DataMembers a -> DataMembers a -> Bool
forall a. Eq a => DataMembers a -> DataMembers a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataMembers a -> DataMembers a -> Bool
$c/= :: forall a. Eq a => DataMembers a -> DataMembers a -> Bool
== :: DataMembers a -> DataMembers a -> Bool
$c== :: forall a. Eq a => DataMembers a -> DataMembers a -> Bool
Eq, DataMembers a -> DataMembers a -> Bool
DataMembers a -> DataMembers a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (DataMembers a)
forall a. Ord a => DataMembers a -> DataMembers a -> Bool
forall a. Ord a => DataMembers a -> DataMembers a -> Ordering
forall a. Ord a => DataMembers a -> DataMembers a -> DataMembers a
min :: DataMembers a -> DataMembers a -> DataMembers a
$cmin :: forall a. Ord a => DataMembers a -> DataMembers a -> DataMembers a
max :: DataMembers a -> DataMembers a -> DataMembers a
$cmax :: forall a. Ord a => DataMembers a -> DataMembers a -> DataMembers a
>= :: DataMembers a -> DataMembers a -> Bool
$c>= :: forall a. Ord a => DataMembers a -> DataMembers a -> Bool
> :: DataMembers a -> DataMembers a -> Bool
$c> :: forall a. Ord a => DataMembers a -> DataMembers a -> Bool
<= :: DataMembers a -> DataMembers a -> Bool
$c<= :: forall a. Ord a => DataMembers a -> DataMembers a -> Bool
< :: DataMembers a -> DataMembers a -> Bool
$c< :: forall a. Ord a => DataMembers a -> DataMembers a -> Bool
compare :: DataMembers a -> DataMembers a -> Ordering
$ccompare :: forall a. Ord a => DataMembers a -> DataMembers a -> Ordering
Ord, forall a b. a -> DataMembers b -> DataMembers a
forall a b. (a -> b) -> DataMembers a -> DataMembers b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> DataMembers b -> DataMembers a
$c<$ :: forall a b. a -> DataMembers b -> DataMembers a
fmap :: forall a b. (a -> b) -> DataMembers a -> DataMembers b
$cfmap :: forall a b. (a -> b) -> DataMembers a -> DataMembers b
Functor, forall a. Eq a => a -> DataMembers a -> Bool
forall a. Num a => DataMembers a -> a
forall a. Ord a => DataMembers a -> a
forall m. Monoid m => DataMembers m -> m
forall a. DataMembers a -> Bool
forall a. DataMembers a -> Int
forall a. DataMembers a -> [a]
forall a. (a -> a -> a) -> DataMembers a -> a
forall m a. Monoid m => (a -> m) -> DataMembers a -> m
forall b a. (b -> a -> b) -> b -> DataMembers a -> b
forall a b. (a -> b -> b) -> b -> DataMembers a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => DataMembers a -> a
$cproduct :: forall a. Num a => DataMembers a -> a
sum :: forall a. Num a => DataMembers a -> a
$csum :: forall a. Num a => DataMembers a -> a
minimum :: forall a. Ord a => DataMembers a -> a
$cminimum :: forall a. Ord a => DataMembers a -> a
maximum :: forall a. Ord a => DataMembers a -> a
$cmaximum :: forall a. Ord a => DataMembers a -> a
elem :: forall a. Eq a => a -> DataMembers a -> Bool
$celem :: forall a. Eq a => a -> DataMembers a -> Bool
length :: forall a. DataMembers a -> Int
$clength :: forall a. DataMembers a -> Int
null :: forall a. DataMembers a -> Bool
$cnull :: forall a. DataMembers a -> Bool
toList :: forall a. DataMembers a -> [a]
$ctoList :: forall a. DataMembers a -> [a]
foldl1 :: forall a. (a -> a -> a) -> DataMembers a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DataMembers a -> a
foldr1 :: forall a. (a -> a -> a) -> DataMembers a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> DataMembers a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> DataMembers a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DataMembers a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DataMembers a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DataMembers a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DataMembers a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DataMembers a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DataMembers a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> DataMembers a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> DataMembers a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DataMembers a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DataMembers a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DataMembers a -> m
fold :: forall m. Monoid m => DataMembers m -> m
$cfold :: forall m. Monoid m => DataMembers m -> m
Foldable, Functor DataMembers
Foldable DataMembers
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 =>
DataMembers (m a) -> m (DataMembers a)
forall (f :: * -> *) a.
Applicative f =>
DataMembers (f a) -> f (DataMembers a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataMembers a -> m (DataMembers b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataMembers a -> f (DataMembers b)
sequence :: forall (m :: * -> *) a.
Monad m =>
DataMembers (m a) -> m (DataMembers a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
DataMembers (m a) -> m (DataMembers a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataMembers a -> m (DataMembers b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataMembers a -> m (DataMembers b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataMembers (f a) -> f (DataMembers a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataMembers (f a) -> f (DataMembers a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataMembers a -> f (DataMembers b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataMembers a -> f (DataMembers b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DataMembers a) x -> DataMembers a
forall a x. DataMembers a -> Rep (DataMembers a) x
$cto :: forall a x. Rep (DataMembers a) x -> DataMembers a
$cfrom :: forall a x. DataMembers a -> Rep (DataMembers a) x
Generic)

data Declaration a
  = DeclData a (DataHead a) (Maybe (SourceToken, Separated (DataCtor a)))
  | DeclType a (DataHead a) SourceToken (Type a)
  | DeclNewtype a (DataHead a) SourceToken (Name (N.ProperName 'N.ConstructorName)) (Type a)
  | DeclClass a (ClassHead a) (Maybe (SourceToken, NonEmpty (Labeled (Name Ident) (Type a))))
  | DeclInstanceChain a (Separated (Instance a))
  | DeclDerive a SourceToken (Maybe SourceToken) (InstanceHead a)
  | DeclKindSignature a SourceToken (Labeled (Name (N.ProperName 'N.TypeName)) (Type a))
  | DeclSignature a (Labeled (Name Ident) (Type a))
  | DeclValue a (ValueBindingFields a)
  | DeclFixity a FixityFields
  | DeclForeign a SourceToken SourceToken (Foreign a)
  | DeclRole a SourceToken SourceToken (Name (N.ProperName 'N.TypeName)) (NonEmpty Role)
  deriving (Int -> Declaration a -> ShowS
forall a. Show a => Int -> Declaration a -> ShowS
forall a. Show a => [Declaration a] -> ShowS
forall a. Show a => Declaration a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Declaration a] -> ShowS
$cshowList :: forall a. Show a => [Declaration a] -> ShowS
show :: Declaration a -> String
$cshow :: forall a. Show a => Declaration a -> String
showsPrec :: Int -> Declaration a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Declaration a -> ShowS
Show, Declaration a -> Declaration a -> Bool
forall a. Eq a => Declaration a -> Declaration a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Declaration a -> Declaration a -> Bool
$c/= :: forall a. Eq a => Declaration a -> Declaration a -> Bool
== :: Declaration a -> Declaration a -> Bool
$c== :: forall a. Eq a => Declaration a -> Declaration a -> Bool
Eq, Declaration a -> Declaration a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Declaration a)
forall a. Ord a => Declaration a -> Declaration a -> Bool
forall a. Ord a => Declaration a -> Declaration a -> Ordering
forall a. Ord a => Declaration a -> Declaration a -> Declaration a
min :: Declaration a -> Declaration a -> Declaration a
$cmin :: forall a. Ord a => Declaration a -> Declaration a -> Declaration a
max :: Declaration a -> Declaration a -> Declaration a
$cmax :: forall a. Ord a => Declaration a -> Declaration a -> Declaration a
>= :: Declaration a -> Declaration a -> Bool
$c>= :: forall a. Ord a => Declaration a -> Declaration a -> Bool
> :: Declaration a -> Declaration a -> Bool
$c> :: forall a. Ord a => Declaration a -> Declaration a -> Bool
<= :: Declaration a -> Declaration a -> Bool
$c<= :: forall a. Ord a => Declaration a -> Declaration a -> Bool
< :: Declaration a -> Declaration a -> Bool
$c< :: forall a. Ord a => Declaration a -> Declaration a -> Bool
compare :: Declaration a -> Declaration a -> Ordering
$ccompare :: forall a. Ord a => Declaration a -> Declaration a -> Ordering
Ord, forall a b. a -> Declaration b -> Declaration a
forall a b. (a -> b) -> Declaration a -> Declaration b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Declaration b -> Declaration a
$c<$ :: forall a b. a -> Declaration b -> Declaration a
fmap :: forall a b. (a -> b) -> Declaration a -> Declaration b
$cfmap :: forall a b. (a -> b) -> Declaration a -> Declaration b
Functor, forall a. Eq a => a -> Declaration a -> Bool
forall a. Num a => Declaration a -> a
forall a. Ord a => Declaration a -> a
forall m. Monoid m => Declaration m -> m
forall a. Declaration a -> Bool
forall a. Declaration a -> Int
forall a. Declaration a -> [a]
forall a. (a -> a -> a) -> Declaration a -> a
forall m a. Monoid m => (a -> m) -> Declaration a -> m
forall b a. (b -> a -> b) -> b -> Declaration a -> b
forall a b. (a -> b -> b) -> b -> Declaration a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Declaration a -> a
$cproduct :: forall a. Num a => Declaration a -> a
sum :: forall a. Num a => Declaration a -> a
$csum :: forall a. Num a => Declaration a -> a
minimum :: forall a. Ord a => Declaration a -> a
$cminimum :: forall a. Ord a => Declaration a -> a
maximum :: forall a. Ord a => Declaration a -> a
$cmaximum :: forall a. Ord a => Declaration a -> a
elem :: forall a. Eq a => a -> Declaration a -> Bool
$celem :: forall a. Eq a => a -> Declaration a -> Bool
length :: forall a. Declaration a -> Int
$clength :: forall a. Declaration a -> Int
null :: forall a. Declaration a -> Bool
$cnull :: forall a. Declaration a -> Bool
toList :: forall a. Declaration a -> [a]
$ctoList :: forall a. Declaration a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Declaration a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Declaration a -> a
foldr1 :: forall a. (a -> a -> a) -> Declaration a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Declaration a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Declaration a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Declaration a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Declaration a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Declaration a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Declaration a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Declaration a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Declaration a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Declaration a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Declaration a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Declaration a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Declaration a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Declaration a -> m
fold :: forall m. Monoid m => Declaration m -> m
$cfold :: forall m. Monoid m => Declaration m -> m
Foldable, Functor Declaration
Foldable Declaration
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 =>
Declaration (m a) -> m (Declaration a)
forall (f :: * -> *) a.
Applicative f =>
Declaration (f a) -> f (Declaration a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Declaration a -> m (Declaration b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Declaration a -> f (Declaration b)
sequence :: forall (m :: * -> *) a.
Monad m =>
Declaration (m a) -> m (Declaration a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
Declaration (m a) -> m (Declaration a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Declaration a -> m (Declaration b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Declaration a -> m (Declaration b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Declaration (f a) -> f (Declaration a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Declaration (f a) -> f (Declaration a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Declaration a -> f (Declaration b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Declaration a -> f (Declaration b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Declaration a) x -> Declaration a
forall a x. Declaration a -> Rep (Declaration a) x
$cto :: forall a x. Rep (Declaration a) x -> Declaration a
$cfrom :: forall a x. Declaration a -> Rep (Declaration a) x
Generic)

data Instance a = Instance
  { forall a. Instance a -> InstanceHead a
instHead :: InstanceHead a
  , forall a.
Instance a -> Maybe (SourceToken, NonEmpty (InstanceBinding a))
instBody :: Maybe (SourceToken, NonEmpty (InstanceBinding a))
  } deriving (Int -> Instance a -> ShowS
forall a. Show a => Int -> Instance a -> ShowS
forall a. Show a => [Instance a] -> ShowS
forall a. Show a => Instance a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Instance a] -> ShowS
$cshowList :: forall a. Show a => [Instance a] -> ShowS
show :: Instance a -> String
$cshow :: forall a. Show a => Instance a -> String
showsPrec :: Int -> Instance a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Instance a -> ShowS
Show, Instance a -> Instance a -> Bool
forall a. Eq a => Instance a -> Instance a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Instance a -> Instance a -> Bool
$c/= :: forall a. Eq a => Instance a -> Instance a -> Bool
== :: Instance a -> Instance a -> Bool
$c== :: forall a. Eq a => Instance a -> Instance a -> Bool
Eq, Instance a -> Instance a -> Bool
Instance a -> Instance a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Instance a)
forall a. Ord a => Instance a -> Instance a -> Bool
forall a. Ord a => Instance a -> Instance a -> Ordering
forall a. Ord a => Instance a -> Instance a -> Instance a
min :: Instance a -> Instance a -> Instance a
$cmin :: forall a. Ord a => Instance a -> Instance a -> Instance a
max :: Instance a -> Instance a -> Instance a
$cmax :: forall a. Ord a => Instance a -> Instance a -> Instance a
>= :: Instance a -> Instance a -> Bool
$c>= :: forall a. Ord a => Instance a -> Instance a -> Bool
> :: Instance a -> Instance a -> Bool
$c> :: forall a. Ord a => Instance a -> Instance a -> Bool
<= :: Instance a -> Instance a -> Bool
$c<= :: forall a. Ord a => Instance a -> Instance a -> Bool
< :: Instance a -> Instance a -> Bool
$c< :: forall a. Ord a => Instance a -> Instance a -> Bool
compare :: Instance a -> Instance a -> Ordering
$ccompare :: forall a. Ord a => Instance a -> Instance a -> Ordering
Ord, forall a b. a -> Instance b -> Instance a
forall a b. (a -> b) -> Instance a -> Instance b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Instance b -> Instance a
$c<$ :: forall a b. a -> Instance b -> Instance a
fmap :: forall a b. (a -> b) -> Instance a -> Instance b
$cfmap :: forall a b. (a -> b) -> Instance a -> Instance b
Functor, forall a. Eq a => a -> Instance a -> Bool
forall a. Num a => Instance a -> a
forall a. Ord a => Instance a -> a
forall m. Monoid m => Instance m -> m
forall a. Instance a -> Bool
forall a. Instance a -> Int
forall a. Instance a -> [a]
forall a. (a -> a -> a) -> Instance a -> a
forall m a. Monoid m => (a -> m) -> Instance a -> m
forall b a. (b -> a -> b) -> b -> Instance a -> b
forall a b. (a -> b -> b) -> b -> Instance a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Instance a -> a
$cproduct :: forall a. Num a => Instance a -> a
sum :: forall a. Num a => Instance a -> a
$csum :: forall a. Num a => Instance a -> a
minimum :: forall a. Ord a => Instance a -> a
$cminimum :: forall a. Ord a => Instance a -> a
maximum :: forall a. Ord a => Instance a -> a
$cmaximum :: forall a. Ord a => Instance a -> a
elem :: forall a. Eq a => a -> Instance a -> Bool
$celem :: forall a. Eq a => a -> Instance a -> Bool
length :: forall a. Instance a -> Int
$clength :: forall a. Instance a -> Int
null :: forall a. Instance a -> Bool
$cnull :: forall a. Instance a -> Bool
toList :: forall a. Instance a -> [a]
$ctoList :: forall a. Instance a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Instance a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Instance a -> a
foldr1 :: forall a. (a -> a -> a) -> Instance a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Instance a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Instance a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Instance a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Instance a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Instance a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Instance a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Instance a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Instance a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Instance a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Instance a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Instance a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Instance a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Instance a -> m
fold :: forall m. Monoid m => Instance m -> m
$cfold :: forall m. Monoid m => Instance m -> m
Foldable, Functor Instance
Foldable Instance
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 => Instance (m a) -> m (Instance a)
forall (f :: * -> *) a.
Applicative f =>
Instance (f a) -> f (Instance a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Instance a -> m (Instance b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Instance a -> f (Instance b)
sequence :: forall (m :: * -> *) a. Monad m => Instance (m a) -> m (Instance a)
$csequence :: forall (m :: * -> *) a. Monad m => Instance (m a) -> m (Instance a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Instance a -> m (Instance b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Instance a -> m (Instance b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Instance (f a) -> f (Instance a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Instance (f a) -> f (Instance a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Instance a -> f (Instance b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Instance a -> f (Instance b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Instance a) x -> Instance a
forall a x. Instance a -> Rep (Instance a) x
$cto :: forall a x. Rep (Instance a) x -> Instance a
$cfrom :: forall a x. Instance a -> Rep (Instance a) x
Generic)

data InstanceBinding a
  = InstanceBindingSignature a (Labeled (Name Ident) (Type a))
  | InstanceBindingName a (ValueBindingFields a)
  deriving (Int -> InstanceBinding a -> ShowS
forall a. Show a => Int -> InstanceBinding a -> ShowS
forall a. Show a => [InstanceBinding a] -> ShowS
forall a. Show a => InstanceBinding a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InstanceBinding a] -> ShowS
$cshowList :: forall a. Show a => [InstanceBinding a] -> ShowS
show :: InstanceBinding a -> String
$cshow :: forall a. Show a => InstanceBinding a -> String
showsPrec :: Int -> InstanceBinding a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> InstanceBinding a -> ShowS
Show, InstanceBinding a -> InstanceBinding a -> Bool
forall a. Eq a => InstanceBinding a -> InstanceBinding a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InstanceBinding a -> InstanceBinding a -> Bool
$c/= :: forall a. Eq a => InstanceBinding a -> InstanceBinding a -> Bool
== :: InstanceBinding a -> InstanceBinding a -> Bool
$c== :: forall a. Eq a => InstanceBinding a -> InstanceBinding a -> Bool
Eq, InstanceBinding a -> InstanceBinding a -> Bool
InstanceBinding a -> InstanceBinding a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (InstanceBinding a)
forall a. Ord a => InstanceBinding a -> InstanceBinding a -> Bool
forall a.
Ord a =>
InstanceBinding a -> InstanceBinding a -> Ordering
forall a.
Ord a =>
InstanceBinding a -> InstanceBinding a -> InstanceBinding a
min :: InstanceBinding a -> InstanceBinding a -> InstanceBinding a
$cmin :: forall a.
Ord a =>
InstanceBinding a -> InstanceBinding a -> InstanceBinding a
max :: InstanceBinding a -> InstanceBinding a -> InstanceBinding a
$cmax :: forall a.
Ord a =>
InstanceBinding a -> InstanceBinding a -> InstanceBinding a
>= :: InstanceBinding a -> InstanceBinding a -> Bool
$c>= :: forall a. Ord a => InstanceBinding a -> InstanceBinding a -> Bool
> :: InstanceBinding a -> InstanceBinding a -> Bool
$c> :: forall a. Ord a => InstanceBinding a -> InstanceBinding a -> Bool
<= :: InstanceBinding a -> InstanceBinding a -> Bool
$c<= :: forall a. Ord a => InstanceBinding a -> InstanceBinding a -> Bool
< :: InstanceBinding a -> InstanceBinding a -> Bool
$c< :: forall a. Ord a => InstanceBinding a -> InstanceBinding a -> Bool
compare :: InstanceBinding a -> InstanceBinding a -> Ordering
$ccompare :: forall a.
Ord a =>
InstanceBinding a -> InstanceBinding a -> Ordering
Ord, forall a b. a -> InstanceBinding b -> InstanceBinding a
forall a b. (a -> b) -> InstanceBinding a -> InstanceBinding b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> InstanceBinding b -> InstanceBinding a
$c<$ :: forall a b. a -> InstanceBinding b -> InstanceBinding a
fmap :: forall a b. (a -> b) -> InstanceBinding a -> InstanceBinding b
$cfmap :: forall a b. (a -> b) -> InstanceBinding a -> InstanceBinding b
Functor, forall a. Eq a => a -> InstanceBinding a -> Bool
forall a. Num a => InstanceBinding a -> a
forall a. Ord a => InstanceBinding a -> a
forall m. Monoid m => InstanceBinding m -> m
forall a. InstanceBinding a -> Bool
forall a. InstanceBinding a -> Int
forall a. InstanceBinding a -> [a]
forall a. (a -> a -> a) -> InstanceBinding a -> a
forall m a. Monoid m => (a -> m) -> InstanceBinding a -> m
forall b a. (b -> a -> b) -> b -> InstanceBinding a -> b
forall a b. (a -> b -> b) -> b -> InstanceBinding a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => InstanceBinding a -> a
$cproduct :: forall a. Num a => InstanceBinding a -> a
sum :: forall a. Num a => InstanceBinding a -> a
$csum :: forall a. Num a => InstanceBinding a -> a
minimum :: forall a. Ord a => InstanceBinding a -> a
$cminimum :: forall a. Ord a => InstanceBinding a -> a
maximum :: forall a. Ord a => InstanceBinding a -> a
$cmaximum :: forall a. Ord a => InstanceBinding a -> a
elem :: forall a. Eq a => a -> InstanceBinding a -> Bool
$celem :: forall a. Eq a => a -> InstanceBinding a -> Bool
length :: forall a. InstanceBinding a -> Int
$clength :: forall a. InstanceBinding a -> Int
null :: forall a. InstanceBinding a -> Bool
$cnull :: forall a. InstanceBinding a -> Bool
toList :: forall a. InstanceBinding a -> [a]
$ctoList :: forall a. InstanceBinding a -> [a]
foldl1 :: forall a. (a -> a -> a) -> InstanceBinding a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InstanceBinding a -> a
foldr1 :: forall a. (a -> a -> a) -> InstanceBinding a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> InstanceBinding a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> InstanceBinding a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InstanceBinding a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InstanceBinding a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InstanceBinding a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InstanceBinding a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InstanceBinding a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InstanceBinding a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> InstanceBinding a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> InstanceBinding a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstanceBinding a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InstanceBinding a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InstanceBinding a -> m
fold :: forall m. Monoid m => InstanceBinding m -> m
$cfold :: forall m. Monoid m => InstanceBinding m -> m
Foldable, Functor InstanceBinding
Foldable InstanceBinding
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 =>
InstanceBinding (m a) -> m (InstanceBinding a)
forall (f :: * -> *) a.
Applicative f =>
InstanceBinding (f a) -> f (InstanceBinding a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstanceBinding a -> m (InstanceBinding b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstanceBinding a -> f (InstanceBinding b)
sequence :: forall (m :: * -> *) a.
Monad m =>
InstanceBinding (m a) -> m (InstanceBinding a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
InstanceBinding (m a) -> m (InstanceBinding a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstanceBinding a -> m (InstanceBinding b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstanceBinding a -> m (InstanceBinding b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstanceBinding (f a) -> f (InstanceBinding a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstanceBinding (f a) -> f (InstanceBinding a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstanceBinding a -> f (InstanceBinding b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstanceBinding a -> f (InstanceBinding b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (InstanceBinding a) x -> InstanceBinding a
forall a x. InstanceBinding a -> Rep (InstanceBinding a) x
$cto :: forall a x. Rep (InstanceBinding a) x -> InstanceBinding a
$cfrom :: forall a x. InstanceBinding a -> Rep (InstanceBinding a) x
Generic)

data ImportDecl a = ImportDecl
  { forall a. ImportDecl a -> a
impAnn :: a
  , forall a. ImportDecl a -> SourceToken
impKeyword :: SourceToken
  , forall a. ImportDecl a -> Name ModuleName
impModule :: Name N.ModuleName
  , forall a.
ImportDecl a
-> Maybe (Maybe SourceToken, DelimitedNonEmpty (Import a))
impNames :: Maybe (Maybe SourceToken, DelimitedNonEmpty (Import a))
  , forall a. ImportDecl a -> Maybe (SourceToken, Name ModuleName)
impQual :: Maybe (SourceToken, Name N.ModuleName)
  } deriving (Int -> ImportDecl a -> ShowS
forall a. Show a => Int -> ImportDecl a -> ShowS
forall a. Show a => [ImportDecl a] -> ShowS
forall a. Show a => ImportDecl a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportDecl a] -> ShowS
$cshowList :: forall a. Show a => [ImportDecl a] -> ShowS
show :: ImportDecl a -> String
$cshow :: forall a. Show a => ImportDecl a -> String
showsPrec :: Int -> ImportDecl a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ImportDecl a -> ShowS
Show, ImportDecl a -> ImportDecl a -> Bool
forall a. Eq a => ImportDecl a -> ImportDecl a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportDecl a -> ImportDecl a -> Bool
$c/= :: forall a. Eq a => ImportDecl a -> ImportDecl a -> Bool
== :: ImportDecl a -> ImportDecl a -> Bool
$c== :: forall a. Eq a => ImportDecl a -> ImportDecl a -> Bool
Eq, ImportDecl a -> ImportDecl a -> Bool
ImportDecl a -> ImportDecl a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (ImportDecl a)
forall a. Ord a => ImportDecl a -> ImportDecl a -> Bool
forall a. Ord a => ImportDecl a -> ImportDecl a -> Ordering
forall a. Ord a => ImportDecl a -> ImportDecl a -> ImportDecl a
min :: ImportDecl a -> ImportDecl a -> ImportDecl a
$cmin :: forall a. Ord a => ImportDecl a -> ImportDecl a -> ImportDecl a
max :: ImportDecl a -> ImportDecl a -> ImportDecl a
$cmax :: forall a. Ord a => ImportDecl a -> ImportDecl a -> ImportDecl a
>= :: ImportDecl a -> ImportDecl a -> Bool
$c>= :: forall a. Ord a => ImportDecl a -> ImportDecl a -> Bool
> :: ImportDecl a -> ImportDecl a -> Bool
$c> :: forall a. Ord a => ImportDecl a -> ImportDecl a -> Bool
<= :: ImportDecl a -> ImportDecl a -> Bool
$c<= :: forall a. Ord a => ImportDecl a -> ImportDecl a -> Bool
< :: ImportDecl a -> ImportDecl a -> Bool
$c< :: forall a. Ord a => ImportDecl a -> ImportDecl a -> Bool
compare :: ImportDecl a -> ImportDecl a -> Ordering
$ccompare :: forall a. Ord a => ImportDecl a -> ImportDecl a -> Ordering
Ord, forall a b. a -> ImportDecl b -> ImportDecl a
forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ImportDecl b -> ImportDecl a
$c<$ :: forall a b. a -> ImportDecl b -> ImportDecl a
fmap :: forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
$cfmap :: forall a b. (a -> b) -> ImportDecl a -> ImportDecl b
Functor, forall a. Eq a => a -> ImportDecl a -> Bool
forall a. Num a => ImportDecl a -> a
forall a. Ord a => ImportDecl a -> a
forall m. Monoid m => ImportDecl m -> m
forall a. ImportDecl a -> Bool
forall a. ImportDecl a -> Int
forall a. ImportDecl a -> [a]
forall a. (a -> a -> a) -> ImportDecl a -> a
forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ImportDecl a -> a
$cproduct :: forall a. Num a => ImportDecl a -> a
sum :: forall a. Num a => ImportDecl a -> a
$csum :: forall a. Num a => ImportDecl a -> a
minimum :: forall a. Ord a => ImportDecl a -> a
$cminimum :: forall a. Ord a => ImportDecl a -> a
maximum :: forall a. Ord a => ImportDecl a -> a
$cmaximum :: forall a. Ord a => ImportDecl a -> a
elem :: forall a. Eq a => a -> ImportDecl a -> Bool
$celem :: forall a. Eq a => a -> ImportDecl a -> Bool
length :: forall a. ImportDecl a -> Int
$clength :: forall a. ImportDecl a -> Int
null :: forall a. ImportDecl a -> Bool
$cnull :: forall a. ImportDecl a -> Bool
toList :: forall a. ImportDecl a -> [a]
$ctoList :: forall a. ImportDecl a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
foldr1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ImportDecl a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ImportDecl a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ImportDecl a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ImportDecl a -> m
fold :: forall m. Monoid m => ImportDecl m -> m
$cfold :: forall m. Monoid m => ImportDecl m -> m
Foldable, Functor ImportDecl
Foldable ImportDecl
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 =>
ImportDecl (m a) -> m (ImportDecl a)
forall (f :: * -> *) a.
Applicative f =>
ImportDecl (f a) -> f (ImportDecl a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportDecl a -> m (ImportDecl b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportDecl a -> f (ImportDecl b)
sequence :: forall (m :: * -> *) a.
Monad m =>
ImportDecl (m a) -> m (ImportDecl a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ImportDecl (m a) -> m (ImportDecl a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportDecl a -> m (ImportDecl b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ImportDecl a -> m (ImportDecl b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportDecl (f a) -> f (ImportDecl a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ImportDecl (f a) -> f (ImportDecl a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportDecl a -> f (ImportDecl b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ImportDecl a -> f (ImportDecl b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ImportDecl a) x -> ImportDecl a
forall a x. ImportDecl a -> Rep (ImportDecl a) x
$cto :: forall a x. Rep (ImportDecl a) x -> ImportDecl a
$cfrom :: forall a x. ImportDecl a -> Rep (ImportDecl a) x
Generic)

data Import a
  = ImportValue a (Name Ident)
  | ImportOp a (Name (N.OpName 'N.ValueOpName))
  | ImportType a (Name (N.ProperName 'N.TypeName)) (Maybe (DataMembers a))
  | ImportTypeOp a SourceToken (Name (N.OpName 'N.TypeOpName))
  | ImportClass a SourceToken (Name (N.ProperName 'N.ClassName))
  deriving (Int -> Import a -> ShowS
forall a. Show a => Int -> Import a -> ShowS
forall a. Show a => [Import a] -> ShowS
forall a. Show a => Import a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Import a] -> ShowS
$cshowList :: forall a. Show a => [Import a] -> ShowS
show :: Import a -> String
$cshow :: forall a. Show a => Import a -> String
showsPrec :: Int -> Import a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Import a -> ShowS
Show, Import a -> Import a -> Bool
forall a. Eq a => Import a -> Import a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Import a -> Import a -> Bool
$c/= :: forall a. Eq a => Import a -> Import a -> Bool
== :: Import a -> Import a -> Bool
$c== :: forall a. Eq a => Import a -> Import a -> Bool
Eq, Import a -> Import a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Import a)
forall a. Ord a => Import a -> Import a -> Bool
forall a. Ord a => Import a -> Import a -> Ordering
forall a. Ord a => Import a -> Import a -> Import a
min :: Import a -> Import a -> Import a
$cmin :: forall a. Ord a => Import a -> Import a -> Import a
max :: Import a -> Import a -> Import a
$cmax :: forall a. Ord a => Import a -> Import a -> Import a
>= :: Import a -> Import a -> Bool
$c>= :: forall a. Ord a => Import a -> Import a -> Bool
> :: Import a -> Import a -> Bool
$c> :: forall a. Ord a => Import a -> Import a -> Bool
<= :: Import a -> Import a -> Bool
$c<= :: forall a. Ord a => Import a -> Import a -> Bool
< :: Import a -> Import a -> Bool
$c< :: forall a. Ord a => Import a -> Import a -> Bool
compare :: Import a -> Import a -> Ordering
$ccompare :: forall a. Ord a => Import a -> Import a -> Ordering
Ord, forall a b. a -> Import b -> Import a
forall a b. (a -> b) -> Import a -> Import b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Import b -> Import a
$c<$ :: forall a b. a -> Import b -> Import a
fmap :: forall a b. (a -> b) -> Import a -> Import b
$cfmap :: forall a b. (a -> b) -> Import a -> Import b
Functor, forall a. Eq a => a -> Import a -> Bool
forall a. Num a => Import a -> a
forall a. Ord a => Import a -> a
forall m. Monoid m => Import m -> m
forall a. Import a -> Bool
forall a. Import a -> Int
forall a. Import a -> [a]
forall a. (a -> a -> a) -> Import a -> a
forall m a. Monoid m => (a -> m) -> Import a -> m
forall b a. (b -> a -> b) -> b -> Import a -> b
forall a b. (a -> b -> b) -> b -> Import a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Import a -> a
$cproduct :: forall a. Num a => Import a -> a
sum :: forall a. Num a => Import a -> a
$csum :: forall a. Num a => Import a -> a
minimum :: forall a. Ord a => Import a -> a
$cminimum :: forall a. Ord a => Import a -> a
maximum :: forall a. Ord a => Import a -> a
$cmaximum :: forall a. Ord a => Import a -> a
elem :: forall a. Eq a => a -> Import a -> Bool
$celem :: forall a. Eq a => a -> Import a -> Bool
length :: forall a. Import a -> Int
$clength :: forall a. Import a -> Int
null :: forall a. Import a -> Bool
$cnull :: forall a. Import a -> Bool
toList :: forall a. Import a -> [a]
$ctoList :: forall a. Import a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Import a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Import a -> a
foldr1 :: forall a. (a -> a -> a) -> Import a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Import a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Import a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Import a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Import a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Import a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Import a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Import a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Import a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Import a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Import a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Import a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Import a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Import a -> m
fold :: forall m. Monoid m => Import m -> m
$cfold :: forall m. Monoid m => Import m -> m
Foldable, Functor Import
Foldable Import
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 => Import (m a) -> m (Import a)
forall (f :: * -> *) a.
Applicative f =>
Import (f a) -> f (Import a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Import a -> m (Import b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Import a -> f (Import b)
sequence :: forall (m :: * -> *) a. Monad m => Import (m a) -> m (Import a)
$csequence :: forall (m :: * -> *) a. Monad m => Import (m a) -> m (Import a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Import a -> m (Import b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Import a -> m (Import b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Import (f a) -> f (Import a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Import (f a) -> f (Import a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Import a -> f (Import b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Import a -> f (Import b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Import a) x -> Import a
forall a x. Import a -> Rep (Import a) x
$cto :: forall a x. Rep (Import a) x -> Import a
$cfrom :: forall a x. Import a -> Rep (Import a) x
Generic)

data DataHead a = DataHead
  { forall a. DataHead a -> SourceToken
dataHdKeyword :: SourceToken
  , forall a. DataHead a -> Name (ProperName 'TypeName)
dataHdName :: Name (N.ProperName 'N.TypeName)
  , forall a. DataHead a -> [TypeVarBinding a]
dataHdVars :: [TypeVarBinding a]
  } deriving (Int -> DataHead a -> ShowS
forall a. Show a => Int -> DataHead a -> ShowS
forall a. Show a => [DataHead a] -> ShowS
forall a. Show a => DataHead a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataHead a] -> ShowS
$cshowList :: forall a. Show a => [DataHead a] -> ShowS
show :: DataHead a -> String
$cshow :: forall a. Show a => DataHead a -> String
showsPrec :: Int -> DataHead a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DataHead a -> ShowS
Show, DataHead a -> DataHead a -> Bool
forall a. Eq a => DataHead a -> DataHead a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataHead a -> DataHead a -> Bool
$c/= :: forall a. Eq a => DataHead a -> DataHead a -> Bool
== :: DataHead a -> DataHead a -> Bool
$c== :: forall a. Eq a => DataHead a -> DataHead a -> Bool
Eq, DataHead a -> DataHead a -> Bool
DataHead a -> DataHead a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (DataHead a)
forall a. Ord a => DataHead a -> DataHead a -> Bool
forall a. Ord a => DataHead a -> DataHead a -> Ordering
forall a. Ord a => DataHead a -> DataHead a -> DataHead a
min :: DataHead a -> DataHead a -> DataHead a
$cmin :: forall a. Ord a => DataHead a -> DataHead a -> DataHead a
max :: DataHead a -> DataHead a -> DataHead a
$cmax :: forall a. Ord a => DataHead a -> DataHead a -> DataHead a
>= :: DataHead a -> DataHead a -> Bool
$c>= :: forall a. Ord a => DataHead a -> DataHead a -> Bool
> :: DataHead a -> DataHead a -> Bool
$c> :: forall a. Ord a => DataHead a -> DataHead a -> Bool
<= :: DataHead a -> DataHead a -> Bool
$c<= :: forall a. Ord a => DataHead a -> DataHead a -> Bool
< :: DataHead a -> DataHead a -> Bool
$c< :: forall a. Ord a => DataHead a -> DataHead a -> Bool
compare :: DataHead a -> DataHead a -> Ordering
$ccompare :: forall a. Ord a => DataHead a -> DataHead a -> Ordering
Ord, forall a b. a -> DataHead b -> DataHead a
forall a b. (a -> b) -> DataHead a -> DataHead b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> DataHead b -> DataHead a
$c<$ :: forall a b. a -> DataHead b -> DataHead a
fmap :: forall a b. (a -> b) -> DataHead a -> DataHead b
$cfmap :: forall a b. (a -> b) -> DataHead a -> DataHead b
Functor, forall a. Eq a => a -> DataHead a -> Bool
forall a. Num a => DataHead a -> a
forall a. Ord a => DataHead a -> a
forall m. Monoid m => DataHead m -> m
forall a. DataHead a -> Bool
forall a. DataHead a -> Int
forall a. DataHead a -> [a]
forall a. (a -> a -> a) -> DataHead a -> a
forall m a. Monoid m => (a -> m) -> DataHead a -> m
forall b a. (b -> a -> b) -> b -> DataHead a -> b
forall a b. (a -> b -> b) -> b -> DataHead a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => DataHead a -> a
$cproduct :: forall a. Num a => DataHead a -> a
sum :: forall a. Num a => DataHead a -> a
$csum :: forall a. Num a => DataHead a -> a
minimum :: forall a. Ord a => DataHead a -> a
$cminimum :: forall a. Ord a => DataHead a -> a
maximum :: forall a. Ord a => DataHead a -> a
$cmaximum :: forall a. Ord a => DataHead a -> a
elem :: forall a. Eq a => a -> DataHead a -> Bool
$celem :: forall a. Eq a => a -> DataHead a -> Bool
length :: forall a. DataHead a -> Int
$clength :: forall a. DataHead a -> Int
null :: forall a. DataHead a -> Bool
$cnull :: forall a. DataHead a -> Bool
toList :: forall a. DataHead a -> [a]
$ctoList :: forall a. DataHead a -> [a]
foldl1 :: forall a. (a -> a -> a) -> DataHead a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DataHead a -> a
foldr1 :: forall a. (a -> a -> a) -> DataHead a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> DataHead a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> DataHead a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DataHead a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DataHead a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DataHead a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DataHead a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DataHead a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DataHead a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> DataHead a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> DataHead a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DataHead a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DataHead a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DataHead a -> m
fold :: forall m. Monoid m => DataHead m -> m
$cfold :: forall m. Monoid m => DataHead m -> m
Foldable, Functor DataHead
Foldable DataHead
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 => DataHead (m a) -> m (DataHead a)
forall (f :: * -> *) a.
Applicative f =>
DataHead (f a) -> f (DataHead a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataHead a -> m (DataHead b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataHead a -> f (DataHead b)
sequence :: forall (m :: * -> *) a. Monad m => DataHead (m a) -> m (DataHead a)
$csequence :: forall (m :: * -> *) a. Monad m => DataHead (m a) -> m (DataHead a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataHead a -> m (DataHead b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataHead a -> m (DataHead b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataHead (f a) -> f (DataHead a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataHead (f a) -> f (DataHead a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataHead a -> f (DataHead b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataHead a -> f (DataHead b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DataHead a) x -> DataHead a
forall a x. DataHead a -> Rep (DataHead a) x
$cto :: forall a x. Rep (DataHead a) x -> DataHead a
$cfrom :: forall a x. DataHead a -> Rep (DataHead a) x
Generic)

data DataCtor a = DataCtor
  { forall a. DataCtor a -> a
dataCtorAnn :: a
  , forall a. DataCtor a -> Name (ProperName 'ConstructorName)
dataCtorName :: Name (N.ProperName 'N.ConstructorName)
  , forall a. DataCtor a -> [Type a]
dataCtorFields :: [Type a]
  } deriving (Int -> DataCtor a -> ShowS
forall a. Show a => Int -> DataCtor a -> ShowS
forall a. Show a => [DataCtor a] -> ShowS
forall a. Show a => DataCtor a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DataCtor a] -> ShowS
$cshowList :: forall a. Show a => [DataCtor a] -> ShowS
show :: DataCtor a -> String
$cshow :: forall a. Show a => DataCtor a -> String
showsPrec :: Int -> DataCtor a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DataCtor a -> ShowS
Show, DataCtor a -> DataCtor a -> Bool
forall a. Eq a => DataCtor a -> DataCtor a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DataCtor a -> DataCtor a -> Bool
$c/= :: forall a. Eq a => DataCtor a -> DataCtor a -> Bool
== :: DataCtor a -> DataCtor a -> Bool
$c== :: forall a. Eq a => DataCtor a -> DataCtor a -> Bool
Eq, DataCtor a -> DataCtor a -> Bool
DataCtor a -> DataCtor a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (DataCtor a)
forall a. Ord a => DataCtor a -> DataCtor a -> Bool
forall a. Ord a => DataCtor a -> DataCtor a -> Ordering
forall a. Ord a => DataCtor a -> DataCtor a -> DataCtor a
min :: DataCtor a -> DataCtor a -> DataCtor a
$cmin :: forall a. Ord a => DataCtor a -> DataCtor a -> DataCtor a
max :: DataCtor a -> DataCtor a -> DataCtor a
$cmax :: forall a. Ord a => DataCtor a -> DataCtor a -> DataCtor a
>= :: DataCtor a -> DataCtor a -> Bool
$c>= :: forall a. Ord a => DataCtor a -> DataCtor a -> Bool
> :: DataCtor a -> DataCtor a -> Bool
$c> :: forall a. Ord a => DataCtor a -> DataCtor a -> Bool
<= :: DataCtor a -> DataCtor a -> Bool
$c<= :: forall a. Ord a => DataCtor a -> DataCtor a -> Bool
< :: DataCtor a -> DataCtor a -> Bool
$c< :: forall a. Ord a => DataCtor a -> DataCtor a -> Bool
compare :: DataCtor a -> DataCtor a -> Ordering
$ccompare :: forall a. Ord a => DataCtor a -> DataCtor a -> Ordering
Ord, forall a b. a -> DataCtor b -> DataCtor a
forall a b. (a -> b) -> DataCtor a -> DataCtor b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> DataCtor b -> DataCtor a
$c<$ :: forall a b. a -> DataCtor b -> DataCtor a
fmap :: forall a b. (a -> b) -> DataCtor a -> DataCtor b
$cfmap :: forall a b. (a -> b) -> DataCtor a -> DataCtor b
Functor, forall a. Eq a => a -> DataCtor a -> Bool
forall a. Num a => DataCtor a -> a
forall a. Ord a => DataCtor a -> a
forall m. Monoid m => DataCtor m -> m
forall a. DataCtor a -> Bool
forall a. DataCtor a -> Int
forall a. DataCtor a -> [a]
forall a. (a -> a -> a) -> DataCtor a -> a
forall m a. Monoid m => (a -> m) -> DataCtor a -> m
forall b a. (b -> a -> b) -> b -> DataCtor a -> b
forall a b. (a -> b -> b) -> b -> DataCtor a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => DataCtor a -> a
$cproduct :: forall a. Num a => DataCtor a -> a
sum :: forall a. Num a => DataCtor a -> a
$csum :: forall a. Num a => DataCtor a -> a
minimum :: forall a. Ord a => DataCtor a -> a
$cminimum :: forall a. Ord a => DataCtor a -> a
maximum :: forall a. Ord a => DataCtor a -> a
$cmaximum :: forall a. Ord a => DataCtor a -> a
elem :: forall a. Eq a => a -> DataCtor a -> Bool
$celem :: forall a. Eq a => a -> DataCtor a -> Bool
length :: forall a. DataCtor a -> Int
$clength :: forall a. DataCtor a -> Int
null :: forall a. DataCtor a -> Bool
$cnull :: forall a. DataCtor a -> Bool
toList :: forall a. DataCtor a -> [a]
$ctoList :: forall a. DataCtor a -> [a]
foldl1 :: forall a. (a -> a -> a) -> DataCtor a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DataCtor a -> a
foldr1 :: forall a. (a -> a -> a) -> DataCtor a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> DataCtor a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> DataCtor a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DataCtor a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DataCtor a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DataCtor a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DataCtor a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DataCtor a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DataCtor a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> DataCtor a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> DataCtor a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DataCtor a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DataCtor a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DataCtor a -> m
fold :: forall m. Monoid m => DataCtor m -> m
$cfold :: forall m. Monoid m => DataCtor m -> m
Foldable, Functor DataCtor
Foldable DataCtor
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 => DataCtor (m a) -> m (DataCtor a)
forall (f :: * -> *) a.
Applicative f =>
DataCtor (f a) -> f (DataCtor a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataCtor a -> m (DataCtor b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataCtor a -> f (DataCtor b)
sequence :: forall (m :: * -> *) a. Monad m => DataCtor (m a) -> m (DataCtor a)
$csequence :: forall (m :: * -> *) a. Monad m => DataCtor (m a) -> m (DataCtor a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataCtor a -> m (DataCtor b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DataCtor a -> m (DataCtor b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataCtor (f a) -> f (DataCtor a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DataCtor (f a) -> f (DataCtor a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataCtor a -> f (DataCtor b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DataCtor a -> f (DataCtor b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DataCtor a) x -> DataCtor a
forall a x. DataCtor a -> Rep (DataCtor a) x
$cto :: forall a x. Rep (DataCtor a) x -> DataCtor a
$cfrom :: forall a x. DataCtor a -> Rep (DataCtor a) x
Generic)

data ClassHead a = ClassHead
  { forall a. ClassHead a -> SourceToken
clsKeyword :: SourceToken
  , forall a.
ClassHead a -> Maybe (OneOrDelimited (Constraint a), SourceToken)
clsSuper :: Maybe (OneOrDelimited (Constraint a), SourceToken)
  , forall a. ClassHead a -> Name (ProperName 'ClassName)
clsName :: Name (N.ProperName 'N.ClassName)
  , forall a. ClassHead a -> [TypeVarBinding a]
clsVars :: [TypeVarBinding a]
  , forall a. ClassHead a -> Maybe (SourceToken, Separated ClassFundep)
clsFundeps :: Maybe (SourceToken, Separated ClassFundep)
  } deriving (Int -> ClassHead a -> ShowS
forall a. Show a => Int -> ClassHead a -> ShowS
forall a. Show a => [ClassHead a] -> ShowS
forall a. Show a => ClassHead a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClassHead a] -> ShowS
$cshowList :: forall a. Show a => [ClassHead a] -> ShowS
show :: ClassHead a -> String
$cshow :: forall a. Show a => ClassHead a -> String
showsPrec :: Int -> ClassHead a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ClassHead a -> ShowS
Show, ClassHead a -> ClassHead a -> Bool
forall a. Eq a => ClassHead a -> ClassHead a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClassHead a -> ClassHead a -> Bool
$c/= :: forall a. Eq a => ClassHead a -> ClassHead a -> Bool
== :: ClassHead a -> ClassHead a -> Bool
$c== :: forall a. Eq a => ClassHead a -> ClassHead a -> Bool
Eq, ClassHead a -> ClassHead a -> Bool
ClassHead a -> ClassHead a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (ClassHead a)
forall a. Ord a => ClassHead a -> ClassHead a -> Bool
forall a. Ord a => ClassHead a -> ClassHead a -> Ordering
forall a. Ord a => ClassHead a -> ClassHead a -> ClassHead a
min :: ClassHead a -> ClassHead a -> ClassHead a
$cmin :: forall a. Ord a => ClassHead a -> ClassHead a -> ClassHead a
max :: ClassHead a -> ClassHead a -> ClassHead a
$cmax :: forall a. Ord a => ClassHead a -> ClassHead a -> ClassHead a
>= :: ClassHead a -> ClassHead a -> Bool
$c>= :: forall a. Ord a => ClassHead a -> ClassHead a -> Bool
> :: ClassHead a -> ClassHead a -> Bool
$c> :: forall a. Ord a => ClassHead a -> ClassHead a -> Bool
<= :: ClassHead a -> ClassHead a -> Bool
$c<= :: forall a. Ord a => ClassHead a -> ClassHead a -> Bool
< :: ClassHead a -> ClassHead a -> Bool
$c< :: forall a. Ord a => ClassHead a -> ClassHead a -> Bool
compare :: ClassHead a -> ClassHead a -> Ordering
$ccompare :: forall a. Ord a => ClassHead a -> ClassHead a -> Ordering
Ord, forall a b. a -> ClassHead b -> ClassHead a
forall a b. (a -> b) -> ClassHead a -> ClassHead b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ClassHead b -> ClassHead a
$c<$ :: forall a b. a -> ClassHead b -> ClassHead a
fmap :: forall a b. (a -> b) -> ClassHead a -> ClassHead b
$cfmap :: forall a b. (a -> b) -> ClassHead a -> ClassHead b
Functor, forall a. Eq a => a -> ClassHead a -> Bool
forall a. Num a => ClassHead a -> a
forall a. Ord a => ClassHead a -> a
forall m. Monoid m => ClassHead m -> m
forall a. ClassHead a -> Bool
forall a. ClassHead a -> Int
forall a. ClassHead a -> [a]
forall a. (a -> a -> a) -> ClassHead a -> a
forall m a. Monoid m => (a -> m) -> ClassHead a -> m
forall b a. (b -> a -> b) -> b -> ClassHead a -> b
forall a b. (a -> b -> b) -> b -> ClassHead a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ClassHead a -> a
$cproduct :: forall a. Num a => ClassHead a -> a
sum :: forall a. Num a => ClassHead a -> a
$csum :: forall a. Num a => ClassHead a -> a
minimum :: forall a. Ord a => ClassHead a -> a
$cminimum :: forall a. Ord a => ClassHead a -> a
maximum :: forall a. Ord a => ClassHead a -> a
$cmaximum :: forall a. Ord a => ClassHead a -> a
elem :: forall a. Eq a => a -> ClassHead a -> Bool
$celem :: forall a. Eq a => a -> ClassHead a -> Bool
length :: forall a. ClassHead a -> Int
$clength :: forall a. ClassHead a -> Int
null :: forall a. ClassHead a -> Bool
$cnull :: forall a. ClassHead a -> Bool
toList :: forall a. ClassHead a -> [a]
$ctoList :: forall a. ClassHead a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ClassHead a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ClassHead a -> a
foldr1 :: forall a. (a -> a -> a) -> ClassHead a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ClassHead a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ClassHead a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ClassHead a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ClassHead a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ClassHead a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ClassHead a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ClassHead a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ClassHead a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ClassHead a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ClassHead a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ClassHead a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ClassHead a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ClassHead a -> m
fold :: forall m. Monoid m => ClassHead m -> m
$cfold :: forall m. Monoid m => ClassHead m -> m
Foldable, Functor ClassHead
Foldable ClassHead
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 =>
ClassHead (m a) -> m (ClassHead a)
forall (f :: * -> *) a.
Applicative f =>
ClassHead (f a) -> f (ClassHead a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ClassHead a -> m (ClassHead b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ClassHead a -> f (ClassHead b)
sequence :: forall (m :: * -> *) a.
Monad m =>
ClassHead (m a) -> m (ClassHead a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ClassHead (m a) -> m (ClassHead a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ClassHead a -> m (ClassHead b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ClassHead a -> m (ClassHead b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ClassHead (f a) -> f (ClassHead a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ClassHead (f a) -> f (ClassHead a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ClassHead a -> f (ClassHead b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ClassHead a -> f (ClassHead b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ClassHead a) x -> ClassHead a
forall a x. ClassHead a -> Rep (ClassHead a) x
$cto :: forall a x. Rep (ClassHead a) x -> ClassHead a
$cfrom :: forall a x. ClassHead a -> Rep (ClassHead a) x
Generic)

data ClassFundep
  = FundepDetermined SourceToken (NonEmpty (Name Ident))
  | FundepDetermines (NonEmpty (Name Ident)) SourceToken (NonEmpty (Name Ident))
  deriving (Int -> ClassFundep -> ShowS
[ClassFundep] -> ShowS
ClassFundep -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClassFundep] -> ShowS
$cshowList :: [ClassFundep] -> ShowS
show :: ClassFundep -> String
$cshow :: ClassFundep -> String
showsPrec :: Int -> ClassFundep -> ShowS
$cshowsPrec :: Int -> ClassFundep -> ShowS
Show, ClassFundep -> ClassFundep -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClassFundep -> ClassFundep -> Bool
$c/= :: ClassFundep -> ClassFundep -> Bool
== :: ClassFundep -> ClassFundep -> Bool
$c== :: ClassFundep -> ClassFundep -> Bool
Eq, Eq ClassFundep
ClassFundep -> ClassFundep -> Bool
ClassFundep -> ClassFundep -> Ordering
ClassFundep -> ClassFundep -> ClassFundep
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 :: ClassFundep -> ClassFundep -> ClassFundep
$cmin :: ClassFundep -> ClassFundep -> ClassFundep
max :: ClassFundep -> ClassFundep -> ClassFundep
$cmax :: ClassFundep -> ClassFundep -> ClassFundep
>= :: ClassFundep -> ClassFundep -> Bool
$c>= :: ClassFundep -> ClassFundep -> Bool
> :: ClassFundep -> ClassFundep -> Bool
$c> :: ClassFundep -> ClassFundep -> Bool
<= :: ClassFundep -> ClassFundep -> Bool
$c<= :: ClassFundep -> ClassFundep -> Bool
< :: ClassFundep -> ClassFundep -> Bool
$c< :: ClassFundep -> ClassFundep -> Bool
compare :: ClassFundep -> ClassFundep -> Ordering
$ccompare :: ClassFundep -> ClassFundep -> Ordering
Ord, forall x. Rep ClassFundep x -> ClassFundep
forall x. ClassFundep -> Rep ClassFundep x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ClassFundep x -> ClassFundep
$cfrom :: forall x. ClassFundep -> Rep ClassFundep x
Generic)

data InstanceHead a = InstanceHead
  { forall a. InstanceHead a -> SourceToken
instKeyword :: SourceToken
  , forall a. InstanceHead a -> Maybe (Name Ident, SourceToken)
instNameSep :: Maybe (Name Ident, SourceToken)
  , forall a.
InstanceHead a
-> Maybe (OneOrDelimited (Constraint a), SourceToken)
instConstraints :: Maybe (OneOrDelimited (Constraint a), SourceToken)
  , forall a. InstanceHead a -> QualifiedName (ProperName 'ClassName)
instClass :: QualifiedName (N.ProperName 'N.ClassName)
  , forall a. InstanceHead a -> [Type a]
instTypes :: [Type a]
  } deriving (Int -> InstanceHead a -> ShowS
forall a. Show a => Int -> InstanceHead a -> ShowS
forall a. Show a => [InstanceHead a] -> ShowS
forall a. Show a => InstanceHead a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InstanceHead a] -> ShowS
$cshowList :: forall a. Show a => [InstanceHead a] -> ShowS
show :: InstanceHead a -> String
$cshow :: forall a. Show a => InstanceHead a -> String
showsPrec :: Int -> InstanceHead a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> InstanceHead a -> ShowS
Show, InstanceHead a -> InstanceHead a -> Bool
forall a. Eq a => InstanceHead a -> InstanceHead a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InstanceHead a -> InstanceHead a -> Bool
$c/= :: forall a. Eq a => InstanceHead a -> InstanceHead a -> Bool
== :: InstanceHead a -> InstanceHead a -> Bool
$c== :: forall a. Eq a => InstanceHead a -> InstanceHead a -> Bool
Eq, InstanceHead a -> InstanceHead a -> Bool
InstanceHead a -> InstanceHead a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (InstanceHead a)
forall a. Ord a => InstanceHead a -> InstanceHead a -> Bool
forall a. Ord a => InstanceHead a -> InstanceHead a -> Ordering
forall a.
Ord a =>
InstanceHead a -> InstanceHead a -> InstanceHead a
min :: InstanceHead a -> InstanceHead a -> InstanceHead a
$cmin :: forall a.
Ord a =>
InstanceHead a -> InstanceHead a -> InstanceHead a
max :: InstanceHead a -> InstanceHead a -> InstanceHead a
$cmax :: forall a.
Ord a =>
InstanceHead a -> InstanceHead a -> InstanceHead a
>= :: InstanceHead a -> InstanceHead a -> Bool
$c>= :: forall a. Ord a => InstanceHead a -> InstanceHead a -> Bool
> :: InstanceHead a -> InstanceHead a -> Bool
$c> :: forall a. Ord a => InstanceHead a -> InstanceHead a -> Bool
<= :: InstanceHead a -> InstanceHead a -> Bool
$c<= :: forall a. Ord a => InstanceHead a -> InstanceHead a -> Bool
< :: InstanceHead a -> InstanceHead a -> Bool
$c< :: forall a. Ord a => InstanceHead a -> InstanceHead a -> Bool
compare :: InstanceHead a -> InstanceHead a -> Ordering
$ccompare :: forall a. Ord a => InstanceHead a -> InstanceHead a -> Ordering
Ord, forall a b. a -> InstanceHead b -> InstanceHead a
forall a b. (a -> b) -> InstanceHead a -> InstanceHead b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> InstanceHead b -> InstanceHead a
$c<$ :: forall a b. a -> InstanceHead b -> InstanceHead a
fmap :: forall a b. (a -> b) -> InstanceHead a -> InstanceHead b
$cfmap :: forall a b. (a -> b) -> InstanceHead a -> InstanceHead b
Functor, forall a. Eq a => a -> InstanceHead a -> Bool
forall a. Num a => InstanceHead a -> a
forall a. Ord a => InstanceHead a -> a
forall m. Monoid m => InstanceHead m -> m
forall a. InstanceHead a -> Bool
forall a. InstanceHead a -> Int
forall a. InstanceHead a -> [a]
forall a. (a -> a -> a) -> InstanceHead a -> a
forall m a. Monoid m => (a -> m) -> InstanceHead a -> m
forall b a. (b -> a -> b) -> b -> InstanceHead a -> b
forall a b. (a -> b -> b) -> b -> InstanceHead a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => InstanceHead a -> a
$cproduct :: forall a. Num a => InstanceHead a -> a
sum :: forall a. Num a => InstanceHead a -> a
$csum :: forall a. Num a => InstanceHead a -> a
minimum :: forall a. Ord a => InstanceHead a -> a
$cminimum :: forall a. Ord a => InstanceHead a -> a
maximum :: forall a. Ord a => InstanceHead a -> a
$cmaximum :: forall a. Ord a => InstanceHead a -> a
elem :: forall a. Eq a => a -> InstanceHead a -> Bool
$celem :: forall a. Eq a => a -> InstanceHead a -> Bool
length :: forall a. InstanceHead a -> Int
$clength :: forall a. InstanceHead a -> Int
null :: forall a. InstanceHead a -> Bool
$cnull :: forall a. InstanceHead a -> Bool
toList :: forall a. InstanceHead a -> [a]
$ctoList :: forall a. InstanceHead a -> [a]
foldl1 :: forall a. (a -> a -> a) -> InstanceHead a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> InstanceHead a -> a
foldr1 :: forall a. (a -> a -> a) -> InstanceHead a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> InstanceHead a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> InstanceHead a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> InstanceHead a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InstanceHead a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> InstanceHead a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InstanceHead a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> InstanceHead a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InstanceHead a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> InstanceHead a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> InstanceHead a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> InstanceHead a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InstanceHead a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> InstanceHead a -> m
fold :: forall m. Monoid m => InstanceHead m -> m
$cfold :: forall m. Monoid m => InstanceHead m -> m
Foldable, Functor InstanceHead
Foldable InstanceHead
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 =>
InstanceHead (m a) -> m (InstanceHead a)
forall (f :: * -> *) a.
Applicative f =>
InstanceHead (f a) -> f (InstanceHead a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstanceHead a -> m (InstanceHead b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstanceHead a -> f (InstanceHead b)
sequence :: forall (m :: * -> *) a.
Monad m =>
InstanceHead (m a) -> m (InstanceHead a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
InstanceHead (m a) -> m (InstanceHead a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstanceHead a -> m (InstanceHead b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InstanceHead a -> m (InstanceHead b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstanceHead (f a) -> f (InstanceHead a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
InstanceHead (f a) -> f (InstanceHead a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstanceHead a -> f (InstanceHead b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InstanceHead a -> f (InstanceHead b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (InstanceHead a) x -> InstanceHead a
forall a x. InstanceHead a -> Rep (InstanceHead a) x
$cto :: forall a x. Rep (InstanceHead a) x -> InstanceHead a
$cfrom :: forall a x. InstanceHead a -> Rep (InstanceHead a) x
Generic)

data Fixity
  = Infix
  | Infixl
  | Infixr
  deriving (Int -> Fixity -> ShowS
[Fixity] -> ShowS
Fixity -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Fixity] -> ShowS
$cshowList :: [Fixity] -> ShowS
show :: Fixity -> String
$cshow :: Fixity -> String
showsPrec :: Int -> Fixity -> ShowS
$cshowsPrec :: Int -> Fixity -> ShowS
Show, Fixity -> Fixity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fixity -> Fixity -> Bool
$c/= :: Fixity -> Fixity -> Bool
== :: Fixity -> Fixity -> Bool
$c== :: Fixity -> Fixity -> Bool
Eq, Eq Fixity
Fixity -> Fixity -> Bool
Fixity -> Fixity -> Ordering
Fixity -> Fixity -> Fixity
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 :: Fixity -> Fixity -> Fixity
$cmin :: Fixity -> Fixity -> Fixity
max :: Fixity -> Fixity -> Fixity
$cmax :: Fixity -> Fixity -> Fixity
>= :: Fixity -> Fixity -> Bool
$c>= :: Fixity -> Fixity -> Bool
> :: Fixity -> Fixity -> Bool
$c> :: Fixity -> Fixity -> Bool
<= :: Fixity -> Fixity -> Bool
$c<= :: Fixity -> Fixity -> Bool
< :: Fixity -> Fixity -> Bool
$c< :: Fixity -> Fixity -> Bool
compare :: Fixity -> Fixity -> Ordering
$ccompare :: Fixity -> Fixity -> Ordering
Ord, forall x. Rep Fixity x -> Fixity
forall x. Fixity -> Rep Fixity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Fixity x -> Fixity
$cfrom :: forall x. Fixity -> Rep Fixity x
Generic)

data FixityOp
  = FixityValue (QualifiedName (Either Ident (N.ProperName 'N.ConstructorName))) SourceToken (Name (N.OpName 'N.ValueOpName))
  | FixityType SourceToken (QualifiedName (N.ProperName 'N.TypeName)) SourceToken (Name (N.OpName 'N.TypeOpName))
  deriving (Int -> FixityOp -> ShowS
[FixityOp] -> ShowS
FixityOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixityOp] -> ShowS
$cshowList :: [FixityOp] -> ShowS
show :: FixityOp -> String
$cshow :: FixityOp -> String
showsPrec :: Int -> FixityOp -> ShowS
$cshowsPrec :: Int -> FixityOp -> ShowS
Show, FixityOp -> FixityOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixityOp -> FixityOp -> Bool
$c/= :: FixityOp -> FixityOp -> Bool
== :: FixityOp -> FixityOp -> Bool
$c== :: FixityOp -> FixityOp -> Bool
Eq, Eq FixityOp
FixityOp -> FixityOp -> Bool
FixityOp -> FixityOp -> Ordering
FixityOp -> FixityOp -> FixityOp
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 :: FixityOp -> FixityOp -> FixityOp
$cmin :: FixityOp -> FixityOp -> FixityOp
max :: FixityOp -> FixityOp -> FixityOp
$cmax :: FixityOp -> FixityOp -> FixityOp
>= :: FixityOp -> FixityOp -> Bool
$c>= :: FixityOp -> FixityOp -> Bool
> :: FixityOp -> FixityOp -> Bool
$c> :: FixityOp -> FixityOp -> Bool
<= :: FixityOp -> FixityOp -> Bool
$c<= :: FixityOp -> FixityOp -> Bool
< :: FixityOp -> FixityOp -> Bool
$c< :: FixityOp -> FixityOp -> Bool
compare :: FixityOp -> FixityOp -> Ordering
$ccompare :: FixityOp -> FixityOp -> Ordering
Ord, forall x. Rep FixityOp x -> FixityOp
forall x. FixityOp -> Rep FixityOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FixityOp x -> FixityOp
$cfrom :: forall x. FixityOp -> Rep FixityOp x
Generic)

data FixityFields = FixityFields
  { FixityFields -> (SourceToken, Fixity)
fxtKeyword :: (SourceToken, Fixity)
  , FixityFields -> (SourceToken, Integer)
fxtPrec :: (SourceToken, Integer)
  , FixityFields -> FixityOp
fxtOp :: FixityOp
  } deriving (Int -> FixityFields -> ShowS
[FixityFields] -> ShowS
FixityFields -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FixityFields] -> ShowS
$cshowList :: [FixityFields] -> ShowS
show :: FixityFields -> String
$cshow :: FixityFields -> String
showsPrec :: Int -> FixityFields -> ShowS
$cshowsPrec :: Int -> FixityFields -> ShowS
Show, FixityFields -> FixityFields -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixityFields -> FixityFields -> Bool
$c/= :: FixityFields -> FixityFields -> Bool
== :: FixityFields -> FixityFields -> Bool
$c== :: FixityFields -> FixityFields -> Bool
Eq, Eq FixityFields
FixityFields -> FixityFields -> Bool
FixityFields -> FixityFields -> Ordering
FixityFields -> FixityFields -> FixityFields
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 :: FixityFields -> FixityFields -> FixityFields
$cmin :: FixityFields -> FixityFields -> FixityFields
max :: FixityFields -> FixityFields -> FixityFields
$cmax :: FixityFields -> FixityFields -> FixityFields
>= :: FixityFields -> FixityFields -> Bool
$c>= :: FixityFields -> FixityFields -> Bool
> :: FixityFields -> FixityFields -> Bool
$c> :: FixityFields -> FixityFields -> Bool
<= :: FixityFields -> FixityFields -> Bool
$c<= :: FixityFields -> FixityFields -> Bool
< :: FixityFields -> FixityFields -> Bool
$c< :: FixityFields -> FixityFields -> Bool
compare :: FixityFields -> FixityFields -> Ordering
$ccompare :: FixityFields -> FixityFields -> Ordering
Ord, forall x. Rep FixityFields x -> FixityFields
forall x. FixityFields -> Rep FixityFields x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FixityFields x -> FixityFields
$cfrom :: forall x. FixityFields -> Rep FixityFields x
Generic)

data ValueBindingFields a = ValueBindingFields
  { forall a. ValueBindingFields a -> Name Ident
valName :: Name Ident
  , forall a. ValueBindingFields a -> [Binder a]
valBinders :: [Binder a]
  , forall a. ValueBindingFields a -> Guarded a
valGuarded :: Guarded a
  } deriving (Int -> ValueBindingFields a -> ShowS
forall a. Show a => Int -> ValueBindingFields a -> ShowS
forall a. Show a => [ValueBindingFields a] -> ShowS
forall a. Show a => ValueBindingFields a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ValueBindingFields a] -> ShowS
$cshowList :: forall a. Show a => [ValueBindingFields a] -> ShowS
show :: ValueBindingFields a -> String
$cshow :: forall a. Show a => ValueBindingFields a -> String
showsPrec :: Int -> ValueBindingFields a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ValueBindingFields a -> ShowS
Show, ValueBindingFields a -> ValueBindingFields a -> Bool
forall a.
Eq a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ValueBindingFields a -> ValueBindingFields a -> Bool
$c/= :: forall a.
Eq a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
== :: ValueBindingFields a -> ValueBindingFields a -> Bool
$c== :: forall a.
Eq a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
Eq, ValueBindingFields a -> ValueBindingFields a -> Bool
ValueBindingFields a -> ValueBindingFields a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (ValueBindingFields a)
forall a.
Ord a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
forall a.
Ord a =>
ValueBindingFields a -> ValueBindingFields a -> Ordering
forall a.
Ord a =>
ValueBindingFields a
-> ValueBindingFields a -> ValueBindingFields a
min :: ValueBindingFields a
-> ValueBindingFields a -> ValueBindingFields a
$cmin :: forall a.
Ord a =>
ValueBindingFields a
-> ValueBindingFields a -> ValueBindingFields a
max :: ValueBindingFields a
-> ValueBindingFields a -> ValueBindingFields a
$cmax :: forall a.
Ord a =>
ValueBindingFields a
-> ValueBindingFields a -> ValueBindingFields a
>= :: ValueBindingFields a -> ValueBindingFields a -> Bool
$c>= :: forall a.
Ord a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
> :: ValueBindingFields a -> ValueBindingFields a -> Bool
$c> :: forall a.
Ord a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
<= :: ValueBindingFields a -> ValueBindingFields a -> Bool
$c<= :: forall a.
Ord a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
< :: ValueBindingFields a -> ValueBindingFields a -> Bool
$c< :: forall a.
Ord a =>
ValueBindingFields a -> ValueBindingFields a -> Bool
compare :: ValueBindingFields a -> ValueBindingFields a -> Ordering
$ccompare :: forall a.
Ord a =>
ValueBindingFields a -> ValueBindingFields a -> Ordering
Ord, forall a b. a -> ValueBindingFields b -> ValueBindingFields a
forall a b.
(a -> b) -> ValueBindingFields a -> ValueBindingFields b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> ValueBindingFields b -> ValueBindingFields a
$c<$ :: forall a b. a -> ValueBindingFields b -> ValueBindingFields a
fmap :: forall a b.
(a -> b) -> ValueBindingFields a -> ValueBindingFields b
$cfmap :: forall a b.
(a -> b) -> ValueBindingFields a -> ValueBindingFields b
Functor, forall a. Eq a => a -> ValueBindingFields a -> Bool
forall a. Num a => ValueBindingFields a -> a
forall a. Ord a => ValueBindingFields a -> a
forall m. Monoid m => ValueBindingFields m -> m
forall a. ValueBindingFields a -> Bool
forall a. ValueBindingFields a -> Int
forall a. ValueBindingFields a -> [a]
forall a. (a -> a -> a) -> ValueBindingFields a -> a
forall m a. Monoid m => (a -> m) -> ValueBindingFields a -> m
forall b a. (b -> a -> b) -> b -> ValueBindingFields a -> b
forall a b. (a -> b -> b) -> b -> ValueBindingFields a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => ValueBindingFields a -> a
$cproduct :: forall a. Num a => ValueBindingFields a -> a
sum :: forall a. Num a => ValueBindingFields a -> a
$csum :: forall a. Num a => ValueBindingFields a -> a
minimum :: forall a. Ord a => ValueBindingFields a -> a
$cminimum :: forall a. Ord a => ValueBindingFields a -> a
maximum :: forall a. Ord a => ValueBindingFields a -> a
$cmaximum :: forall a. Ord a => ValueBindingFields a -> a
elem :: forall a. Eq a => a -> ValueBindingFields a -> Bool
$celem :: forall a. Eq a => a -> ValueBindingFields a -> Bool
length :: forall a. ValueBindingFields a -> Int
$clength :: forall a. ValueBindingFields a -> Int
null :: forall a. ValueBindingFields a -> Bool
$cnull :: forall a. ValueBindingFields a -> Bool
toList :: forall a. ValueBindingFields a -> [a]
$ctoList :: forall a. ValueBindingFields a -> [a]
foldl1 :: forall a. (a -> a -> a) -> ValueBindingFields a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ValueBindingFields a -> a
foldr1 :: forall a. (a -> a -> a) -> ValueBindingFields a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ValueBindingFields a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> ValueBindingFields a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ValueBindingFields a -> b
foldl :: forall b a. (b -> a -> b) -> b -> ValueBindingFields a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ValueBindingFields a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> ValueBindingFields a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ValueBindingFields a -> b
foldr :: forall a b. (a -> b -> b) -> b -> ValueBindingFields a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ValueBindingFields a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> ValueBindingFields a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ValueBindingFields a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> ValueBindingFields a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ValueBindingFields a -> m
fold :: forall m. Monoid m => ValueBindingFields m -> m
$cfold :: forall m. Monoid m => ValueBindingFields m -> m
Foldable, Functor ValueBindingFields
Foldable ValueBindingFields
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 =>
ValueBindingFields (m a) -> m (ValueBindingFields a)
forall (f :: * -> *) a.
Applicative f =>
ValueBindingFields (f a) -> f (ValueBindingFields a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ValueBindingFields a -> m (ValueBindingFields b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ValueBindingFields a -> f (ValueBindingFields b)
sequence :: forall (m :: * -> *) a.
Monad m =>
ValueBindingFields (m a) -> m (ValueBindingFields a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ValueBindingFields (m a) -> m (ValueBindingFields a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ValueBindingFields a -> m (ValueBindingFields b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ValueBindingFields a -> m (ValueBindingFields b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
ValueBindingFields (f a) -> f (ValueBindingFields a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ValueBindingFields (f a) -> f (ValueBindingFields a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ValueBindingFields a -> f (ValueBindingFields b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ValueBindingFields a -> f (ValueBindingFields b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ValueBindingFields a) x -> ValueBindingFields a
forall a x. ValueBindingFields a -> Rep (ValueBindingFields a) x
$cto :: forall a x. Rep (ValueBindingFields a) x -> ValueBindingFields a
$cfrom :: forall a x. ValueBindingFields a -> Rep (ValueBindingFields a) x
Generic)

data Guarded a
  = Unconditional SourceToken (Where a)
  | Guarded (NonEmpty (GuardedExpr a))
  deriving (Int -> Guarded a -> ShowS
forall a. Show a => Int -> Guarded a -> ShowS
forall a. Show a => [Guarded a] -> ShowS
forall a. Show a => Guarded a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Guarded a] -> ShowS
$cshowList :: forall a. Show a => [Guarded a] -> ShowS
show :: Guarded a -> String
$cshow :: forall a. Show a => Guarded a -> String
showsPrec :: Int -> Guarded a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Guarded a -> ShowS
Show, Guarded a -> Guarded a -> Bool
forall a. Eq a => Guarded a -> Guarded a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Guarded a -> Guarded a -> Bool
$c/= :: forall a. Eq a => Guarded a -> Guarded a -> Bool
== :: Guarded a -> Guarded a -> Bool
$c== :: forall a. Eq a => Guarded a -> Guarded a -> Bool
Eq, Guarded a -> Guarded a -> Bool
Guarded a -> Guarded a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Guarded a)
forall a. Ord a => Guarded a -> Guarded a -> Bool
forall a. Ord a => Guarded a -> Guarded a -> Ordering
forall a. Ord a => Guarded a -> Guarded a -> Guarded a
min :: Guarded a -> Guarded a -> Guarded a
$cmin :: forall a. Ord a => Guarded a -> Guarded a -> Guarded a
max :: Guarded a -> Guarded a -> Guarded a
$cmax :: forall a. Ord a => Guarded a -> Guarded a -> Guarded a
>= :: Guarded a -> Guarded a -> Bool
$c>= :: forall a. Ord a => Guarded a -> Guarded a -> Bool
> :: Guarded a -> Guarded a -> Bool
$c> :: forall a. Ord a => Guarded a -> Guarded a -> Bool
<= :: Guarded a -> Guarded a -> Bool
$c<= :: forall a. Ord a => Guarded a -> Guarded a -> Bool
< :: Guarded a -> Guarded a -> Bool
$c< :: forall a. Ord a => Guarded a -> Guarded a -> Bool
compare :: Guarded a -> Guarded a -> Ordering
$ccompare :: forall a. Ord a => Guarded a -> Guarded a -> Ordering
Ord, forall a b. a -> Guarded b -> Guarded a
forall a b. (a -> b) -> Guarded a -> Guarded b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Guarded b -> Guarded a
$c<$ :: forall a b. a -> Guarded b -> Guarded a
fmap :: forall a b. (a -> b) -> Guarded a -> Guarded b
$cfmap :: forall a b. (a -> b) -> Guarded a -> Guarded b
Functor, forall a. Eq a => a -> Guarded a -> Bool
forall a. Num a => Guarded a -> a
forall a. Ord a => Guarded a -> a
forall m. Monoid m => Guarded m -> m
forall a. Guarded a -> Bool
forall a. Guarded a -> Int
forall a. Guarded a -> [a]
forall a. (a -> a -> a) -> Guarded a -> a
forall m a. Monoid m => (a -> m) -> Guarded a -> m
forall b a. (b -> a -> b) -> b -> Guarded a -> b
forall a b. (a -> b -> b) -> b -> Guarded a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Guarded a -> a
$cproduct :: forall a. Num a => Guarded a -> a
sum :: forall a. Num a => Guarded a -> a
$csum :: forall a. Num a => Guarded a -> a
minimum :: forall a. Ord a => Guarded a -> a
$cminimum :: forall a. Ord a => Guarded a -> a
maximum :: forall a. Ord a => Guarded a -> a
$cmaximum :: forall a. Ord a => Guarded a -> a
elem :: forall a. Eq a => a -> Guarded a -> Bool
$celem :: forall a. Eq a => a -> Guarded a -> Bool
length :: forall a. Guarded a -> Int
$clength :: forall a. Guarded a -> Int
null :: forall a. Guarded a -> Bool
$cnull :: forall a. Guarded a -> Bool
toList :: forall a. Guarded a -> [a]
$ctoList :: forall a. Guarded a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Guarded a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Guarded a -> a
foldr1 :: forall a. (a -> a -> a) -> Guarded a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Guarded a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Guarded a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Guarded a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Guarded a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Guarded a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Guarded a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Guarded a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Guarded a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Guarded a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Guarded a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Guarded a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Guarded a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Guarded a -> m
fold :: forall m. Monoid m => Guarded m -> m
$cfold :: forall m. Monoid m => Guarded m -> m
Foldable, Functor Guarded
Foldable Guarded
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 => Guarded (m a) -> m (Guarded a)
forall (f :: * -> *) a.
Applicative f =>
Guarded (f a) -> f (Guarded a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Guarded a -> m (Guarded b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Guarded a -> f (Guarded b)
sequence :: forall (m :: * -> *) a. Monad m => Guarded (m a) -> m (Guarded a)
$csequence :: forall (m :: * -> *) a. Monad m => Guarded (m a) -> m (Guarded a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Guarded a -> m (Guarded b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Guarded a -> m (Guarded b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Guarded (f a) -> f (Guarded a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Guarded (f a) -> f (Guarded a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Guarded a -> f (Guarded b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Guarded a -> f (Guarded b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Guarded a) x -> Guarded a
forall a x. Guarded a -> Rep (Guarded a) x
$cto :: forall a x. Rep (Guarded a) x -> Guarded a
$cfrom :: forall a x. Guarded a -> Rep (Guarded a) x
Generic)

data GuardedExpr a = GuardedExpr
  { forall a. GuardedExpr a -> SourceToken
grdBar :: SourceToken
  , forall a. GuardedExpr a -> Separated (PatternGuard a)
grdPatterns :: Separated (PatternGuard a)
  , forall a. GuardedExpr a -> SourceToken
grdSep :: SourceToken
  , forall a. GuardedExpr a -> Where a
grdWhere :: Where a
  } deriving (Int -> GuardedExpr a -> ShowS
forall a. Show a => Int -> GuardedExpr a -> ShowS
forall a. Show a => [GuardedExpr a] -> ShowS
forall a. Show a => GuardedExpr a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GuardedExpr a] -> ShowS
$cshowList :: forall a. Show a => [GuardedExpr a] -> ShowS
show :: GuardedExpr a -> String
$cshow :: forall a. Show a => GuardedExpr a -> String
showsPrec :: Int -> GuardedExpr a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> GuardedExpr a -> ShowS
Show, GuardedExpr a -> GuardedExpr a -> Bool
forall a. Eq a => GuardedExpr a -> GuardedExpr a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GuardedExpr a -> GuardedExpr a -> Bool
$c/= :: forall a. Eq a => GuardedExpr a -> GuardedExpr a -> Bool
== :: GuardedExpr a -> GuardedExpr a -> Bool
$c== :: forall a. Eq a => GuardedExpr a -> GuardedExpr a -> Bool
Eq, GuardedExpr a -> GuardedExpr a -> Bool
GuardedExpr a -> GuardedExpr a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (GuardedExpr a)
forall a. Ord a => GuardedExpr a -> GuardedExpr a -> Bool
forall a. Ord a => GuardedExpr a -> GuardedExpr a -> Ordering
forall a. Ord a => GuardedExpr a -> GuardedExpr a -> GuardedExpr a
min :: GuardedExpr a -> GuardedExpr a -> GuardedExpr a
$cmin :: forall a. Ord a => GuardedExpr a -> GuardedExpr a -> GuardedExpr a
max :: GuardedExpr a -> GuardedExpr a -> GuardedExpr a
$cmax :: forall a. Ord a => GuardedExpr a -> GuardedExpr a -> GuardedExpr a
>= :: GuardedExpr a -> GuardedExpr a -> Bool
$c>= :: forall a. Ord a => GuardedExpr a -> GuardedExpr a -> Bool
> :: GuardedExpr a -> GuardedExpr a -> Bool
$c> :: forall a. Ord a => GuardedExpr a -> GuardedExpr a -> Bool
<= :: GuardedExpr a -> GuardedExpr a -> Bool
$c<= :: forall a. Ord a => GuardedExpr a -> GuardedExpr a -> Bool
< :: GuardedExpr a -> GuardedExpr a -> Bool
$c< :: forall a. Ord a => GuardedExpr a -> GuardedExpr a -> Bool
compare :: GuardedExpr a -> GuardedExpr a -> Ordering
$ccompare :: forall a. Ord a => GuardedExpr a -> GuardedExpr a -> Ordering
Ord, forall a b. a -> GuardedExpr b -> GuardedExpr a
forall a b. (a -> b) -> GuardedExpr a -> GuardedExpr b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> GuardedExpr b -> GuardedExpr a
$c<$ :: forall a b. a -> GuardedExpr b -> GuardedExpr a
fmap :: forall a b. (a -> b) -> GuardedExpr a -> GuardedExpr b
$cfmap :: forall a b. (a -> b) -> GuardedExpr a -> GuardedExpr b
Functor, forall a. Eq a => a -> GuardedExpr a -> Bool
forall a. Num a => GuardedExpr a -> a
forall a. Ord a => GuardedExpr a -> a
forall m. Monoid m => GuardedExpr m -> m
forall a. GuardedExpr a -> Bool
forall a. GuardedExpr a -> Int
forall a. GuardedExpr a -> [a]
forall a. (a -> a -> a) -> GuardedExpr a -> a
forall m a. Monoid m => (a -> m) -> GuardedExpr a -> m
forall b a. (b -> a -> b) -> b -> GuardedExpr a -> b
forall a b. (a -> b -> b) -> b -> GuardedExpr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => GuardedExpr a -> a
$cproduct :: forall a. Num a => GuardedExpr a -> a
sum :: forall a. Num a => GuardedExpr a -> a
$csum :: forall a. Num a => GuardedExpr a -> a
minimum :: forall a. Ord a => GuardedExpr a -> a
$cminimum :: forall a. Ord a => GuardedExpr a -> a
maximum :: forall a. Ord a => GuardedExpr a -> a
$cmaximum :: forall a. Ord a => GuardedExpr a -> a
elem :: forall a. Eq a => a -> GuardedExpr a -> Bool
$celem :: forall a. Eq a => a -> GuardedExpr a -> Bool
length :: forall a. GuardedExpr a -> Int
$clength :: forall a. GuardedExpr a -> Int
null :: forall a. GuardedExpr a -> Bool
$cnull :: forall a. GuardedExpr a -> Bool
toList :: forall a. GuardedExpr a -> [a]
$ctoList :: forall a. GuardedExpr a -> [a]
foldl1 :: forall a. (a -> a -> a) -> GuardedExpr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> GuardedExpr a -> a
foldr1 :: forall a. (a -> a -> a) -> GuardedExpr a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> GuardedExpr a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> GuardedExpr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> GuardedExpr a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GuardedExpr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> GuardedExpr a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GuardedExpr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> GuardedExpr a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GuardedExpr a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> GuardedExpr a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> GuardedExpr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> GuardedExpr a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GuardedExpr a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> GuardedExpr a -> m
fold :: forall m. Monoid m => GuardedExpr m -> m
$cfold :: forall m. Monoid m => GuardedExpr m -> m
Foldable, Functor GuardedExpr
Foldable GuardedExpr
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 =>
GuardedExpr (m a) -> m (GuardedExpr a)
forall (f :: * -> *) a.
Applicative f =>
GuardedExpr (f a) -> f (GuardedExpr a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GuardedExpr a -> m (GuardedExpr b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GuardedExpr a -> f (GuardedExpr b)
sequence :: forall (m :: * -> *) a.
Monad m =>
GuardedExpr (m a) -> m (GuardedExpr a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
GuardedExpr (m a) -> m (GuardedExpr a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GuardedExpr a -> m (GuardedExpr b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> GuardedExpr a -> m (GuardedExpr b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
GuardedExpr (f a) -> f (GuardedExpr a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
GuardedExpr (f a) -> f (GuardedExpr a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GuardedExpr a -> f (GuardedExpr b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> GuardedExpr a -> f (GuardedExpr b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (GuardedExpr a) x -> GuardedExpr a
forall a x. GuardedExpr a -> Rep (GuardedExpr a) x
$cto :: forall a x. Rep (GuardedExpr a) x -> GuardedExpr a
$cfrom :: forall a x. GuardedExpr a -> Rep (GuardedExpr a) x
Generic)

data PatternGuard a = PatternGuard
  { forall a. PatternGuard a -> Maybe (Binder a, SourceToken)
patBinder :: Maybe (Binder a, SourceToken)
  , forall a. PatternGuard a -> Expr a
patExpr :: Expr a
  } deriving (Int -> PatternGuard a -> ShowS
forall a. Show a => Int -> PatternGuard a -> ShowS
forall a. Show a => [PatternGuard a] -> ShowS
forall a. Show a => PatternGuard a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PatternGuard a] -> ShowS
$cshowList :: forall a. Show a => [PatternGuard a] -> ShowS
show :: PatternGuard a -> String
$cshow :: forall a. Show a => PatternGuard a -> String
showsPrec :: Int -> PatternGuard a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> PatternGuard a -> ShowS
Show, PatternGuard a -> PatternGuard a -> Bool
forall a. Eq a => PatternGuard a -> PatternGuard a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PatternGuard a -> PatternGuard a -> Bool
$c/= :: forall a. Eq a => PatternGuard a -> PatternGuard a -> Bool
== :: PatternGuard a -> PatternGuard a -> Bool
$c== :: forall a. Eq a => PatternGuard a -> PatternGuard a -> Bool
Eq, PatternGuard a -> PatternGuard a -> Bool
PatternGuard a -> PatternGuard a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (PatternGuard a)
forall a. Ord a => PatternGuard a -> PatternGuard a -> Bool
forall a. Ord a => PatternGuard a -> PatternGuard a -> Ordering
forall a.
Ord a =>
PatternGuard a -> PatternGuard a -> PatternGuard a
min :: PatternGuard a -> PatternGuard a -> PatternGuard a
$cmin :: forall a.
Ord a =>
PatternGuard a -> PatternGuard a -> PatternGuard a
max :: PatternGuard a -> PatternGuard a -> PatternGuard a
$cmax :: forall a.
Ord a =>
PatternGuard a -> PatternGuard a -> PatternGuard a
>= :: PatternGuard a -> PatternGuard a -> Bool
$c>= :: forall a. Ord a => PatternGuard a -> PatternGuard a -> Bool
> :: PatternGuard a -> PatternGuard a -> Bool
$c> :: forall a. Ord a => PatternGuard a -> PatternGuard a -> Bool
<= :: PatternGuard a -> PatternGuard a -> Bool
$c<= :: forall a. Ord a => PatternGuard a -> PatternGuard a -> Bool
< :: PatternGuard a -> PatternGuard a -> Bool
$c< :: forall a. Ord a => PatternGuard a -> PatternGuard a -> Bool
compare :: PatternGuard a -> PatternGuard a -> Ordering
$ccompare :: forall a. Ord a => PatternGuard a -> PatternGuard a -> Ordering
Ord, forall a b. a -> PatternGuard b -> PatternGuard a
forall a b. (a -> b) -> PatternGuard a -> PatternGuard b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> PatternGuard b -> PatternGuard a
$c<$ :: forall a b. a -> PatternGuard b -> PatternGuard a
fmap :: forall a b. (a -> b) -> PatternGuard a -> PatternGuard b
$cfmap :: forall a b. (a -> b) -> PatternGuard a -> PatternGuard b
Functor, forall a. Eq a => a -> PatternGuard a -> Bool
forall a. Num a => PatternGuard a -> a
forall a. Ord a => PatternGuard a -> a
forall m. Monoid m => PatternGuard m -> m
forall a. PatternGuard a -> Bool
forall a. PatternGuard a -> Int
forall a. PatternGuard a -> [a]
forall a. (a -> a -> a) -> PatternGuard a -> a
forall m a. Monoid m => (a -> m) -> PatternGuard a -> m
forall b a. (b -> a -> b) -> b -> PatternGuard a -> b
forall a b. (a -> b -> b) -> b -> PatternGuard a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => PatternGuard a -> a
$cproduct :: forall a. Num a => PatternGuard a -> a
sum :: forall a. Num a => PatternGuard a -> a
$csum :: forall a. Num a => PatternGuard a -> a
minimum :: forall a. Ord a => PatternGuard a -> a
$cminimum :: forall a. Ord a => PatternGuard a -> a
maximum :: forall a. Ord a => PatternGuard a -> a
$cmaximum :: forall a. Ord a => PatternGuard a -> a
elem :: forall a. Eq a => a -> PatternGuard a -> Bool
$celem :: forall a. Eq a => a -> PatternGuard a -> Bool
length :: forall a. PatternGuard a -> Int
$clength :: forall a. PatternGuard a -> Int
null :: forall a. PatternGuard a -> Bool
$cnull :: forall a. PatternGuard a -> Bool
toList :: forall a. PatternGuard a -> [a]
$ctoList :: forall a. PatternGuard a -> [a]
foldl1 :: forall a. (a -> a -> a) -> PatternGuard a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PatternGuard a -> a
foldr1 :: forall a. (a -> a -> a) -> PatternGuard a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> PatternGuard a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> PatternGuard a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PatternGuard a -> b
foldl :: forall b a. (b -> a -> b) -> b -> PatternGuard a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PatternGuard a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> PatternGuard a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PatternGuard a -> b
foldr :: forall a b. (a -> b -> b) -> b -> PatternGuard a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> PatternGuard a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> PatternGuard a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PatternGuard a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> PatternGuard a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PatternGuard a -> m
fold :: forall m. Monoid m => PatternGuard m -> m
$cfold :: forall m. Monoid m => PatternGuard m -> m
Foldable, Functor PatternGuard
Foldable PatternGuard
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 =>
PatternGuard (m a) -> m (PatternGuard a)
forall (f :: * -> *) a.
Applicative f =>
PatternGuard (f a) -> f (PatternGuard a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatternGuard a -> m (PatternGuard b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatternGuard a -> f (PatternGuard b)
sequence :: forall (m :: * -> *) a.
Monad m =>
PatternGuard (m a) -> m (PatternGuard a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
PatternGuard (m a) -> m (PatternGuard a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatternGuard a -> m (PatternGuard b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PatternGuard a -> m (PatternGuard b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
PatternGuard (f a) -> f (PatternGuard a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PatternGuard (f a) -> f (PatternGuard a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatternGuard a -> f (PatternGuard b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PatternGuard a -> f (PatternGuard b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (PatternGuard a) x -> PatternGuard a
forall a x. PatternGuard a -> Rep (PatternGuard a) x
$cto :: forall a x. Rep (PatternGuard a) x -> PatternGuard a
$cfrom :: forall a x. PatternGuard a -> Rep (PatternGuard a) x
Generic)

data Foreign a
  = ForeignValue (Labeled (Name Ident) (Type a))
  | ForeignData SourceToken (Labeled (Name (N.ProperName 'N.TypeName)) (Type a))
  | ForeignKind SourceToken (Name (N.ProperName 'N.TypeName))
  deriving (Int -> Foreign a -> ShowS
forall a. Show a => Int -> Foreign a -> ShowS
forall a. Show a => [Foreign a] -> ShowS
forall a. Show a => Foreign a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Foreign a] -> ShowS
$cshowList :: forall a. Show a => [Foreign a] -> ShowS
show :: Foreign a -> String
$cshow :: forall a. Show a => Foreign a -> String
showsPrec :: Int -> Foreign a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Foreign a -> ShowS
Show, Foreign a -> Foreign a -> Bool
forall a. Eq a => Foreign a -> Foreign a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Foreign a -> Foreign a -> Bool
$c/= :: forall a. Eq a => Foreign a -> Foreign a -> Bool
== :: Foreign a -> Foreign a -> Bool
$c== :: forall a. Eq a => Foreign a -> Foreign a -> Bool
Eq, Foreign a -> Foreign a -> Bool
Foreign a -> Foreign a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Foreign a)
forall a. Ord a => Foreign a -> Foreign a -> Bool
forall a. Ord a => Foreign a -> Foreign a -> Ordering
forall a. Ord a => Foreign a -> Foreign a -> Foreign a
min :: Foreign a -> Foreign a -> Foreign a
$cmin :: forall a. Ord a => Foreign a -> Foreign a -> Foreign a
max :: Foreign a -> Foreign a -> Foreign a
$cmax :: forall a. Ord a => Foreign a -> Foreign a -> Foreign a
>= :: Foreign a -> Foreign a -> Bool
$c>= :: forall a. Ord a => Foreign a -> Foreign a -> Bool
> :: Foreign a -> Foreign a -> Bool
$c> :: forall a. Ord a => Foreign a -> Foreign a -> Bool
<= :: Foreign a -> Foreign a -> Bool
$c<= :: forall a. Ord a => Foreign a -> Foreign a -> Bool
< :: Foreign a -> Foreign a -> Bool
$c< :: forall a. Ord a => Foreign a -> Foreign a -> Bool
compare :: Foreign a -> Foreign a -> Ordering
$ccompare :: forall a. Ord a => Foreign a -> Foreign a -> Ordering
Ord, forall a b. a -> Foreign b -> Foreign a
forall a b. (a -> b) -> Foreign a -> Foreign b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Foreign b -> Foreign a
$c<$ :: forall a b. a -> Foreign b -> Foreign a
fmap :: forall a b. (a -> b) -> Foreign a -> Foreign b
$cfmap :: forall a b. (a -> b) -> Foreign a -> Foreign b
Functor, forall a. Eq a => a -> Foreign a -> Bool
forall a. Num a => Foreign a -> a
forall a. Ord a => Foreign a -> a
forall m. Monoid m => Foreign m -> m
forall a. Foreign a -> Bool
forall a. Foreign a -> Int
forall a. Foreign a -> [a]
forall a. (a -> a -> a) -> Foreign a -> a
forall m a. Monoid m => (a -> m) -> Foreign a -> m
forall b a. (b -> a -> b) -> b -> Foreign a -> b
forall a b. (a -> b -> b) -> b -> Foreign a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Foreign a -> a
$cproduct :: forall a. Num a => Foreign a -> a
sum :: forall a. Num a => Foreign a -> a
$csum :: forall a. Num a => Foreign a -> a
minimum :: forall a. Ord a => Foreign a -> a
$cminimum :: forall a. Ord a => Foreign a -> a
maximum :: forall a. Ord a => Foreign a -> a
$cmaximum :: forall a. Ord a => Foreign a -> a
elem :: forall a. Eq a => a -> Foreign a -> Bool
$celem :: forall a. Eq a => a -> Foreign a -> Bool
length :: forall a. Foreign a -> Int
$clength :: forall a. Foreign a -> Int
null :: forall a. Foreign a -> Bool
$cnull :: forall a. Foreign a -> Bool
toList :: forall a. Foreign a -> [a]
$ctoList :: forall a. Foreign a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Foreign a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Foreign a -> a
foldr1 :: forall a. (a -> a -> a) -> Foreign a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Foreign a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Foreign a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Foreign a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Foreign a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Foreign a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Foreign a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Foreign a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Foreign a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Foreign a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Foreign a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Foreign a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Foreign a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Foreign a -> m
fold :: forall m. Monoid m => Foreign m -> m
$cfold :: forall m. Monoid m => Foreign m -> m
Foldable, Functor Foreign
Foldable Foreign
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 => Foreign (m a) -> m (Foreign a)
forall (f :: * -> *) a.
Applicative f =>
Foreign (f a) -> f (Foreign a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Foreign a -> m (Foreign b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Foreign a -> f (Foreign b)
sequence :: forall (m :: * -> *) a. Monad m => Foreign (m a) -> m (Foreign a)
$csequence :: forall (m :: * -> *) a. Monad m => Foreign (m a) -> m (Foreign a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Foreign a -> m (Foreign b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Foreign a -> m (Foreign b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Foreign (f a) -> f (Foreign a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Foreign (f a) -> f (Foreign a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Foreign a -> f (Foreign b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Foreign a -> f (Foreign b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Foreign a) x -> Foreign a
forall a x. Foreign a -> Rep (Foreign a) x
$cto :: forall a x. Rep (Foreign a) x -> Foreign a
$cfrom :: forall a x. Foreign a -> Rep (Foreign a) x
Generic)

data Role = Role
  { Role -> SourceToken
roleTok :: SourceToken
  , Role -> Role
roleValue :: R.Role
  } deriving (Int -> Role -> ShowS
[Role] -> ShowS
Role -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Role] -> ShowS
$cshowList :: [Role] -> ShowS
show :: Role -> String
$cshow :: Role -> String
showsPrec :: Int -> Role -> ShowS
$cshowsPrec :: Int -> Role -> ShowS
Show, Role -> Role -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Role -> Role -> Bool
$c/= :: Role -> Role -> Bool
== :: Role -> Role -> Bool
$c== :: Role -> Role -> Bool
Eq, Eq Role
Role -> Role -> Bool
Role -> Role -> Ordering
Role -> Role -> Role
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 :: Role -> Role -> Role
$cmin :: Role -> Role -> Role
max :: Role -> Role -> Role
$cmax :: Role -> Role -> Role
>= :: Role -> Role -> Bool
$c>= :: Role -> Role -> Bool
> :: Role -> Role -> Bool
$c> :: Role -> Role -> Bool
<= :: Role -> Role -> Bool
$c<= :: Role -> Role -> Bool
< :: Role -> Role -> Bool
$c< :: Role -> Role -> Bool
compare :: Role -> Role -> Ordering
$ccompare :: Role -> Role -> Ordering
Ord, forall x. Rep Role x -> Role
forall x. Role -> Rep Role x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Role x -> Role
$cfrom :: forall x. Role -> Rep Role x
Generic)

data Expr a
  = ExprHole a (Name Ident)
  | ExprSection a SourceToken
  | ExprIdent a (QualifiedName Ident)
  | ExprConstructor a (QualifiedName (N.ProperName 'N.ConstructorName))
  | ExprBoolean a SourceToken Bool
  | ExprChar a SourceToken Char
  | ExprString a SourceToken PSString
  | ExprNumber a SourceToken (Either Integer Double)
  | ExprArray a (Delimited (Expr a))
  | ExprRecord a (Delimited (RecordLabeled (Expr a)))
  | ExprParens a (Wrapped (Expr a))
  | ExprTyped a (Expr a) SourceToken (Type a)
  | ExprInfix a (Expr a) (Wrapped (Expr a)) (Expr a)
  | ExprOp a (Expr a) (QualifiedName (N.OpName 'N.ValueOpName)) (Expr a)
  | ExprOpName a (QualifiedName (N.OpName 'N.ValueOpName))
  | ExprNegate a SourceToken (Expr a)
  | ExprRecordAccessor a (RecordAccessor a)
  | ExprRecordUpdate a (Expr a) (DelimitedNonEmpty (RecordUpdate a))
  | ExprApp a (Expr a) (Expr a)
  | ExprVisibleTypeApp a (Expr a) SourceToken (Type a)
  | ExprLambda a (Lambda a)
  | ExprIf a (IfThenElse a)
  | ExprCase a (CaseOf a)
  | ExprLet a (LetIn a)
  | ExprDo a (DoBlock a)
  | ExprAdo a (AdoBlock a)
  deriving (Int -> Expr a -> ShowS
forall a. Show a => Int -> Expr a -> ShowS
forall a. Show a => [Expr a] -> ShowS
forall a. Show a => Expr a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expr a] -> ShowS
$cshowList :: forall a. Show a => [Expr a] -> ShowS
show :: Expr a -> String
$cshow :: forall a. Show a => Expr a -> String
showsPrec :: Int -> Expr a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Expr a -> ShowS
Show, Expr a -> Expr a -> Bool
forall a. Eq a => Expr a -> Expr a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expr a -> Expr a -> Bool
$c/= :: forall a. Eq a => Expr a -> Expr a -> Bool
== :: Expr a -> Expr a -> Bool
$c== :: forall a. Eq a => Expr a -> Expr a -> Bool
Eq, Expr a -> Expr a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Expr a)
forall a. Ord a => Expr a -> Expr a -> Bool
forall a. Ord a => Expr a -> Expr a -> Ordering
forall a. Ord a => Expr a -> Expr a -> Expr a
min :: Expr a -> Expr a -> Expr a
$cmin :: forall a. Ord a => Expr a -> Expr a -> Expr a
max :: Expr a -> Expr a -> Expr a
$cmax :: forall a. Ord a => Expr a -> Expr a -> Expr a
>= :: Expr a -> Expr a -> Bool
$c>= :: forall a. Ord a => Expr a -> Expr a -> Bool
> :: Expr a -> Expr a -> Bool
$c> :: forall a. Ord a => Expr a -> Expr a -> Bool
<= :: Expr a -> Expr a -> Bool
$c<= :: forall a. Ord a => Expr a -> Expr a -> Bool
< :: Expr a -> Expr a -> Bool
$c< :: forall a. Ord a => Expr a -> Expr a -> Bool
compare :: Expr a -> Expr a -> Ordering
$ccompare :: forall a. Ord a => Expr a -> Expr a -> Ordering
Ord, forall a b. a -> Expr b -> Expr a
forall a b. (a -> b) -> Expr a -> Expr b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Expr b -> Expr a
$c<$ :: forall a b. a -> Expr b -> Expr a
fmap :: forall a b. (a -> b) -> Expr a -> Expr b
$cfmap :: forall a b. (a -> b) -> Expr a -> Expr b
Functor, forall a. Eq a => a -> Expr a -> Bool
forall a. Num a => Expr a -> a
forall a. Ord a => Expr a -> a
forall m. Monoid m => Expr m -> m
forall a. Expr a -> Bool
forall a. Expr a -> Int
forall a. Expr a -> [a]
forall a. (a -> a -> a) -> Expr a -> a
forall m a. Monoid m => (a -> m) -> Expr a -> m
forall b a. (b -> a -> b) -> b -> Expr a -> b
forall a b. (a -> b -> b) -> b -> Expr a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Expr a -> a
$cproduct :: forall a. Num a => Expr a -> a
sum :: forall a. Num a => Expr a -> a
$csum :: forall a. Num a => Expr a -> a
minimum :: forall a. Ord a => Expr a -> a
$cminimum :: forall a. Ord a => Expr a -> a
maximum :: forall a. Ord a => Expr a -> a
$cmaximum :: forall a. Ord a => Expr a -> a
elem :: forall a. Eq a => a -> Expr a -> Bool
$celem :: forall a. Eq a => a -> Expr a -> Bool
length :: forall a. Expr a -> Int
$clength :: forall a. Expr a -> Int
null :: forall a. Expr a -> Bool
$cnull :: forall a. Expr a -> Bool
toList :: forall a. Expr a -> [a]
$ctoList :: forall a. Expr a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Expr a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Expr a -> a
foldr1 :: forall a. (a -> a -> a) -> Expr a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Expr a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Expr a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Expr a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Expr a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Expr a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Expr a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Expr a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Expr a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Expr a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Expr a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Expr a -> m
fold :: forall m. Monoid m => Expr m -> m
$cfold :: forall m. Monoid m => Expr m -> m
Foldable, Functor Expr
Foldable Expr
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 => Expr (m a) -> m (Expr a)
forall (f :: * -> *) a. Applicative f => Expr (f a) -> f (Expr a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr a -> m (Expr b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr a -> f (Expr b)
sequence :: forall (m :: * -> *) a. Monad m => Expr (m a) -> m (Expr a)
$csequence :: forall (m :: * -> *) a. Monad m => Expr (m a) -> m (Expr a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr a -> m (Expr b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Expr a -> m (Expr b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Expr (f a) -> f (Expr a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Expr (f a) -> f (Expr a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr a -> f (Expr b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Expr a -> f (Expr b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Expr a) x -> Expr a
forall a x. Expr a -> Rep (Expr a) x
$cto :: forall a x. Rep (Expr a) x -> Expr a
$cfrom :: forall a x. Expr a -> Rep (Expr a) x
Generic)

data RecordLabeled a
  = RecordPun (Name Ident)
  | RecordField Label SourceToken a
  deriving (Int -> RecordLabeled a -> ShowS
forall a. Show a => Int -> RecordLabeled a -> ShowS
forall a. Show a => [RecordLabeled a] -> ShowS
forall a. Show a => RecordLabeled a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecordLabeled a] -> ShowS
$cshowList :: forall a. Show a => [RecordLabeled a] -> ShowS
show :: RecordLabeled a -> String
$cshow :: forall a. Show a => RecordLabeled a -> String
showsPrec :: Int -> RecordLabeled a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> RecordLabeled a -> ShowS
Show, RecordLabeled a -> RecordLabeled a -> Bool
forall a. Eq a => RecordLabeled a -> RecordLabeled a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecordLabeled a -> RecordLabeled a -> Bool
$c/= :: forall a. Eq a => RecordLabeled a -> RecordLabeled a -> Bool
== :: RecordLabeled a -> RecordLabeled a -> Bool
$c== :: forall a. Eq a => RecordLabeled a -> RecordLabeled a -> Bool
Eq, RecordLabeled a -> RecordLabeled a -> Bool
RecordLabeled a -> RecordLabeled a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (RecordLabeled a)
forall a. Ord a => RecordLabeled a -> RecordLabeled a -> Bool
forall a. Ord a => RecordLabeled a -> RecordLabeled a -> Ordering
forall a.
Ord a =>
RecordLabeled a -> RecordLabeled a -> RecordLabeled a
min :: RecordLabeled a -> RecordLabeled a -> RecordLabeled a
$cmin :: forall a.
Ord a =>
RecordLabeled a -> RecordLabeled a -> RecordLabeled a
max :: RecordLabeled a -> RecordLabeled a -> RecordLabeled a
$cmax :: forall a.
Ord a =>
RecordLabeled a -> RecordLabeled a -> RecordLabeled a
>= :: RecordLabeled a -> RecordLabeled a -> Bool
$c>= :: forall a. Ord a => RecordLabeled a -> RecordLabeled a -> Bool
> :: RecordLabeled a -> RecordLabeled a -> Bool
$c> :: forall a. Ord a => RecordLabeled a -> RecordLabeled a -> Bool
<= :: RecordLabeled a -> RecordLabeled a -> Bool
$c<= :: forall a. Ord a => RecordLabeled a -> RecordLabeled a -> Bool
< :: RecordLabeled a -> RecordLabeled a -> Bool
$c< :: forall a. Ord a => RecordLabeled a -> RecordLabeled a -> Bool
compare :: RecordLabeled a -> RecordLabeled a -> Ordering
$ccompare :: forall a. Ord a => RecordLabeled a -> RecordLabeled a -> Ordering
Ord, forall a b. a -> RecordLabeled b -> RecordLabeled a
forall a b. (a -> b) -> RecordLabeled a -> RecordLabeled b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> RecordLabeled b -> RecordLabeled a
$c<$ :: forall a b. a -> RecordLabeled b -> RecordLabeled a
fmap :: forall a b. (a -> b) -> RecordLabeled a -> RecordLabeled b
$cfmap :: forall a b. (a -> b) -> RecordLabeled a -> RecordLabeled b
Functor, forall a. Eq a => a -> RecordLabeled a -> Bool
forall a. Num a => RecordLabeled a -> a
forall a. Ord a => RecordLabeled a -> a
forall m. Monoid m => RecordLabeled m -> m
forall a. RecordLabeled a -> Bool
forall a. RecordLabeled a -> Int
forall a. RecordLabeled a -> [a]
forall a. (a -> a -> a) -> RecordLabeled a -> a
forall m a. Monoid m => (a -> m) -> RecordLabeled a -> m
forall b a. (b -> a -> b) -> b -> RecordLabeled a -> b
forall a b. (a -> b -> b) -> b -> RecordLabeled a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => RecordLabeled a -> a
$cproduct :: forall a. Num a => RecordLabeled a -> a
sum :: forall a. Num a => RecordLabeled a -> a
$csum :: forall a. Num a => RecordLabeled a -> a
minimum :: forall a. Ord a => RecordLabeled a -> a
$cminimum :: forall a. Ord a => RecordLabeled a -> a
maximum :: forall a. Ord a => RecordLabeled a -> a
$cmaximum :: forall a. Ord a => RecordLabeled a -> a
elem :: forall a. Eq a => a -> RecordLabeled a -> Bool
$celem :: forall a. Eq a => a -> RecordLabeled a -> Bool
length :: forall a. RecordLabeled a -> Int
$clength :: forall a. RecordLabeled a -> Int
null :: forall a. RecordLabeled a -> Bool
$cnull :: forall a. RecordLabeled a -> Bool
toList :: forall a. RecordLabeled a -> [a]
$ctoList :: forall a. RecordLabeled a -> [a]
foldl1 :: forall a. (a -> a -> a) -> RecordLabeled a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RecordLabeled a -> a
foldr1 :: forall a. (a -> a -> a) -> RecordLabeled a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> RecordLabeled a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> RecordLabeled a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RecordLabeled a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RecordLabeled a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RecordLabeled a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RecordLabeled a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RecordLabeled a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RecordLabeled a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> RecordLabeled a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> RecordLabeled a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RecordLabeled a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RecordLabeled a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RecordLabeled a -> m
fold :: forall m. Monoid m => RecordLabeled m -> m
$cfold :: forall m. Monoid m => RecordLabeled m -> m
Foldable, Functor RecordLabeled
Foldable RecordLabeled
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 =>
RecordLabeled (m a) -> m (RecordLabeled a)
forall (f :: * -> *) a.
Applicative f =>
RecordLabeled (f a) -> f (RecordLabeled a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordLabeled a -> m (RecordLabeled b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordLabeled a -> f (RecordLabeled b)
sequence :: forall (m :: * -> *) a.
Monad m =>
RecordLabeled (m a) -> m (RecordLabeled a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
RecordLabeled (m a) -> m (RecordLabeled a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordLabeled a -> m (RecordLabeled b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordLabeled a -> m (RecordLabeled b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RecordLabeled (f a) -> f (RecordLabeled a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
RecordLabeled (f a) -> f (RecordLabeled a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordLabeled a -> f (RecordLabeled b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordLabeled a -> f (RecordLabeled b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (RecordLabeled a) x -> RecordLabeled a
forall a x. RecordLabeled a -> Rep (RecordLabeled a) x
$cto :: forall a x. Rep (RecordLabeled a) x -> RecordLabeled a
$cfrom :: forall a x. RecordLabeled a -> Rep (RecordLabeled a) x
Generic)

data RecordUpdate a
  = RecordUpdateLeaf Label SourceToken (Expr a)
  | RecordUpdateBranch Label (DelimitedNonEmpty (RecordUpdate a))
  deriving (Int -> RecordUpdate a -> ShowS
forall a. Show a => Int -> RecordUpdate a -> ShowS
forall a. Show a => [RecordUpdate a] -> ShowS
forall a. Show a => RecordUpdate a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecordUpdate a] -> ShowS
$cshowList :: forall a. Show a => [RecordUpdate a] -> ShowS
show :: RecordUpdate a -> String
$cshow :: forall a. Show a => RecordUpdate a -> String
showsPrec :: Int -> RecordUpdate a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> RecordUpdate a -> ShowS
Show, RecordUpdate a -> RecordUpdate a -> Bool
forall a. Eq a => RecordUpdate a -> RecordUpdate a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecordUpdate a -> RecordUpdate a -> Bool
$c/= :: forall a. Eq a => RecordUpdate a -> RecordUpdate a -> Bool
== :: RecordUpdate a -> RecordUpdate a -> Bool
$c== :: forall a. Eq a => RecordUpdate a -> RecordUpdate a -> Bool
Eq, RecordUpdate a -> RecordUpdate a -> Bool
RecordUpdate a -> RecordUpdate a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (RecordUpdate a)
forall a. Ord a => RecordUpdate a -> RecordUpdate a -> Bool
forall a. Ord a => RecordUpdate a -> RecordUpdate a -> Ordering
forall a.
Ord a =>
RecordUpdate a -> RecordUpdate a -> RecordUpdate a
min :: RecordUpdate a -> RecordUpdate a -> RecordUpdate a
$cmin :: forall a.
Ord a =>
RecordUpdate a -> RecordUpdate a -> RecordUpdate a
max :: RecordUpdate a -> RecordUpdate a -> RecordUpdate a
$cmax :: forall a.
Ord a =>
RecordUpdate a -> RecordUpdate a -> RecordUpdate a
>= :: RecordUpdate a -> RecordUpdate a -> Bool
$c>= :: forall a. Ord a => RecordUpdate a -> RecordUpdate a -> Bool
> :: RecordUpdate a -> RecordUpdate a -> Bool
$c> :: forall a. Ord a => RecordUpdate a -> RecordUpdate a -> Bool
<= :: RecordUpdate a -> RecordUpdate a -> Bool
$c<= :: forall a. Ord a => RecordUpdate a -> RecordUpdate a -> Bool
< :: RecordUpdate a -> RecordUpdate a -> Bool
$c< :: forall a. Ord a => RecordUpdate a -> RecordUpdate a -> Bool
compare :: RecordUpdate a -> RecordUpdate a -> Ordering
$ccompare :: forall a. Ord a => RecordUpdate a -> RecordUpdate a -> Ordering
Ord, forall a b. a -> RecordUpdate b -> RecordUpdate a
forall a b. (a -> b) -> RecordUpdate a -> RecordUpdate b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> RecordUpdate b -> RecordUpdate a
$c<$ :: forall a b. a -> RecordUpdate b -> RecordUpdate a
fmap :: forall a b. (a -> b) -> RecordUpdate a -> RecordUpdate b
$cfmap :: forall a b. (a -> b) -> RecordUpdate a -> RecordUpdate b
Functor, forall a. Eq a => a -> RecordUpdate a -> Bool
forall a. Num a => RecordUpdate a -> a
forall a. Ord a => RecordUpdate a -> a
forall m. Monoid m => RecordUpdate m -> m
forall a. RecordUpdate a -> Bool
forall a. RecordUpdate a -> Int
forall a. RecordUpdate a -> [a]
forall a. (a -> a -> a) -> RecordUpdate a -> a
forall m a. Monoid m => (a -> m) -> RecordUpdate a -> m
forall b a. (b -> a -> b) -> b -> RecordUpdate a -> b
forall a b. (a -> b -> b) -> b -> RecordUpdate a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => RecordUpdate a -> a
$cproduct :: forall a. Num a => RecordUpdate a -> a
sum :: forall a. Num a => RecordUpdate a -> a
$csum :: forall a. Num a => RecordUpdate a -> a
minimum :: forall a. Ord a => RecordUpdate a -> a
$cminimum :: forall a. Ord a => RecordUpdate a -> a
maximum :: forall a. Ord a => RecordUpdate a -> a
$cmaximum :: forall a. Ord a => RecordUpdate a -> a
elem :: forall a. Eq a => a -> RecordUpdate a -> Bool
$celem :: forall a. Eq a => a -> RecordUpdate a -> Bool
length :: forall a. RecordUpdate a -> Int
$clength :: forall a. RecordUpdate a -> Int
null :: forall a. RecordUpdate a -> Bool
$cnull :: forall a. RecordUpdate a -> Bool
toList :: forall a. RecordUpdate a -> [a]
$ctoList :: forall a. RecordUpdate a -> [a]
foldl1 :: forall a. (a -> a -> a) -> RecordUpdate a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RecordUpdate a -> a
foldr1 :: forall a. (a -> a -> a) -> RecordUpdate a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> RecordUpdate a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> RecordUpdate a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RecordUpdate a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RecordUpdate a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RecordUpdate a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RecordUpdate a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RecordUpdate a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RecordUpdate a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> RecordUpdate a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> RecordUpdate a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RecordUpdate a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RecordUpdate a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RecordUpdate a -> m
fold :: forall m. Monoid m => RecordUpdate m -> m
$cfold :: forall m. Monoid m => RecordUpdate m -> m
Foldable, Functor RecordUpdate
Foldable RecordUpdate
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 =>
RecordUpdate (m a) -> m (RecordUpdate a)
forall (f :: * -> *) a.
Applicative f =>
RecordUpdate (f a) -> f (RecordUpdate a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordUpdate a -> m (RecordUpdate b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordUpdate a -> f (RecordUpdate b)
sequence :: forall (m :: * -> *) a.
Monad m =>
RecordUpdate (m a) -> m (RecordUpdate a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
RecordUpdate (m a) -> m (RecordUpdate a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordUpdate a -> m (RecordUpdate b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordUpdate a -> m (RecordUpdate b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RecordUpdate (f a) -> f (RecordUpdate a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
RecordUpdate (f a) -> f (RecordUpdate a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordUpdate a -> f (RecordUpdate b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordUpdate a -> f (RecordUpdate b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (RecordUpdate a) x -> RecordUpdate a
forall a x. RecordUpdate a -> Rep (RecordUpdate a) x
$cto :: forall a x. Rep (RecordUpdate a) x -> RecordUpdate a
$cfrom :: forall a x. RecordUpdate a -> Rep (RecordUpdate a) x
Generic)

data RecordAccessor a = RecordAccessor
  { forall a. RecordAccessor a -> Expr a
recExpr :: Expr a
  , forall a. RecordAccessor a -> SourceToken
recDot :: SourceToken
  , forall a. RecordAccessor a -> Separated Label
recPath :: Separated Label
  } deriving (Int -> RecordAccessor a -> ShowS
forall a. Show a => Int -> RecordAccessor a -> ShowS
forall a. Show a => [RecordAccessor a] -> ShowS
forall a. Show a => RecordAccessor a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecordAccessor a] -> ShowS
$cshowList :: forall a. Show a => [RecordAccessor a] -> ShowS
show :: RecordAccessor a -> String
$cshow :: forall a. Show a => RecordAccessor a -> String
showsPrec :: Int -> RecordAccessor a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> RecordAccessor a -> ShowS
Show, RecordAccessor a -> RecordAccessor a -> Bool
forall a. Eq a => RecordAccessor a -> RecordAccessor a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecordAccessor a -> RecordAccessor a -> Bool
$c/= :: forall a. Eq a => RecordAccessor a -> RecordAccessor a -> Bool
== :: RecordAccessor a -> RecordAccessor a -> Bool
$c== :: forall a. Eq a => RecordAccessor a -> RecordAccessor a -> Bool
Eq, RecordAccessor a -> RecordAccessor a -> Bool
RecordAccessor a -> RecordAccessor a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (RecordAccessor a)
forall a. Ord a => RecordAccessor a -> RecordAccessor a -> Bool
forall a. Ord a => RecordAccessor a -> RecordAccessor a -> Ordering
forall a.
Ord a =>
RecordAccessor a -> RecordAccessor a -> RecordAccessor a
min :: RecordAccessor a -> RecordAccessor a -> RecordAccessor a
$cmin :: forall a.
Ord a =>
RecordAccessor a -> RecordAccessor a -> RecordAccessor a
max :: RecordAccessor a -> RecordAccessor a -> RecordAccessor a
$cmax :: forall a.
Ord a =>
RecordAccessor a -> RecordAccessor a -> RecordAccessor a
>= :: RecordAccessor a -> RecordAccessor a -> Bool
$c>= :: forall a. Ord a => RecordAccessor a -> RecordAccessor a -> Bool
> :: RecordAccessor a -> RecordAccessor a -> Bool
$c> :: forall a. Ord a => RecordAccessor a -> RecordAccessor a -> Bool
<= :: RecordAccessor a -> RecordAccessor a -> Bool
$c<= :: forall a. Ord a => RecordAccessor a -> RecordAccessor a -> Bool
< :: RecordAccessor a -> RecordAccessor a -> Bool
$c< :: forall a. Ord a => RecordAccessor a -> RecordAccessor a -> Bool
compare :: RecordAccessor a -> RecordAccessor a -> Ordering
$ccompare :: forall a. Ord a => RecordAccessor a -> RecordAccessor a -> Ordering
Ord, forall a b. a -> RecordAccessor b -> RecordAccessor a
forall a b. (a -> b) -> RecordAccessor a -> RecordAccessor b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> RecordAccessor b -> RecordAccessor a
$c<$ :: forall a b. a -> RecordAccessor b -> RecordAccessor a
fmap :: forall a b. (a -> b) -> RecordAccessor a -> RecordAccessor b
$cfmap :: forall a b. (a -> b) -> RecordAccessor a -> RecordAccessor b
Functor, forall a. Eq a => a -> RecordAccessor a -> Bool
forall a. Num a => RecordAccessor a -> a
forall a. Ord a => RecordAccessor a -> a
forall m. Monoid m => RecordAccessor m -> m
forall a. RecordAccessor a -> Bool
forall a. RecordAccessor a -> Int
forall a. RecordAccessor a -> [a]
forall a. (a -> a -> a) -> RecordAccessor a -> a
forall m a. Monoid m => (a -> m) -> RecordAccessor a -> m
forall b a. (b -> a -> b) -> b -> RecordAccessor a -> b
forall a b. (a -> b -> b) -> b -> RecordAccessor a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => RecordAccessor a -> a
$cproduct :: forall a. Num a => RecordAccessor a -> a
sum :: forall a. Num a => RecordAccessor a -> a
$csum :: forall a. Num a => RecordAccessor a -> a
minimum :: forall a. Ord a => RecordAccessor a -> a
$cminimum :: forall a. Ord a => RecordAccessor a -> a
maximum :: forall a. Ord a => RecordAccessor a -> a
$cmaximum :: forall a. Ord a => RecordAccessor a -> a
elem :: forall a. Eq a => a -> RecordAccessor a -> Bool
$celem :: forall a. Eq a => a -> RecordAccessor a -> Bool
length :: forall a. RecordAccessor a -> Int
$clength :: forall a. RecordAccessor a -> Int
null :: forall a. RecordAccessor a -> Bool
$cnull :: forall a. RecordAccessor a -> Bool
toList :: forall a. RecordAccessor a -> [a]
$ctoList :: forall a. RecordAccessor a -> [a]
foldl1 :: forall a. (a -> a -> a) -> RecordAccessor a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> RecordAccessor a -> a
foldr1 :: forall a. (a -> a -> a) -> RecordAccessor a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> RecordAccessor a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> RecordAccessor a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> RecordAccessor a -> b
foldl :: forall b a. (b -> a -> b) -> b -> RecordAccessor a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> RecordAccessor a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> RecordAccessor a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> RecordAccessor a -> b
foldr :: forall a b. (a -> b -> b) -> b -> RecordAccessor a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> RecordAccessor a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> RecordAccessor a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> RecordAccessor a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> RecordAccessor a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> RecordAccessor a -> m
fold :: forall m. Monoid m => RecordAccessor m -> m
$cfold :: forall m. Monoid m => RecordAccessor m -> m
Foldable, Functor RecordAccessor
Foldable RecordAccessor
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 =>
RecordAccessor (m a) -> m (RecordAccessor a)
forall (f :: * -> *) a.
Applicative f =>
RecordAccessor (f a) -> f (RecordAccessor a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordAccessor a -> m (RecordAccessor b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordAccessor a -> f (RecordAccessor b)
sequence :: forall (m :: * -> *) a.
Monad m =>
RecordAccessor (m a) -> m (RecordAccessor a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
RecordAccessor (m a) -> m (RecordAccessor a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordAccessor a -> m (RecordAccessor b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> RecordAccessor a -> m (RecordAccessor b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
RecordAccessor (f a) -> f (RecordAccessor a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
RecordAccessor (f a) -> f (RecordAccessor a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordAccessor a -> f (RecordAccessor b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> RecordAccessor a -> f (RecordAccessor b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (RecordAccessor a) x -> RecordAccessor a
forall a x. RecordAccessor a -> Rep (RecordAccessor a) x
$cto :: forall a x. Rep (RecordAccessor a) x -> RecordAccessor a
$cfrom :: forall a x. RecordAccessor a -> Rep (RecordAccessor a) x
Generic)

data Lambda a = Lambda
  { forall a. Lambda a -> SourceToken
lmbSymbol :: SourceToken
  , forall a. Lambda a -> NonEmpty (Binder a)
lmbBinders :: NonEmpty (Binder a)
  , forall a. Lambda a -> SourceToken
lmbArr :: SourceToken
  , forall a. Lambda a -> Expr a
lmbBody :: Expr a
  } deriving (Int -> Lambda a -> ShowS
forall a. Show a => Int -> Lambda a -> ShowS
forall a. Show a => [Lambda a] -> ShowS
forall a. Show a => Lambda a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lambda a] -> ShowS
$cshowList :: forall a. Show a => [Lambda a] -> ShowS
show :: Lambda a -> String
$cshow :: forall a. Show a => Lambda a -> String
showsPrec :: Int -> Lambda a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Lambda a -> ShowS
Show, Lambda a -> Lambda a -> Bool
forall a. Eq a => Lambda a -> Lambda a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lambda a -> Lambda a -> Bool
$c/= :: forall a. Eq a => Lambda a -> Lambda a -> Bool
== :: Lambda a -> Lambda a -> Bool
$c== :: forall a. Eq a => Lambda a -> Lambda a -> Bool
Eq, Lambda a -> Lambda a -> Bool
Lambda a -> Lambda a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Lambda a)
forall a. Ord a => Lambda a -> Lambda a -> Bool
forall a. Ord a => Lambda a -> Lambda a -> Ordering
forall a. Ord a => Lambda a -> Lambda a -> Lambda a
min :: Lambda a -> Lambda a -> Lambda a
$cmin :: forall a. Ord a => Lambda a -> Lambda a -> Lambda a
max :: Lambda a -> Lambda a -> Lambda a
$cmax :: forall a. Ord a => Lambda a -> Lambda a -> Lambda a
>= :: Lambda a -> Lambda a -> Bool
$c>= :: forall a. Ord a => Lambda a -> Lambda a -> Bool
> :: Lambda a -> Lambda a -> Bool
$c> :: forall a. Ord a => Lambda a -> Lambda a -> Bool
<= :: Lambda a -> Lambda a -> Bool
$c<= :: forall a. Ord a => Lambda a -> Lambda a -> Bool
< :: Lambda a -> Lambda a -> Bool
$c< :: forall a. Ord a => Lambda a -> Lambda a -> Bool
compare :: Lambda a -> Lambda a -> Ordering
$ccompare :: forall a. Ord a => Lambda a -> Lambda a -> Ordering
Ord, forall a b. a -> Lambda b -> Lambda a
forall a b. (a -> b) -> Lambda a -> Lambda b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Lambda b -> Lambda a
$c<$ :: forall a b. a -> Lambda b -> Lambda a
fmap :: forall a b. (a -> b) -> Lambda a -> Lambda b
$cfmap :: forall a b. (a -> b) -> Lambda a -> Lambda b
Functor, forall a. Eq a => a -> Lambda a -> Bool
forall a. Num a => Lambda a -> a
forall a. Ord a => Lambda a -> a
forall m. Monoid m => Lambda m -> m
forall a. Lambda a -> Bool
forall a. Lambda a -> Int
forall a. Lambda a -> [a]
forall a. (a -> a -> a) -> Lambda a -> a
forall m a. Monoid m => (a -> m) -> Lambda a -> m
forall b a. (b -> a -> b) -> b -> Lambda a -> b
forall a b. (a -> b -> b) -> b -> Lambda a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Lambda a -> a
$cproduct :: forall a. Num a => Lambda a -> a
sum :: forall a. Num a => Lambda a -> a
$csum :: forall a. Num a => Lambda a -> a
minimum :: forall a. Ord a => Lambda a -> a
$cminimum :: forall a. Ord a => Lambda a -> a
maximum :: forall a. Ord a => Lambda a -> a
$cmaximum :: forall a. Ord a => Lambda a -> a
elem :: forall a. Eq a => a -> Lambda a -> Bool
$celem :: forall a. Eq a => a -> Lambda a -> Bool
length :: forall a. Lambda a -> Int
$clength :: forall a. Lambda a -> Int
null :: forall a. Lambda a -> Bool
$cnull :: forall a. Lambda a -> Bool
toList :: forall a. Lambda a -> [a]
$ctoList :: forall a. Lambda a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Lambda a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Lambda a -> a
foldr1 :: forall a. (a -> a -> a) -> Lambda a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Lambda a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Lambda a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Lambda a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Lambda a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Lambda a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Lambda a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Lambda a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Lambda a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Lambda a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Lambda a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Lambda a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Lambda a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Lambda a -> m
fold :: forall m. Monoid m => Lambda m -> m
$cfold :: forall m. Monoid m => Lambda m -> m
Foldable, Functor Lambda
Foldable Lambda
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 => Lambda (m a) -> m (Lambda a)
forall (f :: * -> *) a.
Applicative f =>
Lambda (f a) -> f (Lambda a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Lambda a -> m (Lambda b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Lambda a -> f (Lambda b)
sequence :: forall (m :: * -> *) a. Monad m => Lambda (m a) -> m (Lambda a)
$csequence :: forall (m :: * -> *) a. Monad m => Lambda (m a) -> m (Lambda a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Lambda a -> m (Lambda b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Lambda a -> m (Lambda b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Lambda (f a) -> f (Lambda a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Lambda (f a) -> f (Lambda a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Lambda a -> f (Lambda b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Lambda a -> f (Lambda b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Lambda a) x -> Lambda a
forall a x. Lambda a -> Rep (Lambda a) x
$cto :: forall a x. Rep (Lambda a) x -> Lambda a
$cfrom :: forall a x. Lambda a -> Rep (Lambda a) x
Generic)

data IfThenElse a = IfThenElse
  { forall a. IfThenElse a -> SourceToken
iteIf :: SourceToken
  , forall a. IfThenElse a -> Expr a
iteCond :: Expr a
  , forall a. IfThenElse a -> SourceToken
iteThen :: SourceToken
  , forall a. IfThenElse a -> Expr a
iteTrue :: Expr a
  , forall a. IfThenElse a -> SourceToken
iteElse :: SourceToken
  , forall a. IfThenElse a -> Expr a
iteFalse :: Expr a
  } deriving (Int -> IfThenElse a -> ShowS
forall a. Show a => Int -> IfThenElse a -> ShowS
forall a. Show a => [IfThenElse a] -> ShowS
forall a. Show a => IfThenElse a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IfThenElse a] -> ShowS
$cshowList :: forall a. Show a => [IfThenElse a] -> ShowS
show :: IfThenElse a -> String
$cshow :: forall a. Show a => IfThenElse a -> String
showsPrec :: Int -> IfThenElse a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> IfThenElse a -> ShowS
Show, IfThenElse a -> IfThenElse a -> Bool
forall a. Eq a => IfThenElse a -> IfThenElse a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IfThenElse a -> IfThenElse a -> Bool
$c/= :: forall a. Eq a => IfThenElse a -> IfThenElse a -> Bool
== :: IfThenElse a -> IfThenElse a -> Bool
$c== :: forall a. Eq a => IfThenElse a -> IfThenElse a -> Bool
Eq, IfThenElse a -> IfThenElse a -> Bool
IfThenElse a -> IfThenElse a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (IfThenElse a)
forall a. Ord a => IfThenElse a -> IfThenElse a -> Bool
forall a. Ord a => IfThenElse a -> IfThenElse a -> Ordering
forall a. Ord a => IfThenElse a -> IfThenElse a -> IfThenElse a
min :: IfThenElse a -> IfThenElse a -> IfThenElse a
$cmin :: forall a. Ord a => IfThenElse a -> IfThenElse a -> IfThenElse a
max :: IfThenElse a -> IfThenElse a -> IfThenElse a
$cmax :: forall a. Ord a => IfThenElse a -> IfThenElse a -> IfThenElse a
>= :: IfThenElse a -> IfThenElse a -> Bool
$c>= :: forall a. Ord a => IfThenElse a -> IfThenElse a -> Bool
> :: IfThenElse a -> IfThenElse a -> Bool
$c> :: forall a. Ord a => IfThenElse a -> IfThenElse a -> Bool
<= :: IfThenElse a -> IfThenElse a -> Bool
$c<= :: forall a. Ord a => IfThenElse a -> IfThenElse a -> Bool
< :: IfThenElse a -> IfThenElse a -> Bool
$c< :: forall a. Ord a => IfThenElse a -> IfThenElse a -> Bool
compare :: IfThenElse a -> IfThenElse a -> Ordering
$ccompare :: forall a. Ord a => IfThenElse a -> IfThenElse a -> Ordering
Ord, forall a b. a -> IfThenElse b -> IfThenElse a
forall a b. (a -> b) -> IfThenElse a -> IfThenElse b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> IfThenElse b -> IfThenElse a
$c<$ :: forall a b. a -> IfThenElse b -> IfThenElse a
fmap :: forall a b. (a -> b) -> IfThenElse a -> IfThenElse b
$cfmap :: forall a b. (a -> b) -> IfThenElse a -> IfThenElse b
Functor, forall a. Eq a => a -> IfThenElse a -> Bool
forall a. Num a => IfThenElse a -> a
forall a. Ord a => IfThenElse a -> a
forall m. Monoid m => IfThenElse m -> m
forall a. IfThenElse a -> Bool
forall a. IfThenElse a -> Int
forall a. IfThenElse a -> [a]
forall a. (a -> a -> a) -> IfThenElse a -> a
forall m a. Monoid m => (a -> m) -> IfThenElse a -> m
forall b a. (b -> a -> b) -> b -> IfThenElse a -> b
forall a b. (a -> b -> b) -> b -> IfThenElse a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => IfThenElse a -> a
$cproduct :: forall a. Num a => IfThenElse a -> a
sum :: forall a. Num a => IfThenElse a -> a
$csum :: forall a. Num a => IfThenElse a -> a
minimum :: forall a. Ord a => IfThenElse a -> a
$cminimum :: forall a. Ord a => IfThenElse a -> a
maximum :: forall a. Ord a => IfThenElse a -> a
$cmaximum :: forall a. Ord a => IfThenElse a -> a
elem :: forall a. Eq a => a -> IfThenElse a -> Bool
$celem :: forall a. Eq a => a -> IfThenElse a -> Bool
length :: forall a. IfThenElse a -> Int
$clength :: forall a. IfThenElse a -> Int
null :: forall a. IfThenElse a -> Bool
$cnull :: forall a. IfThenElse a -> Bool
toList :: forall a. IfThenElse a -> [a]
$ctoList :: forall a. IfThenElse a -> [a]
foldl1 :: forall a. (a -> a -> a) -> IfThenElse a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> IfThenElse a -> a
foldr1 :: forall a. (a -> a -> a) -> IfThenElse a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> IfThenElse a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> IfThenElse a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> IfThenElse a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IfThenElse a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> IfThenElse a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IfThenElse a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> IfThenElse a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IfThenElse a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> IfThenElse a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> IfThenElse a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> IfThenElse a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IfThenElse a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> IfThenElse a -> m
fold :: forall m. Monoid m => IfThenElse m -> m
$cfold :: forall m. Monoid m => IfThenElse m -> m
Foldable, Functor IfThenElse
Foldable IfThenElse
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 =>
IfThenElse (m a) -> m (IfThenElse a)
forall (f :: * -> *) a.
Applicative f =>
IfThenElse (f a) -> f (IfThenElse a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IfThenElse a -> m (IfThenElse b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IfThenElse a -> f (IfThenElse b)
sequence :: forall (m :: * -> *) a.
Monad m =>
IfThenElse (m a) -> m (IfThenElse a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
IfThenElse (m a) -> m (IfThenElse a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IfThenElse a -> m (IfThenElse b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IfThenElse a -> m (IfThenElse b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IfThenElse (f a) -> f (IfThenElse a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
IfThenElse (f a) -> f (IfThenElse a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IfThenElse a -> f (IfThenElse b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IfThenElse a -> f (IfThenElse b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (IfThenElse a) x -> IfThenElse a
forall a x. IfThenElse a -> Rep (IfThenElse a) x
$cto :: forall a x. Rep (IfThenElse a) x -> IfThenElse a
$cfrom :: forall a x. IfThenElse a -> Rep (IfThenElse a) x
Generic)

data CaseOf a = CaseOf
  { forall a. CaseOf a -> SourceToken
caseKeyword :: SourceToken
  , forall a. CaseOf a -> Separated (Expr a)
caseHead :: Separated (Expr a)
  , forall a. CaseOf a -> SourceToken
caseOf :: SourceToken
  , forall a. CaseOf a -> NonEmpty (Separated (Binder a), Guarded a)
caseBranches :: NonEmpty (Separated (Binder a), Guarded a)
  } deriving (Int -> CaseOf a -> ShowS
forall a. Show a => Int -> CaseOf a -> ShowS
forall a. Show a => [CaseOf a] -> ShowS
forall a. Show a => CaseOf a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CaseOf a] -> ShowS
$cshowList :: forall a. Show a => [CaseOf a] -> ShowS
show :: CaseOf a -> String
$cshow :: forall a. Show a => CaseOf a -> String
showsPrec :: Int -> CaseOf a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> CaseOf a -> ShowS
Show, CaseOf a -> CaseOf a -> Bool
forall a. Eq a => CaseOf a -> CaseOf a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CaseOf a -> CaseOf a -> Bool
$c/= :: forall a. Eq a => CaseOf a -> CaseOf a -> Bool
== :: CaseOf a -> CaseOf a -> Bool
$c== :: forall a. Eq a => CaseOf a -> CaseOf a -> Bool
Eq, CaseOf a -> CaseOf a -> Bool
CaseOf a -> CaseOf a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (CaseOf a)
forall a. Ord a => CaseOf a -> CaseOf a -> Bool
forall a. Ord a => CaseOf a -> CaseOf a -> Ordering
forall a. Ord a => CaseOf a -> CaseOf a -> CaseOf a
min :: CaseOf a -> CaseOf a -> CaseOf a
$cmin :: forall a. Ord a => CaseOf a -> CaseOf a -> CaseOf a
max :: CaseOf a -> CaseOf a -> CaseOf a
$cmax :: forall a. Ord a => CaseOf a -> CaseOf a -> CaseOf a
>= :: CaseOf a -> CaseOf a -> Bool
$c>= :: forall a. Ord a => CaseOf a -> CaseOf a -> Bool
> :: CaseOf a -> CaseOf a -> Bool
$c> :: forall a. Ord a => CaseOf a -> CaseOf a -> Bool
<= :: CaseOf a -> CaseOf a -> Bool
$c<= :: forall a. Ord a => CaseOf a -> CaseOf a -> Bool
< :: CaseOf a -> CaseOf a -> Bool
$c< :: forall a. Ord a => CaseOf a -> CaseOf a -> Bool
compare :: CaseOf a -> CaseOf a -> Ordering
$ccompare :: forall a. Ord a => CaseOf a -> CaseOf a -> Ordering
Ord, forall a b. a -> CaseOf b -> CaseOf a
forall a b. (a -> b) -> CaseOf a -> CaseOf b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> CaseOf b -> CaseOf a
$c<$ :: forall a b. a -> CaseOf b -> CaseOf a
fmap :: forall a b. (a -> b) -> CaseOf a -> CaseOf b
$cfmap :: forall a b. (a -> b) -> CaseOf a -> CaseOf b
Functor, forall a. Eq a => a -> CaseOf a -> Bool
forall a. Num a => CaseOf a -> a
forall a. Ord a => CaseOf a -> a
forall m. Monoid m => CaseOf m -> m
forall a. CaseOf a -> Bool
forall a. CaseOf a -> Int
forall a. CaseOf a -> [a]
forall a. (a -> a -> a) -> CaseOf a -> a
forall m a. Monoid m => (a -> m) -> CaseOf a -> m
forall b a. (b -> a -> b) -> b -> CaseOf a -> b
forall a b. (a -> b -> b) -> b -> CaseOf a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => CaseOf a -> a
$cproduct :: forall a. Num a => CaseOf a -> a
sum :: forall a. Num a => CaseOf a -> a
$csum :: forall a. Num a => CaseOf a -> a
minimum :: forall a. Ord a => CaseOf a -> a
$cminimum :: forall a. Ord a => CaseOf a -> a
maximum :: forall a. Ord a => CaseOf a -> a
$cmaximum :: forall a. Ord a => CaseOf a -> a
elem :: forall a. Eq a => a -> CaseOf a -> Bool
$celem :: forall a. Eq a => a -> CaseOf a -> Bool
length :: forall a. CaseOf a -> Int
$clength :: forall a. CaseOf a -> Int
null :: forall a. CaseOf a -> Bool
$cnull :: forall a. CaseOf a -> Bool
toList :: forall a. CaseOf a -> [a]
$ctoList :: forall a. CaseOf a -> [a]
foldl1 :: forall a. (a -> a -> a) -> CaseOf a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> CaseOf a -> a
foldr1 :: forall a. (a -> a -> a) -> CaseOf a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> CaseOf a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> CaseOf a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> CaseOf a -> b
foldl :: forall b a. (b -> a -> b) -> b -> CaseOf a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> CaseOf a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> CaseOf a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> CaseOf a -> b
foldr :: forall a b. (a -> b -> b) -> b -> CaseOf a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> CaseOf a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> CaseOf a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> CaseOf a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> CaseOf a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> CaseOf a -> m
fold :: forall m. Monoid m => CaseOf m -> m
$cfold :: forall m. Monoid m => CaseOf m -> m
Foldable, Functor CaseOf
Foldable CaseOf
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 => CaseOf (m a) -> m (CaseOf a)
forall (f :: * -> *) a.
Applicative f =>
CaseOf (f a) -> f (CaseOf a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseOf a -> m (CaseOf b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseOf a -> f (CaseOf b)
sequence :: forall (m :: * -> *) a. Monad m => CaseOf (m a) -> m (CaseOf a)
$csequence :: forall (m :: * -> *) a. Monad m => CaseOf (m a) -> m (CaseOf a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseOf a -> m (CaseOf b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CaseOf a -> m (CaseOf b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CaseOf (f a) -> f (CaseOf a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
CaseOf (f a) -> f (CaseOf a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseOf a -> f (CaseOf b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CaseOf a -> f (CaseOf b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (CaseOf a) x -> CaseOf a
forall a x. CaseOf a -> Rep (CaseOf a) x
$cto :: forall a x. Rep (CaseOf a) x -> CaseOf a
$cfrom :: forall a x. CaseOf a -> Rep (CaseOf a) x
Generic)

data LetIn a = LetIn
  { forall a. LetIn a -> SourceToken
letKeyword :: SourceToken
  , forall a. LetIn a -> NonEmpty (LetBinding a)
letBindings :: NonEmpty (LetBinding a)
  , forall a. LetIn a -> SourceToken
letIn :: SourceToken
  , forall a. LetIn a -> Expr a
letBody :: Expr a
  } deriving (Int -> LetIn a -> ShowS
forall a. Show a => Int -> LetIn a -> ShowS
forall a. Show a => [LetIn a] -> ShowS
forall a. Show a => LetIn a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LetIn a] -> ShowS
$cshowList :: forall a. Show a => [LetIn a] -> ShowS
show :: LetIn a -> String
$cshow :: forall a. Show a => LetIn a -> String
showsPrec :: Int -> LetIn a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> LetIn a -> ShowS
Show, LetIn a -> LetIn a -> Bool
forall a. Eq a => LetIn a -> LetIn a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LetIn a -> LetIn a -> Bool
$c/= :: forall a. Eq a => LetIn a -> LetIn a -> Bool
== :: LetIn a -> LetIn a -> Bool
$c== :: forall a. Eq a => LetIn a -> LetIn a -> Bool
Eq, LetIn a -> LetIn a -> Bool
LetIn a -> LetIn a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (LetIn a)
forall a. Ord a => LetIn a -> LetIn a -> Bool
forall a. Ord a => LetIn a -> LetIn a -> Ordering
forall a. Ord a => LetIn a -> LetIn a -> LetIn a
min :: LetIn a -> LetIn a -> LetIn a
$cmin :: forall a. Ord a => LetIn a -> LetIn a -> LetIn a
max :: LetIn a -> LetIn a -> LetIn a
$cmax :: forall a. Ord a => LetIn a -> LetIn a -> LetIn a
>= :: LetIn a -> LetIn a -> Bool
$c>= :: forall a. Ord a => LetIn a -> LetIn a -> Bool
> :: LetIn a -> LetIn a -> Bool
$c> :: forall a. Ord a => LetIn a -> LetIn a -> Bool
<= :: LetIn a -> LetIn a -> Bool
$c<= :: forall a. Ord a => LetIn a -> LetIn a -> Bool
< :: LetIn a -> LetIn a -> Bool
$c< :: forall a. Ord a => LetIn a -> LetIn a -> Bool
compare :: LetIn a -> LetIn a -> Ordering
$ccompare :: forall a. Ord a => LetIn a -> LetIn a -> Ordering
Ord, forall a b. a -> LetIn b -> LetIn a
forall a b. (a -> b) -> LetIn a -> LetIn b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> LetIn b -> LetIn a
$c<$ :: forall a b. a -> LetIn b -> LetIn a
fmap :: forall a b. (a -> b) -> LetIn a -> LetIn b
$cfmap :: forall a b. (a -> b) -> LetIn a -> LetIn b
Functor, forall a. Eq a => a -> LetIn a -> Bool
forall a. Num a => LetIn a -> a
forall a. Ord a => LetIn a -> a
forall m. Monoid m => LetIn m -> m
forall a. LetIn a -> Bool
forall a. LetIn a -> Int
forall a. LetIn a -> [a]
forall a. (a -> a -> a) -> LetIn a -> a
forall m a. Monoid m => (a -> m) -> LetIn a -> m
forall b a. (b -> a -> b) -> b -> LetIn a -> b
forall a b. (a -> b -> b) -> b -> LetIn a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => LetIn a -> a
$cproduct :: forall a. Num a => LetIn a -> a
sum :: forall a. Num a => LetIn a -> a
$csum :: forall a. Num a => LetIn a -> a
minimum :: forall a. Ord a => LetIn a -> a
$cminimum :: forall a. Ord a => LetIn a -> a
maximum :: forall a. Ord a => LetIn a -> a
$cmaximum :: forall a. Ord a => LetIn a -> a
elem :: forall a. Eq a => a -> LetIn a -> Bool
$celem :: forall a. Eq a => a -> LetIn a -> Bool
length :: forall a. LetIn a -> Int
$clength :: forall a. LetIn a -> Int
null :: forall a. LetIn a -> Bool
$cnull :: forall a. LetIn a -> Bool
toList :: forall a. LetIn a -> [a]
$ctoList :: forall a. LetIn a -> [a]
foldl1 :: forall a. (a -> a -> a) -> LetIn a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> LetIn a -> a
foldr1 :: forall a. (a -> a -> a) -> LetIn a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> LetIn a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> LetIn a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> LetIn a -> b
foldl :: forall b a. (b -> a -> b) -> b -> LetIn a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> LetIn a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> LetIn a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> LetIn a -> b
foldr :: forall a b. (a -> b -> b) -> b -> LetIn a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> LetIn a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> LetIn a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> LetIn a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> LetIn a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> LetIn a -> m
fold :: forall m. Monoid m => LetIn m -> m
$cfold :: forall m. Monoid m => LetIn m -> m
Foldable, Functor LetIn
Foldable LetIn
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 => LetIn (m a) -> m (LetIn a)
forall (f :: * -> *) a. Applicative f => LetIn (f a) -> f (LetIn a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LetIn a -> m (LetIn b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LetIn a -> f (LetIn b)
sequence :: forall (m :: * -> *) a. Monad m => LetIn (m a) -> m (LetIn a)
$csequence :: forall (m :: * -> *) a. Monad m => LetIn (m a) -> m (LetIn a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LetIn a -> m (LetIn b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LetIn a -> m (LetIn b)
sequenceA :: forall (f :: * -> *) a. Applicative f => LetIn (f a) -> f (LetIn a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => LetIn (f a) -> f (LetIn a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LetIn a -> f (LetIn b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LetIn a -> f (LetIn b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (LetIn a) x -> LetIn a
forall a x. LetIn a -> Rep (LetIn a) x
$cto :: forall a x. Rep (LetIn a) x -> LetIn a
$cfrom :: forall a x. LetIn a -> Rep (LetIn a) x
Generic)

data Where a = Where
  { forall a. Where a -> Expr a
whereExpr :: Expr a
  , forall a. Where a -> Maybe (SourceToken, NonEmpty (LetBinding a))
whereBindings :: Maybe (SourceToken, NonEmpty (LetBinding a))
  } deriving (Int -> Where a -> ShowS
forall a. Show a => Int -> Where a -> ShowS
forall a. Show a => [Where a] -> ShowS
forall a. Show a => Where a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Where a] -> ShowS
$cshowList :: forall a. Show a => [Where a] -> ShowS
show :: Where a -> String
$cshow :: forall a. Show a => Where a -> String
showsPrec :: Int -> Where a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Where a -> ShowS
Show, Where a -> Where a -> Bool
forall a. Eq a => Where a -> Where a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Where a -> Where a -> Bool
$c/= :: forall a. Eq a => Where a -> Where a -> Bool
== :: Where a -> Where a -> Bool
$c== :: forall a. Eq a => Where a -> Where a -> Bool
Eq, Where a -> Where a -> Bool
Where a -> Where a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Where a)
forall a. Ord a => Where a -> Where a -> Bool
forall a. Ord a => Where a -> Where a -> Ordering
forall a. Ord a => Where a -> Where a -> Where a
min :: Where a -> Where a -> Where a
$cmin :: forall a. Ord a => Where a -> Where a -> Where a
max :: Where a -> Where a -> Where a
$cmax :: forall a. Ord a => Where a -> Where a -> Where a
>= :: Where a -> Where a -> Bool
$c>= :: forall a. Ord a => Where a -> Where a -> Bool
> :: Where a -> Where a -> Bool
$c> :: forall a. Ord a => Where a -> Where a -> Bool
<= :: Where a -> Where a -> Bool
$c<= :: forall a. Ord a => Where a -> Where a -> Bool
< :: Where a -> Where a -> Bool
$c< :: forall a. Ord a => Where a -> Where a -> Bool
compare :: Where a -> Where a -> Ordering
$ccompare :: forall a. Ord a => Where a -> Where a -> Ordering
Ord, forall a b. a -> Where b -> Where a
forall a b. (a -> b) -> Where a -> Where b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Where b -> Where a
$c<$ :: forall a b. a -> Where b -> Where a
fmap :: forall a b. (a -> b) -> Where a -> Where b
$cfmap :: forall a b. (a -> b) -> Where a -> Where b
Functor, forall a. Eq a => a -> Where a -> Bool
forall a. Num a => Where a -> a
forall a. Ord a => Where a -> a
forall m. Monoid m => Where m -> m
forall a. Where a -> Bool
forall a. Where a -> Int
forall a. Where a -> [a]
forall a. (a -> a -> a) -> Where a -> a
forall m a. Monoid m => (a -> m) -> Where a -> m
forall b a. (b -> a -> b) -> b -> Where a -> b
forall a b. (a -> b -> b) -> b -> Where a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Where a -> a
$cproduct :: forall a. Num a => Where a -> a
sum :: forall a. Num a => Where a -> a
$csum :: forall a. Num a => Where a -> a
minimum :: forall a. Ord a => Where a -> a
$cminimum :: forall a. Ord a => Where a -> a
maximum :: forall a. Ord a => Where a -> a
$cmaximum :: forall a. Ord a => Where a -> a
elem :: forall a. Eq a => a -> Where a -> Bool
$celem :: forall a. Eq a => a -> Where a -> Bool
length :: forall a. Where a -> Int
$clength :: forall a. Where a -> Int
null :: forall a. Where a -> Bool
$cnull :: forall a. Where a -> Bool
toList :: forall a. Where a -> [a]
$ctoList :: forall a. Where a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Where a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Where a -> a
foldr1 :: forall a. (a -> a -> a) -> Where a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Where a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Where a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Where a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Where a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Where a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Where a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Where a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Where a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Where a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Where a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Where a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Where a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Where a -> m
fold :: forall m. Monoid m => Where m -> m
$cfold :: forall m. Monoid m => Where m -> m
Foldable, Functor Where
Foldable Where
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 => Where (m a) -> m (Where a)
forall (f :: * -> *) a. Applicative f => Where (f a) -> f (Where a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Where a -> m (Where b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Where a -> f (Where b)
sequence :: forall (m :: * -> *) a. Monad m => Where (m a) -> m (Where a)
$csequence :: forall (m :: * -> *) a. Monad m => Where (m a) -> m (Where a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Where a -> m (Where b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Where a -> m (Where b)
sequenceA :: forall (f :: * -> *) a. Applicative f => Where (f a) -> f (Where a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Where (f a) -> f (Where a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Where a -> f (Where b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Where a -> f (Where b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Where a) x -> Where a
forall a x. Where a -> Rep (Where a) x
$cto :: forall a x. Rep (Where a) x -> Where a
$cfrom :: forall a x. Where a -> Rep (Where a) x
Generic)

data LetBinding a
  = LetBindingSignature a (Labeled (Name Ident) (Type a))
  | LetBindingName a (ValueBindingFields a)
  | LetBindingPattern a (Binder a) SourceToken (Where a)
  deriving (Int -> LetBinding a -> ShowS
forall a. Show a => Int -> LetBinding a -> ShowS
forall a. Show a => [LetBinding a] -> ShowS
forall a. Show a => LetBinding a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LetBinding a] -> ShowS
$cshowList :: forall a. Show a => [LetBinding a] -> ShowS
show :: LetBinding a -> String
$cshow :: forall a. Show a => LetBinding a -> String
showsPrec :: Int -> LetBinding a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> LetBinding a -> ShowS
Show, LetBinding a -> LetBinding a -> Bool
forall a. Eq a => LetBinding a -> LetBinding a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LetBinding a -> LetBinding a -> Bool
$c/= :: forall a. Eq a => LetBinding a -> LetBinding a -> Bool
== :: LetBinding a -> LetBinding a -> Bool
$c== :: forall a. Eq a => LetBinding a -> LetBinding a -> Bool
Eq, LetBinding a -> LetBinding a -> Bool
LetBinding a -> LetBinding a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (LetBinding a)
forall a. Ord a => LetBinding a -> LetBinding a -> Bool
forall a. Ord a => LetBinding a -> LetBinding a -> Ordering
forall a. Ord a => LetBinding a -> LetBinding a -> LetBinding a
min :: LetBinding a -> LetBinding a -> LetBinding a
$cmin :: forall a. Ord a => LetBinding a -> LetBinding a -> LetBinding a
max :: LetBinding a -> LetBinding a -> LetBinding a
$cmax :: forall a. Ord a => LetBinding a -> LetBinding a -> LetBinding a
>= :: LetBinding a -> LetBinding a -> Bool
$c>= :: forall a. Ord a => LetBinding a -> LetBinding a -> Bool
> :: LetBinding a -> LetBinding a -> Bool
$c> :: forall a. Ord a => LetBinding a -> LetBinding a -> Bool
<= :: LetBinding a -> LetBinding a -> Bool
$c<= :: forall a. Ord a => LetBinding a -> LetBinding a -> Bool
< :: LetBinding a -> LetBinding a -> Bool
$c< :: forall a. Ord a => LetBinding a -> LetBinding a -> Bool
compare :: LetBinding a -> LetBinding a -> Ordering
$ccompare :: forall a. Ord a => LetBinding a -> LetBinding a -> Ordering
Ord, forall a b. a -> LetBinding b -> LetBinding a
forall a b. (a -> b) -> LetBinding a -> LetBinding b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> LetBinding b -> LetBinding a
$c<$ :: forall a b. a -> LetBinding b -> LetBinding a
fmap :: forall a b. (a -> b) -> LetBinding a -> LetBinding b
$cfmap :: forall a b. (a -> b) -> LetBinding a -> LetBinding b
Functor, forall a. Eq a => a -> LetBinding a -> Bool
forall a. Num a => LetBinding a -> a
forall a. Ord a => LetBinding a -> a
forall m. Monoid m => LetBinding m -> m
forall a. LetBinding a -> Bool
forall a. LetBinding a -> Int
forall a. LetBinding a -> [a]
forall a. (a -> a -> a) -> LetBinding a -> a
forall m a. Monoid m => (a -> m) -> LetBinding a -> m
forall b a. (b -> a -> b) -> b -> LetBinding a -> b
forall a b. (a -> b -> b) -> b -> LetBinding a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => LetBinding a -> a
$cproduct :: forall a. Num a => LetBinding a -> a
sum :: forall a. Num a => LetBinding a -> a
$csum :: forall a. Num a => LetBinding a -> a
minimum :: forall a. Ord a => LetBinding a -> a
$cminimum :: forall a. Ord a => LetBinding a -> a
maximum :: forall a. Ord a => LetBinding a -> a
$cmaximum :: forall a. Ord a => LetBinding a -> a
elem :: forall a. Eq a => a -> LetBinding a -> Bool
$celem :: forall a. Eq a => a -> LetBinding a -> Bool
length :: forall a. LetBinding a -> Int
$clength :: forall a. LetBinding a -> Int
null :: forall a. LetBinding a -> Bool
$cnull :: forall a. LetBinding a -> Bool
toList :: forall a. LetBinding a -> [a]
$ctoList :: forall a. LetBinding a -> [a]
foldl1 :: forall a. (a -> a -> a) -> LetBinding a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> LetBinding a -> a
foldr1 :: forall a. (a -> a -> a) -> LetBinding a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> LetBinding a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> LetBinding a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> LetBinding a -> b
foldl :: forall b a. (b -> a -> b) -> b -> LetBinding a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> LetBinding a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> LetBinding a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> LetBinding a -> b
foldr :: forall a b. (a -> b -> b) -> b -> LetBinding a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> LetBinding a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> LetBinding a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> LetBinding a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> LetBinding a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> LetBinding a -> m
fold :: forall m. Monoid m => LetBinding m -> m
$cfold :: forall m. Monoid m => LetBinding m -> m
Foldable, Functor LetBinding
Foldable LetBinding
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 =>
LetBinding (m a) -> m (LetBinding a)
forall (f :: * -> *) a.
Applicative f =>
LetBinding (f a) -> f (LetBinding a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LetBinding a -> m (LetBinding b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LetBinding a -> f (LetBinding b)
sequence :: forall (m :: * -> *) a.
Monad m =>
LetBinding (m a) -> m (LetBinding a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
LetBinding (m a) -> m (LetBinding a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LetBinding a -> m (LetBinding b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LetBinding a -> m (LetBinding b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
LetBinding (f a) -> f (LetBinding a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
LetBinding (f a) -> f (LetBinding a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LetBinding a -> f (LetBinding b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LetBinding a -> f (LetBinding b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (LetBinding a) x -> LetBinding a
forall a x. LetBinding a -> Rep (LetBinding a) x
$cto :: forall a x. Rep (LetBinding a) x -> LetBinding a
$cfrom :: forall a x. LetBinding a -> Rep (LetBinding a) x
Generic)

data DoBlock a = DoBlock
  { forall a. DoBlock a -> SourceToken
doKeyword :: SourceToken
  , forall a. DoBlock a -> NonEmpty (DoStatement a)
doStatements :: NonEmpty (DoStatement a)
  } deriving (Int -> DoBlock a -> ShowS
forall a. Show a => Int -> DoBlock a -> ShowS
forall a. Show a => [DoBlock a] -> ShowS
forall a. Show a => DoBlock a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DoBlock a] -> ShowS
$cshowList :: forall a. Show a => [DoBlock a] -> ShowS
show :: DoBlock a -> String
$cshow :: forall a. Show a => DoBlock a -> String
showsPrec :: Int -> DoBlock a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DoBlock a -> ShowS
Show, DoBlock a -> DoBlock a -> Bool
forall a. Eq a => DoBlock a -> DoBlock a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DoBlock a -> DoBlock a -> Bool
$c/= :: forall a. Eq a => DoBlock a -> DoBlock a -> Bool
== :: DoBlock a -> DoBlock a -> Bool
$c== :: forall a. Eq a => DoBlock a -> DoBlock a -> Bool
Eq, DoBlock a -> DoBlock a -> Bool
DoBlock a -> DoBlock a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (DoBlock a)
forall a. Ord a => DoBlock a -> DoBlock a -> Bool
forall a. Ord a => DoBlock a -> DoBlock a -> Ordering
forall a. Ord a => DoBlock a -> DoBlock a -> DoBlock a
min :: DoBlock a -> DoBlock a -> DoBlock a
$cmin :: forall a. Ord a => DoBlock a -> DoBlock a -> DoBlock a
max :: DoBlock a -> DoBlock a -> DoBlock a
$cmax :: forall a. Ord a => DoBlock a -> DoBlock a -> DoBlock a
>= :: DoBlock a -> DoBlock a -> Bool
$c>= :: forall a. Ord a => DoBlock a -> DoBlock a -> Bool
> :: DoBlock a -> DoBlock a -> Bool
$c> :: forall a. Ord a => DoBlock a -> DoBlock a -> Bool
<= :: DoBlock a -> DoBlock a -> Bool
$c<= :: forall a. Ord a => DoBlock a -> DoBlock a -> Bool
< :: DoBlock a -> DoBlock a -> Bool
$c< :: forall a. Ord a => DoBlock a -> DoBlock a -> Bool
compare :: DoBlock a -> DoBlock a -> Ordering
$ccompare :: forall a. Ord a => DoBlock a -> DoBlock a -> Ordering
Ord, forall a b. a -> DoBlock b -> DoBlock a
forall a b. (a -> b) -> DoBlock a -> DoBlock b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> DoBlock b -> DoBlock a
$c<$ :: forall a b. a -> DoBlock b -> DoBlock a
fmap :: forall a b. (a -> b) -> DoBlock a -> DoBlock b
$cfmap :: forall a b. (a -> b) -> DoBlock a -> DoBlock b
Functor, forall a. Eq a => a -> DoBlock a -> Bool
forall a. Num a => DoBlock a -> a
forall a. Ord a => DoBlock a -> a
forall m. Monoid m => DoBlock m -> m
forall a. DoBlock a -> Bool
forall a. DoBlock a -> Int
forall a. DoBlock a -> [a]
forall a. (a -> a -> a) -> DoBlock a -> a
forall m a. Monoid m => (a -> m) -> DoBlock a -> m
forall b a. (b -> a -> b) -> b -> DoBlock a -> b
forall a b. (a -> b -> b) -> b -> DoBlock a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => DoBlock a -> a
$cproduct :: forall a. Num a => DoBlock a -> a
sum :: forall a. Num a => DoBlock a -> a
$csum :: forall a. Num a => DoBlock a -> a
minimum :: forall a. Ord a => DoBlock a -> a
$cminimum :: forall a. Ord a => DoBlock a -> a
maximum :: forall a. Ord a => DoBlock a -> a
$cmaximum :: forall a. Ord a => DoBlock a -> a
elem :: forall a. Eq a => a -> DoBlock a -> Bool
$celem :: forall a. Eq a => a -> DoBlock a -> Bool
length :: forall a. DoBlock a -> Int
$clength :: forall a. DoBlock a -> Int
null :: forall a. DoBlock a -> Bool
$cnull :: forall a. DoBlock a -> Bool
toList :: forall a. DoBlock a -> [a]
$ctoList :: forall a. DoBlock a -> [a]
foldl1 :: forall a. (a -> a -> a) -> DoBlock a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DoBlock a -> a
foldr1 :: forall a. (a -> a -> a) -> DoBlock a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> DoBlock a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> DoBlock a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DoBlock a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DoBlock a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DoBlock a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DoBlock a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DoBlock a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DoBlock a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> DoBlock a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> DoBlock a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DoBlock a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DoBlock a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DoBlock a -> m
fold :: forall m. Monoid m => DoBlock m -> m
$cfold :: forall m. Monoid m => DoBlock m -> m
Foldable, Functor DoBlock
Foldable DoBlock
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 => DoBlock (m a) -> m (DoBlock a)
forall (f :: * -> *) a.
Applicative f =>
DoBlock (f a) -> f (DoBlock a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DoBlock a -> m (DoBlock b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DoBlock a -> f (DoBlock b)
sequence :: forall (m :: * -> *) a. Monad m => DoBlock (m a) -> m (DoBlock a)
$csequence :: forall (m :: * -> *) a. Monad m => DoBlock (m a) -> m (DoBlock a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DoBlock a -> m (DoBlock b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DoBlock a -> m (DoBlock b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DoBlock (f a) -> f (DoBlock a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DoBlock (f a) -> f (DoBlock a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DoBlock a -> f (DoBlock b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DoBlock a -> f (DoBlock b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DoBlock a) x -> DoBlock a
forall a x. DoBlock a -> Rep (DoBlock a) x
$cto :: forall a x. Rep (DoBlock a) x -> DoBlock a
$cfrom :: forall a x. DoBlock a -> Rep (DoBlock a) x
Generic)

data DoStatement a
  = DoLet SourceToken (NonEmpty (LetBinding a))
  | DoDiscard (Expr a)
  | DoBind (Binder a) SourceToken (Expr a)
  deriving (Int -> DoStatement a -> ShowS
forall a. Show a => Int -> DoStatement a -> ShowS
forall a. Show a => [DoStatement a] -> ShowS
forall a. Show a => DoStatement a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DoStatement a] -> ShowS
$cshowList :: forall a. Show a => [DoStatement a] -> ShowS
show :: DoStatement a -> String
$cshow :: forall a. Show a => DoStatement a -> String
showsPrec :: Int -> DoStatement a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> DoStatement a -> ShowS
Show, DoStatement a -> DoStatement a -> Bool
forall a. Eq a => DoStatement a -> DoStatement a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DoStatement a -> DoStatement a -> Bool
$c/= :: forall a. Eq a => DoStatement a -> DoStatement a -> Bool
== :: DoStatement a -> DoStatement a -> Bool
$c== :: forall a. Eq a => DoStatement a -> DoStatement a -> Bool
Eq, DoStatement a -> DoStatement a -> Bool
DoStatement a -> DoStatement a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (DoStatement a)
forall a. Ord a => DoStatement a -> DoStatement a -> Bool
forall a. Ord a => DoStatement a -> DoStatement a -> Ordering
forall a. Ord a => DoStatement a -> DoStatement a -> DoStatement a
min :: DoStatement a -> DoStatement a -> DoStatement a
$cmin :: forall a. Ord a => DoStatement a -> DoStatement a -> DoStatement a
max :: DoStatement a -> DoStatement a -> DoStatement a
$cmax :: forall a. Ord a => DoStatement a -> DoStatement a -> DoStatement a
>= :: DoStatement a -> DoStatement a -> Bool
$c>= :: forall a. Ord a => DoStatement a -> DoStatement a -> Bool
> :: DoStatement a -> DoStatement a -> Bool
$c> :: forall a. Ord a => DoStatement a -> DoStatement a -> Bool
<= :: DoStatement a -> DoStatement a -> Bool
$c<= :: forall a. Ord a => DoStatement a -> DoStatement a -> Bool
< :: DoStatement a -> DoStatement a -> Bool
$c< :: forall a. Ord a => DoStatement a -> DoStatement a -> Bool
compare :: DoStatement a -> DoStatement a -> Ordering
$ccompare :: forall a. Ord a => DoStatement a -> DoStatement a -> Ordering
Ord, forall a b. a -> DoStatement b -> DoStatement a
forall a b. (a -> b) -> DoStatement a -> DoStatement b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> DoStatement b -> DoStatement a
$c<$ :: forall a b. a -> DoStatement b -> DoStatement a
fmap :: forall a b. (a -> b) -> DoStatement a -> DoStatement b
$cfmap :: forall a b. (a -> b) -> DoStatement a -> DoStatement b
Functor, forall a. Eq a => a -> DoStatement a -> Bool
forall a. Num a => DoStatement a -> a
forall a. Ord a => DoStatement a -> a
forall m. Monoid m => DoStatement m -> m
forall a. DoStatement a -> Bool
forall a. DoStatement a -> Int
forall a. DoStatement a -> [a]
forall a. (a -> a -> a) -> DoStatement a -> a
forall m a. Monoid m => (a -> m) -> DoStatement a -> m
forall b a. (b -> a -> b) -> b -> DoStatement a -> b
forall a b. (a -> b -> b) -> b -> DoStatement a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => DoStatement a -> a
$cproduct :: forall a. Num a => DoStatement a -> a
sum :: forall a. Num a => DoStatement a -> a
$csum :: forall a. Num a => DoStatement a -> a
minimum :: forall a. Ord a => DoStatement a -> a
$cminimum :: forall a. Ord a => DoStatement a -> a
maximum :: forall a. Ord a => DoStatement a -> a
$cmaximum :: forall a. Ord a => DoStatement a -> a
elem :: forall a. Eq a => a -> DoStatement a -> Bool
$celem :: forall a. Eq a => a -> DoStatement a -> Bool
length :: forall a. DoStatement a -> Int
$clength :: forall a. DoStatement a -> Int
null :: forall a. DoStatement a -> Bool
$cnull :: forall a. DoStatement a -> Bool
toList :: forall a. DoStatement a -> [a]
$ctoList :: forall a. DoStatement a -> [a]
foldl1 :: forall a. (a -> a -> a) -> DoStatement a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> DoStatement a -> a
foldr1 :: forall a. (a -> a -> a) -> DoStatement a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> DoStatement a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> DoStatement a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> DoStatement a -> b
foldl :: forall b a. (b -> a -> b) -> b -> DoStatement a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> DoStatement a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> DoStatement a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> DoStatement a -> b
foldr :: forall a b. (a -> b -> b) -> b -> DoStatement a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> DoStatement a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> DoStatement a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> DoStatement a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> DoStatement a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> DoStatement a -> m
fold :: forall m. Monoid m => DoStatement m -> m
$cfold :: forall m. Monoid m => DoStatement m -> m
Foldable, Functor DoStatement
Foldable DoStatement
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 =>
DoStatement (m a) -> m (DoStatement a)
forall (f :: * -> *) a.
Applicative f =>
DoStatement (f a) -> f (DoStatement a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DoStatement a -> m (DoStatement b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DoStatement a -> f (DoStatement b)
sequence :: forall (m :: * -> *) a.
Monad m =>
DoStatement (m a) -> m (DoStatement a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
DoStatement (m a) -> m (DoStatement a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DoStatement a -> m (DoStatement b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> DoStatement a -> m (DoStatement b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
DoStatement (f a) -> f (DoStatement a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
DoStatement (f a) -> f (DoStatement a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DoStatement a -> f (DoStatement b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> DoStatement a -> f (DoStatement b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (DoStatement a) x -> DoStatement a
forall a x. DoStatement a -> Rep (DoStatement a) x
$cto :: forall a x. Rep (DoStatement a) x -> DoStatement a
$cfrom :: forall a x. DoStatement a -> Rep (DoStatement a) x
Generic)

data AdoBlock a = AdoBlock
  { forall a. AdoBlock a -> SourceToken
adoKeyword :: SourceToken
  , forall a. AdoBlock a -> [DoStatement a]
adoStatements :: [DoStatement a]
  , forall a. AdoBlock a -> SourceToken
adoIn :: SourceToken
  , forall a. AdoBlock a -> Expr a
adoResult :: Expr a
  } deriving (Int -> AdoBlock a -> ShowS
forall a. Show a => Int -> AdoBlock a -> ShowS
forall a. Show a => [AdoBlock a] -> ShowS
forall a. Show a => AdoBlock a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AdoBlock a] -> ShowS
$cshowList :: forall a. Show a => [AdoBlock a] -> ShowS
show :: AdoBlock a -> String
$cshow :: forall a. Show a => AdoBlock a -> String
showsPrec :: Int -> AdoBlock a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> AdoBlock a -> ShowS
Show, AdoBlock a -> AdoBlock a -> Bool
forall a. Eq a => AdoBlock a -> AdoBlock a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AdoBlock a -> AdoBlock a -> Bool
$c/= :: forall a. Eq a => AdoBlock a -> AdoBlock a -> Bool
== :: AdoBlock a -> AdoBlock a -> Bool
$c== :: forall a. Eq a => AdoBlock a -> AdoBlock a -> Bool
Eq, AdoBlock a -> AdoBlock a -> Bool
AdoBlock a -> AdoBlock a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (AdoBlock a)
forall a. Ord a => AdoBlock a -> AdoBlock a -> Bool
forall a. Ord a => AdoBlock a -> AdoBlock a -> Ordering
forall a. Ord a => AdoBlock a -> AdoBlock a -> AdoBlock a
min :: AdoBlock a -> AdoBlock a -> AdoBlock a
$cmin :: forall a. Ord a => AdoBlock a -> AdoBlock a -> AdoBlock a
max :: AdoBlock a -> AdoBlock a -> AdoBlock a
$cmax :: forall a. Ord a => AdoBlock a -> AdoBlock a -> AdoBlock a
>= :: AdoBlock a -> AdoBlock a -> Bool
$c>= :: forall a. Ord a => AdoBlock a -> AdoBlock a -> Bool
> :: AdoBlock a -> AdoBlock a -> Bool
$c> :: forall a. Ord a => AdoBlock a -> AdoBlock a -> Bool
<= :: AdoBlock a -> AdoBlock a -> Bool
$c<= :: forall a. Ord a => AdoBlock a -> AdoBlock a -> Bool
< :: AdoBlock a -> AdoBlock a -> Bool
$c< :: forall a. Ord a => AdoBlock a -> AdoBlock a -> Bool
compare :: AdoBlock a -> AdoBlock a -> Ordering
$ccompare :: forall a. Ord a => AdoBlock a -> AdoBlock a -> Ordering
Ord, forall a b. a -> AdoBlock b -> AdoBlock a
forall a b. (a -> b) -> AdoBlock a -> AdoBlock b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> AdoBlock b -> AdoBlock a
$c<$ :: forall a b. a -> AdoBlock b -> AdoBlock a
fmap :: forall a b. (a -> b) -> AdoBlock a -> AdoBlock b
$cfmap :: forall a b. (a -> b) -> AdoBlock a -> AdoBlock b
Functor, forall a. Eq a => a -> AdoBlock a -> Bool
forall a. Num a => AdoBlock a -> a
forall a. Ord a => AdoBlock a -> a
forall m. Monoid m => AdoBlock m -> m
forall a. AdoBlock a -> Bool
forall a. AdoBlock a -> Int
forall a. AdoBlock a -> [a]
forall a. (a -> a -> a) -> AdoBlock a -> a
forall m a. Monoid m => (a -> m) -> AdoBlock a -> m
forall b a. (b -> a -> b) -> b -> AdoBlock a -> b
forall a b. (a -> b -> b) -> b -> AdoBlock a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => AdoBlock a -> a
$cproduct :: forall a. Num a => AdoBlock a -> a
sum :: forall a. Num a => AdoBlock a -> a
$csum :: forall a. Num a => AdoBlock a -> a
minimum :: forall a. Ord a => AdoBlock a -> a
$cminimum :: forall a. Ord a => AdoBlock a -> a
maximum :: forall a. Ord a => AdoBlock a -> a
$cmaximum :: forall a. Ord a => AdoBlock a -> a
elem :: forall a. Eq a => a -> AdoBlock a -> Bool
$celem :: forall a. Eq a => a -> AdoBlock a -> Bool
length :: forall a. AdoBlock a -> Int
$clength :: forall a. AdoBlock a -> Int
null :: forall a. AdoBlock a -> Bool
$cnull :: forall a. AdoBlock a -> Bool
toList :: forall a. AdoBlock a -> [a]
$ctoList :: forall a. AdoBlock a -> [a]
foldl1 :: forall a. (a -> a -> a) -> AdoBlock a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> AdoBlock a -> a
foldr1 :: forall a. (a -> a -> a) -> AdoBlock a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> AdoBlock a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> AdoBlock a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> AdoBlock a -> b
foldl :: forall b a. (b -> a -> b) -> b -> AdoBlock a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> AdoBlock a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> AdoBlock a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> AdoBlock a -> b
foldr :: forall a b. (a -> b -> b) -> b -> AdoBlock a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> AdoBlock a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> AdoBlock a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> AdoBlock a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> AdoBlock a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> AdoBlock a -> m
fold :: forall m. Monoid m => AdoBlock m -> m
$cfold :: forall m. Monoid m => AdoBlock m -> m
Foldable, Functor AdoBlock
Foldable AdoBlock
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 => AdoBlock (m a) -> m (AdoBlock a)
forall (f :: * -> *) a.
Applicative f =>
AdoBlock (f a) -> f (AdoBlock a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AdoBlock a -> m (AdoBlock b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AdoBlock a -> f (AdoBlock b)
sequence :: forall (m :: * -> *) a. Monad m => AdoBlock (m a) -> m (AdoBlock a)
$csequence :: forall (m :: * -> *) a. Monad m => AdoBlock (m a) -> m (AdoBlock a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AdoBlock a -> m (AdoBlock b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AdoBlock a -> m (AdoBlock b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
AdoBlock (f a) -> f (AdoBlock a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
AdoBlock (f a) -> f (AdoBlock a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AdoBlock a -> f (AdoBlock b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AdoBlock a -> f (AdoBlock b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (AdoBlock a) x -> AdoBlock a
forall a x. AdoBlock a -> Rep (AdoBlock a) x
$cto :: forall a x. Rep (AdoBlock a) x -> AdoBlock a
$cfrom :: forall a x. AdoBlock a -> Rep (AdoBlock a) x
Generic)

data Binder a
  = BinderWildcard a SourceToken
  | BinderVar a (Name Ident)
  | BinderNamed a (Name Ident) SourceToken (Binder a)
  | BinderConstructor a (QualifiedName (N.ProperName 'N.ConstructorName)) [Binder a]
  | BinderBoolean a SourceToken Bool
  | BinderChar a SourceToken Char
  | BinderString a SourceToken PSString
  | BinderNumber a (Maybe SourceToken) SourceToken (Either Integer Double)
  | BinderArray a (Delimited (Binder a))
  | BinderRecord a (Delimited (RecordLabeled (Binder a)))
  | BinderParens a (Wrapped (Binder a))
  | BinderTyped a (Binder a) SourceToken (Type a)
  | BinderOp a (Binder a) (QualifiedName (N.OpName 'N.ValueOpName)) (Binder a)
  deriving (Int -> Binder a -> ShowS
forall a. Show a => Int -> Binder a -> ShowS
forall a. Show a => [Binder a] -> ShowS
forall a. Show a => Binder a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Binder a] -> ShowS
$cshowList :: forall a. Show a => [Binder a] -> ShowS
show :: Binder a -> String
$cshow :: forall a. Show a => Binder a -> String
showsPrec :: Int -> Binder a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Binder a -> ShowS
Show, Binder a -> Binder a -> Bool
forall a. Eq a => Binder a -> Binder a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Binder a -> Binder a -> Bool
$c/= :: forall a. Eq a => Binder a -> Binder a -> Bool
== :: Binder a -> Binder a -> Bool
$c== :: forall a. Eq a => Binder a -> Binder a -> Bool
Eq, Binder a -> Binder a -> Ordering
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Binder a)
forall a. Ord a => Binder a -> Binder a -> Bool
forall a. Ord a => Binder a -> Binder a -> Ordering
forall a. Ord a => Binder a -> Binder a -> Binder a
min :: Binder a -> Binder a -> Binder a
$cmin :: forall a. Ord a => Binder a -> Binder a -> Binder a
max :: Binder a -> Binder a -> Binder a
$cmax :: forall a. Ord a => Binder a -> Binder a -> Binder a
>= :: Binder a -> Binder a -> Bool
$c>= :: forall a. Ord a => Binder a -> Binder a -> Bool
> :: Binder a -> Binder a -> Bool
$c> :: forall a. Ord a => Binder a -> Binder a -> Bool
<= :: Binder a -> Binder a -> Bool
$c<= :: forall a. Ord a => Binder a -> Binder a -> Bool
< :: Binder a -> Binder a -> Bool
$c< :: forall a. Ord a => Binder a -> Binder a -> Bool
compare :: Binder a -> Binder a -> Ordering
$ccompare :: forall a. Ord a => Binder a -> Binder a -> Ordering
Ord, forall a b. a -> Binder b -> Binder a
forall a b. (a -> b) -> Binder a -> Binder b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Binder b -> Binder a
$c<$ :: forall a b. a -> Binder b -> Binder a
fmap :: forall a b. (a -> b) -> Binder a -> Binder b
$cfmap :: forall a b. (a -> b) -> Binder a -> Binder b
Functor, forall a. Eq a => a -> Binder a -> Bool
forall a. Num a => Binder a -> a
forall a. Ord a => Binder a -> a
forall m. Monoid m => Binder m -> m
forall a. Binder a -> Bool
forall a. Binder a -> Int
forall a. Binder a -> [a]
forall a. (a -> a -> a) -> Binder a -> a
forall m a. Monoid m => (a -> m) -> Binder a -> m
forall b a. (b -> a -> b) -> b -> Binder a -> b
forall a b. (a -> b -> b) -> b -> Binder a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Binder a -> a
$cproduct :: forall a. Num a => Binder a -> a
sum :: forall a. Num a => Binder a -> a
$csum :: forall a. Num a => Binder a -> a
minimum :: forall a. Ord a => Binder a -> a
$cminimum :: forall a. Ord a => Binder a -> a
maximum :: forall a. Ord a => Binder a -> a
$cmaximum :: forall a. Ord a => Binder a -> a
elem :: forall a. Eq a => a -> Binder a -> Bool
$celem :: forall a. Eq a => a -> Binder a -> Bool
length :: forall a. Binder a -> Int
$clength :: forall a. Binder a -> Int
null :: forall a. Binder a -> Bool
$cnull :: forall a. Binder a -> Bool
toList :: forall a. Binder a -> [a]
$ctoList :: forall a. Binder a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Binder a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Binder a -> a
foldr1 :: forall a. (a -> a -> a) -> Binder a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Binder a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Binder a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Binder a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Binder a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Binder a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Binder a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Binder a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Binder a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Binder a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Binder a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Binder a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Binder a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Binder a -> m
fold :: forall m. Monoid m => Binder m -> m
$cfold :: forall m. Monoid m => Binder m -> m
Foldable, Functor Binder
Foldable Binder
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 => Binder (m a) -> m (Binder a)
forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
sequence :: forall (m :: * -> *) a. Monad m => Binder (m a) -> m (Binder a)
$csequence :: forall (m :: * -> *) a. Monad m => Binder (m a) -> m (Binder a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Binder a -> m (Binder b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Binder (f a) -> f (Binder a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Binder a -> f (Binder b)
Traversable, forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Binder a) x -> Binder a
forall a x. Binder a -> Rep (Binder a) x
$cto :: forall a x. Rep (Binder a) x -> Binder a
$cfrom :: forall a x. Binder a -> Rep (Binder a) x
Generic)