{- -----------------------------------------------------------------------------
Copyright 2019 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# LANGUAGE FlexibleInstances #-}

module Parser.TypeCategory (
  parseFilters,
  parseScope,
  parseScopedFunction,
  singleDefine,
  singleFilter,
  singleRefine,
) where

import Base.Positional
import Parser.Common
import Parser.TextParser
import Parser.TypeInstance ()
import Types.TypeCategory
import Types.TypeInstance
import Types.Variance


instance ParseFromSource (AnyCategory SourceContext) where
  sourceParser :: TextParser (AnyCategory SourceContext)
sourceParser = TextParser (AnyCategory SourceContext)
parseValue TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser (AnyCategory SourceContext)
parseInstance TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser (AnyCategory SourceContext)
parseConcrete where
    open :: TextParser ()
open = TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (String -> TextParser ()
string_ String
"{")
    close :: TextParser ()
close = TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (String -> TextParser ()
string_ String
"}")
    parseValue :: TextParser (AnyCategory SourceContext)
parseValue = String
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall a. String -> TextParser a -> TextParser a
labeled String
"value interface" (TextParser (AnyCategory SourceContext)
 -> TextParser (AnyCategory SourceContext))
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall a b. (a -> b) -> a -> b
$ do
      SourceContext
c <- TextParser SourceContext
getSourceContext
      TextParser () -> TextParser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ TextParser ()
kwValue TextParser () -> TextParser () -> TextParser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TextParser ()
kwInterface
      CategoryName
n <- TextParser CategoryName
forall a. ParseFromSource a => TextParser a
sourceParser
      [ValueParam SourceContext]
ps <- TextParser [ValueParam SourceContext]
parseCategoryParams
      TextParser ()
open
      ([ValueRefine SourceContext]
rs,[ParamFilter SourceContext]
vs) <- TextParser
  ([ValueRefine SourceContext], [ParamFilter SourceContext])
parseRefinesFilters
      [ScopedFunction SourceContext]
fs <- (ParsecT
   CompilerMessage String Identity (ScopedFunction SourceContext)
 -> TextParser ()
 -> ParsecT
      CompilerMessage String Identity [ScopedFunction SourceContext])
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall a b c. (a -> b -> c) -> b -> a -> c
flip ParsecT
  CompilerMessage String Identity (ScopedFunction SourceContext)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy TextParser ()
optionalSpace (ParsecT
   CompilerMessage String Identity (ScopedFunction SourceContext)
 -> ParsecT
      CompilerMessage String Identity [ScopedFunction SourceContext])
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall a b. (a -> b) -> a -> b
$ TextParser SymbolScope
-> TextParser CategoryName
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
parseScopedFunction (SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a. Monad m => a -> m a
return SymbolScope
ValueScope) (CategoryName -> TextParser CategoryName
forall (m :: * -> *) a. Monad m => a -> m a
return CategoryName
n)
      TextParser ()
close
      AnyCategory SourceContext -> TextParser (AnyCategory SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnyCategory SourceContext
 -> TextParser (AnyCategory SourceContext))
-> AnyCategory SourceContext
-> TextParser (AnyCategory SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext]
-> Namespace
-> CategoryName
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ParamFilter SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [ValueParam c]
-> [ValueRefine c]
-> [ParamFilter c]
-> [ScopedFunction c]
-> AnyCategory c
ValueInterface [SourceContext
c] Namespace
NoNamespace CategoryName
n [ValueParam SourceContext]
ps [ValueRefine SourceContext]
rs [ParamFilter SourceContext]
vs [ScopedFunction SourceContext]
fs
    parseInstance :: TextParser (AnyCategory SourceContext)
parseInstance = String
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall a. String -> TextParser a -> TextParser a
labeled String
"type interface" (TextParser (AnyCategory SourceContext)
 -> TextParser (AnyCategory SourceContext))
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall a b. (a -> b) -> a -> b
$ do
      SourceContext
c <- TextParser SourceContext
getSourceContext
      TextParser () -> TextParser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ TextParser ()
kwType TextParser () -> TextParser () -> TextParser ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TextParser ()
kwInterface
      CategoryName
n <- TextParser CategoryName
forall a. ParseFromSource a => TextParser a
sourceParser
      [ValueParam SourceContext]
ps <- TextParser [ValueParam SourceContext]
parseCategoryParams
      TextParser ()
open
      [ParamFilter SourceContext]
vs <- TextParser [ParamFilter SourceContext]
parseFilters
      [ScopedFunction SourceContext]
fs <- (ParsecT
   CompilerMessage String Identity (ScopedFunction SourceContext)
 -> TextParser ()
 -> ParsecT
      CompilerMessage String Identity [ScopedFunction SourceContext])
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall a b c. (a -> b -> c) -> b -> a -> c
flip ParsecT
  CompilerMessage String Identity (ScopedFunction SourceContext)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy TextParser ()
optionalSpace (ParsecT
   CompilerMessage String Identity (ScopedFunction SourceContext)
 -> ParsecT
      CompilerMessage String Identity [ScopedFunction SourceContext])
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall a b. (a -> b) -> a -> b
$ TextParser SymbolScope
-> TextParser CategoryName
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
parseScopedFunction (SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a. Monad m => a -> m a
return SymbolScope
TypeScope) (CategoryName -> TextParser CategoryName
forall (m :: * -> *) a. Monad m => a -> m a
return CategoryName
n)
      TextParser ()
close
      AnyCategory SourceContext -> TextParser (AnyCategory SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnyCategory SourceContext
 -> TextParser (AnyCategory SourceContext))
-> AnyCategory SourceContext
-> TextParser (AnyCategory SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext]
-> Namespace
-> CategoryName
-> [ValueParam SourceContext]
-> [ParamFilter SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [ValueParam c]
-> [ParamFilter c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [SourceContext
c] Namespace
NoNamespace CategoryName
n [ValueParam SourceContext]
ps [ParamFilter SourceContext]
vs [ScopedFunction SourceContext]
fs
    parseConcrete :: TextParser (AnyCategory SourceContext)
parseConcrete = String
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall a. String -> TextParser a -> TextParser a
labeled String
"concrete type" (TextParser (AnyCategory SourceContext)
 -> TextParser (AnyCategory SourceContext))
-> TextParser (AnyCategory SourceContext)
-> TextParser (AnyCategory SourceContext)
forall a b. (a -> b) -> a -> b
$ do
      SourceContext
c <- TextParser SourceContext
getSourceContext
      TextParser ()
kwConcrete
      CategoryName
n <- TextParser CategoryName
forall a. ParseFromSource a => TextParser a
sourceParser
      [ValueParam SourceContext]
ps <- TextParser [ValueParam SourceContext]
parseCategoryParams
      TextParser ()
open
      ([ValueRefine SourceContext]
rs,[ValueDefine SourceContext]
ds,[ParamFilter SourceContext]
vs) <- TextParser
  ([ValueRefine SourceContext], [ValueDefine SourceContext],
   [ParamFilter SourceContext])
parseRefinesDefinesFilters
      [ScopedFunction SourceContext]
fs <- (ParsecT
   CompilerMessage String Identity (ScopedFunction SourceContext)
 -> TextParser ()
 -> ParsecT
      CompilerMessage String Identity [ScopedFunction SourceContext])
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall a b c. (a -> b -> c) -> b -> a -> c
flip ParsecT
  CompilerMessage String Identity (ScopedFunction SourceContext)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy TextParser ()
optionalSpace (ParsecT
   CompilerMessage String Identity (ScopedFunction SourceContext)
 -> ParsecT
      CompilerMessage String Identity [ScopedFunction SourceContext])
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity [ScopedFunction SourceContext]
forall a b. (a -> b) -> a -> b
$ TextParser SymbolScope
-> TextParser CategoryName
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
parseScopedFunction TextParser SymbolScope
parseScope (CategoryName -> TextParser CategoryName
forall (m :: * -> *) a. Monad m => a -> m a
return CategoryName
n)
      TextParser ()
close
      AnyCategory SourceContext -> TextParser (AnyCategory SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (AnyCategory SourceContext
 -> TextParser (AnyCategory SourceContext))
-> AnyCategory SourceContext
-> TextParser (AnyCategory SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext]
-> Namespace
-> CategoryName
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ValueDefine SourceContext]
-> [ParamFilter SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [ValueParam c]
-> [ValueRefine c]
-> [ValueDefine c]
-> [ParamFilter c]
-> [ScopedFunction c]
-> AnyCategory c
ValueConcrete [SourceContext
c] Namespace
NoNamespace CategoryName
n [ValueParam SourceContext]
ps [ValueRefine SourceContext]
rs [ValueDefine SourceContext]
ds [ParamFilter SourceContext]
vs [ScopedFunction SourceContext]
fs

parseCategoryParams :: TextParser [ValueParam SourceContext]
parseCategoryParams :: TextParser [ValueParam SourceContext]
parseCategoryParams = do
  ([(SourceContext, ParamName)]
con,[(SourceContext, ParamName)]
inv,[(SourceContext, ParamName)]
cov) <- ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
forall a a a.
ParsecT CompilerMessage String Identity ([a], [a], [a])
none ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
forall a a.
ParsecT
  CompilerMessage
  String
  Identity
  ([a], [(SourceContext, ParamName)], [a])
fixedOnly ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
forall a.
ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [a], [(SourceContext, ParamName)])
noFixed ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
explicitFixed
  [ValueParam SourceContext] -> TextParser [ValueParam SourceContext]
forall (m :: * -> *) a. Monad m => a -> m a
return ([ValueParam SourceContext]
 -> TextParser [ValueParam SourceContext])
-> [ValueParam SourceContext]
-> TextParser [ValueParam SourceContext]
forall a b. (a -> b) -> a -> b
$ ((SourceContext, ParamName) -> ValueParam SourceContext)
-> [(SourceContext, ParamName)] -> [ValueParam SourceContext]
forall a b. (a -> b) -> [a] -> [b]
map (Variance -> (SourceContext, ParamName) -> ValueParam SourceContext
forall c. Variance -> (c, ParamName) -> ValueParam c
apply Variance
Contravariant) [(SourceContext, ParamName)]
con [ValueParam SourceContext]
-> [ValueParam SourceContext] -> [ValueParam SourceContext]
forall a. [a] -> [a] -> [a]
++
           ((SourceContext, ParamName) -> ValueParam SourceContext)
-> [(SourceContext, ParamName)] -> [ValueParam SourceContext]
forall a b. (a -> b) -> [a] -> [b]
map (Variance -> (SourceContext, ParamName) -> ValueParam SourceContext
forall c. Variance -> (c, ParamName) -> ValueParam c
apply Variance
Invariant) [(SourceContext, ParamName)]
inv [ValueParam SourceContext]
-> [ValueParam SourceContext] -> [ValueParam SourceContext]
forall a. [a] -> [a] -> [a]
++
           ((SourceContext, ParamName) -> ValueParam SourceContext)
-> [(SourceContext, ParamName)] -> [ValueParam SourceContext]
forall a b. (a -> b) -> [a] -> [b]
map (Variance -> (SourceContext, ParamName) -> ValueParam SourceContext
forall c. Variance -> (c, ParamName) -> ValueParam c
apply Variance
Covariant) [(SourceContext, ParamName)]
cov
  where
    none :: ParsecT CompilerMessage String Identity ([a], [a], [a])
none = do
      ParsecT CompilerMessage String Identity String -> TextParser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (Tokens String
-> ParsecT CompilerMessage String Identity (Tokens String)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string String
Tokens String
"<")
      ([a], [a], [a])
-> ParsecT CompilerMessage String Identity ([a], [a], [a])
forall (m :: * -> *) a. Monad m => a -> m a
return ([],[],[])
    fixedOnly :: ParsecT
  CompilerMessage
  String
  Identity
  ([a], [(SourceContext, ParamName)], [a])
fixedOnly = do -- T<a,b,c>
      [(SourceContext, ParamName)]
inv <- TextParser ()
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"<")
                     (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
">")
                     (ParsecT CompilerMessage String Identity (SourceContext, ParamName)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ParsecT CompilerMessage String Identity (SourceContext, ParamName)
singleParam (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
","))
      ([a], [(SourceContext, ParamName)], [a])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([a], [(SourceContext, ParamName)], [a])
forall (m :: * -> *) a. Monad m => a -> m a
return ([],[(SourceContext, ParamName)]
inv,[])
    noFixed :: ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [a], [(SourceContext, ParamName)])
noFixed = do -- T<a,b|c,d>
      [(SourceContext, ParamName)]
con <- TextParser ()
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"<")
                     (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"|")
                     (ParsecT CompilerMessage String Identity (SourceContext, ParamName)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ParsecT CompilerMessage String Identity (SourceContext, ParamName)
singleParam (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
","))
      [(SourceContext, ParamName)]
