{- |
    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 (([ImportDecl] -> [Decl ()] -> Module ())
-> ([ImportDecl], [Decl ()]) -> Module ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (([ImportDecl] -> [Decl ()] -> Module ())
 -> ([ImportDecl], [Decl ()]) -> Module ())
-> Parser
     (Module ()) Token ([ImportDecl] -> [Decl ()] -> Module ())
-> Parser
     (Module ()) Token (([ImportDecl], [Decl ()]) -> Module ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Module ()) Token ([ImportDecl] -> [Decl ()] -> Module ())
forall a b. Parser a Token ([ImportDecl] -> [Decl b] -> Module b)
moduleHeader Parser (Module ()) Token (([ImportDecl], [Decl ()]) -> Module ())
-> Parser (Module ()) Token ([ImportDecl], [Decl ()])
-> Parser (Module ()) Token (Module ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Module ()) Token ([ImportDecl], [Decl ()])
-> Parser (Module ()) Token ([ImportDecl], [Decl ()])
forall a b. Parser a Token b -> Parser a Token b
layout Parser (Module ()) Token ([ImportDecl], [Decl ()])
forall a. Parser a Token ([ImportDecl], [Decl ()])
moduleDecls) Lexer Token (Module ())
forall a. Lexer Token a
lexer

-- TODO position on prefix parsers?
-- |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
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl ()]
-> Module ()
forall a.
SpanInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl a]
-> Module a
Module (Span -> [Span] -> SpanInfo
SpanInfo Span
sp []) [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 (Parser (Module ()) Token ([ImportDecl] -> [Decl ()] -> Module ())
forall a b. Parser a Token ([ImportDecl] -> [Decl b] -> Module b)
moduleHeader Parser (Module ()) Token ([ImportDecl] -> [Decl ()] -> Module ())
-> Parser (Module ()) Token [ImportDecl]
-> Parser (Module ()) Token ([Decl ()] -> Module ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Module ()) Token [ImportDecl]
-> Parser (Module ()) Token [ImportDecl]
forall a b. Parser a Token b -> Parser a Token b
startLayout Parser (Module ()) Token [ImportDecl]
forall a. Parser a Token [ImportDecl]
importDecls Parser (Module ()) Token ([Decl ()] -> Module ())
-> Parser (Module ()) Token [Decl ()]
-> Parser (Module ()) Token (Module ())
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Decl ()] -> Parser (Module ()) Token [Decl ()]
forall b a s. b -> Parser a s b
succeed []) Lexer Token (Module ())
forall a. Lexer Token a
lexer
  where importDecls :: Parser a Token [ImportDecl]
importDecls = Parser a Token ImportDecl -> Parser a Token [ImportDecl]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many (Parser a Token ImportDecl
forall a. Parser a Token ImportDecl
importDecl Parser a Token ImportDecl
-> Parser a Token [Attributes] -> Parser a Token ImportDecl
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s b
<*-> Parser a Token Attributes -> Parser a Token [Attributes]
forall s a b. Symbol s => Parser a s b -> Parser a s [b]
many Parser a Token Attributes
forall a. Parser a Token Attributes
semicolon)

-- |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 ([ImportDecl] -> [Decl b] -> Module b)
moduleHeader :: Parser a Token ([ImportDecl] -> [Decl b] -> Module b)
moduleHeader =
  (\sp :: Span
sp ps :: [ModulePragma]
ps (m :: ModuleIdent
m, es :: Maybe ExportSpec
es, inf :: [Span]
inf) is :: [ImportDecl]
is ds :: [Decl b]
ds -> Module b -> Module b
forall a. HasSpanInfo a => a -> a
updateEndPos
      (SpanInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl b]
-> Module b
forall a.
SpanInfo
-> [ModulePragma]
-> ModuleIdent
-> Maybe ExportSpec
-> [ImportDecl]
-> [Decl a]
-> Module a
Module (Span -> [Span] -> SpanInfo
SpanInfo Span
sp [Span]
inf) [ModulePragma]
ps ModuleIdent
m Maybe ExportSpec
es [ImportDecl]
is [Decl b]
ds))
    (Span
 -> [ModulePragma]
 -> (ModuleIdent, Maybe ExportSpec, [Span])
 -> [ImportDecl]
 -> [Decl b]
 -> Module b)
-> Parser a Token Span
-> Parser
     a
     Token
     ([ModulePragma]
      -> (ModuleIdent, Maybe ExportSpec, [Span])
      -> [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])
   -> [ImportDecl]
   -> [Decl b]
   -> Module b)
-> Parser a Token [ModulePragma]
-> Parser
     a
     Token
     ((ModuleIdent, Maybe ExportSpec, [Span])
      -> [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])
   -> [ImportDecl] -> [Decl b] -> Module b)
-> Parser a Token (ModuleIdent, Maybe ExportSpec, [Span])
-> Parser a Token ([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 ()])
moduleDecls :: Parser a Token ([ImportDecl], [Decl ()])
moduleDecls = ImportDecl
-> ([ImportDecl], [Decl ()]) -> ([ImportDecl], [Decl ()])
forall a b. a -> ([a], b) -> ([a], b)
impDecl (ImportDecl
 -> ([ImportDecl], [Decl ()]) -> ([ImportDecl], [Decl ()]))
-> Parser a Token ImportDecl
-> Parser
     a Token (([ImportDecl], [Decl ()]) -> ([ImportDecl], [Decl ()]))
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 ()]) -> ([ImportDecl], [Decl ()]))
-> Parser a Token ([ImportDecl], [Decl ()])
-> Parser a Token ([ImportDecl], [Decl ()])
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 ([ImportDecl], [Decl ()])
-> Parser a Token ([ImportDecl], [Decl ()])
forall s a b c.
Symbol s =>
Parser a s b -> Parser a s c -> Parser a s c
<-*> Parser a Token ([ImportDecl], [Decl ()])
forall a. Parser a Token ([ImportDecl], [Decl ()])
moduleDecls Parser a Token ([ImportDecl], [Decl ()])
-> ([ImportDecl], [Decl ()])
-> Parser a Token ([ImportDecl], [Decl ()])
forall s a b. Symbol s => Parser a s b -> b -> Parser a s b
`opt` ([], []))
          Parser a Token ([ImportDecl], [Decl ()])
-> Parser a Token ([ImportDecl], [Decl ()])
-> Parser a Token ([ImportDecl], [Decl ()])
forall s a b.
Symbol s =>
Parser a s b -> Parser a s b -> Parser a s b
<|> (,) []  ([Decl ()] -> ([ImportDecl], [Decl ()]))
-> Parser a Token [Decl ()]
-> Parser a Token ([ImportDecl], [Decl ()])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a Token [Decl ()]
forall a. Parser a Token [Decl ()]
topDecls
  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 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 ()]
topDecls :: Parser a Token [Decl ()]
topDecls = Parser a Token (Decl ())
forall a. Parser a Token (Decl ())
topDecl Parser a Token (Decl ())
-> Parser a Token Attributes -> Parser a Token [Decl ()]
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

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
<$>