{- -----------------------------------------------------------------------------
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 :: Parser GeneralInstance
sourceParser = Parser GeneralInstance -> Parser GeneralInstance
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser GeneralInstance
allT Parser GeneralInstance
-> Parser GeneralInstance -> Parser GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser GeneralInstance -> Parser GeneralInstance
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser GeneralInstance
anyT Parser GeneralInstance
-> Parser GeneralInstance -> Parser GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser GeneralInstance
intersectOrUnion Parser GeneralInstance
-> Parser GeneralInstance -> Parser GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser GeneralInstance
single where
    allT :: Parser GeneralInstance
allT = String -> Parser GeneralInstance -> Parser GeneralInstance
forall a. String -> Parser a -> Parser a
labeled String
"all" (Parser GeneralInstance -> Parser GeneralInstance)
-> Parser GeneralInstance -> Parser GeneralInstance
forall a b. (a -> b) -> a -> b
$ do
      Parser ()
kwAll
      GeneralInstance -> Parser GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
forall a. Bounded a => a
minBound
    anyT :: Parser GeneralInstance
anyT = String -> Parser GeneralInstance -> Parser GeneralInstance
forall a. String -> Parser a -> Parser a
labeled String
"any" (Parser GeneralInstance -> Parser GeneralInstance)
-> Parser GeneralInstance -> Parser GeneralInstance
forall a b. (a -> b) -> a -> b
$ do
      Parser ()
kwAny
      GeneralInstance -> Parser GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
forall a. Bounded a => a
maxBound
    intersectOrUnion :: Parser GeneralInstance
intersectOrUnion = String -> Parser GeneralInstance -> Parser GeneralInstance
forall a. String -> Parser a -> Parser a
labeled String
"union or intersection" (Parser GeneralInstance -> Parser GeneralInstance)
-> Parser GeneralInstance -> Parser GeneralInstance
forall a b. (a -> b) -> a -> b
$ do
      Parser () -> Parser ()
forall a. Parser a -> Parser a
sepAfter (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$ String -> Parser ()
string_ String
"["
      GeneralInstance
t1 <- String -> Parser GeneralInstance -> Parser GeneralInstance
forall a. String -> Parser a -> Parser a
labeled String
"type" (Parser GeneralInstance -> Parser GeneralInstance)
-> Parser GeneralInstance -> Parser GeneralInstance
forall a b. (a -> b) -> a -> b
$ Parser GeneralInstance -> Parser GeneralInstance
forall a. Parser a -> Parser a
sepAfter Parser GeneralInstance
forall a. ParseFromSource a => Parser a
sourceParser
      GeneralInstance
t <- GeneralInstance -> Parser GeneralInstance
forall b.
(ParseFromSource b, Mergeable b) =>
b -> ParsecT String () Identity b
intersect GeneralInstance
t1 Parser GeneralInstance
-> Parser GeneralInstance -> Parser GeneralInstance
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> GeneralInstance -> Parser GeneralInstance
forall b.
(ParseFromSource b, Mergeable b) =>
b -> ParsecT String () Identity b
union GeneralInstance
t1
      Parser () -> Parser ()
forall a. Parser a -> Parser a
sepAfter (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$ String -> Parser ()
string_ String
"]"
      GeneralInstance -> Parser GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
t
    intersect :: b -> ParsecT String () Identity b
intersect b
t1 = do
      [b]
ts <- ParsecT String () Identity b -> ParsecT String () Identity [b]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (Parser () -> Parser ()
forall a. Parser a -> Parser a
sepAfter (String -> Parser ()
string_ String
"&") Parser ()
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall a. String -> Parser a -> Parser a
labeled String
"type" ParsecT String () Identity b
forall a. ParseFromSource a => Parser a
sourceParser)
      b -> ParsecT String () Identity b
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> ParsecT String () Identity b)
-> b -> ParsecT String () Identity 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 () Identity b
union b
t1 = do
      [b]
ts <- ParsecT String () Identity b -> ParsecT String () Identity [b]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (Parser () -> Parser ()
forall a. Parser a -> Parser a
sepAfter (String -> Parser ()
string_ String
"|") Parser ()
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String
-> ParsecT String () Identity b -> ParsecT String () Identity b
forall a. String -> Parser a -> Parser a
labeled String
"type" ParsecT String () Identity b
forall a. ParseFromSource a => Parser a
sourceParser)
      b -> ParsecT String () Identity b
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> ParsecT String () Identity b)
-> b -> ParsecT String () Identity 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 :: Parser GeneralInstance
single = do
      TypeInstanceOrParam
t <- Parser TypeInstanceOrParam
forall a. ParseFromSource a => Parser a
sourceParser
      GeneralInstance -> Parser GeneralInstance
forall (m :: * -> *) a. Monad m => a -> m a
return (GeneralInstance -> Parser GeneralInstance)
-> GeneralInstance -> Parser 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 :: Parser ValueType
sourceParser = do
    StorageType
r <- Parser StorageType
getWeak Parser StorageType -> Parser StorageType -> Parser StorageType
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser StorageType
getOptional Parser StorageType -> Parser StorageType -> Parser StorageType
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser StorageType
getRequired
    GeneralInstance
t <- Parser GeneralInstance
forall a. ParseFromSource a => Parser a
sourceParser
    ValueType -> Parser ValueType
forall (m :: * -> *) a. Monad m => a -> m a
return (ValueType -> Parser ValueType) -> ValueType -> Parser ValueType
forall a b. (a -> b) -> a -> b
$ StorageType -> GeneralInstance -> ValueType
ValueType StorageType
r GeneralInstance
t
    where
      getWeak :: Parser StorageType
getWeak = String -> Parser StorageType -> Parser StorageType
forall a. String -> Parser a -> Parser a
labeled String
"weak" (Parser StorageType -> Parser StorageType)
-> Parser StorageType -> Parser StorageType
forall a b. (a -> b) -> a -> b
$ do
        Parser () -> Parser ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser ()
kwWeak
        StorageType -> Parser StorageType
forall (m :: * -> *) a. Monad m => a -> m a
return StorageType
WeakValue
      getOptional :: Parser StorageType
getOptional = String -> Parser StorageType -> Parser StorageType
forall a. String -> Parser a -> Parser a
labeled String
"optional" (Parser StorageType -> Parser StorageType)
-> Parser StorageType -> Parser StorageType
forall a b. (a -> b) -> a -> b
$ do
        Parser () -> Parser ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser ()
kwOptional
        StorageType -> Parser StorageType
forall (m :: * -> *) a. Monad m => a -> m a
return StorageType
OptionalValue
      getRequired :: Parser StorageType
getRequired = StorageType -> Parser StorageType
forall (m :: * -> *) a. Monad m => a -> m a
return StorageType
RequiredValue

instance ParseFromSource CategoryName where
  sourceParser :: Parser CategoryName
sourceParser = String -> Parser CategoryName -> Parser CategoryName
forall a. String -> Parser a -> Parser a
labeled String
"type name" (Parser CategoryName -> Parser CategoryName)
-> Parser CategoryName -> Parser CategoryName
forall a b. (a -> b) -> a -> b
$ do
    Parser ()
noKeywords
    Char
b <- ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
upper
    String
e <- Parser String -> Parser String
forall a. Parser a -> Parser a
sepAfter (Parser String -> Parser String) -> Parser String -> Parser String
forall a b. (a -> b) -> a -> b
$ ParsecT String () Identity Char -> Parser String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum
    CategoryName -> Parser CategoryName
forall (m :: * -> *) a. Monad m => a -> m a
return (CategoryName -> Parser CategoryName)
-> CategoryName -> Parser 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 :: Parser ParamName
sourceParser = String -> Parser ParamName -> Parser ParamName
forall a. String -> Parser a -> Parser a
labeled String
"param name" (Parser ParamName -> Parser ParamName)
-> Parser ParamName -> Parser ParamName
forall a b. (a -> b) -> a -> b
$ do
    Parser ()
noKeywords
    Char -> Parser ()
char_ Char
'#'
    Char
b <- ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
lower
    String
e <- Parser String -> Parser String
forall a. Parser a -> Parser a
sepAfter (Parser String -> Parser String) -> Parser String -> Parser String
forall a b. (a -> b) -> a -> b
$ ParsecT String () Identity Char -> Parser String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT String () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum
    ParamName -> Parser ParamName
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamName -> Parser ParamName) -> ParamName -> Parser 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 :: Parser TypeInstance
sourceParser = String -> Parser TypeInstance -> Parser TypeInstance
forall a. String -> Parser a -> Parser a
labeled String
"type" (Parser TypeInstance -> Parser TypeInstance)
-> Parser TypeInstance -> Parser TypeInstance
forall a b. (a -> b) -> a -> b
$ do
    CategoryName
