{-# 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)
-- integer-negate is now generated
--  ,   ("integer-negate", ValueOp stepInteger_Negate)
--  ,   ("int-neg", ValueOp stepInteger_Negate)
  , (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"