-- | A model which provides a common syntax tree for Hydra serializers

module Hydra.Ast where

import qualified Hydra.Core as Core
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

-- | Operator associativity
data Associativity = 
  AssociativityNone  |
  AssociativityLeft  |
  AssociativityRight  |
  AssociativityBoth 
  deriving (Associativity -> Associativity -> Bool
(Associativity -> Associativity -> Bool)
-> (Associativity -> Associativity -> Bool) -> Eq Associativity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Associativity -> Associativity -> Bool
== :: Associativity -> Associativity -> Bool
$c/= :: Associativity -> Associativity -> Bool
/= :: Associativity -> Associativity -> Bool
Eq, Eq Associativity
Eq Associativity =>
(Associativity -> Associativity -> Ordering)
-> (Associativity -> Associativity -> Bool)
-> (Associativity -> Associativity -> Bool)
-> (Associativity -> Associativity -> Bool)
-> (Associativity -> Associativity -> Bool)
-> (Associativity -> Associativity -> Associativity)
-> (Associativity -> Associativity -> Associativity)
-> Ord Associativity
Associativity -> Associativity -> Bool
Associativity -> Associativity -> Ordering
Associativity -> Associativity -> Associativity
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Associativity -> Associativity -> Ordering
compare :: Associativity -> Associativity -> Ordering
$c< :: Associativity -> Associativity -> Bool
< :: Associativity -> Associativity -> Bool
$c<= :: Associativity -> Associativity -> Bool
<= :: Associativity -> Associativity -> Bool
$c> :: Associativity -> Associativity -> Bool
> :: Associativity -> Associativity -> Bool
$c>= :: Associativity -> Associativity -> Bool
>= :: Associativity -> Associativity -> Bool
$cmax :: Associativity -> Associativity -> Associativity
max :: Associativity -> Associativity -> Associativity
$cmin :: Associativity -> Associativity -> Associativity
min :: Associativity -> Associativity -> Associativity
Ord, ReadPrec [Associativity]
ReadPrec Associativity
Int -> ReadS Associativity
ReadS [Associativity]
(Int -> ReadS Associativity)
-> ReadS [Associativity]
-> ReadPrec Associativity
-> ReadPrec [Associativity]
-> Read Associativity
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Associativity
readsPrec :: Int -> ReadS Associativity
$creadList :: ReadS [Associativity]
readList :: ReadS [Associativity]
$creadPrec :: ReadPrec Associativity
readPrec :: ReadPrec Associativity
$creadListPrec :: ReadPrec [Associativity]
readListPrec :: ReadPrec [Associativity]
Read, Int -> Associativity -> ShowS
[Associativity] -> ShowS
Associativity -> String
(Int -> Associativity -> ShowS)
-> (Associativity -> String)
-> ([Associativity] -> ShowS)
-> Show Associativity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Associativity -> ShowS
showsPrec :: Int -> Associativity -> ShowS
$cshow :: Associativity -> String
show :: Associativity -> String
$cshowList :: [Associativity] -> ShowS
showList :: [Associativity] -> ShowS
Show)

_Associativity :: Name
_Associativity = (String -> Name
Core.Name String
"hydra/ast.Associativity")

_Associativity_none :: Name
_Associativity_none = (String -> Name
Core.Name String
"none")

_Associativity_left :: Name
_Associativity_left = (String -> Name
Core.Name String
"left")

_Associativity_right :: Name
_Associativity_right = (String -> Name
Core.Name String
"right")

_Associativity_both :: Name
_Associativity_both = (String -> Name
Core.Name String
"both")