n <- Parser CategoryName
forall a. ParseFromSource a => Parser a
sourceParser
    [GeneralInstance]
as <- String -> Parser [GeneralInstance] -> Parser [GeneralInstance]
forall a. String -> Parser a -> Parser a
labeled String
"type args" (Parser [GeneralInstance] -> Parser [GeneralInstance])
-> Parser [GeneralInstance] -> Parser [GeneralInstance]
forall a b. (a -> b) -> a -> b
$ Parser [GeneralInstance] -> Parser [GeneralInstance]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser [GeneralInstance]
args Parser [GeneralInstance]
-> Parser [GeneralInstance] -> Parser [GeneralInstance]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [GeneralInstance] -> Parser [GeneralInstance]
forall (m :: * -> *) a. Monad m => a -> m a
return []
    TypeInstance -> Parser TypeInstance
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeInstance -> Parser TypeInstance)
-> TypeInstance -> Parser 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 :: Parser [GeneralInstance]
args = Parser String
-> Parser String
-> Parser [GeneralInstance]
-> Parser [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 (Parser String -> Parser String
forall a. Parser a -> Parser a
sepAfter (Parser String -> Parser String) -> Parser String -> Parser String
forall a b. (a -> b) -> a -> b
$ String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
"<")
                     (Parser String -> Parser String
forall a. Parser a -> Parser a
sepAfter (Parser String -> Parser String) -> Parser String -> Parser String
forall a b. (a -> b) -> a -> b
$ String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
">")
                     (Parser GeneralInstance -> Parser String -> Parser [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 Parser GeneralInstance
forall a. ParseFromSource a => Parser a
sourceParser (Parser String -> Parser String
forall a. Parser a -> Parser a
sepAfter (Parser String -> Parser String) -> Parser String -> Parser String
forall a b. (a -> b) -> a -> b
$ String -> Parser String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
","))

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

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

instance ParseFromSource TypeFilter where
  sourceParser :: Parser TypeFilter
sourceParser = Parser TypeFilter
requires Parser TypeFilter -> Parser TypeFilter -> Parser TypeFilter
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TypeFilter
allows Parser TypeFilter -> Parser TypeFilter -> Parser TypeFilter
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser TypeFilter
defines where
    requires :: Parser TypeFilter
requires = String -> Parser TypeFilter -> Parser TypeFilter
forall a. String -> Parser a -> Parser a
labeled String
"requires filter" (Parser TypeFilter -> Parser TypeFilter)
-> Parser TypeFilter -> Parser TypeFilter
forall a b. (a -> b) -> a -> b
$ do
      Parser () -> Parser ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser ()
kwRequires
      TypeInstanceOrParam
t <- Parser TypeInstanceOrParam
forall a. ParseFromSource a => Parser a
sourceParser
      TypeFilter -> Parser TypeFilter
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeFilter -> Parser TypeFilter)
-> TypeFilter -> Parser 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 :: Parser TypeFilter
allows = String -> Parser TypeFilter -> Parser TypeFilter
forall a. String -> Parser a -> Parser a
labeled String
"allows filter" (Parser TypeFilter -> Parser TypeFilter)
-> Parser TypeFilter -> Parser TypeFilter
forall a b. (a -> b) -> a -> b
$ do
      Parser () -> Parser ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser ()
kwAllows
      TypeInstanceOrParam
t <- Parser TypeInstanceOrParam
forall a. ParseFromSource a => Parser a
sourceParser
      TypeFilter -> Parser TypeFilter
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeFilter -> Parser TypeFilter)
-> TypeFilter -> Parser 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 :: Parser TypeFilter
defines = String -> Parser TypeFilter -> Parser TypeFilter
forall a. String -> Parser a -> Parser a
labeled String
"defines filter" (Parser TypeFilter -> Parser TypeFilter)
-> Parser TypeFilter -> Parser TypeFilter
forall a b. (a -> b) -> a -> b
$ do
      Parser () -> Parser ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try Parser ()
kwDefines
      DefinesInstance
t <- Parser DefinesInstance
forall a. ParseFromSource a => Parser a
sourceParser
      TypeFilter -> Parser TypeFilter
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeFilter -> Parser TypeFilter)
-> TypeFilter -> Parser TypeFilter
forall a b. (a -> b) -> a -> b
$ DefinesInstance -> TypeFilter
DefinesFilter DefinesInstance
t