{- -----------------------------------------------------------------------------
Copyright 2019-2020 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.TypeInstance (
) where

import Control.Applicative ((<|>))
import Text.Parsec hiding ((<|>))

import Base.Mergeable (mergeAll,mergeAny)
import Parser.Common
import Types.GeneralType
import Types.Positional
import Types.TypeInstance


instance ParseFromSource GeneralInstance where
  sourceParser :: ParserE m GeneralInstance
sourceParser = ParserE m GeneralInstance -> ParserE m GeneralInstance
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m GeneralInstance
allT ParserE m GeneralInstance
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m GeneralInstance
anyT ParserE m GeneralInstance
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m GeneralInstance
intersectOrUnion ParserE m GeneralInstance
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m GeneralInstance
single where
    allT :: ParserE m GeneralInstance
allT = String -> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"all" (ParserE m GeneralInstance -> ParserE m GeneralInstance)
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall a b. (a -> b) -> a -> b
$ do
      ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwAll
      GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
forall a. Bounded a => a
minBound
    anyT :: ParserE m GeneralInstance
anyT = String -> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"any" (ParserE m GeneralInstance -> ParserE m GeneralInstance)
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall a b. (a -> b) -> a -> b
$ do
      ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwAny
      GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
forall a. Bounded a => a
maxBound
    intersectOrUnion :: ParserE m GeneralInstance
intersectOrUnion = String -> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"union or intersection" (ParserE m GeneralInstance -> ParserE m GeneralInstance)
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall a b. (a -> b) -> a -> b
$ do
      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
"["
      GeneralInstance
t1 <- String -> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type" (ParserE m GeneralInstance -> ParserE m GeneralInstance)
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall a b. (a -> b) -> a -> b
$ ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter ParserE m GeneralInstance
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
      GeneralInstance
t <- GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) b.
(ParseFromSource b, CompileErrorM m, Mergeable b) =>
b -> ParsecT String () m b
intersect GeneralInstance
t1 ParserE m GeneralInstance
-> ParserE m GeneralInstance -> ParserE m GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) b.
(ParseFromSource b, CompileErrorM m, Mergeable b) =>
b -> ParsecT String () m b
union GeneralInstance
t1
      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
"]"
      GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
t
    intersect :: b -> ParsecT String () m b
intersect b
t1 = do
      [b]
ts <- ParsecT String () m b -> ParsecT String () m [b]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (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
"&") ParserE m () -> ParsecT String () m b -> ParsecT String () m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> ParsecT String () m b -> ParsecT String () m b
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type" ParsecT String () m b
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser)
      b -> ParsecT String () m b
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> ParsecT String () m b) -> b -> ParsecT String () m b
forall a b. (a -> b) -> a -> b
$ [b] -> b
forall a (f :: * -> *). (Mergeable a, Foldable f) => f a -> a
mergeAll (b
t1b -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
ts)
    union :: b -> ParsecT String () m b
union b
t1 = do
      [b]
ts <- ParsecT String () m b -> ParsecT String () m [b]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (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
"|") ParserE m () -> ParsecT String () m b -> ParsecT String () m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> ParsecT String () m b -> ParsecT String () m b
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type" ParsecT String () m b
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser)
      b -> ParsecT String () m b
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> ParsecT String () m b) -> b -> ParsecT String () m b
forall a b. (a -> b) -> a -> b
$ [b] -> b
forall a (f :: * -> *). (Mergeable a, Foldable f) => f a -> a
mergeAny (b
t1b -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
ts)
    single :: ParserE m GeneralInstance
single = do
      TypeInstanceOrParam
t <- ParserE m TypeInstanceOrParam
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
      GeneralInstance -> ParserE m GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return (GeneralInstance -> ParserE m GeneralInstance)
-> GeneralInstance -> ParserE m GeneralInstance
forall a b. (a -> b) -> a -> b
$ TypeInstanceOrParam -> GeneralInstance
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType TypeInstanceOrParam
t

instance ParseFromSource ValueType where
  sourceParser :: ParserE m ValueType
sourceParser = do
    StorageType
