Agda-2.5.2: A dependently typed functional programming language and proof assistant

Safe Haskell | None
Language | Haskell2010

Agda.Syntax.Concrete.Operators.Parser

Contents

- Parser combinators

Synopsis

- placeholder :: PositionInName -> Parser e (MaybePlaceholder e)
- maybePlaceholder :: Maybe PositionInName -> Parser e e -> Parser e (MaybePlaceholder e)
- notPlaceholder :: Parser e e
- sat' :: (e -> Bool) -> Parser e e
- data ExprView e
  - = LocalV QName
  - | WildV e
  - | OtherV e
  - | AppV e (NamedArg e)
  - | OpAppV QName (Set Name) [NamedArg (MaybePlaceholder (OpApp e))]
  - | HiddenArgV (Named_ e)
  - | InstanceArgV (Named_ e)
  - | LamV [LamBinding] e
  - | ParenV e
- class HasRange e => IsExpr e where
- data ParseSections
  - = ParseSections
  - | DoNotParseSections
- parse :: IsExpr e => (ParseSections, Parser e a) -> [e] -> [a]
- partP :: IsExpr e => [Name] -> RawName -> Parser e Range
- atLeastTwoParts :: IsExpr e => Parser e Name
- wildOrUnqualifiedName :: IsExpr e => Parser e (Maybe Name)
- type family OperatorType (k :: NotationKind) (e :: *) :: *
- data NK k :: * where
  - In :: NK InfixNotation
  - Pre :: NK PrefixNotation
  - Post :: NK PostfixNotation
  - Non :: NK NonfixNotation
- opP :: forall e k. IsExpr e => ParseSections -> Parser e e -> NewNotation -> NK k -> Parser e (OperatorType k e)
- argsP :: IsExpr e => Parser e e -> Parser e [NamedArg e]
- appP :: IsExpr e => Parser e e -> Parser e [NamedArg e] -> Parser e e
- atomP :: IsExpr e => (QName -> Bool) -> Parser e e

# Documentation

placeholder :: PositionInName -> Parser e (MaybePlaceholder e) #

maybePlaceholder :: Maybe PositionInName -> Parser e e -> Parser e (MaybePlaceholder e) #

notPlaceholder :: Parser e e #

sat' :: (e -> Bool) -> Parser e e #

data ExprView e #

Constructors

LocalV QName |
WildV e |
OtherV e |
AppV e (NamedArg e) |
OpAppV QName (Set Name) [NamedArg (MaybePlaceholder (OpApp e))] | The `QName` is possibly ambiguous, but it must correspond to one of the names in the set.
HiddenArgV (Named_ e) |
InstanceArgV (Named_ e) |
LamV [LamBinding] e |
ParenV e |

Instances

IsExpr e => HasRange (ExprView e) # |
Methods getRange :: ExprView e -> Range #

class HasRange e => IsExpr e where #

Minimal complete definition

exprView, unExprView

Methods

exprView :: e -> ExprView e #

unExprView :: ExprView e -> e #

Instances

IsExpr Pattern # |
Methods exprView :: Pattern -> ExprView Pattern # unExprView :: ExprView Pattern -> Pattern #
IsExpr Expr # |
Methods exprView :: Expr -> ExprView Expr # unExprView :: ExprView Expr -> Expr #

data ParseSections #

Should sections be parsed?

Constructors

ParseSections |
DoNotParseSections |

Instances

Eq ParseSections # |
Methods (==) :: ParseSections -> ParseSections -> Bool # (/=) :: ParseSections -> ParseSections -> Bool #
Show ParseSections # |
Methods showsPrec :: Int -> ParseSections -> ShowS # show :: ParseSections -> String # showList :: [ParseSections] -> ShowS #

parse :: IsExpr e => (ParseSections, Parser e a) -> [e] -> [a] #

Runs a parser. If sections should be parsed, then identifiers with at least two name parts are split up into multiple tokens, using `PositionInName` to record the tokens' original positions within their respective identifiers.

# Parser combinators

partP :: IsExpr e => [Name] -> RawName -> Parser e Range #

Parse a specific identifier as a NamePart

atLeastTwoParts :: IsExpr e => Parser e Name #

Parses a split-up, unqualified name consisting of at least two name parts.

The parser does not check that underscores and other name parts alternate. The range of the resulting name is the range of the first name part that is not an underscore.

wildOrUnqualifiedName :: IsExpr e => Parser e (Maybe Name) #

Either a wildcard (`_`), or an unqualified name (possibly containing multiple name parts).

type family OperatorType (k :: NotationKind) (e :: *) :: * #

Used to define the return type of `opP`.

Instances

type OperatorType InfixNotation e # |
type OperatorType InfixNotation e = MaybePlaceholder e -> MaybePlaceholder e -> e
type OperatorType PrefixNotation e # |
type OperatorType PrefixNotation e = MaybePlaceholder e -> e
type OperatorType PostfixNotation e # |
type OperatorType PostfixNotation e = MaybePlaceholder e -> e
type OperatorType NonfixNotation e # |
type OperatorType NonfixNotation e = e

data NK k :: * where #

A singleton type for `NotationKind` (except for the constructor `NoNotation`).

Constructors

In :: NK InfixNotation |
Pre :: NK PrefixNotation |
Post :: NK PostfixNotation |
Non :: NK NonfixNotation |

opP :: forall e k. IsExpr e => ParseSections -> Parser e e -> NewNotation -> NK k -> Parser e (OperatorType k e) #

Parse the "operator part" of the given notation.

Normal holes (but not binders) at the beginning and end are ignored.

If the notation does not contain any binders, then a section notation is allowed.

argsP :: IsExpr e => Parser e e -> Parser e [NamedArg e] #

appP :: IsExpr e => Parser e e -> Parser e [NamedArg e] -> Parser e e #

atomP :: IsExpr e => (QName -> Bool) -> Parser e e #