module MagicHaskeller.LibExcelStaged where
import MagicHaskeller
import Data.List
import Data.Char

default (Int, Integer, Double)

-- gcd in the latest library is total, but with older versions gcd 0 0 causes an error. 
totalGCD :: t -> t -> t
totalGCD t
x t
y =  t -> t -> t
forall t. Integral t => t -> t -> t
gcd' (t -> t
forall a. Num a => a -> a
abs t
x) (t -> t
forall a. Num a => a -> a
abs t
y)
  where gcd' :: t -> t -> t
gcd' t
a t
0  =  t
a
        gcd' t
a t
b  =  t -> t -> t
gcd' t
b (t
a t -> t -> t
forall t. Integral t => t -> t -> t
`rem` t
b)




curry2 :: ((a, b) -> c) -> a -> b -> c
curry2 = ((a, b) -> c) -> a -> b -> c
forall a b c. ((a, b) -> c) -> a -> b -> c
curry
curry3 :: ((a,b,c) -> d) -> a->b->c->d
curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d
curry3 (a, b, c) -> d
f a
x b
y c
z = (a, b, c) -> d
f(a
x,b
y,c
z)
curry4 :: ((a,b,c,d) -> e) -> a->b->c->d->e
curry4 :: ((a, b, c, d) -> e) -> a -> b -> c -> d -> e
curry4 (a, b, c, d) -> e
f a
w b
x c
y d
z = (a, b, c, d) -> e
f(a
w,b
x,c
y,d
z)
curry5 :: ((a,b,c,d,e) -> f) -> a->b->c->d->e->f
curry5 :: ((a, b, c, d, e) -> f) -> a -> b -> c -> d -> e -> f
curry5 (a, b, c, d, e) -> f
f a
v b
w c
x d
y e
z = (a, b, c, d, e) -> f
f(a
v,b
w,c
x,d
y,e
z)
curry6 :: ((a,b,c,d,e,f) -> g) -> a->b->c->d->e->f->g
curry6 :: ((a, b, c, d, e, f) -> g) -> a -> b -> c -> d -> e -> f -> g
curry6 (a, b, c, d, e, f) -> g
f a
u b
v c
w d
x e
y f
z = (a, b, c, d, e, f) -> g
f(a
u,b
v,c
w,d
x,e
y,f
z)

{-
The Policy:
1. During synthesis, monomorphic types including Int and Double must be used by mkTrie &c.
2. fromIntegral and floor are available when synthesizing, but they are removed by ppExcel.
3. Because of 2., functions must be defined polymorphically here, or the generation of input-output examples by the CGI would cause type mismatch.
-}

