{- -----------------------------------------------------------------------------
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 #-}
{-# LANGUAGE Safe #-}

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

import Text.Parsec

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


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

parseCategoryParams :: CompileErrorM m => ParserE m [ValueParam SourcePos]
parseCategoryParams :: ParserE m [ValueParam SourcePos]
parseCategoryParams = do
  ([(SourcePos, ParamName)]
con,[(SourcePos, ParamName)]
inv,[(SourcePos, ParamName)]
cov) <- ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
forall u a a a. ParsecT String u m ([a], [a], [a])
none ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
forall a a.
ParsecT String () m ([a], [(SourcePos, ParamName)], [a])
fixedOnly ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
forall a.
ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [a], [(SourcePos, ParamName)])
noFixed ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
explicitFixed
  [ValueParam SourcePos] -> ParserE m [ValueParam SourcePos]
forall (m :: * -> *) a. Monad m => a -> m a
return ([ValueParam SourcePos] -> ParserE m [ValueParam SourcePos])
-> [ValueParam SourcePos] -> ParserE m [ValueParam SourcePos]
forall a b. (a -> b) -> a -> b
$ ((SourcePos, ParamName) -> ValueParam SourcePos)
-> [(SourcePos, ParamName)] -> [ValueParam SourcePos]
forall a b. (a -> b) -> [a] -> [b]
map (Variance -> (SourcePos, ParamName) -> ValueParam SourcePos
forall c. Variance -> (c, ParamName) -> ValueParam c
apply Variance
Contravariant) [(SourcePos, ParamName)]
con [ValueParam SourcePos]
-> [ValueParam SourcePos] -> [ValueParam SourcePos]
forall a. [a] -> [a] -> [a]
++
           ((SourcePos, ParamName) -> ValueParam SourcePos)
-> [(SourcePos, ParamName)] -> [ValueParam SourcePos]
forall a b. (a -> b) -> [a] -> [b]
map (Variance -> (SourcePos, ParamName) -> ValueParam SourcePos
forall c. Variance -> (c, ParamName) -> ValueParam c
apply Variance
Invariant) [(SourcePos, ParamName)]
inv [ValueParam SourcePos]
-> [ValueParam SourcePos] -> [ValueParam SourcePos]
forall a. [a] -> [a] -> [a]
++
           ((SourcePos, ParamName) -> ValueParam SourcePos)
-> [(SourcePos, ParamName)] -> [ValueParam SourcePos]
forall a b. (a -> b) -> [a] -> [b]
map (Variance -> (SourcePos, ParamName) -> ValueParam SourcePos
forall c. Variance -> (c, ParamName) -> ValueParam c
apply Variance
Covariant) [(SourcePos, ParamName)]
cov
  where
    none :: ParsecT String u m ([a], [a], [a])
none = do
      ParsecT String u m String -> ParsecT String u m ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (String -> ParsecT String u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
"<")
      ([a], [a], [a]) -> ParsecT String u m ([a], [a], [a])
forall (m :: * -> *) a. Monad m => a -> m a
return ([],[],[])
    fixedOnly :: ParsecT String () m ([a], [(SourcePos, ParamName)], [a])
fixedOnly = do -- T<a,b,c>
      [(SourcePos, ParamName)]
inv <- ParsecT String () m ()
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"<")
                     (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
">")
                     (ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (SourcePos, ParamName)
singleParam (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
","))
      ([a], [(SourcePos, ParamName)], [a])
-> ParsecT String () m ([a], [(SourcePos, ParamName)], [a])
forall (m :: * -> *) a. Monad m => a -> m a
return ([],[(SourcePos, ParamName)]
inv,[])
    noFixed :: ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [a], [(SourcePos, ParamName)])
noFixed = do -- T<a,b|c,d>
      [(SourcePos, ParamName)]
con <- ParsecT String () m ()
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"<")
                     (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"|")
                     (ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (SourcePos, ParamName)
singleParam (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
","))
      [(SourcePos, ParamName)]
