Spielwiese: Einfache Funktionen auf Listen
==========================================

Als f' definierte Funktionsn sind in Haskell als f vordefiniert.

> module ListIntro where

Laenge einer Liste

> length':: [a]  -> Int
> length' []     =  0
> length' (a:as) =  length' as + 1

Vergleich zweier Listen --vordefiniert als xs == ys

> eqList:: (Eq a) => [a] -> [a] -> Bool
> eqList []     []              =  True
> eqList (x:xs) (y:ys)          =  x == y && eqList xs ys

Paaren zweier Listen -- vordefiniert als zip xs ys

> zip' :: [a] -> [b] -> [(a,b)]
> zip' []     []     =  []
> zip' (x:xs) (y:ys) =  (x,y) : zip' xs ys

Ausprobieren auf zip' "wenn" "aber"
                 zip' "wenn "laber"

Verhaelt sich aber anders als da vordefinierte zip!! Es fehlen die klauseln
fuer ungleich lange Listen!! Welche sind das und wo muessen sie hin?


Verketten zweier Listen (++)

> app:: [a] -> [a] -> [a]
> app []     ys    =  ys
> app (x:xs) ys    =  x : app xs ys

Tst mit 
  "halle" `app` "lujah"




Die ersten k Elemente nehmen/weglassen

> take' 0     xs     =  []
> take' _     []     =  []
> take' (n+1) (x:xs) =  x:take' n xs

> drop' 0     xs     =  xs
> drop' _     []     =  []
> drop' (n+1) (x:xs) =  drop' n xs

Pruefe fuer verschiedene k-Werte

  let test k xs = take k xs ++ drop k xs in test 5 "aber"

Jedes zweite Element:

> alt:: [a]    -> [a]
> alt []       =  []
> alt [x]      =  [x]
> alt (x:y:ys) =  x : alt ys

Jedes vierte -- benutzt den Kompositions-Operator (.) "nach"

> allt = alt . alt

oder etwas weniger cool
  allt xs = alt(alt xs)

Was ist der Typ von (.)? 
 (.):: (b->c) -> (a->b) -> (a ->c)
Definiert als
 (f . g) x = f(g x)

Reverse

>rev:: [a]   -> [a]
> rev []     =  []
> rev (x:xs) =  rev xs ++ [x]

Listen von Listen:


> l =  ["dann", "halt", "eben", "doch", "noch"]

> t = [[1..10], [2..20], [], [30,24..0]]

Aeussere Liste umdrehen:

  rev l

Innere listen umdrehen:

  map rev l

Beide umdrehen
  rev (map rev l) oder
  map rev (rev l)

Auch schoen anzusehen:

  map rev (zip l [1..]) -- Fehler

  rev (zip (map rev l) [1..])  --okay