r <- ParserE m StorageType
getWeak ParserE m StorageType
-> ParserE m StorageType -> ParserE m StorageType
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m StorageType
getOptional ParserE m StorageType
-> ParserE m StorageType -> ParserE m StorageType
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m StorageType
getRequired
    GeneralInstance
t <- ParserE m GeneralInstance
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
    ValueType -> ParserE m ValueType
forall (m :: * -> *) a. Monad m => a -> m a
return (ValueType -> ParserE m ValueType)
-> ValueType -> ParserE m ValueType
forall a b. (a -> b) -> a -> b
$ StorageType -> GeneralInstance -> ValueType
ValueType StorageType
r GeneralInstance
t
    where
      getWeak :: ParserE m StorageType
getWeak = String -> ParserE m StorageType -> ParserE m StorageType
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"weak" (ParserE m StorageType -> ParserE m StorageType)
-> ParserE m StorageType -> ParserE m StorageType
forall a b. (a -> b) -> a -> b
$ do
        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 ()
kwWeak
        StorageType -> ParserE m StorageType
forall (m :: * -> *) a. Monad m => a -> m a
return StorageType
WeakValue
      getOptional :: ParserE m StorageType
getOptional = String -> ParserE m StorageType -> ParserE m StorageType
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"optional" (ParserE m StorageType -> ParserE m StorageType)
-> ParserE m StorageType -> ParserE m StorageType
forall a b. (a -> b) -> a -> b
$ do
        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 ()
kwOptional
        StorageType -> ParserE m StorageType
forall (m :: * -> *) a. Monad m => a -> m a
return StorageType
OptionalValue
      getRequired :: ParserE m StorageType
getRequired = StorageType -> ParserE m StorageType
forall (m :: * -> *) a. Monad m => a -> m a
return StorageType
RequiredValue

instance ParseFromSource CategoryName where
  sourceParser :: ParserE m CategoryName
sourceParser = String -> ParserE m CategoryName -> ParserE m CategoryName
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type name" (ParserE m CategoryName -> ParserE m CategoryName)
-> ParserE m CategoryName -> ParserE m CategoryName
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
upper
    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
    CategoryName -> ParserE m CategoryName
forall (m :: * -> *) a. Monad m => a -> m a
return (CategoryName -> ParserE m CategoryName)
-> CategoryName -> ParserE m CategoryName
forall a b. (a -> b) -> a -> b
$ String -> CategoryName
box (Char
bChar -> String -> String
forall a. a -> [a] -> [a]
:String
e)
    where
      box :: String -> CategoryName
box String
n
        | String
n String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"Bool"         = CategoryName
BuiltinBool
        | String
n String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"Char"         = CategoryName
BuiltinChar
        | String
n String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"Int"          = CategoryName
BuiltinInt
        | String
n String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"Float"        = CategoryName
BuiltinFloat
        | String
n String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"String"       = CategoryName
BuiltinString
        | String
n String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"Formatted"    = CategoryName
BuiltinFormatted
        | Bool
otherwise = String -> CategoryName
CategoryName String
n

instance ParseFromSource ParamName where
  sourceParser :: ParserE m ParamName
sourceParser = String -> ParserE m ParamName -> ParserE m ParamName
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"param name" (ParserE m ParamName -> ParserE m ParamName)
-> ParserE m ParamName -> ParserE m ParamName
forall a b. (a -> b) -> a -> b
$ do
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
noKeywords
    Char -> ParserE m ()
forall (m :: * -> *). Monad m => Char -> ParserE m ()
char_ Char
'#'
    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
    ParamName -> ParserE m ParamName
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamName -> ParserE m ParamName)
-> ParamName -> ParserE m ParamName
forall a b. (a -> b) -> a -> b
$ String -> ParamName
ParamName (Char
'#'Char -> String -> String
forall a. a -> [a] -> [a]
:Char
bChar -> String -> String
forall a. a -> [a] -> [a]
:String
e)

instance ParseFromSource TypeInstance where
  sourceParser :: ParserE m TypeInstance
sourceParser = String -> ParserE m TypeInstance -> ParserE m TypeInstance
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type" (ParserE m TypeInstance -> ParserE m TypeInstance)
-> ParserE m TypeInstance -> ParserE m TypeInstance
forall a b. (a -> b) -> a -> b
$ do
    CategoryName