cov <- ParsecT String () m ()
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse
                     (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
">")
                     (ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (SourcePos, ParamName)
singleParam (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
","))
      ([(SourcePos, ParamName)], [a], [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [a], [(SourcePos, ParamName)])
forall (m :: * -> *) a. Monad m => a -> m a
return ([(SourcePos, ParamName)]
con,[],[(SourcePos, ParamName)]
cov)
    explicitFixed :: ParsecT
  String
  ()
  m
  ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
   [(SourcePos, ParamName)])
explicitFixed = do -- T<a,b|c,d|e,f>
      [(SourcePos, ParamName)]
con <- ParsecT String () m ()
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"<")
                     (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"|")
                     (ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (SourcePos, ParamName)
singleParam (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
","))
      [(SourcePos, ParamName)]
inv <- ParsecT String () m ()
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse
                     (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"|")
                     (ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (SourcePos, ParamName)
singleParam (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
","))
      [(SourcePos, ParamName)]
cov <- ParsecT String () m ()
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse
                     (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
">")
                     (ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m ()
-> ParsecT String () m [(SourcePos, ParamName)]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (SourcePos, ParamName)
singleParam (ParsecT String () m () -> ParsecT String () m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m () -> ParsecT String () m ())
-> ParsecT String () m () -> ParsecT String () m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
","))
      ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
 [(SourcePos, ParamName)])
-> ParsecT
     String
     ()
     m
     ([(SourcePos, ParamName)], [(SourcePos, ParamName)],
      [(SourcePos, ParamName)])
forall (m :: * -> *) a. Monad m => a -> m a
return ([(SourcePos, ParamName)]
con,[(SourcePos, ParamName)]
inv,[(SourcePos, ParamName)]
cov)
    singleParam :: ParsecT String () m (SourcePos, ParamName)
singleParam = String
-> ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m (SourcePos, ParamName)
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"param declaration" (ParsecT String () m (SourcePos, ParamName)
 -> ParsecT String () m (SourcePos, ParamName))
-> ParsecT String () m (SourcePos, ParamName)
-> ParsecT String () m (SourcePos, ParamName)
forall a b. (a -> b) -> a -> b
$ do
      SourcePos
c <- ParsecT String () m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
      ParamName
n <- ParserE m ParamName
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
      (SourcePos, ParamName)
-> ParsecT String () m (SourcePos, ParamName)
forall (m :: * -> *) a. Monad m => a -> m a
return (SourcePos
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 :: CompileErrorM m => ParserE m (ValueRefine SourcePos)
singleRefine :: ParserE m (ValueRefine SourcePos)
singleRefine = do
  SourcePos
c <- ParsecT String () m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  ParsecT String () m () -> ParsecT String () m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwRefines
  TypeInstance
t <- ParserE m TypeInstance
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
  ValueRefine SourcePos -> ParserE m (ValueRefine SourcePos)
forall (m :: * -> *) a. Monad m => a -> m a
return (ValueRefine SourcePos -> ParserE m (ValueRefine SourcePos))
-> ValueRefine SourcePos -> ParserE m (ValueRefine SourcePos)
forall a b. (a -> b) -> a -> b
$ [SourcePos] -> TypeInstance -> ValueRefine SourcePos
forall c. [c] -> TypeInstance -> ValueRefine c
ValueRefine [SourcePos
c] TypeInstance
t

singleDefine :: CompileErrorM m => ParserE m (ValueDefine SourcePos)
singleDefine :: ParserE m (ValueDefine SourcePos)
singleDefine = do
  SourcePos
c <- ParsecT String () m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  ParsecT String () m () -> ParsecT String () m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwDefines
  DefinesInstance
t <- ParserE m DefinesInstance
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
  ValueDefine SourcePos -> ParserE m (ValueDefine SourcePos)
forall (m :: * -> *) a. Monad m => a -> m a
return (ValueDefine SourcePos -> ParserE m (ValueDefine SourcePos))
-> ValueDefine SourcePos -> ParserE m (ValueDefine SourcePos)
forall a b. (a -> b) -> a -> b
$ [SourcePos] -> DefinesInstance -> ValueDefine SourcePos
forall c. [c] -> DefinesInstance -> ValueDefine c
ValueDefine [SourcePos
c] DefinesInstance
t

singleFilter :: CompileErrorM m => ParserE m (ParamFilter SourcePos)
singleFilter :: ParserE m (ParamFilter SourcePos)
singleFilter = ParserE m (ParamFilter SourcePos)
-> ParserE m (ParamFilter SourcePos)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParserE m (ParamFilter SourcePos)
 -> ParserE m (ParamFilter SourcePos))
