{-# LANGUAGE OverloadedStrings #-}
module Funcons.Operations.Integers where
import Funcons.Operations.Internal hiding (isInt)
import Funcons.Operations.Types
import Funcons.Operations.Booleans (tobool)
import Data.Char
import Numeric
library :: HasValues t => Library t
library :: Library t
library = [(OP, ValueOp t)] -> Library t
forall t. [(OP, ValueOp t)] -> Library t
libFromList [
(OP
"integers", NullaryExpr t -> ValueOp t
forall t. NullaryExpr t -> ValueOp t
NullaryExpr NullaryExpr t
forall t. HasValues t => OpExpr t
integers)
, (OP
"integers-from", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
integers_from)
, (OP
"from", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
integers_from)
, (OP
"integers-up-to", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
integers_up_to)
, (OP
"up-to", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
integers_up_to)
, (OP
"is-integer", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
is_integer)
, (OP
"is-int", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
is_integer)
, (OP
"int-add", NaryExpr t -> ValueOp t
forall t. NaryExpr t -> ValueOp t
NaryExpr NaryExpr t
forall t. HasValues t => [OpExpr t] -> OpExpr t
integer_add_)
, (OP
"integer-add", NaryExpr t -> ValueOp t
forall t. NaryExpr t -> ValueOp t
NaryExpr NaryExpr t
forall t. HasValues t => [OpExpr t] -> OpExpr t
integer_add_)
, (OP
"int-sub", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_subtract)
, (OP
"integer-subtract", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_subtract)
, (OP
"integer-sub", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_subtract)
, (OP
"integer-modulo", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
stepMod)
, (OP
"integer-mod", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
stepMod)
, (OP
"int-mod", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
stepMod)
, (OP
"integer-multiply", NaryExpr t -> ValueOp t
forall t. NaryExpr t -> ValueOp t
NaryExpr NaryExpr t
forall t. HasValues t => [OpExpr t] -> OpExpr t
integer_multiply_)
, (OP
"int-mul", NaryExpr t -> ValueOp t
forall t. NaryExpr t -> ValueOp t
NaryExpr NaryExpr t
forall t. HasValues t => [OpExpr t] -> OpExpr t
integer_multiply_)
, (OP
"integer-divide", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_divide)
, (OP
"int-div", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_divide)
, (OP
"integer-power", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_power)
, (OP
"int-pow", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_power)
, (OP
"integer-list", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_list)
, (OP
"integer-absolute-value", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
integer_absolute_value)
, (OP
"decimal-natural", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
decimal_natural)
, (OP
"decimal", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
decimal_natural)
, (OP
"hexadecimal-natural", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
hexadecimal_natural)
, (OP
"hexadecimal", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
hexadecimal_natural)
, (OP
"binary-natural", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
binary_natural)
, (OP
"binary", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
binary_natural)
, (OP
"octal-natural", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
octal_natural)
, (OP
"octal", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
octal_natural)
, (OP
"natural-predecessor", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
natural_predecessor)
, (OP
"nat-pred", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
natural_predecessor)
, (OP
"natural-successor", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
natural_successor)
, (OP
"nat-successor", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
natural_successor)
, (OP
"nat-succ", UnaryExpr t -> ValueOp t
forall t. UnaryExpr t -> ValueOp t
UnaryExpr UnaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t
natural_successor)
, (OP
"integer-is-less", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_less)
, (OP
"is-less", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_less)
, (OP
"is-less-or-equal", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_less_or_equal)
, (OP
"integer-is-less-or-equal", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_less_or_equal)
, (OP
"is-greater", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_greater)
, (OP
"integer-is-greater", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_greater)
, (OP
"is-greater-or-equal", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_greater_or_equal)
, (OP
"integer-is-greater-or-equal", BinaryExpr t -> ValueOp t
forall t. BinaryExpr t -> ValueOp t
BinaryExpr BinaryExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_greater_or_equal)
]
integer_modulo_, integer_mod_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_mod_ :: [OpExpr t] -> OpExpr t
integer_mod_ = 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
stepMod
integer_modulo_ :: [OpExpr t] -> OpExpr t
integer_modulo_ = 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
stepMod
stepMod :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
stepMod :: OpExpr t -> OpExpr t -> OpExpr t
stepMod = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"mod" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy | (Int Integer
x, Int Integer
y)<- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy)
= if Integer
y Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 then 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 Values t
forall t. Values t
null__
else 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
mk_integers (Integer -> Values t) -> Integer -> Values t
forall a b. (a -> b) -> a -> b
$ Integer
x Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`mod` Integer
y
op Values t
_ Values t
_ = OP -> Result t
forall t. OP -> Result t
SortErr OP
"mod not applied to integers"
integers_ :: HasValues t => [OpExpr t] -> OpExpr t
integers_ :: [OpExpr t] -> OpExpr t
integers_ = OpExpr t -> [OpExpr t] -> OpExpr t
forall t. NullaryExpr t -> [NullaryExpr t] -> NullaryExpr t
nullaryOp OpExpr t
forall t. HasValues t => OpExpr t
integers
integers :: HasValues t => OpExpr t
integers :: OpExpr t
integers = OP -> NullaryVOp t -> OpExpr t
forall t. OP -> NullaryVOp t -> OpExpr t
vNullaryOp OP
"integers" (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
Integers)
integers_from_ :: HasValues t => [OpExpr t] -> OpExpr t
integers_from_ :: [OpExpr t] -> OpExpr t
integers_from_ = 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
integers_from
integers_from :: HasValues t => OpExpr t -> OpExpr t
integers_from :: OpExpr t -> OpExpr t
integers_from = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"integers-from" UnaryVOp t
forall t t. HasValues t => Values t -> Result t
op
where op :: Values t -> Result t
op Values t
v | Int Integer
i <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
v = t -> Result t
forall t. t -> Result t
Normal (t -> Result t) -> t -> Result t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT (Types t -> t) -> Types t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Types t
forall t. Integer -> Types t
IntegersFrom Integer
i
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integers-from not applied to an integer"
integers_up_to_ :: HasValues t => [OpExpr t] -> OpExpr t
integers_up_to_ :: [OpExpr t] -> OpExpr t
integers_up_to_ = 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
integers_up_to
integers_up_to :: HasValues t => OpExpr t -> OpExpr t
integers_up_to :: OpExpr t -> OpExpr t
integers_up_to = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"integers-up-to" UnaryVOp t
forall t t. HasValues t => Values t -> Result t
op
where op :: Values t -> Result t
op Values t
v | Int Integer
i <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
v = t -> Result t
forall t. t -> Result t
Normal (t -> Result t) -> t -> Result t
forall a b. (a -> b) -> a -> b
$ Types t -> t
forall t. HasTypes t => Types t -> t
injectT (Types t -> t) -> Types t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Types t
forall t. Integer -> Types t
IntegersUpTo Integer
i
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integers-up-to not applied to an integer"
is_integer_ :: HasValues t => [OpExpr t] -> OpExpr t
is_integer_ :: [OpExpr t] -> OpExpr t
is_integer_ = 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_integer
is_integer :: HasValues t => OpExpr t -> OpExpr t
is_integer :: OpExpr t -> OpExpr t
is_integer OpExpr t
x = OP -> OpExpr t -> [OpExpr t] -> OpExpr t
forall t. OP -> OpExpr t -> [OpExpr t] -> OpExpr t
RewritesTo OP
"is-integer" (OpExpr t -> OpExpr t -> OpExpr t
forall t. HasValues t => OpExpr t -> OpExpr t -> OpExpr t
type_member OpExpr t
x (Values t -> OpExpr t
forall t. Values t -> OpExpr t
ValExpr (ComputationTypes t -> Values t
forall t. ComputationTypes t -> Values t
ComputationType (Types t -> ComputationTypes t
forall t. Types t -> ComputationTypes t
Type Types t
forall t. Types t
Integers)))) [OpExpr t
x]
isInt :: Values t -> Bool
isInt :: Values t -> Bool
isInt Values t
x | Int Integer
i <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
x = Bool
True
| Bool
otherwise = Bool
False
unInt :: Values t -> Integer
unInt Values t
x | Int Integer
i <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
x = Integer
i
| Bool
otherwise = OP -> Integer
forall a. HasCallStack => OP -> a
error OP
"unInt"
integer_add_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_add_ :: [OpExpr t] -> OpExpr t
integer_add_ = OP -> NaryVOp t -> [OpExpr t] -> OpExpr t
forall t. HasValues t => OP -> NaryVOp t -> [OpExpr t] -> OpExpr t
vNaryOp OP
"integer-add" NaryVOp t
forall t t. HasValues t => [Values t] -> Result t
op
where op :: [Values t] -> Result t
op [Values t]
xs | (Values t -> Bool) -> [Values t] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Values t -> Bool
forall t. Values t -> Bool
isInt [Values t]
xs = 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
mk_integers (Integer -> Values t) -> Integer -> Values t
forall a b. (a -> b) -> a -> b
$ [Integer] -> Integer
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ((Values t -> Integer) -> [Values t] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
map Values t -> Integer
forall t. Values t -> Integer
unInt [Values t]
xs)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integer-add not applied to integers"
integer_multiply_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_multiply_ :: [OpExpr t] -> OpExpr t
integer_multiply_ = OP -> NaryVOp t -> [OpExpr t] -> OpExpr t
forall t. HasValues t => OP -> NaryVOp t -> [OpExpr t] -> OpExpr t
vNaryOp OP
"integer-multiply" NaryVOp t
forall t t. HasValues t => [Values t] -> Result t
op
where op :: [Values t] -> Result t
op [Values t]
xs | (Values t -> Bool) -> [Values t] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Values t -> Bool
forall t. Values t -> Bool
isInt [Values t]
xs = 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
mk_integers (Integer -> Values t) -> Integer -> Values t
forall a b. (a -> b) -> a -> b
$ [Integer] -> Integer
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product ((Values t -> Integer) -> [Values t] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
map Values t -> Integer
forall t. Values t -> Integer
unInt [Values t]
xs)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integer-multiply not applied to integers"
integer_subtract_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_subtract_ :: [OpExpr t] -> OpExpr t
integer_subtract_ = 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
integer_subtract
integer_subtract :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_subtract :: OpExpr t -> OpExpr t -> OpExpr t
integer_subtract = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"integer-subtract" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy | Int Integer
x <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx
, Int Integer
y <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy = 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
mk_integers (Integer -> Values t) -> Integer -> Values t
forall a b. (a -> b) -> a -> b
$ (Integer
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
y)
op Values t
_ Values t
_ = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integer-subtract not applied to integers"
integer_divide_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_divide_ :: [OpExpr t] -> OpExpr t
integer_divide_ = 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
integer_divide
integer_divide :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_divide :: OpExpr t -> OpExpr t -> OpExpr t
integer_divide = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"integer-divide" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy
| (Int Integer
x,Int Integer
y) <- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy) =
if Integer
y Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
then 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 Values t
forall t. Values t
null__
else 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
mk_integers (Integer -> Values t) -> Integer -> Values t
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => Integer -> a
fromInteger (Integer
x Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`div` Integer
y)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integer-divide not applied to ints"
integer_power_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_power_ :: [OpExpr t] -> OpExpr t
integer_power_ = 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
integer_power
integer_power :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_power :: OpExpr t -> OpExpr t -> OpExpr t
integer_power = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"integer-power" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy
| (Int Integer
x, Int Integer
y) <- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy) =
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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
mk_integers (Integer -> Values t) -> Integer -> Values t
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => Integer -> a
fromInteger (Integer -> Integer) -> Integer -> Integer
forall a b. (a -> b) -> a -> b
$(Integer
x Integer -> Integer -> Integer
forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
y)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integer-power not applied to two integers"
natural_predecessor_, nat_pred_ :: HasValues t => [OpExpr t] -> OpExpr t
natural_predecessor_ :: [OpExpr t] -> OpExpr t
natural_predecessor_ = 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
natural_predecessor
nat_pred_ :: [OpExpr t] -> OpExpr t
nat_pred_ = 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
natural_predecessor
natural_predecessor :: HasValues t => OpExpr t -> OpExpr t
natural_predecessor :: OpExpr t -> OpExpr t
natural_predecessor = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"natural-predecessor" UnaryVOp t
forall t t. HasValues t => Values t -> Result t
op
where op :: Values t -> Result t
op Values t
x | Nat Integer
n <- Values t -> Values t
forall t. Values t -> Values t
upcastNaturals Values t
x =
if Integer
n Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 then 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 Values t
forall t. Values t
null__
else 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
Nat (Integer
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"natural-pred not applied to a natural number"
natural_successor_, nat_succ_ :: HasValues t => [OpExpr t] -> OpExpr t
natural_successor_ :: [OpExpr t] -> OpExpr t
natural_successor_ = [OpExpr t] -> OpExpr t
forall t. HasValues t => [OpExpr t] -> OpExpr t
nat_succ_
nat_succ_ :: [OpExpr t] -> OpExpr t
nat_succ_ = 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
natural_successor
natural_successor :: HasValues t => OpExpr t -> OpExpr t
natural_successor :: OpExpr t -> OpExpr t
natural_successor = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"natural-successor" UnaryVOp t
forall t t. HasValues t => Values t -> Result t
op
where op :: Values t -> Result t
op Values t
x | Nat Integer
n <- Values t -> Values t
forall t. Values t -> Values t
upcastNaturals Values t
x = 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
Nat (Integer
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"natural-succ not applied to a natural number"
integer_list_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_list_ :: [OpExpr t] -> OpExpr t
integer_list_ = 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
integer_list
integer_list :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
integer_list :: OpExpr t -> OpExpr t -> OpExpr t
integer_list = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"integer-list" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vi1 Values t
vi2
| (Int Integer
i1, Int Integer
i2) <- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vi1, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vi2)
= 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Name -> [t] -> Values t
forall t. Name -> [t] -> Values t
ADTVal Name
"list" ((Integer -> t) -> [Integer] -> [t]
forall a b. (a -> b) -> [a] -> [b]
map (Values t -> t
forall t. HasValues t => Values t -> t
inject (Values t -> t) -> (Integer -> Values t) -> Integer -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Values t
forall t. Integer -> Values t
Int) [Integer
i1.. Integer
i2])
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"integer-list not applied to two integers"
integer_absolute_value_ :: HasValues t => [OpExpr t] -> OpExpr t
integer_absolute_value_ :: [OpExpr t] -> OpExpr t
integer_absolute_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
integer_absolute_value
integer_absolute_value :: HasValues t => OpExpr t -> OpExpr t
integer_absolute_value :: OpExpr t -> OpExpr t
integer_absolute_value = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"integer-absolute-value" UnaryVOp t
forall t t. HasValues t => Values t -> Result t
op
where op :: Values t -> Result t
op Values t
v | Int Integer
i <- Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
v =
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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
Int (Integer -> Integer
forall a. Num a => a -> a
Prelude.abs Integer
i)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"sort check: integer-absolute-value(I1)"
decimal_natural_ :: HasValues t => [OpExpr t] -> OpExpr t
decimal_natural_ :: [OpExpr t] -> OpExpr t
decimal_natural_ = 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
decimal_natural
decimal_natural :: HasValues t => OpExpr t -> OpExpr t
decimal_natural :: OpExpr t -> OpExpr t
decimal_natural = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"decimal-natural" UnaryVOp t
forall t. HasValues t => Values t -> Result t
op
where op :: HasValues t => Values t -> Result t
op :: Values t -> Result t
op Values t
s | Values t -> Bool
forall t. HasValues t => Values t -> Bool
isString_ Values t
s = 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
Nat (OP -> Integer
forall a. Read a => OP -> a
read (Values t -> OP
forall t. HasValues t => Values t -> OP
unString Values t
s))
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"decimal-natural not applied to a string"
binary_natural_ :: HasValues t => [OpExpr t] -> OpExpr t
binary_natural_ :: [OpExpr t] -> OpExpr t
binary_natural_ = 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
decimal_natural
binary_natural :: HasValues t => OpExpr t -> OpExpr t
binary_natural :: OpExpr t -> OpExpr t
binary_natural = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"binary-natural" UnaryVOp t
forall t. HasValues t => Values t -> Result t
op
where op :: HasValues t => Values t -> Result t
op :: Values t -> Result t
op Values t
s | Values t -> Bool
forall t. HasValues t => Values t -> Bool
isString_ Values t
s = case Integer -> (Char -> Bool) -> (Char -> Int) -> ReadS Integer
forall a. Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
readInt Integer
2 (Char -> OP -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char
'0'..Char
'1']) Char -> Int
digitToInt (Values t -> OP
forall t. HasValues t => Values t -> OP
unString Values t
s) of
[(Integer
i,OP
"")] -> 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
Nat Integer
i
[(Integer, OP)]
_ -> OP -> Result t
forall t. OP -> Result t
SortErr OP
"binary-natural not applied to a binary number"
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"binary-natural not applied to a string"
octal_natural_ :: HasValues t => [OpExpr t] -> OpExpr t
octal_natural_ :: [OpExpr t] -> OpExpr t
octal_natural_ = 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
decimal_natural
octal_natural :: HasValues t => OpExpr t -> OpExpr t
octal_natural :: OpExpr t -> OpExpr t
octal_natural = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"octal-natural" UnaryVOp t
forall t. HasValues t => Values t -> Result t
op
where op :: HasValues t => Values t -> Result t
op :: Values t -> Result t
op Values t
s | Values t -> Bool
forall t. HasValues t => Values t -> Bool
isString_ Values t
s = case Integer -> (Char -> Bool) -> (Char -> Int) -> ReadS Integer
forall a. Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
readInt Integer
8 (Char -> OP -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char
'0'..Char
'7']) Char -> Int
digitToInt (Values t -> OP
forall t. HasValues t => Values t -> OP
unString Values t
s) of
[(Integer
i,OP
"")] -> 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
Nat Integer
i
[(Integer, OP)]
_ -> OP -> Result t
forall t. OP -> Result t
SortErr OP
"octal-natural not applied to a octal number"
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"octal-natural not applied to a string"
hexadecimal_natural_ :: HasValues t => [OpExpr t] -> OpExpr t
hexadecimal_natural_ :: [OpExpr t] -> OpExpr t
hexadecimal_natural_ = 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
hexadecimal_natural
hexadecimal_natural :: HasValues t => OpExpr t -> OpExpr t
hexadecimal_natural :: OpExpr t -> OpExpr t
hexadecimal_natural = OP -> UnaryVOp t -> OpExpr t -> OpExpr t
forall t. HasValues t => OP -> UnaryVOp t -> OpExpr t -> OpExpr t
vUnaryOp OP
"hexadecimal-natural" UnaryVOp t
forall t. HasValues t => Values t -> Result t
op
where op :: HasValues t => Values t -> Result t
op :: Values t -> Result t
op Values t
s | Values t -> Bool
forall t. HasValues t => Values t -> Bool
isString_ Values t
s = case Integer -> (Char -> Bool) -> (Char -> Int) -> ReadS Integer
forall a. Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
readInt Integer
16 (Char -> OP -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Char
'0'..Char
'9'] OP -> OP -> OP
forall a. [a] -> [a] -> [a]
++ [Char
'a'..Char
'f'] OP -> OP -> OP
forall a. [a] -> [a] -> [a]
++ [Char
'A'..Char
'F'])) Char -> Int
digitToInt (Values t -> OP
forall t. HasValues t => Values t -> OP
unString Values t
s) of
[(Integer
i,OP
"")] -> 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Integer -> Values t
forall t. Integer -> Values t
Nat Integer
i
[(Integer, OP)]
_ -> OP -> Result t
forall t. OP -> Result t
SortErr OP
"hexadecimal-natural not applied to a hexadecimal number"
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"hexadecimal-natural not applied to a string"
is_less_ :: HasValues t => [OpExpr t] -> OpExpr t
is_less_ :: [OpExpr t] -> OpExpr t
is_less_ = 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
is_less
is_less :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_less :: OpExpr t -> OpExpr t -> OpExpr t
is_less = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"is-less" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy
| (Int Integer
x, Int Integer
y) <- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy)
= 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Bool -> Values t
forall t. Bool -> Values t
tobool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
y)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"is-less not applied to rationals"
is_less_or_equal_ :: HasValues t => [OpExpr t] -> OpExpr t
is_less_or_equal_ :: [OpExpr t] -> OpExpr t
is_less_or_equal_ = 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
is_less_or_equal
is_less_or_equal :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_less_or_equal :: OpExpr t -> OpExpr t -> OpExpr t
is_less_or_equal = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"is-less-or-equal" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy
| (Int Integer
x, Int Integer
y) <- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy)
= 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Bool -> Values t
forall t. Bool -> Values t
tobool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
y)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"is_less_or_equal not applied to two arguments"
is_greater_ :: HasValues t => [OpExpr t] -> OpExpr t
is_greater_ :: [OpExpr t] -> OpExpr t
is_greater_ = 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
is_greater
is_greater :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_greater :: OpExpr t -> OpExpr t -> OpExpr t
is_greater = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"is-greater" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy
| (Int Integer
x, Int Integer
y) <- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy)
= 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Bool -> Values t
forall t. Bool -> Values t
tobool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
y)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"is-greater not applied to two arguments"
is_greater_or_equal_ :: HasValues t => [OpExpr t] -> OpExpr t
is_greater_or_equal_ :: [OpExpr t] -> OpExpr t
is_greater_or_equal_ = 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
is_greater_or_equal
is_greater_or_equal :: HasValues t => OpExpr t -> OpExpr t -> OpExpr t
is_greater_or_equal :: OpExpr t -> OpExpr t -> OpExpr t
is_greater_or_equal = OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
forall t.
HasValues t =>
OP -> BinaryVOp t -> OpExpr t -> OpExpr t -> OpExpr t
vBinaryOp OP
"is-greater-or-equal" BinaryVOp t
forall t t t. HasValues t => Values t -> Values t -> Result t
op
where op :: Values t -> Values t -> Result t
op Values t
vx Values t
vy | (Int Integer
x, Int Integer
y) <- (Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vx, Values t -> Values t
forall t. Values t -> Values t
upcastIntegers Values t
vy)
= 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 (Values t -> t) -> Values t -> t
forall a b. (a -> b) -> a -> b
$ Bool -> Values t
forall t. Bool -> Values t
tobool (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
y)
| Bool
otherwise = OP -> Result t
forall t. OP -> Result t
SortErr OP
"is-greater-or-equal not applied to rationals"