cov <- TextParser ()
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between TextParser ()
nullParse
                     (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
">")
                     (ParsecT CompilerMessage String Identity (SourceContext, ParamName)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ParsecT CompilerMessage String Identity (SourceContext, ParamName)
singleParam (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
","))
      ([(SourceContext, ParamName)], [a], [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [a], [(SourceContext, ParamName)])
forall (m :: * -> *) a. Monad m => a -> m a
return ([(SourceContext, ParamName)]
con,[],[(SourceContext, ParamName)]
cov)
    explicitFixed :: ParsecT
  CompilerMessage
  String
  Identity
  ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
   [(SourceContext, ParamName)])
explicitFixed = do -- T<a,b|c,d|e,f>
      [(SourceContext, ParamName)]
con <- TextParser ()
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"<")
                     (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"|")
                     (ParsecT CompilerMessage String Identity (SourceContext, ParamName)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ParsecT CompilerMessage String Identity (SourceContext, ParamName)
singleParam (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
","))
      [(SourceContext, ParamName)]
inv <- TextParser ()
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between TextParser ()
nullParse
                     (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"|")
                     (ParsecT CompilerMessage String Identity (SourceContext, ParamName)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ParsecT CompilerMessage String Identity (SourceContext, ParamName)
singleParam (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
","))
      [(SourceContext, ParamName)]