-- | Formatting option for code blocks
data BlockStyle = 
  BlockStyle {
    BlockStyle -> Maybe String
blockStyleIndent :: (Maybe String),
    BlockStyle -> Bool
blockStyleNewlineBeforeContent :: Bool,
    BlockStyle -> Bool
blockStyleNewlineAfterContent :: Bool}
  deriving (BlockStyle -> BlockStyle -> Bool
(BlockStyle -> BlockStyle -> Bool)
-> (BlockStyle -> BlockStyle -> Bool) -> Eq BlockStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlockStyle -> BlockStyle -> Bool
== :: BlockStyle -> BlockStyle -> Bool
$c/= :: BlockStyle -> BlockStyle -> Bool
/= :: BlockStyle -> BlockStyle -> Bool
Eq, Eq BlockStyle
Eq BlockStyle =>
(BlockStyle -> BlockStyle -> Ordering)
-> (BlockStyle -> BlockStyle -> Bool)
-> (BlockStyle -> BlockStyle -> Bool)
-> (BlockStyle -> BlockStyle -> Bool)
-> (BlockStyle -> BlockStyle -> Bool)
-> (BlockStyle -> BlockStyle -> BlockStyle)
-> (BlockStyle -> BlockStyle -> BlockStyle)
-> Ord BlockStyle
BlockStyle -> BlockStyle -> Bool
BlockStyle -> BlockStyle -> Ordering
BlockStyle -> BlockStyle -> BlockStyle
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BlockStyle -> BlockStyle -> Ordering
compare :: BlockStyle -> BlockStyle -> Ordering
$c< :: BlockStyle -> BlockStyle -> Bool
< :: BlockStyle -> BlockStyle -> Bool
$c<= :: BlockStyle -> BlockStyle -> Bool
<= :: BlockStyle -> BlockStyle -> Bool
$c> :: BlockStyle -> BlockStyle -> Bool
> :: BlockStyle -> BlockStyle -> Bool
$c>= :: BlockStyle -> BlockStyle -> Bool
>= :: BlockStyle -> BlockStyle -> Bool
$cmax :: BlockStyle -> BlockStyle -> BlockStyle
max :: BlockStyle -> BlockStyle -> BlockStyle
$cmin :: BlockStyle -> BlockStyle -> BlockStyle
min :: BlockStyle -> BlockStyle -> BlockStyle
Ord, ReadPrec [BlockStyle]
ReadPrec BlockStyle
Int -> ReadS BlockStyle
ReadS [BlockStyle]
(Int -> ReadS BlockStyle)
-> ReadS [BlockStyle]
-> ReadPrec BlockStyle
-> ReadPrec [BlockStyle]
-> Read BlockStyle
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BlockStyle
readsPrec :: Int -> ReadS BlockStyle
$creadList :: ReadS [BlockStyle]
readList :: ReadS [BlockStyle]
$creadPrec :: ReadPrec BlockStyle
readPrec :: ReadPrec BlockStyle
$creadListPrec :: ReadPrec [BlockStyle]
readListPrec :: ReadPrec [BlockStyle]
Read, Int -> BlockStyle -> ShowS
[BlockStyle] -> ShowS
BlockStyle -> String
(Int -> BlockStyle -> ShowS)
-> (BlockStyle -> String)
-> ([BlockStyle] -> ShowS)
-> Show BlockStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlockStyle -> ShowS
showsPrec :: Int -> BlockStyle -> ShowS
$cshow :: BlockStyle -> String
show :: BlockStyle -> String
$cshowList :: [BlockStyle] -> ShowS
showList :: [BlockStyle] -> ShowS
Show)

_BlockStyle :: Name
_BlockStyle = (String -> Name
Core.Name String
"hydra/ast.BlockStyle")

_BlockStyle_indent :: Name
_BlockStyle_indent = (String -> Name
Core.Name String
"indent")

_BlockStyle_newlineBeforeContent :: Name
_BlockStyle_newlineBeforeContent = (String -> Name
Core.Name String
"newlineBeforeContent")

_BlockStyle_newlineAfterContent :: Name
_BlockStyle_newlineAfterContent = (String -> Name
Core.Name String
"newlineAfterContent")

-- | An expression enclosed by brackets
data BracketExpr = 
  BracketExpr {
    BracketExpr -> Brackets
bracketExprBrackets :: Brackets,
    BracketExpr -> Expr
bracketExprEnclosed :: Expr,
    BracketExpr -> BlockStyle
bracketExprStyle :: BlockStyle}
  deriving (BracketExpr -> BracketExpr -> Bool
(BracketExpr -> BracketExpr -> Bool)
-> (BracketExpr -> BracketExpr -> Bool) -> Eq BracketExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BracketExpr -> BracketExpr -> Bool
== :: BracketExpr -> BracketExpr -> Bool
$c/= :: BracketExpr -> BracketExpr -> Bool
/= :: BracketExpr -> BracketExpr -> Bool
Eq, Eq BracketExpr
Eq BracketExpr =>
(BracketExpr -> BracketExpr -> Ordering)
-> (BracketExpr -> BracketExpr -> Bool)
-> (BracketExpr -> BracketExpr -> Bool)
-> (BracketExpr -> BracketExpr -> Bool)
-> (BracketExpr -> BracketExpr -> Bool)
-> (BracketExpr -> BracketExpr -> BracketExpr)
-> (BracketExpr -> BracketExpr -> BracketExpr)
-> Ord BracketExpr
BracketExpr -> BracketExpr -> Bool
BracketExpr -> BracketExpr -> Ordering
BracketExpr -> BracketExpr -> BracketExpr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BracketExpr -> BracketExpr -> Ordering
compare :: BracketExpr -> BracketExpr -> Ordering
$c< :: BracketExpr -> BracketExpr -> Bool
< :: BracketExpr -> BracketExpr -> Bool
$c<= :: BracketExpr -> BracketExpr -> Bool
<= :: BracketExpr -> BracketExpr -> Bool
$c> :: BracketExpr -> BracketExpr -> Bool
> :: BracketExpr -> BracketExpr -> Bool
$c>= :: BracketExpr -> BracketExpr -> Bool
>= :: BracketExpr -> BracketExpr -> Bool
$cmax :: BracketExpr -> BracketExpr -> BracketExpr
max :: BracketExpr -> BracketExpr -> BracketExpr
$cmin :: BracketExpr -> BracketExpr -> BracketExpr
min :: BracketExpr -> BracketExpr -> BracketExpr
Ord, ReadPrec [BracketExpr]
ReadPrec BracketExpr
Int -> ReadS BracketExpr
ReadS [BracketExpr]
(Int -> ReadS BracketExpr)
-> ReadS [BracketExpr]
-> ReadPrec BracketExpr
-> ReadPrec [BracketExpr]
-> Read BracketExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BracketExpr
readsPrec :: Int -> ReadS BracketExpr
$creadList :: ReadS [BracketExpr]
readList :: ReadS [BracketExpr]
$creadPrec :: ReadPrec BracketExpr
readPrec :: ReadPrec BracketExpr
$creadListPrec :: ReadPrec [BracketExpr]
readListPrec :: ReadPrec [BracketExpr]
Read, Int -> BracketExpr -> ShowS
[BracketExpr] -> ShowS
BracketExpr -> String
(Int -> BracketExpr -> ShowS)
-> (BracketExpr -> String)
-> ([BracketExpr] -> ShowS)
-> Show BracketExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BracketExpr -> ShowS
showsPrec :: Int -> BracketExpr -> ShowS
$cshow :: BracketExpr -> String
show :: BracketExpr -> String
$cshowList :: [BracketExpr] -> ShowS
showList :: [BracketExpr] -> ShowS
Show)

