{-# Language FlexibleContexts, FlexibleInstances, OverloadedStrings, Rank2Types, RecordWildCards, ScopedTypeVariables,
             TypeFamilies, TypeSynonymInstances, TemplateHaskell #-}

-- | Modula-2 grammar adapted from ''Report on the Programming Language Modula-2''

module Language.Modula2.Grammar (module Language.Modula2.Grammar, Lexeme(..), ParsedLexemes(..)) where

import Control.Applicative
import Control.Arrow (first)
import Control.Monad (guard, void)
import Data.Char (isAlphaNum, isDigit, isHexDigit, isLetter, isOctDigit, isSpace)
import Data.List.NonEmpty (NonEmpty, toList)
import Data.Maybe (catMaybes)
import Data.Monoid ((<>))
import Data.Text (Text, unpack)
import Numeric (readOct, readDec, readHex, readFloat)
import Text.Grampa
import Text.Grampa.ContextFree.LeftRecursive.Transformer (ParserT, lift, tmap)
import Text.Parser.Combinators (sepBy, sepBy1, sepByNonEmpty, try)
import Text.Parser.Token (braces, brackets, parens)

import qualified Rank2.TH
import Language.Oberon.Grammar (Lexeme(..), TokenType(..), ParsedLexemes(Trailing))

import qualified Language.Modula2.Abstract as Abstract
import qualified Language.Modula2.AST as AST

type Parser = ParserT ((,) [[Lexeme]])

-- | The names and types of all the Modula-2 grammar productions
data Modula2Grammar l f p = Modula2Grammar {
   Modula2Grammar l f p -> p Ident
ident :: p Abstract.Ident,
   Modula2Grammar l f p -> p (Value l l f f)
number :: p (Abstract.Value l l f f),
   Modula2Grammar l f p -> p (Value l l f f)
integer :: p (Abstract.Value l l f f),
   Modula2Grammar l f p -> p (Value l l f f)
real :: p (Abstract.Value l l f f),
   Modula2Grammar l f p -> p Ident
scaleFactor :: p Text,
   Modula2Grammar l f p -> p Ident
hexDigit :: p Text,
   Modula2Grammar l f p -> p Ident
digit :: p Text,
   Modula2Grammar l f p -> p Ident
octalDigit :: p Text,
   Modula2Grammar l f p -> p Ident
string_prod :: p Text,
   Modula2Grammar l f p -> p (QualIdent l)
qualident :: p (Abstract.QualIdent l),
   Modula2Grammar l f p -> p (Declaration l l f f)
constantDeclaration :: p (Abstract.Declaration l l f f),
   Modula2Grammar l f p -> p (Definition l l f f)
constantDefinition :: p (Abstract.Definition l l f f),
   Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
constExpression :: p (NodeWrap (Abstract.ConstExpression l l f f)),
   Modula2Grammar l f p -> p RelOp
relation :: p Abstract.RelOp,
   Modula2Grammar l f p
-> p (f (Expression l l f f)
      -> f (Expression l l f f) -> Expression l l f f)
addOperator :: p (f (Abstract.Expression l l f f) -> f (Abstract.Expression l l f f) -> Abstract.Expression l l f f),
   Modula2Grammar l f p
-> p (f (Expression l l f f)
      -> f (Expression l l f f) -> Expression l l f f)
mulOperator :: p (f (Abstract.Expression l l f f) -> f (Abstract.Expression l l f f) -> Abstract.Expression l l f f),
   Modula2Grammar l f p -> p (Expression l l f f)
set :: p (Abstract.Expression l l f f),
   Modula2Grammar l f p -> p (Element l l f f)
element :: p (Abstract.Element l l f f),
   Modula2Grammar l f p -> p (Declaration l l f f)
typeDeclaration :: p (Abstract.Declaration l l f f),
   Modula2Grammar l f p -> p (Definition l l f f)
typeDefinition :: p (Abstract.Definition l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
type_prod :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
simpleType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
enumeration :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (IdentList l)
identList :: p (Abstract.IdentList l),
   Modula2Grammar l f p -> p (Type l l f f)
subrangeType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
arrayType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
recordType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p [f (FieldList l l f f)]
fieldListSequence :: p [f (Abstract.FieldList l l f f)],
   Modula2Grammar l f p -> p (FieldList l l f f)
fieldList :: p (Abstract.FieldList l l f f),
   Modula2Grammar l f p -> p (Variant l l f f)
variant :: p (Abstract.Variant l l f f),
   Modula2Grammar l f p -> p (NonEmpty (f (CaseLabels l l f f)))
caseLabelList :: p (NonEmpty (f (Abstract.CaseLabels l l f f))),
   Modula2Grammar l f p -> p (CaseLabels l l f f)
caseLabels :: p (Abstract.CaseLabels l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
setType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
pointerType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
procedureType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (FormalParameters l l f f)
formalTypeList :: p (Abstract.FormalParameters l l f f),
   Modula2Grammar l f p -> p (Declaration l l f f)
variableDeclaration :: p (Abstract.Declaration l l f f),
   Modula2Grammar l f p -> p (Definition l l f f)
variableDefinition :: p (Abstract.Definition l l f f),
   Modula2Grammar l f p -> p (Designator l l f f)
designator :: p (Abstract.Designator l l f f),
   Modula2Grammar l f p -> p (NonEmpty (f (Expression l l f f)))
expList :: p (NonEmpty (f (Abstract.Expression l l f f))),
   Modula2Grammar l f p -> p (NodeWrap (Expression l l f f))
expression :: p (NodeWrap (Abstract.Expression l l f f)),
   Modula2Grammar l f p -> p (NodeWrap (Expression l l f f))
simpleExpression :: p (NodeWrap (Abstract.Expression l l f f)),
   Modula2Grammar l f p -> p (NodeWrap (Expression l l f f))
term :: p (NodeWrap (Abstract.Expression l l f f)),
   Modula2Grammar l f p -> p (NodeWrap (Expression l l f f))
factor :: p (NodeWrap (Abstract.Expression l l f f)),
   Modula2Grammar l f p -> p [f (Expression l l f f)]
actualParameters :: p [f (Abstract.Expression l l f f)],
   Modula2Grammar l f p -> p (Statement l l f f)
statement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
assignment :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
procedureCall :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (NodeWrap (StatementSequence l l f f))
statementSequence :: p (NodeWrap (Abstract.StatementSequence l l f f)),
   Modula2Grammar l f p -> p (Statement l l f f)
ifStatement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
caseStatement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Case l l f f)
case_prod :: p (Abstract.Case l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
whileStatement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
repeatStatement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
forStatement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
loopStatement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Statement l l f f)
withStatement :: p (Abstract.Statement l l f f),
   Modula2Grammar l f p -> p (Declaration l l f f)
procedureDeclaration :: p (Abstract.Declaration l l f f),
   Modula2Grammar l f p -> p (Ident, ProcedureHeading l l f f)
procedureHeading :: p (Abstract.Ident, Abstract.ProcedureHeading l l f f),
   Modula2Grammar l f p -> p (Block l l f f)
block :: p (Abstract.Block l l f f),
   Modula2Grammar l f p -> p [f (Declaration l l f f)]
declarationSequence :: p [f (Abstract.Declaration l l f f)],
   Modula2Grammar l f p -> p (FormalParameters l l f f)
formalParameters :: p (Abstract.FormalParameters l l f f),
   Modula2Grammar l f p -> p (FPSection l l f f)
fPSection :: p (Abstract.FPSection l l f f),
   Modula2Grammar l f p -> p (Type l l f f)
formalType :: p (Abstract.Type l l f f),
   Modula2Grammar l f p -> p (Declaration l l f f)
moduleDeclaration :: p (Abstract.Declaration l l f f),
   Modula2Grammar l f p -> p (NodeWrap (Priority l l f f))
priority :: p (NodeWrap (Abstract.Priority l l f f)),
   Modula2Grammar l f p -> p (Export l)
export :: p (Abstract.Export l),
   Modula2Grammar l f p -> p (Import l)
import_prod :: p (Abstract.Import l),
   Modula2Grammar l f p -> p (Module l l f f)
definitionModule :: p (Abstract.Module l l f f),
   Modula2Grammar l f p -> p [f (Definition l l f f)]
definitionSequence :: p [f (Abstract.Definition l l f f)],
   Modula2Grammar l f p -> p (Module l l f f)
programModule :: p (Abstract.Module l l f f),
   Modula2Grammar l f p -> p (NodeWrap (Module l l f f))
compilationUnit :: p (NodeWrap (Abstract.Module l l f f))
   }

type NodeWrap = (,) (Position, ParsedLexemes, Position)

modula2grammar :: Grammar (Modula2Grammar AST.Language NodeWrap) Parser Text
modula2grammar :: Grammar (Modula2Grammar Language NodeWrap) Parser Ident
modula2grammar = (Grammar (Modula2Grammar Language NodeWrap) Parser Ident
 -> Grammar (Modula2Grammar Language NodeWrap) Parser Ident)
-> Grammar (Modula2Grammar Language NodeWrap) Parser Ident
forall (m :: * -> *) (g :: (* -> *) -> *).
(GrammarParsing m, g ~ ParserGrammar m, GrammarConstraint m g,
 Distributive g) =>
(g m -> g m) -> g m
fixGrammar Grammar (Modula2Grammar Language NodeWrap) Parser Ident
-> Grammar (Modula2Grammar Language NodeWrap) Parser Ident
forall l (g :: (* -> *) -> *).
(Modula2 l, LexicalParsing (Parser g Ident)) =>
GrammarBuilder (Modula2Grammar l NodeWrap) g Parser Ident
grammar

-- | All the productions of Modula-2 grammar
grammar :: forall l g. (Abstract.Modula2 l, LexicalParsing (Parser g Text))
        => GrammarBuilder (Modula2Grammar l NodeWrap) g Parser Text
grammar :: GrammarBuilder (Modula2Grammar l NodeWrap) g Parser Ident
grammar g :: Modula2Grammar l NodeWrap (Parser g Ident)
g@Modula2Grammar{Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
Parser g Ident (NodeWrap (Module l l NodeWrap NodeWrap))
Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
Parser g Ident Ident
Parser
  g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
Parser
  g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
Parser g Ident (IdentList l)
Parser g Ident RelOp
Parser g Ident (QualIdent l)
Parser g Ident (Import l)
Parser g Ident (Element l l NodeWrap NodeWrap)
Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
Parser g Ident (Case l l NodeWrap NodeWrap)
Parser g Ident (Block l l NodeWrap NodeWrap)
Parser g Ident (FPSection l l NodeWrap NodeWrap)
Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
Parser g Ident (FieldList l l NodeWrap NodeWrap)
Parser g Ident (Value l l NodeWrap NodeWrap)
Parser g Ident (Designator l l NodeWrap NodeWrap)
Parser g Ident (Expression l l NodeWrap NodeWrap)
Parser g Ident (Statement l l NodeWrap NodeWrap)
Parser g Ident (Type l l NodeWrap NodeWrap)
Parser g Ident (Declaration l l NodeWrap NodeWrap)
Parser g Ident (Module l l NodeWrap NodeWrap)
Parser g Ident (Export l)
Parser g Ident (Definition l l NodeWrap NodeWrap)
Parser g Ident (Variant l l NodeWrap NodeWrap)
Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
compilationUnit :: Parser g Ident (NodeWrap (Module l l NodeWrap NodeWrap))
programModule :: Parser g Ident (Module l l NodeWrap NodeWrap)
definitionSequence :: Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
definitionModule :: Parser g Ident (Module l l NodeWrap NodeWrap)
import_prod :: Parser g Ident (Import l)
export :: Parser g Ident (Export l)
priority :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
moduleDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
formalType :: Parser g Ident (Type l l NodeWrap NodeWrap)
fPSection :: Parser g Ident (FPSection l l NodeWrap NodeWrap)
formalParameters :: Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
declarationSequence :: Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
block :: Parser g Ident (Block l l NodeWrap NodeWrap)
procedureHeading :: Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
procedureDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
withStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
loopStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
forStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
repeatStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
whileStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
case_prod :: Parser g Ident (Case l l NodeWrap NodeWrap)
caseStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
ifStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
statementSequence :: Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
procedureCall :: Parser g Ident (Statement l l NodeWrap NodeWrap)
assignment :: Parser g Ident (Statement l l NodeWrap NodeWrap)
statement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
actualParameters :: Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
factor :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
term :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expList :: Parser
  g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
designator :: Parser g Ident (Designator l l NodeWrap NodeWrap)
variableDefinition :: Parser g Ident (Definition l l NodeWrap NodeWrap)
variableDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
formalTypeList :: Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
procedureType :: Parser g Ident (Type l l NodeWrap NodeWrap)
pointerType :: Parser g Ident (Type l l NodeWrap NodeWrap)
setType :: Parser g Ident (Type l l NodeWrap NodeWrap)
caseLabels :: Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
caseLabelList :: Parser
  g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
variant :: Parser g Ident (Variant l l NodeWrap NodeWrap)
fieldList :: Parser g Ident (FieldList l l NodeWrap NodeWrap)
fieldListSequence :: Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
recordType :: Parser g Ident (Type l l NodeWrap NodeWrap)
arrayType :: Parser g Ident (Type l l NodeWrap NodeWrap)
subrangeType :: Parser g Ident (Type l l NodeWrap NodeWrap)
identList :: Parser g Ident (IdentList l)
enumeration :: Parser g Ident (Type l l NodeWrap NodeWrap)
simpleType :: Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod :: Parser g Ident (Type l l NodeWrap NodeWrap)
typeDefinition :: Parser g Ident (Definition l l NodeWrap NodeWrap)
typeDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
element :: Parser g Ident (Element l l NodeWrap NodeWrap)
set :: Parser g Ident (Expression l l NodeWrap NodeWrap)
mulOperator :: Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
addOperator :: Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
relation :: Parser g Ident RelOp
constExpression :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constantDefinition :: Parser g Ident (Definition l l NodeWrap NodeWrap)
constantDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
qualident :: Parser g Ident (QualIdent l)
string_prod :: Parser g Ident Ident
octalDigit :: Parser g Ident Ident
digit :: Parser g Ident Ident
hexDigit :: Parser g Ident Ident
scaleFactor :: Parser g Ident Ident
real :: Parser g Ident (Value l l NodeWrap NodeWrap)
integer :: Parser g Ident (Value l l NodeWrap NodeWrap)
number :: Parser g Ident (Value l l NodeWrap NodeWrap)
ident :: Parser g Ident Ident
compilationUnit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (Module l l f f))
programModule :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Module l l f f)
definitionSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (Definition l l f f)]
definitionModule :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Module l l f f)
import_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Import l)
export :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Export l)
priority :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
moduleDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
formalType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
fPSection :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FPSection l l f f)
formalParameters :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FormalParameters l l f f)
declarationSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (Declaration l l f f)]
block :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Block l l f f)
procedureHeading :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Ident, ProcedureHeading l l f f)
procedureDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
withStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
loopStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
forStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
repeatStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
whileStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
case_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Case l l f f)
caseStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
ifStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
statementSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (StatementSequence l l f f))
procedureCall :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
assignment :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
statement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
actualParameters :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (ConstExpression l l f f)]
factor :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
term :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
simpleExpression :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
expression :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
expList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NonEmpty (f (ConstExpression l l f f)))
designator :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Designator l l f f)
variableDefinition :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
variableDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
formalTypeList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FormalParameters l l f f)
procedureType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
pointerType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
setType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
caseLabels :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (CaseLabels l l f f)
caseLabelList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NonEmpty (f (CaseLabels l l f f)))
variant :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Variant l l f f)
fieldList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FieldList l l f f)
fieldListSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (FieldList l l f f)]
recordType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
arrayType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
subrangeType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
identList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (IdentList l)
enumeration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
simpleType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
type_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
typeDefinition :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
typeDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
element :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Element l l f f)
set :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (ConstExpression l l f f)
mulOperator :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p
-> p (f (ConstExpression l l f f)
      -> f (ConstExpression l l f f) -> ConstExpression l l f f)
