ULOHY
-------

1. Prevedte na pointfree tvar
a) \x -> x + 1
b) \s -> 1:s
c) \m -> 1 + 2 * m
d) \f -> mod f 3
e) \t -> zipWith (^) t [1..]
f) \x -> mod (x + 3) 12
g) \f -> map (map f) []
h) \u v -> filter u (map v [1..])
i) \chuck test a -> max (chuck test) a
a trochu narocnejsie, trikovejsie (a posledny na precvicenie rutiny):
j) \s -> 1 : s 1
k) \m -> (m, 3) + 1
l) \r s -> s . (r.)
m) \x -> x - 1
n) \x y z -> f z y x

2. Prevedte na pointwise tvar
a) max
b) (.)
c) (*2) . (2-) . curry snd 5
d) (.) (.) (.)
e) flip (flip flip)
tazsie:
f) uncurry . curry

3. Prevedte (id.) . max do pointwise tvaru a odtial nazad do pointfree tvaru.



 RIESENIA
----------

1.
a) flip (+) 1
   alebo
   (+1)

b) (1:)

c) \m -> 1 + (2 * m)
   \m -> (1+) ((2*) m)
   \m -> ((1+) . (2*)) m
   (1+) . (2*)

d) \f -> flip mod 3 f
   flip mod 3

e) \t -> (zipWith (^)) t [1..]
   \t -> flip (zipWith (^)) [1..] t
   flip (zipWith (^)) [1..]

f) \x -> flip mod 12 (x + 3)
   \x -> (flip mod 12) ((+3) x)
   flip mod 12 . (+3)

g) \f -> flip map [] (map f)
   flip map [] . map

h) \u v -> filter u (map v [1..])
   \u v -> filter u (flip map [1..] v)
   \u -> filter u . flip map [1..]
   \u -> (.) (filter u) (flip map [1..])
   \u -> flip (.) (flip map [1..]) (filter u)
   \u -> (flip (.) (flip map [1..])) (filter u)
   flip (.) (flip map [1..]) . filter

i) \chuck test a -> max (chuck test) a
   \chuck test -> max (chuck test)
   \chuck -> max . chuck
   \chuck -> (.) max chuck
   (.) max

j) \s -> 1 : s 1
   \s -> 1 : ((id s) 1)
   \s -> 1 : (id s 1)
   \s -> (1:) (flip id 1 s)
   (1:) . flip id 1

k) \m -> (m, 3) + 1
   \m -> (,) m 3 + 1
   \m -> (+1) . flip (,) 3

l) \r s -> s . (r.)
   \r s -> (.) s (r.)
   \r s -> flip (.) (r.) s
   \r -> flip (.) (r.)
   \r -> flip (.) ((.) r)
   flip (.) . (.)

m) \x -> x - 1
   flip (-) 1
   operator - je specialnym pripadom, ked nasledovny postup nie je spravny:
   \x -> (-1) x
   (-1)
   problem je totiz v tom, ze - existuje aj v unarnej forme a jeho interpretacia
   tymto sposobom ma vyssiu prioritu; da sa vsak pouzit funkcia subtract:
   subtract m n = n - m
   \x -> x - 1
   \x -> subtract 1 x
   subtract 1

n) \x y z -> f z y x
   \x y z -> flip f y z x
   \x y z -> (flip f y) z x
   \x y z -> flip (flip f y) x z
   \x y -> flip (flip f y) x
   \x y -> flip flip x (flip f y)
   \x -> flip flip x . flip f
   \x -> (.) (flip flip x) (flip f)
   \x -> flip (.) (flip f) (flip flip x)
   flip (.) (flip f) . flip flip

2.
a) \x -> max x
   \x y -> max x y

b) \f g -> (.) f g
   \f g -> f . g
   \f g x -> (f . g) x
   \f g x -> f (g x)

c) \x -> (*2) ((2-) (curry snd 5 x))
   \x -> (2 - curry snd 5 x) * 2
   dalej uz v podstate nie je nutne upravovat, ale da sa
   \x -> (2 - snd (5, x)) * 2
   \x -> (2 - x) * 2

d) (.) (.) (.)
   -- mame f m n, kde f = (.), m = (.), n = (.), kedze f je operator v prefixe,
   -- dame ho do infixu
   (.) . (.)
   -- mame f . g, kde f = (.), g = (.), pouzijeme prepis na \t -> f (g t)
   \x -> (.) ((.) x)
   -- (.) berie viac ako jeden argument, zatial ma len ((.) x), preto pridame y
   \x y -> (.) ((.) x) y
   -- prepiseme (.) do infixu
   \x y -> ((.) x) . y
   -- odstranime implicitne zatvorky okolo (.) x, kedze nie su nutne
   \x y -> (.) x . y
   -- mame f . g, kde f = (.) x, g = y, prepiseme na \t -> f (g t)
   \x y z -> (.) x (y z)
   -- (.) prepiseme do infixu
   \x y z -> x . y z
   -- f . g prepiseme na \t -> f (g t)
   \x y z q -> x (y z q)
   -- premenovanie formalnych argumentov
   \f g x y -> f (g x y)

e) flip (flip flip)
   -- flip ma tri argumenty, pridame teda este dva
   \x y -> flip (flip flip) x y
   -- rozpiseme flip (hned za ->) podla def.
   \x y -> (flip flip) y x
   -- odstranime zatvorky ciastocnej aplikacie
   \x y -> flip flip y x
   -- rozpiseme flip (hned za ->)
   \x y -> flip x y
   -- flip ma tri argumenty, pridame este jeden
   \x y z -> flip x y z
   -- zase rozpiseme flip
   \x y z -> x z y
   -- premenujeme
   \f x y -> f y x

   mimochodom...
   \f x y -> f y x
   \f x y -> flip f x y
   flip
   teda flip = flip (flip flip)

f) uncurry . curry
   \f -> uncurry (curry f)
   -- prepis funkcie curry podla def.
   \f -> uncurry (\x y -> f (x, y))
   -- prepis funkcie uncurry podla def.
   \f -> (\(u, v) -> (\x y -> f (x, y)) u v)
   -- aplikovanie argumentov
   \f -> (\(u, v) -> f (u, v))
   -- eta redukcia
   \f -> f
   id

   Otazka na zamyslenie: Preco id 3 = 3, ale (uncurry . curry) 3 je chybne?
   (Cely postup je korektny, tam problem nie je.)

3. (id .) . max
   \x -> (id .) (max x)
   \x -> id . max x
   \x y -> id (max x y)
   \x y -> max x y

   \x y -> max x y
   max

   Pointou tohto prikladu je, ze vyraz moze mat rozne zapisy v pointwise, ci
   pointfree tvare.