cov <- TextParser ()
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between TextParser ()
nullParse
                     (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
">")
                     (ParsecT CompilerMessage String Identity (SourceContext, ParamName)
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [(SourceContext, ParamName)]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ParsecT CompilerMessage String Identity (SourceContext, ParamName)
singleParam (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
","))
      ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
 [(SourceContext, ParamName)])
-> ParsecT
     CompilerMessage
     String
     Identity
     ([(SourceContext, ParamName)], [(SourceContext, ParamName)],
      [(SourceContext, ParamName)])
forall (m :: * -> *) a. Monad m => a -> m a
return ([(SourceContext, ParamName)]
con,[(SourceContext, ParamName)]
inv,[(SourceContext, ParamName)]
cov)
    singleParam :: ParsecT CompilerMessage String Identity (SourceContext, ParamName)
singleParam = String
-> ParsecT
     CompilerMessage String Identity (SourceContext, ParamName)
-> ParsecT
     CompilerMessage String Identity (SourceContext, ParamName)
forall a. String -> TextParser a -> TextParser a
labeled String
"param declaration" (ParsecT CompilerMessage String Identity (SourceContext, ParamName)
 -> ParsecT
      CompilerMessage String Identity (SourceContext, ParamName))
-> ParsecT
     CompilerMessage String Identity (SourceContext, ParamName)