addOperator :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p
-> p (f (ConstExpression l l f f)
      -> f (ConstExpression l l f f) -> ConstExpression l l f f)
relation :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p RelOp
constExpression :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
constantDefinition :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
constantDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
qualident :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (QualIdent l)
string_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Ident
octalDigit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Ident
digit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Ident
hexDigit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Ident
scaleFactor :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Ident
real :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
integer :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
number :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
ident :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Ident
..} = Modula2Grammar l NodeWrap (Parser g Ident)
g{
   ident :: Parser g Ident Ident
ident = Parser g Ident Ident
forall (m :: * -> *). LexicalParsing m => m (ParserInput m)
identifier,
   number :: Parser g Ident (Value l l NodeWrap NodeWrap)
number = Parser g Ident (Value l l NodeWrap NodeWrap)
integer Parser g Ident (Value l l NodeWrap NodeWrap)
-> Parser g Ident (Value l l NodeWrap NodeWrap)
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Value l l NodeWrap NodeWrap)
real Parser g Ident (Value l l NodeWrap NodeWrap)
-> String -> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"a number",
   integer :: Parser g Ident (Value l l NodeWrap NodeWrap)
integer = Parser g Ident (Value l l NodeWrap NodeWrap)
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (Integer -> Value l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Integer -> Value l l' f' f
Abstract.integer (Integer -> Value l l NodeWrap NodeWrap)
-> ([(Integer, String)] -> Integer)
-> [(Integer, String)]
-> Value l l NodeWrap NodeWrap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Integer, String) -> Integer
forall a b. (a, b) -> a
fst ((Integer, String) -> Integer)
-> ([(Integer, String)] -> (Integer, String))
-> [(Integer, String)]
-> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Integer, String)] -> (Integer, String)
forall a. [a] -> a
head
                           ([(Integer, String)] -> Value l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ReadS Integer
forall a. (Eq a, Num a) => ReadS a
readDec ReadS Integer -> (Ident -> String) -> Ident -> [(Integer, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> String
unpack (Ident -> [(Integer, String)])
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isDigit
                                Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ReadS Integer
forall a. (Eq a, Num a) => ReadS a
readOct ReadS Integer -> (Ident -> String) -> Ident -> [(Integer, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> String
unpack (Ident -> [(Integer, String)])
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isOctDigit Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser g Ident)
"B"
                                Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ReadS Integer
forall a. (Eq a, Num a) => ReadS a
readHex ReadS Integer -> (Ident -> String) -> Ident -> [(Integer, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> String
unpack (Ident -> [(Integer, String)])
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser g Ident Ident
digit Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isHexDigit) Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [(Integer, String)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser g Ident)
"H")
                           Parser g Ident (Value l l NodeWrap NodeWrap)
-> Parser g Ident (Value l l NodeWrap NodeWrap)
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Value l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Int -> Value l l' f' f
Abstract.charCode (Int -> Value l l NodeWrap NodeWrap)
-> (Ident -> Int) -> Ident -> Value l l NodeWrap NodeWrap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, String) -> Int
forall a b. (a, b) -> a
fst ((Int, String) -> Int) -> (Ident -> (Int, String)) -> Ident -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Int, String)] -> (Int, String)
forall a. [a] -> a
head ([(Int, String)] -> (Int, String))
-> (Ident -> [(Int, String)]) -> Ident -> (Int, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadS Int
forall a. (Eq a, Num a) => ReadS a
readOct ReadS Int -> (Ident -> String) -> Ident -> [(Int, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> String
unpack
                               (Ident -> Value l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser g Ident Ident
octalDigit Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isOctDigit Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser g Ident)
"C")),
   real :: Parser g Ident (Value l l NodeWrap NodeWrap)
real = Double -> Value l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Double -> Value l l' f' f
Abstract.real (Double -> Value l l NodeWrap NodeWrap)
-> (Ident -> Double) -> Ident -> Value l l NodeWrap NodeWrap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Double, String) -> Double
forall a b. (a, b) -> a
fst ((Double, String) -> Double)
-> (Ident -> (Double, String)) -> Ident -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Double, String)] -> (Double, String)
forall a. [a] -> a
head ([(Double, String)] -> (Double, String))
-> (Ident -> [(Double, String)]) -> Ident -> (Double, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadS Double
forall a. RealFrac a => ReadS a
readFloat ReadS Double -> (Ident -> String) -> Ident -> [(Double, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> String
unpack
          (Ident -> Value l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken ((Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isDigit Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser g Ident)
"." Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isDigit Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a. (Alternative f, Monoid (f a)) => f a -> f a
moptional Parser g Ident Ident
scaleFactor),
   scaleFactor :: Parser g Ident Ident
scaleFactor = ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser g Ident)
"E" Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a. (Alternative f, Monoid (f a)) => f a -> f a
moptional (ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser g Ident)
"+" Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser g Ident)
"-") Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isDigit,
   hexDigit :: Parser g Ident Ident
hexDigit = (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
satisfyCharInput Char -> Bool
isHexDigit,
   digit :: Parser g Ident Ident
digit = (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
satisfyCharInput Char -> Bool
isDigit,
   octalDigit :: Parser g Ident Ident
octalDigit = (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
satisfyCharInput Char -> Bool
isOctDigit,
   string_prod :: Parser g Ident Ident
string_prod = Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (Char -> Parser g Ident Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\'' Parser g Ident Char -> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile (\Char
c-> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\'' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n') Parser g Ident Ident -> Parser g Ident Char -> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser g Ident Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\''
                               Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> Parser g Ident Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'"' Parser g Ident Char -> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile (\Char
c-> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'"' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n') Parser g Ident Ident -> Parser g Ident Char -> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> Parser g Ident Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'"'),
   qualident :: Parser g Ident (QualIdent l)
qualident = [Ident] -> Ident -> QualIdent l
forall l. Modula2 l => [Ident] -> Ident -> QualIdent l
Abstract.qualIdent ([Ident] -> Ident -> QualIdent l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Ident]
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Ident -> QualIdent l)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Ident]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser g Ident Ident
ident Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
".") Fixed (ParserT ((,) [[Lexeme]])) g Ident (Ident -> QualIdent l)
-> Parser g Ident Ident -> Parser g Ident (QualIdent l)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident Ident
ident,
   constantDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
constantDeclaration = IdentDef l
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Declaration l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
IdentDef l'
-> f (ConstExpression l' l' f' f') -> Declaration l l' f' f
Abstract.constantDeclaration (IdentDef l
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident -> IdentDef l
forall l. Wirthy l => Ident -> IdentDef l
Abstract.identDef (Ident -> IdentDef l)
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
ident)
                         Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
"=" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   constantDefinition :: Parser g Ident (Definition l l NodeWrap NodeWrap)
constantDefinition = IdentDef l
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Definition l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
IdentDef l'
-> f (ConstExpression l' l' f' f') -> Definition l l' f' f
Abstract.constantDefinition (IdentDef l
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Definition l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident -> IdentDef l
forall l. Wirthy l => Ident -> IdentDef l
Abstract.identDef (Ident -> IdentDef l)
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
ident)
                        Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Definition l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
"=" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Definition l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   constExpression :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression = Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   relation :: Parser g Ident RelOp
relation = RelOp
Abstract.Equal RelOp
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident RelOp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"=" Parser g Ident RelOp
-> Parser g Ident RelOp -> Parser g Ident RelOp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.Unequal RelOp
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident RelOp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"#" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"<>")
              Parser g Ident RelOp
-> Parser g Ident RelOp -> Parser g Ident RelOp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.Less RelOp
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident RelOp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"<" Parser g Ident RelOp
-> Parser g Ident RelOp -> Parser g Ident RelOp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.LessOrEqual RelOp
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident RelOp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"<=" 
              Parser g Ident RelOp
-> Parser g Ident RelOp -> Parser g Ident RelOp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.Greater RelOp
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident RelOp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
">" Parser g Ident RelOp
-> Parser g Ident RelOp -> Parser g Ident RelOp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.GreaterOrEqual RelOp
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident RelOp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
">=" 
              Parser g Ident RelOp
-> Parser g Ident RelOp -> Parser g Ident RelOp
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.In RelOp
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident RelOp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"IN",
   addOperator :: Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
addOperator = NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.add (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"+" Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.subtract (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"-" Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.or (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"OR",
   mulOperator :: Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
mulOperator = NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.multiply (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"*" Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.divide (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"/"
                 Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.integerDivide (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"DIV" Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.modulo (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"MOD"
                 Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.and (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"&" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"AND"),
   set :: Parser g Ident (Expression l l NodeWrap NodeWrap)
set = Maybe (QualIdent l)
-> [((Position, ParsedLexemes, Position),
     Element l l NodeWrap NodeWrap)]
-> Expression l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Maybe (QualIdent l')
-> [f (Element l' l' f' f')] -> Expression l l' f' f
Abstract.set (Maybe (QualIdent l)
 -> [((Position, ParsedLexemes, Position),
      Element l l NodeWrap NodeWrap)]
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (QualIdent l))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([((Position, ParsedLexemes, Position),
        Element l l NodeWrap NodeWrap)]
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (QualIdent l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (QualIdent l))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Ident (QualIdent l)
qualident Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([((Position, ParsedLexemes, Position),
     Element l l NodeWrap NodeWrap)]
   -> Expression l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       Element l l NodeWrap NodeWrap)]
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  [((Position, ParsedLexemes, Position),
    Element l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       Element l l NodeWrap NodeWrap)]
forall (m :: * -> *) a. TokenParsing m => m a -> m a
braces (Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   Element l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       Element l l NodeWrap NodeWrap)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy (Parser g Ident (Element l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Element l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Element l l NodeWrap NodeWrap)
element) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
",")),
   element :: Parser g Ident (Element l l NodeWrap NodeWrap)
element = NodeWrap (Expression l l NodeWrap NodeWrap)
-> Element l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Element l l' f' f
Abstract.element (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Element l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Element l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
             Parser g Ident (Element l l NodeWrap NodeWrap)
-> Parser g Ident (Element l l NodeWrap NodeWrap)
-> Parser g Ident (Element l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Element l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Element l l' f' f
Abstract.range (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Element l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Element l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Element l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Element l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
".." Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Element l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Element l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   typeDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
typeDeclaration = IdentDef l
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> Declaration l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
IdentDef l' -> f (Type l' l' f' f') -> Declaration l l' f' f
Abstract.typeDeclaration (IdentDef l
 -> ((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)
 -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident -> IdentDef l
forall l. Wirthy l => Ident -> IdentDef l
Abstract.identDef (Ident -> IdentDef l)
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
ident) Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
"=" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod,
   typeDefinition :: Parser g Ident (Definition l l NodeWrap NodeWrap)
typeDefinition = IdentDef l
-> Maybe
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Definition l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
IdentDef l' -> Maybe (f (Type l' l' f' f')) -> Definition l l' f' f
Abstract.typeDefinition (IdentDef l
 -> Maybe
      ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
 -> Definition l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe
        ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ident -> IdentDef l
forall l. Wirthy l => Ident -> IdentDef l
Abstract.identDef (Ident -> IdentDef l)
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
ident) Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Definition l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe
        ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap))
-> Parser g Ident (Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe
        ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
"=" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod),
   type_prod :: Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod = Parser g Ident (Type l l NodeWrap NodeWrap)
simpleType Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Type l l NodeWrap NodeWrap)
arrayType Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Type l l NodeWrap NodeWrap)
recordType Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Type l l NodeWrap NodeWrap)
setType Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Type l l NodeWrap NodeWrap)
pointerType Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Type l l NodeWrap NodeWrap)
procedureType,
   simpleType :: Parser g Ident (Type l l NodeWrap NodeWrap)
simpleType = QualIdent l -> Type l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
QualIdent l' -> Type l l' f' f
Abstract.typeReference (QualIdent l -> Type l l NodeWrap NodeWrap)
-> Parser g Ident (QualIdent l)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (QualIdent l)
qualident
                Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Type l l NodeWrap NodeWrap)
enumeration
                Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Type l l NodeWrap NodeWrap)
subrangeType,
   enumeration :: Parser g Ident (Type l l NodeWrap NodeWrap)
enumeration = IdentList l -> Type l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Modula2 l =>
IdentList l' -> Type l l' f' f
Abstract.enumeration (IdentList l -> Type l l NodeWrap NodeWrap)
-> Parser g Ident (IdentList l)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (IdentList l) -> Parser g Ident (IdentList l)
forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens Parser g Ident (IdentList l)
identList,
   identList :: Parser g Ident (IdentList l)
identList = Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (IdentList l)
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (Ident -> IdentDef l
forall l. Wirthy l => Ident -> IdentDef l
Abstract.identDef (Ident -> IdentDef l)
-> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (IdentDef l)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
ident) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
","),
   subrangeType :: Parser g Ident (Type l l NodeWrap NodeWrap)
subrangeType = Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (m :: * -> *) a. TokenParsing m => m a -> m a
brackets (Maybe (QualIdent l)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Type l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Maybe (QualIdent l')
-> f (ConstExpression l' l' f' f')
-> f (ConstExpression l' l' f' f')
-> Type l l' f' f
Abstract.subRange (Maybe (QualIdent l)
forall a. Maybe a
Nothing :: Maybe (Abstract.QualIdent l)) (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Type l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression
                            Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
".." Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression),
   arrayType :: Parser g Ident (Type l l NodeWrap NodeWrap)
arrayType =
      [((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)]
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> Type l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
[f (Type l' l' f' f')] -> f (Type l' l' f' f') -> Type l l' f' f
Abstract.arrayType ([((Position, ParsedLexemes, Position),
   Type l l NodeWrap NodeWrap)]
 -> ((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)
 -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([((Position, ParsedLexemes, Position),
        Type l l NodeWrap NodeWrap)]
      -> ((Position, ParsedLexemes, Position),
          Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"ARRAY" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)]
   -> ((Position, ParsedLexemes, Position),
       Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
simpleType) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
",") Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"OF" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod,
   recordType :: Parser g Ident (Type l l NodeWrap NodeWrap)
recordType = [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> Type l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
[f (FieldList l' l' f' f')] -> Type l l' f' f
Abstract.recordType ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
 -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"RECORD" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> Type l l NodeWrap NodeWrap)
-> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
fieldListSequence Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   fieldListSequence :: Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
fieldListSequence = [Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap))]
-> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap))]
 -> [NodeWrap (FieldList l l NodeWrap NodeWrap)])
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap))]
-> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap)))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap))]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (FieldList l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Fixed
   (ParserT ((,) [[Lexeme]]))
   g
   Ident
   (NodeWrap (FieldList l l NodeWrap NodeWrap))
 -> Fixed
      (ParserT ((,) [[Lexeme]]))
      g
      Ident
      (Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap))))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (FieldList l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (FieldList l l NodeWrap NodeWrap)))