iF :: (Bool, a, a) -> a
iF :: (Bool, a, a) -> a
iF (Bool
True,  a
t, a
f) = a
t
iF (Bool
False, a
t, a
f) = a
f
upper :: [Char] -> [Char]
upper = (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper
lower :: [Char] -> [Char]
lower = (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower
{- This definition unnecessarily trims the spaces.
proper = unwords . map proper' . words
proper' ""     = ""
proper' (h:ts) = toUpper h : map toLower ts
-}
-- I think the following definition is enough. PROPER capitalizes letters even after a hyphen or an apostrophe.
proper :: [Char] -> [Char]
proper [Char]
""     = [Char]
""
proper (Char
c:[Char]
cs) | Char -> Bool
isAlpha Char
c = Char -> Char
toUpper Char
c Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: case (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span Char -> Bool
isAlpha [Char]
cs of ([Char]
ts, [Char]
ds) -> (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
ts [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
proper [Char]
ds
              | Bool
otherwise = Char
c Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Char] -> [Char]
proper [Char]
cs

right, left :: ([b], Int) -> [b]
left1 :: [a] -> [a]
left1  = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take Int
1
right1 :: [b] -> [b]
right1 [b]
str = ([b], Int) -> [b]
forall b. ([b], Int) -> [b]
right ([b]
str, Int
1)
left :: ([b], Int) -> [b]
left  ([b]
b, Int
a)    = Int -> [b] -> [b]
forall a. Int -> [a] -> [a]
take Int
a [b]
b
right :: ([b], Int) -> [b]
right ([b]
b, Int
a)    = [b] -> [b]
forall a. [a] -> [a]
reverse (Int -> [b] -> [b]
forall a. Int -> [a] -> [a]
take Int
a ([b] -> [b]
forall a. [a] -> [a]
reverse [b]
b))
dropLeft :: [Char] -> Int -> [Char]
dropLeft [Char]
b Int
a    = ([Char], Int) -> [Char]
forall b. ([b], Int) -> [b]
right([Char]
b, [Char] -> Int
forall a. Num a => [Char] -> a
len([Char]
b) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
a)
mid :: ([a], Int, Int) -> [a]
mid   ([a]
c, Int
a, Int
b) = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take Int
b (Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
drop (Int
a Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) [a]
c)
len :: Num a => String -> a
len :: [Char] -> a
len = Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> a) -> ([Char] -> Int) -> [Char] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length
concatenate :: ([a], [a]) -> [a]
concatenate ([a]
a, [a]
b) = [a]
a [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a]
b
concatenatE :: ([a], [a], [a]) -> [a]
concatenatE ([a]
a,[a]
b,[a]
c) = [a]
a[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
b[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
c
concatenaTE :: ([a], [a], [a], [a]) -> [a]
concatenaTE ([a]
a,[a]
b,[a]
c,[a]
d) = [a]
a[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
b[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
c[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
d
concatenATE :: ([a], [a], [a], [a], [a]) -> [a]
concatenATE ([a]
a,[a]
b,[a]
c,[a]
d,[a]
e) = [a]
a[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
b[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
c[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
d[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
e
concateNATE :: ([a], [a], [a], [a], [a], [a]) -> [a]
concateNATE ([a]
a,[a]
b,[a]
c,[a]
d,[a]
e,[a]
f) = [a]
a[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
b[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
c[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
d[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
e[a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++[a]
f


{-
max = maximum
min= minimum
average= \a -> Prelude.sum a / fromIntegral (length a)
count= \a -> length (filter (/= 0) a)
sumif ms = Prelude.sum[x|Just x <- ms]
-}
cEILING, fLOOR, mround :: (Double, Double) -> Double
cEILING :: (Double, Double) -> Double
cEILING (Double
_, Double
0) = Double
0
cEILING (Double
a, Double
b) = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Double -> Int
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.ceiling (Double
a Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
b))Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b
mround :: (Double, Double) -> Double
mround  (Double
_, Double
0) = Double
0
mround  (Double
a, Double
b) = Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Double -> Int
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.round   (Double
a Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
b))Double -> Double -> Double
forall a. Num a => a -> a -> a
*Double
b
-- http://office.microsoft.com/en-us/excel-help/mround-HP005209185.aspx?CTT=5&origin=HP005204211

-- As for FLOOR, FLOOR(0,0) is 0, but FLOOR(x,0) is #DIV/0 for other x's. Also, if the second argument is negative, the result is $NUM.
-- Thus, we should prepare something different, defining  \a b -> IF(b > 0, FLOOR(a,b), 0).
-- The postprocessor expands it to FLOOR(a,b) if b is known to be positive.
fLOOR0 :: p -> p -> p
fLOOR0 p
a p
b | p
b p -> p -> Bool
forall a. Ord a => a -> a -> Bool
<= p
0    = p
0
           | Bool
otherwise = Int -> p
forall a b. (Integral a, Num b) => a -> b
fromIntegral (p -> Int
forall a b. (RealFrac a, Integral b) => a -> b
Prelude.floor   (p
a p -> p -> p
forall a. Fractional a => a -> a -> a
/ p
b))p -> p -> p
forall a. Num a => a -> a -> a
*p
b
 
-- We need fLOOR in order to generate I/O examples. This definition is not exact, but it alerts anyway if its second argument is not positive.
fLOOR :: (Double, Double) -> Double
fLOOR (Double
0, Double
0) = Double
0 
fLOOR (Double
a, Double
b) | Double
b Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
<= Double
0    = Double
0Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
0
             | Bool
otherwise = Double -> Double -> Double
forall p. RealFrac p => p -> p -> p
fLOOR0 Double
a Double
b

-- これらの第２引数は切り捨てで整数にされるみたい。なので、**ではなく^^を用いなければならない。
rOUND, roundup, rounddown :: (Double, Int) -> Double
rOUND :: (Double, Int) -> Double
rOUND (Double
a, Int
b) = (Double, Double) -> Double
mround (Double
a, Double
0.1 Double -> Int -> Double
forall a b. (Fractional a, Integral b) => a -> b -> a
^^ Int
b)
roundup :: (Double, Int) -> Double
roundup (Double
a, Int
b) | Double
a Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
0     = (Double, Double) -> Double
cEILING (Double
a, Double
0.1 Double -> Int -> Double
forall a b. (Fractional a, Integral b) => a -> b -> a
^^ Int
b)
               | Bool
otherwise = Double -> Double -> Double
forall p. RealFrac p => p -> p -> p
fLOOR0 Double
a (Double
0.1 Double -> Int -> Double
forall a b. (Fractional a, Integral b) => a -> b -> a
^^ Int
b)
rounddown :: (Double, Int) -> Double
rounddown (Double
a, Int
b) | Double
a Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
0     = (Double, Double) -> Double
cEILING (Double
a, Double
0.1 Double -> Int -> Double
forall a b. (Fractional a, Integral b) => a -> b -> a
^^ Int
b)
                 | Bool
otherwise = Double -> Double -> Double
forall p. RealFrac p => p -> p -> p
fLOOR0 Double
a (Double
0.1 Double -> Int -> Double
forall a b. (Fractional a, Integral b) => a -> b -> a
^^ Int
b)

trim :: [Char] -> [Char]
trim = [[Char]] -> [Char]
unwords ([[Char]] -> [Char]) -> ([Char] -> [[Char]]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words
fIND :: (Num b) => (String, String, Int) -> Maybe b
fIND :: ([Char], [Char], Int) -> Maybe b
fIND ([Char]
pat, [Char]
xs, Int
pos) = ((Int, [Char]) -> b) -> Maybe (Int, [Char]) -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Int -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> b) -> ((Int, [Char]) -> Int) -> (Int, [Char]) -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, [Char]) -> Int
forall a b. (a, b) -> a
fst) (Maybe (Int, [Char]) -> Maybe b) -> Maybe (Int, [Char]) -> Maybe b
forall a b. (a -> b) -> a -> b
$ ((Int, [Char]) -> Bool) -> [(Int, [Char])] -> Maybe (Int, [Char])
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
Data.List.find ([Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
isPrefixOf [Char]
pat ([Char] -> Bool)
-> ((Int, [Char]) -> [Char]) -> (Int, [Char]) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int, [Char]) -> [Char]
forall a b. (a, b) -> b
snd) ([(Int, [Char])] -> Maybe (Int, [Char]))
-> [(Int, [Char])] -> Maybe (Int, [Char])
forall a b. (a -> b) -> a -> b
$ [Int] -> [[Char]] -> [(Int, [Char])]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
1..] ([[Char]] -> [(Int, [Char])]) -> [[Char]] -> [(Int, [Char])]
forall a b. (a -> b) -> a -> b
$ Int -> [[Char]] -> [[Char]]
forall a. Int -> [a] -> [a]
drop (Int
posInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
forall a. [a] -> [[a]]
tails [Char]
xs
ifERROR :: (Maybe a, a) -> a
ifERROR :: (Maybe a, a) -> a
ifERROR (Maybe a
mb, a
x) = a -> (a -> a) -> Maybe a -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe a
x a -> a
forall a. a -> a
id Maybe a
mb
aND :: (Bool, Bool) -> Bool
aND (Bool
a, Bool
b) = Bool
a Bool -> Bool -> Bool
&& Bool
b
oR :: (Bool, Bool) -> Bool
oR  (Bool
a, Bool
b) = Bool
a Bool -> Bool -> Bool
|| Bool
b
sign :: Num a => a -> a
sign :: a -> a
sign = a -> a
forall a. Num a => a -> a
signum
power :: (a, a) -> Maybe a
power (a
a,a
b) | a -> Bool
forall a. RealFloat a => a -> Bool
isNaN a
result Bool -> Bool -> Bool
|| a -> Bool
forall a. RealFloat a => a -> Bool
isInfinite a
result = Maybe a
forall a. Maybe a
Nothing 
            | Bool
otherwise                         = a -> Maybe a
forall a. a -> Maybe a
Just a
result
  where result :: a
result = a
a a -> a -> a
forall a. Floating a => a -> a -> a
** a
b
sQRT :: a -> Maybe a
sQRT a
x | a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0     = Maybe a
forall a. Maybe a
Nothing
       | Bool
otherwise = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Floating a => a -> a
sqrt a
x
lOG :: (a, a) -> Maybe a
lOG(a
a,a
b) | a
aa -> a -> Bool
forall a. Ord a => a -> a -> Bool
<=a
0 Bool -> Bool -> Bool
|| a
ba -> a -> Bool
forall a. Ord a => a -> a -> Bool
<=a
0 = Maybe a
forall a. Maybe a
Nothing
         | Bool
otherwise    = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ a -> a -> a
forall a. Floating a => a -> a -> a
logBase a
b a
a
ln :: a -> Maybe a
ln a
a | a
a a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<= a
0    = Maybe a
forall a. Maybe a
Nothing
     | Bool
otherwise = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Floating a => a -> a
Prelude.log a
a
pI :: () -> a
pI () = a
forall a. Floating a => a
pi
aTAN2 :: (a, a) -> a
aTAN2 (a
x,a
y) = a -> a -> a
forall a. RealFloat a => a -> a -> a
atan2 a
y a
x

fact :: a -> Maybe a
fact a
n | a
n a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0 = Maybe a
forall a. Maybe a
Nothing
       | Bool
otherwise = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product [a
1..a
n]
combin :: (a, a) -> Maybe a
combin (a
n,a
r) | (a -> a
forall a. Num a => a -> a
signum a
n a -> a -> a
forall a. Num a => a -> a -> a
+ a
1) a -> a -> a
forall a. Num a => a -> a -> a
* (a -> a
forall a. Num a => a -> a
signum a
r a -> a -> a
forall a. Num a => a -> a -> a
+ a
1) a -> a -> a
forall a. Num a => a -> a -> a
* (a -> a
forall a. Num a => a -> a
signum (a
ra -> a -> a
forall a. Num a => a -> a -> a
-a
n) a -> a -> a
forall a. Num a => a -> a -> a
+ a
1) a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0 = Maybe a
forall a. Maybe a
Nothing
             | Bool
otherwise = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> a -> Maybe a
forall a b. (a -> b) -> a -> b
$ [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product [a
na -> a -> a
forall a. Num a => a -> a -> a
-a
ra -> a -> a
forall a. Num a => a -> a -> a
+a
1 .. a
n] a -> a -> a
forall t. Integral t => t -> t -> t
`div` [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
product [a
1..a
r]

mOD    :: (Int, Int) -> Maybe Int
mOD :: (Int, Int) -> Maybe Int
mOD(Int
_,Int
0) = Maybe Int
forall a. Maybe a
Nothing
mOD(Int
m,Int
n) = Int -> Maybe Int
forall a. a -> Maybe a
Just (Int -> Maybe Int) -> Int -> Maybe Int
forall a b. (a -> b) -> a -> b
$ Int
m Int -> Int -> Int
forall t. Integral t => t -> t -> t
`mod` Int
n
degrees :: Double -> Double
degrees = ((Double
180Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
forall a. Floating a => a
pi)Double -> Double -> Double
forall a. Num a => a -> a -> a
*)
radians :: Double -> Double
radians = ((Double
forall a. Floating a => a
piDouble -> Double -> Double
forall a. Fractional a => a -> a -> a
/Double
180)Double -> Double -> Double
forall a. Num a => a -> a -> a
*)


gCD :: (a, a) -> t
gCD (a
m, a
n) = t -> t -> t
forall t. Integral t => t -> t -> t
totalGCD (a -> t
forall a b. (RealFrac a, Integral b) => a -> b
truncate a
m) (a -> t
forall a b. (RealFrac a, Integral b) => a -> b
truncate a
n)

findIx :: [Char] -> [Char] -> Int -> a
findIx [Char]
c [Char]
xs Int
n = ([Char], [Char]) -> a
forall b. Num b => ([Char], [Char]) -> b
finD(Int -> [Char]
char(Int
7), ([Char], [Char], [Char], Int) -> [Char]
sUBSTITUTE(([Char], [Char]) -> [Char]
forall a. ([a], [a]) -> [a]
concatenate([Char]
c,[Char]
xs), [Char]
c, Int -> [Char]
char(Int
7), Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int -> Int
forall a. Num a => a -> a
abs(Int
n)))a -> a -> a
forall a. Num a => a -> a -> a
-a
1
finD :: ([Char], [Char]) -> b
finD([Char]
c, [Char]
xs) = b -> (b -> b) -> Maybe b -> b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe b
forall a. HasCallStack => a
undefined b -> b
forall a. a -> a
id (Maybe b -> b) -> Maybe b -> b
forall a b. (a -> b) -> a -> b
$ ([Char], [Char], Int) -> Maybe b
forall b. Num b => ([Char], [Char], Int) -> Maybe b
fIND([Char]
c, [Char]
xs, Int
1)
char :: Int -> [Char]
char = (Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
:[Char]
"") (Char -> [Char]) -> (Int -> Char) -> Int -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Char
chr


sUBsTITUTE :: (String, String, String) -> String
sUBsTITUTE :: ([Char], [Char], [Char]) -> [Char]
sUBsTITUTE([Char]
ts, [Char]
"", [Char]
_) = [Char]
ts -- 実際やってみたらこうだった．
sUBsTITUTE([], [Char]
_,  [Char]
_) = []
sUBsTITUTE(text :: [Char]
text@(Char
t:[Char]
ts), [Char]
old, [Char]
new) = case [Char]
old [Char] -> [Char] -> Maybe [Char]
forall a. Eq a => [a] -> [a] -> Maybe [a]
`stripPrefix` [Char]
text of Maybe [Char]
Nothing   -> Char
t   Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
:  ([Char], [Char], [Char]) -> [Char]
sUBsTITUTE([Char]
ts,   [Char]
old, [Char]
new)
                                                                   Just [Char]
rest -> [Char]
new [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ([Char], [Char], [Char]) -> [Char]
sUBsTITUTE([Char]
rest, [Char]
old, [Char]
new)

sUBSTITUTE :: (String, String, String, Int) -> String
sUBSTITUTE :: ([Char], [Char], [Char], Int) -> [Char]
sUBSTITUTE([Char]
text, [Char]
old, [Char]
new, Int
num) | Int
num Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0  = [Char] -> [Char]
forall a. HasCallStack => [Char] -> a
error [Char]
"#NUM"
                                | Bool
otherwise = if [Char] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
old then [Char]
text
                                                          else [Char] -> [Char] -> [Char] -> Int -> [Char]
forall a.
(Ord a, Num a) =>
[Char] -> [Char] -> [Char] -> a -> [Char]
sUB [Char]
text [Char]
old [Char]
new Int
num
sUB :: [Char] -> [Char] -> [Char] -> a -> [Char]
sUB [Char]
""          [Char]
_   [Char]
_   a
_ = [Char]
""
sUB text :: [Char]
text@(Char
t:[Char]
ts) [Char]
old [Char]
new a
n = case [Char]
old [Char] -> [Char] -> Maybe [Char]
forall a. Eq a => [a] -> [a] -> Maybe [a]
`stripPrefix` [Char]
text of Maybe [Char]
Nothing               -> Char
t Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Char] -> [Char] -> [Char] -> a -> [Char]
sUB [Char]
ts [Char]
old [Char]
new a
n
                                                           Just [Char]
rest | a
na -> a -> Bool
forall a. Ord a => a -> a -> Bool
<=a
1      -> [Char]
new [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
rest
                                                                     | Bool
otherwise -> [Char]
old [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char] -> [Char] -> a -> [Char]
sUB [Char]
rest [Char]
old [Char]
new (a
na -> a -> a
forall a. Num a => a -> a -> a
-a
1)

sUBST4 :: String -> String -> String -> Int -> String
sUBST4 :: [Char] -> [Char] -> [Char] -> Int -> [Char]
sUBST4 [Char]
text [Char]
old [Char]
new Int
num = ([Char], [Char], [Char], Int) -> [Char]
sUBSTITUTE([Char]
text, [Char]
old, [Char]
new, Int
1Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int -> Int
forall a. Num a => a -> a
abs(Int
num))

countStr :: Num a => String -> String -> a
countStr :: [Char] -> [Char] -> a
countStr [Char]
x [Char]
""  = a
0
countStr [Char]
x [Char]
str = Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> a) -> Int -> a
forall a b. (a -> b) -> a -> b
$ ([Char] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length([Char]
x)Int -> Int -> Int
forall a. Num a => a -> a -> a
-[Char] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length(([Char], [Char], [Char]) -> [Char]
sUBsTITUTE([Char]
x,[Char]
str,[Char]
""))) Int -> Int -> Int
forall t. Integral t => t -> t -> t
`div` [Char] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([Char]
str)
$(mkCurriedDecls "'2" [|curry2|] [|(left,right,concatenate,cEILING,mround,rOUND,roundup,rounddown,ifERROR,aND,oR,power,lOG,aTAN2,combin,mOD,gCD)|])
{- The above should generate:
left'2  = curry2 left
right'2 = curry2 right
...
-}

$(mkCurriedDecls "'3" [|curry3|] [|(iF,mid,fIND,sUBsTITUTE,concatenatE)|])
{- again,
iF'3    = curry3 iF
mid'3   = curry3 mid
...
-}

$(mkCurriedDecls "'4" [|curry4|] [|concatenaTE|])

$(mkCurriedDecls "'5" [|curry5|] [|concatenATE|])

$(mkCurriedDecls "'6" [|curry6|] [|concateNATE|])