-> ParsecT
     CompilerMessage String Identity (SourceContext, ParamName)
forall a b. (a -> b) -> a -> b
$ do
      TextParser ()
noParamSelf
      SourceContext
c <- TextParser SourceContext
getSourceContext
      ParamName
n <- TextParser ParamName
forall a. ParseFromSource a => TextParser a
sourceParser
      (SourceContext, ParamName)
-> ParsecT
     CompilerMessage String Identity (SourceContext, ParamName)
forall (m :: * -> *) a. Monad m => a -> m a
return (SourceContext
c,ParamName
n)
    apply :: Variance -> (c, ParamName) -> ValueParam c
apply Variance
v (c
c,ParamName
n) = [c] -> ParamName -> Variance -> ValueParam c
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [c
c] ParamName
n Variance
v

singleRefine :: TextParser (ValueRefine SourceContext)
singleRefine :: TextParser (ValueRefine SourceContext)
singleRefine = do
  SourceContext
c <- TextParser SourceContext
getSourceContext
  TextParser ()
kwRefines
  TypeInstance
t <- TextParser TypeInstance
forall a. ParseFromSource a => TextParser a
sourceParser
  ValueRefine SourceContext -> TextParser (ValueRefine SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (ValueRefine SourceContext
 -> TextParser (ValueRefine SourceContext))
-> ValueRefine SourceContext
-> TextParser (ValueRefine SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext] -> TypeInstance -> ValueRefine SourceContext
forall c. [c] -> TypeInstance -> ValueRefine c
ValueRefine [SourceContext
c] TypeInstance
t

singleDefine :: TextParser (ValueDefine SourceContext)
singleDefine :: TextParser (ValueDefine SourceContext)
singleDefine = do
  SourceContext
c <- TextParser SourceContext
getSourceContext
  TextParser ()
kwDefines
  DefinesInstance
t <- TextParser DefinesInstance
forall a. ParseFromSource a => TextParser a
sourceParser
  ValueDefine SourceContext -> TextParser (ValueDefine SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (ValueDefine SourceContext
 -> TextParser (ValueDefine SourceContext))
-> ValueDefine SourceContext
-> TextParser (ValueDefine SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext] -> DefinesInstance -> ValueDefine SourceContext
forall c. [c] -> DefinesInstance -> ValueDefine c
ValueDefine [SourceContext
c] DefinesInstance
t

singleFilter :: TextParser (ParamFilter SourceContext)
singleFilter :: TextParser (ParamFilter SourceContext)
singleFilter = do
  SourceContext
c <- TextParser SourceContext
getSourceContext
  TextParser ()
noParamSelf
  ParamName
n <- TextParser ParamName
forall a. ParseFromSource a => TextParser a
sourceParser
  TypeFilter
f <- TextParser TypeFilter
forall a. ParseFromSource a => TextParser a
sourceParser
  ParamFilter SourceContext -> TextParser (ParamFilter SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamFilter SourceContext
 -> TextParser (ParamFilter SourceContext))
-> ParamFilter SourceContext
-> TextParser (ParamFilter SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext]
-> ParamName -> TypeFilter -> ParamFilter SourceContext
forall c. [c] -> ParamName -> TypeFilter -> ParamFilter c
ParamFilter [SourceContext
c] ParamName
n TypeFilter
f

parseCategoryRefines :: TextParser [ValueRefine SourceContext]
parseCategoryRefines :: TextParser [ValueRefine SourceContext]
parseCategoryRefines = TextParser [ValueRefine SourceContext]
-> TextParser [ValueRefine SourceContext]
forall a. TextParser a -> TextParser a
sepAfter (TextParser [ValueRefine SourceContext]
 -> TextParser [ValueRefine SourceContext])
-> TextParser [ValueRefine SourceContext]
-> TextParser [ValueRefine SourceContext]
forall a b. (a -> b) -> a -> b
$ TextParser (ValueRefine SourceContext)
-> TextParser () -> TextParser [ValueRefine SourceContext]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy TextParser (ValueRefine SourceContext)
singleRefine TextParser ()
optionalSpace

parseFilters :: TextParser [ParamFilter SourceContext]
parseFilters :: TextParser [ParamFilter SourceContext]
parseFilters = TextParser (ParamFilter SourceContext)
-> TextParser () -> TextParser [ParamFilter SourceContext]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy TextParser (ParamFilter SourceContext)
singleFilter TextParser ()
optionalSpace

parseRefinesFilters :: TextParser ([ValueRefine SourceContext],[ParamFilter SourceContext])
parseRefinesFilters :: TextParser
  ([ValueRefine SourceContext], [ParamFilter SourceContext])
parseRefinesFilters = ParsecT
  CompilerMessage
  String
  Identity
  [([ValueRefine SourceContext], [ParamFilter SourceContext])]
parsed ParsecT
  CompilerMessage
  String
  Identity
  [([ValueRefine SourceContext], [ParamFilter SourceContext])]
-> ([([ValueRefine SourceContext], [ParamFilter SourceContext])]
    -> TextParser
         ([ValueRefine SourceContext], [ParamFilter SourceContext]))
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([ValueRefine SourceContext], [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall (m :: * -> *) a. Monad m => a -> m a
return (([ValueRefine SourceContext], [ParamFilter SourceContext])
 -> TextParser
      ([ValueRefine SourceContext], [ParamFilter SourceContext]))
-> ([([ValueRefine SourceContext], [ParamFilter SourceContext])]
    -> ([ValueRefine SourceContext], [ParamFilter SourceContext]))
-> [([ValueRefine SourceContext], [ParamFilter SourceContext])]
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([ValueRefine SourceContext], [ParamFilter SourceContext])]
-> ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall (f :: * -> *) a b.
(Foldable f, Monoid a, Monoid b) =>
f (a, b) -> (a, b)
merge2 where
  parsed :: ParsecT
  CompilerMessage
  String
  Identity
  [([ValueRefine SourceContext], [ParamFilter SourceContext])]
parsed = TextParser
  ([ValueRefine SourceContext], [ParamFilter SourceContext])
-> TextParser ()
-> ParsecT
     CompilerMessage
     String
     Identity
     [([ValueRefine SourceContext], [ParamFilter SourceContext])]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy TextParser
  ([ValueRefine SourceContext], [ParamFilter SourceContext])
anyType TextParser ()
optionalSpace
  anyType :: TextParser
  ([ValueRefine SourceContext], [ParamFilter SourceContext])
anyType = String
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall a. String -> TextParser a -> TextParser a
labeled String
"refine or param filter" (TextParser
   ([ValueRefine SourceContext], [ParamFilter SourceContext])
 -> TextParser
      ([ValueRefine SourceContext], [ParamFilter SourceContext]))
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall a b. (a -> b) -> a -> b
$ TextParser (ValueRefine SourceContext)
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall (m :: * -> *) a b.
(Functor m, Monad m) =>
m a -> m ([a], [b])
put12 TextParser (ValueRefine SourceContext)
singleRefine TextParser
  ([ValueRefine SourceContext], [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser (ParamFilter SourceContext)
-> TextParser
     ([ValueRefine SourceContext], [ParamFilter SourceContext])
forall (m :: * -> *) b a.
(Functor m, Monad m) =>
m b -> m ([a], [b])
put22 TextParser (ParamFilter SourceContext)
singleFilter

parseRefinesDefinesFilters ::
  TextParser ([ValueRefine SourceContext],[ValueDefine SourceContext],[ParamFilter SourceContext])
parseRefinesDefinesFilters :: TextParser
  ([ValueRefine SourceContext], [ValueDefine SourceContext],
   [ParamFilter SourceContext])
parseRefinesDefinesFilters = ParsecT
  CompilerMessage
  String
  Identity
  [([ValueRefine SourceContext], [ValueDefine SourceContext],
    [ParamFilter SourceContext])]
parsed ParsecT
  CompilerMessage
  String
  Identity
  [([ValueRefine SourceContext], [ValueDefine SourceContext],
    [ParamFilter SourceContext])]
-> ([([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])]
    -> TextParser
         ([ValueRefine SourceContext], [ValueDefine SourceContext],
          [ParamFilter SourceContext]))
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([ValueRefine SourceContext], [ValueDefine SourceContext],
 [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall (m :: * -> *) a. Monad m => a -> m a
return (([ValueRefine SourceContext], [ValueDefine SourceContext],
  [ParamFilter SourceContext])
 -> TextParser
      ([ValueRefine SourceContext], [ValueDefine SourceContext],
       [ParamFilter SourceContext]))
-> ([([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])]
    -> ([ValueRefine SourceContext], [ValueDefine SourceContext],
        [ParamFilter SourceContext]))
-> [([ValueRefine SourceContext], [ValueDefine SourceContext],
     [ParamFilter SourceContext])]
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([ValueRefine SourceContext], [ValueDefine SourceContext],
  [ParamFilter SourceContext])]
-> ([ValueRefine SourceContext], [ValueDefine SourceContext],
    [ParamFilter SourceContext])
forall (f :: * -> *) a b c.
(Foldable f, Monoid a, Monoid b, Monoid c) =>
f (a, b, c) -> (a, b, c)
merge3 where
  parsed :: ParsecT
  CompilerMessage
  String
  Identity
  [([ValueRefine SourceContext], [ValueDefine SourceContext],
    [ParamFilter SourceContext])]
parsed = TextParser
  ([ValueRefine SourceContext], [ValueDefine SourceContext],
   [ParamFilter SourceContext])
-> TextParser ()
-> ParsecT
     CompilerMessage
     String
     Identity
     [([ValueRefine SourceContext], [ValueDefine SourceContext],
       [ParamFilter SourceContext])]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy TextParser
  ([ValueRefine SourceContext], [ValueDefine SourceContext],
   [ParamFilter SourceContext])
anyType TextParser ()
optionalSpace
  anyType :: TextParser
  ([ValueRefine SourceContext], [ValueDefine SourceContext],
   [ParamFilter SourceContext])
anyType =
    String
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall a. String -> TextParser a -> TextParser a
labeled String
"refine or define or param filter" (TextParser
   ([ValueRefine SourceContext], [ValueDefine SourceContext],
    [ParamFilter SourceContext])
 -> TextParser
      ([ValueRefine SourceContext], [ValueDefine SourceContext],
       [ParamFilter SourceContext]))
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall a b. (a -> b) -> a -> b
$ TextParser (ValueRefine SourceContext)
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall (m :: * -> *) a b c.
(Functor m, Monad m) =>
m a -> m ([a], [b], [c])
put13 TextParser (ValueRefine SourceContext)
singleRefine TextParser
  ([ValueRefine SourceContext], [ValueDefine SourceContext],
   [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser (ValueDefine SourceContext)
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall (m :: * -> *) b a c.
(Functor m, Monad m) =>
m b -> m ([a], [b], [c])
put23 TextParser (ValueDefine SourceContext)
singleDefine TextParser
  ([ValueRefine SourceContext], [ValueDefine SourceContext],
   [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser (ParamFilter SourceContext)
-> TextParser
     ([ValueRefine SourceContext], [ValueDefine SourceContext],
      [ParamFilter SourceContext])
forall (m :: * -> *) c a b.
(Functor m, Monad m) =>
m c -> m ([a], [b], [c])
put33 TextParser (ParamFilter SourceContext)
singleFilter

instance ParseFromSource FunctionName where
  sourceParser :: TextParser FunctionName
sourceParser = String -> TextParser FunctionName -> TextParser FunctionName
forall a. String -> TextParser a -> TextParser a
labeled String
"function name" (TextParser FunctionName -> TextParser FunctionName)
-> TextParser FunctionName -> TextParser FunctionName
forall a b. (a -> b) -> a -> b
$ do
    TextParser ()
noKeywords
    Char
b <- ParsecT CompilerMessage String Identity Char
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
lowerChar
    String
e <- ParsecT CompilerMessage String Identity String
-> ParsecT CompilerMessage String Identity String
forall a. TextParser a -> TextParser a
sepAfter (ParsecT CompilerMessage String Identity String
 -> ParsecT CompilerMessage String Identity String)
-> ParsecT CompilerMessage String Identity String
-> ParsecT CompilerMessage String Identity String
forall a b. (a -> b) -> a -> b
$ ParsecT CompilerMessage String Identity Char
-> ParsecT CompilerMessage String Identity String
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many ParsecT CompilerMessage String Identity Char
forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
alphaNumChar
    FunctionName -> TextParser FunctionName
forall (m :: * -> *) a. Monad m => a -> m a
return (FunctionName -> TextParser FunctionName)
-> FunctionName -> TextParser FunctionName
forall a b. (a -> b) -> a -> b
$ String -> FunctionName
FunctionName (Char
bChar -> String -> String
forall a. a -> [a] -> [a]
:String
e)

parseScopedFunction ::
  TextParser SymbolScope -> TextParser CategoryName -> TextParser (ScopedFunction SourceContext)
parseScopedFunction :: TextParser SymbolScope
-> TextParser CategoryName
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
parseScopedFunction TextParser SymbolScope
sp TextParser CategoryName
tp = String
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
forall a. String -> TextParser a -> TextParser a
labeled String
"function" (ParsecT
   CompilerMessage String Identity (ScopedFunction SourceContext)
 -> ParsecT
      CompilerMessage String Identity (ScopedFunction SourceContext))
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
forall a b. (a -> b) -> a -> b
$ do
  SourceContext
c <- TextParser SourceContext
getSourceContext
  (SymbolScope
s,CategoryName
t,FunctionName
n) <- ParsecT
  CompilerMessage
  String
  Identity
  (SymbolScope, CategoryName, FunctionName)
-> ParsecT
     CompilerMessage
     String
     Identity
     (SymbolScope, CategoryName, FunctionName)
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ParsecT
  CompilerMessage
  String
  Identity
  (SymbolScope, CategoryName, FunctionName)
parseName
  Positional (ValueParam SourceContext)
ps <- ([ValueParam SourceContext]
 -> Positional (ValueParam SourceContext))
-> TextParser [ValueParam SourceContext]
-> ParsecT
     CompilerMessage
     String
     Identity
     (Positional (ValueParam SourceContext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [ValueParam SourceContext] -> Positional (ValueParam SourceContext)
forall a. [a] -> Positional a
Positional (TextParser [ValueParam SourceContext]
 -> ParsecT
      CompilerMessage
      String
      Identity
      (Positional (ValueParam SourceContext)))
-> TextParser [ValueParam SourceContext]
-> ParsecT
     CompilerMessage
     String
     Identity
     (Positional (ValueParam SourceContext))
forall a b. (a -> b) -> a -> b
$ TextParser [ValueParam SourceContext]
forall a. ParsecT CompilerMessage String Identity [a]
noParams TextParser [ValueParam SourceContext]
-> TextParser [ValueParam SourceContext]
-> TextParser [ValueParam SourceContext]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser [ValueParam SourceContext]
someParams
  [ParamFilter SourceContext]
fa <- TextParser [ParamFilter SourceContext]
parseFilters
  Positional (PassedValue SourceContext)
as <- ([PassedValue SourceContext]
 -> Positional (PassedValue SourceContext))
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
-> ParsecT
     CompilerMessage
     String
     Identity
     (Positional (PassedValue SourceContext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [PassedValue SourceContext]
-> Positional (PassedValue SourceContext)
forall a. [a] -> Positional a
Positional (ParsecT
   CompilerMessage String Identity [PassedValue SourceContext]
 -> ParsecT
      CompilerMessage
      String
      Identity
      (Positional (PassedValue SourceContext)))
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
-> ParsecT
     CompilerMessage
     String
     Identity
     (Positional (PassedValue SourceContext))
forall a b. (a -> b) -> a -> b
$ String
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
typeList String
"argument type"
  ParsecT CompilerMessage String Identity String -> TextParser ()
forall a. TextParser a -> TextParser ()
sepAfter_ (Tokens String
-> ParsecT CompilerMessage String Identity (Tokens String)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string String
Tokens String
"->")
  Positional (PassedValue SourceContext)
rs <- ([PassedValue SourceContext]
 -> Positional (PassedValue SourceContext))
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
-> ParsecT
     CompilerMessage
     String
     Identity
     (Positional (PassedValue SourceContext))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [PassedValue SourceContext]
-> Positional (PassedValue SourceContext)
forall a. [a] -> Positional a
Positional (ParsecT
   CompilerMessage String Identity [PassedValue SourceContext]
 -> ParsecT
      CompilerMessage
      String
      Identity
      (Positional (PassedValue SourceContext)))
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
-> ParsecT
     CompilerMessage
     String
     Identity
     (Positional (PassedValue SourceContext))
forall a b. (a -> b) -> a -> b
$ String
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
typeList String
"return type"
  ScopedFunction SourceContext
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (ScopedFunction SourceContext
 -> ParsecT
      CompilerMessage String Identity (ScopedFunction SourceContext))
-> ScopedFunction SourceContext
-> ParsecT
     CompilerMessage String Identity (ScopedFunction SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext]
-> FunctionName
-> CategoryName
-> SymbolScope
-> Positional (PassedValue SourceContext)
-> Positional (PassedValue SourceContext)
-> Positional (ValueParam SourceContext)
-> [ParamFilter SourceContext]
-> [ScopedFunction SourceContext]
-> ScopedFunction SourceContext
forall c.
[c]
-> FunctionName
-> CategoryName
-> SymbolScope
-> Positional (PassedValue c)
-> Positional (PassedValue c)
-> Positional (ValueParam c)
-> [ParamFilter c]
-> [ScopedFunction c]
-> ScopedFunction c
ScopedFunction [SourceContext
c] FunctionName
n CategoryName
t SymbolScope
s Positional (PassedValue SourceContext)
as Positional (PassedValue SourceContext)
rs Positional (ValueParam SourceContext)
ps [ParamFilter SourceContext]
fa []
  where
    parseName :: ParsecT
  CompilerMessage
  String
  Identity
  (SymbolScope, CategoryName, FunctionName)
parseName = do
      SymbolScope
s <- TextParser SymbolScope
sp -- Could be a constant, i.e., nothing consumed.
      CategoryName
t <- TextParser CategoryName
tp -- Same here.
      FunctionName
n <- TextParser FunctionName
forall a. ParseFromSource a => TextParser a
sourceParser
      (SymbolScope, CategoryName, FunctionName)
-> ParsecT
     CompilerMessage
     String
     Identity
     (SymbolScope, CategoryName, FunctionName)
forall (m :: * -> *) a. Monad m => a -> m a
return (SymbolScope
s,CategoryName
t,FunctionName
n)
    noParams :: ParsecT CompilerMessage String Identity [a]
noParams = ParsecT CompilerMessage String Identity String -> TextParser ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (Tokens String
-> ParsecT CompilerMessage String Identity (Tokens String)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string String
Tokens String
"<") TextParser ()
-> ParsecT CompilerMessage String Identity [a]
-> ParsecT CompilerMessage String Identity [a]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [a] -> ParsecT CompilerMessage String Identity [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
    someParams :: TextParser [ValueParam SourceContext]
someParams = TextParser ()
-> TextParser ()
-> TextParser [ValueParam SourceContext]
-> TextParser [ValueParam SourceContext]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"<")
                         (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
">")
                         (ParsecT CompilerMessage String Identity (ValueParam SourceContext)
-> ParsecT CompilerMessage String Identity String
-> TextParser [ValueParam SourceContext]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy ParsecT CompilerMessage String Identity (ValueParam SourceContext)
singleParam (ParsecT CompilerMessage String Identity String
-> ParsecT CompilerMessage String Identity String
forall a. TextParser a -> TextParser a
sepAfter (ParsecT CompilerMessage String Identity String
 -> ParsecT CompilerMessage String Identity String)
-> ParsecT CompilerMessage String Identity String
-> ParsecT CompilerMessage String Identity String
forall a b. (a -> b) -> a -> b
$ Tokens String
-> ParsecT CompilerMessage String Identity (Tokens String)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string String
Tokens String
","))
    singleParam :: ParsecT CompilerMessage String Identity (ValueParam SourceContext)
singleParam = String
-> ParsecT
     CompilerMessage String Identity (ValueParam SourceContext)
-> ParsecT
     CompilerMessage String Identity (ValueParam SourceContext)
forall a. String -> TextParser a -> TextParser a
labeled String
"param declaration" (ParsecT CompilerMessage String Identity (ValueParam SourceContext)
 -> ParsecT
      CompilerMessage String Identity (ValueParam SourceContext))
-> ParsecT
     CompilerMessage String Identity (ValueParam SourceContext)
-> ParsecT
     CompilerMessage String Identity (ValueParam SourceContext)
forall a b. (a -> b) -> a -> b
$ do
      TextParser ()
noParamSelf
      SourceContext
c <- TextParser SourceContext
getSourceContext
      ParamName
n <- TextParser ParamName
forall a. ParseFromSource a => TextParser a
sourceParser
      ValueParam SourceContext
-> ParsecT
     CompilerMessage String Identity (ValueParam SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (ValueParam SourceContext
 -> ParsecT
      CompilerMessage String Identity (ValueParam SourceContext))
-> ValueParam SourceContext
-> ParsecT
     CompilerMessage String Identity (ValueParam SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext]
-> ParamName -> Variance -> ValueParam SourceContext
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [SourceContext
c] ParamName
n Variance
Invariant
    typeList :: String
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
typeList String
l = TextParser ()
-> TextParser ()
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
"(")
                         (TextParser () -> TextParser ()
forall a. TextParser a -> TextParser a
sepAfter (TextParser () -> TextParser ()) -> TextParser () -> TextParser ()
forall a b. (a -> b) -> a -> b
$ String -> TextParser ()
string_ String
")")
                         (ParsecT CompilerMessage String Identity (PassedValue SourceContext)
-> ParsecT CompilerMessage String Identity String
-> ParsecT
     CompilerMessage String Identity [PassedValue SourceContext]
forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
sepBy (String
-> ParsecT
     CompilerMessage String Identity (PassedValue SourceContext)
-> ParsecT
     CompilerMessage String Identity (PassedValue SourceContext)
forall a. String -> TextParser a -> TextParser a
labeled String
l (ParsecT
   CompilerMessage String Identity (PassedValue SourceContext)
 -> ParsecT
      CompilerMessage String Identity (PassedValue SourceContext))
-> ParsecT
     CompilerMessage String Identity (PassedValue SourceContext)
-> ParsecT
     CompilerMessage String Identity (PassedValue SourceContext)
forall a b. (a -> b) -> a -> b
$ ParsecT CompilerMessage String Identity (PassedValue SourceContext)
singleType) (ParsecT CompilerMessage String Identity String
-> ParsecT CompilerMessage String Identity String
forall a. TextParser a -> TextParser a
sepAfter (ParsecT CompilerMessage String Identity String
 -> ParsecT CompilerMessage String Identity String)
-> ParsecT CompilerMessage String Identity String
-> ParsecT CompilerMessage String Identity String
forall a b. (a -> b) -> a -> b
$ Tokens String
-> ParsecT CompilerMessage String Identity (Tokens String)
forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string String
Tokens String
","))
    singleType :: ParsecT CompilerMessage String Identity (PassedValue SourceContext)
singleType = do
      SourceContext
c <- TextParser SourceContext
getSourceContext
      ValueType
t <- TextParser ValueType
forall a. ParseFromSource a => TextParser a
sourceParser
      PassedValue SourceContext
-> ParsecT
     CompilerMessage String Identity (PassedValue SourceContext)
forall (m :: * -> *) a. Monad m => a -> m a
return (PassedValue SourceContext
 -> ParsecT
      CompilerMessage String Identity (PassedValue SourceContext))
-> PassedValue SourceContext
-> ParsecT
     CompilerMessage String Identity (PassedValue SourceContext)
forall a b. (a -> b) -> a -> b
$ [SourceContext] -> ValueType -> PassedValue SourceContext
forall c. [c] -> ValueType -> PassedValue c
PassedValue [SourceContext
c] ValueType
t

parseScope :: TextParser SymbolScope
parseScope :: TextParser SymbolScope
parseScope = TextParser SymbolScope -> TextParser SymbolScope
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try TextParser SymbolScope
categoryScope TextParser SymbolScope
-> TextParser SymbolScope -> TextParser SymbolScope
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser SymbolScope -> TextParser SymbolScope
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try TextParser SymbolScope
typeScope TextParser SymbolScope
-> TextParser SymbolScope -> TextParser SymbolScope
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> TextParser SymbolScope
valueScope

categoryScope :: TextParser SymbolScope
categoryScope :: TextParser SymbolScope
categoryScope = TextParser ()
kwCategory TextParser () -> TextParser SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a. Monad m => a -> m a
return SymbolScope
CategoryScope

typeScope :: TextParser SymbolScope
typeScope :: TextParser SymbolScope
typeScope = TextParser ()
kwType TextParser () -> TextParser SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a. Monad m => a -> m a
return SymbolScope
TypeScope

valueScope :: TextParser SymbolScope
valueScope :: TextParser SymbolScope
valueScope = TextParser ()
kwValue TextParser () -> TextParser SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SymbolScope -> TextParser SymbolScope
forall (m :: * -> *) a. Monad m => a -> m a
return SymbolScope
ValueScope