_BracketExpr :: Name
_BracketExpr = (String -> Name
Core.Name String
"hydra/ast.BracketExpr")

_BracketExpr_brackets :: Name
_BracketExpr_brackets = (String -> Name
Core.Name String
"brackets")

_BracketExpr_enclosed :: Name
_BracketExpr_enclosed = (String -> Name
Core.Name String
"enclosed")

_BracketExpr_style :: Name
_BracketExpr_style = (String -> Name
Core.Name String
"style")

-- | Matching open and close bracket symbols
data Brackets = 
  Brackets {
    Brackets -> Symbol
bracketsOpen :: Symbol,
    Brackets -> Symbol
bracketsClose :: Symbol}
  deriving (Brackets -> Brackets -> Bool
(Brackets -> Brackets -> Bool)
-> (Brackets -> Brackets -> Bool) -> Eq Brackets
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Brackets -> Brackets -> Bool
== :: Brackets -> Brackets -> Bool
$c/= :: Brackets -> Brackets -> Bool
/= :: Brackets -> Brackets -> Bool
Eq, Eq Brackets
Eq Brackets =>
(Brackets -> Brackets -> Ordering)
-> (Brackets -> Brackets -> Bool)
-> (Brackets -> Brackets -> Bool)
-> (Brackets -> Brackets -> Bool)
-> (Brackets -> Brackets -> Bool)
-> (Brackets -> Brackets -> Brackets)
-> (Brackets -> Brackets -> Brackets)
-> Ord Brackets
Brackets -> Brackets -> Bool
Brackets -> Brackets -> Ordering
Brackets -> Brackets -> Brackets
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Brackets -> Brackets -> Ordering
compare :: Brackets -> Brackets -> Ordering
$c< :: Brackets -> Brackets -> Bool
< :: Brackets -> Brackets -> Bool
$c<= :: Brackets -> Brackets -> Bool
<= :: Brackets -> Brackets -> Bool
$c> :: Brackets -> Brackets -> Bool
> :: Brackets -> Brackets -> Bool
$c>= :: Brackets -> Brackets -> Bool
>= :: Brackets -> Brackets -> Bool
$cmax :: Brackets -> Brackets -> Brackets
max :: Brackets -> Brackets -> Brackets
$cmin :: Brackets -> Brackets -> Brackets
min :: Brackets -> Brackets -> Brackets
Ord, ReadPrec [Brackets]
ReadPrec Brackets
Int -> ReadS Brackets
ReadS [Brackets]
(Int -> ReadS Brackets)
-> ReadS [Brackets]
-> ReadPrec Brackets
-> ReadPrec [Brackets]
-> Read Brackets
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Brackets
readsPrec :: Int -> ReadS Brackets
$creadList :: ReadS [Brackets]
readList :: ReadS [Brackets]
$creadPrec :: ReadPrec Brackets
readPrec :: ReadPrec Brackets
$creadListPrec :: ReadPrec [Brackets]
readListPrec :: ReadPrec [Brackets]
Read, Int -> Brackets -> ShowS
[Brackets] -> ShowS
Brackets -> String
(Int -> Brackets -> ShowS)
-> (Brackets -> String) -> ([Brackets] -> ShowS) -> Show Brackets
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Brackets -> ShowS
showsPrec :: Int -> Brackets -> ShowS
$cshow :: Brackets -> String
show :: Brackets -> String
$cshowList :: [Brackets] -> ShowS
showList :: [Brackets] -> ShowS
Show)