forall a b. (a -> b) -> a -> b
$ Parser g Ident (FieldList l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (FieldList l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (FieldList l l NodeWrap NodeWrap)
fieldList) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"),
   fieldList :: Parser g Ident (FieldList l l NodeWrap NodeWrap)
fieldList = (IdentList l
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> FieldList l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
NonEmpty (IdentDef l')
-> f (Type l' l' f' f') -> FieldList l l' f' f
Abstract.fieldList (IdentList l
 -> ((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)
 -> FieldList l l NodeWrap NodeWrap)
-> Parser g Ident (IdentList l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (IdentList l)
identList Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> FieldList l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> FieldList l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod
                :: Parser g Text (Abstract.FieldList l l NodeWrap NodeWrap))
               Parser g Ident (FieldList l l NodeWrap NodeWrap)
-> Parser g Ident (FieldList l l NodeWrap NodeWrap)
-> Parser g Ident (FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Ident
-> QualIdent l
-> NonEmpty
     ((Position, ParsedLexemes, Position),
      Variant l l NodeWrap NodeWrap)
-> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> FieldList l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Maybe Ident
-> QualIdent l'
-> NonEmpty (f (Variant l' l' f' f'))
-> [f (FieldList l' l' f' f')]
-> FieldList l l' f' f
Abstract.caseFieldList (Maybe Ident
 -> QualIdent l
 -> NonEmpty
      ((Position, ParsedLexemes, Position),
       Variant l l NodeWrap NodeWrap)
 -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
 -> FieldList l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe Ident
      -> QualIdent l
      -> NonEmpty
           ((Position, ParsedLexemes, Position),
            Variant l l NodeWrap NodeWrap)
      -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"CASE" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe Ident
   -> QualIdent l
   -> NonEmpty
        ((Position, ParsedLexemes, Position),
         Variant l l NodeWrap NodeWrap)
   -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> FieldList l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (QualIdent l
      -> NonEmpty
           ((Position, ParsedLexemes, Position),
            Variant l l NodeWrap NodeWrap)
      -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe Ident)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser g Ident Ident
ident Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":") Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (QualIdent l
   -> NonEmpty
        ((Position, ParsedLexemes, Position),
         Variant l l NodeWrap NodeWrap)
   -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> FieldList l l NodeWrap NodeWrap)
-> Parser g Ident (QualIdent l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty
        ((Position, ParsedLexemes, Position),
         Variant l l NodeWrap NodeWrap)
      -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (QualIdent l)
qualident
                                          Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NonEmpty
     ((Position, ParsedLexemes, Position),
      Variant l l NodeWrap NodeWrap)
   -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> FieldList l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty
        ((Position, ParsedLexemes, Position),
         Variant l l NodeWrap NodeWrap)
      -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"OF" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NonEmpty
     ((Position, ParsedLexemes, Position),
      Variant l l NodeWrap NodeWrap)
   -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> FieldList l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty
        ((Position, ParsedLexemes, Position),
         Variant l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   Variant l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty
        ((Position, ParsedLexemes, Position),
         Variant l l NodeWrap NodeWrap))
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (Parser g Ident (Variant l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Variant l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Variant l l NodeWrap NodeWrap)
variant) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
"|")
                                          Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> FieldList l l NodeWrap NodeWrap)
-> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> Parser g Ident (FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. (Alternative f, Monoid (f a)) => f a -> f a
moptional (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"ELSE" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
fieldListSequence) Parser g Ident (FieldList l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (FieldList l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   variant :: Parser g Ident (Variant l l NodeWrap NodeWrap)
variant = NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap))
-> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> Variant l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
NonEmpty (f (CaseLabels l' l' f' f'))
-> [f (FieldList l' l' f' f')] -> Variant l l' f' f
Abstract.variant (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap))
 -> [NodeWrap (FieldList l l NodeWrap NodeWrap)]
 -> Variant l l NodeWrap NodeWrap)
-> Parser
     g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> Variant l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
caseLabelList Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> Variant l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
      -> Variant l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([NodeWrap (FieldList l l NodeWrap NodeWrap)]
   -> Variant l l NodeWrap NodeWrap)
-> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
-> Parser g Ident (Variant l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident [NodeWrap (FieldList l l NodeWrap NodeWrap)]
fieldListSequence,
   caseLabelList :: Parser
  g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
caseLabelList = Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (CaseLabels l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (CaseLabels l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
caseLabels) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
","),
   caseLabels :: Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
caseLabels = NodeWrap (Expression l l NodeWrap NodeWrap)
-> CaseLabels l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (ConstExpression l' l' f' f') -> CaseLabels l l' f' f
Abstract.singleLabel (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> CaseLabels l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression
                Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
-> Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
-> Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> CaseLabels l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (ConstExpression l' l' f' f')
-> f (ConstExpression l' l' f' f') -> CaseLabels l l' f' f
Abstract.labelRange (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> CaseLabels l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> CaseLabels l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> CaseLabels l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> CaseLabels l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
".." Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> CaseLabels l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (CaseLabels l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   setType :: Parser g Ident (Type l l NodeWrap NodeWrap)
setType = ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Type l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
f (Type l' l' f' f') -> Type l l' f' f
Abstract.setType (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
 -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"SET" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"OF" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
simpleType,
   pointerType :: Parser g Ident (Type l l NodeWrap NodeWrap)
pointerType = ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Type l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Type l' l' f' f') -> Type l l' f' f
Abstract.pointerType (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
 -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"POINTER" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"TO" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod,
   procedureType :: Parser g Ident (Type l l NodeWrap NodeWrap)
procedureType = Maybe
  ((Position, ParsedLexemes, Position),
   FormalParameters l l NodeWrap NodeWrap)
-> Type l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Maybe (f (FormalParameters l' l' f' f')) -> Type l l' f' f
Abstract.procedureType (Maybe
   ((Position, ParsedLexemes, Position),
    FormalParameters l l NodeWrap NodeWrap)
 -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe
        ((Position, ParsedLexemes, Position),
         FormalParameters l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"PROCEDURE" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe
     ((Position, ParsedLexemes, Position),
      FormalParameters l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe
        ((Position, ParsedLexemes, Position),
         FormalParameters l l NodeWrap NodeWrap))
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   FormalParameters l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe
        ((Position, ParsedLexemes, Position),
         FormalParameters l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      FormalParameters l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
formalTypeList),
   formalTypeList :: Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
formalTypeList = [((Position, ParsedLexemes, Position),
  FPSection l l NodeWrap NodeWrap)]
-> Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (FPSection l' l' f' f')]
-> Maybe (ReturnType l') -> FormalParameters l l' f' f
Abstract.formalParameters
                    ([((Position, ParsedLexemes, Position),
   FPSection l l NodeWrap NodeWrap)]
 -> Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       FPSection l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  [((Position, ParsedLexemes, Position),
    FPSection l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       FPSection l l NodeWrap NodeWrap)]
forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens (Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   FPSection l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       FPSection l l NodeWrap NodeWrap)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy (Parser g Ident (FPSection l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      FPSection l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (Parser g Ident (FPSection l l NodeWrap NodeWrap)
 -> Fixed
      (ParserT ((,) [[Lexeme]]))
      g
      Ident
      ((Position, ParsedLexemes, Position),
       FPSection l l NodeWrap NodeWrap))
-> Parser g Ident (FPSection l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      FPSection l l NodeWrap NodeWrap)
forall a b. (a -> b) -> a -> b
$
                                       Bool
-> [Ident]
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> FPSection l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Bool -> [Ident] -> f (Type l' l' f' f') -> FPSection l l' f' f
Abstract.fpSection (Bool
 -> [Ident]
 -> ((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)
 -> FPSection l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([Ident]
      -> ((Position, ParsedLexemes, Position),
          Type l l NodeWrap NodeWrap)
      -> FPSection l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bool
True Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"VAR" Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool -> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False) Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([Ident]
   -> ((Position, ParsedLexemes, Position),
       Type l l NodeWrap NodeWrap)
   -> FPSection l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Ident]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> FPSection l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Ident] -> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Ident]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [] Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> FPSection l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (FPSection l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
formalType)
                                      (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
","))
                    Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (QualIdent l))
-> Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (QualIdent l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (QualIdent l))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (QualIdent l) -> Parser g Ident (QualIdent l)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident (QualIdent l)
qualident),
   variableDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
variableDeclaration = IdentList l
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> Declaration l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
IdentList l' -> f (Type l' l' f' f') -> Declaration l l' f' f
Abstract.variableDeclaration (IdentList l
 -> ((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)
 -> Declaration l l NodeWrap NodeWrap)
-> Parser g Ident (IdentList l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (IdentList l)
identList Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod,
   variableDefinition :: Parser g Ident (Definition l l NodeWrap NodeWrap)
variableDefinition = IdentList l
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> Definition l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
IdentList l' -> f (Type l' l' f' f') -> Definition l l' f' f
Abstract.variableDefinition (IdentList l
 -> ((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)
 -> Definition l l NodeWrap NodeWrap)
-> Parser g Ident (IdentList l)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (IdentList l)
identList Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Definition l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Definition l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
type_prod,
   designator :: Parser g Ident (Designator l l NodeWrap NodeWrap)
designator = QualIdent l -> Designator l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
QualIdent l' -> Designator l l' f' f
Abstract.variable (QualIdent l -> Designator l l NodeWrap NodeWrap)
-> (Ident -> QualIdent l)
-> Ident
-> Designator l l NodeWrap NodeWrap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> QualIdent l
forall l. Wirthy l => Ident -> QualIdent l
Abstract.nonQualIdent (Ident -> Designator l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
ident -- qualident
                Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> Ident -> Designator l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f') -> Ident -> Designator l l' f' f
Abstract.field (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> Ident -> Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Ident -> Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Ident -> Designator l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Ident -> Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
"." Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Ident -> Designator l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident Ident
ident
                Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Designator l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> NonEmpty (f (Expression l' l' f' f')) -> Designator l l' f' f
Abstract.index (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap))
 -> Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> Designator l l NodeWrap NodeWrap)
-> Parser
     g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser
  g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
-> Parser
     g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
forall (m :: * -> *) a. TokenParsing m => m a -> m a
brackets Parser
  g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
expList
                Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> Designator l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f') -> Designator l l' f' f
Abstract.dereference (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Designator l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"^",
   expList :: Parser
  g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
expList = Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g Ident (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
","),
   expression :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression = Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression
                Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap ((RelOp
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> RelOp
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall a b c. (a -> b -> c) -> b -> a -> c
flip RelOp
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
RelOp
-> f (Expression l' l' f' f')
-> f (Expression l' l' f' f')
-> Expression l l' f' f
Abstract.relation (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> RelOp
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (RelOp
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (RelOp
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident RelOp
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident RelOp
relation Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression)
                Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> String
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"expression",
   simpleExpression :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression =
      Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.positive (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"+" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
term
            Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.negative (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"-" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
term)
      Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
term
      Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
addOperator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
term),
   term :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
term = Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
factor Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
term Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
mulOperator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
factor),
   factor :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
factor = Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (((Position, ParsedLexemes, Position), Value l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Value l' l' f' f') -> Expression l l' f' f
Abstract.literal (((Position, ParsedLexemes, Position), Value l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Value l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Value l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Value l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (Parser g Ident (Value l l NodeWrap NodeWrap)
number
                                             Parser g Ident (Value l l NodeWrap NodeWrap)
-> Parser g Ident (Value l l NodeWrap NodeWrap)
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Ident -> Value l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Ident -> Value l l' f' f
Abstract.string (Ident -> Value l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Value l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
string_prod)
                  Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Expression l l NodeWrap NodeWrap)
set
                  Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f') -> Expression l l' f' f
Abstract.read (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator
                  Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> [NodeWrap (Expression l l NodeWrap NodeWrap)]
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> [f (Expression l' l' f' f')] -> Expression l l' f' f
Abstract.functionCall (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> [NodeWrap (Expression l l NodeWrap NodeWrap)]
 -> Expression l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([NodeWrap (Expression l l NodeWrap NodeWrap)]
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([NodeWrap (Expression l l NodeWrap NodeWrap)]
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
actualParameters
                  Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (NodeWrap (Expression l l NodeWrap NodeWrap)
-> Expression l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.not (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Expression l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
operator Ident
"~" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"NOT") Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Expression l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
factor
                       :: Parser g Text (Abstract.Expression l l NodeWrap NodeWrap)))
            Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   actualParameters :: Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
actualParameters = Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens (Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
",")),
   statement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
statement = Parser g Ident (Statement l l NodeWrap NodeWrap)
assignment Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
procedureCall Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
ifStatement Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
caseStatement 
               Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
whileStatement Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
repeatStatement Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
loopStatement Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
forStatement Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Statement l l NodeWrap NodeWrap)
withStatement 
               Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Statement l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Statement l l' f' f
Abstract.exitStatement Statement l l NodeWrap NodeWrap
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"EXIT" 
               Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Maybe (f (Expression l' l' f' f')) -> Statement l l' f' f
Abstract.returnStatement (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"RETURN" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
               Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Statement l l NodeWrap NodeWrap
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Statement l l' f' f
Abstract.emptyStatement
               Parser g Ident (Statement l l NodeWrap NodeWrap)
-> String -> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"statement",
   assignment :: Parser g Ident (Statement l l NodeWrap NodeWrap)
assignment  =  ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> f (Expression l' l' f' f') -> Statement l l' f' f
Abstract.assignment (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":=" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   procedureCall :: Parser g Ident (Statement l l NodeWrap NodeWrap)
procedureCall = ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> Maybe [NodeWrap (Expression l l NodeWrap NodeWrap)]
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> Maybe [f (Expression l' l' f' f')] -> Statement l l' f' f
Abstract.procedureCall (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> Maybe [NodeWrap (Expression l l NodeWrap NodeWrap)]
 -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe [NodeWrap (Expression l l NodeWrap NodeWrap)]
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe [NodeWrap (Expression l l NodeWrap NodeWrap)]
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe [NodeWrap (Expression l l NodeWrap NodeWrap)])
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe [NodeWrap (Expression l l NodeWrap NodeWrap)])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Ident [NodeWrap (Expression l l NodeWrap NodeWrap)]
actualParameters,
   statementSequence :: Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence = Parser g Ident (StatementSequence l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap ([((Position, ParsedLexemes, Position),
  Statement l l NodeWrap NodeWrap)]
-> StatementSequence l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (Statement l' l' f' f')] -> StatementSequence l l' f' f
Abstract.statementSequence ([((Position, ParsedLexemes, Position),
   Statement l l NodeWrap NodeWrap)]
 -> StatementSequence l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       Statement l l NodeWrap NodeWrap)]
-> Parser g Ident (StatementSequence l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       Statement l l NodeWrap NodeWrap)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Statement l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Statement l l NodeWrap NodeWrap)
statement) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";")),
   ifStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
ifStatement = NonEmpty
  ((Position, ParsedLexemes, Position),
   ConditionalBranch l l NodeWrap NodeWrap)
-> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
NonEmpty (f (ConditionalBranch l' l' f' f'))
-> Maybe (f (StatementSequence l' l' f' f')) -> Statement l l' f' f
Abstract.ifStatement (NonEmpty
   ((Position, ParsedLexemes, Position),
    ConditionalBranch l l NodeWrap NodeWrap)
 -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty
        ((Position, ParsedLexemes, Position),
         ConditionalBranch l l NodeWrap NodeWrap)
      -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"IF"
       Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NonEmpty
     ((Position, ParsedLexemes, Position),
      ConditionalBranch l l NodeWrap NodeWrap)
   -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty
        ((Position, ParsedLexemes, Position),
         ConditionalBranch l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   ConditionalBranch l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NonEmpty
        ((Position, ParsedLexemes, Position),
         ConditionalBranch l l NodeWrap NodeWrap))
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (Parser g Ident (ConditionalBranch l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      ConditionalBranch l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (Parser g Ident (ConditionalBranch l l NodeWrap NodeWrap)
 -> Fixed
      (ParserT ((,) [[Lexeme]]))
      g
      Ident
      ((Position, ParsedLexemes, Position),
       ConditionalBranch l l NodeWrap NodeWrap))
-> Parser g Ident (ConditionalBranch l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      ConditionalBranch l l NodeWrap NodeWrap)
forall a b. (a -> b) -> a -> b
$ NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
-> ConditionalBranch l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (StatementSequence l' l' f' f') -> ConditionalBranch l l' f' f
Abstract.conditionalBranch (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
 -> ConditionalBranch l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> ConditionalBranch l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> ConditionalBranch l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> ConditionalBranch l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"THEN" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> ConditionalBranch l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser g Ident (ConditionalBranch l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence)
                         (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"ELSIF")
       Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap)))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"ELSE" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence) Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   caseStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
caseStatement = NodeWrap (Expression l l NodeWrap NodeWrap)
-> [((Position, ParsedLexemes, Position),
     Case l l NodeWrap NodeWrap)]
-> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> [f (Case l' l' f' f')]
-> Maybe (f (StatementSequence l' l' f' f'))
-> Statement l l' f' f
Abstract.caseStatement (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> [((Position, ParsedLexemes, Position),
      Case l l NodeWrap NodeWrap)]
 -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> [((Position, ParsedLexemes, Position),
           Case l l NodeWrap NodeWrap)]
      -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"CASE" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> [((Position, ParsedLexemes, Position),
        Case l l NodeWrap NodeWrap)]
   -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
   -> Statement l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([((Position, ParsedLexemes, Position),
        Case l l NodeWrap NodeWrap)]
      -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
       Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([((Position, ParsedLexemes, Position),
     Case l l NodeWrap NodeWrap)]
   -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([((Position, ParsedLexemes, Position),
        Case l l NodeWrap NodeWrap)]
      -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"OF" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([((Position, ParsedLexemes, Position),
     Case l l NodeWrap NodeWrap)]
   -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position), Case l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position), Case l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position), Case l l NodeWrap NodeWrap)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (Parser g Ident (Case l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Case l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Case l l NodeWrap NodeWrap)
case_prod) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
"|")
       Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap)))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"ELSE" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence) Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   case_prod :: Parser g Ident (Case l l NodeWrap NodeWrap)
case_prod = NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap))
-> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
-> Case l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
NonEmpty (f (CaseLabels l' l' f' f'))
-> f (StatementSequence l' l' f' f') -> Case l l' f' f
Abstract.caseAlternative (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap))
 -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
 -> Case l l NodeWrap NodeWrap)
-> Parser
     g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Case l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  g Ident (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
caseLabelList Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Case l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Case l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Case l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser g Ident (Case l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence,
   whileStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
whileStatement = NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (StatementSequence l' l' f' f') -> Statement l l' f' f
Abstract.whileStatement (NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"WHILE" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"DO"
                    Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   repeatStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
repeatStatement = NodeWrap (StatementSequence l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (StatementSequence l' l' f' f')
-> f (Expression l' l' f' f') -> Statement l l' f' f
Abstract.repeatStatement (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"REPEAT"
                     Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"UNTIL" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   forStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
forStatement = 
      Ident
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> NodeWrap (Expression l l NodeWrap NodeWrap)
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Ident
-> f (Expression l' l' f' f')
-> f (Expression l' l' f' f')
-> Maybe (f (Expression l' l' f' f'))
-> f (StatementSequence l' l' f' f')
-> Statement l l' f' f
Abstract.forStatement (Ident
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> NodeWrap (Expression l l NodeWrap NodeWrap)
 -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
 -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Ident
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"FOR" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Ident
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident Ident
ident Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":=" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
      Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Expression l l NodeWrap NodeWrap)
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"TO" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
expression Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"BY" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression)
      Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"DO" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   loopStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
loopStatement = NodeWrap (StatementSequence l l NodeWrap NodeWrap)
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (StatementSequence l' l' f' f') -> Statement l l' f' f
Abstract.loopStatement (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"LOOP" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   withStatement :: Parser g Ident (Statement l l NodeWrap NodeWrap)
withStatement = ((Position, ParsedLexemes, Position),
 Designator l l NodeWrap NodeWrap)
-> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
-> Statement l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
f (Designator l' l' f' f')
-> f (StatementSequence l' l' f' f') -> Statement l l' f' f
Abstract.withStatement (((Position, ParsedLexemes, Position),
  Designator l l NodeWrap NodeWrap)
 -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
 -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position),
       Designator l l NodeWrap NodeWrap)
      -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"WITH" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position),
    Designator l l NodeWrap NodeWrap)
   -> NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Designator l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      Designator l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Designator l l NodeWrap NodeWrap)
designator Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
      -> Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"DO"
                   Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (StatementSequence l l NodeWrap NodeWrap)
   -> Statement l l NodeWrap NodeWrap)
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence Parser g Ident (Statement l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Statement l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   procedureDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
procedureDeclaration = do (Ident
procedureName, ((Position, ParsedLexemes, Position),
 ProcedureHeading l l NodeWrap NodeWrap)
heading) <- ((Position, ParsedLexemes, Position),
 (Ident, ProcedureHeading l l NodeWrap NodeWrap))
-> (Ident,
    ((Position, ParsedLexemes, Position),
     ProcedureHeading l l NodeWrap NodeWrap))
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA (((Position, ParsedLexemes, Position),
  (Ident, ProcedureHeading l l NodeWrap NodeWrap))
 -> (Ident,
     ((Position, ParsedLexemes, Position),
      ProcedureHeading l l NodeWrap NodeWrap)))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      (Ident, ProcedureHeading l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Ident,
      ((Position, ParsedLexemes, Position),
       ProcedureHeading l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      (Ident, ProcedureHeading l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
procedureHeading
                             Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"
                             NodeWrap (Block l l NodeWrap NodeWrap)
body <- Parser g Ident (Block l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Block l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Block l l NodeWrap NodeWrap)
block
                             Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Ident
ParserInput (Parser g Ident)
procedureName)
                             Declaration l l NodeWrap NodeWrap
-> Parser g Ident (Declaration l l NodeWrap NodeWrap)
forall (m :: * -> *) a. Monad m => a -> m a
return (((Position, ParsedLexemes, Position),
 ProcedureHeading l l NodeWrap NodeWrap)
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Declaration l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (ProcedureHeading l' l' f' f')
-> f (Block l' l' f' f') -> Declaration l l' f' f
Abstract.procedureDeclaration ((Position, ParsedLexemes, Position),
 ProcedureHeading l l NodeWrap NodeWrap)
heading NodeWrap (Block l l NodeWrap NodeWrap)
body),
   procedureHeading :: Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
procedureHeading = Ident
-> Maybe
     ((Position, ParsedLexemes, Position),
      FormalParameters l l NodeWrap NodeWrap)
-> ProcedureHeading l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Ident
-> Maybe (f (FormalParameters l' l' f' f'))
-> ProcedureHeading l l' f' f
Abstract.procedureHeading (Ident
 -> Maybe
      ((Position, ParsedLexemes, Position),
       FormalParameters l l NodeWrap NodeWrap)
 -> ProcedureHeading l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Ident
      -> Maybe
           ((Position, ParsedLexemes, Position),
            FormalParameters l l NodeWrap NodeWrap)
      -> ProcedureHeading l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"PROCEDURE"
                      Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Ident
   -> Maybe
        ((Position, ParsedLexemes, Position),
         FormalParameters l l NodeWrap NodeWrap)
   -> ProcedureHeading l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Ident
       -> Maybe
            ((Position, ParsedLexemes, Position),
             FormalParameters l l NodeWrap NodeWrap)
       -> ProcedureHeading l l NodeWrap NodeWrap)
      -> (Ident, ProcedureHeading l l NodeWrap NodeWrap))
-> Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> do Ident
name <- Parser g Ident Ident
ident
                              Maybe
  ((Position, ParsedLexemes, Position),
   FormalParameters l l NodeWrap NodeWrap)
params <- Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   FormalParameters l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe
        ((Position, ParsedLexemes, Position),
         FormalParameters l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      FormalParameters l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
formalParameters)
                              ((Ident
  -> Maybe
       ((Position, ParsedLexemes, Position),
        FormalParameters l l NodeWrap NodeWrap)
  -> ProcedureHeading l l NodeWrap NodeWrap)
 -> (Ident, ProcedureHeading l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Ident
       -> Maybe
            ((Position, ParsedLexemes, Position),
             FormalParameters l l NodeWrap NodeWrap)
       -> ProcedureHeading l l NodeWrap NodeWrap)
      -> (Ident, ProcedureHeading l l NodeWrap NodeWrap))
forall (m :: * -> *) a. Monad m => a -> m a
return (\Ident
-> Maybe
     ((Position, ParsedLexemes, Position),
      FormalParameters l l NodeWrap NodeWrap)
-> ProcedureHeading l l NodeWrap NodeWrap
proc-> (Ident
name, Ident
-> Maybe
     ((Position, ParsedLexemes, Position),
      FormalParameters l l NodeWrap NodeWrap)
-> ProcedureHeading l l NodeWrap NodeWrap
proc Ident
name Maybe
  ((Position, ParsedLexemes, Position),
   FormalParameters l l NodeWrap NodeWrap)
params)),
   block :: Parser g Ident (Block l l NodeWrap NodeWrap)
block = [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Block l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (Declaration l' l' f' f')]
-> Maybe (f (StatementSequence l' l' f' f')) -> Block l l' f' f
Abstract.block ([NodeWrap (Declaration l l NodeWrap NodeWrap)]
 -> Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
 -> Block l l NodeWrap NodeWrap)
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
      -> Block l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
declarationSequence Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
   -> Block l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap)))
-> Parser g Ident (Block l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (StatementSequence l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"BEGIN" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
-> Parser
     g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence)
           Parser g Ident (Block l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Block l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END",
   declarationSequence :: Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
declarationSequence = Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (p :: * -> *) a. (Alternative p, Monoid a) => p a -> p a
concatMany (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"CONST" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser g Ident (Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Declaration l l NodeWrap NodeWrap)
constantDeclaration Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";")
                                     Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"TYPE" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser g Ident (Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Declaration l l NodeWrap NodeWrap)
typeDeclaration Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";")
                                     Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"VAR" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser g Ident (Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Declaration l l NodeWrap NodeWrap)
variableDeclaration Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";")
                                     Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (NodeWrap (Declaration l l NodeWrap NodeWrap)
-> [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall a. a -> [a] -> [a]
:[]) (NodeWrap (Declaration l l NodeWrap NodeWrap)
 -> [NodeWrap (Declaration l l NodeWrap NodeWrap)])
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser g Ident (Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Declaration l l NodeWrap NodeWrap)
procedureDeclaration Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"
                                                    Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Declaration l l NodeWrap NodeWrap)
moduleDeclaration Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Declaration l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Declaration l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"))
                         Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
-> String
-> Parser g Ident [NodeWrap (Declaration l l NodeWrap NodeWrap)]
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"declarations",
   formalParameters :: Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
formalParameters = [((Position, ParsedLexemes, Position),
  FPSection l l NodeWrap NodeWrap)]
-> Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (FPSection l' l' f' f')]
-> Maybe (ReturnType l') -> FormalParameters l l' f' f
Abstract.formalParameters ([((Position, ParsedLexemes, Position),
   FPSection l l NodeWrap NodeWrap)]
 -> Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       FPSection l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  [((Position, ParsedLexemes, Position),
    FPSection l l NodeWrap NodeWrap)]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       FPSection l l NodeWrap NodeWrap)]
forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens (Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ((Position, ParsedLexemes, Position),
   FPSection l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     [((Position, ParsedLexemes, Position),
       FPSection l l NodeWrap NodeWrap)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy (Parser g Ident (FPSection l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      FPSection l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (FPSection l l NodeWrap NodeWrap)
fPSection) (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"))
                      Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (QualIdent l) -> FormalParameters l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (QualIdent l))
-> Parser g Ident (FormalParameters l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (QualIdent l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (QualIdent l))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (QualIdent l) -> Parser g Ident (QualIdent l)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident (QualIdent l)
qualident),
   fPSection :: Parser g Ident (FPSection l l NodeWrap NodeWrap)
fPSection = Bool
-> [Ident]
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> FPSection l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Bool -> [Ident] -> f (Type l' l' f' f') -> FPSection l l' f' f
Abstract.fpSection (Bool
 -> [Ident]
 -> ((Position, ParsedLexemes, Position),
     Type l l NodeWrap NodeWrap)
 -> FPSection l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([Ident]
      -> ((Position, ParsedLexemes, Position),
          Type l l NodeWrap NodeWrap)
      -> FPSection l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bool
True Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"VAR" Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool -> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False) 
               Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([Ident]
   -> ((Position, ParsedLexemes, Position),
       Type l l NodeWrap NodeWrap)
   -> FPSection l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Ident]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> FPSection l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Ident]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 Parser g Ident Ident
ident (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
",") Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> FPSection l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> FPSection l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
":" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> FPSection l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (FPSection l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
formalType,
   formalType :: Parser g Ident (Type l l NodeWrap NodeWrap)
formalType = [((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)]
-> ((Position, ParsedLexemes, Position),
    Type l l NodeWrap NodeWrap)
-> Type l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
[f (Type l' l' f' f')] -> f (Type l' l' f' f') -> Type l l' f' f
Abstract.arrayType [] (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
 -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"ARRAY" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
      -> Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"OF" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
   -> Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position), Type l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Type l l NodeWrap NodeWrap)
formalType 
                Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> QualIdent l -> Type l l NodeWrap NodeWrap
forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
QualIdent l' -> Type l l' f' f
Abstract.typeReference (QualIdent l -> Type l l NodeWrap NodeWrap)
-> Parser g Ident (QualIdent l)
-> Parser g Ident (Type l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (QualIdent l)
qualident,
   moduleDeclaration :: Parser g Ident (Declaration l l NodeWrap NodeWrap)
moduleDeclaration = do ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"MODULE"
                          Ident
name <- Parser g Ident Ident
ident
                          Ident
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> [Import l]
-> Maybe (Export l)
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Declaration l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Ident
-> Maybe (f (Priority l' l' f' f'))
-> [Import l']
-> Maybe (Export l')
-> f (Block l' l' f' f')
-> Declaration l l' f' f
Abstract.moduleDeclaration Ident
name (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
 -> [Import l]
 -> Maybe (Export l)
 -> NodeWrap (Block l l NodeWrap NodeWrap)
 -> Declaration l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([Import l]
      -> Maybe (Export l)
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
priority Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([Import l]
   -> Maybe (Export l)
   -> NodeWrap (Block l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([Import l]
      -> Maybe (Export l)
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"
                             Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([Import l]
   -> Maybe (Export l)
   -> NodeWrap (Block l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Import l]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (Export l)
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Import l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Import l]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser g Ident (Import l)
import_prod Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (Export l)
   -> NodeWrap (Block l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (Export l))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Block l l NodeWrap NodeWrap)
      -> Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Export l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (Export l))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Ident (Export l)
export Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Block l l NodeWrap NodeWrap)
   -> Declaration l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Block l l NodeWrap NodeWrap))
-> Parser g Ident (Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Block l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Block l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Block l l NodeWrap NodeWrap)
block Parser g Ident (Declaration l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Declaration l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Ident
ParserInput (Parser g Ident)
name),
   priority :: Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
priority = Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
forall (m :: * -> *) a. TokenParsing m => m a -> m a
brackets Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   export :: Parser g Ident (Export l)
export = Bool -> NonEmpty Ident -> Export l
forall l. Modula2 l => Bool -> NonEmpty Ident -> Export l
Abstract.moduleExport (Bool -> NonEmpty Ident -> Export l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Bool -> NonEmpty Ident -> Export l)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"EXPORT" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Bool -> NonEmpty Ident -> Export l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident -> Export l)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Bool
True Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"QUALIFIED" Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool -> Fixed (ParserT ((,) [[Lexeme]])) g Ident Bool
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False)
            Fixed
  (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident -> Export l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident)
-> Parser g Ident (Export l)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident)
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty Parser g Ident Ident
ident (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
",") Parser g Ident (Export l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Export l)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";",
   import_prod :: Parser g Ident (Import l)
import_prod = Maybe Ident -> NonEmpty Ident -> Import l
forall l. Modula2 l => Maybe Ident -> NonEmpty Ident -> Import l
Abstract.moduleImport (Maybe Ident -> NonEmpty Ident -> Import l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident -> Import l)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe Ident)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"FROM" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident Ident
ident)
                 Fixed
  (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident -> Import l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident -> Import l)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"IMPORT" Fixed
  (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident -> Import l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident)
-> Parser g Ident (Import l)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (NonEmpty Ident)
forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty Parser g Ident Ident
ident (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
",") Parser g Ident (Import l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Import l)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";",
   definitionModule :: Parser g Ident (Module l l NodeWrap NodeWrap)
definitionModule = ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"DEFINITION" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"MODULE" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Module l l NodeWrap NodeWrap)
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
                      do Ident
name <- Parser g Ident Ident
ident
                         Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"
                         Ident
-> [Import l]
-> Maybe (Export l)
-> [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Module l l NodeWrap NodeWrap
forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Ident
-> [Import l']
-> Maybe (Export l')
-> [f (Definition l' l' f' f')]
-> Module l l' f' f
Abstract.definitionModule Ident
name ([Import l]
 -> Maybe (Export l)
 -> [NodeWrap (Definition l l NodeWrap NodeWrap)]
 -> Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Import l]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (Export l)
      -> [NodeWrap (Definition l l NodeWrap NodeWrap)]
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Import l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Import l]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser g Ident (Import l)
import_prod Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (Maybe (Export l)
   -> [NodeWrap (Definition l l NodeWrap NodeWrap)]
   -> Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (Export l))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([NodeWrap (Definition l l NodeWrap NodeWrap)]
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Export l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (Maybe (Export l))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Ident (Export l)
export Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([NodeWrap (Definition l l NodeWrap NodeWrap)]
   -> Module l l NodeWrap NodeWrap)
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
definitionSequence
                                                   Parser g Ident (Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"END" Parser g Ident (Module l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Ident
ParserInput (Parser g Ident)
name) Parser g Ident (Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
".",
   definitionSequence :: Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
definitionSequence =  Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (p :: * -> *) a. (Alternative p, Monoid a) => p a -> p a
concatMany (ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"CONST" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser g Ident (Definition l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Definition l l NodeWrap NodeWrap)
constantDefinition Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";")
                                     Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"TYPE" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser g Ident (Definition l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Definition l l NodeWrap NodeWrap)
typeDefinition Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";")
                                     Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"VAR" Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parser g Ident (Definition l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Definition l l NodeWrap NodeWrap)
variableDefinition Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";")
                                     Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (NodeWrap (Definition l l NodeWrap NodeWrap)
-> [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall a. a -> [a] -> [a]
:[]) (NodeWrap (Definition l l NodeWrap NodeWrap)
 -> [NodeWrap (Definition l l NodeWrap NodeWrap)])
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser g Ident (Definition l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (((Position, ParsedLexemes, Position),
 ProcedureHeading l l NodeWrap NodeWrap)
-> Definition l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
f (ProcedureHeading l' l' f' f') -> Definition l l' f' f
Abstract.procedureDefinition (((Position, ParsedLexemes, Position),
  ProcedureHeading l l NodeWrap NodeWrap)
 -> Definition l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      ProcedureHeading l l NodeWrap NodeWrap)
-> Parser g Ident (Definition l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (ProcedureHeading l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ((Position, ParsedLexemes, Position),
      ProcedureHeading l l NodeWrap NodeWrap)
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap ((Ident, ProcedureHeading l l NodeWrap NodeWrap)
-> ProcedureHeading l l NodeWrap NodeWrap
forall a b. (a, b) -> b
snd ((Ident, ProcedureHeading l l NodeWrap NodeWrap)
 -> ProcedureHeading l l NodeWrap NodeWrap)
-> Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
-> Parser g Ident (ProcedureHeading l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (Ident, ProcedureHeading l l NodeWrap NodeWrap)
procedureHeading))
                                                    Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Definition l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Definition l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";"))
                         Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
-> String
-> Parser g Ident [NodeWrap (Definition l l NodeWrap NodeWrap)]
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"definitions",
   programModule :: Parser g Ident (Module l l NodeWrap NodeWrap)
programModule = do Ident
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> [Import l]
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Module l l NodeWrap NodeWrap
con <- (Ident
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> [Import l]
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Module l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Ident
-> Maybe (f (Priority l' l' f' f'))
-> [Import l']
-> f (Block l' l' f' f')
-> Module l l' f' f
Abstract.implementationModule (Ident
 -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
 -> [Import l]
 -> NodeWrap (Block l l NodeWrap NodeWrap)
 -> Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (Ident
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> [Import l]
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"IMPLEMENTATION"
                              Parser
  g
  Ident
  (Ident
   -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> [Import l]
   -> NodeWrap (Block l l NodeWrap NodeWrap)
   -> Module l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (Ident
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> [Import l]
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (Ident
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> [Import l]
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Ident
 -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
 -> [Import l]
 -> NodeWrap (Block l l NodeWrap NodeWrap)
 -> Module l l NodeWrap NodeWrap)
-> Parser
     g
     Ident
     (Ident
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> [Import l]
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Ident
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> [Import l]
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Module l l NodeWrap NodeWrap
forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Ident
-> Maybe (f (Priority l' l' f' f'))
-> [Import l']
-> f (Block l' l' f' f')
-> Module l l' f' f
Abstract.programModule) Parser
  g
  Ident
  (Ident
   -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
   -> [Import l]
   -> NodeWrap (Block l l NodeWrap NodeWrap)
   -> Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser
     g
     Ident
     (Ident
      -> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
      -> [Import l]
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParserInput (Parser g Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword ParserInput (Parser g Ident)
"MODULE"
                      Ident
name <- Parser g Ident Ident
ident
                      Ident
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> [Import l]
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Module l l NodeWrap NodeWrap
con Ident
name (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
 -> [Import l]
 -> NodeWrap (Block l l NodeWrap NodeWrap)
 -> Module l l NodeWrap NodeWrap)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([Import l]
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (Maybe (NodeWrap (Expression l l NodeWrap NodeWrap)))
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Ident (NodeWrap (Expression l l NodeWrap NodeWrap))
priority Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([Import l]
   -> NodeWrap (Block l l NodeWrap NodeWrap)
   -> Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     ([Import l]
      -> NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
";" Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  ([Import l]
   -> NodeWrap (Block l l NodeWrap NodeWrap)
   -> Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Import l]
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (NodeWrap (Block l l NodeWrap NodeWrap)
      -> Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Import l)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident [Import l]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser g Ident (Import l)
import_prod
                               Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Ident
  (NodeWrap (Block l l NodeWrap NodeWrap)
   -> Module l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Block l l NodeWrap NodeWrap))
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Ident (Block l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Block l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap Parser g Ident (Block l l NodeWrap NodeWrap)
block Parser g Ident (Module l l NodeWrap NodeWrap)
-> Parser g Ident Ident
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (ParserInput (Parser g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]])) g Ident (ParserInput (Parser g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Ident
ParserInput (Parser g Ident)
name) Parser g Ident (Module l l NodeWrap NodeWrap)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Ident -> Parser g Ident ()
delimiter Ident
".",
   compilationUnit :: Parser g Ident (NodeWrap (Module l l NodeWrap NodeWrap))
compilationUnit = Parser g Ident (Module l l NodeWrap NodeWrap)
-> Parser g Ident (NodeWrap (Module l l NodeWrap NodeWrap))
forall (g :: (* -> *) -> *) a.
Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap (Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (Module l l NodeWrap NodeWrap)
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Parser g Ident (Module l l NodeWrap NodeWrap)
definitionModule Parser g Ident (Module l l NodeWrap NodeWrap)
-> Parser g Ident (Module l l NodeWrap NodeWrap)
-> Parser g Ident (Module l l NodeWrap NodeWrap)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Ident (Module l l NodeWrap NodeWrap)
programModule)) Parser g Ident (NodeWrap (Module l l NodeWrap NodeWrap))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident (NodeWrap (Module l l NodeWrap NodeWrap))
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *) a. Parsing m => m a -> m ()
skipMany (Char -> Parser g Ident Char
forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\x1a' Parser g Ident Char
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace)
   }

instance TokenParsing (Parser (Modula2Grammar l f) Text) where
   someSpace :: Parser (Modula2Grammar l f) Ident ()
someSpace = Parser (Modula2Grammar l f) Ident ()
forall (m :: * -> *). LexicalParsing m => m ()
someLexicalSpace
   token :: Parser (Modula2Grammar l f) Ident a
-> Parser (Modula2Grammar l f) Ident a
token = Parser (Modula2Grammar l f) Ident a
-> Parser (Modula2Grammar l f) Ident a
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken

instance LexicalParsing (Parser (Modula2Grammar l f) Text) where
   lexicalComment :: Parser (Modula2Grammar l f) Ident ()
lexicalComment = do Ident
c <- Parser (Modula2Grammar l f) Ident Ident
forall (g :: (* -> *) -> *). Parser g Ident Ident
comment
                       ([[Lexeme]], ()) -> Parser (Modula2Grammar l f) Ident ()
forall (m :: * -> *) a (g :: (* -> *) -> *) s.
Applicative m =>
m a -> ParserT m g s a
lift ([[Ident -> Lexeme
Comment Ident
c]], ())
   lexicalWhiteSpace :: Parser (Modula2Grammar l f) Ident ()
lexicalWhiteSpace = Parser (Modula2Grammar l f) Ident ()
forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Ident) =>
Parser g Ident ()
whiteSpace
   isIdentifierStartChar :: Char -> Bool
isIdentifierStartChar = Char -> Bool
isLetter
   isIdentifierFollowChar :: Char -> Bool
isIdentifierFollowChar = Char -> Bool
isAlphaNum
   identifierToken :: Parser
  (Modula2Grammar l f)
  Ident
  (ParserInput (Parser (Modula2Grammar l f) Ident))
-> Parser
     (Modula2Grammar l f)
     Ident
     (ParserInput (Parser (Modula2Grammar l f) Ident))
identifierToken Parser
  (Modula2Grammar l f)
  Ident
  (ParserInput (Parser (Modula2Grammar l f) Ident))
word = Parser (Modula2Grammar l f) Ident Ident
-> Parser (Modula2Grammar l f) Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (do Ident
w <- Parser (Modula2Grammar l f) Ident Ident
Parser
  (Modula2Grammar l f)
  Ident
  (ParserInput (Parser (Modula2Grammar l f) Ident))
word
                                           Bool -> Parser (Modula2Grammar l f) Ident ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Ident
w Ident -> [Ident] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Ident]
reservedWords)
                                           Ident -> Parser (Modula2Grammar l f) Ident Ident
forall (m :: * -> *) a. Monad m => a -> m a
return Ident
w)
   lexicalToken :: Parser (Modula2Grammar l f) Ident a
-> Parser (Modula2Grammar l f) Ident a
lexicalToken Parser (Modula2Grammar l f) Ident a
p = (Ident, a) -> a
forall a b. (a, b) -> b
snd ((Ident, a) -> a)
-> Fixed
     (ParserT ((,) [[Lexeme]])) (Modula2Grammar l f) Ident (Ident, a)
-> Parser (Modula2Grammar l f) Ident a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (([[Lexeme]], (Ident, a)) -> ([[Lexeme]], (Ident, a)))
-> Fixed
     (ParserT ((,) [[Lexeme]])) (Modula2Grammar l f) Ident (Ident, a)
-> Fixed
     (ParserT ((,) [[Lexeme]])) (Modula2Grammar l f) Ident (Ident, a)
forall (m :: * -> *) a (g :: (* -> *) -> *) s.
(m a -> m a) -> ParserT m g s a -> ParserT m g s a
tmap ([[Lexeme]], (Ident, a)) -> ([[Lexeme]], (Ident, a))
forall b. ([[Lexeme]], (Ident, b)) -> ([[Lexeme]], (Ident, b))
addOtherToken (Parser (Modula2Grammar l f) Ident a
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     (Modula2Grammar l f)
     Ident
     (ParserInput (Parser (Modula2Grammar l f) Ident), a)
forall (m :: * -> *) a.
ConsumedInputParsing m =>
m a -> m (ParserInput m, a)
match Parser (Modula2Grammar l f) Ident a
p) Parser (Modula2Grammar l f) Ident a
-> Parser (Modula2Grammar l f) Ident ()
-> Parser (Modula2Grammar l f) Ident a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser (Modula2Grammar l f) Ident ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace
      where addOtherToken :: ([[Lexeme]], (Ident, b)) -> ([[Lexeme]], (Ident, b))
addOtherToken ([], (Ident
i, b
x)) = ([[TokenType -> Ident -> Lexeme
Token TokenType
Other Ident
i]], (Ident
i, b
x))
            addOtherToken ([[Lexeme]]
t, (Ident
i, b
x)) = ([[Lexeme]]
t, (Ident
i, b
x))
   keyword :: ParserInput (Parser (Modula2Grammar l f) Ident)
-> Parser (Modula2Grammar l f) Ident ()
keyword ParserInput (Parser (Modula2Grammar l f) Ident)
s = Parser (Modula2Grammar l f) Ident ()
-> Parser (Modula2Grammar l f) Ident ()
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (ParserInput (Parser (Modula2Grammar l f) Ident)
-> Parser
     (Modula2Grammar l f)
     Ident
     (ParserInput (Parser (Modula2Grammar l f) Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser (Modula2Grammar l f) Ident)
s
                             Parser (Modula2Grammar l f) Ident Ident
-> Parser (Modula2Grammar l f) Ident ()
-> Parser (Modula2Grammar l f) Ident ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Char -> Bool) -> Parser (Modula2Grammar l f) Ident ()
forall (m :: * -> *). InputCharParsing m => (Char -> Bool) -> m ()
notSatisfyChar Char -> Bool
isAlphaNum
                             Parser (Modula2Grammar l f) Ident ()
-> Parser (Modula2Grammar l f) Ident ()
-> Parser (Modula2Grammar l f) Ident ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ([[Lexeme]], ()) -> Parser (Modula2Grammar l f) Ident ()
forall (m :: * -> *) a (g :: (* -> *) -> *) s.
Applicative m =>
m a -> ParserT m g s a
lift ([[TokenType -> Ident -> Lexeme
Token TokenType
Keyword Ident
ParserInput (Parser (Modula2Grammar l f) Ident)
s]], ()))
               Parser (Modula2Grammar l f) Ident ()
-> String -> Parser (Modula2Grammar l f) Ident ()
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> (String
"keyword " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Ident -> String
forall a. Show a => a -> String
show Ident
ParserInput (Parser (Modula2Grammar l f) Ident)
s)

comment :: Parser g Text Text
comment :: Parser g Ident Ident
comment = Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. Parsing m => m a -> m a
try (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
"(*"
               Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> Parser g Ident Ident -> Parser g Ident Ident
forall (p :: * -> *) a. (Alternative p, Monoid a) => p a -> p a
concatMany (Parser g Ident Ident
forall (g :: (* -> *) -> *). Parser g Ident Ident
comment Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> Parser g Ident Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
"*)") Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Parser g Ident Ident -> Parser g Ident Ident
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident Ident
forall (m :: * -> *). InputParsing m => m (ParserInput m)
anyToken Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> (Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isCommentChar)
               Parser g Ident Ident
-> Parser g Ident Ident -> Parser g Ident Ident
forall a. Semigroup a => a -> a -> a
<> ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
"*)")
   where isCommentChar :: Char -> Bool
isCommentChar Char
c = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'*' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'('

whiteSpace :: LexicalParsing (Parser g Text) => Parser g Text ()
whiteSpace :: Parser g Ident ()
whiteSpace = Parser g Ident ()
forall (g :: (* -> *) -> *).
Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
spaceChars Parser g Ident () -> Parser g Ident () -> Parser g Ident ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident () -> Parser g Ident ()
forall (m :: * -> *) a. Parsing m => m a -> m ()
skipMany (Parser g Ident ()
forall (m :: * -> *). LexicalParsing m => m ()
lexicalComment Parser g Ident () -> Parser g Ident () -> Parser g Ident ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Ident ()
forall (g :: (* -> *) -> *).
Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
spaceChars) Parser g Ident () -> String -> Parser g Ident ()
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace"
   where spaceChars :: Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
spaceChars = ((Char -> Bool)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident))
forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isSpace Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
-> (Ident -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ())
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Ident
ws-> ([[Lexeme]], ()) -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *) a (g :: (* -> *) -> *) s.
Applicative m =>
m a -> ParserT m g s a
lift ([[Ident -> Lexeme
WhiteSpace Ident
ws]], ())) Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> () -> Fixed (ParserT ((,) [[Lexeme]])) g Ident ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

wrap :: Parser g Text a -> Parser g Text (NodeWrap a)
wrap :: Parser g Ident a -> Parser g Ident (NodeWrap a)
wrap = (\Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
p-> (Position -> (ParsedLexemes, a) -> Position -> NodeWrap a)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Position
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Position
-> Parser g Ident (NodeWrap a)
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 Position -> (ParsedLexemes, a) -> Position -> NodeWrap a
forall a b b c. a -> (b, b) -> c -> ((a, b, c), b)
surround Fixed (ParserT ((,) [[Lexeme]])) g Ident Position
forall (m :: * -> *). InputParsing m => m Position
getSourcePos Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
p Fixed (ParserT ((,) [[Lexeme]])) g Ident Position
forall (m :: * -> *). InputParsing m => m Position
getSourcePos) (Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
 -> Parser g Ident (NodeWrap a))
-> (Parser g Ident a
    -> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a))
-> Parser g Ident a
-> Parser g Ident (NodeWrap a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([[Lexeme]], (ParsedLexemes, a))
 -> ([[Lexeme]], (ParsedLexemes, a)))
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
forall (m :: * -> *) a (g :: (* -> *) -> *) s.
(m a -> m a) -> ParserT m g s a -> ParserT m g s a
tmap ([[Lexeme]], (ParsedLexemes, a))
-> ([[Lexeme]], (ParsedLexemes, a))
forall a (t :: * -> *) b.
(Monoid a, Foldable t) =>
(t [Lexeme], (ParsedLexemes, b)) -> (a, (ParsedLexemes, b))
store (Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
 -> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a))
-> (Parser g Ident a
    -> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a))
-> Parser g Ident a
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((,) ([Lexeme] -> ParsedLexemes
Trailing []) (a -> (ParsedLexemes, a))
-> Parser g Ident a
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident (ParsedLexemes, a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)
   where surround :: a -> (b, b) -> c -> ((a, b, c), b)
surround a
start (b
lexemes, b
p) c
end = ((a
start, b
lexemes, c
end), b
p)
         store :: (t [Lexeme], (ParsedLexemes, b)) -> (a, (ParsedLexemes, b))
store (t [Lexeme]
wss, (Trailing [Lexeme]
ws', b
a)) = (a
forall a. Monoid a => a
mempty, ([Lexeme] -> ParsedLexemes
Trailing ([Lexeme] -> ParsedLexemes) -> [Lexeme] -> ParsedLexemes
forall a b. (a -> b) -> a -> b
$ [Lexeme]
ws' [Lexeme] -> [Lexeme] -> [Lexeme]
forall a. Semigroup a => a -> a -> a
<> t [Lexeme] -> [Lexeme]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat t [Lexeme]
wss, b
a))

moptional :: f a -> f a
moptional f a
p = f a
p f a -> f a -> f a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> f a
forall a. Monoid a => a
mempty

delimiter, operator :: (LexicalParsing (Parser g Text)) => Text -> Parser g Text ()

delimiter :: Ident -> Parser g Ident ()
delimiter Ident
s = Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident -> Parser g Ident ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
 -> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
forall a b. (a -> b) -> a -> b
$ ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Ident
ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
s) Parser g Ident () -> String -> Parser g Ident ()
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> (String
"delimiter " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Ident -> String
forall a. Show a => a -> String
show Ident
s)
operator :: Ident -> Parser g Ident ()
operator Ident
s = Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident -> Parser g Ident ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
 -> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident)
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
-> Fixed (ParserT ((,) [[Lexeme]])) g Ident Ident
forall a b. (a -> b) -> a -> b
$ ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
-> Fixed
     (ParserT ((,) [[Lexeme]]))
     g
     Ident
     (ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident))
forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Ident
ParserInput (Fixed (ParserT ((,) [[Lexeme]])) g Ident)
s) Parser g Ident () -> String -> Parser g Ident ()
forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> (String
"operator " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Ident -> String
forall a. Show a => a -> String
show Ident
s)

reservedWords :: [Text]
reservedWords :: [Ident]
reservedWords = [Ident
"AND", Ident
"ARRAY", Ident
"BEGIN", Ident
"BY",
                 Ident
"CASE", Ident
"CONST", Ident
"DEFINITION", Ident
"DIV", Ident
"DO",
                 Ident
"ELSE", Ident
"ELSIF", Ident
"END", Ident
"EXIT", Ident
"EXPORT", Ident
"FOR", Ident
"FROM",
                 Ident
"IF", Ident
"IMPLEMENTATION", Ident
"IMPORT", Ident
"IN", Ident
"LOOP",
                 Ident
"MOD", Ident
"MODULE", Ident
"NOT",
                 Ident
"OF", Ident
"OR", Ident
"POINTER", Ident
"PROCEDURE",
                 Ident
"QUALIFIED", Ident
"RECORD", Ident
"REPEAT", Ident
"RETURN",
                 Ident
"SET", Ident
"THEN", Ident
"TO", Ident
"TYPE",
                 Ident
"UNTIL", Ident
"VAR", Ident
"WHILE", Ident
"WITH"]

$(Rank2.TH.deriveAll ''Modula2Grammar)