module MyFile where

import Char

-------------------
-- MyFile.hs: a sample file for students of CS 254
-- by Fritz Ruehr, WU, Spring 2009
-------------------

-- f a  = (map toUpper (take 1 a)) ++ tail a
f' a = (    toUpper (head a))   :  tail a

title a = unwords (map f' ( map (map toLower) (words a)))

-- here is my very special test data

test = "thIS IS a TEST phrase to be TItleD"

title' s = unwords (map capitalize (words (map toLower s))) 
           where capitalize s = toUpper (head s) : tail s

dv xs = filter novowel xs where
	novowel x = notElem x vs && notElem x capvs
        vs = "aeiou"    -- lowercase vowels
        capvs = map toUpper vs

trim s = reverse (dropWhile isSpace (reverse (dropWhile isSpace s)))

trim' = trimSpace . fromBack trimSpace
        where trimSpace = dropWhile (==' ')

fromBack f = reverse . f . reverse



dog = "the dog runs"

f = unwords . map reverse . words

g = unwords . reverse . words

orr = foldr (||) False

eny p xs = orr (map p xs)
awl p xs = foldr (&&) True (map p xs)

dbase = [ ("Janeba", 305), ("Johnson", 301), ("Otto", 303) ]



zap as bs = take n (zip (ouro as) (ouro bs))
            where n = length as `max` length bs
                  ouro xs = xs ++ repeat (last xs)
                  
flap  f x y = f y x

unkurri f (x,y) =  f x y


----------------------------------------

fold f u [] = u
fold f u (x:xs) = f x (fold f u xs)

-- len = fold (const (1+)) 0

summ = fold (+) 0

prod = fold (*) 1

fac 0 = 1
fac (n+1) = (n+1) * fac n

fib 0 = 1
fib 1 = 1
fib (n+2) = fib (n+1) + fib n

fibs = 1 : 1 : zipWith (+) fibs (tail fibs)

fibb i = fibs !! i



------------------------



data Nat = Zero | Succ Nat     deriving Show

add  Zero    m = m
add (Succ n) m = Succ (add n m)

mul  Zero    m = Zero
mul (Succ n) m = add m (mul n m)

pow m  Zero    = Succ Zero
pow m (Succ n) = mul m (pow m n)

iter s z  Zero    = z
iter s z (Succ n) = s (iter s z n)

plus n m = iter  Succ    m    n
mult n m = iter (plus m) Zero n
expt n m = iter (mult m) one  n


ntoi Zero = 0
ntoi (Succ n) = 1 + (ntoi n)

n2i = iter (+1) 0
i2n = yttr Succ Zero

iton 0     = Zero
iton (i+1) = Succ (iton i)

yttr s z  0    = z
yttr s z (i+1) = s (yttr s z i)

lom = yttr (():) []

lomp k l = k ++ l
lomm k l = concat (map (const k) l)

l2i = length
i2l = flip replicate ()

att f i j = l2i (f (i2l i) (i2l j))

try f i j = ntoi (f (iton i) (iton j))

one = Succ Zero
two = Succ (Succ Zero)
three = Succ two


data Unit = Unit


----------------------------------
-- If you missed the "reverse" lecture, see >> HERE <<
----------------------------------

-- lists define by us instead of Haskell's built-in lists:

data List a = Nil | Cons a (List a)    deriving Show


-- a version of length for "our" lists

len Nil = 0
len (Cons x xs) = 1 + len xs


-- a version of map for "our" lists

mapp :: (a -> b) -> List a -> List b
mapp f Nil = Nil
mapp f (Cons a as) = Cons (f a) (mapp f as)


-- a version of filter for "our" lists

phylter :: (a -> Bool) -> List a -> List a
phylter p Nil = Nil
phylter p (Cons x xs) = if p x 
                           then Cons x (phylter p xs) 
                           else phylter p xs


-- a version of append for "our" lists

apend Nil ys = ys
apend (Cons x xs) ys = Cons x (apend xs ys)


-- first version of reverse for "our" lists
-- (too slow: since it uses "apend", it is O(n^2) )

riverse Nil = Nil 
riverse (Cons x xs) = (riverse xs) `apend` (Cons x Nil)


-- a better version of "riverse", using an *accumulating parameter* (acc)
-- (see also the graphic linked in from the home page)

friv acc Nil = acc
friv acc (Cons x xs) = friv (Cons x acc) xs


-- changing the order of arguments to friv

phriv Nil acc = acc
phriv (Cons x xs) acc = phriv xs (Cons x acc)


-- phriv above can now be re-written to show more directly that 
-- we are constructing a function on lists

phrivv Nil = id
phrivv (Cons x xs) = phrivv xs . Cons x


-- conversion from Haskell lists to ours

l2L [] = Nil
l2L (x:xs) = Cons x (l2L xs)

-- a "copying" indentity function on Lists

idd Nil = Nil
idd (Cons x xs) = Cons x (idd xs)


-- sample List for testing

tl = l2L [1..1000]



------------------------------


factors n = [ x | x<- [1..n], n `mod` x == 0 ]

konkat xss = [ x | xs <- xss, x <- xs ]