mirror of
https://github.com/chubin/cheat.sheets
synced 2024-11-17 09:25:32 +00:00
85 lines
2.1 KiB
Plaintext
85 lines
2.1 KiB
Plaintext
// 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
|