_Brackets :: Name
_Brackets = (String -> Name
Core.Name String
"hydra/ast.Brackets")

_Brackets_open :: Name
_Brackets_open = (String -> Name
Core.Name String
"open")

_Brackets_close :: Name
_Brackets_close = (String -> Name
Core.Name String
"close")

-- | An abstract expression
data Expr = 
  ExprConst Symbol |
  ExprIndent IndentedExpression |
  ExprOp OpExpr |
  ExprBrackets BracketExpr
  deriving (Expr -> Expr -> Bool
(Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Expr -> Expr -> Bool
== :: Expr -> Expr -> Bool
$c/= :: Expr -> Expr -> Bool
/= :: Expr -> Expr -> Bool
Eq, Eq Expr
Eq Expr =>
(Expr -> Expr -> Ordering)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Expr)
-> (Expr -> Expr -> Expr)
-> Ord Expr
Expr -> Expr -> Bool
Expr -> Expr -> Ordering
Expr -> Expr -> Expr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Expr -> Expr -> Ordering
compare :: Expr -> Expr -> Ordering
$c< :: Expr -> Expr -> Bool
< :: Expr -> Expr -> Bool
$c<= :: Expr -> Expr -> Bool
<= :: Expr -> Expr -> Bool
$c> :: Expr -> Expr -> Bool
> :: Expr -> Expr -> Bool
$c>= :: Expr -> Expr -> Bool
>= :: Expr -> Expr -> Bool
$cmax :: Expr -> Expr -> Expr
max :: Expr -> Expr -> Expr
$cmin :: Expr -> Expr -> Expr
min :: Expr -> Expr -> Expr
Ord, ReadPrec [Expr]
ReadPrec Expr
Int -> ReadS Expr
ReadS [Expr]
(Int -> ReadS Expr)
-> ReadS [Expr] -> ReadPrec Expr -> ReadPrec [Expr] -> Read Expr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Expr
readsPrec :: Int -> ReadS Expr
$creadList :: ReadS [Expr]
readList :: ReadS [Expr]
$creadPrec :: ReadPrec Expr
readPrec :: ReadPrec Expr
$creadListPrec :: ReadPrec [Expr]
readListPrec :: ReadPrec [Expr]
Read, Int -> Expr -> ShowS
[Expr] -> ShowS
Expr -> String
(Int -> Expr -> ShowS)
-> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Expr -> ShowS
showsPrec :: Int -> Expr -> ShowS
$cshow :: Expr -> String
show :: Expr -> String
$cshowList :: [Expr] -> ShowS
showList :: [Expr] -> ShowS
Show)

_Expr :: Name
_Expr = (String -> Name
Core.Name String
"hydra/ast.Expr")

_Expr_const :: Name
_Expr_const = (String -> Name
Core.Name String
"const")

_Expr_indent :: Name
_Expr_indent = (String -> Name
Core.Name String
"indent")

_Expr_op :: Name
_Expr_op = (String -> Name
Core.Name String
"op")

_Expr_brackets :: Name
_Expr_brackets = (String -> Name
Core.Name String
"brackets")