n <- ParserE m CategoryName
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
    [GeneralInstance]
as <- String
-> ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type args" (ParserE m [GeneralInstance] -> ParserE m [GeneralInstance])
-> ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall a b. (a -> b) -> a -> b
$ ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m [GeneralInstance]
args ParserE m [GeneralInstance]
-> ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [GeneralInstance] -> ParserE m [GeneralInstance]
forall (m :: * -> *) a. Monad m => a -> m a
return []
    TypeInstance -> ParserE m TypeInstance
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeInstance -> ParserE m TypeInstance)
-> TypeInstance -> ParserE m TypeInstance
forall a b. (a -> b) -> a -> b
$ CategoryName -> InstanceParams -> TypeInstance
TypeInstance CategoryName
n ([GeneralInstance] -> InstanceParams
forall a. [a] -> Positional a
Positional [GeneralInstance]
as)
    where
      args :: ParserE m [GeneralInstance]
args = ParsecT String () m String
-> ParsecT String () m String
-> ParserE m [GeneralInstance]
-> ParserE m [GeneralInstance]
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 String -> ParsecT String () m String
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m String -> ParsecT String () m String)
-> ParsecT String () m String -> ParsecT String () m String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
"<")
                     (ParsecT String () m String -> ParsecT String () m String
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m String -> ParsecT String () m String)
-> ParsecT String () m String -> ParsecT String () m String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
">")
                     (ParsecT String () m GeneralInstance
-> ParsecT String () m String -> ParserE m [GeneralInstance]
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 GeneralInstance
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser (ParsecT String () m String -> ParsecT String () m String
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m String -> ParsecT String () m String)
-> ParsecT String () m String -> ParsecT String () m String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
","))

instance ParseFromSource DefinesInstance where
  sourceParser :: ParserE m DefinesInstance
sourceParser = String -> ParserE m DefinesInstance -> ParserE m DefinesInstance
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type" (ParserE m DefinesInstance -> ParserE m DefinesInstance)
-> ParserE m DefinesInstance -> ParserE m DefinesInstance
forall a b. (a -> b) -> a -> b
$ do
    CategoryName
n <- ParserE m CategoryName
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
    [GeneralInstance]
as <- String
-> ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type args" (ParserE m [GeneralInstance] -> ParserE m [GeneralInstance])
-> ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall a b. (a -> b) -> a -> b
$ ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m [GeneralInstance]
args ParserE m [GeneralInstance]
-> ParserE m [GeneralInstance] -> ParserE m [GeneralInstance]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [GeneralInstance] -> ParserE m [GeneralInstance]
forall (m :: * -> *) a. Monad m => a -> m a
return []
    DefinesInstance -> ParserE m DefinesInstance
forall (m :: * -> *) a. Monad m => a -> m a
return (DefinesInstance -> ParserE m DefinesInstance)
-> DefinesInstance -> ParserE m DefinesInstance
forall a b. (a -> b) -> a -> b
$ CategoryName -> InstanceParams -> DefinesInstance
DefinesInstance CategoryName
n ([GeneralInstance] -> InstanceParams
forall a. [a] -> Positional a
Positional [GeneralInstance]
as)
    where
      args :: ParserE m [GeneralInstance]
args = ParsecT String () m String
-> ParsecT String () m String
-> ParserE m [GeneralInstance]
-> ParserE m [GeneralInstance]
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 String -> ParsecT String () m String
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m String -> ParsecT String () m String)
-> ParsecT String () m String -> ParsecT String () m String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
"<")
                     (ParsecT String () m String -> ParsecT String () m String
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m String -> ParsecT String () m String)
-> ParsecT String () m String -> ParsecT String () m String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
">")
                     (ParsecT String () m GeneralInstance
-> ParsecT String () m String -> ParserE m [GeneralInstance]
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 GeneralInstance
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser (ParsecT String () m String -> ParsecT String () m String
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParsecT String () m String -> ParsecT String () m String)
-> ParsecT String () m String -> ParsecT String () m String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
","))

instance ParseFromSource TypeInstanceOrParam where
  sourceParser :: ParserE m TypeInstanceOrParam