-> ParserE m (ParamFilter SourcePos)
-> ParserE m (ParamFilter SourcePos)
forall a b. (a -> b) -> a -> b
$ do
  SourcePos
c <- ParsecT String () m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  ParamName
n <- ParserE m ParamName
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
  TypeFilter
f <- ParserE m TypeFilter
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
  ParamFilter SourcePos -> ParserE m (ParamFilter SourcePos)
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamFilter SourcePos -> ParserE m (ParamFilter SourcePos))
-> ParamFilter SourcePos -> ParserE m (ParamFilter SourcePos)
forall a b. (a -> b) -> a -> b
$ [SourcePos] -> ParamName -> TypeFilter -> ParamFilter SourcePos
forall c. [c] -> ParamName -> TypeFilter -> ParamFilter c
ParamFilter [SourcePos
c] ParamName
n TypeFilter
f

parseCategoryRefines :: CompileErrorM m => ParserE m [ValueRefine SourcePos]
parseCategoryRefines :: ParserE m [ValueRefine SourcePos]
parseCategoryRefines = ParserE m [ValueRefine SourcePos]
-> ParserE m [ValueRefine SourcePos]
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParserE m [ValueRefine SourcePos]
 -> ParserE m [ValueRefine SourcePos])
-> ParserE m [ValueRefine SourcePos]
-> ParserE m [ValueRefine SourcePos]
forall a b. (a -> b) -> a -> b
$ ParsecT String () m (ValueRefine SourcePos)
-> ParsecT String () m () -> ParserE m [ValueRefine SourcePos]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (ValueRefine SourcePos)
forall (m :: * -> *).
CompileErrorM m =>
ParserE m (ValueRefine SourcePos)
singleRefine ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace

parseFilters :: CompileErrorM m => ParserE m [ParamFilter SourcePos]
parseFilters :: ParserE m [ParamFilter SourcePos]
parseFilters = ParsecT String () m (ParamFilter SourcePos)
-> ParsecT String () m () -> ParserE m [ParamFilter SourcePos]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT String () m (ParamFilter SourcePos)
forall (m :: * -> *).
CompileErrorM m =>
ParserE m (ParamFilter SourcePos)
singleFilter ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace

parseRefinesFilters :: CompileErrorM m => ParserE m ([ValueRefine SourcePos],[ParamFilter SourcePos])
parseRefinesFilters :: ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
parseRefinesFilters = ParsecT
  String () m [([ValueRefine SourcePos], [ParamFilter SourcePos])]
parsed ParsecT
  String () m [([ValueRefine SourcePos], [ParamFilter SourcePos])]
-> ([([ValueRefine SourcePos], [ParamFilter SourcePos])]
    -> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos]))
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([ValueRefine SourcePos], [ParamFilter SourcePos])
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall (m :: * -> *) a. Monad m => a -> m a
return (([ValueRefine SourcePos], [ParamFilter SourcePos])
 -> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos]))
-> ([([ValueRefine SourcePos], [ParamFilter SourcePos])]
    -> ([ValueRefine SourcePos], [ParamFilter SourcePos]))