-- | An expression indented in a certain style
data IndentedExpression = 
  IndentedExpression {
    IndentedExpression -> IndentStyle
indentedExpressionStyle :: IndentStyle,
    IndentedExpression -> Expr
indentedExpressionExpr :: Expr}
  deriving (IndentedExpression -> IndentedExpression -> Bool
(IndentedExpression -> IndentedExpression -> Bool)
-> (IndentedExpression -> IndentedExpression -> Bool)
-> Eq IndentedExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndentedExpression -> IndentedExpression -> Bool
== :: IndentedExpression -> IndentedExpression -> Bool
$c/= :: IndentedExpression -> IndentedExpression -> Bool
/= :: IndentedExpression -> IndentedExpression -> Bool
Eq, Eq IndentedExpression
Eq IndentedExpression =>
(IndentedExpression -> IndentedExpression -> Ordering)
-> (IndentedExpression -> IndentedExpression -> Bool)
-> (IndentedExpression -> IndentedExpression -> Bool)
-> (IndentedExpression -> IndentedExpression -> Bool)
-> (IndentedExpression -> IndentedExpression -> Bool)
-> (IndentedExpression -> IndentedExpression -> IndentedExpression)
-> (IndentedExpression -> IndentedExpression -> IndentedExpression)
-> Ord IndentedExpression
IndentedExpression -> IndentedExpression -> Bool
IndentedExpression -> IndentedExpression -> Ordering
IndentedExpression -> IndentedExpression -> IndentedExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IndentedExpression -> IndentedExpression -> Ordering
compare :: IndentedExpression -> IndentedExpression -> Ordering
$c< :: IndentedExpression -> IndentedExpression -> Bool
< :: IndentedExpression -> IndentedExpression -> Bool
$c<= :: IndentedExpression -> IndentedExpression -> Bool
<= :: IndentedExpression -> IndentedExpression -> Bool
$c> :: IndentedExpression -> IndentedExpression -> Bool
> :: IndentedExpression -> IndentedExpression -> Bool
$c>= :: IndentedExpression -> IndentedExpression -> Bool
>= :: IndentedExpression -> IndentedExpression -> Bool
$cmax :: IndentedExpression -> IndentedExpression -> IndentedExpression
max :: IndentedExpression -> IndentedExpression -> IndentedExpression
$cmin :: IndentedExpression -> IndentedExpression -> IndentedExpression
min :: IndentedExpression -> IndentedExpression -> IndentedExpression
Ord, ReadPrec [IndentedExpression]
ReadPrec IndentedExpression
Int -> ReadS IndentedExpression
ReadS [IndentedExpression]
(Int -> ReadS IndentedExpression)
-> ReadS [IndentedExpression]
-> ReadPrec IndentedExpression
-> ReadPrec [IndentedExpression]
-> Read IndentedExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IndentedExpression
readsPrec :: Int -> ReadS IndentedExpression
$creadList :: ReadS [IndentedExpression]
readList :: ReadS [IndentedExpression]
$creadPrec :: ReadPrec IndentedExpression
readPrec :: ReadPrec IndentedExpression
$creadListPrec :: ReadPrec [IndentedExpression]
readListPrec :: ReadPrec [IndentedExpression]
Read, Int -> IndentedExpression -> ShowS
[IndentedExpression] -> ShowS
IndentedExpression -> String
(Int -> IndentedExpression -> ShowS)
-> (IndentedExpression -> String)
-> ([IndentedExpression] -> ShowS)
-> Show IndentedExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndentedExpression -> ShowS
showsPrec :: Int -> IndentedExpression -> ShowS
$cshow :: IndentedExpression -> String
show :: IndentedExpression -> String
$cshowList :: [IndentedExpression] -> ShowS
showList :: [IndentedExpression] -> ShowS
Show)

_IndentedExpression :: Name
_IndentedExpression = (String -> Name
Core.Name String
"hydra/ast.IndentedExpression")

_IndentedExpression_style :: Name
_IndentedExpression_style = (String -> Name
Core.Name String
"style")

_IndentedExpression_expr :: Name
_IndentedExpression_expr = (String -> Name
Core.Name String
"expr")

-- | Any of several indentation styles
data IndentStyle = 
  IndentStyleAllLines String |
  IndentStyleSubsequentLines String
  deriving (IndentStyle -> IndentStyle -> Bool
(IndentStyle -> IndentStyle -> Bool)
-> (IndentStyle -> IndentStyle -> Bool) -> Eq IndentStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndentStyle -> IndentStyle -> Bool
== :: IndentStyle -> IndentStyle -> Bool
$c/= :: IndentStyle -> IndentStyle -> Bool
/= :: IndentStyle -> IndentStyle -> Bool
Eq, Eq IndentStyle
Eq IndentStyle =>
(IndentStyle -> IndentStyle -> Ordering)
-> (IndentStyle -> IndentStyle -> Bool)
-> (IndentStyle -> IndentStyle -> Bool)
-> (IndentStyle -> IndentStyle -> Bool)
-> (IndentStyle -> IndentStyle -> Bool)
-> (IndentStyle -> IndentStyle -> IndentStyle)
-> (IndentStyle -> IndentStyle -> IndentStyle)
-> Ord IndentStyle
IndentStyle -> IndentStyle -> Bool
IndentStyle -> IndentStyle -> Ordering
IndentStyle -> IndentStyle -> IndentStyle
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IndentStyle -> IndentStyle -> Ordering
compare :: IndentStyle -> IndentStyle -> Ordering
$c< :: IndentStyle -> IndentStyle -> Bool
< :: IndentStyle -> IndentStyle -> Bool
$c<= :: IndentStyle -> IndentStyle -> Bool
<= :: IndentStyle -> IndentStyle -> Bool
$c> :: IndentStyle -> IndentStyle -> Bool
> :: IndentStyle -> IndentStyle -> Bool
$c>= :: IndentStyle -> IndentStyle -> Bool
>= :: IndentStyle -> IndentStyle -> Bool
$cmax :: IndentStyle -> IndentStyle -> IndentStyle
max :: IndentStyle -> IndentStyle -> IndentStyle
$cmin :: IndentStyle -> IndentStyle -> IndentStyle
min :: IndentStyle -> IndentStyle -> IndentStyle
Ord, ReadPrec [IndentStyle]
ReadPrec IndentStyle
Int -> ReadS IndentStyle
ReadS [IndentStyle]
(Int -> ReadS IndentStyle)
-> ReadS [IndentStyle]
-> ReadPrec IndentStyle
-> ReadPrec [IndentStyle]
-> Read IndentStyle
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IndentStyle
readsPrec :: Int -> ReadS IndentStyle
$creadList :: ReadS [IndentStyle]
readList :: ReadS [IndentStyle]
$creadPrec :: ReadPrec IndentStyle
readPrec :: ReadPrec IndentStyle
$creadListPrec :: ReadPrec [IndentStyle]
readListPrec :: ReadPrec [IndentStyle]
Read, Int -> IndentStyle -> ShowS
[IndentStyle] -> ShowS
IndentStyle -> String
(Int -> IndentStyle -> ShowS)
-> (IndentStyle -> String)
-> ([IndentStyle] -> ShowS)
-> Show IndentStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndentStyle -> ShowS
showsPrec :: Int -> IndentStyle -> ShowS
$cshow :: IndentStyle -> String
show :: IndentStyle -> String
$cshowList :: [IndentStyle] -> ShowS
showList :: [IndentStyle] -> ShowS
Show)

