# Frage zu Fallunterscheidung bei Funktionen



## TJava (18. Apr 2014)

```
def isort(xs: List[Int]): List[Int] = xs match {
case List() => List()
case x :: xs1 => insert(x, isort(xs1))
}
def insert(x: Int, xs: List[Int]): List[Int] = xs match {
case List() => List(x)
case y :: ys => if (x <= y) x :: xs else y :: insert(x, ys)
}
```

Hey, kann mir jemand diesen code erklären?

isort wird eine Liste übergeben, wenn die Liste leer ist wird eine leere Liste zurückgegeben?
was passiert da bei case x:: xs1? oder was bedeutet dieser Ausdruck?
mmmh? Wäre nett...


----------



## DrZoidberg (18. Apr 2014)

isort führt einen insert sort aus. Eine leere Liste muss nicht sortiert werden, also wird in dem Fall einfach wieder eine leere Liste zurückgegeben.

case x :: xs ist ein pattern match Ausdruck. Das erste Element der Liste wird x zugewiesen und der ganze Rest xs1.
Die Liste wird rekursiv sortiert indem erst der Rest der Liste sortiert wird und danach dann das erste Element in die sortierte Liste eingefügt wird.


----------



## TJava (18. Apr 2014)

Danke dafür..
Kannst du mir vll noch das hier erklären?

Ströme in Scala

In Scala werden Ströme in der Klasse Stream[A] deﬁniert.
Besonderheit: Der zweite Parameter der cons-Funktion ist als lazy deﬁniert, d.h. ein
aktueller Parameterausdruck dazu wird erst ausgewertet, wenn er benutzt wird, d.h. der
Parameterausdruck wird in eine parameterlose Funktion umgewandelt und so übergeben.
Diese Technik kann allgemein für Scala-Parameter angewandt werden.


```
def iterates[A] (f: A => A) (x: A): Stream[A] =
Stream.cons(x, iterates (f) (f (x)))
def smap[A] (sq: Stream[A]) (f: A => A): Stream[A] =
Stream.cons(f (sq.head), smap[A] (sq.tail) (f) )
```



```
val from = iterates[Int] (_ + 1) _
val sq = from (1)
val even = sq filter (_ % 2 == 0)
val ssq = from (7)
val msq = smap (ssq) (x=>x*x)
println( msq.take(10).mkString(",") )
```


----------

