{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE LambdaCase #-}

module Funcons.Operations.Types where

import Prelude hiding (null)

import Funcons.Operations.Booleans
import Funcons.Operations.Internal
import qualified Data.Set as S
import qualified Data.MultiSet as MS
import qualified Data.Vector as V

library :: (HasValues t, Ord t) => Library t
library :: Library t
library = [(OP, ValueOp t)] -> Library t
forall t. [(OP, ValueOp t)] -> Library t
libFromList [
    (OP
"types", NullaryExpr t -> ValueOp t
forall t. NullaryExpr t -> ValueOp t
NullaryExpr NullaryExpr t
forall t. HasValues t => OpExpr t
types)
  , (OP
"value-types", NullaryExpr t -> ValueOp t
forall t. NullaryExpr t -> ValueOp t
NullaryExpr NullaryExpr t
forall t. HasValues t => OpExpr t
value_types)
  , (OP
"empty-type", NullaryExpr t -> ValueOp t
forall t. NullaryExpr t -> ValueOp t
NullaryExpr NullaryExpr t
forall t. HasValues t => OpExpr t
empty_type)
--  , ("null-type", NullaryExpr nulltype)
--  , ("null", NullaryExpr null)
  , (OP
"values", NullaryExpr t -> ValueOp t
forall t. NullaryExpr t -> ValueOp t
NullaryExpr NullaryExpr t
forall t. HasValues t => OpExpr t
values)
  , (OP
"type-member", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
type_member)
--  , ("is-value", UnaryExpr is_value)
--  , ("is-val", UnaryExpr is_value)
  , (OP
"value-type", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
value_type)
  , (OP
"datatype-values", NullaryExpr t -> ValueOp t
forall t. NullaryExpr t -> ValueOp t
NullaryExpr NullaryExpr t
forall t. HasValues t => OpExpr t
datatype_values)
  , (OP
"ground-values", NullaryExpr t -> ValueOp t
forall t. NullaryExpr t -> ValueOp t
NullaryExpr NullaryExpr t
forall t. HasValues t => OpExpr t
ground_values)
  ]

datatype_values_ :: HasValues t => [OpExpr t] -> OpExpr t
datatype_values_ :: [OpExpr t] -> OpExpr t
datatype_values_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
datatype_values
datatype_values :: HasValues t => OpExpr t
datatype_values :: OpExpr t
datatype_values = OP -> NullaryVOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
vNullaryOp OP
"datatype-values" (t -> NullaryVOp t
forall t. t -> Result t
Normal (t -> NullaryVOp t) -> t -> NullaryVOp t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
ADTs)

ground_values_ :: HasValues t => [OpExpr t] -> OpExpr t
ground_values_ :: [OpExpr t] -> OpExpr t
ground_values_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
ground_values
ground_values :: HasValues t => OpExpr t
ground_values :: OpExpr t
ground_values = OP -> NullaryVOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
vNullaryOp OP
"ground-values" (t -> NullaryVOp t
forall t. t -> Result t
Normal (t -> NullaryVOp t) -> t -> NullaryVOp t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT (Name -> [t] -> Types t
forall t. Name -> [t] -> Types t
ADT Name
"ground-values" []))

types_ :: HasValues t => [OpExpr t] -> OpExpr t
types_ :: [OpExpr t] -> OpExpr t
types_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
types
types :: HasValues t => OpExpr t
types :: OpExpr t
types = OP -> NullaryOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
NullaryOp OP
"types" (t -> NullaryOp t
forall t. t -> Result t
Normal (t -> NullaryOp t) -> t -> NullaryOp t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
Types)

value_types_ :: HasValues t => [OpExpr t] -> OpExpr t
value_types_ :: [OpExpr t] -> OpExpr t
value_types_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
value_types
value_types :: HasValues t => OpExpr t
value_types :: OpExpr t
value_types = OP -> NullaryOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
NullaryOp OP
"value-types" (t -> NullaryOp t
forall t. t -> Result t
Normal (t -> NullaryOp t) -> t -> NullaryOp t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
Types)

empty_type_ :: HasValues t => [OpExpr t] -> OpExpr t
empty_type_ :: [OpExpr t] -> OpExpr t
empty_type_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
empty_type
empty_type :: HasValues t => OpExpr t
empty_type :: OpExpr t
empty_type = OP -> NullaryOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
NullaryOp OP
"empty-types" (t -> NullaryOp t
forall t. t -> Result t
Normal (t -> NullaryOp t) -> t -> NullaryOp t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
EmptyType)

nulltype_ :: HasValues t => [OpExpr t] -> OpExpr t
nulltype_ :: [OpExpr t] -> OpExpr t
nulltype_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
nulltype 
nulltype :: HasValues t => OpExpr t
nulltype :: OpExpr t
nulltype = OP -> NullaryOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
NullaryOp OP
"null-type" (t -> NullaryOp t
forall t. t -> Result t
Normal (t -> NullaryOp t) -> t -> NullaryOp t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
NullType)

null_ :: HasValues t => [OpExpr t] -> OpExpr t
null_ :: [OpExpr t] -> OpExpr t
null_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
null
null :: HasValues t => OpExpr t
null :: OpExpr t
null = OP -> NullaryOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
NullaryOp OP
"null" (t -> NullaryOp t
forall t. t -> Result t
Normal (t -> NullaryOp t) -> t -> NullaryOp t
forall a b. (a -> b) -> a -> b
$ Values t -> t
forall t. HasValues t => Values t -> t
inject Values t
forall t. Values t
null__)

values_ :: HasValues t => [OpExpr t] -> OpExpr t
values_ :: [OpExpr t] -> OpExpr t
values_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
values
values :: HasValues t => OpExpr t
values :: OpExpr t
values = OP -> NullaryOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
NullaryOp OP
"values" (t -> NullaryOp t
forall t. t -> Result t
Normal (t -> NullaryOp t) -> t -> NullaryOp t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
Values)


is_value_ :: HasValues t => [OpExpr t] -> OpExpr t
is_value_ :: [OpExpr t] -> OpExpr t
is_value_ = UnaryExpr t -> [OpExpr t] -> OpExpr t
forall t. UnaryExpr t -> [OpExpr t] -> OpExpr t
unaryOp UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
is_value
is_value :: HasValues t => OpExpr t -> OpExpr t
is_value :: OpExpr t -> OpExpr t
is_value = OP -> UnaryOp t -> OpExpr t -> OpExpr t
forall t. OP -> UnaryOp t -> OpExpr t -> OpExpr t
UnaryOp OP
"is-value" UnaryOp t
forall t p. HasValues t => p -> Result t
op
  where op :: p -> Result t
op p
_ = t -> Result t
forall t. t -> Result t
Normal (t -> Result t) -> t -> Result t
forall a b. (a -> b) -> a -> b
$ Values t -> t
forall t. HasValues t => Values t -> t
inject (Bool -> Values t
forall t. Bool -> Values t
tobool Bool
True) 

value_type_ :: HasValues t => [OpExpr t] -> OpExpr t
value_type_ :: [OpExpr t] -> OpExpr t
value_type_ = UnaryExpr t -> [OpExpr t] -> OpExpr t
forall t. UnaryExpr t -> [OpExpr t] -> OpExpr t
unaryOp UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
value_type
value_type :: HasValues t => OpExpr t -> OpExpr t
value_type :: OpExpr t -> OpExpr t
value_type = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"value-type" (t -> Result t
forall t. t -> Result t
Normal (t -> Result t) -> (Values t -> t) -> UnaryVOp t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Types t -> t
forall t. HasTypes t => Types t -> t
injectT (Types t -> t) -> (Values t -> Types t) -> Values t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Values t -> Types t
forall t. HasValues t => Values t -> Types t
tyOf)
 
tyOf :: HasValues t => Values t -> Types t
tyOf :: Values t -> Types t
tyOf (ADTVal Name
"true" [])         = Name -> [t] -> Types t
forall t. Name -> [t] -> Types t
ADT Name
"booleans" []
tyOf (ADTVal Name
"false" [])        = Name -> [t] -> Types t
forall t. Name -> [t] -> Types t
ADT Name
"booleans" []
tyOf (ADTVal Name
c [t
p]) | Name
c Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
unicode_cons = Types t
forall t. Types t
UnicodeCharacters
tyOf (Int Integer
_)                    = Types t
forall t. Types t
Integers
tyOf (Nat Integer
_)                    = Types t
forall t. Types t
Naturals
tyOf (ADTVal Name
_ [t]
_)               = Types t
forall t. Types t
ADTs
tyOf (Atom OP
_)                   = Types t
forall t. Types t
Atoms
tyOf (ComputationType (Type Types t
_)) = Types t
forall t. Types t
Types
tyOf (ComputationType ComputationTypes t
_)        = Types t
forall t. Types t
ComputationTypes
tyOf (Float Double
f)                  = IEEEFormats -> Types t
forall t. IEEEFormats -> Types t
IEEEFloats IEEEFormats
Binary32 
--tyOf (Type _)                   = Types 
tyOf (IEEE_Float_32 Float
_)          = IEEEFormats -> Types t
forall t. IEEEFormats -> Types t
IEEEFloats IEEEFormats
Binary32 
tyOf (IEEE_Float_64 Double
_)          = IEEEFormats -> Types t
forall t. IEEEFormats -> Types t
IEEEFloats IEEEFormats
Binary64 
tyOf (Rational Rational
_)               = Types t
forall t. Types t
Rationals
tyOf (Map ValueMaps (Values t)
m)                    = t -> t -> Types t
forall t. HasValues t => t -> t -> Types t
maps (Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
Values) (Types t -> t
forall t. HasTypes t => Types t -> t
injectT Types t
forall t. Types t
Values) -- TODO find "strongest common type"
tyOf (Set ValueSets (Values t)
s)                    | ValueSets (Values t) -> Bool
forall a. Set a -> Bool
S.null ValueSets (Values t)
s = Types t -> Types t
forall t. HasValues t => Types t -> Types t
sets Types t
forall t. Types t
Values
                                | Bool
otherwise = Types t -> Types t
forall t. HasValues t => Types t -> Types t
sets (Values t -> Types t
forall t. HasValues t => Values t -> Types t
tyOf (ValueSets (Values t) -> Values t
forall a. Set a -> a
S.findMax ValueSets (Values t)
s))
tyOf (Multiset MultiSet (Values t)
s)               | MultiSet (Values t) -> Bool
forall a. MultiSet a -> Bool
MS.null MultiSet (Values t)
s = Types t -> Types t
forall t. HasValues t => Types t -> Types t
multisets Types t
forall t. Types t
Values
                                | Bool
otherwise = Types t -> Types t
forall t. HasValues t => Types t -> Types t
multisets (Values t -> Types t
forall t. HasValues t => Values t -> Types t
tyOf (MultiSet (Values t) -> Values t
forall a. MultiSet a -> a
MS.findMax MultiSet (Values t)
s)) 
tyOf (Vector ValueVectors (Values t)
v)                 | ValueVectors (Values t) -> Bool
forall a. Vector a -> Bool
V.null ValueVectors (Values t)
v = Types t -> Types t
forall t. HasValues t => Types t -> Types t
vectors Types t
forall t. Types t
Values
                                | Bool
otherwise = Types t -> Types t
forall t. HasValues t => Types t -> Types t
vectors (Values t -> Types t
forall t. HasValues t => Values t -> Types t
tyOf (ValueVectors (Values t)
v ValueVectors (Values t) -> Int -> Values t
forall a. Vector a -> Int -> a
V.! Int
0))
tyOf Values t
VAny                       = Types t
forall t. Types t
Values
tyOf (ValSeq [t]
ts)                = Types t
forall t. Types t
Values

type_member_ :: HasValues t => [OpExpr t] -> OpExpr t
type_member_ :: [OpExpr t] -> OpExpr t
type_member_ = BinaryExpr t -> [OpExpr t] -> OpExpr t
forall t. BinaryExpr t -> [OpExpr t] -> OpExpr t
binaryOp BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
type_member
-- | Type membership check for primitive types and
-- predefined composite types (non-ADTs).
type_member :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
type_member :: OpExpr t -> OpExpr t -> OpExpr t
type_member = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"type-member" BinaryVOp t
forall t t.
(HasValues t, HasValues t) =>
Values t -> Values t -> Result t
op
  where op :: Values t -> Values t -> Result t
op Values t
v Values t
mty = case Values t
mty of
         ComputationType (Type Types t
t) -> Values t -> Types t -> Result t
forall t t.
(HasValues t, HasValues t) =>
Values t -> Types t -> Result t
proceed Values t
v Types t
t
         ComputationType (ComputesType Types t
t) -> Values t -> Types t -> Result t
forall t t.
(HasValues t, HasValues t) =>
Values t -> Types t -> Result t
proceed Values t
v Types t
t
         ComputationType (ComputesFromType Types t
_ Types t
t) -> Values t -> Types t -> Result t
forall t t.
(HasValues t, HasValues t) =>
Values t -> Types t -> Result t
proceed Values t
v Types t
t
         Values t
_ -> OP -> Result t
forall t. OP -> Result t
SortErr OP
"type-member(V,Ty) not applied to a value and a type"
 
        proceed :: Values t -> Types t -> Result t
proceed Values t
v Types t
ty = case Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
ty of
          Maybe Bool
Nothing -> OP -> Result t
forall t. OP -> Result t
DomErr OP
"type-member applied to an ADT or a non-type"
          Just Bool
b  -> t -> Result t
forall t. t -> Result t
Normal (t -> Result t) -> t -> Result t
forall a b. (a -> b) -> a -> b
$ Values t -> t
forall t. HasValues t => Values t -> t
inject (Bool -> Values t
forall t. Bool -> Values t
tobool Bool
b)

isInType :: HasValues t => Values t -> Types t -> Maybe Bool
isInType :: Values t -> Types t -> Maybe Bool
isInType Values t
_ Types t
EmptyType = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
isInType Values t
v Types t
Values = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True --(not (isNull v)) 
isInType Values t
n Types t
NullType = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Values t -> Bool
forall t. Values t -> Bool
isNull Values t
n) 
isInType Values t
v (ADT Name
"ground-values" []) = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Values t -> Bool
forall t. HasValues t => Values t -> Bool
isGround Values t
v)
isInType Values t
v (ADT Name
"strings" []) = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Values t -> Bool
forall t. HasValues t => Values t -> Bool
isString_ Values t
v)
isInType (ADTVal Name
"list" [t]
vs') (ADT Name
"lists" [t
ty']) 
  | Just Types t
ty <- t -> Maybe (Types t)
forall t. HasTypes t => t -> Maybe (Types t)
projectT t
ty', Just [Values t]
vs <- [Maybe (Values t)] -> Maybe [Values t]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ((t -> Maybe (Values t)) -> [t] -> [Maybe (Values t)]
forall a b. (a -> b) -> [a] -> [b]
map t -> Maybe (Values t)
forall t. HasValues t => t -> Maybe (Values t)
project [t]
vs') = 
  [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ([Bool] -> Bool) -> Maybe [Bool] -> Maybe Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Values t -> Maybe Bool) -> [Values t] -> Maybe [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((Values t -> Types t -> Maybe Bool)
-> Types t -> Values t -> Maybe Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Types t
ty) [Values t]
vs

isInType Values t
v (ADT Name
nm [t]
tys) = Maybe Bool
forall a. Maybe a
Nothing
isInType (ADTVal Name
_ [t]
_) Types t
ADTs = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType (Atom OP
_) Types t
Atoms = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType Values t
v Types t
Characters | Just Char
_ <- Values t -> Maybe Char
forall t. HasValues t => Values t -> Maybe Char
upcastCharacter Values t
v = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType Values t
v (IntegersFrom Integer
n) 
    | Int Integer
i <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
v = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
n)
isInType Values t
v (IntegersUpTo Integer
n) 
    | Int Integer
i <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
v = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
n)
isInType (ComputationType ComputationTypes t
_) Types t
Types = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType (ComputationType (ComputesFromType Types t
_ Types t
_)) Types t
ComputationTypes = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType (ComputationType (ComputesType Types t
_)) Types t
ComputationTypes = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType (ComputationType (Type Types t
_)) Types t
ComputationTypes = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType (IEEE_Float_32 Float
_) (IEEEFloats IEEEFormats
Binary32) = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType (IEEE_Float_64 Double
_) (IEEEFloats IEEEFormats
Binary64) = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType Values t
v Types t
Integers | Int Integer
_ <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
v = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType Values t
v Types t
Naturals | Nat Integer
_ <- Values t -> Values t
forall t. Values t -> Values t
upcastNaturals Values t
v = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType Values t
v Types t
Rationals | Rational Rational
_ <- Values t -> Values t
forall t. Values t -> Values t
upcastRationals Values t
v = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True 
isInType (ADTVal Name
c [t
p]) Types t
UnicodeCharacters |  Name
c Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
unicode_cons = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True
isInType Values t
v Types t
AsciiCharacters = Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
forall t. Types t
UnicodeCharacters -- requires interpreter to check whether character is in the character range 
isInType Values t
v Types t
ISOLatinCharacters = Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
forall t. Types t
UnicodeCharacters -- requires interpreter to check whether character is in the character range 
isInType Values t
v Types t
BMPCharacters = Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
forall t. Types t
UnicodeCharacters -- requires interpreter to check whether character is in the character range 
isInType Values t
v (Union Types t
ty1 Types t
ty2) = Bool -> Bool -> Bool
(||) (Bool -> Bool -> Bool) -> Maybe Bool -> Maybe (Bool -> Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
ty1 Maybe (Bool -> Bool) -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
ty2
isInType Values t
v (Complement Types t
ty) = Bool -> Bool
not (Bool -> Bool) -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
ty
isInType Values t
v (Intersection Types t
ty1 Types t
ty2) = Bool -> Bool -> Bool
(&&) (Bool -> Bool -> Bool) -> Maybe Bool -> Maybe (Bool -> Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
ty1 Maybe (Bool -> Bool) -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType Values t
v Types t
ty2
isInType Values t
_ Types t
_ = Bool -> Maybe Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False

isInTupleType :: HasValues t => [Values t] -> [Types t] -> Maybe Bool
isInTupleType :: [Values t] -> [Types t] -> Maybe Bool
isInTupleType [Values t]
vs [Types t]
ttparams = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ([Bool] -> Bool) -> Maybe [Bool] -> Maybe Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Maybe Bool] -> Maybe [Bool]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ((Values t -> Types t -> Maybe Bool)
-> [Values t] -> [Types t] -> [Maybe Bool]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Values t -> Types t -> Maybe Bool
forall t. HasValues t => Values t -> Types t -> Maybe Bool
isInType [Values t]
vs [Types t]
ttparams)