Ast.hs

-- Note: this is an automatically generated file. Do not edit.

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

module Hydra.Ast where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

-- | Operator associativity
data Associativity =
  AssociativityNone |
  AssociativityLeft |
  AssociativityRight |
  AssociativityBoth
  deriving (Eq, Ord, Read, Show)

_Associativity = Core.Name "hydra.ast.Associativity"

_Associativity_none = Core.Name "none"

_Associativity_left = Core.Name "left"

_Associativity_right = Core.Name "right"

_Associativity_both = Core.Name "both"

-- | Formatting option for code blocks
data BlockStyle =
  BlockStyle {
    -- | An optional indentation string
    blockStyleIndent :: (Maybe String),
    -- | Whether to place a newline before the content
    blockStyleNewlineBeforeContent :: Bool,
    -- | Whether to place a newline after the content
    blockStyleNewlineAfterContent :: Bool}
  deriving (Eq, Ord, Read, Show)

_BlockStyle = Core.Name "hydra.ast.BlockStyle"

_BlockStyle_indent = Core.Name "indent"

_BlockStyle_newlineBeforeContent = Core.Name "newlineBeforeContent"

_BlockStyle_newlineAfterContent = Core.Name "newlineAfterContent"

-- | An expression enclosed by brackets
data BracketExpr =
  BracketExpr {
    -- | The bracket pair enclosing the expression
    bracketExprBrackets :: Brackets,
    -- | The expression within the brackets
    bracketExprEnclosed :: Expr,
    -- | The formatting style for the bracketed block
    bracketExprStyle :: BlockStyle}
  deriving (Eq, Ord, Read, Show)

_BracketExpr = Core.Name "hydra.ast.BracketExpr"

_BracketExpr_brackets = Core.Name "brackets"

_BracketExpr_enclosed = Core.Name "enclosed"

_BracketExpr_style = Core.Name "style"

-- | Matching open and close bracket symbols
data Brackets =
  Brackets {
    -- | The opening bracket symbol
    bracketsOpen :: Symbol,
    -- | The closing bracket symbol
    bracketsClose :: Symbol}
  deriving (Eq, Ord, Read, Show)

_Brackets = Core.Name "hydra.ast.Brackets"

_Brackets_open = Core.Name "open"

_Brackets_close = Core.Name "close"

-- | An abstract expression
data Expr =
  -- | A constant symbol
  ExprConst Symbol |
  -- | An indented expression
  ExprIndent IndentedExpression |
  -- | An operator expression
  ExprOp OpExpr |
  -- | A bracketed expression
  ExprBrackets BracketExpr |
  -- | A sequence of expressions joined by a separator, treated as structural layout (not subject to parenthesization)
  ExprSeq SeqExpr
  deriving (Eq, Ord, Read, Show)

_Expr = Core.Name "hydra.ast.Expr"

_Expr_const = Core.Name "const"

_Expr_indent = Core.Name "indent"

_Expr_op = Core.Name "op"

_Expr_brackets = Core.Name "brackets"

_Expr_seq = Core.Name "seq"

-- | Any of several indentation styles
data IndentStyle =
  -- | Indent all lines with the given string
  IndentStyleAllLines String |
  -- | Indent only lines after the first with the given string
  IndentStyleSubsequentLines String
  deriving (Eq, Ord, Read, Show)

_IndentStyle = Core.Name "hydra.ast.IndentStyle"

_IndentStyle_allLines = Core.Name "allLines"

_IndentStyle_subsequentLines = Core.Name "subsequentLines"

-- | An expression indented in a certain style
data IndentedExpression =
  IndentedExpression {
    -- | The indentation style
    indentedExpressionStyle :: IndentStyle,
    -- | The expression to be indented
    indentedExpressionExpr :: Expr}
  deriving (Eq, Ord, Read, Show)

_IndentedExpression = Core.Name "hydra.ast.IndentedExpression"

_IndentedExpression_style = Core.Name "style"

_IndentedExpression_expr = Core.Name "expr"

-- | An operator symbol
data Op =
  Op {
    -- | The operator symbol
    opSymbol :: Symbol,
    -- | The padding around the operator
    opPadding :: Padding,
    -- | The precedence of the operator
    opPrecedence :: Precedence,
    -- | The associativity of the operator
    opAssociativity :: Associativity}
  deriving (Eq, Ord, Read, Show)

_Op = Core.Name "hydra.ast.Op"

_Op_symbol = Core.Name "symbol"

_Op_padding = Core.Name "padding"

_Op_precedence = Core.Name "precedence"

_Op_associativity = Core.Name "associativity"

-- | An operator expression
data OpExpr =
  OpExpr {
    -- | The operator
    opExprOp :: Op,
    -- | The left-hand side operand
    opExprLhs :: Expr,
    -- | The right-hand side operand
    opExprRhs :: Expr}
  deriving (Eq, Ord, Read, Show)

_OpExpr = Core.Name "hydra.ast.OpExpr"

_OpExpr_op = Core.Name "op"

_OpExpr_lhs = Core.Name "lhs"

_OpExpr_rhs = Core.Name "rhs"

-- | Left and right padding for an operator
data Padding =
  Padding {
    -- | Padding to the left of the operator
    paddingLeft :: Ws,
    -- | Padding to the right of the operator
    paddingRight :: Ws}
  deriving (Eq, Ord, Read, Show)

_Padding = Core.Name "hydra.ast.Padding"

_Padding_left = Core.Name "left"

_Padding_right = Core.Name "right"

-- | Operator precedence
newtype Precedence =
  Precedence {
    unPrecedence :: Int}
  deriving (Eq, Ord, Read, Show)

_Precedence = Core.Name "hydra.ast.Precedence"

-- | A sequence of expressions joined by a separator operator. Unlike OpExpr, parenthesize ignores SeqExpr boundaries.
data SeqExpr =
  SeqExpr {
    -- | The separator operator
    seqExprOp :: Op,
    -- | The expressions to join
    seqExprElements :: [Expr]}
  deriving (Eq, Ord, Read, Show)

_SeqExpr = Core.Name "hydra.ast.SeqExpr"

_SeqExpr_op = Core.Name "op"

_SeqExpr_elements = Core.Name "elements"

-- | Any symbol
newtype Symbol =
  Symbol {
    unSymbol :: String}
  deriving (Eq, Ord, Read, Show)

_Symbol = Core.Name "hydra.ast.Symbol"

-- | One of several classes of whitespace
data Ws =
  -- | No whitespace
  WsNone |
  -- | A single space
  WsSpace |
  -- | A line break
  WsBreak |
  -- | A line break followed by indentation
  WsBreakAndIndent String |
  -- | Two line breaks
  WsDoubleBreak
  deriving (Eq, Ord, Read, Show)

_Ws = Core.Name "hydra.ast.Ws"

_Ws_none = Core.Name "none"

_Ws_space = Core.Name "space"

_Ws_break = Core.Name "break"

_Ws_breakAndIndent = Core.Name "breakAndIndent"

_Ws_doubleBreak = Core.Name "doubleBreak"