_IndentStyle :: Name
_IndentStyle = (String -> Name
Core.Name String
"hydra/ast.IndentStyle")

_IndentStyle_allLines :: Name
_IndentStyle_allLines = (String -> Name
Core.Name String
"allLines")

_IndentStyle_subsequentLines :: Name
_IndentStyle_subsequentLines = (String -> Name
Core.Name String
"subsequentLines")

-- | An operator symbol
data Op = 
  Op {
    Op -> Symbol
opSymbol :: Symbol,
    Op -> Padding
opPadding :: Padding,
    Op -> Precedence
opPrecedence :: Precedence,
    Op -> Associativity
opAssociativity :: Associativity}
  deriving (Op -> Op -> Bool
(Op -> Op -> Bool) -> (Op -> Op -> Bool) -> Eq Op
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Op -> Op -> Bool
== :: Op -> Op -> Bool
$c/= :: Op -> Op -> Bool
/= :: Op -> Op -> Bool
Eq, Eq Op
Eq Op =>
(Op -> Op -> Ordering)
-> (Op -> Op -> Bool)
-> (Op -> Op -> Bool)
-> (Op -> Op -> Bool)
-> (Op -> Op -> Bool)
-> (Op -> Op -> Op)
-> (Op -> Op -> Op)
-> Ord Op
Op -> Op -> Bool
Op -> Op -> Ordering
Op -> Op -> Op
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Op -> Op -> Ordering
compare :: Op -> Op -> Ordering
$c< :: Op -> Op -> Bool
< :: Op -> Op -> Bool
$c<= :: Op -> Op -> Bool
<= :: Op -> Op -> Bool
$c> :: Op -> Op -> Bool
> :: Op -> Op -> Bool
$c>= :: Op -> Op -> Bool
>= :: Op -> Op -> Bool
$cmax :: Op -> Op -> Op
max :: Op -> Op -> Op
$cmin :: Op -> Op -> Op
min :: Op -> Op -> Op
Ord, ReadPrec [Op]
ReadPrec Op
Int -> ReadS Op
ReadS [Op]
(Int -> ReadS Op)
-> ReadS [Op] -> ReadPrec Op -> ReadPrec [Op] -> Read Op
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Op
readsPrec :: Int -> ReadS Op
$creadList :: ReadS [Op]
readList :: ReadS [Op]
$creadPrec :: ReadPrec Op
readPrec :: ReadPrec Op
$creadListPrec :: ReadPrec [Op]
readListPrec :: ReadPrec [Op]
Read, Int -> Op -> ShowS
[Op] -> ShowS
Op -> String
(Int -> Op -> ShowS)
-> (Op -> String) -> ([Op] -> ShowS) -> Show Op
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Op -> ShowS
showsPrec :: Int -> Op -> ShowS
$cshow :: Op -> String
show :: Op -> String
$cshowList :: [Op] -> ShowS
showList :: [Op] -> ShowS
Show)

_Op :: Name
_Op = (String -> Name
Core.Name String
"hydra/ast.Op")

_Op_symbol :: Name
_Op_symbol = (String -> Name
Core.Name String
"symbol")

_Op_padding :: Name
_Op_padding = (String -> Name
Core.Name String
"padding")

_Op_precedence :: Name
_Op_precedence = (String -> Name
Core.Name String
"precedence")

_Op_associativity :: Name
_Op_associativity = (String -> Name
Core.Name String
"associativity")

