{- |
    Module      :  $Header$
    Description :  A Parser for Curry
    Copyright   :  (c) 1999 - 2004 Wolfgang Lux
                       2005        Martin Engelke
                       2011 - 2015 Björn Peemöller
                       2016 - 2017 Finn Teegen
    License     :  BSD-3-clause

    Maintainer  :  bjp@informatik.uni-kiel.de
    Stability   :  experimental
    Portability :  portable

    The Curry parser is implemented using the (mostly) LL(1) parsing
    combinators implemented in 'Curry.Base.LLParseComb'.
-}
module Curry.Syntax.Parser
  ( parseSource, parseHeader, parsePragmas, parseInterface, parseGoal
  ) where

import Curry.Base.Ident
import Curry.Base.Monad       (CYM)
import Curry.Base.Position    (Position(..), getPosition, setPosition, incr)
import Curry.Base.LLParseComb
import Curry.Base.Span        hiding (file) -- clash with Position.file
import Curry.Base.SpanInfo

import Curry.Syntax.Extension
import Curry.Syntax.Lexer (Token (..), Category (..), Attributes (..), lexer)
import Curry.Syntax.Type

-- |Parse a 'Module'
parseSource :: FilePath -> String -> CYM (Module ())
parseSource :: FilePath -> FilePath -> CYM (Module ())
parseSource = Parser (Module ()) Token (Module ())
-> Lexer Token (Module ())
-> FilePath
-> FilePath
-> CYM (Module ())
forall s a.
Symbol s =>
Parser a s a -> Lexer s a -> FilePath -> FilePath -> CYM a
fullParser ((LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
-> (([ImportDecl], [Decl ()]), LayoutInfo) -> Module ()
forall t t t t. (t -> t -> t -> t) -> ((t, t), t) -> t
mkMod ((LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
 -> (([ImportDecl], [Decl ()]), LayoutInfo) -> Module ())
-> Parser
     (Module ())
     Token
     (LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
-> Parser
     (Module ())
     Token
     ((([ImportDecl], [Decl ()]), LayoutInfo) -> Module ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  (Module ())
  Token
  (LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
forall a b.
Parser a Token (LayoutInfo -> [ImportDecl] -> [Decl b] -> Module b)
moduleHeader Parser
  (Module ())
  Token
  ((([ImportDecl], [Decl ()]), LayoutInfo) -> Module ())
-> Parser (Module ()) Token (([ImportDecl], [Decl ()]), LayoutInfo)
-> Parser (Module ()) Token (Module ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Module ()) Token (([ImportDecl], [Decl ()]), [Span])
-> Parser (Module ()) Token (([ImportDecl], [Decl ()]), LayoutInfo)
forall a b.
Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
layout Parser (Module ()) Token (([ImportDecl], [Decl ()]), [Span])
forall a. Parser a Token (([ImportDecl], [Decl ()]), [Span])
moduleDecls) Lexer Token (Module ())
forall a. Lexer Token a
lexer
  where mkMod :: (t -> t -> t -> t) -> ((t, t), t) -> t
mkMod f :: t -> t -> t -> t
f ((im :: t
im, ds :: t
ds), lay :: t
lay) = t -> t -> t -> t
f t
lay t
im t
ds

-- |Parse only pragmas of a 'Module'
parsePragmas :: FilePath -> String -> CYM (Module ())
parsePragmas :: FilePath -> FilePath -> CYM (Module ())
parsePragmas
  = Parser (Module ()) Token (Module ())
-> Lexer Token (Module ())
-> FilePath
-> FilePath
-> CYM (Module ())
forall s a.
Symbol s =>
Parser a s a -> Lexer s a -> FilePath -> FilePath -> CYM a
prefixParser ((\ps :: [ModulePragma]
ps sp :: Span
sp -> Position -> Module () -> Module ()
forall a. HasSpanInfo a => Position -> a -> a
setEndPosition Position
NoPos
                              (SpanInfo
-> LayoutInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl ()]
-> Module ()
forall a.
SpanInfo
-> LayoutInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl a]
-> Module a
Module (Span -> [Span] -> SpanInfo
spanInfo Span
sp []) LayoutInfo
WhitespaceLayout
                                 [ModulePragma]
ps ModuleIdent
mainMIdent Maybe ExportSpec
forall a. Maybe a
Nothing [] []))
                    ([ModulePragma] -> Span -> Module ())
-> Parser (Module ()) Token [ModulePragma]
-> Parser (Module ()) Token (Span -> Module ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Module ()) Token [ModulePragma]
forall a. Parser a Token [ModulePragma]
modulePragmas Parser (Module ()) Token (Span -> Module ())
-> Parser (Module ()) Token Span
-> Parser (Module ()) Token (Module ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Module ()) Token Span
forall s a. Symbol s => Parser a s Span
spanPosition)
      Lexer Token (Module ())
forall a. Lexer Token a
lexer

-- |Parse a 'Module' header
parseHeader :: FilePath -> String -> CYM (Module ())
parseHeader :: FilePath -> FilePath -> CYM (Module ())
parseHeader = Parser (Module ()) Token (Module ())
-> Lexer Token (Module ())
-> FilePath
-> FilePath
-> CYM (Module ())
forall s a.
Symbol s =>
Parser a s a -> Lexer s a -> FilePath -> FilePath -> CYM a
prefixParser
  ((LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
-> ([ImportDecl], LayoutInfo) -> Module ()
forall t t a t. (t -> t -> [a] -> t) -> (t, t) -> t
mkMod ((LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
 -> ([ImportDecl], LayoutInfo) -> Module ())
-> Parser
     (Module ())
     Token
     (LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
-> Parser
     (Module ()) Token (([ImportDecl], LayoutInfo) -> Module ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  (Module ())
  Token
  (LayoutInfo -> [ImportDecl] -> [Decl ()] -> Module ())
forall a b.
Parser a Token (LayoutInfo -> [ImportDecl] -> [Decl b] -> Module b)
moduleHeader Parser (Module ()) Token (([ImportDecl], LayoutInfo) -> Module ())
-> Parser (Module ()) Token ([ImportDecl], LayoutInfo)
-> Parser (Module ()) Token (Module ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Module ()) Token ([ImportDecl], [Span])
-> Parser (Module ()) Token ([ImportDecl], LayoutInfo)
forall a b.
Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
startLayout Parser (Module ()) Token ([ImportDecl], [Span])
forall a. Parser a Token ([ImportDecl], [Span])
importDecls) Lexer Token (Module ())
forall a. Lexer Token a
lexer
  where
    importDecls :: Parser a Token ([ImportDecl], [Span])
importDecls = [(ImportDecl, [Span])] -> ([ImportDecl], [Span])
forall a a. [(a, [a])] -> ([a], [a])
mkImport ([(ImportDecl, [Span])] -> ([ImportDecl], [Span]))
-> Parser a Token [(ImportDecl, [Span])]
-> Parser a Token ([ImportDecl], [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (ImportDecl, [Span])
-> Parser a Token [(ImportDecl, [Span])]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many ((,) (ImportDecl -> [Span] -> (ImportDecl, [Span]))
-> Parser a Token ImportDecl
-> Parser a Token ([Span] -> (ImportDecl, [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token ImportDecl
forall a. Parser a Token ImportDecl
importDecl
                                         Parser a Token ([Span] -> (ImportDecl, [Span]))
-> Parser a Token [Span] -> Parser a Token (ImportDecl, [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span -> Parser a Token [Span]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many (Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token Attributes -> Parser a Token Span
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon))
    mkImport :: [(a, [a])] -> ([a], [a])
mkImport xs :: [(a, [a])]
xs = let (im :: [a]
im, spss :: [[a]]
spss) = [(a, [a])] -> ([a], [[a]])
forall a b. [(a, b)] -> ([a], [b])
unzip [(a, [a])]
xs in ([a]
im, [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[a]]
spss)
    mkMod :: (t -> t -> [a] -> t) -> (t, t) -> t
mkMod f :: t -> t -> [a] -> t
f (im :: t
im, lay :: t
lay) = t -> t -> [a] -> t
f t
lay t
im []

-- |Parse an 'Interface'
parseInterface :: FilePath -> String -> CYM Interface
parseInterface :: FilePath -> FilePath -> CYM Interface
parseInterface = Parser Interface Token Interface
-> Lexer Token Interface -> FilePath -> FilePath -> CYM Interface
forall s a.
Symbol s =>
Parser a s a -> Lexer s a -> FilePath -> FilePath -> CYM a
fullParser Parser Interface Token Interface
forall a. Parser a Token Interface
interface Lexer Token Interface
forall a. Lexer Token a
lexer

-- |Parse a 'Goal'
parseGoal :: String -> CYM (Goal ())
parseGoal :: FilePath -> CYM (Goal ())
parseGoal = Parser (Goal ()) Token (Goal ())
-> Lexer Token (Goal ()) -> FilePath -> FilePath -> CYM (Goal ())
forall s a.
Symbol s =>
Parser a s a -> Lexer s a -> FilePath -> FilePath -> CYM a
fullParser Parser (Goal ()) Token (Goal ())
forall a. Parser a Token (Goal ())
goal Lexer Token (Goal ())
forall a. Lexer Token a
lexer ""

-- ---------------------------------------------------------------------------
-- Module header
-- ---------------------------------------------------------------------------

-- |Parser for a module header
moduleHeader :: Parser a Token
                  (LayoutInfo -> [ImportDecl] -> [Decl b] -> Module b)
moduleHeader :: Parser a Token (LayoutInfo -> [ImportDecl] -> [Decl b] -> Module b)
moduleHeader =
  (\sp :: Span
sp ps :: [ModulePragma]
ps (m :: ModuleIdent
m, es :: Maybe ExportSpec
es, inf :: [Span]
inf) lay :: LayoutInfo
lay is :: [ImportDecl]
is ds :: [Decl b]
ds -> Module b -> Module b
forall a. HasSpanInfo a => a -> a
updateEndPos (Module b -> Module b) -> Module b -> Module b
forall a b. (a -> b) -> a -> b
$
      SpanInfo
-> LayoutInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl b]
-> Module b
forall a.
SpanInfo
-> LayoutInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl a]
-> Module a
Module (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span]
inf) LayoutInfo
lay [ModulePragma]
ps ModuleIdent
m Maybe ExportSpec
es [ImportDecl]
is [Decl b]
ds)
    (Span
 -> [ModulePragma]
 -> (ModuleIdent, Maybe ExportSpec, [Span])
 -> LayoutInfo
 -> [ImportDecl]
 -> [Decl b]
 -> Module b)
-> Parser a Token Span
-> Parser
     a
     Token
     ([ModulePragma]
      -> (ModuleIdent, Maybe ExportSpec, [Span])
      -> LayoutInfo
      -> [ImportDecl]
      -> [Decl b]
      -> Module b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
    Parser
  a
  Token
  ([ModulePragma]
   -> (ModuleIdent, Maybe ExportSpec, [Span])
   -> LayoutInfo
   -> [ImportDecl]
   -> [Decl b]
   -> Module b)
-> Parser a Token [ModulePragma]
-> Parser
     a
     Token
     ((ModuleIdent, Maybe ExportSpec, [Span])
      -> LayoutInfo -> [ImportDecl] -> [Decl b] -> Module b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [ModulePragma]
forall a. Parser a Token [ModulePragma]
modulePragmas
    Parser
  a
  Token
  ((ModuleIdent, Maybe ExportSpec, [Span])
   -> LayoutInfo -> [ImportDecl] -> [Decl b] -> Module b)
-> Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
-> Parser
     a Token (LayoutInfo -> [ImportDecl] -> [Decl b] -> Module b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
forall a. Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
header
  where header :: Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
header = (\sp1 :: Span
sp1 m :: ModuleIdent
m es :: Maybe ExportSpec
es sp2 :: Span
sp2 -> (ModuleIdent
m, Maybe ExportSpec
es, [Span
sp1,Span
sp2]))
                    (Span
 -> ModuleIdent
 -> Maybe ExportSpec
 -> Span
 -> (ModuleIdent, Maybe ExportSpec, [Span]))
-> Parser a Token Span
-> Parser
     a
     Token
     (ModuleIdent
      -> Maybe ExportSpec
      -> Span
      -> (ModuleIdent, Maybe ExportSpec, [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>  Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_module
                    Parser
  a
  Token
  (ModuleIdent
   -> Maybe ExportSpec
   -> Span
   -> (ModuleIdent, Maybe ExportSpec, [Span]))
-> Parser a Token ModuleIdent
-> Parser
     a
     Token
     (Maybe ExportSpec
      -> Span -> (ModuleIdent, Maybe ExportSpec, [Span]))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
modIdent
                    Parser
  a
  Token
  (Maybe ExportSpec
   -> Span -> (ModuleIdent, Maybe ExportSpec, [Span]))
-> Parser a Token (Maybe ExportSpec)
-> Parser a Token (Span -> (ModuleIdent, Maybe ExportSpec, [Span]))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser a Token ExportSpec -> Parser a Token (Maybe ExportSpec)
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option Parser a Token ExportSpec
forall a. Parser a Token ExportSpec
exportSpec
                    Parser a Token (Span -> (ModuleIdent, Maybe ExportSpec, [Span]))
-> Parser a Token Span
-> Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
                    Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
-> Parser a Token Attributes
-> Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
expectWhere
                Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
-> (ModuleIdent, Maybe ExportSpec, [Span])
-> Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` (ModuleIdent
mainMIdent, Maybe ExportSpec
forall a. Maybe a
Nothing, [])

modulePragmas :: Parser a Token [ModulePragma]
modulePragmas :: Parser a Token [ModulePragma]
modulePragmas = Parser a Token ModulePragma -> Parser a Token [ModulePragma]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many (Parser a Token ModulePragma
forall a. Parser a Token ModulePragma
languagePragma Parser a Token ModulePragma
-> Parser a Token ModulePragma -> Parser a Token ModulePragma
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token ModulePragma
forall a. Parser a Token ModulePragma
optionsPragma)

languagePragma :: Parser a Token ModulePragma
languagePragma :: Parser a Token ModulePragma
languagePragma =   Span -> ([Extension], [Span]) -> Span -> ModulePragma
languagePragma'
              (Span -> ([Extension], [Span]) -> Span -> ModulePragma)
-> Parser a Token Span
-> Parser a Token (([Extension], [Span]) -> Span -> ModulePragma)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>  Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
PragmaLanguage
              Parser a Token (([Extension], [Span]) -> Span -> ModulePragma)
-> Parser a Token ([Extension], [Span])
-> Parser a Token (Span -> ModulePragma)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  (Parser a Token Extension
forall a. Parser a Token Extension
languageExtension Parser a Token Extension
-> Parser a Token Attributes
-> Parser a Token ([Extension], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
              Parser a Token (Span -> ModulePragma)
-> Parser a Token Span -> Parser a Token ModulePragma
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
PragmaEnd
  where languageExtension :: Parser a Token Extension
languageExtension = Ident -> Extension
classifyExtension (Ident -> Extension)
-> Parser a Token Ident -> Parser a Token Extension
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
ident
        languagePragma' :: Span -> ([Extension], [Span]) -> Span -> ModulePragma
languagePragma' sp1 :: Span
sp1 (ex :: [Extension]
ex, ss :: [Span]
ss) sp2 :: Span
sp2 = ModulePragma -> ModulePragma
forall a. HasSpanInfo a => a -> a
updateEndPos (ModulePragma -> ModulePragma) -> ModulePragma -> ModulePragma
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> [Extension] -> ModulePragma
LanguagePragma (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: [Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2])) [Extension]
ex

-- TODO The span info is not 100% complete due to the lexer
-- combining OPTIONS, toolVal and toolArgs
optionsPragma :: Parser a Token ModulePragma
optionsPragma :: Parser a Token ModulePragma
optionsPragma = Span -> Attributes -> Span -> ModulePragma
optionsPragma'
           (Span -> Attributes -> Span -> ModulePragma)
-> Parser a Token Span
-> Parser a Token (Attributes -> Span -> ModulePragma)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>  Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
           Parser a Token (Attributes -> Span -> ModulePragma)
-> Parser a Token Attributes
-> Parser a Token (Span -> ModulePragma)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaOptions
           Parser a Token (Span -> ModulePragma)
-> Parser a Token Span -> Parser a Token ModulePragma
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
PragmaEnd
  where optionsPragma' :: Span -> Attributes -> Span -> ModulePragma
optionsPragma' sp1 :: Span
sp1 a :: Attributes
a sp2 :: Span
sp2 = ModulePragma -> ModulePragma
forall a. HasSpanInfo a => a -> a
updateEndPos (ModulePragma -> ModulePragma) -> ModulePragma -> ModulePragma
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Maybe Tool -> FilePath -> ModulePragma
OptionsPragma (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2])
                        (FilePath -> Tool
classifyTool (FilePath -> Tool) -> Maybe FilePath -> Maybe Tool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Attributes -> Maybe FilePath
toolVal Attributes
a)
                        (Attributes -> FilePath
toolArgs Attributes
a)

-- |Parser for an export specification
exportSpec :: Parser a Token ExportSpec
exportSpec :: Parser a Token ExportSpec
exportSpec = Span -> (([Export], [Span]), Span, Span) -> ExportSpec
exportSpec' (Span -> (([Export], [Span]), Span, Span) -> ExportSpec)
-> Parser a Token Span
-> Parser a Token ((([Export], [Span]), Span, Span) -> ExportSpec)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token ((([Export], [Span]), Span, Span) -> ExportSpec)
-> Parser a Token (([Export], [Span]), Span, Span)
-> Parser a Token ExportSpec
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([Export], [Span])
-> Parser a Token (([Export], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token Export
forall a. Parser a Token Export
export Parser a Token Export
-> Parser a Token Attributes -> Parser a Token ([Export], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
  where exportSpec' :: Span -> (([Export], [Span]), Span, Span) -> ExportSpec
exportSpec' sp1 :: Span
sp1 ((ex :: [Export]
ex, ss :: [Span]
ss),sp2 :: Span
sp2,sp3 :: Span
sp3) = ExportSpec -> ExportSpec
forall a. HasSpanInfo a => a -> a
updateEndPos (ExportSpec -> ExportSpec) -> ExportSpec -> ExportSpec
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> [Export] -> ExportSpec
Exporting (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (Span
sp2Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
:([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp3]))) [Export]
ex

-- |Parser for an export item
export :: Parser a Token Export
export :: Parser a Token Export
export =  Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycon Parser a Token QualIdent
-> Parser a Token (QualIdent -> Export) -> Parser a Token Export
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (((SpanInfo -> QualIdent -> Export, [Span]), Span, Span)
-> QualIdent -> Export
forall a t.
(HasSpanInfo a, HasSpanInfo t) =>
((SpanInfo -> t -> a, [Span]), Span, Span) -> t -> a
tcExportWith (((SpanInfo -> QualIdent -> Export, [Span]), Span, Span)
 -> QualIdent -> Export)
-> Parser
     a Token ((SpanInfo -> QualIdent -> Export, [Span]), Span, Span)
-> Parser a Token (QualIdent -> Export)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
-> Parser
     a Token ((SpanInfo -> QualIdent -> Export, [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
forall a. Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
spec Parser a Token (QualIdent -> Export)
-> (QualIdent -> Export) -> Parser a Token (QualIdent -> Export)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` QualIdent -> Export
tcExport)
      Parser a Token Export
-> Parser a Token Export -> Parser a Token Export
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> QualIdent -> Export
tcExport (QualIdent -> Export)
-> Parser a Token QualIdent -> Parser a Token Export
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qfun Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycon
      Parser a Token Export
-> Parser a Token Export -> Parser a Token Export
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Span -> ModuleIdent -> Export
exportModule' (Span -> ModuleIdent -> Export)
-> Parser a Token Span -> Parser a Token (ModuleIdent -> Export)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_module Parser a Token (ModuleIdent -> Export)
-> Parser a Token ModuleIdent -> Parser a Token Export
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
modIdent
  where spec :: Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
spec =  (\sp :: Span
sp      -> (SpanInfo -> QualIdent -> Export
ExportTypeAll    , [Span
sp])) (Span -> (SpanInfo -> QualIdent -> Export, [Span]))
-> Parser a Token Span
-> Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DotDot
            Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
-> Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
-> Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (\(c :: [Ident]
c, ss :: [Span]
ss) -> ([Ident] -> SpanInfo -> QualIdent -> Export
exportTypeWith' [Ident]
c,  [Span]
ss )) (([Ident], [Span]) -> (SpanInfo -> QualIdent -> Export, [Span]))
-> Parser a Token ([Ident], [Span])
-> Parser a Token (SpanInfo -> QualIdent -> Export, [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
con Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token ([Ident], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma
        tcExport :: QualIdent -> Export
tcExport qtc :: QualIdent
qtc = Export -> Export
forall a. HasSpanInfo a => a -> a
updateEndPos (Export -> Export) -> Export -> Export
forall a b. (a -> b) -> a -> b
$ SpanInfo -> QualIdent -> Export
Export (Span -> SpanInfo
fromSrcSpan (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
qtc)) QualIdent
qtc
        tcExportWith :: ((SpanInfo -> t -> a, [Span]), Span, Span) -> t -> a
tcExportWith ((spc :: SpanInfo -> t -> a
spc, ss :: [Span]
ss), sp1 :: Span
sp1, sp2 :: Span
sp2) qtc :: t
qtc =
          a -> a
forall a. HasSpanInfo a => a -> a
updateEndPos (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ [Span] -> a -> a
forall a. HasSpanInfo a => [Span] -> a -> a
setSrcInfoPoints (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2])) (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> t -> a
spc (Span -> SpanInfo
fromSrcSpan (t -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan t
qtc)) t
qtc
        exportTypeWith' :: [Ident] -> SpanInfo -> QualIdent -> Export
exportTypeWith' c :: [Ident]
c spi :: SpanInfo
spi qtc :: QualIdent
qtc = SpanInfo -> QualIdent -> [Ident] -> Export
ExportTypeWith SpanInfo
spi QualIdent
qtc [Ident]
c
        exportModule' :: Span -> ModuleIdent -> Export
exportModule' sp :: Span
sp = Export -> Export
forall a. HasSpanInfo a => a -> a
updateEndPos (Export -> Export)
-> (ModuleIdent -> Export) -> ModuleIdent -> Export
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanInfo -> ModuleIdent -> Export
ExportModule (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span
sp])

moduleDecls :: Parser a Token (([ImportDecl], [Decl ()]), [Span])
moduleDecls :: Parser a Token (([ImportDecl], [Decl ()]), [Span])
moduleDecls = ImportDecl
-> ([ImportDecl], [Decl ()], [Span])
-> (([ImportDecl], [Decl ()]), [Span])
forall a b b. a -> ([a], b, b) -> (([a], b), b)
mkImpDecl (ImportDecl
 -> ([ImportDecl], [Decl ()], [Span])
 -> (([ImportDecl], [Decl ()]), [Span]))
-> Parser a Token ImportDecl
-> Parser
     a
     Token
     (([ImportDecl], [Decl ()], [Span])
      -> (([ImportDecl], [Decl ()]), [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token ImportDecl
forall a. Parser a Token ImportDecl
importDecl
                        Parser
  a
  Token
  (([ImportDecl], [Decl ()], [Span])
   -> (([ImportDecl], [Decl ()]), [Span]))
-> Parser a Token ([ImportDecl], [Decl ()], [Span])
-> Parser a Token (([ImportDecl], [Decl ()]), [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser a Token ([ImportDecl], [Decl ()], [Span])
forall a. Parser a Token ([ImportDecl], [Decl ()], [Span])
moduleDecls' Parser a Token ([ImportDecl], [Decl ()], [Span])
-> ([ImportDecl], [Decl ()], [Span])
-> Parser a Token ([ImportDecl], [Decl ()], [Span])
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` ([], [], []))
          Parser a Token (([ImportDecl], [Decl ()]), [Span])
-> Parser a Token (([ImportDecl], [Decl ()]), [Span])
-> Parser a Token (([ImportDecl], [Decl ()]), [Span])
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> ([Decl ()], [Span]) -> (([ImportDecl], [Decl ()]), [Span])
forall b b a. (b, b) -> (([a], b), b)
mkTopDecl (([Decl ()], [Span]) -> (([ImportDecl], [Decl ()]), [Span]))
-> Parser a Token ([Decl ()], [Span])
-> Parser a Token (([ImportDecl], [Decl ()]), [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token ([Decl ()], [Span])
forall a. Parser a Token ([Decl ()], [Span])
topDecls
  where
    mkImpDecl :: a -> ([a], b, b) -> (([a], b), b)
mkImpDecl i :: a
i (is :: [a]
is, ds :: b
ds, sps :: b
sps) = ((a
ia -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
is, b
ds), b
sps)
    mkTopDecl :: (b, b) -> (([a], b), b)
mkTopDecl (ds :: b
ds, sps :: b
sps) = (([], b
ds), b
sps)

    moduleDecls' :: Parser a Token ([ImportDecl], [Decl ()], [Span])
moduleDecls' = Span
-> (([ImportDecl], [Decl ()]), [Span])
-> ([ImportDecl], [Decl ()], [Span])
forall a a b. a -> ((a, b), [a]) -> (a, b, [a])
mkDecls (Span
 -> (([ImportDecl], [Decl ()]), [Span])
 -> ([ImportDecl], [Decl ()], [Span]))
-> Parser a Token Span
-> Parser
     a
     Token
     ((([ImportDecl], [Decl ()]), [Span])
      -> ([ImportDecl], [Decl ()], [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser
  a
  Token
  ((([ImportDecl], [Decl ()]), [Span])
   -> ([ImportDecl], [Decl ()], [Span]))
-> Parser a Token Attributes
-> Parser
     a
     Token
     ((([ImportDecl], [Decl ()]), [Span])
      -> ([ImportDecl], [Decl ()], [Span]))
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon Parser
  a
  Token
  ((([ImportDecl], [Decl ()]), [Span])
   -> ([ImportDecl], [Decl ()], [Span]))
-> Parser a Token (([ImportDecl], [Decl ()]), [Span])
-> Parser a Token ([ImportDecl], [Decl ()], [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (([ImportDecl], [Decl ()]), [Span])
forall a. Parser a Token (([ImportDecl], [Decl ()]), [Span])
moduleDecls
    mkDecls :: a -> ((a, b), [a]) -> (a, b, [a])
mkDecls sp :: a
sp ((im :: a
im, ds :: b
ds), sps :: [a]
sps) = (a
im, b
ds, a
spa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
sps)

-- |Parser for a single import declaration
importDecl :: Parser a Token ImportDecl
importDecl :: Parser a Token ImportDecl
importDecl =  Span
-> Maybe Span
-> ModuleIdent
-> Maybe (Span, ModuleIdent)
-> Maybe ImportSpec
-> ImportDecl
importDecl'
          (Span
 -> Maybe Span
 -> ModuleIdent
 -> Maybe (Span, ModuleIdent)
 -> Maybe ImportSpec
 -> ImportDecl)
-> Parser a Token Span
-> Parser
     a
     Token
     (Maybe Span
      -> ModuleIdent
      -> Maybe (Span, ModuleIdent)
      -> Maybe ImportSpec
      -> ImportDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_import
          Parser
  a
  Token
  (Maybe Span
   -> ModuleIdent
   -> Maybe (Span, ModuleIdent)
   -> Maybe ImportSpec
   -> ImportDecl)
-> Parser a Token (Maybe Span)
-> Parser
     a
     Token
     (ModuleIdent
      -> Maybe (Span, ModuleIdent) -> Maybe ImportSpec -> ImportDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span -> Parser a Token (Maybe Span)
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Id_qualified)
          Parser
  a
  Token
  (ModuleIdent
   -> Maybe (Span, ModuleIdent) -> Maybe ImportSpec -> ImportDecl)
-> Parser a Token ModuleIdent
-> Parser
     a
     Token
     (Maybe (Span, ModuleIdent) -> Maybe ImportSpec -> ImportDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
modIdent
          Parser
  a
  Token
  (Maybe (Span, ModuleIdent) -> Maybe ImportSpec -> ImportDecl)
-> Parser a Token (Maybe (Span, ModuleIdent))
-> Parser a Token (Maybe ImportSpec -> ImportDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Span, ModuleIdent)
-> Parser a Token (Maybe (Span, ModuleIdent))
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option ((,) (Span -> ModuleIdent -> (Span, ModuleIdent))
-> Parser a Token Span
-> Parser a Token (ModuleIdent -> (Span, ModuleIdent))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Id_as Parser a Token (ModuleIdent -> (Span, ModuleIdent))
-> Parser a Token ModuleIdent -> Parser a Token (Span, ModuleIdent)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
modIdent)
          Parser a Token (Maybe ImportSpec -> ImportDecl)
-> Parser a Token (Maybe ImportSpec) -> Parser a Token ImportDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ImportSpec -> Parser a Token (Maybe ImportSpec)
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option Parser a Token ImportSpec
forall a. Parser a Token ImportSpec
importSpec
  where
    importDecl' :: Span
-> Maybe Span
-> ModuleIdent
-> Maybe (Span, ModuleIdent)
-> Maybe ImportSpec
-> ImportDecl
importDecl' sp1 :: Span
sp1 (Just sp2 :: Span
sp2) mid :: ModuleIdent
mid (Just (sp3 :: Span
sp3, alias :: ModuleIdent
alias)) = ImportDecl -> ImportDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ImportDecl -> ImportDecl)
-> (Maybe ImportSpec -> ImportDecl)
-> Maybe ImportSpec
-> ImportDecl
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      SpanInfo
-> ModuleIdent
-> Qualified
-> Maybe ModuleIdent
-> Maybe ImportSpec
-> ImportDecl
ImportDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2, Span
sp3]) ModuleIdent
mid Qualified
True  (ModuleIdent -> Maybe ModuleIdent
forall a. a -> Maybe a
Just ModuleIdent
alias)
    importDecl' sp1 :: Span
sp1 Nothing    mid :: ModuleIdent
mid (Just (sp3 :: Span
sp3, alias :: ModuleIdent
alias)) = ImportDecl -> ImportDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ImportDecl -> ImportDecl)
-> (Maybe ImportSpec -> ImportDecl)
-> Maybe ImportSpec
-> ImportDecl
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      SpanInfo
-> ModuleIdent
-> Qualified
-> Maybe ModuleIdent
-> Maybe ImportSpec
-> ImportDecl
ImportDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1      [Span
sp1, Span
sp3]) ModuleIdent
mid Qualified
False (ModuleIdent -> Maybe ModuleIdent
forall a. a -> Maybe a
Just ModuleIdent
alias)
    importDecl' sp1 :: Span
sp1 (Just sp2 :: Span
sp2) mid :: ModuleIdent
mid Nothing             = ImportDecl -> ImportDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ImportDecl -> ImportDecl)
-> (Maybe ImportSpec -> ImportDecl)
-> Maybe ImportSpec
-> ImportDecl
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      SpanInfo
-> ModuleIdent
-> Qualified
-> Maybe ModuleIdent
-> Maybe ImportSpec
-> ImportDecl
ImportDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1      [Span
sp1, Span
sp2]) ModuleIdent
mid Qualified
True  Maybe ModuleIdent
forall a. Maybe a
Nothing
    importDecl' sp1 :: Span
sp1 Nothing    mid :: ModuleIdent
mid Nothing             = ImportDecl -> ImportDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ImportDecl -> ImportDecl)
-> (Maybe ImportSpec -> ImportDecl)
-> Maybe ImportSpec
-> ImportDecl
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      SpanInfo
-> ModuleIdent
-> Qualified
-> Maybe ModuleIdent
-> Maybe ImportSpec
-> ImportDecl
ImportDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1           [Span
sp1]) ModuleIdent
mid Qualified
False Maybe ModuleIdent
forall a. Maybe a
Nothing

-- |Parser for an import specification
importSpec :: Parser a Token ImportSpec
importSpec :: Parser a Token ImportSpec
importSpec =   Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
          Parser a Token Span
-> Parser
     a Token (Span -> (([Import], [Span]), Span, Span) -> ImportSpec)
-> Parser a Token ((([Import], [Span]), Span, Span) -> ImportSpec)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Span -> (([Import], [Span]), Span, Span) -> ImportSpec
hiding' (Span -> (([Import], [Span]), Span, Span) -> ImportSpec)
-> Parser a Token Attributes
-> Parser
     a Token (Span -> (([Import], [Span]), Span, Span) -> ImportSpec)
forall s a b c. Symbol s => a -> Parser b s c -> Parser b s a
<$-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Id_hiding Parser
  a Token (Span -> (([Import], [Span]), Span, Span) -> ImportSpec)
-> (Span -> (([Import], [Span]), Span, Span) -> ImportSpec)
-> Parser
     a Token (Span -> (([Import], [Span]), Span, Span) -> ImportSpec)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` Span -> (([Import], [Span]), Span, Span) -> ImportSpec
importing')
          Parser a Token ((([Import], [Span]), Span, Span) -> ImportSpec)
-> Parser a Token (([Import], [Span]), Span, Span)
-> Parser a Token ImportSpec
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser a Token ([Import], [Span])
-> Parser a Token (([Import], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token Import
forall a. Parser a Token Import
importSp Parser a Token Import
-> Parser a Token Attributes -> Parser a Token ([Import], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
  where
    hiding' :: Span -> (([Import], [Span]), Span, Span) -> ImportSpec
hiding' sp1 :: Span
sp1 ((specs :: [Import]
specs, ss :: [Span]
ss), sp2 :: Span
sp2, sp3 :: Span
sp3) = ImportSpec -> ImportSpec
forall a. HasSpanInfo a => a -> a
updateEndPos (ImportSpec -> ImportSpec) -> ImportSpec -> ImportSpec
forall a b. (a -> b) -> a -> b
$
      SpanInfo -> [Import] -> ImportSpec
Hiding    (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: Span
sp2 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp3]))) [Import]
specs
    importing' :: Span -> (([Import], [Span]), Span, Span) -> ImportSpec
importing' sp1 :: Span
sp1 ((specs :: [Import]
specs, ss :: [Span]
ss), sp2 :: Span
sp2, sp3 :: Span
sp3) = ImportSpec -> ImportSpec
forall a. HasSpanInfo a => a -> a
updateEndPos (ImportSpec -> ImportSpec) -> ImportSpec -> ImportSpec
forall a b. (a -> b) -> a -> b
$
      SpanInfo -> [Import] -> ImportSpec
Importing (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (      Span
sp2 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp3]))) [Import]
specs

importSp :: Parser a Token Import
importSp :: Parser a Token Import
importSp = Parser a Token Ident
forall a. Parser a Token Ident
tycon Parser a Token Ident
-> Parser a Token (Ident -> Import) -> Parser a Token Import
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (((SpanInfo -> Ident -> Import, [Span]), Span, Span)
-> Ident -> Import
forall a t.
(HasSpanInfo a, HasSpanInfo t) =>
((SpanInfo -> t -> a, [Span]), Span, Span) -> t -> a
tcImportWith (((SpanInfo -> Ident -> Import, [Span]), Span, Span)
 -> Ident -> Import)
-> Parser
     a Token ((SpanInfo -> Ident -> Import, [Span]), Span, Span)
-> Parser a Token (Ident -> Import)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (SpanInfo -> Ident -> Import, [Span])
-> Parser
     a Token ((SpanInfo -> Ident -> Import, [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp Parser a Token (SpanInfo -> Ident -> Import, [Span])
forall a. Parser a Token (SpanInfo -> Ident -> Import, [Span])
spec Parser a Token (Ident -> Import)
-> (Ident -> Import) -> Parser a Token (Ident -> Import)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` Ident -> Import
tcImport)
      Parser a Token Import
-> Parser a Token Import -> Parser a Token Import
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Ident -> Import
tcImport (Ident -> Import) -> Parser a Token Ident -> Parser a Token Import
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
tycon
  where spec :: Parser a Token (SpanInfo -> Ident -> Import, [Span])
spec =  (\sp :: Span
sp      -> (SpanInfo -> Ident -> Import
ImportTypeAll    , [Span
sp])) (Span -> (SpanInfo -> Ident -> Import, [Span]))
-> Parser a Token Span
-> Parser a Token (SpanInfo -> Ident -> Import, [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DotDot
            Parser a Token (SpanInfo -> Ident -> Import, [Span])
-> Parser a Token (SpanInfo -> Ident -> Import, [Span])
-> Parser a Token (SpanInfo -> Ident -> Import, [Span])
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (\(c :: [Ident]
c, ss :: [Span]
ss) -> ([Ident] -> SpanInfo -> Ident -> Import
importTypeWith' [Ident]
c,  [Span]
ss )) (([Ident], [Span]) -> (SpanInfo -> Ident -> Import, [Span]))
-> Parser a Token ([Ident], [Span])
-> Parser a Token (SpanInfo -> Ident -> Import, [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
con Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token ([Ident], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma
        tcImport :: Ident -> Import
tcImport tc :: Ident
tc = Import -> Import
forall a. HasSpanInfo a => a -> a
updateEndPos (Import -> Import) -> Import -> Import
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Ident -> Import
Import (Span -> SpanInfo
fromSrcSpan (Ident -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Ident
tc)) Ident
tc
        tcImportWith :: ((SpanInfo -> t -> a, [Span]), Span, Span) -> t -> a
tcImportWith ((spc :: SpanInfo -> t -> a
spc, ss :: [Span]
ss), sp1 :: Span
sp1, sp2 :: Span
sp2) tc :: t
tc =
          a -> a
forall a. HasSpanInfo a => a -> a
updateEndPos (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ [Span] -> a -> a
forall a. HasSpanInfo a => [Span] -> a -> a
setSrcInfoPoints (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2])) (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> t -> a
spc (Span -> SpanInfo
fromSrcSpan (t -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan t
tc)) t
tc
        importTypeWith' :: [Ident] -> SpanInfo -> Ident -> Import
importTypeWith' c :: [Ident]
c spi :: SpanInfo
spi tc :: Ident
tc = SpanInfo -> Ident -> [Ident] -> Import
ImportTypeWith SpanInfo
spi Ident
tc [Ident]
c
-- ---------------------------------------------------------------------------
-- Interfaces
-- ---------------------------------------------------------------------------

-- |Parser for an interface
interface :: Parser a Token Interface
interface :: Parser a Token Interface
interface = ([IImportDecl] -> [IDecl] -> Interface)
-> ([IImportDecl], [IDecl]) -> Interface
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (([IImportDecl] -> [IDecl] -> Interface)
 -> ([IImportDecl], [IDecl]) -> Interface)
-> Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
-> Parser a Token (([IImportDecl], [IDecl]) -> Interface)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
forall a. Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
intfHeader Parser a Token (([IImportDecl], [IDecl]) -> Interface)
-> Parser a Token ([IImportDecl], [IDecl])
-> Parser a Token Interface
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([IImportDecl], [IDecl])
-> Parser a Token ([IImportDecl], [IDecl])
forall a b. Parser a Token b -> Parser a Token b
braces Parser a Token ([IImportDecl], [IDecl])
forall a. Parser a Token ([IImportDecl], [IDecl])
intfDecls

intfHeader :: Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
intfHeader :: Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
intfHeader = ModuleIdent -> [IImportDecl] -> [IDecl] -> Interface
Interface (ModuleIdent -> [IImportDecl] -> [IDecl] -> Interface)
-> Parser a Token Attributes
-> Parser
     a Token (ModuleIdent -> [IImportDecl] -> [IDecl] -> Interface)
forall s a b c. Symbol s => a -> Parser b s c -> Parser b s a
<$-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Id_interface Parser
  a Token (ModuleIdent -> [IImportDecl] -> [IDecl] -> Interface)
-> Parser a Token ModuleIdent
-> Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
modIdent Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
-> Parser a Token Attributes
-> Parser a Token ([IImportDecl] -> [IDecl] -> Interface)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
expectWhere

intfDecls :: Parser a Token ([IImportDecl], [IDecl])
intfDecls :: Parser a Token ([IImportDecl], [IDecl])
intfDecls = IImportDecl -> ([IImportDecl], [IDecl]) -> ([IImportDecl], [IDecl])
forall a b. a -> ([a], b) -> ([a], b)
impDecl (IImportDecl
 -> ([IImportDecl], [IDecl]) -> ([IImportDecl], [IDecl]))
-> Parser a Token IImportDecl
-> Parser
     a Token (([IImportDecl], [IDecl]) -> ([IImportDecl], [IDecl]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token IImportDecl
forall a. Parser a Token IImportDecl
iImportDecl
                    Parser
  a Token (([IImportDecl], [IDecl]) -> ([IImportDecl], [IDecl]))
-> Parser a Token ([IImportDecl], [IDecl])
-> Parser a Token ([IImportDecl], [IDecl])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon Parser a Token Attributes
-> Parser a Token ([IImportDecl], [IDecl])
-> Parser a Token ([IImportDecl], [IDecl])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ([IImportDecl], [IDecl])
forall a. Parser a Token ([IImportDecl], [IDecl])
intfDecls Parser a Token ([IImportDecl], [IDecl])
-> ([IImportDecl], [IDecl])
-> Parser a Token ([IImportDecl], [IDecl])
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` ([], []))
        Parser a Token ([IImportDecl], [IDecl])
-> Parser a Token ([IImportDecl], [IDecl])
-> Parser a Token ([IImportDecl], [IDecl])
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (,) [] ([IDecl] -> ([IImportDecl], [IDecl]))
-> Parser a Token [IDecl]
-> Parser a Token ([IImportDecl], [IDecl])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token IDecl
forall a. Parser a Token IDecl
intfDecl Parser a Token IDecl
-> Parser a Token Attributes -> Parser a Token [IDecl]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s [b]
`sepBy` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon
  where impDecl :: a -> ([a], b) -> ([a], b)
impDecl i :: a
i (is :: [a]
is, ds :: b
ds) = (a
ia -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
is, b
ds)

-- |Parser for a single interface import declaration
iImportDecl :: Parser a Token IImportDecl
iImportDecl :: Parser a Token IImportDecl
iImportDecl = Position -> ModuleIdent -> IImportDecl
IImportDecl (Position -> ModuleIdent -> IImportDecl)
-> Parser a Token Position
-> Parser a Token (ModuleIdent -> IImportDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Position
forall a. Category -> Parser a Token Position
tokenPos Category
KW_import Parser a Token (ModuleIdent -> IImportDecl)
-> Parser a Token ModuleIdent -> Parser a Token IImportDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
modIdent

-- |Parser for a single interface declaration
intfDecl :: Parser a Token IDecl
intfDecl :: Parser a Token IDecl
intfDecl = [Parser a Token IDecl] -> Parser a Token IDecl
forall s a b. Symbol s => [Parser a s b] -> Parser a s b
choice [ Parser a Token IDecl
forall a. Parser a Token IDecl
iInfixDecl, Parser a Token IDecl
forall a. Parser a Token IDecl
iHidingDecl, Parser a Token IDecl
forall a. Parser a Token IDecl
iDataDecl, Parser a Token IDecl
forall a. Parser a Token IDecl
iNewtypeDecl
                  , Parser a Token IDecl
forall a. Parser a Token IDecl
iTypeDecl , Parser a Token IDecl
forall a. Parser a Token IDecl
iFunctionDecl Parser a Token IDecl
-> Parser a Token Attributes -> Parser a Token IDecl
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Id_hiding
                  , Parser a Token IDecl
forall a. Parser a Token IDecl
iClassDecl, Parser a Token IDecl
forall a. Parser a Token IDecl
iInstanceDecl ]

-- |Parser for an interface infix declaration
iInfixDecl :: Parser a Token IDecl
iInfixDecl :: Parser a Token IDecl
iInfixDecl = (Span -> Infix -> Precedence -> QualIdent -> IDecl)
-> Parser a Token (Precedence -> QualIdent -> IDecl)
forall a b. (Span -> Infix -> a) -> Parser b Token a
infixDeclLhs Span -> Infix -> Precedence -> QualIdent -> IDecl
iInfixDecl' Parser a Token (Precedence -> QualIdent -> IDecl)
-> Parser a Token Precedence -> Parser a Token (QualIdent -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Precedence
forall a. Parser a Token Precedence
integer Parser a Token (QualIdent -> IDecl)
-> Parser a Token QualIdent -> Parser a Token IDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qfunop
  where iInfixDecl' :: Span -> Infix -> Precedence -> QualIdent -> IDecl
iInfixDecl' sp :: Span
sp = Position -> Infix -> Precedence -> QualIdent -> IDecl
IInfixDecl (Span -> Position
span2Pos Span
sp)

-- |Parser for an interface hiding declaration
iHidingDecl :: Parser a Token IDecl
iHidingDecl :: Parser a Token IDecl
iHidingDecl = Category -> Parser a Token Position
forall a. Category -> Parser a Token Position
tokenPos Category
Id_hiding Parser a Token Position
-> Parser a Token (Position -> IDecl) -> Parser a Token IDecl
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Parser a Token (Position -> IDecl)
forall b. Parser b Token (Position -> IDecl)
hDataDecl Parser a Token (Position -> IDecl)
-> Parser a Token (Position -> IDecl)
-> Parser a Token (Position -> IDecl)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Position -> IDecl)
forall b. Parser b Token (Position -> IDecl)
hClassDecl)
  where
  hDataDecl :: Parser b Token (Position -> IDecl)
hDataDecl = (QualIdent, Maybe KindExpr) -> [Ident] -> Position -> IDecl
hiddenData ((QualIdent, Maybe KindExpr) -> [Ident] -> Position -> IDecl)
-> Parser b Token Attributes
-> Parser
     b
     Token
     ((QualIdent, Maybe KindExpr) -> [Ident] -> Position -> IDecl)
forall s a b c. Symbol s => a -> Parser b s c -> Parser b s a
<$-> Category -> Parser b Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
KW_data Parser
  b
  Token
  ((QualIdent, Maybe KindExpr) -> [Ident] -> Position -> IDecl)
-> Parser b Token (QualIdent, Maybe KindExpr)
-> Parser b Token ([Ident] -> Position -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser b Token QualIdent
-> Parser b Token (QualIdent, Maybe KindExpr)
forall a b. Parser a Token b -> Parser a Token (b, Maybe KindExpr)
withKind Parser b Token QualIdent
forall a. Parser a Token QualIdent
qtycon Parser b Token ([Ident] -> Position -> IDecl)
-> Parser b Token [Ident] -> Parser b Token (Position -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser b Token Ident -> Parser b Token [Ident]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many Parser b Token Ident
forall a. Parser a Token Ident
tyvar
  hClassDecl :: Parser a Token (Position -> IDecl)
hClassDecl = (Span, [Span], Context, (QualIdent, Maybe KindExpr), Ident)
-> Position -> IDecl
forall a b.
(a, b, Context, (QualIdent, Maybe KindExpr), Ident)
-> Position -> IDecl
hiddenClass ((Span, [Span], Context, (QualIdent, Maybe KindExpr), Ident)
 -> Position -> IDecl)
-> Parser
     a Token (Span, [Span], Context, (QualIdent, Maybe KindExpr), Ident)
-> Parser a Token (Position -> IDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category
-> Parser a Token (QualIdent, Maybe KindExpr)
-> Parser a Token Ident
-> Parser
     a Token (Span, [Span], Context, (QualIdent, Maybe KindExpr), Ident)
forall a b c.
Category
-> Parser a Token b
-> Parser a Token c
-> Parser a Token (Span, [Span], Context, b, c)
classInstHead Category
KW_class (Parser a Token QualIdent
-> Parser a Token (QualIdent, Maybe KindExpr)
forall a b. Parser a Token b -> Parser a Token (b, Maybe KindExpr)
withKind Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycls) Parser a Token Ident
forall a. Parser a Token Ident
clsvar
  hiddenData :: (QualIdent, Maybe KindExpr) -> [Ident] -> Position -> IDecl
hiddenData (tc :: QualIdent
tc, k :: Maybe KindExpr
k) tvs :: [Ident]
tvs p :: Position
p = Position -> QualIdent -> Maybe KindExpr -> [Ident] -> IDecl
HidingDataDecl Position
p QualIdent
tc Maybe KindExpr
k [Ident]
tvs
  hiddenClass :: (a, b, Context, (QualIdent, Maybe KindExpr), Ident)
-> Position -> IDecl
hiddenClass (_, _, cx :: Context
cx, (qcls :: QualIdent
qcls, k :: Maybe KindExpr
k), tv :: Ident
tv) p :: Position
p = Position
-> Context -> QualIdent -> Maybe KindExpr -> Ident -> IDecl
HidingClassDecl Position
p Context
cx QualIdent
qcls Maybe KindExpr
k Ident
tv

-- |Parser for an interface data declaration
iDataDecl :: Parser a Token IDecl
iDataDecl :: Parser a Token IDecl
iDataDecl = (Position
 -> QualIdent
 -> Maybe KindExpr
 -> [Ident]
 -> [ConstrDecl]
 -> [Ident]
 -> IDecl)
-> Category -> Parser a Token ([ConstrDecl] -> [Ident] -> IDecl)
forall a b.
(Position -> QualIdent -> Maybe KindExpr -> [Ident] -> a)
-> Category -> Parser b Token a
iTypeDeclLhs Position
-> QualIdent
-> Maybe KindExpr
-> [Ident]
-> [ConstrDecl]
-> [Ident]
-> IDecl
IDataDecl Category
KW_data Parser a Token ([ConstrDecl] -> [Ident] -> IDecl)
-> Parser a Token [ConstrDecl] -> Parser a Token ([Ident] -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [ConstrDecl]
forall a. Parser a Token [ConstrDecl]
constrs Parser a Token ([Ident] -> IDecl)
-> Parser a Token [Ident] -> Parser a Token IDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [Ident]
forall a. Parser a Token [Ident]
iHiddenPragma
  where constrs :: Parser a Token [ConstrDecl]
constrs = Parser a Token Attributes
forall a. Parser a Token Attributes
equals Parser a Token Attributes
-> Parser a Token [ConstrDecl] -> Parser a Token [ConstrDecl]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ConstrDecl
forall a. Parser a Token ConstrDecl
constrDecl Parser a Token ConstrDecl
-> Parser a Token Attributes -> Parser a Token [ConstrDecl]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s [b]
`sepBy1` Parser a Token Attributes
forall a. Parser a Token Attributes
bar Parser a Token [ConstrDecl]
-> [ConstrDecl] -> Parser a Token [ConstrDecl]
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` []

-- |Parser for an interface newtype declaration
iNewtypeDecl :: Parser a Token IDecl
iNewtypeDecl :: Parser a Token IDecl
iNewtypeDecl = (Position
 -> QualIdent
 -> Maybe KindExpr
 -> [Ident]
 -> NewConstrDecl
 -> [Ident]
 -> IDecl)
-> Category -> Parser a Token (NewConstrDecl -> [Ident] -> IDecl)
forall a b.
(Position -> QualIdent -> Maybe KindExpr -> [Ident] -> a)
-> Category -> Parser b Token a
iTypeDeclLhs Position
-> QualIdent
-> Maybe KindExpr
-> [Ident]
-> NewConstrDecl
-> [Ident]
-> IDecl
INewtypeDecl Category
KW_newtype
               Parser a Token (NewConstrDecl -> [Ident] -> IDecl)
-> Parser a Token Attributes
-> Parser a Token (NewConstrDecl -> [Ident] -> IDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
equals Parser a Token (NewConstrDecl -> [Ident] -> IDecl)
-> Parser a Token NewConstrDecl
-> Parser a Token ([Ident] -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token NewConstrDecl
forall a. Parser a Token NewConstrDecl
newConstrDecl Parser a Token ([Ident] -> IDecl)
-> Parser a Token [Ident] -> Parser a Token IDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [Ident]
forall a. Parser a Token [Ident]
iHiddenPragma

-- |Parser for an interface type synonym declaration
iTypeDecl :: Parser a Token IDecl
iTypeDecl :: Parser a Token IDecl
iTypeDecl = (Position
 -> QualIdent -> Maybe KindExpr -> [Ident] -> TypeExpr -> IDecl)
-> Category -> Parser a Token (TypeExpr -> IDecl)
forall a b.
(Position -> QualIdent -> Maybe KindExpr -> [Ident] -> a)
-> Category -> Parser b Token a
iTypeDeclLhs Position
-> QualIdent -> Maybe KindExpr -> [Ident] -> TypeExpr -> IDecl
ITypeDecl Category
KW_type
            Parser a Token (TypeExpr -> IDecl)
-> Parser a Token Attributes -> Parser a Token (TypeExpr -> IDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
equals Parser a Token (TypeExpr -> IDecl)
-> Parser a Token TypeExpr -> Parser a Token IDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0

-- |Parser for an interface hiding pragma
iHiddenPragma :: Parser a Token [Ident]
iHiddenPragma :: Parser a Token [Ident]
iHiddenPragma = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaHiding
                Parser a Token Attributes
-> Parser a Token [Ident] -> Parser a Token [Ident]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> (Parser a Token Ident
forall a. Parser a Token Ident
con Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token [Ident]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s [b]
`sepBy` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
                Parser a Token [Ident]
-> Parser a Token Attributes -> Parser a Token [Ident]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaEnd
                Parser a Token [Ident] -> [Ident] -> Parser a Token [Ident]
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` []

-- |Parser for an interface function declaration
iFunctionDecl :: Parser a Token IDecl
iFunctionDecl :: Parser a Token IDecl
iFunctionDecl = Position
-> QualIdent -> Maybe Ident -> Arity -> QualTypeExpr -> IDecl
IFunctionDecl (Position
 -> QualIdent -> Maybe Ident -> Arity -> QualTypeExpr -> IDecl)
-> Parser a Token Position
-> Parser
     a
     Token
     (QualIdent -> Maybe Ident -> Arity -> QualTypeExpr -> IDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Position
forall a s. Parser a s Position
position Parser
  a
  Token
  (QualIdent -> Maybe Ident -> Arity -> QualTypeExpr -> IDecl)
-> Parser a Token QualIdent
-> Parser a Token (Maybe Ident -> Arity -> QualTypeExpr -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qfun Parser a Token (Maybe Ident -> Arity -> QualTypeExpr -> IDecl)
-> Parser a Token (Maybe Ident)
-> Parser a Token (Arity -> QualTypeExpr -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident -> Parser a Token (Maybe Ident)
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option Parser a Token Ident
forall a. Parser a Token Ident
iMethodPragma
                Parser a Token (Arity -> QualTypeExpr -> IDecl)
-> Parser a Token Arity -> Parser a Token (QualTypeExpr -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Arity
forall a. Parser a Token Arity
arity Parser a Token (QualTypeExpr -> IDecl)
-> Parser a Token Attributes
-> Parser a Token (QualTypeExpr -> IDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
DoubleColon Parser a Token (QualTypeExpr -> IDecl)
-> Parser a Token QualTypeExpr -> Parser a Token IDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualTypeExpr
forall a. Parser a Token QualTypeExpr
qualType

-- |Parser for an interface method pragma
iMethodPragma :: Parser a Token Ident
iMethodPragma :: Parser a Token Ident
iMethodPragma = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaMethod Parser a Token Attributes
-> Parser a Token Ident -> Parser a Token Ident
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token Ident
forall a. Parser a Token Ident
clsvar Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token Ident
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaEnd

-- |Parser for function's arity
arity :: Parser a Token Int
arity :: Parser a Token Arity
arity = Parser a Token Arity
forall a. Parser a Token Arity
int Parser a Token Arity -> Arity -> Parser a Token Arity
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` 0

iTypeDeclLhs :: (Position -> QualIdent -> Maybe KindExpr -> [Ident] -> a)
             -> Category -> Parser b Token a
iTypeDeclLhs :: (Position -> QualIdent -> Maybe KindExpr -> [Ident] -> a)
-> Category -> Parser b Token a
iTypeDeclLhs f :: Position -> QualIdent -> Maybe KindExpr -> [Ident] -> a
f kw :: Category
kw = Position -> (QualIdent, Maybe KindExpr) -> [Ident] -> a
f' (Position -> (QualIdent, Maybe KindExpr) -> [Ident] -> a)
-> Parser b Token Position
-> Parser b Token ((QualIdent, Maybe KindExpr) -> [Ident] -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser b Token Position
forall a. Category -> Parser a Token Position
tokenPos Category
kw Parser b Token ((QualIdent, Maybe KindExpr) -> [Ident] -> a)
-> Parser b Token (QualIdent, Maybe KindExpr)
-> Parser b Token ([Ident] -> a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser b Token QualIdent
-> Parser b Token (QualIdent, Maybe KindExpr)
forall a b. Parser a Token b -> Parser a Token (b, Maybe KindExpr)
withKind Parser b Token QualIdent
forall a. Parser a Token QualIdent
qtycon Parser b Token ([Ident] -> a)
-> Parser b Token [Ident] -> Parser b Token a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser b Token Ident -> Parser b Token [Ident]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many Parser b Token Ident
forall a. Parser a Token Ident
tyvar
  where f' :: Position -> (QualIdent, Maybe KindExpr) -> [Ident] -> a
f' p :: Position
p (tc :: QualIdent
tc, k :: Maybe KindExpr
k) = Position -> QualIdent -> Maybe KindExpr -> [Ident] -> a
f Position
p QualIdent
tc Maybe KindExpr
k

-- |Parser for an interface class declaration
iClassDecl :: Parser a Token IDecl
iClassDecl :: Parser a Token IDecl
iClassDecl = (\(sp :: Span
sp, _, cx :: Context
cx, (qcls :: QualIdent
qcls, k :: Maybe KindExpr
k), tv :: Ident
tv) ->
               Position
-> Context
-> QualIdent
-> Maybe KindExpr
-> Ident
-> [IMethodDecl]
-> [Ident]
-> IDecl
IClassDecl (Span -> Position
span2Pos Span
sp) Context
cx QualIdent
qcls Maybe KindExpr
k Ident
tv)
        ((Span, [Span], Context, (QualIdent, Maybe KindExpr), Ident)
 -> [IMethodDecl] -> [Ident] -> IDecl)
-> Parser
     a Token (Span, [Span], Context, (QualIdent, Maybe KindExpr), Ident)
-> Parser a Token ([IMethodDecl] -> [Ident] -> IDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category
-> Parser a Token (QualIdent, Maybe KindExpr)
-> Parser a Token Ident
-> Parser
     a Token (Span, [Span], Context, (QualIdent, Maybe KindExpr), Ident)
forall a b c.
Category
-> Parser a Token b
-> Parser a Token c
-> Parser a Token (Span, [Span], Context, b, c)
classInstHead Category
KW_class (Parser a Token QualIdent
-> Parser a Token (QualIdent, Maybe KindExpr)
forall a b. Parser a Token b -> Parser a Token (b, Maybe KindExpr)
withKind Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycls) Parser a Token Ident
forall a. Parser a Token Ident
clsvar
        Parser a Token ([IMethodDecl] -> [Ident] -> IDecl)
-> Parser a Token [IMethodDecl]
-> Parser a Token ([Ident] -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [IMethodDecl] -> Parser a Token [IMethodDecl]
forall a b. Parser a Token b -> Parser a Token b
braces (Parser a Token IMethodDecl
forall a. Parser a Token IMethodDecl
iMethod Parser a Token IMethodDecl
-> Parser a Token Attributes -> Parser a Token [IMethodDecl]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s [b]
`sepBy` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon)
        Parser a Token ([Ident] -> IDecl)
-> Parser a Token [Ident] -> Parser a Token IDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [Ident]
forall a. Parser a Token [Ident]
iClassHidden

-- |Parser for an interface method declaration
iMethod :: Parser a Token IMethodDecl
iMethod :: Parser a Token IMethodDecl
iMethod = Position -> Ident -> Maybe Arity -> QualTypeExpr -> IMethodDecl
IMethodDecl (Position -> Ident -> Maybe Arity -> QualTypeExpr -> IMethodDecl)
-> Parser a Token Position
-> Parser
     a Token (Ident -> Maybe Arity -> QualTypeExpr -> IMethodDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Position
forall a s. Parser a s Position
position
                      Parser
  a Token (Ident -> Maybe Arity -> QualTypeExpr -> IMethodDecl)
-> Parser a Token Ident
-> Parser a Token (Maybe Arity -> QualTypeExpr -> IMethodDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token (Maybe Arity -> QualTypeExpr -> IMethodDecl)
-> Parser a Token (Maybe Arity)
-> Parser a Token (QualTypeExpr -> IMethodDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Arity -> Parser a Token (Maybe Arity)
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option Parser a Token Arity
forall a. Parser a Token Arity
int Parser a Token (QualTypeExpr -> IMethodDecl)
-> Parser a Token Attributes
-> Parser a Token (QualTypeExpr -> IMethodDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
DoubleColon Parser a Token (QualTypeExpr -> IMethodDecl)
-> Parser a Token QualTypeExpr -> Parser a Token IMethodDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualTypeExpr
forall a. Parser a Token QualTypeExpr
qualType

-- |Parser for an interface hiding pragma
iClassHidden :: Parser a Token [Ident]
iClassHidden :: Parser a Token [Ident]
iClassHidden = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaHiding
          Parser a Token Attributes
-> Parser a Token [Ident] -> Parser a Token [Ident]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> (Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token [Ident]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s [b]
`sepBy` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
          Parser a Token [Ident]
-> Parser a Token Attributes -> Parser a Token [Ident]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaEnd
          Parser a Token [Ident] -> [Ident] -> Parser a Token [Ident]
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` []

-- |Parser for an interface instance declaration
iInstanceDecl :: Parser a Token IDecl
iInstanceDecl :: Parser a Token IDecl
iInstanceDecl = (\(sp :: Span
sp, _, cx :: Context
cx, qcls :: QualIdent
qcls, inst :: TypeExpr
inst) ->
                   Position
-> Context
-> QualIdent
-> TypeExpr
-> [IMethodImpl]
-> Maybe ModuleIdent
-> IDecl
IInstanceDecl (Span -> Position
span2Pos Span
sp) Context
cx QualIdent
qcls TypeExpr
inst)
           ((Span, [Span], Context, QualIdent, TypeExpr)
 -> [IMethodImpl] -> Maybe ModuleIdent -> IDecl)
-> Parser a Token (Span, [Span], Context, QualIdent, TypeExpr)
-> Parser a Token ([IMethodImpl] -> Maybe ModuleIdent -> IDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category
-> Parser a Token QualIdent
-> Parser a Token TypeExpr
-> Parser a Token (Span, [Span], Context, QualIdent, TypeExpr)
forall a b c.
Category
-> Parser a Token b
-> Parser a Token c
-> Parser a Token (Span, [Span], Context, b, c)
classInstHead Category
KW_instance Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycls Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2
           Parser a Token ([IMethodImpl] -> Maybe ModuleIdent -> IDecl)
-> Parser a Token [IMethodImpl]
-> Parser a Token (Maybe ModuleIdent -> IDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [IMethodImpl] -> Parser a Token [IMethodImpl]
forall a b. Parser a Token b -> Parser a Token b
braces (Parser a Token IMethodImpl
forall a. Parser a Token IMethodImpl
iImpl Parser a Token IMethodImpl
-> Parser a Token Attributes -> Parser a Token [IMethodImpl]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s [b]
`sepBy` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon)
           Parser a Token (Maybe ModuleIdent -> IDecl)
-> Parser a Token (Maybe ModuleIdent) -> Parser a Token IDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ModuleIdent -> Parser a Token (Maybe ModuleIdent)
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
iModulePragma

-- |Parser for an interface method implementation
iImpl :: Parser a Token IMethodImpl
iImpl :: Parser a Token IMethodImpl
iImpl = (,) (Ident -> Arity -> IMethodImpl)
-> Parser a Token Ident -> Parser a Token (Arity -> IMethodImpl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token (Arity -> IMethodImpl)
-> Parser a Token Arity -> Parser a Token IMethodImpl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Arity
forall a. Parser a Token Arity
arity

iModulePragma :: Parser a Token ModuleIdent
iModulePragma :: Parser a Token ModuleIdent
iModulePragma = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaModule Parser a Token Attributes
-> Parser a Token ModuleIdent -> Parser a Token ModuleIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
modIdent Parser a Token ModuleIdent
-> Parser a Token Attributes -> Parser a Token ModuleIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
PragmaEnd

-- ---------------------------------------------------------------------------
-- Top-Level Declarations
-- ---------------------------------------------------------------------------

topDecls :: Parser a Token ([Decl ()], [Span])
topDecls :: Parser a Token ([Decl ()], [Span])
topDecls = Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
topDecl Parser a Token (Decl ())
-> Parser a Token Attributes -> Parser a Token ([Decl ()], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon

topDecl :: Parser a Token (Decl ())
topDecl :: Parser a Token (Decl ())
topDecl = [Parser a Token (Decl ())] -> Parser a Token (Decl ())
forall s a b. Symbol s => [Parser a s b] -> Parser a s b
choice [ Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
dataDecl, Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
externalDataDecl, Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
newtypeDecl, Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
typeDecl
                 , Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
classDecl, Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
instanceDecl, Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
defaultDecl
                 , Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
infixDecl, Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
functionDecl ]

dataDecl :: Parser a Token (Decl ())
dataDecl :: Parser a Token (Decl ())
dataDecl = ([ConstrDecl] -> [QualIdent] -> Decl ())
-> ([ConstrDecl], [Span]) -> ([QualIdent], [Span]) -> Decl ()
forall a t1 t2.
HasSpanInfo a =>
(t1 -> t2 -> a) -> (t1, [Span]) -> (t2, [Span]) -> a
combineWithSpans
             (([ConstrDecl] -> [QualIdent] -> Decl ())
 -> ([ConstrDecl], [Span]) -> ([QualIdent], [Span]) -> Decl ())
-> Parser a Token ([ConstrDecl] -> [QualIdent] -> Decl ())
-> Parser
     a
     Token
     (([ConstrDecl], [Span]) -> ([QualIdent], [Span]) -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Span
 -> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl ())
-> Category
-> Parser a Token ([ConstrDecl] -> [QualIdent] -> Decl ())
forall a b.
(Span -> Ident -> [Ident] -> a) -> Category -> Parser b Token a
typeDeclLhs Span -> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl ()
forall a.
Span -> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl a
dataDecl' Category
KW_data
             Parser
  a
  Token
  (([ConstrDecl], [Span]) -> ([QualIdent], [Span]) -> Decl ())
-> Parser a Token ([ConstrDecl], [Span])
-> Parser a Token (([QualIdent], [Span]) -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Span -> ([ConstrDecl], [Span]) -> ([ConstrDecl], [Span])
forall a. Span -> (a, [Span]) -> (a, [Span])
addSpan (Span -> ([ConstrDecl], [Span]) -> ([ConstrDecl], [Span]))
-> Parser a Token Span
-> Parser
     a Token (([ConstrDecl], [Span]) -> ([ConstrDecl], [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Equals Parser a Token (([ConstrDecl], [Span]) -> ([ConstrDecl], [Span]))
-> Parser a Token ([ConstrDecl], [Span])
-> Parser a Token ([ConstrDecl], [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([ConstrDecl], [Span])
forall a. Parser a Token ([ConstrDecl], [Span])
constrs) Parser a Token ([ConstrDecl], [Span])
-> ([ConstrDecl], [Span]) -> Parser a Token ([ConstrDecl], [Span])
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` ([],[]))
             Parser a Token (([QualIdent], [Span]) -> Decl ())
-> Parser a Token ([QualIdent], [Span]) -> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([QualIdent], [Span])
forall a. Parser a Token ([QualIdent], [Span])
deriv
  where constrs :: Parser a Token ([ConstrDecl], [Span])
constrs = Parser a Token ConstrDecl
forall a. Parser a Token ConstrDecl
constrDecl Parser a Token ConstrDecl
-> Parser a Token Attributes
-> Parser a Token ([ConstrDecl], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
bar
        dataDecl' :: Span -> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl a
dataDecl' sp :: Span
sp = SpanInfo
-> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl a
forall a.
SpanInfo
-> Ident -> [Ident] -> [ConstrDecl] -> [QualIdent] -> Decl a
DataDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span
sp])

externalDataDecl :: Parser a Token (Decl ())
externalDataDecl :: Parser a Token (Decl ())
externalDataDecl = Span -> (Span, Ident, [Ident]) -> Decl ()
forall a. Span -> (Span, Ident, [Ident]) -> Decl a
decl (Span -> (Span, Ident, [Ident]) -> Decl ())
-> Parser a Token Span
-> Parser a Token ((Span, Ident, [Ident]) -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_external Parser a Token ((Span, Ident, [Ident]) -> Decl ())
-> Parser a Token (Span, Ident, [Ident])
-> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Span -> Ident -> [Ident] -> (Span, Ident, [Ident]))
-> Category -> Parser a Token (Span, Ident, [Ident])
forall a b.
(Span -> Ident -> [Ident] -> a) -> Category -> Parser b Token a
typeDeclLhs (,,) Category
KW_data
  where decl :: Span -> (Span, Ident, [Ident]) -> Decl a
decl sp1 :: Span
sp1 (sp2 :: Span
sp2, tc :: Ident
tc, tvs :: [Ident]
tvs) = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Ident -> [Ident] -> Decl a
forall a. SpanInfo -> Ident -> [Ident] -> Decl a
ExternalDataDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2]) Ident
tc [Ident]
tvs

newtypeDecl :: Parser a Token (Decl ())
newtypeDecl :: Parser a Token (Decl ())
newtypeDecl = (NewConstrDecl -> [QualIdent] -> Decl ())
-> (NewConstrDecl, [Span]) -> ([QualIdent], [Span]) -> Decl ()
forall a t1 t2.
HasSpanInfo a =>
(t1 -> t2 -> a) -> (t1, [Span]) -> (t2, [Span]) -> a
combineWithSpans
             ((NewConstrDecl -> [QualIdent] -> Decl ())
 -> (NewConstrDecl, [Span]) -> ([QualIdent], [Span]) -> Decl ())
-> Parser a Token (NewConstrDecl -> [QualIdent] -> Decl ())
-> Parser
     a
     Token
     ((NewConstrDecl, [Span]) -> ([QualIdent], [Span]) -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Span
 -> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl ())
-> Category
-> Parser a Token (NewConstrDecl -> [QualIdent] -> Decl ())
forall a b.
(Span -> Ident -> [Ident] -> a) -> Category -> Parser b Token a
typeDeclLhs Span -> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl ()
forall a.
Span -> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl a
newtypeDecl' Category
KW_newtype
             Parser
  a
  Token
  ((NewConstrDecl, [Span]) -> ([QualIdent], [Span]) -> Decl ())
-> Parser a Token (NewConstrDecl, [Span])
-> Parser a Token (([QualIdent], [Span]) -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((\sp :: Span
sp c :: NewConstrDecl
c -> (NewConstrDecl
c, [Span
sp]))  (Span -> NewConstrDecl -> (NewConstrDecl, [Span]))
-> Parser a Token Span
-> Parser a Token (NewConstrDecl -> (NewConstrDecl, [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Equals Parser a Token (NewConstrDecl -> (NewConstrDecl, [Span]))
-> Parser a Token NewConstrDecl
-> Parser a Token (NewConstrDecl, [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token NewConstrDecl
forall a. Parser a Token NewConstrDecl
newConstrDecl)
             Parser a Token (([QualIdent], [Span]) -> Decl ())
-> Parser a Token ([QualIdent], [Span]) -> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([QualIdent], [Span])
forall a. Parser a Token ([QualIdent], [Span])
deriv
  where newtypeDecl' :: Span -> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl a
newtypeDecl' sp :: Span
sp = SpanInfo
-> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl a
forall a.
SpanInfo
-> Ident -> [Ident] -> NewConstrDecl -> [QualIdent] -> Decl a
NewtypeDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span
sp])

combineWithSpans :: HasSpanInfo a =>
                    (t1 -> t2 -> a) -> (t1, [Span]) -> (t2, [Span]) -> a
combineWithSpans :: (t1 -> t2 -> a) -> (t1, [Span]) -> (t2, [Span]) -> a
combineWithSpans df :: t1 -> t2 -> a
df (cs :: t1
cs, sps1 :: [Span]
sps1) (cls :: t2
cls, sps2 :: [Span]
sps2)
  = a -> a
forall a. HasSpanInfo a => a -> a
updateEndPos (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ [Span] -> a -> a
forall a. HasSpanInfo a => [Span] -> a -> a
setSrcInfoPoints (a -> [Span]
forall a. HasSpanInfo a => a -> [Span]
getSrcInfoPoints a
res [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span]
sps1 [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span]
sps2) a
res
  where res :: a
res = t1 -> t2 -> a
df t1
cs t2
cls

typeDecl :: Parser a Token (Decl ())
typeDecl :: Parser a Token (Decl ())
typeDecl = (Span -> Ident -> [Ident] -> Span -> TypeExpr -> Decl ())
-> Category -> Parser a Token (Span -> TypeExpr -> Decl ())
forall a b.
(Span -> Ident -> [Ident] -> a) -> Category -> Parser b Token a
typeDeclLhs Span -> Ident -> [Ident] -> Span -> TypeExpr -> Decl ()
forall a. Span -> Ident -> [Ident] -> Span -> TypeExpr -> Decl a
typeDecl' Category
KW_type Parser a Token (Span -> TypeExpr -> Decl ())
-> Parser a Token Span -> Parser a Token (TypeExpr -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Equals Parser a Token (TypeExpr -> Decl ())
-> Parser a Token TypeExpr -> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0
  where typeDecl' :: Span -> Ident -> [Ident] -> Span -> TypeExpr -> Decl a
typeDecl' sp1 :: Span
sp1 tyc :: Ident
tyc tyv :: [Ident]
tyv sp2 :: Span
sp2 txp :: TypeExpr
txp = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Ident -> [Ident] -> TypeExpr -> Decl a
forall a. SpanInfo -> Ident -> [Ident] -> TypeExpr -> Decl a
TypeDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2]) Ident
tyc [Ident]
tyv TypeExpr
txp

typeDeclLhs :: (Span -> Ident -> [Ident] -> a) -> Category
            -> Parser b Token a
typeDeclLhs :: (Span -> Ident -> [Ident] -> a) -> Category -> Parser b Token a
typeDeclLhs f :: Span -> Ident -> [Ident] -> a
f kw :: Category
kw = Span -> Ident -> [Ident] -> a
f (Span -> Ident -> [Ident] -> a)
-> Parser b Token Span -> Parser b Token (Ident -> [Ident] -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser b Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
kw Parser b Token (Ident -> [Ident] -> a)
-> Parser b Token Ident -> Parser b Token ([Ident] -> a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser b Token Ident
forall a. Parser a Token Ident
tycon Parser b Token ([Ident] -> a)
-> Parser b Token [Ident] -> Parser b Token a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser b Token Ident -> Parser b Token [Ident]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many Parser b Token Ident
forall a. Parser a Token Ident
anonOrTyvar

constrDecl :: Parser a Token ConstrDecl
constrDecl :: Parser a Token ConstrDecl
constrDecl = Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token (Span -> ConstrDecl) -> Parser a Token ConstrDecl
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> ConstrDecl)
forall a. Parser a Token (Span -> ConstrDecl)
constr
  where
  constr :: Parser a Token (Span -> ConstrDecl)
constr =  Parser a Token Ident
forall a. Parser a Token Ident
conId     Parser a Token Ident
-> Parser a Token (Ident -> Span -> ConstrDecl)
-> Parser a Token (Span -> ConstrDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Ident -> Span -> ConstrDecl)
forall a. Parser a Token (Ident -> Span -> ConstrDecl)
identDecl
        Parser a Token (Span -> ConstrDecl)
-> Parser a Token (Span -> ConstrDecl)
-> Parser a Token (Span -> ConstrDecl)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftParen Parser a Token Span
-> Parser a Token (Span -> Span -> ConstrDecl)
-> Parser a Token (Span -> ConstrDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> Span -> ConstrDecl)
forall a. Parser a Token (Span -> Span -> ConstrDecl)
parenDecl
        Parser a Token (Span -> ConstrDecl)
-> Parser a Token (Span -> ConstrDecl)
-> Parser a Token (Span -> ConstrDecl)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type1 Parser a Token TypeExpr
-> Parser a Token Ident -> Parser a Token TypeExpr
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
conId Parser a Token TypeExpr
-> Parser a Token Attributes -> Parser a Token TypeExpr
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Attributes
forall a. Parser a Token Attributes
leftParen Parser a Token TypeExpr
-> Parser a Token (TypeExpr -> Span -> ConstrDecl)
-> Parser a Token (Span -> ConstrDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (TypeExpr -> Span -> ConstrDecl)
forall a. Parser a Token (TypeExpr -> Span -> ConstrDecl)
opDecl
  identDecl :: Parser a Token (Ident -> Span -> ConstrDecl)
identDecl =  Parser a Token TypeExpr -> Parser a Token [TypeExpr]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2 Parser a Token [TypeExpr]
-> Parser a Token ([TypeExpr] -> Ident -> Span -> ConstrDecl)
-> Parser a Token (Ident -> Span -> ConstrDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> ((TypeExpr -> Span -> ConstrDecl)
-> [TypeExpr] -> Ident -> Span -> ConstrDecl
forall (t :: * -> *) t.
Foldable t =>
(TypeExpr -> t) -> t TypeExpr -> Ident -> t
conType ((TypeExpr -> Span -> ConstrDecl)
 -> [TypeExpr] -> Ident -> Span -> ConstrDecl)
-> Parser a Token (TypeExpr -> Span -> ConstrDecl)
-> Parser a Token ([TypeExpr] -> Ident -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (TypeExpr -> Span -> ConstrDecl)
forall a. Parser a Token (TypeExpr -> Span -> ConstrDecl)
opDecl Parser a Token ([TypeExpr] -> Ident -> Span -> ConstrDecl)
-> ([TypeExpr] -> Ident -> Span -> ConstrDecl)
-> Parser a Token ([TypeExpr] -> Ident -> Span -> ConstrDecl)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` [TypeExpr] -> Ident -> Span -> ConstrDecl
conDecl)
           Parser a Token (Ident -> Span -> ConstrDecl)
-> Parser a Token (Ident -> Span -> ConstrDecl)
-> Parser a Token (Ident -> Span -> ConstrDecl)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (([FieldDecl], [Span]), Span, Span) -> Ident -> Span -> ConstrDecl
recDecl ((([FieldDecl], [Span]), Span, Span)
 -> Ident -> Span -> ConstrDecl)
-> Parser a Token (([FieldDecl], [Span]), Span, Span)
-> Parser a Token (Ident -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (([FieldDecl], [Span]), Span, Span)
forall a. Parser a Token (([FieldDecl], [Span]), Span, Span)
recFields
  parenDecl :: Parser a Token (Span -> Span -> ConstrDecl)
parenDecl =  Ident -> Span -> TypeExpr -> TypeExpr -> Span -> Span -> ConstrDecl
conOpDeclPrefix
           (Ident
 -> Span -> TypeExpr -> TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token Ident
-> Parser
     a
     Token
     (Span -> TypeExpr -> TypeExpr -> Span -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
conSym    Parser
  a
  Token
  (Span -> TypeExpr -> TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token Span
-> Parser
     a Token (TypeExpr -> TypeExpr -> Span -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>   Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen Parser a Token (TypeExpr -> TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token TypeExpr
-> Parser a Token (TypeExpr -> Span -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2 Parser a Token (TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token TypeExpr
-> Parser a Token (Span -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2
           Parser a Token (Span -> Span -> ConstrDecl)
-> Parser a Token (Span -> Span -> ConstrDecl)
-> Parser a Token (Span -> Span -> ConstrDecl)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
tupleType Parser a Token TypeExpr
-> Parser a Token (TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token (Span -> Span -> ConstrDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen Parser a Token Span
-> Parser a Token (Span -> TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token (TypeExpr -> Span -> Span -> ConstrDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> TypeExpr -> Span -> Span -> ConstrDecl)
forall a.
Parser a Token (Span -> TypeExpr -> Span -> Span -> ConstrDecl)
opDeclParen)
  opDecl :: Parser a Token (TypeExpr -> Span -> ConstrDecl)
opDecl = Ident -> TypeExpr -> TypeExpr -> Span -> ConstrDecl
conOpDecl (Ident -> TypeExpr -> TypeExpr -> Span -> ConstrDecl)
-> Parser a Token Ident
-> Parser a Token (TypeExpr -> TypeExpr -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
conop Parser a Token (TypeExpr -> TypeExpr -> Span -> ConstrDecl)
-> Parser a Token TypeExpr
-> Parser a Token (TypeExpr -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type1
  opDeclParen :: Parser a Token (Span -> TypeExpr -> Span -> Span -> ConstrDecl)
opDeclParen = Ident -> TypeExpr -> Span -> TypeExpr -> Span -> Span -> ConstrDecl
conOpDeclParen (Ident
 -> TypeExpr -> Span -> TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token Ident
-> Parser
     a
     Token
     (TypeExpr -> Span -> TypeExpr -> Span -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
conop Parser
  a
  Token
  (TypeExpr -> Span -> TypeExpr -> Span -> Span -> ConstrDecl)
-> Parser a Token TypeExpr
-> Parser a Token (Span -> TypeExpr -> Span -> Span -> ConstrDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type1
  recFields :: Parser a Token (([FieldDecl], [Span]), Span, Span)
recFields = Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOff Parser a Token Any
-> Parser a Token (([FieldDecl], [Span]), Span, Span)
-> Parser a Token (([FieldDecl], [Span]), Span, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ([FieldDecl], [Span])
-> Parser a Token (([FieldDecl], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp (Parser a Token FieldDecl
forall a. Parser a Token FieldDecl
fieldDecl Parser a Token FieldDecl
-> Parser a Token Attributes
-> Parser a Token ([FieldDecl], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
  conType :: (TypeExpr -> t) -> t TypeExpr -> Ident -> t
conType f :: TypeExpr -> t
f tys :: t TypeExpr
tys c :: Ident
c = TypeExpr -> t
f (TypeExpr -> t) -> TypeExpr -> t
forall a b. (a -> b) -> a -> b
$ (TypeExpr -> TypeExpr -> TypeExpr)
-> TypeExpr -> t TypeExpr -> TypeExpr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl TypeExpr -> TypeExpr -> TypeExpr
mkApply (QualIdent -> TypeExpr
mkConstructorType (QualIdent -> TypeExpr) -> QualIdent -> TypeExpr
forall a b. (a -> b) -> a -> b
$ Ident -> QualIdent
qualify Ident
c) t TypeExpr
tys
  mkApply :: TypeExpr -> TypeExpr -> TypeExpr
mkApply t1 :: TypeExpr
t1 t2 :: TypeExpr
t2 = TypeExpr -> TypeExpr
forall a. HasSpanInfo a => a -> a
updateEndPos (TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr
forall a b. (a -> b) -> a -> b
$ SpanInfo -> TypeExpr -> TypeExpr -> TypeExpr
ApplyType (Span -> SpanInfo
fromSrcSpan (TypeExpr -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan TypeExpr
t1)) TypeExpr
t1 TypeExpr
t2
  mkConstructorType :: QualIdent -> TypeExpr
mkConstructorType qid :: QualIdent
qid = SpanInfo -> QualIdent -> TypeExpr
ConstructorType (Span -> SpanInfo
fromSrcSpan (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
qid)) QualIdent
qid
  conDecl :: [TypeExpr] -> Ident -> Span -> ConstrDecl
conDecl tys :: [TypeExpr]
tys c :: Ident
c sp :: Span
sp = ConstrDecl -> ConstrDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ConstrDecl -> ConstrDecl) -> ConstrDecl -> ConstrDecl
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> Ident -> [TypeExpr] -> ConstrDecl
ConstrDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp []) Ident
c [TypeExpr]
tys
  conOpDecl :: Ident -> TypeExpr -> TypeExpr -> Span -> ConstrDecl
conOpDecl op :: Ident
op ty2 :: TypeExpr
ty2 ty1 :: TypeExpr
ty1 sp :: Span
sp = ConstrDecl -> ConstrDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ConstrDecl -> ConstrDecl) -> ConstrDecl -> ConstrDecl
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> TypeExpr -> Ident -> TypeExpr -> ConstrDecl
ConOpDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp []) TypeExpr
ty1 Ident
op TypeExpr
ty2
  conOpDeclParen :: Ident -> TypeExpr -> Span -> TypeExpr -> Span -> Span -> ConstrDecl
conOpDeclParen op :: Ident
op ty2 :: TypeExpr
ty2 sp1 :: Span
sp1 ty1 :: TypeExpr
ty1 sp2 :: Span
sp2 sp5 :: Span
sp5 = ConstrDecl -> ConstrDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ConstrDecl -> ConstrDecl) -> ConstrDecl -> ConstrDecl
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> TypeExpr -> Ident -> TypeExpr -> ConstrDecl
ConOpDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp5 [Span
sp2, Span
sp1]) TypeExpr
ty1 Ident
op TypeExpr
ty2
  conOpDeclPrefix :: Ident -> Span -> TypeExpr -> TypeExpr -> Span -> Span -> ConstrDecl
conOpDeclPrefix op :: Ident
op sp1 :: Span
sp1 ty1 :: TypeExpr
ty1 ty2 :: TypeExpr
ty2 sp2 :: Span
sp2 sp3 :: Span
sp3 = ConstrDecl -> ConstrDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ConstrDecl -> ConstrDecl) -> ConstrDecl -> ConstrDecl
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> TypeExpr -> Ident -> TypeExpr -> ConstrDecl
ConOpDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp3 [Span
sp2, Span
sp1]) TypeExpr
ty1 Ident
op TypeExpr
ty2
  recDecl :: (([FieldDecl], [Span]), Span, Span) -> Ident -> Span -> ConstrDecl
recDecl ((fs :: [FieldDecl]
fs, ss :: [Span]
ss), sp1 :: Span
sp1, sp2 :: Span
sp2) c :: Ident
c sp3 :: Span
sp3 = ConstrDecl -> ConstrDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (ConstrDecl -> ConstrDecl) -> ConstrDecl -> ConstrDecl
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> Ident -> [FieldDecl] -> ConstrDecl
RecordDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp3 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: [Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2])) Ident
c [FieldDecl]
fs

fieldDecl :: Parser a Token FieldDecl
fieldDecl :: Parser a Token FieldDecl
fieldDecl = Span -> ([Ident], [Span]) -> Span -> TypeExpr -> FieldDecl
mkFieldDecl (Span -> ([Ident], [Span]) -> Span -> TypeExpr -> FieldDecl)
-> Parser a Token Span
-> Parser
     a Token (([Ident], [Span]) -> Span -> TypeExpr -> FieldDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (([Ident], [Span]) -> Span -> TypeExpr -> FieldDecl)
-> Parser a Token ([Ident], [Span])
-> Parser a Token (Span -> TypeExpr -> FieldDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([Ident], [Span])
forall a. Parser a Token ([Ident], [Span])
labels
                        Parser a Token (Span -> TypeExpr -> FieldDecl)
-> Parser a Token Span -> Parser a Token (TypeExpr -> FieldDecl)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DoubleColon Parser a Token (TypeExpr -> FieldDecl)
-> Parser a Token TypeExpr -> Parser a Token FieldDecl
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0
  where labels :: Parser a Token ([Ident], [Span])
labels = Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token ([Ident], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma
        mkFieldDecl :: Span -> ([Ident], [Span]) -> Span -> TypeExpr -> FieldDecl
mkFieldDecl sp1 :: Span
sp1 (idt :: [Ident]
idt,ss :: [Span]
ss) sp2 :: Span
sp2 ty :: TypeExpr
ty = FieldDecl -> FieldDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (FieldDecl -> FieldDecl) -> FieldDecl -> FieldDecl
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> [Ident] -> TypeExpr -> FieldDecl
FieldDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2])) [Ident]
idt TypeExpr
ty

newConstrDecl :: Parser a Token NewConstrDecl
newConstrDecl :: Parser a Token NewConstrDecl
newConstrDecl = Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token (Span -> NewConstrDecl)
-> Parser a Token NewConstrDecl
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Parser a Token Ident
forall a. Parser a Token Ident
con Parser a Token Ident
-> Parser a Token (Ident -> Span -> NewConstrDecl)
-> Parser a Token (Span -> NewConstrDecl)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Ident -> Span -> NewConstrDecl)
forall a. Parser a Token (Ident -> Span -> NewConstrDecl)
newConstr)
  where newConstr :: Parser a Token (Ident -> Span -> NewConstrDecl)
newConstr =  TypeExpr -> Ident -> Span -> NewConstrDecl
newConDecl (TypeExpr -> Ident -> Span -> NewConstrDecl)
-> Parser a Token TypeExpr
-> Parser a Token (Ident -> Span -> NewConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2
                 Parser a Token (Ident -> Span -> NewConstrDecl)
-> Parser a Token (Ident -> Span -> NewConstrDecl)
-> Parser a Token (Ident -> Span -> NewConstrDecl)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> ((Ident, Span, TypeExpr), Span, Span)
-> Ident -> Span -> NewConstrDecl
newRecDecl (((Ident, Span, TypeExpr), Span, Span)
 -> Ident -> Span -> NewConstrDecl)
-> Parser a Token ((Ident, Span, TypeExpr), Span, Span)
-> Parser a Token (Ident -> Span -> NewConstrDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token ((Ident, Span, TypeExpr), Span, Span)
forall a. Parser a Token ((Ident, Span, TypeExpr), Span, Span)
newFieldDecl
        newConDecl :: TypeExpr -> Ident -> Span -> NewConstrDecl
newConDecl ty :: TypeExpr
ty  c :: Ident
c sp :: Span
sp = NewConstrDecl -> NewConstrDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (NewConstrDecl -> NewConstrDecl) -> NewConstrDecl -> NewConstrDecl
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Ident -> TypeExpr -> NewConstrDecl
NewConstrDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp []) Ident
c TypeExpr
ty
        newRecDecl :: ((Ident, Span, TypeExpr), Span, Span)
-> Ident -> Span -> NewConstrDecl
newRecDecl ((idt :: Ident
idt, sp2 :: Span
sp2, ty :: TypeExpr
ty), sp3 :: Span
sp3, sp4 :: Span
sp4) c :: Ident
c sp1 :: Span
sp1 = NewConstrDecl -> NewConstrDecl
forall a. HasSpanInfo a => a -> a
updateEndPos (NewConstrDecl -> NewConstrDecl) -> NewConstrDecl -> NewConstrDecl
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Ident -> (Ident, TypeExpr) -> NewConstrDecl
NewRecordDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp3,Span
sp2,Span
sp4]) Ident
c (Ident
idt, TypeExpr
ty)

newFieldDecl :: Parser a Token ((Ident, Span, TypeExpr), Span, Span)
newFieldDecl :: Parser a Token ((Ident, Span, TypeExpr), Span, Span)
newFieldDecl = Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOff Parser a Token Any
-> Parser a Token ((Ident, Span, TypeExpr), Span, Span)
-> Parser a Token ((Ident, Span, TypeExpr), Span, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token (Ident, Span, TypeExpr)
-> Parser a Token ((Ident, Span, TypeExpr), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp Parser a Token (Ident, Span, TypeExpr)
forall a. Parser a Token (Ident, Span, TypeExpr)
labelDecl
  where labelDecl :: Parser a Token (Ident, Span, TypeExpr)
labelDecl = (,,) (Ident -> Span -> TypeExpr -> (Ident, Span, TypeExpr))
-> Parser a Token Ident
-> Parser a Token (Span -> TypeExpr -> (Ident, Span, TypeExpr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token (Span -> TypeExpr -> (Ident, Span, TypeExpr))
-> Parser a Token Span
-> Parser a Token (TypeExpr -> (Ident, Span, TypeExpr))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DoubleColon Parser a Token (TypeExpr -> (Ident, Span, TypeExpr))
-> Parser a Token TypeExpr
-> Parser a Token (Ident, Span, TypeExpr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0

deriv :: Parser a Token ([QualIdent], [Span])
deriv :: Parser a Token ([QualIdent], [Span])
deriv = (Span -> ([QualIdent], [Span]) -> ([QualIdent], [Span])
forall a. Span -> (a, [Span]) -> (a, [Span])
addSpan (Span -> ([QualIdent], [Span]) -> ([QualIdent], [Span]))
-> Parser a Token Span
-> Parser a Token (([QualIdent], [Span]) -> ([QualIdent], [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_deriving Parser a Token (([QualIdent], [Span]) -> ([QualIdent], [Span]))
-> Parser a Token ([QualIdent], [Span])
-> Parser a Token ([QualIdent], [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([QualIdent], [Span])
forall a. Parser a Token ([QualIdent], [Span])
classes) Parser a Token ([QualIdent], [Span])
-> ([QualIdent], [Span]) -> Parser a Token ([QualIdent], [Span])
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` ([], [])
  where classes :: Parser a Token ([QualIdent], [Span])
classes = ((\q :: QualIdent
q -> ([QualIdent
q], [])) (QualIdent -> ([QualIdent], [Span]))
-> Parser a Token QualIdent -> Parser a Token ([QualIdent], [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycls)
               Parser a Token ([QualIdent], [Span])
-> Parser a Token ([QualIdent], [Span])
-> Parser a Token ([QualIdent], [Span])
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> ((\sp1 :: Span
sp1 (qs :: [QualIdent]
qs, ss :: [Span]
ss) sp2 :: Span
sp2 -> ([QualIdent]
qs, Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2])))
                      (Span -> ([QualIdent], [Span]) -> Span -> ([QualIdent], [Span]))
-> Parser a Token Span
-> Parser
     a Token (([QualIdent], [Span]) -> Span -> ([QualIdent], [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftParen
                      Parser
  a Token (([QualIdent], [Span]) -> Span -> ([QualIdent], [Span]))
-> Parser a Token ([QualIdent], [Span])
-> Parser a Token (Span -> ([QualIdent], [Span]))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycls Parser a Token QualIdent
-> Parser a Token Attributes
-> Parser a Token ([QualIdent], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
                      Parser a Token (Span -> ([QualIdent], [Span]))
-> Parser a Token Span -> Parser a Token ([QualIdent], [Span])
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen)

functionDecl :: Parser a Token (Decl ())
functionDecl :: Parser a Token (Decl ())
functionDecl = Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token (Span -> Decl ()) -> Parser a Token (Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> Decl ())
forall a. Parser a Token (Span -> Decl ())
decl
  where decl :: Parser a Token (Span -> Decl ())
decl = Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token ([Ident], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma Parser a Token ([Ident], [Span])
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token (Span -> Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall a. Parser a Token (([Ident], [Span]) -> Span -> Decl ())
funListDecl Parser a Token (Span -> Decl ())
-> Parser a Token (Span -> Decl ())
-> Parser a Token (Span -> Decl ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> Parser a Token (Span -> Decl ())
forall a. Parser a Token (Span -> Decl ())
funRule

funRule :: Parser a Token (Span -> Decl ())
funRule :: Parser a Token (Span -> Decl ())
funRule = (Ident, Lhs ()) -> Rhs () -> Span -> Decl ()
mkFunDecl ((Ident, Lhs ()) -> Rhs () -> Span -> Decl ())
-> Parser a Token (Ident, Lhs ())
-> Parser a Token (Rhs () -> Span -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Ident, Lhs ())
forall a. Parser a Token (Ident, Lhs ())
lhs Parser a Token (Rhs () -> Span -> Decl ())
-> Parser a Token (Rhs ()) -> Parser a Token (Span -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Rhs ())
forall a. Parser a Token (Rhs ())
declRhs
  where lhs :: Parser a Token (Ident, Lhs ())
lhs = (\f :: Ident
f ->
                 (Ident
f, Lhs () -> Lhs ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Lhs () -> Lhs ()) -> Lhs () -> Lhs ()
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Ident -> [Pattern ()] -> Lhs ()
forall a. SpanInfo -> Ident -> [Pattern a] -> Lhs a
FunLhs (Span -> SpanInfo
fromSrcSpan (Ident -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Ident
f)) Ident
f []))
                 (Ident -> (Ident, Lhs ()))
-> Parser a Token Ident -> Parser a Token (Ident, Lhs ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token (Ident, Lhs ())
-> Parser a Token (Ident, Lhs ()) -> Parser a Token (Ident, Lhs ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> Parser a Token (Ident, Lhs ())
forall a. Parser a Token (Ident, Lhs ())
funLhs

funListDecl :: Parser a Token (([Ident],[Span]) -> Span -> Decl ())
funListDecl :: Parser a Token (([Ident], [Span]) -> Span -> Decl ())
funListDecl = Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall a. Parser a Token (([Ident], [Span]) -> Span -> Decl ())
typeSig Parser a Token (([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Span -> ([Ident], [Span]) -> Span -> Decl ()
mkExtFun (Span -> ([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token Span
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_external
  where mkExtFun :: Span -> ([Ident], [Span]) -> Span -> Decl ()
mkExtFun sp1 :: Span
sp1 (vs :: [Ident]
vs,ss :: [Span]
ss) sp2 :: Span
sp2 = Decl () -> Decl ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl () -> Decl ()) -> Decl () -> Decl ()
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> [Var ()] -> Decl ()
forall a. SpanInfo -> [Var a] -> Decl a
ExternalDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp2 ([Span]
ss[Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++[Span
sp1])) ((Ident -> Var ()) -> [Ident] -> [Var ()]
forall a b. (a -> b) -> [a] -> [b]
map (() -> Ident -> Var ()
forall a. a -> Ident -> Var a
Var ()) [Ident]
vs)


typeSig :: Parser a Token (([Ident],[Span]) -> Span -> Decl ())
typeSig :: Parser a Token (([Ident], [Span]) -> Span -> Decl ())
typeSig = Span -> QualTypeExpr -> ([Ident], [Span]) -> Span -> Decl ()
forall a.
Span -> QualTypeExpr -> ([Ident], [Span]) -> Span -> Decl a
sig (Span -> QualTypeExpr -> ([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token Span
-> Parser
     a Token (QualTypeExpr -> ([Ident], [Span]) -> Span -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DoubleColon Parser
  a Token (QualTypeExpr -> ([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token QualTypeExpr
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualTypeExpr
forall a. Parser a Token QualTypeExpr
qualType
  where sig :: Span -> QualTypeExpr -> ([Ident], [Span]) -> Span -> Decl a
sig sp1 :: Span
sp1 qty :: QualTypeExpr
qty (vs :: [Ident]
vs,ss :: [Span]
ss) sp2 :: Span
sp2 = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> [Ident] -> QualTypeExpr -> Decl a
forall a. SpanInfo -> [Ident] -> QualTypeExpr -> Decl a
TypeSig (Span -> [Span] -> SpanInfo
spanInfo Span
sp2 ([Span]
ss[Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++[Span
sp1])) [Ident]
vs QualTypeExpr
qty

mkFunDecl :: (Ident, Lhs ()) -> Rhs () -> Span -> Decl ()
mkFunDecl :: (Ident, Lhs ()) -> Rhs () -> Span -> Decl ()
mkFunDecl (f :: Ident
f, lhs :: Lhs ()
lhs) rhs' :: Rhs ()
rhs' p :: Span
p = Decl () -> Decl ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl () -> Decl ()) -> Decl () -> Decl ()
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> () -> Ident -> [Equation ()] -> Decl ()
forall a. SpanInfo -> a -> Ident -> [Equation a] -> Decl a
FunctionDecl (Span -> [Span] -> SpanInfo
spanInfo Span
p []) () Ident
f [Equation () -> Equation ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Equation () -> Equation ()) -> Equation () -> Equation ()
forall a b. (a -> b) -> a -> b
$
                                         SpanInfo -> Lhs () -> Rhs () -> Equation ()
forall a. SpanInfo -> Lhs a -> Rhs a -> Equation a
Equation (Span -> [Span] -> SpanInfo
spanInfo Span
p []) Lhs ()
lhs Rhs ()
rhs']

funLhs :: Parser a Token (Ident, Lhs ())
funLhs :: Parser a Token (Ident, Lhs ())
funLhs = Ident -> [Pattern ()] -> (Ident, Lhs ())
forall a. Ident -> [Pattern a] -> (Ident, Lhs a)
mkFunLhs    (Ident -> [Pattern ()] -> (Ident, Lhs ()))
-> Parser a Token Ident
-> Parser a Token ([Pattern ()] -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
fun      Parser a Token ([Pattern ()] -> (Ident, Lhs ()))
-> Parser a Token [Pattern ()] -> Parser a Token (Ident, Lhs ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ()) -> Parser a Token [Pattern ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2
    Parser a Token (Ident, Lhs ())
-> Parser a Token (Ident, Lhs ()) -> Parser a Token (Ident, Lhs ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
 -> Pattern () -> (Ident, Lhs ()))
-> Pattern ()
-> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> (Ident, Lhs ())
forall a b c. (a -> b -> c) -> b -> a -> c
flip (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ())
forall a b. (a -> b) -> a -> b
$ Pattern () -> Pattern ()
forall a. HasSpanInfo a => a -> a
updateEndPos) (Pattern ()
 -> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
 -> (Ident, Lhs ()))
-> Parser a Token (Pattern ())
-> Parser
     a
     Token
     (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
      -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern1 Parser
  a
  Token
  (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
   -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser a Token (Ident, Lhs ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser
  a
  Token
  ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall a.
Parser
  a
  Token
  ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLhs
    Parser a Token (Ident, Lhs ())
-> Parser a Token (Ident, Lhs ()) -> Parser a Token (Ident, Lhs ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> Parser a Token (Ident, Lhs ())
forall a. Parser a Token (Ident, Lhs ())
curriedLhs
  where
  opLhs :: Parser
  a
  Token
  ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLhs  =                Parser a Token Ident
-> Parser a Token QualIdent
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLHS Parser a Token Ident
forall a. Parser a Token Ident
funSym (Parser a Token QualIdent
forall a. Parser a Token QualIdent
gConSym Parser a Token QualIdent
-> Parser a Token Ident -> Parser a Token QualIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
funSym)
       Parser
  a
  Token
  ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Backquote Parser a Token Span
-> Parser
     a
     Token
     (Span
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**>
             Parser a Token (Ident, Span)
-> Parser a Token (QualIdent, Span)
-> Parser
     a
     Token
     (Span
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLHSSp ((,) (Ident -> Span -> (Ident, Span))
-> Parser a Token Ident -> Parser a Token (Span -> (Ident, Span))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
funId            Parser a Token (Span -> (Ident, Span))
-> Parser a Token Span -> Parser a Token (Ident, Span)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
                                               Parser a Token (Ident, Span)
-> Parser a Token Attributes -> Parser a Token (Ident, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
expectBackquote)
                     ((,) (QualIdent -> Span -> (QualIdent, Span))
-> Parser a Token QualIdent
-> Parser a Token (Span -> (QualIdent, Span))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConId Parser a Token QualIdent
-> Parser a Token Ident -> Parser a Token QualIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
funId Parser a Token (Span -> (QualIdent, Span))
-> Parser a Token Span -> Parser a Token (QualIdent, Span)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
                                               Parser a Token (QualIdent, Span)
-> Parser a Token Attributes -> Parser a Token (QualIdent, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
expectBackquote)
  opLHS :: Parser a Token Ident
-> Parser a Token QualIdent
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLHS funP :: Parser a Token Ident
funP consP :: Parser a Token QualIdent
consP   = Ident
-> Pattern ()
-> (Pattern () -> Pattern ())
-> Pattern ()
-> (Ident, Lhs ())
forall a p.
Ident -> Pattern a -> (p -> Pattern a) -> p -> (Ident, Lhs a)
mkOpLhs       (Ident
 -> Pattern ()
 -> (Pattern () -> Pattern ())
 -> Pattern ()
 -> (Ident, Lhs ()))
-> Parser a Token Ident
-> Parser
     a
     Token
     (Pattern ()
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
funP  Parser
  a
  Token
  (Pattern ()
   -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser a Token (Pattern ())
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0
                    Parser
  a
  Token
  ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> QualIdent
-> Pattern ()
-> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> (Pattern () -> Pattern ())
-> Pattern ()
-> (Ident, Lhs ())
forall t c t.
QualIdent
-> t
-> ((Pattern () -> c) -> t -> t)
-> (Pattern () -> c)
-> Pattern ()
-> t
mkInfixPat   (QualIdent
 -> Pattern ()
 -> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
 -> (Pattern () -> Pattern ())
 -> Pattern ()
 -> (Ident, Lhs ()))
-> Parser a Token QualIdent
-> Parser
     a
     Token
     (Pattern ()
      -> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
      -> (Pattern () -> Pattern ())
      -> Pattern ()
      -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
consP Parser
  a
  Token
  (Pattern ()
   -> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
   -> (Pattern () -> Pattern ())
   -> Pattern ()
   -> (Ident, Lhs ()))
-> Parser a Token (Pattern ())
-> Parser
     a
     Token
     (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern1 Parser
  a
  Token
  (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
   -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser
  a
  Token
  ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLhs
  opLHSSp :: Parser a Token (Ident, Span)
-> Parser a Token (QualIdent, Span)
-> Parser
     a
     Token
     (Span
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLHSSp funP :: Parser a Token (Ident, Span)
funP consP :: Parser a Token (QualIdent, Span)
consP = (Ident, Span)
-> Pattern ()
-> Span
-> (Pattern () -> Pattern ())
-> Pattern ()
-> (Ident, Lhs ())
forall a p.
(Ident, Span)
-> Pattern a -> Span -> (p -> Pattern a) -> p -> (Ident, Lhs a)
mkOpLhsSp     ((Ident, Span)
 -> Pattern ()
 -> Span
 -> (Pattern () -> Pattern ())
 -> Pattern ()
 -> (Ident, Lhs ()))
-> Parser a Token (Ident, Span)
-> Parser
     a
     Token
     (Pattern ()
      -> Span
      -> (Pattern () -> Pattern ())
      -> Pattern ()
      -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Ident, Span)
funP  Parser
  a
  Token
  (Pattern ()
   -> Span
   -> (Pattern () -> Pattern ())
   -> Pattern ()
   -> (Ident, Lhs ()))
-> Parser a Token (Pattern ())
-> Parser
     a
     Token
     (Span
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0
                    Parser
  a
  Token
  (Span
   -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     (Span
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     (Span
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (QualIdent, Span)
-> Pattern ()
-> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Span
-> (Pattern () -> Pattern ())
-> Pattern ()
-> (Ident, Lhs ())
forall t c t.
(QualIdent, Span)
-> t
-> ((Pattern () -> c) -> t -> t)
-> Span
-> (Pattern () -> c)
-> Pattern ()
-> t
mkInfixPatSp ((QualIdent, Span)
 -> Pattern ()
 -> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
 -> Span
 -> (Pattern () -> Pattern ())
 -> Pattern ()
 -> (Ident, Lhs ()))
-> Parser a Token (QualIdent, Span)
-> Parser
     a
     Token
     (Pattern ()
      -> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
      -> Span
      -> (Pattern () -> Pattern ())
      -> Pattern ()
      -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (QualIdent, Span)
consP Parser
  a
  Token
  (Pattern ()
   -> ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
   -> Span
   -> (Pattern () -> Pattern ())
   -> Pattern ()
   -> (Ident, Lhs ()))
-> Parser a Token (Pattern ())
-> Parser
     a
     Token
     (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
      -> Span
      -> (Pattern () -> Pattern ())
      -> Pattern ()
      -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern1 Parser
  a
  Token
  (((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
   -> Span
   -> (Pattern () -> Pattern ())
   -> Pattern ()
   -> (Ident, Lhs ()))
-> Parser
     a
     Token
     ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
-> Parser
     a
     Token
     (Span
      -> (Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser
  a
  Token
  ((Pattern () -> Pattern ()) -> Pattern () -> (Ident, Lhs ()))
opLhs
  mkFunLhs :: Ident -> [Pattern a] -> (Ident, Lhs a)
mkFunLhs f :: Ident
f ts :: [Pattern a]
ts = (Ident
f , Lhs a -> Lhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Lhs a -> Lhs a) -> Lhs a -> Lhs a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Ident -> [Pattern a] -> Lhs a
forall a. SpanInfo -> Ident -> [Pattern a] -> Lhs a
FunLhs (Span -> SpanInfo
fromSrcSpan (Ident -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Ident
f)) Ident
f [Pattern a]
ts)
  mkOpLhs :: Ident -> Pattern a -> (p -> Pattern a) -> p -> (Ident, Lhs a)
mkOpLhs op :: Ident
op t2 :: Pattern a
t2 f :: p -> Pattern a
f t1 :: p
t1      =
    let t1' :: Pattern a
t1' = p -> Pattern a
f p
t1
    in (Ident
op, Lhs a -> Lhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Lhs a -> Lhs a) -> Lhs a -> Lhs a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Pattern a -> Ident -> Pattern a -> Lhs a
forall a. SpanInfo -> Pattern a -> Ident -> Pattern a -> Lhs a
OpLhs (Span -> SpanInfo
fromSrcSpan (Pattern a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Pattern a
t1')) Pattern a
t1' Ident
op Pattern a
t2)
  mkInfixPat :: QualIdent
-> t
-> ((Pattern () -> c) -> t -> t)
-> (Pattern () -> c)
-> Pattern ()
-> t
mkInfixPat op :: QualIdent
op t2 :: t
t2 f :: (Pattern () -> c) -> t -> t
f g :: Pattern () -> c
g t1 :: Pattern ()
t1 =
    (Pattern () -> c) -> t -> t
f (Pattern () -> c
g (Pattern () -> c) -> (Pattern () -> Pattern ()) -> Pattern () -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanInfo
-> () -> Pattern () -> QualIdent -> Pattern () -> Pattern ()
forall a.
SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
InfixPattern (Span -> SpanInfo
fromSrcSpan (Pattern () -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Pattern ()
t1)) () Pattern ()
t1 QualIdent
op) t
t2
  mkOpLhsSp :: (Ident, Span)
-> Pattern a -> Span -> (p -> Pattern a) -> p -> (Ident, Lhs a)
mkOpLhsSp (op :: Ident
op, sp1 :: Span
sp1)    t2 :: Pattern a
t2   sp2 :: Span
sp2 f :: p -> Pattern a
f t1 :: p
t1 =
    let t1' :: Pattern a
t1' = p -> Pattern a
f p
t1
    in (Ident
op, Lhs a -> Lhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Lhs a -> Lhs a) -> Lhs a -> Lhs a
forall a b. (a -> b) -> a -> b
$
              SpanInfo -> Pattern a -> Ident -> Pattern a -> Lhs a
forall a. SpanInfo -> Pattern a -> Ident -> Pattern a -> Lhs a
OpLhs (Span -> [Span] -> SpanInfo
spanInfo (Pattern a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Pattern a
t1') [Span
sp2, Span
sp1]) Pattern a
t1' Ident
op Pattern a
t2)

  mkInfixPatSp :: (QualIdent, Span)
-> t
-> ((Pattern () -> c) -> t -> t)
-> Span
-> (Pattern () -> c)
-> Pattern ()
-> t
mkInfixPatSp (op :: QualIdent
op, sp1 :: Span
sp1) t2 :: t
t2 g :: (Pattern () -> c) -> t -> t
g sp2 :: Span
sp2 f :: Pattern () -> c
f t1 :: Pattern ()
t1 =
    (Pattern () -> c) -> t -> t
g (Pattern () -> c
f (Pattern () -> c) -> (Pattern () -> Pattern ()) -> Pattern () -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanInfo
-> () -> Pattern () -> QualIdent -> Pattern () -> Pattern ()
forall a.
SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
InfixPattern (Span -> [Span] -> SpanInfo
spanInfo (Pattern () -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Pattern ()
t1) [Span
sp2, Span
sp1]) () Pattern ()
t1 QualIdent
op) t
t2


curriedLhs :: Parser a Token (Ident, Lhs ())
curriedLhs :: Parser a Token (Ident, Lhs ())
curriedLhs = ((Ident, Lhs ()), Span, Span) -> [Pattern ()] -> (Ident, Lhs ())
forall a a. ((a, Lhs a), Span, Span) -> [Pattern a] -> (a, Lhs a)
apLhs (((Ident, Lhs ()), Span, Span) -> [Pattern ()] -> (Ident, Lhs ()))
-> Parser a Token ((Ident, Lhs ()), Span, Span)
-> Parser a Token ([Pattern ()] -> (Ident, Lhs ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Ident, Lhs ())
-> Parser a Token ((Ident, Lhs ()), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp Parser a Token (Ident, Lhs ())
forall a. Parser a Token (Ident, Lhs ())
funLhs Parser a Token ([Pattern ()] -> (Ident, Lhs ()))
-> Parser a Token [Pattern ()] -> Parser a Token (Ident, Lhs ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ()) -> Parser a Token [Pattern ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2
  where apLhs :: ((a, Lhs a), Span, Span) -> [Pattern a] -> (a, Lhs a)
apLhs ((f :: a
f, lhs :: Lhs a
lhs), sp1 :: Span
sp1, sp2 :: Span
sp2) ts :: [Pattern a]
ts =
          let spi :: SpanInfo
spi = Span -> SpanInfo
fromSrcSpan Span
sp1
          in (a
f, Lhs a -> Lhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Lhs a -> Lhs a) -> Lhs a -> Lhs a
forall a b. (a -> b) -> a -> b
$ [Span] -> Lhs a -> Lhs a
forall a. HasSpanInfo a => [Span] -> a -> a
setSrcInfoPoints [Span
sp1, Span
sp2] (Lhs a -> Lhs a) -> Lhs a -> Lhs a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Lhs a -> [Pattern a] -> Lhs a
forall a. SpanInfo -> Lhs a -> [Pattern a] -> Lhs a
ApLhs SpanInfo
spi Lhs a
lhs [Pattern a]
ts)

declRhs :: Parser a Token (Rhs ())
declRhs :: Parser a Token (Rhs ())
declRhs = Parser a Token Attributes -> Parser a Token (Rhs ())
forall a b. Parser a Token b -> Parser a Token (Rhs ())
rhs Parser a Token Attributes
forall a. Parser a Token Attributes
equals

rhs :: Parser a Token b -> Parser a Token (Rhs ())
rhs :: Parser a Token b -> Parser a Token (Rhs ())
rhs eq :: Parser a Token b
eq = Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
rhsExpr Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
-> Parser a Token (Rhs ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
forall a. Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
localDecls
  where rhsExpr :: Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
rhsExpr =  Span
-> Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ()
forall a.
Span -> Expression a -> (Maybe Span, [Decl a], LayoutInfo) -> Rhs a
mkSimpleRhs  (Span
 -> Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token Span
-> Parser
     a
     Token
     (Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser
  a
  Token
  (Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token b
-> Parser
     a
     Token
     (Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token b
eq Parser
  a
  Token
  (Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token (Expression ())
-> Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
               Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Span
-> [CondExpr ()] -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ()
forall a.
Span -> [CondExpr a] -> (Maybe Span, [Decl a], LayoutInfo) -> Rhs a
mkGuardedRhs (Span
 -> [CondExpr ()] -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token Span
-> Parser
     a
     Token
     ([CondExpr ()] -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser
  a
  Token
  ([CondExpr ()] -> (Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
-> Parser a Token [CondExpr ()]
-> Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Rhs ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  Parser a Token (CondExpr ()) -> Parser a Token [CondExpr ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 (Parser a Token b -> Parser a Token (CondExpr ())
forall a b. Parser a Token b -> Parser a Token (CondExpr ())
condExpr Parser a Token b
eq)
        mkSimpleRhs :: Span -> Expression a -> (Maybe Span, [Decl a], LayoutInfo) -> Rhs a
mkSimpleRhs  sp1 :: Span
sp1 e :: Expression a
e  (Just sp2 :: Span
sp2, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Rhs a -> Rhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Rhs a -> Rhs a) -> Rhs a -> Rhs a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Rhs a
forall a.
SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Rhs a
SimpleRhs  (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 [Span
sp1, Span
sp2]) LayoutInfo
li Expression a
e [Decl a]
ds
        mkSimpleRhs  sp1 :: Span
sp1 e :: Expression a
e  (Nothing, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Rhs a -> Rhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Rhs a -> Rhs a) -> Rhs a -> Rhs a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Rhs a
forall a.
SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Rhs a
SimpleRhs  (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 [Span
sp1]) LayoutInfo
li Expression a
e [Decl a]
ds
        mkGuardedRhs :: Span -> [CondExpr a] -> (Maybe Span, [Decl a], LayoutInfo) -> Rhs a
mkGuardedRhs sp1 :: Span
sp1 ce :: [CondExpr a]
ce (Just sp2 :: Span
sp2, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Rhs a -> Rhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Rhs a -> Rhs a) -> Rhs a -> Rhs a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> LayoutInfo -> [CondExpr a] -> [Decl a] -> Rhs a
forall a.
SpanInfo -> LayoutInfo -> [CondExpr a] -> [Decl a] -> Rhs a
GuardedRhs (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 [Span
sp1, Span
sp2]) LayoutInfo
li [CondExpr a]
ce [Decl a]
ds
        mkGuardedRhs sp1 :: Span
sp1 ce :: [CondExpr a]
ce (Nothing, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Rhs a -> Rhs a
forall a. HasSpanInfo a => a -> a
updateEndPos (Rhs a -> Rhs a) -> Rhs a -> Rhs a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> LayoutInfo -> [CondExpr a] -> [Decl a] -> Rhs a
forall a.
SpanInfo -> LayoutInfo -> [CondExpr a] -> [Decl a] -> Rhs a
GuardedRhs (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 [Span
sp1]) LayoutInfo
li [CondExpr a]
ce [Decl a]
ds

whereClause :: Parser a Token b -> Parser a Token (Maybe Span, [b], LayoutInfo)
whereClause :: Parser a Token b -> Parser a Token (Maybe Span, [b], LayoutInfo)
whereClause decl :: Parser a Token b
decl = (\sp :: Span
sp (ds :: [b]
ds, li :: LayoutInfo
li) -> (Span -> Maybe Span
forall a. a -> Maybe a
Just Span
sp, [b]
ds, LayoutInfo
li))
  (Span -> ([b], LayoutInfo) -> (Maybe Span, [b], LayoutInfo))
-> Parser a Token Span
-> Parser
     a Token (([b], LayoutInfo) -> (Maybe Span, [b], LayoutInfo))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_where
  Parser a Token (([b], LayoutInfo) -> (Maybe Span, [b], LayoutInfo))
-> Parser a Token ([b], LayoutInfo)
-> Parser a Token (Maybe Span, [b], LayoutInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token b -> Parser a Token ([b], LayoutInfo)
forall a b. Parser a Token b -> Parser a Token ([b], LayoutInfo)
layoutWhere Parser a Token b
decl Parser a Token (Maybe Span, [b], LayoutInfo)
-> (Maybe Span, [b], LayoutInfo)
-> Parser a Token (Maybe Span, [b], LayoutInfo)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` (Maybe Span
forall a. Maybe a
Nothing, [], LayoutInfo
WhitespaceLayout)

localDecls :: Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
localDecls :: Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
localDecls = Parser a Token (Decl ())
-> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
forall a b.
Parser a Token b -> Parser a Token (Maybe Span, [b], LayoutInfo)
whereClause Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
valueOrInfixDecl

valueDecls :: Parser a Token ([Decl ()], [Span])
valueDecls :: Parser a Token ([Decl ()], [Span])
valueDecls = Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
valueOrInfixDecl Parser a Token (Decl ())
-> Parser a Token Attributes -> Parser a Token ([Decl ()], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon

valueOrInfixDecl :: Parser a Token (Decl ())
valueOrInfixDecl :: Parser a Token (Decl ())
valueOrInfixDecl = [Parser a Token (Decl ())] -> Parser a Token (Decl ())
forall s a b. Symbol s => [Parser a s b] -> Parser a s b
choice [Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
infixDecl, Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
valueDecl]

infixDecl :: Parser a Token (Decl ())
infixDecl :: Parser a Token (Decl ())
infixDecl = (Span
 -> Infix
 -> Maybe (Span, Precedence)
 -> ([Ident], [Span])
 -> Decl ())
-> Parser
     a Token (Maybe (Span, Precedence) -> ([Ident], [Span]) -> Decl ())
forall a b. (Span -> Infix -> a) -> Parser b Token a
infixDeclLhs Span
-> Infix
-> Maybe (Span, Precedence)
-> ([Ident], [Span])
-> Decl ()
forall a.
Span
-> Infix -> Maybe (Span, Precedence) -> ([Ident], [Span]) -> Decl a
infixDecl'
              Parser
  a Token (Maybe (Span, Precedence) -> ([Ident], [Span]) -> Decl ())
-> Parser a Token (Maybe (Span, Precedence))
-> Parser a Token (([Ident], [Span]) -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Span, Precedence)
-> Parser a Token (Maybe (Span, Precedence))
forall s a b. Symbol s => Parser a s b -> Parser a s (Maybe b)
option ((,) (Span -> Precedence -> (Span, Precedence))
-> Parser a Token Span
-> Parser a Token (Precedence -> (Span, Precedence))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Precedence -> (Span, Precedence))
-> Parser a Token Precedence -> Parser a Token (Span, Precedence)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Precedence
forall a. Parser a Token Precedence
integer)
              Parser a Token (([Ident], [Span]) -> Decl ())
-> Parser a Token ([Ident], [Span]) -> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident
forall a. Parser a Token Ident
funop Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token ([Ident], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma
  where infixDecl' :: Span
-> Infix -> Maybe (Span, Precedence) -> ([Ident], [Span]) -> Decl a
infixDecl' sp1 :: Span
sp1 inf :: Infix
inf (Just (sp2 :: Span
sp2, pr :: Precedence
pr)) (ids :: [Ident]
ids, ss :: [Span]
ss) =
          Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Infix -> Maybe Precedence -> [Ident] -> Decl a
forall a.
SpanInfo -> Infix -> Maybe Precedence -> [Ident] -> Decl a
InfixDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (Span
sp1Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
:Span
sp2Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
:[Span]
ss)) Infix
inf (Precedence -> Maybe Precedence
forall a. a -> Maybe a
Just Precedence
pr) [Ident]
ids
        infixDecl' sp1 :: Span
sp1 inf :: Infix
inf Nothing          (ids :: [Ident]
ids, ss :: [Span]
ss) =
          Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Infix -> Maybe Precedence -> [Ident] -> Decl a
forall a.
SpanInfo -> Infix -> Maybe Precedence -> [Ident] -> Decl a
InfixDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (Span
sp1    Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
:[Span]
ss)) Infix
inf Maybe Precedence
forall a. Maybe a
Nothing   [Ident]
ids

infixDeclLhs :: (Span -> Infix -> a) -> Parser b Token a
infixDeclLhs :: (Span -> Infix -> a) -> Parser b Token a
infixDeclLhs f :: Span -> Infix -> a
f = Span -> Infix -> a
f (Span -> Infix -> a)
-> Parser b Token Span -> Parser b Token (Infix -> a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser b Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser b Token (Infix -> a)
-> Parser b Token Infix -> Parser b Token a
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [(Category, Infix)] -> Parser b Token Infix
forall b a. [(Category, b)] -> Parser a Token b
tokenOps [(Category, Infix)]
infixKW
  where infixKW :: [(Category, Infix)]
infixKW = [(Category
KW_infix, Infix
Infix), (Category
KW_infixl, Infix
InfixL), (Category
KW_infixr, Infix
InfixR)]

valueDecl :: Parser a Token (Decl ())
valueDecl :: Parser a Token (Decl ())
valueDecl = Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token (Span -> Decl ()) -> Parser a Token (Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> Decl ())
forall a. Parser a Token (Span -> Decl ())
decl
  where
  decl :: Parser a Token (Span -> Decl ())
decl =   Parser a Token Ident
forall a. Parser a Token Ident
var Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token ([Ident], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma       Parser a Token ([Ident], [Span])
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token (Span -> Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall a. Parser a Token (([Ident], [Span]) -> Span -> Decl ())
valListDecl
      Parser a Token (Span -> Decl ())
-> Parser a Token (Span -> Decl ())
-> Parser a Token (Span -> Decl ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> Pattern () -> Rhs () -> Span -> Decl ()
patOrFunDecl (Pattern () -> Rhs () -> Span -> Decl ())
-> Parser a Token (Pattern ())
-> Parser a Token (Rhs () -> Span -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0   Parser a Token (Rhs () -> Span -> Decl ())
-> Parser a Token (Rhs ()) -> Parser a Token (Span -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Rhs ())
forall a. Parser a Token (Rhs ())
declRhs
      Parser a Token (Span -> Decl ())
-> Parser a Token (Span -> Decl ())
-> Parser a Token (Span -> Decl ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> (Ident, Lhs ()) -> Rhs () -> Span -> Decl ()
mkFunDecl    ((Ident, Lhs ()) -> Rhs () -> Span -> Decl ())
-> Parser a Token (Ident, Lhs ())
-> Parser a Token (Rhs () -> Span -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Ident, Lhs ())
forall a. Parser a Token (Ident, Lhs ())
curriedLhs Parser a Token (Rhs () -> Span -> Decl ())
-> Parser a Token (Rhs ()) -> Parser a Token (Span -> Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Rhs ())
forall a. Parser a Token (Rhs ())
declRhs

  valListDecl :: Parser a Token (([Ident], [Span]) -> Span -> Decl ())
valListDecl =  Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall a. Parser a Token (([Ident], [Span]) -> Span -> Decl ())
funListDecl
             Parser a Token (([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Span -> ([Ident], [Span]) -> Span -> Decl ()
mkFree (Span -> ([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token Span
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_free
    where mkFree :: Span -> ([Ident], [Span]) -> Span -> Decl ()
mkFree sp1 :: Span
sp1 (vs :: [Ident]
vs, ss :: [Span]
ss) sp2 :: Span
sp2 = Decl () -> Decl ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl () -> Decl ()) -> Decl () -> Decl ()
forall a b. (a -> b) -> a -> b
$
            SpanInfo -> [Var ()] -> Decl ()
forall a. SpanInfo -> [Var a] -> Decl a
FreeDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp2 ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp1])) ((Ident -> Var ()) -> [Ident] -> [Var ()]
forall a b. (a -> b) -> [a] -> [b]
map (() -> Ident -> Var ()
forall a. a -> Ident -> Var a
Var ()) [Ident]
vs)

  patOrFunDecl :: Pattern () -> Rhs () -> Span -> Decl ()
patOrFunDecl (ConstructorPattern spi :: SpanInfo
spi _ c :: QualIdent
c ts :: [Pattern ()]
ts)
    | Qualified -> Qualified
not (QualIdent -> Qualified
isConstrId QualIdent
c) = (Ident, Lhs ()) -> Rhs () -> Span -> Decl ()
mkFunDecl (Ident
f, SpanInfo -> Ident -> [Pattern ()] -> Lhs ()
forall a. SpanInfo -> Ident -> [Pattern a] -> Lhs a
FunLhs SpanInfo
spi Ident
f [Pattern ()]
ts)
    where f :: Ident
f = QualIdent -> Ident
unqualify QualIdent
c
  patOrFunDecl t :: Pattern ()
t = (Pattern () -> Pattern ())
-> Pattern () -> Rhs () -> Span -> Decl ()
patOrOpDecl Pattern () -> Pattern ()
forall a. HasSpanInfo a => a -> a
updateEndPos Pattern ()
t

  patOrOpDecl :: (Pattern () -> Pattern ())
-> Pattern () -> Rhs () -> Span -> Decl ()
patOrOpDecl f :: Pattern () -> Pattern ()
f (InfixPattern spi :: SpanInfo
spi a :: ()
a t1 :: Pattern ()
t1 op :: QualIdent
op t2 :: Pattern ()
t2)
    | QualIdent -> Qualified
isConstrId QualIdent
op = (Pattern () -> Pattern ())
-> Pattern () -> Rhs () -> Span -> Decl ()
patOrOpDecl (Pattern () -> Pattern ()
f (Pattern () -> Pattern ())
-> (Pattern () -> Pattern ()) -> Pattern () -> Pattern ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanInfo
-> () -> Pattern () -> QualIdent -> Pattern () -> Pattern ()
forall a.
SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
InfixPattern SpanInfo
spi ()
a Pattern ()
t1 QualIdent
op) Pattern ()
t2
    | Qualified
otherwise     = (Ident, Lhs ()) -> Rhs () -> Span -> Decl ()
mkFunDecl (Ident
op', Lhs () -> Lhs ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Lhs () -> Lhs ()) -> Lhs () -> Lhs ()
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Pattern () -> Ident -> Pattern () -> Lhs ()
forall a. SpanInfo -> Pattern a -> Ident -> Pattern a -> Lhs a
OpLhs SpanInfo
spi (Pattern () -> Pattern ()
f Pattern ()
t1) Ident
op' Pattern ()
t2)
    where op' :: Ident
op' = QualIdent -> Ident
unqualify QualIdent
op
  patOrOpDecl f :: Pattern () -> Pattern ()
f t :: Pattern ()
t = Pattern () -> Rhs () -> Span -> Decl ()
forall a. Pattern a -> Rhs a -> Span -> Decl a
mkPatDecl (Pattern () -> Pattern ()
f Pattern ()
t)

  mkPatDecl :: Pattern a -> Rhs a -> Span -> Decl a
mkPatDecl t :: Pattern a
t rhs' :: Rhs a
rhs' sp :: Span
sp = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Pattern a -> Rhs a -> Decl a
forall a. SpanInfo -> Pattern a -> Rhs a -> Decl a
PatternDecl (Span -> SpanInfo
fromSrcSpan Span
sp) Pattern a
t Rhs a
rhs'

  isConstrId :: QualIdent -> Qualified
isConstrId c :: QualIdent
c = QualIdent
c QualIdent -> QualIdent -> Qualified
forall a. Eq a => a -> a -> Qualified
== QualIdent
qConsId Qualified -> Qualified -> Qualified
|| QualIdent -> Qualified
isQualified QualIdent
c Qualified -> Qualified -> Qualified
|| QualIdent -> Qualified
isQTupleId QualIdent
c

defaultDecl :: Parser a Token (Decl ())
defaultDecl :: Parser a Token (Decl ())
defaultDecl = Span -> (([TypeExpr], [Span]), Span, Span) -> Decl ()
forall a. Span -> (([TypeExpr], [Span]), Span, Span) -> Decl a
mkDefaultDecl (Span -> (([TypeExpr], [Span]), Span, Span) -> Decl ())
-> Parser a Token Span
-> Parser a Token ((([TypeExpr], [Span]), Span, Span) -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_default
                            Parser a Token ((([TypeExpr], [Span]), Span, Span) -> Decl ())
-> Parser a Token (([TypeExpr], [Span]), Span, Span)
-> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([TypeExpr], [Span])
-> Parser a Token (([TypeExpr], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0 Parser a Token TypeExpr
-> Parser a Token Attributes -> Parser a Token ([TypeExpr], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
  where mkDefaultDecl :: Span -> (([TypeExpr], [Span]), Span, Span) -> Decl a
mkDefaultDecl sp1 :: Span
sp1 ((ty :: [TypeExpr]
ty, ss :: [Span]
ss), sp2 :: Span
sp2, sp3 :: Span
sp3) = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> [TypeExpr] -> Decl a
forall a. SpanInfo -> [TypeExpr] -> Decl a
DefaultDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: Span
sp2 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp3]))) [TypeExpr]
ty

classInstHead :: Category -> Parser a Token b -> Parser a Token c
              -> Parser a Token (Span, [Span], Context, b, c)
classInstHead :: Category
-> Parser a Token b
-> Parser a Token c
-> Parser a Token (Span, [Span], Context, b, c)
classInstHead kw :: Category
kw cls :: Parser a Token b
cls ty :: Parser a Token c
ty = Span -> (Context, [Span], (b, c)) -> (Span, [Span], Context, b, c)
forall a c b d e. a -> (c, b, (d, e)) -> (a, b, c, d, e)
f (Span
 -> (Context, [Span], (b, c)) -> (Span, [Span], Context, b, c))
-> Parser a Token Span
-> Parser
     a
     Token
     ((Context, [Span], (b, c)) -> (Span, [Span], Context, b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
kw
                            Parser
  a
  Token
  ((Context, [Span], (b, c)) -> (Span, [Span], Context, b, c))
-> Parser a Token (Context, [Span], (b, c))
-> Parser a Token (Span, [Span], Context, b, c)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Context -> [Span] -> (b, c) -> (Context, [Span], (b, c)))
-> Parser a Token (b, c)
-> Parser a Token (Context, [Span], (b, c))
forall a b c.
(Context -> [Span] -> a -> b)
-> Parser c Token a -> Parser c Token b
optContext (,,) ((,) (b -> c -> (b, c))
-> Parser a Token b -> Parser a Token (c -> (b, c))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token b
cls Parser a Token (c -> (b, c))
-> Parser a Token c -> Parser a Token (b, c)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token c
ty)
  where f :: a -> (c, b, (d, e)) -> (a, b, c, d, e)
f sp :: a
sp (cx :: c
cx, ss :: b
ss, (cls' :: d
cls', ty' :: e
ty')) = (a
sp, b
ss, c
cx, d
cls', e
ty')

classDecl :: Parser a Token (Decl ())
classDecl :: Parser a Token (Decl ())
classDecl = (Span, [Span], Context, Ident, Ident)
-> (Maybe Span, [Decl ()], LayoutInfo) -> Decl ()
forall a.
(Span, [Span], Context, Ident, Ident)
-> (Maybe Span, [Decl a], LayoutInfo) -> Decl a
mkClass
        ((Span, [Span], Context, Ident, Ident)
 -> (Maybe Span, [Decl ()], LayoutInfo) -> Decl ())
-> Parser a Token (Span, [Span], Context, Ident, Ident)
-> Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category
-> Parser a Token Ident
-> Parser a Token Ident
-> Parser a Token (Span, [Span], Context, Ident, Ident)
forall a b c.
Category
-> Parser a Token b
-> Parser a Token c
-> Parser a Token (Span, [Span], Context, b, c)
classInstHead Category
KW_class Parser a Token Ident
forall a. Parser a Token Ident
tycls Parser a Token Ident
forall a. Parser a Token Ident
clsvar
        Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Decl ())
-> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
-> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Decl ())
-> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
forall a b.
Parser a Token b -> Parser a Token (Maybe Span, [b], LayoutInfo)
whereClause Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
innerDecl
  where
    --TODO: Refactor by left-factorization
    --TODO: Support infixDecl
    innerDecl :: Parser a Token (Decl ())
innerDecl = (Parser a Token (Decl ())
 -> Parser a Token (Decl ()) -> Parser a Token (Decl ()))
-> [Parser a Token (Decl ())] -> Parser a Token (Decl ())
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 Parser a Token (Decl ())
-> Parser a Token (Decl ()) -> Parser a Token (Decl ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
(<|?>)
      [ Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token (Span -> Decl ()) -> Parser a Token (Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Parser a Token Ident
forall a. Parser a Token Ident
fun Parser a Token Ident
-> Parser a Token Attributes -> Parser a Token ([Ident], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma Parser a Token ([Ident], [Span])
-> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
-> Parser a Token (Span -> Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (([Ident], [Span]) -> Span -> Decl ())
forall a. Parser a Token (([Ident], [Span]) -> Span -> Decl ())
typeSig)
      , Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token (Span -> Decl ()) -> Parser a Token (Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> Decl ())
forall a. Parser a Token (Span -> Decl ())
funRule
      {-, infixDecl-} ]
    mkClass :: (Span, [Span], Context, Ident, Ident)
-> (Maybe Span, [Decl a], LayoutInfo) -> Decl a
mkClass (sp1 :: Span
sp1, ss :: [Span]
ss, cx :: Context
cx, cls :: Ident
cls, tv :: Ident
tv) (Just sp2 :: Span
sp2, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
      SpanInfo
-> LayoutInfo -> Context -> Ident -> Ident -> [Decl a] -> Decl a
forall a.
SpanInfo
-> LayoutInfo -> Context -> Ident -> Ident -> [Decl a] -> Decl a
ClassDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2]))) LayoutInfo
li Context
cx Ident
cls Ident
tv [Decl a]
ds
    mkClass (sp1 :: Span
sp1, ss :: [Span]
ss, cx :: Context
cx, cls :: Ident
cls, tv :: Ident
tv) (Nothing, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
      SpanInfo
-> LayoutInfo -> Context -> Ident -> Ident -> [Decl a] -> Decl a
forall a.
SpanInfo
-> LayoutInfo -> Context -> Ident -> Ident -> [Decl a] -> Decl a
ClassDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: [Span]
ss)) LayoutInfo
li Context
cx Ident
cls Ident
tv [Decl a]
ds

instanceDecl :: Parser a Token (Decl ())
instanceDecl :: Parser a Token (Decl ())
instanceDecl = (Span, [Span], Context, QualIdent, TypeExpr)
-> (Maybe Span, [Decl ()], LayoutInfo) -> Decl ()
forall a.
(Span, [Span], Context, QualIdent, TypeExpr)
-> (Maybe Span, [Decl a], LayoutInfo) -> Decl a
mkInstance
           ((Span, [Span], Context, QualIdent, TypeExpr)
 -> (Maybe Span, [Decl ()], LayoutInfo) -> Decl ())
-> Parser a Token (Span, [Span], Context, QualIdent, TypeExpr)
-> Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Decl ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category
-> Parser a Token QualIdent
-> Parser a Token TypeExpr
-> Parser a Token (Span, [Span], Context, QualIdent, TypeExpr)
forall a b c.
Category
-> Parser a Token b
-> Parser a Token c
-> Parser a Token (Span, [Span], Context, b, c)
classInstHead Category
KW_instance Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycls Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2
           Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Decl ())
-> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
-> Parser a Token (Decl ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Decl ())
-> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
forall a b.
Parser a Token b -> Parser a Token (Maybe Span, [b], LayoutInfo)
whereClause Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
innerDecl
  where
    innerDecl :: Parser a Token (Decl ())
innerDecl = Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token (Span -> Decl ()) -> Parser a Token (Decl ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> Decl ())
forall a. Parser a Token (Span -> Decl ())
funRule
    mkInstance :: (Span, [Span], Context, QualIdent, TypeExpr)
-> (Maybe Span, [Decl a], LayoutInfo) -> Decl a
mkInstance (sp1 :: Span
sp1, ss :: [Span]
ss, cx :: Context
cx, qcls :: QualIdent
qcls, inst :: TypeExpr
inst) (Just sp2 :: Span
sp2, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
      SpanInfo
-> LayoutInfo
-> Context
-> QualIdent
-> TypeExpr
-> [Decl a]
-> Decl a
forall a.
SpanInfo
-> LayoutInfo
-> Context
-> QualIdent
-> TypeExpr
-> [Decl a]
-> Decl a
InstanceDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2]))) LayoutInfo
li Context
cx QualIdent
qcls TypeExpr
inst [Decl a]
ds
    mkInstance (sp1 :: Span
sp1, ss :: [Span]
ss, cx :: Context
cx, qcls :: QualIdent
qcls, inst :: TypeExpr
inst) (Nothing, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Decl a -> Decl a
forall a. HasSpanInfo a => a -> a
updateEndPos (Decl a -> Decl a) -> Decl a -> Decl a
forall a b. (a -> b) -> a -> b
$
      SpanInfo
-> LayoutInfo
-> Context
-> QualIdent
-> TypeExpr
-> [Decl a]
-> Decl a
forall a.
SpanInfo
-> LayoutInfo
-> Context
-> QualIdent
-> TypeExpr
-> [Decl a]
-> Decl a
InstanceDecl (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: [Span]
ss)) LayoutInfo
li Context
cx QualIdent
qcls TypeExpr
inst [Decl a]
ds
-- ---------------------------------------------------------------------------
-- Type classes
-- ---------------------------------------------------------------------------

optContext :: (Context -> [Span] -> a -> b)
           -> Parser c Token a
           -> Parser c Token b
optContext :: (Context -> [Span] -> a -> b)
-> Parser c Token a -> Parser c Token b
optContext f :: Context -> [Span] -> a -> b
f p :: Parser c Token a
p = (Context, [Span]) -> Span -> a -> b
combine ((Context, [Span]) -> Span -> a -> b)
-> Parser c Token (Context, [Span])
-> Parser c Token (Span -> a -> b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser c Token (Context, [Span])
forall a. Parser a Token (Context, [Span])
context Parser c Token (Span -> a -> b)
-> Parser c Token Span -> Parser c Token (a -> b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser c Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DoubleArrow Parser c Token (a -> b) -> Parser c Token a -> Parser c Token b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser c Token a
p
            Parser c Token b -> Parser c Token b -> Parser c Token b
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> Context -> [Span] -> a -> b
f [] [] (a -> b) -> Parser c Token a -> Parser c Token b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser c Token a
p
  where combine :: (Context, [Span]) -> Span -> a -> b
combine (ctx :: Context
ctx, ss :: [Span]
ss) sp :: Span
sp = Context -> [Span] -> a -> b
f Context
ctx ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp])

context :: Parser a Token (Context, [Span])
context :: Parser a Token (Context, [Span])
context = (\c :: Constraint
c -> ([Constraint
c], [])) (Constraint -> (Context, [Span]))
-> Parser a Token Constraint -> Parser a Token (Context, [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Constraint
forall a. Parser a Token Constraint
constraint
      Parser a Token (Context, [Span])
-> Parser a Token (Context, [Span])
-> Parser a Token (Context, [Span])
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> ((Context, [Span]), Span, Span) -> (Context, [Span])
forall a a. ((a, [a]), a, a) -> (a, [a])
combine (((Context, [Span]), Span, Span) -> (Context, [Span]))
-> Parser a Token ((Context, [Span]), Span, Span)
-> Parser a Token (Context, [Span])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Context, [Span])
-> Parser a Token ((Context, [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token Constraint
forall a. Parser a Token Constraint
constraint Parser a Token Constraint
-> Parser a Token Attributes -> Parser a Token (Context, [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
  where combine :: ((a, [a]), a, a) -> (a, [a])
combine ((ctx :: a
ctx, ss :: [a]
ss), sp1 :: a
sp1, sp2 :: a
sp2) = (a
ctx, a
sp1 a -> [a] -> [a]
forall a. a -> [a] -> [a]
: ([a]
ss [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a
sp2]))

constraint :: Parser a Token Constraint
constraint :: Parser a Token Constraint
constraint = Span -> QualIdent -> ([Span], TypeExpr) -> Constraint
mkConstraint (Span -> QualIdent -> ([Span], TypeExpr) -> Constraint)
-> Parser a Token Span
-> Parser a Token (QualIdent -> ([Span], TypeExpr) -> Constraint)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (QualIdent -> ([Span], TypeExpr) -> Constraint)
-> Parser a Token QualIdent
-> Parser a Token (([Span], TypeExpr) -> Constraint)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycls Parser a Token (([Span], TypeExpr) -> Constraint)
-> Parser a Token ([Span], TypeExpr) -> Parser a Token Constraint
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([Span], TypeExpr)
forall a. Parser a Token ([Span], TypeExpr)
conType
  where varType :: Parser a Token TypeExpr
varType = Span -> Ident -> TypeExpr
mkVariableType (Span -> Ident -> TypeExpr)
-> Parser a Token Span -> Parser a Token (Ident -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Ident -> TypeExpr)
-> Parser a Token Ident -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident
forall a. Parser a Token Ident
clsvar
        conType :: Parser a Token ([Span], TypeExpr)
conType = (TypeExpr -> ([Span], TypeExpr))
-> Parser a Token TypeExpr -> Parser a Token ([Span], TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((,) []) Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
varType
               Parser a Token ([Span], TypeExpr)
-> Parser a Token ([Span], TypeExpr)
-> Parser a Token ([Span], TypeExpr)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (TypeExpr, Span, Span) -> ([Span], TypeExpr)
forall b a. (b, a, a) -> ([a], b)
mk ((TypeExpr, Span, Span) -> ([Span], TypeExpr))
-> Parser a Token (TypeExpr, Span, Span)
-> Parser a Token ([Span], TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token TypeExpr -> Parser a Token (TypeExpr, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp
                            ((TypeExpr -> TypeExpr -> TypeExpr)
-> TypeExpr -> [TypeExpr] -> TypeExpr
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl TypeExpr -> TypeExpr -> TypeExpr
mkApplyType (TypeExpr -> [TypeExpr] -> TypeExpr)
-> Parser a Token TypeExpr
-> Parser a Token ([TypeExpr] -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
varType Parser a Token ([TypeExpr] -> TypeExpr)
-> Parser a Token [TypeExpr] -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr -> Parser a Token [TypeExpr]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2)
        mkConstraint :: Span -> QualIdent -> ([Span], TypeExpr) -> Constraint
mkConstraint sp :: Span
sp qtc :: QualIdent
qtc (ss :: [Span]
ss, ty :: TypeExpr
ty) = Constraint -> Constraint
forall a. HasSpanInfo a => a -> a
updateEndPos (Constraint -> Constraint) -> Constraint -> Constraint
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> QualIdent -> TypeExpr -> Constraint
Constraint (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span]
ss) QualIdent
qtc TypeExpr
ty
        mkVariableType :: Span -> Ident -> TypeExpr
mkVariableType sp :: Span
sp = SpanInfo -> Ident -> TypeExpr
VariableType (Span -> SpanInfo
fromSrcSpan Span
sp)
        mkApplyType :: TypeExpr -> TypeExpr -> TypeExpr
mkApplyType t1 :: TypeExpr
t1 t2 :: TypeExpr
t2 =
          SpanInfo -> TypeExpr -> TypeExpr -> TypeExpr
ApplyType (Span -> SpanInfo
fromSrcSpan (Span -> Span -> Span
combineSpans (TypeExpr -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan TypeExpr
t1)
                                               (TypeExpr -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan TypeExpr
t2)))
                    TypeExpr
t1 TypeExpr
t2
        mk :: (b, a, a) -> ([a], b)
mk (a :: b
a, sp1 :: a
sp1, sp2 :: a
sp2) = ([a
sp1, a
sp2], b
a)

-- ---------------------------------------------------------------------------
-- Kinds
-- ---------------------------------------------------------------------------

withKind :: Parser a Token b -> Parser a Token (b, Maybe KindExpr)
withKind :: Parser a Token b -> Parser a Token (b, Maybe KindExpr)
withKind p :: Parser a Token b
p = b -> (b, Maybe KindExpr)
forall a a. a -> (a, Maybe a)
implicitKind (b -> (b, Maybe KindExpr))
-> Parser a Token b -> Parser a Token (b, Maybe KindExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token b
p
        Parser a Token (b, Maybe KindExpr)
-> Parser a Token (b, Maybe KindExpr)
-> Parser a Token (b, Maybe KindExpr)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> Parser a Token (b, Maybe KindExpr)
-> Parser a Token (b, Maybe KindExpr)
forall a b. Parser a Token b -> Parser a Token b
parens (b -> KindExpr -> (b, Maybe KindExpr)
forall a a. a -> a -> (a, Maybe a)
explicitKind (b -> KindExpr -> (b, Maybe KindExpr))
-> Parser a Token b
-> Parser a Token (KindExpr -> (b, Maybe KindExpr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token b
p Parser a Token (KindExpr -> (b, Maybe KindExpr))
-> Parser a Token Attributes
-> Parser a Token (KindExpr -> (b, Maybe KindExpr))
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
DoubleColon Parser a Token (KindExpr -> (b, Maybe KindExpr))
-> Parser a Token KindExpr -> Parser a Token (b, Maybe KindExpr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token KindExpr
forall a. Parser a Token KindExpr
kind0)
  where implicitKind :: a -> (a, Maybe a)
implicitKind x :: a
x   = (a
x, Maybe a
forall a. Maybe a
Nothing)
        explicitKind :: a -> a -> (a, Maybe a)
explicitKind x :: a
x k :: a
k = (a
x, a -> Maybe a
forall a. a -> Maybe a
Just a
k)

-- kind0 ::= kind1 ['->' kind0]
kind0 :: Parser a Token KindExpr
kind0 :: Parser a Token KindExpr
kind0 = Parser a Token KindExpr
forall a. Parser a Token KindExpr
kind1 Parser a Token KindExpr
-> Parser a Token (KindExpr -> KindExpr -> KindExpr)
-> Parser a Token KindExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s (b -> b -> b) -> Parser a s b
`chainr1` (KindExpr -> KindExpr -> KindExpr
ArrowKind (KindExpr -> KindExpr -> KindExpr)
-> Parser a Token Attributes
-> Parser a Token (KindExpr -> KindExpr -> KindExpr)
forall s a b c. Symbol s => a -> Parser b s c -> Parser b s a
<$-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
RightArrow)

-- kind1 ::= * | '(' kind0 ')'
kind1 :: Parser a Token KindExpr
kind1 :: Parser a Token KindExpr
kind1 = KindExpr
Star KindExpr -> Parser a Token Attributes -> Parser a Token KindExpr
forall s a b c. Symbol s => a -> Parser b s c -> Parser b s a
<$-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
SymStar
    Parser a Token KindExpr
-> Parser a Token KindExpr -> Parser a Token KindExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token KindExpr -> Parser a Token KindExpr
forall a b. Parser a Token b -> Parser a Token b
parens Parser a Token KindExpr
forall a. Parser a Token KindExpr
kind0

-- ---------------------------------------------------------------------------
-- Types
-- ---------------------------------------------------------------------------

-- qualType ::= [context '=>']  type0
qualType :: Parser a Token QualTypeExpr
qualType :: Parser a Token QualTypeExpr
qualType = Span -> (Context, [Span], TypeExpr) -> QualTypeExpr
mkQualTypeExpr (Span -> (Context, [Span], TypeExpr) -> QualTypeExpr)
-> Parser a Token Span
-> Parser a Token ((Context, [Span], TypeExpr) -> QualTypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token ((Context, [Span], TypeExpr) -> QualTypeExpr)
-> Parser a Token (Context, [Span], TypeExpr)
-> Parser a Token QualTypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Context -> [Span] -> TypeExpr -> (Context, [Span], TypeExpr))
-> Parser a Token TypeExpr
-> Parser a Token (Context, [Span], TypeExpr)
forall a b c.
(Context -> [Span] -> a -> b)
-> Parser c Token a -> Parser c Token b
optContext (,,) Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0
  where mkQualTypeExpr :: Span -> (Context, [Span], TypeExpr) -> QualTypeExpr
mkQualTypeExpr sp :: Span
sp (cx :: Context
cx, ss :: [Span]
ss, ty :: TypeExpr
ty) = QualTypeExpr -> QualTypeExpr
forall a. HasSpanInfo a => a -> a
updateEndPos (QualTypeExpr -> QualTypeExpr) -> QualTypeExpr -> QualTypeExpr
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Context -> TypeExpr -> QualTypeExpr
QualTypeExpr (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span]
ss) Context
cx TypeExpr
ty

-- type0 ::= type1 ['->' type0]
type0 :: Parser a Token TypeExpr
type0 :: Parser a Token TypeExpr
type0 = Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type1 Parser a Token TypeExpr
-> Parser a Token (TypeExpr -> TypeExpr -> TypeExpr)
-> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s (b -> b -> b) -> Parser a s b
`chainr1` (Span -> TypeExpr -> TypeExpr -> TypeExpr
mkArrowType (Span -> TypeExpr -> TypeExpr -> TypeExpr)
-> Parser a Token Span
-> Parser a Token (TypeExpr -> TypeExpr -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightArrow)
  where mkArrowType :: Span -> TypeExpr -> TypeExpr -> TypeExpr
mkArrowType sp :: Span
sp ty1 :: TypeExpr
ty1 ty2 :: TypeExpr
ty2 = TypeExpr -> TypeExpr
forall a. HasSpanInfo a => a -> a
updateEndPos (TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> TypeExpr -> TypeExpr -> TypeExpr
ArrowType (Span -> [Span] -> SpanInfo
spanInfo (TypeExpr -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan TypeExpr
ty1) [Span
sp]) TypeExpr
ty1 TypeExpr
ty2

-- type1 ::= [type1] type2
type1 :: Parser a Token TypeExpr
type1 :: Parser a Token TypeExpr
type1 = (TypeExpr -> TypeExpr -> TypeExpr) -> [TypeExpr] -> TypeExpr
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 TypeExpr -> TypeExpr -> TypeExpr
mkApplyType ([TypeExpr] -> TypeExpr)
-> Parser a Token [TypeExpr] -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token TypeExpr -> Parser a Token [TypeExpr]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type2
  where mkApplyType :: TypeExpr -> TypeExpr -> TypeExpr
mkApplyType ty1 :: TypeExpr
ty1 ty2 :: TypeExpr
ty2 = TypeExpr -> TypeExpr
forall a. HasSpanInfo a => a -> a
updateEndPos (TypeExpr -> TypeExpr) -> TypeExpr -> TypeExpr
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> TypeExpr -> TypeExpr -> TypeExpr
ApplyType (Span -> SpanInfo
fromSrcSpan (TypeExpr -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan TypeExpr
ty1)) TypeExpr
ty1 TypeExpr
ty2

-- type2 ::= anonType | identType | parenType | bracketType
type2 :: Parser a Token TypeExpr
type2 :: Parser a Token TypeExpr
type2 = Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
anonType Parser a Token TypeExpr
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
identType Parser a Token TypeExpr
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
parenType Parser a Token TypeExpr
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
bracketType

-- anonType ::= '_'
anonType :: Parser a Token TypeExpr
anonType :: Parser a Token TypeExpr
anonType = Span -> Ident -> TypeExpr
mkVariableType (Span -> Ident -> TypeExpr)
-> Parser a Token Span -> Parser a Token (Ident -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Ident -> TypeExpr)
-> Parser a Token Ident -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident
forall a. Parser a Token Ident
anonIdent
  where mkVariableType :: Span -> Ident -> TypeExpr
mkVariableType sp :: Span
sp = SpanInfo -> Ident -> TypeExpr
VariableType (Span -> SpanInfo
fromSrcSpan Span
sp)

-- identType ::= <identifier>
identType :: Parser a Token TypeExpr
identType :: Parser a Token TypeExpr
identType =  Span -> Ident -> TypeExpr
mkVariableType    (Span -> Ident -> TypeExpr)
-> Parser a Token Span -> Parser a Token (Ident -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Ident -> TypeExpr)
-> Parser a Token Ident -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident
forall a. Parser a Token Ident
tyvar
         Parser a Token TypeExpr
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Span -> QualIdent -> TypeExpr
mkConstructorType (Span -> QualIdent -> TypeExpr)
-> Parser a Token Span -> Parser a Token (QualIdent -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (QualIdent -> TypeExpr)
-> Parser a Token QualIdent -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qtycon Parser a Token QualIdent
-> Parser a Token Ident -> Parser a Token QualIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
tyvar
  where mkVariableType :: Span -> Ident -> TypeExpr
mkVariableType    sp :: Span
sp = SpanInfo -> Ident -> TypeExpr
VariableType    (Span -> SpanInfo
fromSrcSpan Span
sp)
        mkConstructorType :: Span -> QualIdent -> TypeExpr
mkConstructorType sp :: Span
sp = SpanInfo -> QualIdent -> TypeExpr
ConstructorType (Span -> SpanInfo
fromSrcSpan Span
sp)

-- parenType ::= '(' tupleType ')'
parenType :: Parser a Token TypeExpr
parenType :: Parser a Token TypeExpr
parenType = ((TypeExpr, Span, Span) -> TypeExpr)
-> Parser a Token (TypeExpr, Span, Span) -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TypeExpr, Span, Span) -> TypeExpr
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets (Parser a Token TypeExpr -> Parser a Token (TypeExpr, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
tupleType)

-- tupleType ::= type0                         (parenthesized type)
--            |  type0 ',' type0 { ',' type0 } (tuple type)
--            |  '->'                          (function type constructor)
--            |  ',' { ',' }                   (tuple type constructor)
--            |                                (unit type)
tupleType :: Parser a Token TypeExpr
tupleType :: Parser a Token TypeExpr
tupleType = Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0 Parser a Token TypeExpr
-> Parser a Token (TypeExpr -> TypeExpr) -> Parser a Token TypeExpr
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> ([(Span, TypeExpr)] -> TypeExpr -> TypeExpr
mkTuple ([(Span, TypeExpr)] -> TypeExpr -> TypeExpr)
-> Parser a Token [(Span, TypeExpr)]
-> Parser a Token (TypeExpr -> TypeExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Span, TypeExpr)
-> Parser a Token [(Span, TypeExpr)]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 ((,) (Span -> TypeExpr -> (Span, TypeExpr))
-> Parser a Token Span
-> Parser a Token (TypeExpr -> (Span, TypeExpr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Comma Parser a Token (TypeExpr -> (Span, TypeExpr))
-> Parser a Token TypeExpr -> Parser a Token (Span, TypeExpr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0)
                          Parser a Token (TypeExpr -> TypeExpr)
-> (TypeExpr -> TypeExpr) -> Parser a Token (TypeExpr -> TypeExpr)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> TypeExpr -> TypeExpr
ParenType SpanInfo
NoSpanInfo)
        Parser a Token TypeExpr
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightArrow Parser a Token Span
-> Parser a Token (Span -> TypeExpr) -> Parser a Token TypeExpr
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Span -> TypeExpr) -> Parser a Token (Span -> TypeExpr)
forall b a s. b -> Parser a s b
succeed (QualIdent -> Span -> TypeExpr
mkConstructorType QualIdent
qArrowId)
        Parser a Token TypeExpr
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> [Span] -> TypeExpr
mkConstructorTupleType ([Span] -> TypeExpr)
-> Parser a Token [Span] -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span -> Parser a Token [Span]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Comma)
        Parser a Token TypeExpr
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> TypeExpr -> Parser a Token TypeExpr
forall b a s. b -> Parser a s b
succeed (SpanInfo -> QualIdent -> TypeExpr
ConstructorType SpanInfo
NoSpanInfo QualIdent
qUnitId)
  where mkTuple :: [(Span, TypeExpr)] -> TypeExpr -> TypeExpr
mkTuple stys :: [(Span, TypeExpr)]
stys ty :: TypeExpr
ty = let (ss :: [Span]
ss, tys :: [TypeExpr]
tys) = [(Span, TypeExpr)] -> ([Span], [TypeExpr])
forall a b. [(a, b)] -> ([a], [b])
unzip [(Span, TypeExpr)]
stys
                          in SpanInfo -> [TypeExpr] -> TypeExpr
TupleType ([Span] -> SpanInfo
fromSrcInfoPoints [Span]
ss) (TypeExpr
ty TypeExpr -> [TypeExpr] -> [TypeExpr]
forall a. a -> [a] -> [a]
: [TypeExpr]
tys)
        mkConstructorType :: QualIdent -> Span -> TypeExpr
mkConstructorType qid :: QualIdent
qid sp :: Span
sp = SpanInfo -> QualIdent -> TypeExpr
ConstructorType ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp]) QualIdent
qid
        mkConstructorTupleType :: [Span] -> TypeExpr
mkConstructorTupleType ss :: [Span]
ss = SpanInfo -> QualIdent -> TypeExpr
ConstructorType ([Span] -> SpanInfo
fromSrcInfoPoints [Span]
ss)
                                                    (Arity -> QualIdent
qTupleId ([Span] -> Arity
forall (t :: * -> *) a. Foldable t => t a -> Arity
length [Span]
ss Arity -> Arity -> Arity
forall a. Num a => a -> a -> a
+ 1))

-- bracketType ::= '[' listType ']'
bracketType :: Parser a Token TypeExpr
bracketType :: Parser a Token TypeExpr
bracketType = ((TypeExpr, Span, Span) -> TypeExpr)
-> Parser a Token (TypeExpr, Span, Span) -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TypeExpr, Span, Span) -> TypeExpr
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets (Parser a Token TypeExpr -> Parser a Token (TypeExpr, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracketsSp Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
listType)

-- listType ::= type0 (list type)
--           |        (list type constructor)
listType :: Parser a Token TypeExpr
listType :: Parser a Token TypeExpr
listType = SpanInfo -> TypeExpr -> TypeExpr
ListType SpanInfo
NoSpanInfo (TypeExpr -> TypeExpr)
-> Parser a Token TypeExpr -> Parser a Token TypeExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token TypeExpr
forall a. Parser a Token TypeExpr
type0
             Parser a Token TypeExpr -> TypeExpr -> Parser a Token TypeExpr
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> QualIdent -> TypeExpr
ConstructorType SpanInfo
NoSpanInfo QualIdent
qListId

-- ---------------------------------------------------------------------------
-- Literals
-- ---------------------------------------------------------------------------

-- literal ::= '\'' <escaped character> '\''
--          |  <integer>
--          |  <float>
--          |  '"' <escaped string> '"'
literal :: Parser a Token Literal
literal :: Parser a Token Literal
literal = Char -> Literal
Char   (Char -> Literal) -> Parser a Token Char -> Parser a Token Literal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Char
forall a. Parser a Token Char
char
      Parser a Token Literal
-> Parser a Token Literal -> Parser a Token Literal
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Precedence -> Literal
Int    (Precedence -> Literal)
-> Parser a Token Precedence -> Parser a Token Literal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Precedence
forall a. Parser a Token Precedence
integer
      Parser a Token Literal
-> Parser a Token Literal -> Parser a Token Literal
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Double -> Literal
Float  (Double -> Literal)
-> Parser a Token Double -> Parser a Token Literal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Double
forall a. Parser a Token Double
float
      Parser a Token Literal
-> Parser a Token Literal -> Parser a Token Literal
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> FilePath -> Literal
String (FilePath -> Literal)
-> Parser a Token FilePath -> Parser a Token Literal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token FilePath
forall a. Parser a Token FilePath
string

-- ---------------------------------------------------------------------------
-- Patterns
-- ---------------------------------------------------------------------------

-- pattern0 ::= pattern1 [ gconop pattern0 ]
pattern0 :: Parser a Token (Pattern ())
pattern0 :: Parser a Token (Pattern ())
pattern0 = Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern1 Parser a Token (Pattern ())
-> Parser a Token (Pattern () -> Pattern () -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s (b -> b -> b) -> Parser a s b
`chainr1` (QualIdent -> Pattern () -> Pattern () -> Pattern ()
mkInfixPattern (QualIdent -> Pattern () -> Pattern () -> Pattern ())
-> Parser a Token QualIdent
-> Parser a Token (Pattern () -> Pattern () -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
gconop)
  where mkInfixPattern :: QualIdent -> Pattern () -> Pattern () -> Pattern ()
mkInfixPattern qid :: QualIdent
qid p1 :: Pattern ()
p1 p2 :: Pattern ()
p2 =
          SpanInfo
-> () -> Pattern () -> QualIdent -> Pattern () -> Pattern ()
forall a.
SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
InfixPattern (Span -> SpanInfo
fromSrcSpan (Span -> Span -> Span
combineSpans (Pattern () -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Pattern ()
p1)
                                                  (Pattern () -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Pattern ()
p2)))
            () Pattern ()
p1 QualIdent
qid Pattern ()
p2

-- pattern1 ::= varId
--           |  QConId { pattern2 }
--           |  '-'  Integer
--           |  '-.' Float
--           |  '(' parenPattern'
--           | pattern2
pattern1 :: Parser a Token (Pattern ())
pattern1 :: Parser a Token (Pattern ())
pattern1 = Parser a Token Ident
forall a. Parser a Token Ident
varId Parser a Token Ident
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
identPattern'            -- unqualified
        Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConId Parser a Token QualIdent
-> Parser a Token Ident -> Parser a Token QualIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
varId Parser a Token QualIdent
-> Parser a Token (QualIdent -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (QualIdent -> Pattern ())
forall a. Parser a Token (QualIdent -> Pattern ())
constrPattern -- qualified
        Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Ident -> Pattern () -> Pattern ()
forall a a. (HasSpanInfo a, HasSpanInfo a) => a -> a -> a
mkNegNum (Ident -> Pattern () -> Pattern ())
-> Parser a Token Ident
-> Parser a Token (Pattern () -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
minus Parser a Token (Pattern () -> Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
negNum
        Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftParen Parser a Token Span
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> Pattern ())
forall a. Parser a Token (Span -> Pattern ())
parenPattern'
        Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2  Parser a Token (Pattern ())
-> Parser a Token QualIdent -> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConId Parser a Token (Pattern ())
-> Parser a Token Attributes -> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Attributes
forall a. Parser a Token Attributes
leftParen
  where
  identPattern' :: Parser a Token (Ident -> Pattern ())
identPattern' =  Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
optAsRecPattern
               Parser a Token (Ident -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident -> QualIdent) -> [Pattern ()] -> Ident -> Pattern ()
forall t. (t -> QualIdent) -> [Pattern ()] -> t -> Pattern ()
mkConsPattern Ident -> QualIdent
qualify ([Pattern ()] -> Ident -> Pattern ())
-> Parser a Token [Pattern ()]
-> Parser a Token (Ident -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ()) -> Parser a Token [Pattern ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2

  constrPattern :: Parser a Token (QualIdent -> Pattern ())
constrPattern =  (QualIdent -> QualIdent) -> [Pattern ()] -> QualIdent -> Pattern ()
forall t. (t -> QualIdent) -> [Pattern ()] -> t -> Pattern ()
mkConsPattern QualIdent -> QualIdent
forall a. a -> a
id ([Pattern ()] -> QualIdent -> Pattern ())
-> Parser a Token [Pattern ()]
-> Parser a Token (QualIdent -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ()) -> Parser a Token [Pattern ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2
               Parser a Token (QualIdent -> Pattern ())
-> Parser a Token (QualIdent -> Pattern ())
-> Parser a Token (QualIdent -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (QualIdent -> Pattern ())
forall a. Parser a Token (QualIdent -> Pattern ())
optRecPattern


  parenPattern' :: Parser a Token (Span -> Pattern ())
parenPattern' =  Parser a Token Ident
forall a. Parser a Token Ident
minus Parser a Token Ident
-> Parser a Token (Ident -> Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Ident -> Span -> Pattern ())
forall a. Parser a Token (Ident -> Span -> Pattern ())
minusPattern
      Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> QualIdent -> Span -> [Pattern ()] -> Span -> Pattern ()
mkGconPattern (QualIdent -> Span -> [Pattern ()] -> Span -> Pattern ())
-> Parser a Token QualIdent
-> Parser a Token (Span -> [Pattern ()] -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
gconId Parser a Token (Span -> [Pattern ()] -> Span -> Pattern ())
-> Parser a Token Span
-> Parser a Token ([Pattern ()] -> Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen Parser a Token ([Pattern ()] -> Span -> Pattern ())
-> Parser a Token [Pattern ()]
-> Parser a Token (Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ()) -> Parser a Token [Pattern ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2
      Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Ident -> Span -> (Ident -> Pattern ()) -> Span -> Pattern ()
forall a t. HasSpanInfo a => t -> Span -> (t -> a) -> Span -> a
mkFunIdentP (Ident -> Span -> (Ident -> Pattern ()) -> Span -> Pattern ())
-> Parser a Token Ident
-> Parser
     a Token (Span -> (Ident -> Pattern ()) -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
funSym Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
minus Parser
  a Token (Span -> (Ident -> Pattern ()) -> Span -> Pattern ())
-> Parser a Token Span
-> Parser a Token ((Ident -> Pattern ()) -> Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen
                                           Parser a Token ((Ident -> Pattern ()) -> Span -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
identPattern'
      Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Pattern () -> Span -> Span -> Pattern ()
forall a. HasSpanInfo a => a -> Span -> Span -> a
mkParenTuple (Pattern () -> Span -> Span -> Pattern ())
-> Parser a Token (Pattern ())
-> Parser a Token (Span -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
parenTuplePattern Parser a Token (Pattern ())
-> Parser a Token Ident -> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
minus Parser a Token (Span -> Span -> Pattern ())
-> Parser a Token Span -> Parser a Token (Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen
  minusPattern :: Parser a Token (Ident -> Span -> Pattern ())
minusPattern = ((Ident -> Pattern ()) -> Span -> Ident -> Span -> Pattern ())
-> Span -> (Ident -> Pattern ()) -> Ident -> Span -> Pattern ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Ident -> Pattern ()) -> Span -> Ident -> Span -> Pattern ()
forall a t. HasSpanInfo a => (t -> a) -> Span -> t -> Span -> a
mkParenMinus (Span -> (Ident -> Pattern ()) -> Ident -> Span -> Pattern ())
-> Parser a Token Span
-> Parser
     a Token ((Ident -> Pattern ()) -> Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen Parser
  a Token ((Ident -> Pattern ()) -> Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
identPattern'
         Parser a Token (Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident -> Pattern ()) -> Span -> Ident -> Span -> Pattern ()
forall a t. HasSpanInfo a => (t -> a) -> Span -> t -> Span -> a
mkParenMinus ((Ident -> Pattern ()) -> Span -> Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Span -> Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
parenMinusPattern Parser a Token (Span -> Ident -> Span -> Pattern ())
-> Parser a Token Span
-> Parser a Token (Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen

  mkNegNum :: a -> a -> a
mkNegNum idt :: a
idt = Position -> a -> a
forall a. HasSpanInfo a => Position -> a -> a
setEndPosition (Span -> Position
end (a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan a
idt))
  mkParenTuple :: a -> Span -> Span -> a
mkParenTuple p :: a
p sp1 :: Span
sp1 sp2 :: Span
sp2 =
    SpanInfo -> a -> a
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo (Span -> [Span] -> SpanInfo
spanInfo (Span -> Span -> Span
combineSpans Span
sp2 Span
sp1) [Span
sp2, Span
sp1]) a
p
  mkFunIdentP :: t -> Span -> (t -> a) -> Span -> a
mkFunIdentP idt :: t
idt sp1 :: Span
sp1 f :: t -> a
f sp2 :: Span
sp2 = Span -> a -> a
forall a. HasSpanInfo a => Span -> a -> a
setSrcSpan (Span -> Span -> Span
combineSpans Span
sp2 Span
sp1) (t -> a
f t
idt)
  mkParenMinus :: (t -> a) -> Span -> t -> Span -> a
mkParenMinus f :: t -> a
f sp1 :: Span
sp1 idt :: t
idt sp2 :: Span
sp2 = Span -> a -> a
forall a. HasSpanInfo a => Span -> a -> a
setSrcSpan (Span -> Span -> Span
combineSpans Span
sp2 Span
sp1) (t -> a
f t
idt)
  mkConsPattern :: (t -> QualIdent) -> [Pattern ()] -> t -> Pattern ()
mkConsPattern f :: t -> QualIdent
f ts :: [Pattern ()]
ts c :: t
c = Pattern () -> Pattern ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Pattern () -> Pattern ()) -> Pattern () -> Pattern ()
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> () -> QualIdent -> [Pattern ()] -> Pattern ()
forall a. SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
ConstructorPattern (Span -> SpanInfo
fromSrcSpan (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan (t -> QualIdent
f t
c))) () (t -> QualIdent
f t
c) [Pattern ()]
ts
  mkGconPattern :: QualIdent -> Span -> [Pattern ()] -> Span -> Pattern ()
mkGconPattern qid :: QualIdent
qid sp1 :: Span
sp1 ps :: [Pattern ()]
ps sp2 :: Span
sp2 = Pattern () -> Pattern ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Pattern () -> Pattern ()) -> Pattern () -> Pattern ()
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> () -> QualIdent -> [Pattern ()] -> Pattern ()
forall a. SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
ConstructorPattern (Span -> [Span] -> SpanInfo
spanInfo (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
qid) [Span
sp2,Span
sp1]) () QualIdent
qid [Pattern ()]
ps

pattern2 :: Parser a Token (Pattern ())
pattern2 :: Parser a Token (Pattern ())
pattern2 =  Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
literalPattern Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
anonPattern Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
identPattern
        Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
parenPattern   Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
listPattern Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
lazyPattern

-- literalPattern ::= <integer> | <char> | <float> | <string>
literalPattern :: Parser a Token (Pattern ())
literalPattern :: Parser a Token (Pattern ())
literalPattern = (SpanInfo -> () -> Literal -> Pattern ())
-> () -> SpanInfo -> Literal -> Pattern ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip SpanInfo -> () -> Literal -> Pattern ()
forall a. SpanInfo -> a -> Literal -> Pattern a
LiteralPattern () (SpanInfo -> Literal -> Pattern ())
-> Parser a Token SpanInfo
-> Parser a Token (Literal -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Span -> SpanInfo)
-> Parser a Token Span -> Parser a Token SpanInfo
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Span -> SpanInfo
fromSrcSpan Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
                                        Parser a Token (Literal -> Pattern ())
-> Parser a Token Literal -> Parser a Token (Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Literal
forall a. Parser a Token Literal
literal

-- anonPattern ::= '_'
anonPattern :: Parser a Token (Pattern ())
anonPattern :: Parser a Token (Pattern ())
anonPattern = (SpanInfo -> () -> Ident -> Pattern ())
-> () -> SpanInfo -> Ident -> Pattern ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip SpanInfo -> () -> Ident -> Pattern ()
forall a. SpanInfo -> a -> Ident -> Pattern a
VariablePattern () (SpanInfo -> Ident -> Pattern ())
-> Parser a Token SpanInfo -> Parser a Token (Ident -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Span -> SpanInfo)
-> Parser a Token Span -> Parser a Token SpanInfo
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Span -> SpanInfo
fromSrcSpan Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition
                                      Parser a Token (Ident -> Pattern ())
-> Parser a Token Ident -> Parser a Token (Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident
forall a. Parser a Token Ident
anonIdent

-- identPattern ::= Variable [ '@' pattern2 | '{' fields '}'
--               |  qConId   [ '{' fields '}' ]
identPattern :: Parser a Token (Pattern ())
identPattern :: Parser a Token (Pattern ())
identPattern =  Parser a Token Ident
forall a. Parser a Token Ident
varId Parser a Token Ident
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
optAsRecPattern -- unqualified
            Parser a Token (Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConId Parser a Token QualIdent
-> Parser a Token Ident -> Parser a Token QualIdent
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
varId Parser a Token QualIdent
-> Parser a Token (QualIdent -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (QualIdent -> Pattern ())
forall a. Parser a Token (QualIdent -> Pattern ())
optRecPattern               -- qualified

-- TODO: document me!
parenPattern :: Parser a Token (Pattern ())
parenPattern :: Parser a Token (Pattern ())
parenPattern = Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftParen Parser a Token Span
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Span -> Pattern ())
forall a. Parser a Token (Span -> Pattern ())
parenPattern'
  where
  parenPattern' :: Parser a Token (Span -> Pattern ())
parenPattern' = Parser a Token Ident
forall a. Parser a Token Ident
minus Parser a Token Ident
-> Parser a Token (Ident -> Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Ident -> Span -> Pattern ())
forall a. Parser a Token (Ident -> Span -> Pattern ())
minusPattern
      Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> QualIdent -> Span -> Span -> Pattern ()
mkConstructorPattern (QualIdent -> Span -> Span -> Pattern ())
-> Parser a Token QualIdent
-> Parser a Token (Span -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
gconId Parser a Token (Span -> Span -> Pattern ())
-> Parser a Token Span -> Parser a Token (Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen
      Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Ident -> Span -> (Ident -> Pattern ()) -> Span -> Pattern ()
forall b. b -> Span -> (b -> Pattern ()) -> Span -> Pattern ()
mkFunAsRec (Ident -> Span -> (Ident -> Pattern ()) -> Span -> Pattern ())
-> Parser a Token Ident
-> Parser
     a Token (Span -> (Ident -> Pattern ()) -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
funSym Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
minus Parser
  a Token (Span -> (Ident -> Pattern ()) -> Span -> Pattern ())
-> Parser a Token Span
-> Parser a Token ((Ident -> Pattern ()) -> Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen
                     Parser a Token ((Ident -> Pattern ()) -> Span -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
optAsRecPattern
      Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
-> Parser a Token (Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Pattern () -> Span -> Span -> Pattern ()
forall a. HasSpanInfo a => a -> Span -> Span -> a
mkParenTuple (Pattern () -> Span -> Span -> Pattern ())
-> Parser a Token (Pattern ())
-> Parser a Token (Span -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
parenTuplePattern Parser a Token (Pattern ())
-> Parser a Token Ident -> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
minus Parser a Token (Span -> Span -> Pattern ())
-> Parser a Token Span -> Parser a Token (Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen
  minusPattern :: Parser a Token (Ident -> Span -> Pattern ())
minusPattern = Span -> (Ident -> Pattern ()) -> Ident -> Span -> Pattern ()
forall a p. HasSpanInfo a => Span -> (p -> a) -> p -> Span -> a
mkOptAsRec (Span -> (Ident -> Pattern ()) -> Ident -> Span -> Pattern ())
-> Parser a Token Span
-> Parser
     a Token ((Ident -> Pattern ()) -> Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen Parser
  a Token ((Ident -> Pattern ()) -> Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
optAsRecPattern
      Parser a Token (Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Span -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident -> Pattern ()) -> Span -> Ident -> Span -> Pattern ()
forall a t. HasSpanInfo a => (t -> a) -> Span -> t -> Span -> a
mkParen ((Ident -> Pattern ()) -> Span -> Ident -> Span -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Span -> Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Ident -> Pattern ())
forall a. Parser a Token (Ident -> Pattern ())
parenMinusPattern Parser a Token (Span -> Ident -> Span -> Pattern ())
-> Parser a Token Span
-> Parser a Token (Ident -> Span -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen

  mkConstructorPattern :: QualIdent -> Span -> Span -> Pattern ()
mkConstructorPattern qid :: QualIdent
qid sp1 :: Span
sp1 sp2 :: Span
sp2 =
    SpanInfo -> () -> QualIdent -> [Pattern ()] -> Pattern ()
forall a. SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
ConstructorPattern (Span -> SpanInfo
fromSrcSpan (Span -> Span -> Span
combineSpans Span
sp2 Span
sp1)) () QualIdent
qid []
  mkFunAsRec :: b -> Span -> (b -> Pattern ()) -> Span -> Pattern ()
mkFunAsRec = (Span -> b -> (b -> Pattern ()) -> Span -> Pattern ())
-> b -> Span -> (b -> Pattern ()) -> Span -> Pattern ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (((b -> Pattern ()) -> b -> Span -> Pattern ())
-> b -> (b -> Pattern ()) -> Span -> Pattern ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (((b -> Pattern ()) -> b -> Span -> Pattern ())
 -> b -> (b -> Pattern ()) -> Span -> Pattern ())
-> (Span -> (b -> Pattern ()) -> b -> Span -> Pattern ())
-> Span
-> b
-> (b -> Pattern ())
-> Span
-> Pattern ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Span -> (b -> Pattern ()) -> b -> Span -> Pattern ()
forall a p. HasSpanInfo a => Span -> (p -> a) -> p -> Span -> a
mkOptAsRec)
  mkParenTuple :: a -> Span -> Span -> a
mkParenTuple p :: a
p sp1 :: Span
sp1 sp2 :: Span
sp2 =
    let ss :: [Span]
ss  = a -> [Span]
forall a. HasSpanInfo a => a -> [Span]
getSrcInfoPoints a
p
        spi :: SpanInfo
spi = Span -> [Span] -> SpanInfo
spanInfo (Span -> Span -> Span
combineSpans Span
sp2 Span
sp1) (Span
sp2 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp1]))
    in SpanInfo -> a -> a
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo SpanInfo
spi a
p
  mkOptAsRec :: Span -> (p -> a) -> p -> Span -> a
mkOptAsRec sp1 :: Span
sp1 f :: p -> a
f idt :: p
idt sp2 :: Span
sp2 =
    let p :: a
p   = p -> a
f p
idt
        ss :: [Span]
ss  = a -> [Span]
forall a. HasSpanInfo a => a -> [Span]
getSrcInfoPoints a
p
        spi :: SpanInfo
spi = Span -> [Span] -> SpanInfo
spanInfo (Span -> Span -> Span
combineSpans Span
sp2 Span
sp1) ([Span
sp2, Span
sp1] [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span]
ss)
    in SpanInfo -> a -> a
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo SpanInfo
spi a
p
  mkParen :: (p -> a) -> Span -> p -> Span -> a
mkParen f :: p -> a
f sp1 :: Span
sp1 idt :: p
idt sp2 :: Span
sp2 =
    let p :: a
p   = p -> a
f p
idt
        ss :: [Span]
ss  = a -> [Span]
forall a. HasSpanInfo a => a -> [Span]
getSrcInfoPoints a
p
        spi :: SpanInfo
spi = Span -> [Span] -> SpanInfo
spanInfo (Span -> Span -> Span
combineSpans Span
sp2 Span
sp1) (Span
sp2 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp1]))
    in SpanInfo -> a -> a
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo SpanInfo
spi a
p

-- listPattern ::= '[' pattern0s ']'
-- pattern0s   ::= {- empty -}
--              |  pattern0 ',' pattern0s
listPattern :: Parser a Token (Pattern ())
listPattern :: Parser a Token (Pattern ())
listPattern = (([Pattern ()], [Span]), Span, Span) -> Pattern ()
mkListPattern ((([Pattern ()], [Span]), Span, Span) -> Pattern ())
-> Parser a Token (([Pattern ()], [Span]), Span, Span)
-> Parser a Token (Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token ([Pattern ()], [Span])
-> Parser a Token (([Pattern ()], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracketsSp (Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0 Parser a Token (Pattern ())
-> Parser a Token Attributes
-> Parser a Token ([Pattern ()], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
  where mkListPattern :: (([Pattern ()], [Span]), Span, Span) -> Pattern ()
mkListPattern ((ps :: [Pattern ()]
ps, ss :: [Span]
ss), sp1 :: Span
sp1, sp2 :: Span
sp2) = Pattern () -> Pattern ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Pattern () -> Pattern ()) -> Pattern () -> Pattern ()
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> () -> [Pattern ()] -> Pattern ()
forall a. SpanInfo -> a -> [Pattern a] -> Pattern a
ListPattern (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2]))) () [Pattern ()]
ps

-- lazyPattern ::= '~' pattern2
lazyPattern :: Parser a Token (Pattern ())
lazyPattern :: Parser a Token (Pattern ())
lazyPattern = Span -> Pattern () -> Pattern ()
forall a. Span -> Pattern a -> Pattern a
mkLazyPattern (Span -> Pattern () -> Pattern ())
-> Parser a Token Span -> Parser a Token (Pattern () -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Tilde Parser a Token (Pattern () -> Pattern ())
-> Parser a Token (Pattern ()) -> Parser a Token (Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2
  where mkLazyPattern :: Span -> Pattern a -> Pattern a
mkLazyPattern sp :: Span
sp p :: Pattern a
p = Pattern a -> Pattern a
forall a. HasSpanInfo a => a -> a
updateEndPos (Pattern a -> Pattern a) -> Pattern a -> Pattern a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Pattern a -> Pattern a
forall a. SpanInfo -> Pattern a -> Pattern a
LazyPattern (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span
sp]) Pattern a
p

-- optRecPattern ::= [ '{' fields '}' ]
optRecPattern :: Parser a Token (QualIdent -> Pattern ())
optRecPattern :: Parser a Token (QualIdent -> Pattern ())
optRecPattern = (([Field (Pattern ())], [Span]), Span, Span)
-> QualIdent -> Pattern ()
mkRecordPattern ((([Field (Pattern ())], [Span]), Span, Span)
 -> QualIdent -> Pattern ())
-> Parser a Token (([Field (Pattern ())], [Span]), Span, Span)
-> Parser a Token (QualIdent -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ())
-> Parser a Token (([Field (Pattern ())], [Span]), Span, Span)
forall a b.
Parser a Token b
-> Parser a Token (([Field b], [Span]), Span, Span)
fieldsSp Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0 Parser a Token (QualIdent -> Pattern ())
-> (QualIdent -> Pattern ())
-> Parser a Token (QualIdent -> Pattern ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` QualIdent -> Pattern ()
mkConPattern
  where
  mkRecordPattern :: (([Field (Pattern ())], [Span]), Span, Span)
-> QualIdent -> Pattern ()
mkRecordPattern ((fs :: [Field (Pattern ())]
fs, ss :: [Span]
ss), sp1 :: Span
sp1, sp2 :: Span
sp2) c :: QualIdent
c = Pattern () -> Pattern ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Pattern () -> Pattern ()) -> Pattern () -> Pattern ()
forall a b. (a -> b) -> a -> b
$
    SpanInfo -> () -> QualIdent -> [Field (Pattern ())] -> Pattern ()
forall a.
SpanInfo -> a -> QualIdent -> [Field (Pattern a)] -> Pattern a
RecordPattern (Span -> [Span] -> SpanInfo
spanInfo (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
c) (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2]))) () QualIdent
c [Field (Pattern ())]
fs
  mkConPattern :: QualIdent -> Pattern ()
mkConPattern c :: QualIdent
c = SpanInfo -> () -> QualIdent -> [Pattern ()] -> Pattern ()
forall a. SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
ConstructorPattern (Span -> SpanInfo
fromSrcSpan (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
c)) () QualIdent
c []

-- ---------------------------------------------------------------------------
-- Partial patterns used in the combinators above, but also for parsing
-- the left-hand side of a declaration.
-- ---------------------------------------------------------------------------

gconId :: Parser a Token QualIdent
gconId :: Parser a Token QualIdent
gconId = Parser a Token QualIdent
forall a. Parser a Token QualIdent
colon Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token QualIdent
forall a. Parser a Token QualIdent
tupleCommas

negNum :: Parser a Token (Pattern ())
negNum :: Parser a Token (Pattern ())
negNum = Span -> Literal -> Pattern ()
mkNegativePattern (Span -> Literal -> Pattern ())
-> Parser a Token Span -> Parser a Token (Literal -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Literal -> Pattern ())
-> Parser a Token Literal -> Parser a Token (Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
                             (Precedence -> Literal
Int (Precedence -> Literal)
-> Parser a Token Precedence -> Parser a Token Literal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Precedence
forall a. Parser a Token Precedence
integer Parser a Token Literal
-> Parser a Token Literal -> Parser a Token Literal
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Double -> Literal
Float (Double -> Literal)
-> Parser a Token Double -> Parser a Token Literal
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Double
forall a. Parser a Token Double
float)
  where mkNegativePattern :: Span -> Literal -> Pattern ()
mkNegativePattern sp :: Span
sp = SpanInfo -> () -> Literal -> Pattern ()
forall a. SpanInfo -> a -> Literal -> Pattern a
NegativePattern (Span -> SpanInfo
fromSrcSpan Span
sp) ()

optAsRecPattern :: Parser a Token (Ident -> Pattern ())
optAsRecPattern :: Parser a Token (Ident -> Pattern ())
optAsRecPattern =  Span -> Pattern () -> Ident -> Pattern ()
forall a. Span -> Pattern a -> Ident -> Pattern a
mkAsPattern     (Span -> Pattern () -> Ident -> Pattern ())
-> Parser a Token Span
-> Parser a Token (Pattern () -> Ident -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
At Parser a Token (Pattern () -> Ident -> Pattern ())
-> Parser a Token (Pattern ())
-> Parser a Token (Ident -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2
               Parser a Token (Ident -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (([Field (Pattern ())], [Span]), Span, Span) -> Ident -> Pattern ()
mkRecordPattern ((([Field (Pattern ())], [Span]), Span, Span)
 -> Ident -> Pattern ())
-> Parser a Token (([Field (Pattern ())], [Span]), Span, Span)
-> Parser a Token (Ident -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ())
-> Parser a Token (([Field (Pattern ())], [Span]), Span, Span)
forall a b.
Parser a Token b
-> Parser a Token (([Field b], [Span]), Span, Span)
fieldsSp Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0
               Parser a Token (Ident -> Pattern ())
-> (Ident -> Pattern ()) -> Parser a Token (Ident -> Pattern ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` Ident -> Pattern ()
mkVariablePattern
  where mkRecordPattern :: (([Field (Pattern ())], [Span]), Span, Span) -> Ident -> Pattern ()
mkRecordPattern ((fs :: [Field (Pattern ())]
fs,ss :: [Span]
ss),sp1 :: Span
sp1,sp2 :: Span
sp2) v :: Ident
v =
          let s :: Position
s = Ident -> Position
forall a. HasPosition a => a -> Position
getPosition Ident
v
              e :: Position
e = Span -> Position
end Span
sp2
              f :: FilePath
f = Position -> FilePath
file Position
s
              spi :: SpanInfo
spi = Span -> [Span] -> SpanInfo
spanInfo (FilePath -> Position -> Position -> Span
Span FilePath
f Position
s Position
e) (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2]))
          in Pattern () -> Pattern ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Pattern () -> Pattern ()) -> Pattern () -> Pattern ()
forall a b. (a -> b) -> a -> b
$ SpanInfo -> () -> QualIdent -> [Field (Pattern ())] -> Pattern ()
forall a.
SpanInfo -> a -> QualIdent -> [Field (Pattern a)] -> Pattern a
RecordPattern SpanInfo
spi () (Ident -> QualIdent
qualify Ident
v) [Field (Pattern ())]
fs
        mkAsPattern :: Span -> Pattern a -> Ident -> Pattern a
mkAsPattern sp :: Span
sp p :: Pattern a
p idt :: Ident
idt =
          SpanInfo -> Ident -> Pattern a -> Pattern a
forall a. SpanInfo -> Ident -> Pattern a -> Pattern a
AsPattern (Span -> [Span] -> SpanInfo
spanInfo (Ident -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Ident
idt) [Span
sp]) Ident
idt Pattern a
p
        mkVariablePattern :: Ident -> Pattern ()
mkVariablePattern idt :: Ident
idt =
          SpanInfo -> () -> Ident -> Pattern ()
forall a. SpanInfo -> a -> Ident -> Pattern a
VariablePattern (Span -> SpanInfo
fromSrcSpan (Ident -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Ident
idt)) () Ident
idt

optInfixPattern :: Parser a Token (Pattern () -> Pattern ())
optInfixPattern :: Parser a Token (Pattern () -> Pattern ())
optInfixPattern = QualIdent -> Pattern () -> Pattern () -> Pattern ()
mkInfixPat (QualIdent -> Pattern () -> Pattern () -> Pattern ())
-> Parser a Token QualIdent
-> Parser a Token (Pattern () -> Pattern () -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
gconop Parser a Token (Pattern () -> Pattern () -> Pattern ())
-> Parser a Token (Pattern ())
-> Parser a Token (Pattern () -> Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0
            Parser a Token (Pattern () -> Pattern ())
-> (Pattern () -> Pattern ())
-> Parser a Token (Pattern () -> Pattern ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` Pattern () -> Pattern ()
forall a. a -> a
id
  where mkInfixPat :: QualIdent -> Pattern () -> Pattern () -> Pattern ()
mkInfixPat op :: QualIdent
op t2 :: Pattern ()
t2 t1 :: Pattern ()
t1 =
          let s :: Position
s = Pattern () -> Position
forall a. HasPosition a => a -> Position
getPosition Pattern ()
t1
              e :: Position
e = Pattern () -> Position
forall a. HasSpanInfo a => a -> Position
getSrcSpanEnd Pattern ()
t2
              f :: FilePath
f = Position -> FilePath
file Position
s
          in SpanInfo
-> () -> Pattern () -> QualIdent -> Pattern () -> Pattern ()
forall a.
SpanInfo -> a -> Pattern a -> QualIdent -> Pattern a -> Pattern a
InfixPattern (Span -> SpanInfo
fromSrcSpan (FilePath -> Position -> Position -> Span
Span FilePath
f Position
s Position
e)) () Pattern ()
t1 QualIdent
op Pattern ()
t2

optTuplePattern :: Parser a Token (Pattern () -> Pattern ())
optTuplePattern :: Parser a Token (Pattern () -> Pattern ())
optTuplePattern = [(Span, Pattern ())] -> Pattern () -> Pattern ()
forall a. [(Span, Pattern a)] -> Pattern a -> Pattern a
mkTuple ([(Span, Pattern ())] -> Pattern () -> Pattern ())
-> Parser a Token [(Span, Pattern ())]
-> Parser a Token (Pattern () -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Span, Pattern ())
-> Parser a Token [(Span, Pattern ())]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 ((,) (Span -> Pattern () -> (Span, Pattern ()))
-> Parser a Token Span
-> Parser a Token (Pattern () -> (Span, Pattern ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Comma Parser a Token (Pattern () -> (Span, Pattern ()))
-> Parser a Token (Pattern ()) -> Parser a Token (Span, Pattern ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0)
            Parser a Token (Pattern () -> Pattern ())
-> (Pattern () -> Pattern ())
-> Parser a Token (Pattern () -> Pattern ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> Pattern () -> Pattern ()
forall a. SpanInfo -> Pattern a -> Pattern a
ParenPattern SpanInfo
NoSpanInfo
  where mkTuple :: [(Span, Pattern a)] -> Pattern a -> Pattern a
mkTuple ts :: [(Span, Pattern a)]
ts t :: Pattern a
t = let (ss :: [Span]
ss, ps :: [Pattern a]
ps) = [(Span, Pattern a)] -> ([Span], [Pattern a])
forall a b. [(a, b)] -> ([a], [b])
unzip [(Span, Pattern a)]
ts
                       in SpanInfo -> [Pattern a] -> Pattern a
forall a. SpanInfo -> [Pattern a] -> Pattern a
TuplePattern ([Span] -> SpanInfo
fromSrcInfoPoints [Span]
ss) (Pattern a
tPattern a -> [Pattern a] -> [Pattern a]
forall a. a -> [a] -> [a]
:[Pattern a]
ps)

parenMinusPattern :: Parser a Token (Ident -> Pattern ())
parenMinusPattern :: Parser a Token (Ident -> Pattern ())
parenMinusPattern = Pattern () -> Ident -> Pattern ()
forall a a. (HasSpanInfo a, HasSpanInfo a) => a -> a -> a
mkNeg (Pattern () -> Ident -> Pattern ())
-> Parser a Token (Pattern ())
-> Parser a Token (Ident -> Pattern ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
negNum Parser a Token (Ident -> Pattern ())
-> Parser a Token (Pattern () -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
forall s a b c d.
Symbol s =>
Parser a s (b -> c) -> Parser a s (c -> d) -> Parser a s (b -> d)
<.> Parser a Token (Pattern () -> Pattern ())
forall a. Parser a Token (Pattern () -> Pattern ())
optInfixPattern Parser a Token (Ident -> Pattern ())
-> Parser a Token (Pattern () -> Pattern ())
-> Parser a Token (Ident -> Pattern ())
forall s a b c d.
Symbol s =>
Parser a s (b -> c) -> Parser a s (c -> d) -> Parser a s (b -> d)
<.> Parser a Token (Pattern () -> Pattern ())
forall a. Parser a Token (Pattern () -> Pattern ())
optTuplePattern
  where mkNeg :: a -> a -> a
mkNeg neg :: a
neg idt :: a
idt = Position -> a -> a
forall a. HasSpanInfo a => Position -> a -> a
setEndPosition (Span -> Position
end (a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan a
idt)) a
neg

parenTuplePattern :: Parser a Token (Pattern ())
parenTuplePattern :: Parser a Token (Pattern ())
parenTuplePattern = Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0 Parser a Token (Pattern ())
-> Parser a Token (Pattern () -> Pattern ())
-> Parser a Token (Pattern ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Pattern () -> Pattern ())
forall a. Parser a Token (Pattern () -> Pattern ())
optTuplePattern
              Parser a Token (Pattern ())
-> Pattern () -> Parser a Token (Pattern ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> () -> QualIdent -> [Pattern ()] -> Pattern ()
forall a. SpanInfo -> a -> QualIdent -> [Pattern a] -> Pattern a
ConstructorPattern SpanInfo
NoSpanInfo () QualIdent
qUnitId []

-- ---------------------------------------------------------------------------
-- Expressions
-- ---------------------------------------------------------------------------

-- condExpr ::= '|' expr0 eq expr
--
-- Note: The guard is an `expr0` instead of `expr` since conditional expressions
-- may also occur in case expressions, and an expression like
-- @
-- case a of { _ -> True :: Bool -> a }
-- @
-- can not be parsed with a limited parser lookahead.
condExpr :: Parser a Token b -> Parser a Token (CondExpr ())
condExpr :: Parser a Token b -> Parser a Token (CondExpr ())
condExpr eq :: Parser a Token b
eq = Span -> Expression () -> Span -> Expression () -> CondExpr ()
forall a.
Span -> Expression a -> Span -> Expression a -> CondExpr a
mkCondExpr (Span -> Expression () -> Span -> Expression () -> CondExpr ())
-> Parser a Token Span
-> Parser
     a Token (Expression () -> Span -> Expression () -> CondExpr ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser
  a Token (Expression () -> Span -> Expression () -> CondExpr ())
-> Parser a Token Attributes
-> Parser
     a Token (Expression () -> Span -> Expression () -> CondExpr ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
bar Parser
  a Token (Expression () -> Span -> Expression () -> CondExpr ())
-> Parser a Token (Expression ())
-> Parser a Token (Span -> Expression () -> CondExpr ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr0
                         Parser a Token (Span -> Expression () -> CondExpr ())
-> Parser a Token Span
-> Parser a Token (Expression () -> CondExpr ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Expression () -> CondExpr ())
-> Parser a Token b
-> Parser a Token (Expression () -> CondExpr ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token b
eq  Parser a Token (Expression () -> CondExpr ())
-> Parser a Token (Expression ()) -> Parser a Token (CondExpr ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
  where mkCondExpr :: Span -> Expression a -> Span -> Expression a -> CondExpr a
mkCondExpr sp1 :: Span
sp1 e1 :: Expression a
e1 sp2 :: Span
sp2 e2 :: Expression a
e2 = CondExpr a -> CondExpr a
forall a. HasSpanInfo a => a -> a
updateEndPos (CondExpr a -> CondExpr a) -> CondExpr a -> CondExpr a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Expression a -> Expression a -> CondExpr a
forall a. SpanInfo -> Expression a -> Expression a -> CondExpr a
CondExpr (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2]) Expression a
e1 Expression a
e2

-- expr ::= expr0 [ '::' type0 ]
expr :: Parser a Token (Expression ())
expr :: Parser a Token (Expression ())
expr = Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr0 Parser a Token (Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s (b -> b) -> Parser a s b
<??> (Span -> QualTypeExpr -> Expression () -> Expression ()
forall a. Span -> QualTypeExpr -> Expression a -> Expression a
mkTyped (Span -> QualTypeExpr -> Expression () -> Expression ())
-> Parser a Token Span
-> Parser a Token (QualTypeExpr -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DoubleColon Parser a Token (QualTypeExpr -> Expression () -> Expression ())
-> Parser a Token QualTypeExpr
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualTypeExpr
forall a. Parser a Token QualTypeExpr
qualType)
  where mkTyped :: Span -> QualTypeExpr -> Expression a -> Expression a
mkTyped sp :: Span
sp qty :: QualTypeExpr
qty e :: Expression a
e = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$ Span -> Expression a -> Expression a
forall a. HasSpanInfo a => Span -> a -> a
setSrcSpan (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e) (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Expression a -> QualTypeExpr -> Expression a
forall a. SpanInfo -> Expression a -> QualTypeExpr -> Expression a
Typed ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp]) Expression a
e QualTypeExpr
qty

-- expr0 ::= expr1 { infixOp expr1 }
expr0 :: Parser a Token (Expression ())
expr0 :: Parser a Token (Expression ())
expr0 = Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr1 Parser a Token (Expression ())
-> Parser a Token (Expression () -> Expression () -> Expression ())
-> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s (b -> b -> b) -> Parser a s b
`chainr1` (InfixOp () -> Expression () -> Expression () -> Expression ()
forall a. InfixOp a -> Expression a -> Expression a -> Expression a
mkInfixApply (InfixOp () -> Expression () -> Expression () -> Expression ())
-> Parser a Token (InfixOp ())
-> Parser a Token (Expression () -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (InfixOp ())
forall a. Parser a Token (InfixOp ())
infixOp)
  where mkInfixApply :: InfixOp a -> Expression a -> Expression a -> Expression a
mkInfixApply op :: InfixOp a
op e1 :: Expression a
e1 e2 :: Expression a
e2 = SpanInfo
-> Expression a -> InfixOp a -> Expression a -> Expression a
forall a.
SpanInfo
-> Expression a -> InfixOp a -> Expression a -> Expression a
InfixApply
          (Span -> SpanInfo
fromSrcSpan (Span -> Span -> Span
combineSpans (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e1) (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e2))) Expression a
e1 InfixOp a
op Expression a
e2

-- expr1 ::= - expr2 | -. expr2 | expr2
expr1 :: Parser a Token (Expression ())
expr1 :: Parser a Token (Expression ())
expr1 =  Ident -> Expression () -> Expression ()
forall a a. HasPosition a => a -> Expression a -> Expression a
mkUnaryMinus (Ident -> Expression () -> Expression ())
-> Parser a Token Ident
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
minus Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr2
     Parser a Token (Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr2
  where mkUnaryMinus :: a -> Expression a -> Expression a
mkUnaryMinus idt :: a
idt ex :: Expression a
ex =
          let p :: Position
p = a -> Position
forall a. HasPosition a => a -> Position
getPosition a
idt
              e :: Position
e = Expression a -> Position
forall a. HasSpanInfo a => a -> Position
getSrcSpanEnd Expression a
ex
              f :: FilePath
f = Position -> FilePath
file Position
p
          in SpanInfo -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a
UnaryMinus (Span -> [Span] -> SpanInfo
spanInfo (FilePath -> Position -> Position -> Span
Span FilePath
f Position
p Position
e) [FilePath -> Position -> Position -> Span
Span FilePath
f Position
p (Position -> Arity -> Position
incr Position
p 1)]) Expression a
ex

-- expr2 ::= lambdaExpr | letExpr | doExpr | ifExpr | caseExpr | expr3
expr2 :: Parser a Token (Expression ())
expr2 :: Parser a Token (Expression ())
expr2 = [Parser a Token (Expression ())] -> Parser a Token (Expression ())
forall s a b. Symbol s => [Parser a s b] -> Parser a s b
choice [ Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
lambdaExpr, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
letExpr, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
doExpr, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
ifExpr, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
caseExpr
               , (Expression () -> Expression () -> Expression ())
-> [Expression ()] -> Expression ()
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 Expression () -> Expression () -> Expression ()
forall a. Expression a -> Expression a -> Expression a
mkApply ([Expression ()] -> Expression ())
-> Parser a Token [Expression ()] -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Expression ()) -> Parser a Token [Expression ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr3
               ]
  where mkApply :: Expression a -> Expression a -> Expression a
mkApply e1 :: Expression a
e1 e2 :: Expression a
e2 = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Expression a -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a -> Expression a
Apply (Span -> SpanInfo
fromSrcSpan (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e1)) Expression a
e1 Expression a
e2

expr3 :: Parser a Token (Expression ())
expr3 :: Parser a Token (Expression ())
expr3 = (Expression ()
 -> (([Field (Expression ())], [Span]), Span, Span)
 -> Expression ())
-> Expression ()
-> [(([Field (Expression ())], [Span]), Span, Span)]
-> Expression ()
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Expression ()
-> (([Field (Expression ())], [Span]), Span, Span) -> Expression ()
forall a.
Expression a
-> (([Field (Expression a)], [Span]), Span, Span) -> Expression a
mkRecordUpdate (Expression ()
 -> [(([Field (Expression ())], [Span]), Span, Span)]
 -> Expression ())
-> Parser a Token (Expression ())
-> Parser
     a
     Token
     ([(([Field (Expression ())], [Span]), Span, Span)]
      -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr4 Parser
  a
  Token
  ([(([Field (Expression ())], [Span]), Span, Span)]
   -> Expression ())
-> Parser a Token [(([Field (Expression ())], [Span]), Span, Span)]
-> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (([Field (Expression ())], [Span]), Span, Span)
-> Parser a Token [(([Field (Expression ())], [Span]), Span, Span)]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many Parser a Token (([Field (Expression ())], [Span]), Span, Span)
forall a.
Parser a Token (([Field (Expression ())], [Span]), Span, Span)
recUpdate
  where recUpdate :: Parser a Token (([Field (Expression ())], [Span]), Span, Span)
recUpdate = Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOff Parser a Token Any
-> Parser a Token (([Field (Expression ())], [Span]), Span, Span)
-> Parser a Token (([Field (Expression ())], [Span]), Span, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ([Field (Expression ())], [Span])
-> Parser a Token (([Field (Expression ())], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp (Parser a Token (Expression ())
-> Parser a Token (Field (Expression ()))
forall a b. Parser a Token b -> Parser a Token (Field b)
field Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr0 Parser a Token (Field (Expression ()))
-> Parser a Token Attributes
-> Parser a Token ([Field (Expression ())], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)
        mkRecordUpdate :: Expression a
-> (([Field (Expression a)], [Span]), Span, Span) -> Expression a
mkRecordUpdate e :: Expression a
e ((fs :: [Field (Expression a)]
fs,ss :: [Span]
ss), sp1 :: Span
sp1, sp2 :: Span
sp2) = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
          [Span] -> Expression a -> Expression a
forall a. HasSpanInfo a => [Span] -> a -> a
setSrcInfoPoints (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2])) (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
          SpanInfo -> Expression a -> [Field (Expression a)] -> Expression a
forall a.
SpanInfo -> Expression a -> [Field (Expression a)] -> Expression a
RecordUpdate (Span -> SpanInfo
fromSrcSpan (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e)) Expression a
e [Field (Expression a)]
fs

expr4 :: Parser a Token (Expression ())
expr4 :: Parser a Token (Expression ())
expr4 = [Parser a Token (Expression ())] -> Parser a Token (Expression ())
forall s a b. Symbol s => [Parser a s b] -> Parser a s b
choice
  [Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
constant, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
anonFreeVariable, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
variable, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
parenExpr, Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
listExpr]

constant :: Parser a Token (Expression ())
constant :: Parser a Token (Expression ())
constant = Span -> Literal -> Expression ()
mkLiteral (Span -> Literal -> Expression ())
-> Parser a Token Span -> Parser a Token (Literal -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Literal -> Expression ())
-> Parser a Token Literal -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Literal
forall a. Parser a Token Literal
literal
  where mkLiteral :: Span -> Literal -> Expression ()
mkLiteral sp :: Span
sp = SpanInfo -> () -> Literal -> Expression ()
forall a. SpanInfo -> a -> Literal -> Expression a
Literal (Span -> SpanInfo
fromSrcSpan Span
sp) ()

anonFreeVariable :: Parser a Token (Expression ())
anonFreeVariable :: Parser a Token (Expression ())
anonFreeVariable =  (\ p :: Position
p v :: Ident
v -> QualIdent -> Expression ()
mkVariable (QualIdent -> Expression ()) -> QualIdent -> Expression ()
forall a b. (a -> b) -> a -> b
$ Ident -> QualIdent
qualify (Ident -> QualIdent) -> Ident -> QualIdent
forall a b. (a -> b) -> a -> b
$ Position -> Ident -> Ident
addPositionIdent Position
p Ident
v)
                (Position -> Ident -> Expression ())
-> Parser a Token Position
-> Parser a Token (Ident -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Position
forall a s. Parser a s Position
position Parser a Token (Ident -> Expression ())
-> Parser a Token Ident -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Ident
forall a. Parser a Token Ident
anonIdent
  where mkVariable :: QualIdent -> Expression ()
mkVariable qid :: QualIdent
qid = SpanInfo -> () -> QualIdent -> Expression ()
forall a. SpanInfo -> a -> QualIdent -> Expression a
Variable (Span -> SpanInfo
fromSrcSpan (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
qid)) () QualIdent
qid

variable :: Parser a Token (Expression ())
variable :: Parser a Token (Expression ())
variable = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qFunId Parser a Token QualIdent
-> Parser a Token (QualIdent -> Expression ())
-> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (QualIdent -> Expression ())
forall a. Parser a Token (QualIdent -> Expression ())
optRecord
  where optRecord :: Parser a Token (QualIdent -> Expression ())
optRecord = (([Field (Expression ())], [Span]), Span, Span)
-> QualIdent -> Expression ()
mkRecord ((([Field (Expression ())], [Span]), Span, Span)
 -> QualIdent -> Expression ())
-> Parser a Token (([Field (Expression ())], [Span]), Span, Span)
-> Parser a Token (QualIdent -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Expression ())
-> Parser a Token (([Field (Expression ())], [Span]), Span, Span)
forall a b.
Parser a Token b
-> Parser a Token (([Field b], [Span]), Span, Span)
fieldsSp Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr0 Parser a Token (QualIdent -> Expression ())
-> (QualIdent -> Expression ())
-> Parser a Token (QualIdent -> Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` QualIdent -> Expression ()
mkVariable
        mkRecord :: (([Field (Expression ())], [Span]), Span, Span)
-> QualIdent -> Expression ()
mkRecord ((fs :: [Field (Expression ())]
fs,ss :: [Span]
ss), sp1 :: Span
sp1, sp2 :: Span
sp2) qid :: QualIdent
qid =
          let spi :: SpanInfo
spi = Span -> [Span] -> SpanInfo
spanInfo (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
qid) (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2]))
          in Expression () -> Expression ()
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression () -> Expression ()) -> Expression () -> Expression ()
forall a b. (a -> b) -> a -> b
$ SpanInfo
-> () -> QualIdent -> [Field (Expression ())] -> Expression ()
forall a.
SpanInfo
-> a -> QualIdent -> [Field (Expression a)] -> Expression a
Record SpanInfo
spi () QualIdent
qid [Field (Expression ())]
fs
        mkVariable :: QualIdent -> Expression ()
mkVariable qid :: QualIdent
qid = SpanInfo -> () -> QualIdent -> Expression ()
forall a. SpanInfo -> a -> QualIdent -> Expression a
Variable (Span -> SpanInfo
fromSrcSpan (QualIdent -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan QualIdent
qid)) () QualIdent
qid

parenExpr :: Parser a Token (Expression ())
parenExpr :: Parser a Token (Expression ())
parenExpr = ((Expression (), Span, Span) -> Expression ())
-> Parser a Token (Expression (), Span, Span)
-> Parser a Token (Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Expression (), Span, Span) -> Expression ()
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets (Parser a Token (Expression ())
-> Parser a Token (Expression (), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
pExpr)
  where
  pExpr :: Parser a Token (Expression ())
pExpr = Parser a Token Ident
forall a. Parser a Token Ident
minus Parser a Token Ident
-> Parser a Token (Ident -> Expression ())
-> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Ident -> Expression ())
forall a. Parser a Token (Ident -> Expression ())
minusOrTuple
      Parser a Token (Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> () -> QualIdent -> Expression ()
forall a. a -> QualIdent -> Expression a
mkConstructor () (QualIdent -> Expression ())
-> Parser a Token QualIdent -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
tupleCommas
      Parser a Token (Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
leftSectionOrTuple Parser a Token (Expression ())
-> Parser a Token Ident -> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
minus
      Parser a Token (Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
opOrRightSection Parser a Token (Expression ())
-> Parser a Token Ident -> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token Ident
forall a. Parser a Token Ident
minus
      Parser a Token (Expression ())
-> Expression () -> Parser a Token (Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> () -> QualIdent -> Expression ()
forall a. SpanInfo -> a -> QualIdent -> Expression a
Constructor ([Span] -> SpanInfo
fromSrcInfoPoints []) () QualIdent
qUnitId
  minusOrTuple :: Parser a Token (Ident -> Expression ())
minusOrTuple = Expression () -> Ident -> Expression ()
forall a a. HasPosition a => Expression a -> a -> Expression a
mkUnaryMinus (Expression () -> Ident -> Expression ())
-> Parser a Token (Expression ())
-> Parser a Token (Ident -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr1 Parser a Token (Ident -> Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser a Token (Ident -> Expression ())
forall s a b c d.
Symbol s =>
Parser a s (b -> c) -> Parser a s (c -> d) -> Parser a s (b -> d)
<.> Parser a Token (Expression () -> Expression ())
forall a. Parser a Token (Expression () -> Expression ())
infixOrTuple
            Parser a Token (Ident -> Expression ())
-> (Ident -> Expression ())
-> Parser a Token (Ident -> Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` QualIdent -> Expression ()
mkVariable (QualIdent -> Expression ())
-> (Ident -> QualIdent) -> Ident -> Expression ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> QualIdent
qualify
  leftSectionOrTuple :: Parser a Token (Expression ())
leftSectionOrTuple = Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr1 Parser a Token (Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Expression () -> Expression ())
forall a. Parser a Token (Expression () -> Expression ())
infixOrTuple
  infixOrTuple :: Parser a Token (Expression () -> Expression ())
infixOrTuple = (((Expression () -> Expression ())
 -> Expression () -> Expression ())
-> (Expression () -> Expression ())
-> Expression ()
-> Expression ()
forall a b. (a -> b) -> a -> b
$ Expression () -> Expression ()
forall a. HasSpanInfo a => a -> a
updateEndPos) (((Expression () -> Expression ())
  -> Expression () -> Expression ())
 -> Expression () -> Expression ())
-> Parser
     a
     Token
     ((Expression () -> Expression ())
      -> Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  a
  Token
  ((Expression () -> Expression ())
   -> Expression () -> Expression ())
forall a.
Parser
  a
  Token
  ((Expression () -> Expression ())
   -> Expression () -> Expression ())
infixOrTuple'
  infixOrTuple' :: Parser
  a
  Token
  ((Expression () -> Expression ())
   -> Expression () -> Expression ())
infixOrTuple' = Parser a Token (InfixOp ())
forall a. Parser a Token (InfixOp ())
infixOp Parser a Token (InfixOp ())
-> Parser
     a
     Token
     (InfixOp ()
      -> (Expression () -> Expression ())
      -> Expression ()
      -> Expression ())
-> Parser
     a
     Token
     ((Expression () -> Expression ())
      -> Expression () -> Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser
  a
  Token
  (InfixOp ()
   -> (Expression () -> Expression ())
   -> Expression ()
   -> Expression ())
leftSectionOrExp
              Parser
  a
  Token
  ((Expression () -> Expression ())
   -> Expression () -> Expression ())
-> Parser
     a
     Token
     ((Expression () -> Expression ())
      -> Expression () -> Expression ())
-> Parser
     a
     Token
     ((Expression () -> Expression ())
      -> Expression () -> Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Expression () -> Expression ())
-> (Expression () -> Expression ())
-> Expression ()
-> Expression ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) ((Expression () -> Expression ())
 -> (Expression () -> Expression ())
 -> Expression ()
 -> Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser
     a
     Token
     ((Expression () -> Expression ())
      -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser a Token (Expression () -> Expression ())
forall a a. Parser a Token (Expression a -> Expression a)
optType Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall s a b c d.
Symbol s =>
Parser a s (b -> c) -> Parser a s (c -> d) -> Parser a s (b -> d)
<.> Parser a Token (Expression () -> Expression ())
forall a. Parser a Token (Expression () -> Expression ())
tupleExpr)
  leftSectionOrExp :: Parser
  a
  Token
  (InfixOp ()
   -> (Expression () -> Expression ())
   -> Expression ()
   -> Expression ())
leftSectionOrExp = Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr1 Parser a Token (Expression ())
-> Parser
     a
     Token
     (Expression ()
      -> InfixOp ()
      -> (Expression () -> Expression ())
      -> Expression ()
      -> Expression ())
-> Parser
     a
     Token
     (InfixOp ()
      -> (Expression () -> Expression ())
      -> Expression ()
      -> Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (((Expression () -> Expression ())
 -> Expression () -> Expression ())
-> Expression ()
-> InfixOp ()
-> (Expression () -> Expression ())
-> Expression ()
-> Expression ()
forall a c t t.
((Expression a -> c) -> t -> t)
-> t -> InfixOp a -> (Expression a -> c) -> Expression a -> t
infixApp (((Expression () -> Expression ())
  -> Expression () -> Expression ())
 -> Expression ()
 -> InfixOp ()
 -> (Expression () -> Expression ())
 -> Expression ()
 -> Expression ())
-> Parser
     a
     Token
     ((Expression () -> Expression ())
      -> Expression () -> Expression ())
-> Parser
     a
     Token
     (Expression ()
      -> InfixOp ()
      -> (Expression () -> Expression ())
      -> Expression ()
      -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  a
  Token
  ((Expression () -> Expression ())
   -> Expression () -> Expression ())
infixOrTuple')
                Parser
  a
  Token
  (InfixOp ()
   -> (Expression () -> Expression ())
   -> Expression ()
   -> Expression ())
-> (InfixOp ()
    -> (Expression () -> Expression ())
    -> Expression ()
    -> Expression ())
-> Parser
     a
     Token
     (InfixOp ()
      -> (Expression () -> Expression ())
      -> Expression ()
      -> Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` InfixOp ()
-> (Expression () -> Expression ())
-> Expression ()
-> Expression ()
forall a t. InfixOp a -> (t -> Expression a) -> t -> Expression a
leftSection
  optType :: Parser a Token (Expression a -> Expression a)
optType   = Span -> QualTypeExpr -> Expression a -> Expression a
forall a. Span -> QualTypeExpr -> Expression a -> Expression a
mkTyped (Span -> QualTypeExpr -> Expression a -> Expression a)
-> Parser a Token Span
-> Parser a Token (QualTypeExpr -> Expression a -> Expression a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DoubleColon Parser a Token (QualTypeExpr -> Expression a -> Expression a)
-> Parser a Token QualTypeExpr
-> Parser a Token (Expression a -> Expression a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualTypeExpr
forall a. Parser a Token QualTypeExpr
qualType Parser a Token (Expression a -> Expression a)
-> (Expression a -> Expression a)
-> Parser a Token (Expression a -> Expression a)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` Expression a -> Expression a
forall a. a -> a
id
  tupleExpr :: Parser a Token (Expression () -> Expression ())
tupleExpr = [(Span, Expression ())] -> Expression () -> Expression ()
forall a. [(Span, Expression a)] -> Expression a -> Expression a
mkTuple ([(Span, Expression ())] -> Expression () -> Expression ())
-> Parser a Token [(Span, Expression ())]
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Span, Expression ())
-> Parser a Token [(Span, Expression ())]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 ((,) (Span -> Expression () -> (Span, Expression ()))
-> Parser a Token Span
-> Parser a Token (Expression () -> (Span, Expression ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Comma Parser a Token (Expression () -> (Span, Expression ()))
-> Parser a Token (Expression ())
-> Parser a Token (Span, Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr)
               Parser a Token (Expression () -> Expression ())
-> (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> Expression () -> Expression ()
forall a. SpanInfo -> Expression a -> Expression a
Paren SpanInfo
NoSpanInfo
  opOrRightSection :: Parser a Token (Expression ())
opOrRightSection =  Parser a Token QualIdent
forall a. Parser a Token QualIdent
qFunSym Parser a Token QualIdent
-> Parser a Token (QualIdent -> Expression ())
-> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (QualIdent -> Expression ())
forall a. Parser a Token (QualIdent -> Expression ())
optRightSection
                  Parser a Token (Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token QualIdent
forall a. Parser a Token QualIdent
colon   Parser a Token QualIdent
-> Parser a Token (QualIdent -> Expression ())
-> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (QualIdent -> Expression ())
forall a. Parser a Token (QualIdent -> Expression ())
optCRightSection
                  Parser a Token (Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (InfixOp ())
forall a. Parser a Token (InfixOp ())
infixOp Parser a Token (InfixOp ())
-> Parser a Token QualIdent -> Parser a Token (InfixOp ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token QualIdent
forall a. Parser a Token QualIdent
colon Parser a Token (InfixOp ())
-> Parser a Token QualIdent -> Parser a Token (InfixOp ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qFunSym Parser a Token (InfixOp ())
-> Parser a Token (InfixOp () -> Expression ())
-> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (InfixOp () -> Expression ())
forall a. Parser a Token (InfixOp () -> Expression ())
rightSection
  optRightSection :: Parser a Token (QualIdent -> Expression ())
optRightSection  = ((InfixOp () -> Expression ())
-> (QualIdent -> InfixOp ()) -> QualIdent -> Expression ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> QualIdent -> InfixOp ()
forall a. a -> QualIdent -> InfixOp a
InfixOp ()    ) ((InfixOp () -> Expression ()) -> QualIdent -> Expression ())
-> Parser a Token (InfixOp () -> Expression ())
-> Parser a Token (QualIdent -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (InfixOp () -> Expression ())
forall a. Parser a Token (InfixOp () -> Expression ())
rightSection
                       Parser a Token (QualIdent -> Expression ())
-> (QualIdent -> Expression ())
-> Parser a Token (QualIdent -> Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> () -> QualIdent -> Expression ()
forall a. SpanInfo -> a -> QualIdent -> Expression a
Variable SpanInfo
NoSpanInfo ()
  optCRightSection :: Parser a Token (QualIdent -> Expression ())
optCRightSection = ((InfixOp () -> Expression ())
-> (QualIdent -> InfixOp ()) -> QualIdent -> Expression ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. () -> QualIdent -> InfixOp ()
forall a. a -> QualIdent -> InfixOp a
InfixConstr ()) ((InfixOp () -> Expression ()) -> QualIdent -> Expression ())
-> Parser a Token (InfixOp () -> Expression ())
-> Parser a Token (QualIdent -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (InfixOp () -> Expression ())
forall a. Parser a Token (InfixOp () -> Expression ())
rightSection
                       Parser a Token (QualIdent -> Expression ())
-> (QualIdent -> Expression ())
-> Parser a Token (QualIdent -> Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> () -> QualIdent -> Expression ()
forall a. SpanInfo -> a -> QualIdent -> Expression a
Constructor SpanInfo
NoSpanInfo ()
  rightSection :: Parser a Token (InfixOp () -> Expression ())
rightSection     = Expression () -> InfixOp () -> Expression ()
forall a. Expression a -> InfixOp a -> Expression a
mkRightSection (Expression () -> InfixOp () -> Expression ())
-> Parser a Token (Expression ())
-> Parser a Token (InfixOp () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr0
  infixApp :: ((Expression a -> c) -> t -> t)
-> t -> InfixOp a -> (Expression a -> c) -> Expression a -> t
infixApp f :: (Expression a -> c) -> t -> t
f e2 :: t
e2 op :: InfixOp a
op g :: Expression a -> c
g e1 :: Expression a
e1 = (Expression a -> c) -> t -> t
f (Expression a -> c
g (Expression a -> c)
-> (Expression a -> Expression a) -> Expression a -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expression a -> InfixOp a -> Expression a -> Expression a
forall a. Expression a -> InfixOp a -> Expression a -> Expression a
mkInfixApply Expression a
e1 InfixOp a
op) t
e2
  leftSection :: InfixOp a -> (t -> Expression a) -> t -> Expression a
leftSection op :: InfixOp a
op f :: t -> Expression a
f e :: t
e = Expression a -> InfixOp a -> Expression a
forall a. Expression a -> InfixOp a -> Expression a
mkLeftSection (t -> Expression a
f t
e) InfixOp a
op
  mkTuple :: [(Span, Expression a)] -> Expression a -> Expression a
mkTuple ses :: [(Span, Expression a)]
ses e :: Expression a
e = let (ss :: [Span]
ss,es :: [Expression a]
es) = [(Span, Expression a)] -> ([Span], [Expression a])
forall a b. [(a, b)] -> ([a], [b])
unzip [(Span, Expression a)]
ses
                  in SpanInfo -> [Expression a] -> Expression a
forall a. SpanInfo -> [Expression a] -> Expression a
Tuple ([Span] -> SpanInfo
fromSrcInfoPoints [Span]
ss) (Expression a
eExpression a -> [Expression a] -> [Expression a]
forall a. a -> [a] -> [a]
:[Expression a]
es)
  mkConstructor :: a -> QualIdent -> Expression a
mkConstructor = SpanInfo -> a -> QualIdent -> Expression a
forall a. SpanInfo -> a -> QualIdent -> Expression a
Constructor SpanInfo
NoSpanInfo
  mkTyped :: Span -> QualTypeExpr -> Expression a -> Expression a
mkTyped sp :: Span
sp ty :: QualTypeExpr
ty e :: Expression a
e = SpanInfo -> Expression a -> QualTypeExpr -> Expression a
forall a. SpanInfo -> Expression a -> QualTypeExpr -> Expression a
Typed ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp]) Expression a
e QualTypeExpr
ty
  mkRightSection :: Expression a -> InfixOp a -> Expression a
mkRightSection = (InfixOp a -> Expression a -> Expression a)
-> Expression a -> InfixOp a -> Expression a
forall a b c. (a -> b -> c) -> b -> a -> c
flip (SpanInfo -> InfixOp a -> Expression a -> Expression a
forall a. SpanInfo -> InfixOp a -> Expression a -> Expression a
RightSection SpanInfo
NoSpanInfo)
  mkLeftSection :: Expression a -> InfixOp a -> Expression a
mkLeftSection  = SpanInfo -> Expression a -> InfixOp a -> Expression a
forall a. SpanInfo -> Expression a -> InfixOp a -> Expression a
LeftSection  SpanInfo
NoSpanInfo
  mkInfixApply :: Expression a -> InfixOp a -> Expression a -> Expression a
mkInfixApply e1 :: Expression a
e1 op :: InfixOp a
op e2 :: Expression a
e2 = SpanInfo
-> Expression a -> InfixOp a -> Expression a -> Expression a
forall a.
SpanInfo
-> Expression a -> InfixOp a -> Expression a -> Expression a
InfixApply (Span -> SpanInfo
fromSrcSpan
    (Span -> Span -> Span
combineSpans (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e1) (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e2))) Expression a
e1 InfixOp a
op Expression a
e2
  mkVariable :: QualIdent -> Expression ()
mkVariable = SpanInfo -> () -> QualIdent -> Expression ()
forall a. SpanInfo -> a -> QualIdent -> Expression a
Variable SpanInfo
NoSpanInfo ()
  mkUnaryMinus :: Expression a -> a -> Expression a
mkUnaryMinus ex :: Expression a
ex idt :: a
idt =
    let p :: Position
p = a -> Position
forall a. HasPosition a => a -> Position
getPosition a
idt
        e :: Position
e = Expression a -> Position
forall a. HasSpanInfo a => a -> Position
getSrcSpanEnd Expression a
ex
        f :: FilePath
f = Position -> FilePath
file Position
p
    in SpanInfo -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a
UnaryMinus (Span -> [Span] -> SpanInfo
spanInfo (FilePath -> Position -> Position -> Span
Span FilePath
f Position
p Position
e) [FilePath -> Position -> Position -> Span
Span FilePath
f Position
p (Position -> Arity -> Position
incr Position
p 1)]) Expression a
ex

infixOp :: Parser a Token (InfixOp ())
infixOp :: Parser a Token (InfixOp ())
infixOp = () -> QualIdent -> InfixOp ()
forall a. a -> QualIdent -> InfixOp a
InfixOp () (QualIdent -> InfixOp ())
-> Parser a Token QualIdent -> Parser a Token (InfixOp ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qfunop Parser a Token (InfixOp ())
-> Parser a Token (InfixOp ()) -> Parser a Token (InfixOp ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> () -> QualIdent -> InfixOp ()
forall a. a -> QualIdent -> InfixOp a
InfixConstr () (QualIdent -> InfixOp ())
-> Parser a Token QualIdent -> Parser a Token (InfixOp ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent
forall a. Parser a Token QualIdent
colon

listExpr :: Parser a Token (Expression ())
listExpr :: Parser a Token (Expression ())
listExpr = (Expression (), Span, Span) -> Expression ()
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets ((Expression (), Span, Span) -> Expression ())
-> Parser a Token (Expression (), Span, Span)
-> Parser a Token (Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
             Parser a Token (Expression ())
-> Parser a Token (Expression (), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracketsSp (Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
elements Parser a Token (Expression ())
-> Expression () -> Parser a Token (Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` SpanInfo -> () -> [Expression ()] -> Expression ()
forall a. SpanInfo -> a -> [Expression a] -> Expression a
List ([Span] -> SpanInfo
fromSrcInfoPoints []) () [])
  where
  elements :: Parser a Token (Expression ())
elements = Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr Parser a Token (Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Expression () -> Expression ())
forall a. Parser a Token (Expression () -> Expression ())
rest
  rest :: Parser a Token (Expression () -> Expression ())
rest = Parser a Token (Expression () -> Expression ())
forall a. Parser a Token (Expression () -> Expression ())
comprehension
      Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Expression () -> Span -> Expression () -> Expression ())
-> (Span -> Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall c a.
(Expression () -> Span -> c) -> (Span -> c) -> Parser a Token c
enumeration Expression () -> Span -> Expression () -> Expression ()
forall a. Expression a -> Span -> Expression a -> Expression a
mkEnumFromTo Span -> Expression () -> Expression ()
forall a. Span -> Expression a -> Expression a
mkEnumFrom
      Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Comma Parser a Token Span
-> Parser a Token (Span -> Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr Parser a Token (Expression ())
-> Parser
     a Token (Expression () -> Span -> Expression () -> Expression ())
-> Parser a Token (Span -> Expression () -> Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**>(
           (Expression ()
 -> Span -> Expression () -> Span -> Expression () -> Expression ())
-> (Span
    -> Expression () -> Span -> Expression () -> Expression ())
-> Parser
     a Token (Expression () -> Span -> Expression () -> Expression ())
forall c a.
(Expression () -> Span -> c) -> (Span -> c) -> Parser a Token c
enumeration Expression ()
-> Span -> Expression () -> Span -> Expression () -> Expression ()
forall a.
Expression a
-> Span -> Expression a -> Span -> Expression a -> Expression a
mkEnumFromThenTo Span -> Expression () -> Span -> Expression () -> Expression ()
forall a.
Span -> Expression a -> Span -> Expression a -> Expression a
mkEnumFromThen
          Parser
  a Token (Expression () -> Span -> Expression () -> Expression ())
-> Parser
     a Token (Expression () -> Span -> Expression () -> Expression ())
-> Parser
     a Token (Expression () -> Span -> Expression () -> Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> [(Span, Expression ())]
-> Expression () -> Span -> Expression () -> Expression ()
list ([(Span, Expression ())]
 -> Expression () -> Span -> Expression () -> Expression ())
-> Parser a Token [(Span, Expression ())]
-> Parser
     a Token (Expression () -> Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Span, Expression ())
-> Parser a Token [(Span, Expression ())]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many ((,) (Span -> Expression () -> (Span, Expression ()))
-> Parser a Token Span
-> Parser a Token (Expression () -> (Span, Expression ()))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Comma Parser a Token (Expression () -> (Span, Expression ()))
-> Parser a Token (Expression ())
-> Parser a Token (Span, Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr)))
    Parser a Token (Expression () -> Expression ())
-> (Expression () -> Expression ())
-> Parser a Token (Expression () -> Expression ())
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` (\ e :: Expression ()
e -> SpanInfo -> () -> [Expression ()] -> Expression ()
forall a. SpanInfo -> a -> [Expression a] -> Expression a
List ([Span] -> SpanInfo
fromSrcInfoPoints []) () [Expression ()
e]))
  comprehension :: Parser a Token (Expression () -> Expression ())
comprehension = Span -> [Statement ()] -> Expression () -> Expression ()
forall a. Span -> [Statement a] -> Expression a -> Expression a
mkListCompr (Span -> [Statement ()] -> Expression () -> Expression ())
-> Parser a Token Span
-> Parser
     a Token ([Statement ()] -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Bar Parser a Token ([Statement ()] -> Expression () -> Expression ())
-> Parser a Token [Statement ()]
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token [Statement ()]
forall a. Parser a Token [Statement ()]
quals
  enumeration :: (Expression () -> Span -> c) -> (Span -> c) -> Parser a Token c
enumeration enumTo :: Expression () -> Span -> c
enumTo enum :: Span -> c
enum =
    Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
DotDot Parser a Token Span
-> Parser a Token (Span -> c) -> Parser a Token c
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> (Expression () -> Span -> c
enumTo (Expression () -> Span -> c)
-> Parser a Token (Expression ()) -> Parser a Token (Span -> c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr Parser a Token (Span -> c)
-> (Span -> c) -> Parser a Token (Span -> c)
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` Span -> c
enum)

  mkEnumFrom :: Span -> Expression a -> Expression a
mkEnumFrom                 sp :: Span
sp     =
    SpanInfo -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a
EnumFrom ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp])
  mkEnumFromTo :: Expression a -> Span -> Expression a -> Expression a
mkEnumFromTo            e1 :: Expression a
e1 sp :: Span
sp  e2 :: Expression a
e2 =
    SpanInfo -> Expression a -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a -> Expression a
EnumFromTo ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp]) Expression a
e2 Expression a
e1
  mkEnumFromThen :: Span -> Expression a -> Span -> Expression a -> Expression a
mkEnumFromThen      sp1 :: Span
sp1 e1 :: Expression a
e1 sp2 :: Span
sp2 e2 :: Expression a
e2 =
    SpanInfo -> Expression a -> Expression a -> Expression a
forall a. SpanInfo -> Expression a -> Expression a -> Expression a
EnumFromThen ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp2,Span
sp1]) Expression a
e2 Expression a
e1
  mkEnumFromThenTo :: Expression a
-> Span -> Expression a -> Span -> Expression a -> Expression a
mkEnumFromThenTo e1 :: Expression a
e1 sp1 :: Span
sp1 e2 :: Expression a
e2 sp2 :: Span
sp2 e3 :: Expression a
e3 =
    SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
forall a.
SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
EnumFromThenTo ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp2,Span
sp1]) Expression a
e3 Expression a
e2 Expression a
e1
  mkListCompr :: Span -> [Statement a] -> Expression a -> Expression a
mkListCompr sp :: Span
sp qu :: [Statement a]
qu e :: Expression a
e = SpanInfo -> Expression a -> [Statement a] -> Expression a
forall a. SpanInfo -> Expression a -> [Statement a] -> Expression a
ListCompr ([Span] -> SpanInfo
fromSrcInfoPoints [Span
sp]) Expression a
e [Statement a]
qu

  list :: [(Span, Expression ())]
-> Expression () -> Span -> Expression () -> Expression ()
list xs :: [(Span, Expression ())]
xs e2 :: Expression ()
e2 sp :: Span
sp e1 :: Expression ()
e1 = let (ss :: [Span]
ss, es :: [Expression ()]
es) = [(Span, Expression ())] -> ([Span], [Expression ()])
forall a b. [(a, b)] -> ([a], [b])
unzip [(Span, Expression ())]
xs
                     in SpanInfo -> () -> [Expression ()] -> Expression ()
forall a. SpanInfo -> a -> [Expression a] -> Expression a
List ([Span] -> SpanInfo
fromSrcInfoPoints (Span
spSpan -> [Span] -> [Span]
forall a. a -> [a] -> [a]
:[Span]
ss)) () (Expression ()
e1Expression () -> [Expression ()] -> [Expression ()]
forall a. a -> [a] -> [a]
:Expression ()
e2Expression () -> [Expression ()] -> [Expression ()]
forall a. a -> [a] -> [a]
:[Expression ()]
es)

updateSpanWithBrackets :: HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets :: (a, Span, Span) -> a
updateSpanWithBrackets (ex :: a
ex, sp1 :: Span
sp1, sp2 :: Span
sp2) =
  let ss :: [Span]
ss = a -> [Span]
forall a. HasSpanInfo a => a -> [Span]
getSrcInfoPoints a
ex
      s :: Position
s  = Span -> Position
forall a. HasPosition a => a -> Position
getPosition Span
sp1
      e :: Position
e  = Span -> Position
end Span
sp2
      f :: FilePath
f  = Position -> FilePath
file Position
s
      spi :: SpanInfo
spi = Span -> [Span] -> SpanInfo
spanInfo (FilePath -> Position -> Position -> Span
Span FilePath
f Position
s Position
e) (Span
sp1 Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
: ([Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
sp2]))
  in SpanInfo -> a -> a
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo SpanInfo
spi a
ex

lambdaExpr :: Parser a Token (Expression ())
lambdaExpr :: Parser a Token (Expression ())
lambdaExpr = Span -> [Pattern ()] -> Span -> Expression () -> Expression ()
forall a.
Span -> [Pattern a] -> Span -> Expression a -> Expression a
mkLambda (Span -> [Pattern ()] -> Span -> Expression () -> Expression ())
-> Parser a Token Span
-> Parser
     a Token ([Pattern ()] -> Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Backslash Parser
  a Token ([Pattern ()] -> Span -> Expression () -> Expression ())
-> Parser a Token [Pattern ()]
-> Parser a Token (Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ()) -> Parser a Token [Pattern ()]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern2
                      Parser a Token (Span -> Expression () -> Expression ())
-> Parser a Token Span
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Expression () -> Expression ())
-> Parser a Token Attributes
-> Parser a Token (Expression () -> Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
expectRightArrow
                      Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
  where mkLambda :: Span -> [Pattern a] -> Span -> Expression a -> Expression a
mkLambda sp1 :: Span
sp1 ps :: [Pattern a]
ps sp2 :: Span
sp2 e :: Expression a
e = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$ SpanInfo -> [Pattern a] -> Expression a -> Expression a
forall a. SpanInfo -> [Pattern a] -> Expression a -> Expression a
Lambda (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2]) [Pattern a]
ps Expression a
e

letExpr :: Parser a Token (Expression ())
letExpr :: Parser a Token (Expression ())
letExpr = Span
-> ([Decl ()], LayoutInfo)
-> Span
-> Expression ()
-> Expression ()
forall a.
Span
-> ([Decl a], LayoutInfo) -> Span -> Expression a -> Expression a
mkLet (Span
 -> ([Decl ()], LayoutInfo)
 -> Span
 -> Expression ()
 -> Expression ())
-> Parser a Token Span
-> Parser
     a
     Token
     (([Decl ()], LayoutInfo) -> Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>  Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_let Parser
  a
  Token
  (([Decl ()], LayoutInfo) -> Span -> Expression () -> Expression ())
-> Parser a Token ([Decl ()], LayoutInfo)
-> Parser a Token (Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([Decl ()], [Span])
-> Parser a Token ([Decl ()], LayoutInfo)
forall a b.
Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
layout Parser a Token ([Decl ()], [Span])
forall a. Parser a Token ([Decl ()], [Span])
valueDecls
                Parser a Token (Span -> Expression () -> Expression ())
-> Parser a Token Span
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_in Parser a Token Span -> FilePath -> Parser a Token Span
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "in expected") Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
  where
    mkLet :: Span
-> ([Decl a], LayoutInfo) -> Span -> Expression a -> Expression a
mkLet sp1 :: Span
sp1 (ds :: [Decl a]
ds, lay :: LayoutInfo
lay) sp2 :: Span
sp2 e :: Expression a
e = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
      SpanInfo -> LayoutInfo -> [Decl a] -> Expression a -> Expression a
forall a.
SpanInfo -> LayoutInfo -> [Decl a] -> Expression a -> Expression a
Let (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2])LayoutInfo
lay [Decl a]
ds Expression a
e

doExpr :: Parser a Token (Expression ())
doExpr :: Parser a Token (Expression ())
doExpr = Span
-> (([Statement ()], Expression ()), LayoutInfo) -> Expression ()
forall a.
Span -> (([Statement a], Expression a), LayoutInfo) -> Expression a
mkDo (Span
 -> (([Statement ()], Expression ()), LayoutInfo) -> Expression ())
-> Parser a Token Span
-> Parser
     a
     Token
     ((([Statement ()], Expression ()), LayoutInfo) -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_do Parser
  a
  Token
  ((([Statement ()], Expression ()), LayoutInfo) -> Expression ())
-> Parser a Token (([Statement ()], Expression ()), LayoutInfo)
-> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (([Statement ()], Expression ()), [Span])
-> Parser a Token (([Statement ()], Expression ()), LayoutInfo)
forall a b.
Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
layout Parser a Token (([Statement ()], Expression ()), [Span])
forall a. Parser a Token (([Statement ()], Expression ()), [Span])
stmts
  where
    mkDo :: Span -> (([Statement a], Expression a), LayoutInfo) -> Expression a
mkDo sp :: Span
sp ((stms :: [Statement a]
stms, ex :: Expression a
ex), lay :: LayoutInfo
lay) = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
      SpanInfo
-> LayoutInfo -> [Statement a] -> Expression a -> Expression a
forall a.
SpanInfo
-> LayoutInfo -> [Statement a] -> Expression a -> Expression a
Do (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span
sp]) LayoutInfo
lay [Statement a]
stms Expression a
ex

ifExpr :: Parser a Token (Expression ())
ifExpr :: Parser a Token (Expression ())
ifExpr = Span
-> Expression ()
-> Span
-> Expression ()
-> Span
-> Expression ()
-> Expression ()
forall a.
Span
-> Expression a
-> Span
-> Expression a
-> Span
-> Expression a
-> Expression a
mkIfThenElse
    (Span
 -> Expression ()
 -> Span
 -> Expression ()
 -> Span
 -> Expression ()
 -> Expression ())
-> Parser a Token Span
-> Parser
     a
     Token
     (Expression ()
      -> Span -> Expression () -> Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>  Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_if                        Parser
  a
  Token
  (Expression ()
   -> Span -> Expression () -> Span -> Expression () -> Expression ())
-> Parser a Token (Expression ())
-> Parser
     a
     Token
     (Span -> Expression () -> Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
    Parser
  a
  Token
  (Span -> Expression () -> Span -> Expression () -> Expression ())
-> Parser a Token Span
-> Parser
     a Token (Expression () -> Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_then Parser a Token Span -> FilePath -> Parser a Token Span
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "then expected") Parser
  a Token (Expression () -> Span -> Expression () -> Expression ())
-> Parser a Token (Expression ())
-> Parser a Token (Span -> Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
    Parser a Token (Span -> Expression () -> Expression ())
-> Parser a Token Span
-> Parser a Token (Expression () -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_else Parser a Token Span -> FilePath -> Parser a Token Span
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "else expected") Parser a Token (Expression () -> Expression ())
-> Parser a Token (Expression ()) -> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
  where mkIfThenElse :: Span
-> Expression a
-> Span
-> Expression a
-> Span
-> Expression a
-> Expression a
mkIfThenElse sp1 :: Span
sp1 e1 :: Expression a
e1 sp2 :: Span
sp2 e2 :: Expression a
e2 sp3 :: Span
sp3 e3 :: Expression a
e3 = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
          SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
forall a.
SpanInfo
-> Expression a -> Expression a -> Expression a -> Expression a
IfThenElse (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2, Span
sp3]) Expression a
e1 Expression a
e2 Expression a
e3

caseExpr :: Parser a Token (Expression ())
caseExpr :: Parser a Token (Expression ())
caseExpr = (CaseType
-> Span
-> Expression ()
-> Span
-> ([Alt ()], LayoutInfo)
-> Expression ()
forall a.
CaseType
-> Span
-> Expression a
-> Span
-> ([Alt a], LayoutInfo)
-> Expression a
mkCase CaseType
Flex  (Span
 -> Expression ()
 -> Span
 -> ([Alt ()], LayoutInfo)
 -> Expression ())
-> Parser a Token Span
-> Parser
     a
     Token
     (Expression () -> Span -> ([Alt ()], LayoutInfo) -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_fcase
        Parser
  a
  Token
  (Expression () -> Span -> ([Alt ()], LayoutInfo) -> Expression ())
-> Parser
     a
     Token
     (Expression () -> Span -> ([Alt ()], LayoutInfo) -> Expression ())
-> Parser
     a
     Token
     (Expression () -> Span -> ([Alt ()], LayoutInfo) -> Expression ())
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> CaseType
-> Span
-> Expression ()
-> Span
-> ([Alt ()], LayoutInfo)
-> Expression ()
forall a.
CaseType
-> Span
-> Expression a
-> Span
-> ([Alt a], LayoutInfo)
-> Expression a
mkCase CaseType
Rigid (Span
 -> Expression ()
 -> Span
 -> ([Alt ()], LayoutInfo)
 -> Expression ())
-> Parser a Token Span
-> Parser
     a
     Token
     (Expression () -> Span -> ([Alt ()], LayoutInfo) -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_case)
          Parser
  a
  Token
  (Expression () -> Span -> ([Alt ()], LayoutInfo) -> Expression ())
-> Parser a Token (Expression ())
-> Parser a Token (Span -> ([Alt ()], LayoutInfo) -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
          Parser a Token (Span -> ([Alt ()], LayoutInfo) -> Expression ())
-> Parser a Token Span
-> Parser a Token (([Alt ()], LayoutInfo) -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_of Parser a Token Span -> FilePath -> Parser a Token Span
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "of expected")
          Parser a Token (([Alt ()], LayoutInfo) -> Expression ())
-> Parser a Token ([Alt ()], LayoutInfo)
-> Parser a Token (Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([Alt ()], [Span])
-> Parser a Token ([Alt ()], LayoutInfo)
forall a b.
Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
layout (Parser a Token (Alt ())
forall a. Parser a Token (Alt ())
alt Parser a Token (Alt ())
-> Parser a Token Attributes -> Parser a Token ([Alt ()], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon)
  where
    mkCase :: CaseType
-> Span
-> Expression a
-> Span
-> ([Alt a], LayoutInfo)
-> Expression a
mkCase ct :: CaseType
ct sp1 :: Span
sp1 e :: Expression a
e sp2 :: Span
sp2 (alts :: [Alt a]
alts, lay :: LayoutInfo
lay) = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
      SpanInfo
-> LayoutInfo
-> CaseType
-> Expression a
-> [Alt a]
-> Expression a
forall a.
SpanInfo
-> LayoutInfo
-> CaseType
-> Expression a
-> [Alt a]
-> Expression a
Case (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp1, Span
sp2]) LayoutInfo
lay CaseType
ct Expression a
e [Alt a]
alts

alt :: Parser a Token (Alt ())
alt :: Parser a Token (Alt ())
alt = Span -> Pattern () -> Span -> Rhs () -> Alt ()
forall a. Span -> Pattern a -> Span -> Rhs a -> Alt a
mkAlt (Span -> Pattern () -> Span -> Rhs () -> Alt ())
-> Parser a Token Span
-> Parser a Token (Pattern () -> Span -> Rhs () -> Alt ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Pattern () -> Span -> Rhs () -> Alt ())
-> Parser a Token (Pattern ())
-> Parser a Token (Span -> Rhs () -> Alt ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0
            Parser a Token (Span -> Rhs () -> Alt ())
-> Parser a Token Span -> Parser a Token (Rhs () -> Alt ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Rhs () -> Alt ())
-> Parser a Token (Rhs ()) -> Parser a Token (Alt ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Attributes -> Parser a Token (Rhs ())
forall a b. Parser a Token b -> Parser a Token (Rhs ())
rhs Parser a Token Attributes
forall a. Parser a Token Attributes
expectRightArrow
  where mkAlt :: Span -> Pattern a -> Span -> Rhs a -> Alt a
mkAlt sp1 :: Span
sp1 p :: Pattern a
p sp2 :: Span
sp2 = Alt a -> Alt a
forall a. HasSpanInfo a => a -> a
updateEndPos (Alt a -> Alt a) -> (Rhs a -> Alt a) -> Rhs a -> Alt a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanInfo -> Pattern a -> Rhs a -> Alt a
forall a. SpanInfo -> Pattern a -> Rhs a -> Alt a
Alt (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp2]) Pattern a
p

fieldsSp :: Parser a Token b -> Parser a Token (([Field b], [Span]), Span, Span)
fieldsSp :: Parser a Token b
-> Parser a Token (([Field b], [Span]), Span, Span)
fieldsSp p :: Parser a Token b
p = Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOff Parser a Token Any
-> Parser a Token (([Field b], [Span]), Span, Span)
-> Parser a Token (([Field b], [Span]), Span, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ([Field b], [Span])
-> Parser a Token (([Field b], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp (Parser a Token b -> Parser a Token (Field b)
forall a b. Parser a Token b -> Parser a Token (Field b)
field Parser a Token b
p Parser a Token (Field b)
-> Parser a Token Attributes -> Parser a Token ([Field b], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
comma)

field :: Parser a Token b -> Parser a Token (Field b)
field :: Parser a Token b -> Parser a Token (Field b)
field p :: Parser a Token b
p = Span -> QualIdent -> Span -> b -> Field b
forall a. Span -> QualIdent -> Span -> a -> Field a
mkField (Span -> QualIdent -> Span -> b -> Field b)
-> Parser a Token Span
-> Parser a Token (QualIdent -> Span -> b -> Field b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (QualIdent -> Span -> b -> Field b)
-> Parser a Token QualIdent
-> Parser a Token (Span -> b -> Field b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token QualIdent
forall a. Parser a Token QualIdent
qfun
                  Parser a Token (Span -> b -> Field b)
-> Parser a Token Span -> Parser a Token (b -> Field b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (b -> Field b)
-> Parser a Token Attributes -> Parser a Token (b -> Field b)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
expectEquals
                  Parser a Token (b -> Field b)
-> Parser a Token b -> Parser a Token (Field b)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token b
p
  where mkField :: Span -> QualIdent -> Span -> a -> Field a
mkField sp1 :: Span
sp1 q :: QualIdent
q sp2 :: Span
sp2 = Field a -> Field a
forall a. HasSpanInfo a => a -> a
updateEndPos (Field a -> Field a) -> (a -> Field a) -> a -> Field a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpanInfo -> QualIdent -> a -> Field a
forall a. SpanInfo -> QualIdent -> a -> Field a
Field (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp2]) QualIdent
q

-- ---------------------------------------------------------------------------
-- \paragraph{Statements in list comprehensions and \texttt{do} expressions}
-- Parsing statements is a bit difficult because the syntax of patterns
-- and expressions largely overlaps. The parser will first try to
-- recognize the prefix \emph{Pattern}~\texttt{<-} of a binding statement
-- and if this fails fall back into parsing an expression statement. In
-- addition, we have to be prepared that the sequence
-- \texttt{let}~\emph{LocalDefs} can be either a let-statement or the
-- prefix of a let expression.
-- ---------------------------------------------------------------------------

stmts :: Parser a Token (([Statement ()], Expression ()), [Span])
stmts :: Parser a Token (([Statement ()], Expression ()), [Span])
stmts = Parser
  a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
-> Parser
     a
     Token
     (Expression () -> (([Statement ()], Expression ()), [Span]))
-> Parser a Token (([Statement ()], Expression ()), [Span])
forall a b.
Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
stmt Parser
  a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
forall a.
Parser
  a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
reqStmts Parser
  a
  Token
  (Expression () -> (([Statement ()], Expression ()), [Span]))
forall a.
Parser
  a
  Token
  (Expression () -> (([Statement ()], Expression ()), [Span]))
optStmts

reqStmts :: Parser a Token (Statement ()
                        -> (([Statement ()], Expression ()), [Span]))
reqStmts :: Parser
  a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
reqStmts = Span
-> (([Statement ()], Expression ()), [Span])
-> Statement ()
-> (([Statement ()], Expression ()), [Span])
forall a a b. a -> (([a], b), [a]) -> a -> (([a], b), [a])
mkStmts (Span
 -> (([Statement ()], Expression ()), [Span])
 -> Statement ()
 -> (([Statement ()], Expression ()), [Span]))
-> Parser a Token Span
-> Parser
     a
     Token
     ((([Statement ()], Expression ()), [Span])
      -> Statement () -> (([Statement ()], Expression ()), [Span]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser
  a
  Token
  ((([Statement ()], Expression ()), [Span])
   -> Statement () -> (([Statement ()], Expression ()), [Span]))
-> Parser a Token Attributes
-> Parser
     a
     Token
     ((([Statement ()], Expression ()), [Span])
      -> Statement () -> (([Statement ()], Expression ()), [Span]))
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon Parser
  a
  Token
  ((([Statement ()], Expression ()), [Span])
   -> Statement () -> (([Statement ()], Expression ()), [Span]))
-> Parser a Token (([Statement ()], Expression ()), [Span])
-> Parser
     a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (([Statement ()], Expression ()), [Span])
forall a. Parser a Token (([Statement ()], Expression ()), [Span])
stmts
  where mkStmts :: a -> (([a], b), [a]) -> a -> (([a], b), [a])
mkStmts sp :: a
sp ((sts :: [a]
sts, e :: b
e), sps :: [a]
sps) st :: a
st = ((a
st a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
sts, b
e), a
spa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
sps)

optStmts :: Parser a Token (Expression ()
                        -> (([Statement ()], Expression ()), [Span]))
optStmts :: Parser
  a
  Token
  (Expression () -> (([Statement ()], Expression ()), [Span]))
optStmts = (Expression () -> Statement ())
-> Parser a Token (Expression () -> Statement ())
forall b a s. b -> Parser a s b
succeed Expression () -> Statement ()
forall a. Expression a -> Statement a
mkStmtExpr Parser a Token (Expression () -> Statement ())
-> Parser
     a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
-> Parser
     a
     Token
     (Expression () -> (([Statement ()], Expression ()), [Span]))
forall s a b c d.
Symbol s =>
Parser a s (b -> c) -> Parser a s (c -> d) -> Parser a s (b -> d)
<.> Parser
  a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
forall a.
Parser
  a Token (Statement () -> (([Statement ()], Expression ()), [Span]))
reqStmts Parser
  a
  Token
  (Expression () -> (([Statement ()], Expression ()), [Span]))
-> (Expression () -> (([Statement ()], Expression ()), [Span]))
-> Parser
     a
     Token
     (Expression () -> (([Statement ()], Expression ()), [Span]))
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` (\e :: Expression ()
e -> (([], Expression ()
e), []))
  where mkStmtExpr :: Expression a -> Statement a
mkStmtExpr e :: Expression a
e = SpanInfo -> Expression a -> Statement a
forall a. SpanInfo -> Expression a -> Statement a
StmtExpr (Span -> SpanInfo
fromSrcSpan (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e)) Expression a
e

quals :: Parser a Token [Statement ()]
quals :: Parser a Token [Statement ()]
quals = Parser a Token (Statement () -> Statement ())
-> Parser a Token (Expression () -> Statement ())
-> Parser a Token (Statement ())
forall a b.
Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
stmt ((Statement () -> Statement ())
-> Parser a Token (Statement () -> Statement ())
forall b a s. b -> Parser a s b
succeed Statement () -> Statement ()
forall a. a -> a
id) ((Expression () -> Statement ())
-> Parser a Token (Expression () -> Statement ())
forall b a s. b -> Parser a s b
succeed Expression () -> Statement ()
forall a. Expression a -> Statement a
mkStmtExpr) Parser a Token (Statement ())
-> Parser a Token Attributes -> Parser a Token [Statement ()]
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s [b]
`sepBy1` Parser a Token Attributes
forall a. Parser a Token Attributes
comma
  where mkStmtExpr :: Expression a -> Statement a
mkStmtExpr e :: Expression a
e = SpanInfo -> Expression a -> Statement a
forall a. SpanInfo -> Expression a -> Statement a
StmtExpr (Span -> SpanInfo
fromSrcSpan (Expression a -> Span
forall a. HasSpanInfo a => a -> Span
getSrcSpan Expression a
e)) Expression a
e

stmt :: Parser a Token (Statement () -> b)
     -> Parser a Token (Expression () -> b) -> Parser a Token b
stmt :: Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
stmt stmtCont :: Parser a Token (Statement () -> b)
stmtCont exprCont :: Parser a Token (Expression () -> b)
exprCont =  Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
forall a b.
Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
letStmt Parser a Token (Statement () -> b)
stmtCont Parser a Token (Expression () -> b)
exprCont
                      Parser a Token b -> Parser a Token b -> Parser a Token b
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
forall a b.
Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
exprOrBindStmt Parser a Token (Statement () -> b)
stmtCont Parser a Token (Expression () -> b)
exprCont

letStmt :: Parser a Token (Statement () -> b)
        -> Parser a Token (Expression () -> b) -> Parser a Token b
letStmt :: Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
letStmt stmtCont :: Parser a Token (Statement () -> b)
stmtCont exprCont :: Parser a Token (Expression () -> b)
exprCont = ((,) (Span
 -> ([Decl ()], LayoutInfo) -> (Span, ([Decl ()], LayoutInfo)))
-> Parser a Token Span
-> Parser
     a
     Token
     (([Decl ()], LayoutInfo) -> (Span, ([Decl ()], LayoutInfo)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_let Parser
  a
  Token
  (([Decl ()], LayoutInfo) -> (Span, ([Decl ()], LayoutInfo)))
-> Parser a Token ([Decl ()], LayoutInfo)
-> Parser a Token (Span, ([Decl ()], LayoutInfo))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token ([Decl ()], [Span])
-> Parser a Token ([Decl ()], LayoutInfo)
forall a b.
Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
layout Parser a Token ([Decl ()], [Span])
forall a. Parser a Token ([Decl ()], [Span])
valueDecls)
                              Parser a Token (Span, ([Decl ()], LayoutInfo))
-> Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
-> Parser a Token b
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
optExpr
  where optExpr :: Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
optExpr =  Span
-> Expression ()
-> (Span, ([Decl ()], LayoutInfo))
-> Expression ()
forall a.
Span
-> Expression a -> (Span, ([Decl a], LayoutInfo)) -> Expression a
let' (Span
 -> Expression ()
 -> (Span, ([Decl ()], LayoutInfo))
 -> Expression ())
-> Parser a Token Span
-> Parser
     a
     Token
     (Expression () -> (Span, ([Decl ()], LayoutInfo)) -> Expression ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
KW_in Parser
  a
  Token
  (Expression () -> (Span, ([Decl ()], LayoutInfo)) -> Expression ())
-> Parser a Token (Expression ())
-> Parser
     a Token ((Span, ([Decl ()], LayoutInfo)) -> Expression ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> Expression ())
-> Parser a Token (Expression () -> b)
-> Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
forall s a b c d.
Symbol s =>
Parser a s (b -> c) -> Parser a s (c -> d) -> Parser a s (b -> d)
<.> Parser a Token (Expression () -> b)
exprCont
               Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
-> Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
-> Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> ((Span, ([Decl ()], LayoutInfo)) -> Statement ())
-> Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> Statement ())
forall b a s. b -> Parser a s b
succeed (Span, ([Decl ()], LayoutInfo)) -> Statement ()
forall a. (Span, ([Decl a], LayoutInfo)) -> Statement a
stmtDecl' Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> Statement ())
-> Parser a Token (Statement () -> b)
-> Parser a Token ((Span, ([Decl ()], LayoutInfo)) -> b)
forall s a b c d.
Symbol s =>
Parser a s (b -> c) -> Parser a s (c -> d) -> Parser a s (b -> d)
<.> Parser a Token (Statement () -> b)
stmtCont
          where
            let' :: Span
-> Expression a -> (Span, ([Decl a], LayoutInfo)) -> Expression a
let' sp1 :: Span
sp1 e :: Expression a
e (sp2 :: Span
sp2, (ds :: [Decl a]
ds, lay :: LayoutInfo
lay)) = Expression a -> Expression a
forall a. HasSpanInfo a => a -> a
updateEndPos (Expression a -> Expression a) -> Expression a -> Expression a
forall a b. (a -> b) -> a -> b
$
              SpanInfo -> LayoutInfo -> [Decl a] -> Expression a -> Expression a
forall a.
SpanInfo -> LayoutInfo -> [Decl a] -> Expression a -> Expression a
Let (Span -> [Span] -> SpanInfo
spanInfo Span
sp2 [Span
sp2, Span
sp1]) LayoutInfo
lay [Decl a]
ds Expression a
e
            stmtDecl' :: (Span, ([Decl a], LayoutInfo)) -> Statement a
stmtDecl'  (sp2 :: Span
sp2, (ds :: [Decl a]
ds, lay :: LayoutInfo
lay)) = Statement a -> Statement a
forall a. HasSpanInfo a => a -> a
updateEndPos (Statement a -> Statement a) -> Statement a -> Statement a
forall a b. (a -> b) -> a -> b
$
              SpanInfo -> LayoutInfo -> [Decl a] -> Statement a
forall a. SpanInfo -> LayoutInfo -> [Decl a] -> Statement a
StmtDecl (Span -> [Span] -> SpanInfo
spanInfo Span
sp2 [Span
sp2]) LayoutInfo
lay [Decl a]
ds

exprOrBindStmt :: Parser a Token (Statement () -> b)
               -> Parser a Token (Expression () -> b)
               -> Parser a Token b
exprOrBindStmt :: Parser a Token (Statement () -> b)
-> Parser a Token (Expression () -> b) -> Parser a Token b
exprOrBindStmt stmtCont :: Parser a Token (Statement () -> b)
stmtCont exprCont :: Parser a Token (Expression () -> b)
exprCont =
       Span -> Pattern () -> Span -> Expression () -> Statement ()
forall a. Span -> Pattern a -> Span -> Expression a -> Statement a
stmtBind' (Span -> Pattern () -> Span -> Expression () -> Statement ())
-> Parser a Token Span
-> Parser
     a Token (Pattern () -> Span -> Expression () -> Statement ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser
  a Token (Pattern () -> Span -> Expression () -> Statement ())
-> Parser a Token (Pattern ())
-> Parser a Token (Span -> Expression () -> Statement ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Pattern ())
forall a. Parser a Token (Pattern ())
pattern0 Parser a Token (Span -> Expression () -> Statement ())
-> Parser a Token Span
-> Parser a Token (Expression () -> Statement ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftArrow Parser a Token (Expression () -> Statement ())
-> Parser a Token (Expression ()) -> Parser a Token (Statement ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr
         Parser a Token (Statement ())
-> Parser a Token (Statement () -> b) -> Parser a Token b
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Statement () -> b)
stmtCont
  Parser a Token b -> Parser a Token b -> Parser a Token b
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|?> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr Parser a Token (Expression ())
-> Parser a Token Attributes -> Parser a Token (Expression ())
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<\> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
KW_let Parser a Token (Expression ())
-> Parser a Token (Expression () -> b) -> Parser a Token b
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s (b -> c) -> Parser a s c
<**> Parser a Token (Expression () -> b)
exprCont
  where
    stmtBind' :: Span -> Pattern a -> Span -> Expression a -> Statement a
stmtBind' sp1 :: Span
sp1 p :: Pattern a
p sp2 :: Span
sp2 e :: Expression a
e = Statement a -> Statement a
forall a. HasSpanInfo a => a -> a
updateEndPos (Statement a -> Statement a) -> Statement a -> Statement a
forall a b. (a -> b) -> a -> b
$
      SpanInfo -> Pattern a -> Expression a -> Statement a
forall a. SpanInfo -> Pattern a -> Expression a -> Statement a
StmtBind (Span -> [Span] -> SpanInfo
spanInfo Span
sp1 [Span
sp2]) Pattern a
p Expression a
e

-- ---------------------------------------------------------------------------
-- Goals
-- ---------------------------------------------------------------------------

goal :: Parser a Token (Goal ())
goal :: Parser a Token (Goal ())
goal = Span
-> Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Goal ()
forall a.
Span
-> Expression a -> (Maybe Span, [Decl a], LayoutInfo) -> Goal a
mkGoal (Span
 -> Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Goal ())
-> Parser a Token Span
-> Parser
     a
     Token
     (Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Goal ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser
  a
  Token
  (Expression () -> (Maybe Span, [Decl ()], LayoutInfo) -> Goal ())
-> Parser a Token (Expression ())
-> Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Goal ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Expression ())
forall a. Parser a Token (Expression ())
expr Parser a Token ((Maybe Span, [Decl ()], LayoutInfo) -> Goal ())
-> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
-> Parser a Token (Goal ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
forall a. Parser a Token (Maybe Span, [Decl ()], LayoutInfo)
localDecls
  where
    mkGoal :: Span
-> Expression a -> (Maybe Span, [Decl a], LayoutInfo) -> Goal a
mkGoal sp1 :: Span
sp1 ex :: Expression a
ex (Just sp2 :: Span
sp2, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Goal a -> Goal a
forall a. HasSpanInfo a => a -> a
updateEndPos (Goal a -> Goal a) -> Goal a -> Goal a
forall a b. (a -> b) -> a -> b
$
      SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Goal a
forall a.
SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Goal a
Goal (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 [Span
sp2]) LayoutInfo
li Expression a
ex [Decl a]
ds
    mkGoal sp1 :: Span
sp1 ex :: Expression a
ex (Nothing, ds :: [Decl a]
ds, li :: LayoutInfo
li) = Goal a -> Goal a
forall a. HasSpanInfo a => a -> a
updateEndPos (Goal a -> Goal a) -> Goal a -> Goal a
forall a b. (a -> b) -> a -> b
$
            SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Goal a
forall a.
SpanInfo -> LayoutInfo -> Expression a -> [Decl a] -> Goal a
Goal (Span -> [Span] -> SpanInfo
SpanInfo Span
sp1 []) LayoutInfo
li Expression a
ex [Decl a]
ds

-- ---------------------------------------------------------------------------
-- Literals, identifiers, and (infix) operators
-- ---------------------------------------------------------------------------

char :: Parser a Token Char
char :: Parser a Token Char
char = Attributes -> Char
cval (Attributes -> Char)
-> Parser a Token Attributes -> Parser a Token Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
CharTok

float :: Parser a Token Double
float :: Parser a Token Double
float = Attributes -> Double
fval (Attributes -> Double)
-> Parser a Token Attributes -> Parser a Token Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
FloatTok

int :: Parser a Token Int
int :: Parser a Token Arity
int = Precedence -> Arity
forall a. Num a => Precedence -> a
fromInteger (Precedence -> Arity)
-> Parser a Token Precedence -> Parser a Token Arity
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Precedence
forall a. Parser a Token Precedence
integer

integer :: Parser a Token Integer
integer :: Parser a Token Precedence
integer = Attributes -> Precedence
ival (Attributes -> Precedence)
-> Parser a Token Attributes -> Parser a Token Precedence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
IntTok

string :: Parser a Token String
string :: Parser a Token FilePath
string = Attributes -> FilePath
sval (Attributes -> FilePath)
-> Parser a Token Attributes -> Parser a Token FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
StringTok

tycon :: Parser a Token Ident
tycon :: Parser a Token Ident
tycon = Parser a Token Ident
forall a. Parser a Token Ident
conId

anonOrTyvar :: Parser a Token Ident
anonOrTyvar :: Parser a Token Ident
anonOrTyvar = Parser a Token Ident
forall a. Parser a Token Ident
anonIdent Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token Ident
forall a. Parser a Token Ident
tyvar

tyvar :: Parser a Token Ident
tyvar :: Parser a Token Ident
tyvar = Parser a Token Ident
forall a. Parser a Token Ident
varId

clsvar :: Parser a Token Ident
clsvar :: Parser a Token Ident
clsvar = Parser a Token Ident
forall a. Parser a Token Ident
tyvar

tycls :: Parser a Token Ident
tycls :: Parser a Token Ident
tycls = Parser a Token Ident
forall a. Parser a Token Ident
conId

qtycls :: Parser a Token QualIdent
qtycls :: Parser a Token QualIdent
qtycls = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConId

qtycon :: Parser a Token QualIdent
qtycon :: Parser a Token QualIdent
qtycon = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConId

varId :: Parser a Token Ident
varId :: Parser a Token Ident
varId = Parser a Token Ident
forall a. Parser a Token Ident
ident

funId :: Parser a Token Ident
funId :: Parser a Token Ident
funId = Parser a Token Ident
forall a. Parser a Token Ident
ident

conId :: Parser a Token Ident
conId :: Parser a Token Ident
conId = Parser a Token Ident
forall a. Parser a Token Ident
ident

funSym :: Parser a Token Ident
funSym :: Parser a Token Ident
funSym = Parser a Token Ident
forall a. Parser a Token Ident
sym

conSym :: Parser a Token Ident
conSym :: Parser a Token Ident
conSym = Parser a Token Ident
forall a. Parser a Token Ident
sym

modIdent :: Parser a Token ModuleIdent
modIdent :: Parser a Token ModuleIdent
modIdent = Parser a Token ModuleIdent
forall a. Parser a Token ModuleIdent
mIdent Parser a Token ModuleIdent
-> FilePath -> Parser a Token ModuleIdent
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "module name expected"

var :: Parser a Token Ident
var :: Parser a Token Ident
var = Parser a Token Ident
forall a. Parser a Token Ident
varId Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident, Span, Span) -> Ident
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((Ident, Span, Span) -> Ident)
-> Parser a Token (Ident, Span, Span) -> Parser a Token Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident -> Parser a Token (Ident, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token Ident
forall a. Parser a Token Ident
funSym Parser a Token Ident -> FilePath -> Parser a Token Ident
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator symbol expected")

fun :: Parser a Token Ident
fun :: Parser a Token Ident
fun = Parser a Token Ident
forall a. Parser a Token Ident
funId Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident, Span, Span) -> Ident
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((Ident, Span, Span) -> Ident)
-> Parser a Token (Ident, Span, Span) -> Parser a Token Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident -> Parser a Token (Ident, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token Ident
forall a. Parser a Token Ident
funSym Parser a Token Ident -> FilePath -> Parser a Token Ident
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator symbol expected")

con :: Parser a Token Ident
con :: Parser a Token Ident
con = Parser a Token Ident
forall a. Parser a Token Ident
conId Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident, Span, Span) -> Ident
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((Ident, Span, Span) -> Ident)
-> Parser a Token (Ident, Span, Span) -> Parser a Token Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident -> Parser a Token (Ident, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token Ident
forall a. Parser a Token Ident
conSym Parser a Token Ident -> FilePath -> Parser a Token Ident
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator symbol expected")

funop :: Parser a Token Ident
funop :: Parser a Token Ident
funop = Parser a Token Ident
forall a. Parser a Token Ident
funSym Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident, Span, Span) -> Ident
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((Ident, Span, Span) -> Ident)
-> Parser a Token (Ident, Span, Span) -> Parser a Token Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident -> Parser a Token (Ident, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
backquotesSp (Parser a Token Ident
forall a. Parser a Token Ident
funId Parser a Token Ident -> FilePath -> Parser a Token Ident
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator name expected")

conop :: Parser a Token Ident
conop :: Parser a Token Ident
conop = Parser a Token Ident
forall a. Parser a Token Ident
conSym Parser a Token Ident
-> Parser a Token Ident -> Parser a Token Ident
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (Ident, Span, Span) -> Ident
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((Ident, Span, Span) -> Ident)
-> Parser a Token (Ident, Span, Span) -> Parser a Token Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident -> Parser a Token (Ident, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
backquotesSp (Parser a Token Ident
forall a. Parser a Token Ident
conId Parser a Token Ident -> FilePath -> Parser a Token Ident
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator name expected")

qFunId :: Parser a Token QualIdent
qFunId :: Parser a Token QualIdent
qFunId = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qIdent

qConId :: Parser a Token QualIdent
qConId :: Parser a Token QualIdent
qConId = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qIdent

qFunSym :: Parser a Token QualIdent
qFunSym :: Parser a Token QualIdent
qFunSym = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qSym

qConSym :: Parser a Token QualIdent
qConSym :: Parser a Token QualIdent
qConSym = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qSym

gConSym :: Parser a Token QualIdent
gConSym :: Parser a Token QualIdent
gConSym = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConSym Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token QualIdent
forall a. Parser a Token QualIdent
colon

qfun :: Parser a Token QualIdent
qfun :: Parser a Token QualIdent
qfun = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qFunId Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (QualIdent, Span, Span) -> QualIdent
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((QualIdent, Span, Span) -> QualIdent)
-> Parser a Token (QualIdent, Span, Span)
-> Parser a Token QualIdent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent -> Parser a Token (QualIdent, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
parensSp (Parser a Token QualIdent
forall a. Parser a Token QualIdent
qFunSym Parser a Token QualIdent -> FilePath -> Parser a Token QualIdent
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator symbol expected")

qfunop :: Parser a Token QualIdent
qfunop :: Parser a Token QualIdent
qfunop = Parser a Token QualIdent
forall a. Parser a Token QualIdent
qFunSym Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (QualIdent, Span, Span) -> QualIdent
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((QualIdent, Span, Span) -> QualIdent)
-> Parser a Token (QualIdent, Span, Span)
-> Parser a Token QualIdent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent -> Parser a Token (QualIdent, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
backquotesSp (Parser a Token QualIdent
forall a. Parser a Token QualIdent
qFunId Parser a Token QualIdent -> FilePath -> Parser a Token QualIdent
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator name expected")

gconop :: Parser a Token QualIdent
gconop :: Parser a Token QualIdent
gconop = Parser a Token QualIdent
forall a. Parser a Token QualIdent
gConSym Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (QualIdent, Span, Span) -> QualIdent
forall a. HasSpanInfo a => (a, Span, Span) -> a
updateSpanWithBrackets
                     ((QualIdent, Span, Span) -> QualIdent)
-> Parser a Token (QualIdent, Span, Span)
-> Parser a Token QualIdent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token QualIdent -> Parser a Token (QualIdent, Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
backquotesSp (Parser a Token QualIdent
forall a. Parser a Token QualIdent
qConId Parser a Token QualIdent -> FilePath -> Parser a Token QualIdent
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "operator name expected")

anonIdent :: Parser a Token Ident
anonIdent :: Parser a Token Ident
anonIdent = (SpanInfo -> Ident -> Ident
forall a. HasSpanInfo a => SpanInfo -> a -> a
`setSpanInfo` Ident
anonId) (SpanInfo -> Ident) -> (Span -> SpanInfo) -> Span -> Ident
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Span -> SpanInfo
fromSrcSpanBoth (Span -> Ident) -> Parser a Token Span -> Parser a Token Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Underscore

mIdent :: Parser a Token ModuleIdent
mIdent :: Parser a Token ModuleIdent
mIdent = Span -> Attributes -> ModuleIdent
mIdent' (Span -> Attributes -> ModuleIdent)
-> Parser a Token Span
-> Parser a Token (Attributes -> ModuleIdent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Attributes -> ModuleIdent)
-> Parser a Token Attributes -> Parser a Token ModuleIdent
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
     [Category] -> Parser a Token Attributes
forall a. [Category] -> Parser a Token Attributes
tokens [Category
Id,Category
QId,Category
Id_as,Category
Id_ccall,Category
Id_forall,Category
Id_hiding,
             Category
Id_interface,Category
Id_primitive,Category
Id_qualified]
  where mIdent' :: Span -> Attributes -> ModuleIdent
mIdent' sp :: Span
sp a :: Attributes
a = SpanInfo -> [FilePath] -> ModuleIdent
ModuleIdent (Span -> SpanInfo
fromSrcSpanBoth Span
sp) (Attributes -> [FilePath]
modulVal Attributes
a [FilePath] -> [FilePath] -> [FilePath]
forall a. [a] -> [a] -> [a]
++ [Attributes -> FilePath
sval Attributes
a])

ident :: Parser a Token Ident
ident :: Parser a Token Ident
ident = (\ sp :: Span
sp t :: Attributes
t -> SpanInfo -> Ident -> Ident
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo (Span -> SpanInfo
fromSrcSpanBoth Span
sp) (FilePath -> Ident
mkIdent (Attributes -> FilePath
sval Attributes
t)))
          (Span -> Attributes -> Ident)
-> Parser a Token Span -> Parser a Token (Attributes -> Ident)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Attributes -> Ident)
-> Parser a Token Attributes -> Parser a Token Ident
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Category] -> Parser a Token Attributes
forall a. [Category] -> Parser a Token Attributes
tokens [Category
Id,Category
Id_as,Category
Id_ccall,Category
Id_forall,Category
Id_hiding,
                                       Category
Id_interface,Category
Id_primitive,Category
Id_qualified]

qIdent :: Parser a Token QualIdent
qIdent :: Parser a Token QualIdent
qIdent = Ident -> QualIdent
qualify (Ident -> QualIdent)
-> Parser a Token Ident -> Parser a Token QualIdent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
ident Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Category -> Parser a Token QualIdent
forall a. Category -> Parser a Token QualIdent
qIdentWith Category
QId

sym :: Parser a Token Ident
sym :: Parser a Token Ident
sym = (\ sp :: Span
sp t :: Attributes
t -> SpanInfo -> Ident -> Ident
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo (Span -> SpanInfo
fromSrcSpanBoth Span
sp) (FilePath -> Ident
mkIdent (Attributes -> FilePath
sval Attributes
t)))
        (Span -> Attributes -> Ident)
-> Parser a Token Span -> Parser a Token (Attributes -> Ident)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Attributes -> Ident)
-> Parser a Token Attributes -> Parser a Token Ident
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Category] -> Parser a Token Attributes
forall a. [Category] -> Parser a Token Attributes
tokens [Category
Sym, Category
SymDot, Category
SymMinus, Category
SymStar]

qSym :: Parser a Token QualIdent
qSym :: Parser a Token QualIdent
qSym = Ident -> QualIdent
qualify (Ident -> QualIdent)
-> Parser a Token Ident -> Parser a Token QualIdent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Ident
forall a. Parser a Token Ident
sym Parser a Token QualIdent
-> Parser a Token QualIdent -> Parser a Token QualIdent
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Category -> Parser a Token QualIdent
forall a. Category -> Parser a Token QualIdent
qIdentWith Category
QSym

qIdentWith :: Category -> Parser a Token QualIdent
qIdentWith :: Category -> Parser a Token QualIdent
qIdentWith c :: Category
c = Span -> Attributes -> QualIdent
mkQIdent (Span -> Attributes -> QualIdent)
-> Parser a Token Span -> Parser a Token (Attributes -> QualIdent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (Attributes -> QualIdent)
-> Parser a Token Attributes -> Parser a Token QualIdent
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
c
  where mkQIdent :: Span -> Attributes -> QualIdent
        mkQIdent :: Span -> Attributes -> QualIdent
mkQIdent sp :: Span
sp a :: Attributes
a =
          let mid :: ModuleIdent
mid  = SpanInfo -> [FilePath] -> ModuleIdent
ModuleIdent (Span -> SpanInfo
fromSrcSpan Span
sp) (Attributes -> [FilePath]
modulVal Attributes
a)
              p :: Position
p    = Position -> Arity -> Position
incr (Span -> Position
forall a. HasPosition a => a -> Position
getPosition Span
sp) (ModuleIdent -> Arity
mIdentLength ModuleIdent
mid Arity -> Arity -> Arity
forall a. Num a => a -> a -> a
- 1)
              mid' :: ModuleIdent
mid' = Position -> ModuleIdent -> ModuleIdent
forall a. HasSpanInfo a => Position -> a -> a
setEndPosition Position
p ModuleIdent
mid
              idt :: Ident
idt  = Span -> Ident -> Ident
forall a. HasSpanInfo a => Span -> a -> a
setSrcSpan Span
sp (Ident -> Ident) -> Ident -> Ident
forall a b. (a -> b) -> a -> b
$ FilePath -> Ident
mkIdent (Attributes -> FilePath
sval Attributes
a)
              idt' :: Ident
idt' = Position -> Ident -> Ident
forall a. HasPosition a => Position -> a -> a
setPosition (Position -> Arity -> Position
incr Position
p 1) Ident
idt
          in SpanInfo -> Maybe ModuleIdent -> Ident -> QualIdent
QualIdent (Span -> SpanInfo
fromSrcSpanBoth Span
sp) (ModuleIdent -> Maybe ModuleIdent
forall a. a -> Maybe a
Just ModuleIdent
mid') Ident
idt'

colon :: Parser a Token QualIdent
colon :: Parser a Token QualIdent
colon = Ident -> QualIdent
qualify (Ident -> QualIdent) -> (Span -> Ident) -> Span -> QualIdent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SpanInfo -> Ident -> Ident
forall a. HasSpanInfo a => SpanInfo -> a -> a
`setSpanInfo` Ident
consId) (SpanInfo -> Ident) -> (Span -> SpanInfo) -> Span -> Ident
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Span -> SpanInfo
fromSrcSpanBoth (Span -> QualIdent)
-> Parser a Token Span -> Parser a Token QualIdent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Colon

minus :: Parser a Token Ident
minus :: Parser a Token Ident
minus = (SpanInfo -> Ident -> Ident
forall a. HasSpanInfo a => SpanInfo -> a -> a
`setSpanInfo` Ident
minusId) (SpanInfo -> Ident) -> (Span -> SpanInfo) -> Span -> Ident
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Span -> SpanInfo
fromSrcSpanBoth (Span -> Ident) -> Parser a Token Span -> Parser a Token Ident
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
SymMinus

tupleCommas :: Parser a Token QualIdent
tupleCommas :: Parser a Token QualIdent
tupleCommas = (\ sp :: Span
sp ss :: [Span]
ss -> Ident -> QualIdent
qualify (Ident -> QualIdent) -> Ident -> QualIdent
forall a b. (a -> b) -> a -> b
$ Ident -> Ident
forall a. HasSpanInfo a => a -> a
updateEndPos (Ident -> Ident) -> Ident -> Ident
forall a b. (a -> b) -> a -> b
$ SpanInfo -> Ident -> Ident
forall a. HasSpanInfo a => SpanInfo -> a -> a
setSpanInfo (Span -> [Span] -> SpanInfo
spanInfo Span
sp [Span]
ss)
                                  (Ident -> Ident) -> Ident -> Ident
forall a b. (a -> b) -> a -> b
$ Arity -> Ident
tupleId      (Arity -> Ident) -> Arity -> Ident
forall a b. (a -> b) -> a -> b
$ Arity -> Arity
forall a. Enum a => a -> a
succ (Arity -> Arity) -> Arity -> Arity
forall a b. (a -> b) -> a -> b
$ [Span] -> Arity
forall (t :: * -> *) a. Foldable t => t a -> Arity
length  [Span]
ss)
              (Span -> [Span] -> QualIdent)
-> Parser a Token Span -> Parser a Token ([Span] -> QualIdent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token ([Span] -> QualIdent)
-> Parser a Token [Span] -> Parser a Token QualIdent
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span -> Parser a Token [Span]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many1 (Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Comma)

-- ---------------------------------------------------------------------------
-- Layout
-- ---------------------------------------------------------------------------

-- |This function starts a new layout block but does not wait for its end.
-- This is only used for parsing the module header.
startLayout :: Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
startLayout :: Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
startLayout p :: Parser a Token (b, [Span])
p =  Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOff Parser a Token Any
-> Parser a Token (b, LayoutInfo) -> Parser a Token (b, LayoutInfo)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*>
                   (Span -> (b, [Span]) -> (b, LayoutInfo)
forall b. Span -> (b, [Span]) -> (b, LayoutInfo)
createExpli1Layout (Span -> (b, [Span]) -> (b, LayoutInfo))
-> Parser a Token Span
-> Parser a Token ((b, [Span]) -> (b, LayoutInfo))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftBrace Parser a Token ((b, [Span]) -> (b, LayoutInfo))
-> Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token (b, [Span])
p)
             Parser a Token (b, LayoutInfo)
-> Parser a Token (b, LayoutInfo) -> Parser a Token (b, LayoutInfo)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOn  Parser a Token Any
-> Parser a Token (b, LayoutInfo) -> Parser a Token (b, LayoutInfo)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*>
                   ((b, [Span]) -> (b, LayoutInfo)
forall b. (b, [Span]) -> (b, LayoutInfo)
createWhiteLayout  ((b, [Span]) -> (b, LayoutInfo))
-> Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token (b, [Span])
p)

layout :: Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
layout :: Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
layout p :: Parser a Token (b, [Span])
p =  (((b, [Span]), Span, Span) -> (b, LayoutInfo)
forall b. ((b, [Span]), Span, Span) -> (b, LayoutInfo)
createExpliLayout
              (((b, [Span]), Span, Span) -> (b, LayoutInfo))
-> Parser a Token ((b, [Span]), Span, Span)
-> Parser a Token (b, LayoutInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOff Parser a Token Any
-> Parser a Token ((b, [Span]), Span, Span)
-> Parser a Token ((b, [Span]), Span, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token (b, [Span])
-> Parser a Token ((b, [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp Parser a Token (b, [Span])
p))
        Parser a Token (b, LayoutInfo)
-> Parser a Token (b, LayoutInfo) -> Parser a Token (b, LayoutInfo)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> ((b, [Span]) -> (b, LayoutInfo)
forall b. (b, [Span]) -> (b, LayoutInfo)
createWhiteLayout
              ((b, [Span]) -> (b, LayoutInfo))
-> Parser a Token (b, [Span]) -> Parser a Token (b, LayoutInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOn  Parser a Token Any
-> Parser a Token (b, [Span]) -> Parser a Token (b, [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token (b, [Span])
p Parser a Token (b, [Span])
-> Parser a Token Attributes -> Parser a Token (b, [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> (Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
VRightBrace Parser a Token Attributes
-> Parser a Token Attributes -> Parser a Token Attributes
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token Attributes
forall s a b. Symbol s => Parser a s b
layoutEnd)))

createExpli1Layout :: Span -> (b, [Span]) -> (b, LayoutInfo)
createExpli1Layout :: Span -> (b, [Span]) -> (b, LayoutInfo)
createExpli1Layout sp1 :: Span
sp1 (b :: b
b, ss :: [Span]
ss) = (b
b, [Span] -> LayoutInfo
ExplicitLayout (Span
sp1Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
:[Span]
ss))

createExpliLayout :: ((b, [Span]), Span, Span) -> (b, LayoutInfo)
createExpliLayout :: ((b, [Span]), Span, Span) -> (b, LayoutInfo)
createExpliLayout ((b :: b
b, ss :: [Span]
ss), sp1 :: Span
sp1, spe :: Span
spe) = (b
b, [Span] -> LayoutInfo
ExplicitLayout (Span
sp1Span -> [Span] -> [Span]
forall a. a -> [a] -> [a]
:[Span]
ss [Span] -> [Span] -> [Span]
forall a. [a] -> [a] -> [a]
++ [Span
spe]))

createWhiteLayout :: (b, [Span]) -> (b, LayoutInfo)
createWhiteLayout :: (b, [Span]) -> (b, LayoutInfo)
createWhiteLayout (b :: b
b, _) = (b
b, LayoutInfo
WhitespaceLayout)

-- We have to remove an additional context on an empty where-clause
layoutWhere :: Parser a Token b -> Parser a Token ([b], LayoutInfo)
layoutWhere :: Parser a Token b -> Parser a Token ([b], LayoutInfo)
layoutWhere p :: Parser a Token b
p =  ((([b], [Span]), Span, Span) -> ([b], LayoutInfo)
forall b. ((b, [Span]), Span, Span) -> (b, LayoutInfo)
createExpliLayout
                    ((([b], [Span]), Span, Span) -> ([b], LayoutInfo))
-> Parser a Token (([b], [Span]), Span, Span)
-> Parser a Token ([b], LayoutInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOff Parser a Token Any
-> Parser a Token (([b], [Span]), Span, Span)
-> Parser a Token (([b], [Span]), Span, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ([b], [Span])
-> Parser a Token (([b], [Span]), Span, Span)
forall a b. Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp (Parser a Token b
p Parser a Token b
-> Parser a Token Attributes -> Parser a Token ([b], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBySp` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon)))
             Parser a Token ([b], LayoutInfo)
-> Parser a Token ([b], LayoutInfo)
-> Parser a Token ([b], LayoutInfo)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (([b], [Span]) -> ([b], LayoutInfo)
forall b. (b, [Span]) -> (b, LayoutInfo)
createWhiteLayout
                    (([b], [Span]) -> ([b], LayoutInfo))
-> Parser a Token ([b], [Span]) -> Parser a Token ([b], LayoutInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser a Token Any
forall s a b. Symbol s => Parser a s b
layoutOn  Parser a Token Any
-> Parser a Token ([b], [Span]) -> Parser a Token ([b], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> (Parser a Token b
p Parser a Token b
-> Parser a Token Attributes -> Parser a Token ([b], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s ([b], [Span])
`sepBy1Sp` Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon)
                                   Parser a Token ([b], [Span])
-> Parser a Token Attributes -> Parser a Token ([b], [Span])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> (Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
VRightBrace Parser a Token Attributes
-> Parser a Token Attributes -> Parser a Token Attributes
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Parser a Token Attributes
forall s a b. Symbol s => Parser a s b
layoutEnd)))
             Parser a Token ([b], LayoutInfo)
-> Parser a Token ([b], LayoutInfo)
-> Parser a Token ([b], LayoutInfo)
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> ([b], LayoutInfo) -> Parser a Token ([b], LayoutInfo)
forall b a s. b -> Parser a s b
succeed ([], LayoutInfo
WhitespaceLayout)

-- ---------------------------------------------------------------------------
-- Bracket combinators
-- ---------------------------------------------------------------------------

braces :: Parser a Token b -> Parser a Token b
braces :: Parser a Token b -> Parser a Token b
braces p :: Parser a Token b
p = Parser a Token Attributes
-> Parser a Token b
-> Parser a Token Attributes
-> Parser a Token b
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b -> Parser a s c
between Parser a Token Attributes
forall a. Parser a Token Attributes
leftBrace Parser a Token b
p Parser a Token Attributes
forall a. Parser a Token Attributes
rightBrace

bracesSp :: Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp :: Parser a Token b -> Parser a Token (b, Span, Span)
bracesSp p :: Parser a Token b
p = (\sp1 :: Span
sp1 b :: b
b sp2 :: Span
sp2 -> (b
b, Span
sp1, Span
sp2))
               (Span -> b -> Span -> (b, Span, Span))
-> Parser a Token Span
-> Parser a Token (b -> Span -> (b, Span, Span))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftBrace
               Parser a Token (b -> Span -> (b, Span, Span))
-> Parser a Token b -> Parser a Token (Span -> (b, Span, Span))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token b
p
               Parser a Token (Span -> (b, Span, Span))
-> Parser a Token Span -> Parser a Token (b, Span, Span)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightBrace

bracketsSp :: Parser a Token b -> Parser a Token (b, Span, Span)
bracketsSp :: Parser a Token b -> Parser a Token (b, Span, Span)
bracketsSp p :: Parser a Token b
p = (\sp1 :: Span
sp1 b :: b
b sp2 :: Span
sp2 -> (b
b, Span
sp1, Span
sp2))
                 (Span -> b -> Span -> (b, Span, Span))
-> Parser a Token Span
-> Parser a Token (b -> Span -> (b, Span, Span))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftBracket
                 Parser a Token (b -> Span -> (b, Span, Span))
-> Parser a Token b -> Parser a Token (Span -> (b, Span, Span))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token b
p
                 Parser a Token (Span -> (b, Span, Span))
-> Parser a Token Span -> Parser a Token (b, Span, Span)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightBracket

parens :: Parser a Token b -> Parser a Token b
parens :: Parser a Token b -> Parser a Token b
parens p :: Parser a Token b
p = Parser a Token Attributes
-> Parser a Token b
-> Parser a Token Attributes
-> Parser a Token b
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b -> Parser a s c
between Parser a Token Attributes
forall a. Parser a Token Attributes
leftParen Parser a Token b
p Parser a Token Attributes
forall a. Parser a Token Attributes
rightParen

parensSp :: Parser a Token b -> Parser a Token (b, Span, Span)
parensSp :: Parser a Token b -> Parser a Token (b, Span, Span)
parensSp p :: Parser a Token b
p = (\sp1 :: Span
sp1 b :: b
b sp2 :: Span
sp2 -> (b
b, Span
sp1, Span
sp2))
               (Span -> b -> Span -> (b, Span, Span))
-> Parser a Token Span
-> Parser a Token (b -> Span -> (b, Span, Span))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
LeftParen
               Parser a Token (b -> Span -> (b, Span, Span))
-> Parser a Token b -> Parser a Token (Span -> (b, Span, Span))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token b
p
               Parser a Token (Span -> (b, Span, Span))
-> Parser a Token Span -> Parser a Token (b, Span, Span)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
RightParen

backquotesSp :: Parser a Token b -> Parser a Token (b, Span, Span)
backquotesSp :: Parser a Token b -> Parser a Token (b, Span, Span)
backquotesSp p :: Parser a Token b
p = (\sp1 :: Span
sp1 b :: b
b sp2 :: Span
sp2 -> (b
b, Span
sp1, Span
sp2))
                   (Span -> b -> Span -> (b, Span, Span))
-> Parser a Token Span
-> Parser a Token (b -> Span -> (b, Span, Span))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Category -> Parser a Token Span
forall a. Category -> Parser a Token Span
tokenSpan Category
Backquote
                   Parser a Token (b -> Span -> (b, Span, Span))
-> Parser a Token b -> Parser a Token (Span -> (b, Span, Span))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token b
p
                   Parser a Token (Span -> (b, Span, Span))
-> Parser a Token Span -> Parser a Token (b, Span, Span)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token (b, Span, Span)
-> Parser a Token Attributes -> Parser a Token (b, Span, Span)
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes
forall a. Parser a Token Attributes
expectBackquote

-- ---------------------------------------------------------------------------
-- Simple token parsers
-- ---------------------------------------------------------------------------

token :: Category -> Parser a Token Attributes
token :: Category -> Parser a Token Attributes
token c :: Category
c = Token -> Attributes
attr (Token -> Attributes)
-> Parser a Token Token -> Parser a Token Attributes
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser a Token Token
forall s a. s -> Parser a s s
symbol (Category -> Attributes -> Token
Token Category
c Attributes
NoAttributes)
  where attr :: Token -> Attributes
attr (Token _ a :: Attributes
a) = Attributes
a

tokens :: [Category] -> Parser a Token Attributes
tokens :: [Category] -> Parser a Token Attributes
tokens = (Parser a Token Attributes
 -> Parser a Token Attributes -> Parser a Token Attributes)
-> [Parser a Token Attributes] -> Parser a Token Attributes
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 Parser a Token Attributes
-> Parser a Token Attributes -> Parser a Token Attributes
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
(<|>) ([Parser a Token Attributes] -> Parser a Token Attributes)
-> ([Category] -> [Parser a Token Attributes])
-> [Category]
-> Parser a Token Attributes
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Category -> Parser a Token Attributes)
-> [Category] -> [Parser a Token Attributes]
forall a b. (a -> b) -> [a] -> [b]
map Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token

tokenPos :: Category -> Parser a Token Position
tokenPos :: Category -> Parser a Token Position
tokenPos c :: Category
c = Parser a Token Position
forall a s. Parser a s Position
position Parser a Token Position
-> Parser a Token Attributes -> Parser a Token Position
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
c

tokenSpan :: Category -> Parser a Token Span
tokenSpan :: Category -> Parser a Token Span
tokenSpan c :: Category
c = Parser a Token Span
forall s a. Symbol s => Parser a s Span
spanPosition Parser a Token Span
-> Parser a Token Attributes -> Parser a Token Span
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
c

tokenOps :: [(Category, b)] -> Parser a Token b
tokenOps :: [(Category, b)] -> Parser a Token b
tokenOps cs :: [(Category, b)]
cs = [(Token, b)] -> Parser a Token b
forall s b a. Symbol s => [(s, b)] -> Parser a s b
ops [(Category -> Attributes -> Token
Token Category
c Attributes
NoAttributes, b
x) | (c :: Category
c, x :: b
x) <- [(Category, b)]
cs]

comma :: Parser a Token Attributes
comma :: Parser a Token Attributes
comma = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Comma

semicolon :: Parser a Token Attributes
semicolon :: Parser a Token Attributes
semicolon = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Semicolon Parser a Token Attributes
-> Parser a Token Attributes -> Parser a Token Attributes
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
VSemicolon

bar :: Parser a Token Attributes
bar :: Parser a Token Attributes
bar = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Bar

equals :: Parser a Token Attributes
equals :: Parser a Token Attributes
equals = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Equals

expectEquals :: Parser a Token Attributes
expectEquals :: Parser a Token Attributes
expectEquals = Parser a Token Attributes
forall a. Parser a Token Attributes
equals Parser a Token Attributes -> FilePath -> Parser a Token Attributes
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "= expected"

expectWhere :: Parser a Token Attributes
expectWhere :: Parser a Token Attributes
expectWhere = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
KW_where Parser a Token Attributes -> FilePath -> Parser a Token Attributes
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "where expected"

expectRightArrow :: Parser a Token Attributes
expectRightArrow :: Parser a Token Attributes
expectRightArrow  = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
RightArrow Parser a Token Attributes -> FilePath -> Parser a Token Attributes
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "-> expected"

backquote :: Parser a Token Attributes
backquote :: Parser a Token Attributes
backquote = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
Backquote

expectBackquote :: Parser a Token Attributes
expectBackquote :: Parser a Token Attributes
expectBackquote = Parser a Token Attributes
forall a. Parser a Token Attributes
backquote Parser a Token Attributes -> FilePath -> Parser a Token Attributes
forall s a b. Symbol s => Parser a s b -> FilePath -> Parser a s b
<?> "backquote (`) expected"

leftParen :: Parser a Token Attributes
leftParen :: Parser a Token Attributes
leftParen = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
LeftParen

rightParen :: Parser a Token Attributes
rightParen :: Parser a Token Attributes
rightParen = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
RightParen

leftBrace :: Parser a Token Attributes
leftBrace :: Parser a Token Attributes
leftBrace = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
LeftBrace

rightBrace :: Parser a Token Attributes
rightBrace :: Parser a Token Attributes
rightBrace = Category -> Parser a Token Attributes
forall a. Category -> Parser a Token Attributes
token Category
RightBrace