|
|
// define function
|
|
|
// GOOD
|
|
|
def f(x: Int) = { x*x }
|
|
|
// BAD
|
|
|
// hidden error: without = it’s a Unit-returning procedure; causes havoc
|
|
|
def f(x: Int) { x*x }
|
|
|
|
|
|
// define function
|
|
|
// GOOD
|
|
|
def f(x: Any) = println(x)
|
|
|
// BAD
|
|
|
// syntax error: need types for every arg.
|
|
|
def f(x) = println(x)
|
|
|
|
|
|
// type alias
|
|
|
type R = Double
|
|
|
|
|
|
// call-by-value
|
|
|
def f(x: R)
|
|
|
// call-by-name (lazy parameters)
|
|
|
def f(x: => R)
|
|
|
|
|
|
// anonymous function
|
|
|
(x:R) => x*x
|
|
|
|
|
|
// anonymous function: underscore is positionally matched arg.
|
|
|
(1 to 5).map(_*2) // vs.
|
|
|
(1 to 5).reduceLeft( _+_ )
|
|
|
|
|
|
// anonymous function: to use an arg twice, have to name it.
|
|
|
(1 to 5).map( x => x*x )
|
|
|
|
|
|
// anonymous function: bound infix method. Use 2*_ for sanity’s sake instead.
|
|
|
// GOOD
|
|
|
(1 to 5).map(2*)
|
|
|
// BAD
|
|
|
(1 to 5).map(*2)
|
|
|
|
|
|
// anonymous function: block style returns last expression.
|
|
|
(1 to 5).map { x => val y=x*2; println(y); y }
|
|
|
|
|
|
// anonymous functions: pipeline style. (or parens too).
|
|
|
(1 to 5) filter {_%2 == 0} map {_*2}
|
|
|
|
|
|
// anonymous functions: to pass in multiple blocks, need outer parens.
|
|
|
def compose(g:R=>R, h:R=>R) = (x:R) => g(h(x))
|
|
|
val f = compose({_*2}, {_-1})
|
|
|
|
|
|
// currying, obvious syntax.
|
|
|
val zscore = (mean:R, sd:R) => (x:R) => (x-mean)/sd
|
|
|
|
|
|
// currying, obvious syntax
|
|
|
def zscore(mean:R, sd:R) = (x:R) => (x-mean)/sd
|
|
|
|
|
|
// currying, sugar syntax. but then:
|
|
|
def zscore(mean:R, sd:R)(x:R) = (x-mean)/sd
|
|
|
|
|
|
// need trailing underscore to get the partial, only for the sugar version.
|
|
|
val normer = zscore(7, 0.4) _
|
|
|
|
|
|
// using curried parameters with a partially applied function
|
|
|
// can be called as "add(1)(2)" to return "3"
|
|
|
def add(x: Int) = x + (_: Int)
|
|
|
|
|
|
// generic type.
|
|
|
def mapmake[T](g:T=>T)(seq: List[T]) = seq.map(g)
|
|
|
|
|
|
// infix sugar.
|
|
|
5.+(3); 5 + 3
|
|
|
(1 to 5) map (_*2)
|
|
|
|
|
|
// varargs
|
|
|
def sum(args: Int*) = args.reduceLeft(_+_)
|
|
|
|
|
|
// default parameters
|
|
|
def countTo(i: Int = 5) = 1 to i
|
|
|
countTo(3) = Range(1,2,3)
|
|
|
countTo() = Range(1,2,3,4,5)
|
|
|
|
|
|
// higher order functions
|
|
|
// as long as a function returns the correct type, it can be used as a parameter in another function
|
|
|
def sum(a: Int, b: Int): Int = a + b
|
|
|
def double(x: Int): Int = x * 2
|
|
|
double(sum(1, 1)) // returns 4
|