-- | An operator expression
data OpExpr = 
  OpExpr {
    OpExpr -> Op
opExprOp :: Op,
    OpExpr -> Expr
opExprLhs :: Expr,
    OpExpr -> Expr
opExprRhs :: Expr}
  deriving (OpExpr -> OpExpr -> Bool
(OpExpr -> OpExpr -> Bool)
-> (OpExpr -> OpExpr -> Bool) -> Eq OpExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OpExpr -> OpExpr -> Bool
== :: OpExpr -> OpExpr -> Bool
$c/= :: OpExpr -> OpExpr -> Bool
/= :: OpExpr -> OpExpr -> Bool
Eq, Eq OpExpr
Eq OpExpr =>
(OpExpr -> OpExpr -> Ordering)
-> (OpExpr -> OpExpr -> Bool)
-> (OpExpr -> OpExpr -> Bool)
-> (OpExpr -> OpExpr -> Bool)
-> (OpExpr -> OpExpr -> Bool)
-> (OpExpr -> OpExpr -> OpExpr)
-> (OpExpr -> OpExpr -> OpExpr)
-> Ord OpExpr
OpExpr -> OpExpr -> Bool
OpExpr -> OpExpr -> Ordering
OpExpr -> OpExpr -> OpExpr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OpExpr -> OpExpr -> Ordering
compare :: OpExpr -> OpExpr -> Ordering
$c< :: OpExpr -> OpExpr -> Bool
< :: OpExpr -> OpExpr -> Bool
$c<= :: OpExpr -> OpExpr -> Bool
<= :: OpExpr -> OpExpr -> Bool
$c> :: OpExpr -> OpExpr -> Bool
> :: OpExpr -> OpExpr -> Bool
$c>= :: OpExpr -> OpExpr -> Bool
>= :: OpExpr -> OpExpr -> Bool
$cmax :: OpExpr -> OpExpr -> OpExpr
max :: OpExpr -> OpExpr -> OpExpr
$cmin :: OpExpr -> OpExpr -> OpExpr
min :: OpExpr -> OpExpr -> OpExpr
Ord, ReadPrec [OpExpr]
ReadPrec OpExpr
Int -> ReadS OpExpr
ReadS [OpExpr]
(Int -> ReadS OpExpr)
-> ReadS [OpExpr]
-> ReadPrec OpExpr
-> ReadPrec [OpExpr]
-> Read OpExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OpExpr
readsPrec :: Int -> ReadS OpExpr
$creadList :: ReadS [OpExpr]
readList :: ReadS [OpExpr]
$creadPrec :: ReadPrec OpExpr
readPrec :: ReadPrec OpExpr
$creadListPrec :: ReadPrec [OpExpr]
readListPrec :: ReadPrec [OpExpr]
Read, Int -> OpExpr -> ShowS
[OpExpr] -> ShowS
OpExpr -> String
(Int -> OpExpr -> ShowS)
-> (OpExpr -> String) -> ([OpExpr] -> ShowS) -> Show OpExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OpExpr -> ShowS
showsPrec :: Int -> OpExpr -> ShowS
$cshow :: OpExpr -> String
show :: OpExpr -> String
$cshowList :: [OpExpr] -> ShowS
showList :: [OpExpr] -> ShowS
Show)

_OpExpr :: Name
_OpExpr = (String -> Name
Core.Name String
"hydra/ast.OpExpr")

_OpExpr_op :: Name
_OpExpr_op = (String -> Name
Core.Name String
"op")

_OpExpr_lhs :: Name
_OpExpr_lhs = (String -> Name
Core.Name String
"lhs")

_OpExpr_rhs :: Name
_OpExpr_rhs = (String -> Name
Core.Name String
"rhs")

-- | Left and right padding for an operator
data Padding = 
  Padding {
    Padding -> Ws
paddingLeft :: Ws,
    Padding -> Ws
paddingRight :: Ws}
  deriving (Padding -> Padding -> Bool
(Padding -> Padding -> Bool)
-> (Padding -> Padding -> Bool) -> Eq Padding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Padding -> Padding -> Bool
== :: Padding -> Padding -> Bool
$c/= :: Padding -> Padding -> Bool
/= :: Padding -> Padding -> Bool
Eq, Eq Padding
Eq Padding =>
(Padding -> Padding -> Ordering)
-> (Padding -> Padding -> Bool)
-> (Padding -> Padding -> Bool)
-> (Padding -> Padding -> Bool)
-> (Padding -> Padding -> Bool)
-> (Padding -> Padding -> Padding)
-> (Padding -> Padding -> Padding)
-> Ord Padding
Padding -> Padding -> Bool
Padding -> Padding -> Ordering
Padding -> Padding -> Padding
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Padding -> Padding -> Ordering
compare :: Padding -> Padding -> Ordering
$c< :: Padding -> Padding -> Bool
< :: Padding -> Padding -> Bool
$c<= :: Padding -> Padding -> Bool
<= :: Padding -> Padding -> Bool
$c> :: Padding -> Padding -> Bool
> :: Padding -> Padding -> Bool
$c>= :: Padding -> Padding -> Bool
>= :: Padding -> Padding -> Bool
$cmax :: Padding -> Padding -> Padding
max :: Padding -> Padding -> Padding
$cmin :: Padding -> Padding -> Padding
min :: Padding -> Padding -> Padding
Ord, ReadPrec [Padding]
ReadPrec Padding
Int -> ReadS Padding
ReadS [Padding]
(Int -> ReadS Padding)
-> ReadS [Padding]
-> ReadPrec Padding
-> ReadPrec [Padding]
-> Read Padding
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Padding
readsPrec :: Int -> ReadS Padding
$creadList :: ReadS [Padding]
readList :: ReadS [Padding]
$creadPrec :: ReadPrec Padding
readPrec :: ReadPrec Padding
$creadListPrec :: ReadPrec [Padding]
readListPrec :: ReadPrec [Padding]
Read, Int -> Padding -> ShowS
[Padding] -> ShowS
Padding -> String
(Int -> Padding -> ShowS)
-> (Padding -> String) -> ([Padding] -> ShowS) -> Show Padding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Padding -> ShowS
showsPrec :: Int -> Padding -> ShowS
$cshow :: Padding -> String
show :: Padding -> String
$cshowList :: [Padding] -> ShowS
showList :: [Padding] -> ShowS
Show)