-> [([ValueRefine SourcePos], [ParamFilter SourcePos])]
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([ValueRefine SourcePos], [ParamFilter SourcePos])]
-> ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall (f :: * -> *) a b.
(Foldable f, Monoid a, Monoid b) =>
f (a, b) -> (a, b)
merge2 where
  parsed :: ParsecT
  String () m [([ValueRefine SourcePos], [ParamFilter SourcePos])]
parsed = ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
-> ParsecT String () m ()
-> ParsecT
     String () m [([ValueRefine SourcePos], [ParamFilter SourcePos])]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
anyType ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace
  anyType :: ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
anyType = String
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"refine or param filter" (ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
 -> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos]))
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall a b. (a -> b) -> a -> b
$ ParsecT String () m (ValueRefine SourcePos)
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall (m :: * -> *) a b.
(Functor m, Monad m) =>
m a -> m ([a], [b])
put12 ParsecT String () m (ValueRefine SourcePos)
forall (m :: * -> *).
CompileErrorM m =>
ParserE m (ValueRefine SourcePos)
singleRefine ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () m (ParamFilter SourcePos)
-> ParserE m ([ValueRefine SourcePos], [ParamFilter SourcePos])
forall (m :: * -> *) b a.
(Functor m, Monad m) =>
m b -> m ([a], [b])
put22 ParsecT String () m (ParamFilter SourcePos)
forall (m :: * -> *).
CompileErrorM m =>
ParserE m (ParamFilter SourcePos)
singleFilter

parseRefinesDefinesFilters :: CompileErrorM m =>
  ParserE m ([ValueRefine SourcePos],[ValueDefine SourcePos],[ParamFilter SourcePos])
parseRefinesDefinesFilters :: ParserE
  m
  ([ValueRefine SourcePos], [ValueDefine SourcePos],
   [ParamFilter SourcePos])
parseRefinesDefinesFilters = ParsecT
  String
  ()
  m
  [([ValueRefine SourcePos], [ValueDefine SourcePos],
    [ParamFilter SourcePos])]
parsed ParsecT
  String
  ()
  m
  [([ValueRefine SourcePos], [ValueDefine SourcePos],
    [ParamFilter SourcePos])]
-> ([([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])]
    -> ParserE
         m
         ([ValueRefine SourcePos], [ValueDefine SourcePos],
          [ParamFilter SourcePos]))
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([ValueRefine SourcePos], [ValueDefine SourcePos],
 [ParamFilter SourcePos])
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall (m :: * -> *) a. Monad m => a -> m a
return (([ValueRefine SourcePos], [ValueDefine SourcePos],
  [ParamFilter SourcePos])
 -> ParserE
      m
      ([ValueRefine SourcePos], [ValueDefine SourcePos],
       [ParamFilter SourcePos]))
-> ([([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])]
    -> ([ValueRefine SourcePos], [ValueDefine SourcePos],
        [ParamFilter SourcePos]))
-> [([ValueRefine SourcePos], [ValueDefine SourcePos],
     [ParamFilter SourcePos])]
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([ValueRefine SourcePos], [ValueDefine SourcePos],
  [ParamFilter SourcePos])]
-> ([ValueRefine SourcePos], [ValueDefine SourcePos],
    [ParamFilter SourcePos])
forall (f :: * -> *) a b c.
(Foldable f, Monoid a, Monoid b, Monoid c) =>
f (a, b, c) -> (a, b, c)
merge3 where
  parsed :: ParsecT
  String
  ()
  m
  [([ValueRefine SourcePos], [ValueDefine SourcePos],
    [ParamFilter SourcePos])]
parsed = ParserE
  m
  ([ValueRefine SourcePos], [ValueDefine SourcePos],
   [ParamFilter SourcePos])
-> ParsecT String () m ()
-> ParsecT
     String
     ()
     m
     [([ValueRefine SourcePos], [ValueDefine SourcePos],
       [ParamFilter SourcePos])]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParserE
  m
  ([ValueRefine SourcePos], [ValueDefine SourcePos],
   [ParamFilter SourcePos])
