Plus a few random things More about functions Plus a few random things

Tail recursion A function is said to be tail recursive if the recursive call is the very last thing it does, in any recursive branch Example #1: def collatz(n: Int): Int = { if (n == 1) 1 else if (n % 2 == 0) collatz(n / 2) else collatz(3 * n + 1) } There is no recursion if n == 1 In each other case, the last operation is a recursive call A good compiler can replace tail recursion with a loop def collatz(n: Int): Int = { var nn = n while (nn != 1) { if (nn % 2 == 0) nn = nn / 2 else nn = 3 * nn + 1 } nn } This is desirable because loops don’t cause the stack to grow

Factorial Here’s everybody’s first recursive function: def factorial(n: Long): Long = { if (n == 0 || n == 1) 1 else n * factorial(n - 1) } This is not tail recursive, because there is a multiplication that is performed after the recursive call Can the factorial function be rewritten to be tail recursive? Yes it can, and the technique for doing so can be applied to a lot of other functions, so it’s worth learning I’ll leave this as an exercise, since if you figure it out yourself you are much more likely to remember how to do it Here are three hints, which you can uncover one at at time if you get stuck (the text is white; select it and change the color) Use two functions; the second one should do all the recursive work The second function should have two parameters One of the parameters should be 1

Currying Here’s a function to find the hypotenuse of a right triangle: def hyp(a: Double, b: Double) = sqrt(a * a + b * b) Suppose you were to call it this way: val h = hyp(5.0, 12.0) You can think of this as the compiler substituting a value for each variable Suppose we substitute 5.0 for a first: sqrt(a * a + b * b) becomes sqrt(5.0 * 5.0 + b * b) And afterwards substitute 12.0 for b: sqrt(5.0 * 5.0 + b * b) becomes sqrt(5.0 * 5.0 + 12.0 * 12.0) which is then calculated (giving 13.0) Now suppose we stop after step 1 What we have after step 1 is a partially applied function Currying is a way to make partially applied functions

Currying in Scala Instead of giving our hyp function one parameter list, we can give it two parameter lists: scala> def hyp(a: Double)(b: Double) = sqrt(a * a + b * b) hyp: (a: Double)(b: Double)Double Now when we call it, we have to give it two argument lists, not just one list with two arguments: scala> hyp(5)(12) res2: Double = 13.0 We can stop with just the first list (but we need to use an underscore to tell Scala we know we left something out) scala> val h5 = hyp(5) _ h5: (Double) => Double = <function1> scala> h5(12) res3: Double = 13.0 With more parameters, we can break up the parameter list any way we like def foo(a: Int)(b: Int, c: String)(d: Double) = {...}

Another way to curry Here’s a function written in the usual way: scala> def avg(a: Double, b: Double) = (a + b) /2.0 avg: (a: Double,b: Double)Double Here we’re calling it in the usual way: scala> avg(5, 12) res6: Double = 8.5 Here we’re calling it with the first argument specified (5) but the second argument unspecified (_) scala> val a5 = avg(5, _: Double) a5: (Double) => Double = <function1> Notice that we had to specify the type of the omitted parameter Also pay careful attention to the type of the result Now let’s call our new, curried function: scala> a5(12) res7: Double = 8.5

Call-by-name parameters When using a function as a argument, the function parameter is used only when requested: Example: def foo(f: Int => Int) { println("In foo with " + f(10)) } foo(factorial) // prints "In foo with 3628800" Other types of parameters are first evaluated, then their values are passed into the function: Example: def foo(n: Long) { println(n} } foo(factorial(10)) What is passed into the function is the number 3628800 By using => as the first part of the type in a function definition, the function will treat a parameter as a function Example: def foo(f: => Int) { println("In foo with " + f(10)) } foo(factorial) // prints "In foo with 3628800" This is an example of call-by-name

Lazy evaluation Lazy evaluation is a technique whereby a computation is not actually performed until and unless the result is needed lazy val xxx = someLongAndExpensiveComputation ... if (we decide that we need xxx) { use xxx // The computation is done here } Ranges in Scala are lazy scala> println((1 to Int.MaxValue) take 3) Range(1, 2, 3) The Stream class supports lazy evaluation, and therefore allows “infinite” data structures (example from Programming Scala by Wampler & Payne) scala> lazy val fib: Stream[Int] = Stream.cons(0, Stream.cons(1, fib.zip(fib.tail).map(p => p._1 + p._2))) fib: Stream[Int] = <lazy> cons is like :: scala> fib.take(10).print 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, empty

Building control structures When calling a curried function, you can replace the last set of parentheses with braces scala> hyp(5) { 12 } res27: Double = 13.0 You can only put expressions inside parentheses, but you can put multiple “statements” inside braces This, plus currying, plus lazy evaluation, allows you to build your own control structures scala> def repeat(n: Int)(body: => Unit) { | for (i <- 1 to n) body | } repeat: (n: Int)(body: => Unit)Unit scala> repeat(3) { | println("Hello") | } Hello Hello Hello

XML XML is built into Scala as a data type—not just as something supported by some package scala> val name = "Dave" name: java.lang.String = Dave scala> val x = <html><body><h1>Hello, {name}!</h1></body></html> x: scala.xml.Elem = <html><body><h1>Hello, Dave!</h1></body></html>

DSL Scala has superb support for Domain Specific Languages A parser combinator is a function that takes only other functions as parameters and returns only functions BNF is essentially built into Scala as a combinator library Example: Arithmetic expressions (adapted from Odersky, pp. 620-621) BNF: <expr> ::= <term> { “+” <term> | “-” <term> } <term> ::= <factor> { “*” <factor> | “/” <factor> } <factor> ::= <floatingPointNumber> | “(” <expr> “)” Scala (~ is used to indicate one thing follows another in sequence): import scala.util.parsing.combinator._ class Arith extends JavaTokenParsers { def expr: Parser[Any] = term ~ rep("+" ~ term | "-" ~ term) def term: Parser[Any] = factor ~ rep("*" ~ factor | "/" ~ factor) def factor: Parser[Any] = floatingPointNumber | "(" ~ expr ~ ")" }

The End