_Padding :: Name
_Padding = (String -> Name
Core.Name String
"hydra/ast.Padding")

_Padding_left :: Name
_Padding_left = (String -> Name
Core.Name String
"left")

_Padding_right :: Name
_Padding_right = (String -> Name
Core.Name String
"right")

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

_Precedence :: Name
_Precedence = (String -> Name
Core.Name String
"hydra/ast.Precedence")

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

_Symbol :: Name
_Symbol = (String -> Name
Core.Name String
"hydra/ast.Symbol")

-- | One of several classes of whitespace
data Ws = 
  WsNone  |
  WsSpace  |
  WsBreak  |
  WsBreakAndIndent String |
  WsDoubleBreak 
  deriving (Ws -> Ws -> Bool
(Ws -> Ws -> Bool) -> (Ws -> Ws -> Bool) -> Eq Ws
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ws -> Ws -> Bool
== :: Ws -> Ws -> Bool
$c/= :: Ws -> Ws -> Bool
/= :: Ws -> Ws -> Bool
Eq, Eq Ws
Eq Ws =>
(Ws -> Ws -> Ordering)
-> (Ws -> Ws -> Bool)
-> (Ws -> Ws -> Bool)
-> (Ws -> Ws -> Bool)
-> (Ws -> Ws -> Bool)
-> (Ws -> Ws -> Ws)
-> (Ws -> Ws -> Ws)
-> Ord Ws
Ws -> Ws -> Bool
Ws -> Ws -> Ordering
Ws -> Ws -> Ws
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Ws -> Ws -> Ordering
compare :: Ws -> Ws -> Ordering
$c< :: Ws -> Ws -> Bool
< :: Ws -> Ws -> Bool
$c<= :: Ws -> Ws -> Bool
<= :: Ws -> Ws -> Bool
$c> :: Ws -> Ws -> Bool
> :: Ws -> Ws -> Bool
$c>= :: Ws -> Ws -> Bool
>= :: Ws -> Ws -> Bool
$cmax :: Ws -> Ws -> Ws
max :: Ws -> Ws -> Ws
$cmin :: Ws -> Ws -> Ws
min :: Ws -> Ws -> Ws
Ord, ReadPrec [Ws]
ReadPrec Ws
Int -> ReadS Ws
ReadS [Ws]
(Int -> ReadS Ws)
-> ReadS [Ws] -> ReadPrec Ws -> ReadPrec [Ws] -> Read Ws
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ws
readsPrec :: Int -> ReadS Ws
$creadList :: ReadS [Ws]
readList :: ReadS [Ws]
$creadPrec :: ReadPrec Ws
readPrec :: ReadPrec Ws
$creadListPrec :: ReadPrec [Ws]
readListPrec :: ReadPrec [Ws]
Read, Int -> Ws -> ShowS
[Ws] -> ShowS
Ws -> String
(Int -> Ws -> ShowS)
-> (Ws -> String) -> ([Ws] -> ShowS) -> Show Ws
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ws -> ShowS
showsPrec :: Int -> Ws -> ShowS
$cshow :: Ws -> String
show :: Ws -> String
$cshowList :: [Ws] -> ShowS
showList :: [Ws] -> ShowS
Show)

_Ws :: Name
_Ws = (String -> Name
Core.Name String
"hydra/ast.Ws")

_Ws_none :: Name
_Ws_none = (String -> Name
Core.Name String
"none")

_Ws_space :: Name
_Ws_space = (String -> Name
Core.Name String
"space")

_Ws_break :: Name
_Ws_break = (String -> Name
Core.Name String
"break")

_Ws_breakAndIndent :: Name
_Ws_breakAndIndent = (String -> Name
Core.Name String
"breakAndIndent")

_Ws_doubleBreak :: Name
_Ws_doubleBreak = (String -> Name
Core.Name String
"doubleBreak")