sourceParser = ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m TypeInstanceOrParam
param ParserE m TypeInstanceOrParam
-> ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m TypeInstanceOrParam
inst where
    param :: ParserE m TypeInstanceOrParam
param = String
-> ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"param" (ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam)
-> ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall a b. (a -> b) -> a -> b
$ do
      ParamName
n <- ParserE m ParamName
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
      TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeInstanceOrParam -> ParserE m TypeInstanceOrParam)
-> TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall a b. (a -> b) -> a -> b
$ Bool -> ParamName -> TypeInstanceOrParam
JustParamName Bool
False ParamName
n
    inst :: ParserE m TypeInstanceOrParam
inst = String
-> ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"type" (ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam)
-> ParserE m TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall a b. (a -> b) -> a -> b
$ do
      TypeInstance
t <- ParserE m TypeInstance
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
      TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeInstanceOrParam -> ParserE m TypeInstanceOrParam)
-> TypeInstanceOrParam -> ParserE m TypeInstanceOrParam
forall a b. (a -> b) -> a -> b
$ TypeInstance -> TypeInstanceOrParam
JustTypeInstance TypeInstance
t

instance ParseFromSource TypeFilter where
  sourceParser :: ParserE m TypeFilter
sourceParser = ParserE m TypeFilter
requires ParserE m TypeFilter
-> ParserE m TypeFilter -> ParserE m TypeFilter
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m TypeFilter
allows ParserE m TypeFilter
-> ParserE m TypeFilter -> ParserE m TypeFilter
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ParserE m TypeFilter
defines where
    requires :: ParserE m TypeFilter
requires = String -> ParserE m TypeFilter -> ParserE m TypeFilter
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"requires filter" (ParserE m TypeFilter -> ParserE m TypeFilter)
-> ParserE m TypeFilter -> ParserE m TypeFilter
forall a b. (a -> b) -> a -> b
$ do
      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 ()
kwRequires
      TypeInstanceOrParam
t <- ParserE m TypeInstanceOrParam
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
      TypeFilter -> ParserE m TypeFilter
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeFilter -> ParserE m TypeFilter)
-> TypeFilter -> ParserE m TypeFilter
forall a b. (a -> b) -> a -> b
$ FilterDirection -> GeneralInstance -> TypeFilter
TypeFilter FilterDirection
FilterRequires (GeneralInstance -> TypeFilter) -> GeneralInstance -> TypeFilter
forall a b. (a -> b) -> a -> b
$ TypeInstanceOrParam -> GeneralInstance
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType TypeInstanceOrParam
t
    allows :: ParserE m TypeFilter
allows = String -> ParserE m TypeFilter -> ParserE m TypeFilter
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"allows filter" (ParserE m TypeFilter -> ParserE m TypeFilter)
-> ParserE m TypeFilter -> ParserE m TypeFilter
forall a b. (a -> b) -> a -> b
$ do
      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 ()
kwAllows
      TypeInstanceOrParam
t <- ParserE m TypeInstanceOrParam
forall a (m :: * -> *).
(ParseFromSource a, CompileErrorM m) =>
ParserE m a
sourceParser
      TypeFilter -> ParserE m TypeFilter
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeFilter -> ParserE m TypeFilter)
-> TypeFilter -> ParserE m TypeFilter
forall a b. (a -> b) -> a -> b
$ FilterDirection -> GeneralInstance -> TypeFilter
TypeFilter FilterDirection
FilterAllows (GeneralInstance -> TypeFilter) -> GeneralInstance -> TypeFilter
forall a b. (a -> b) -> a -> b
$ TypeInstanceOrParam -> GeneralInstance
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType TypeInstanceOrParam
t
    defines :: ParserE m TypeFilter
defines = String -> ParserE m TypeFilter -> ParserE m TypeFilter
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"defines filter" (ParserE m TypeFilter -> ParserE m TypeFilter)
-> ParserE m TypeFilter -> ParserE m TypeFilter
forall a b. (a -> b) -> a -> b
$ do
      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
      TypeFilter -> ParserE m TypeFilter
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeFilter -> ParserE m TypeFilter)
-> TypeFilter -> ParserE m TypeFilter
forall a b. (a -> b) -> a -> b
$ DefinesInstance -> TypeFilter
DefinesFilter DefinesInstance
t