anyType ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace
  anyType :: ParserE
  m
  ([ValueRefine SourcePos], [ValueDefine SourcePos],
   [ParamFilter SourcePos])
anyType =
    String
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"refine or define or param filter" (ParserE
   m
   ([ValueRefine SourcePos], [ValueDefine SourcePos],
    [ParamFilter SourcePos])
 -> ParserE
      m
      ([ValueRefine SourcePos], [ValueDefine SourcePos],
       [ParamFilter SourcePos]))
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall a b. (a -> b) -> a -> b
$ ParsecT String () m (ValueRefine SourcePos)
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall (m :: * -> *) a b c.
(Functor m, Monad m) =>
m a -> m ([a], [b], [c])
put13 ParsecT String () m (ValueRefine SourcePos)
forall (m :: * -> *).
CompileErrorM m =>
ParserE m (ValueRefine SourcePos)
singleRefine ParserE
  m
  ([ValueRefine SourcePos], [ValueDefine SourcePos],
   [ParamFilter SourcePos])
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () m (ValueDefine SourcePos)
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall (m :: * -> *) b a c.
(Functor m, Monad m) =>
m b -> m ([a], [b], [c])
put23 ParsecT String () m (ValueDefine SourcePos)
forall (m :: * -> *).
CompileErrorM m =>
ParserE m (ValueDefine SourcePos)
singleDefine ParserE
  m
  ([ValueRefine SourcePos], [ValueDefine SourcePos],
   [ParamFilter SourcePos])
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () m (ParamFilter SourcePos)
-> ParserE
     m
     ([ValueRefine SourcePos], [ValueDefine SourcePos],
      [ParamFilter SourcePos])
forall (m :: * -> *) c a b.
(Functor m, Monad m) =>
m c -> m ([a], [b], [c])
put33 ParsecT String () m (ParamFilter SourcePos)
forall (m :: * -> *).
CompileErrorM m =>
ParserE m (ParamFilter SourcePos)
singleFilter

instance ParseFromSource FunctionName where
  sourceParser :: ParserE m FunctionName
sourceParser = String -> ParserE m FunctionName -> ParserE m FunctionName
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"function name" (ParserE m FunctionName -> ParserE m FunctionName)
-> ParserE m FunctionName -> ParserE m FunctionName
forall a b. (a -> b) -> a -> b
$ do
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
noKeywords
    Char
b <- ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
lower
    String
e <- ParserE m String -> ParserE m String
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParserE m String -> ParserE m String)
-> ParserE m String -> ParserE m String
forall a b. (a -> b) -> a -> b
$ ParsecT String () m Char -> ParserE m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum
    FunctionName -> ParserE m FunctionName
forall (m :: * -> *) a. Monad m => a -> m a
return (FunctionName -> ParserE m FunctionName)
-> FunctionName -> ParserE m FunctionName
forall a b. (a -> b) -> a -> b
$ String -> FunctionName
FunctionName (Char
bChar -> String -> String
forall a. a -> [a] -> [a]
:String
e)

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

parseScope :: Monad m => ParserE m SymbolScope
parseScope :: ParserE m SymbolScope
parseScope = ParserE m SymbolScope -> ParserE m SymbolScope
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m SymbolScope
forall (m :: * -> *). Monad m => ParserE m SymbolScope
categoryScope ParserE m SymbolScope
-> ParserE m SymbolScope -> ParserE m SymbolScope
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m SymbolScope -> ParserE m SymbolScope
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m SymbolScope
forall (m :: * -> *). Monad m => ParserE m SymbolScope
typeScope ParserE m SymbolScope
-> ParserE m SymbolScope -> ParserE m SymbolScope
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m SymbolScope
forall (m :: * -> *). Monad m => ParserE m SymbolScope
valueScope

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

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

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