Pattern matching in anonymous function in Scala

Question

I'm a beginner Scala developer having problems with a coding exercise (5.12) taken by the book "Functional Programming in Scala" by Paul Chiusano.

I have this function here, called unfold, that takes an initial state and a function for producing a stream with the next states:

def unfold[A,S](z: S)(f: S => Option[(A,S)]): Stream[A] = f(z) match {
  case Some((h,t)) => h #:: unfold(t)(f)
  case _ => Stream.empty
}

For example, with this function one can create an infinite stream of objects, e.g.

def constant[A](a: A): Stream[A] = unfold(a)(_ => Some(a,a))

Now, I want to create the Fibonacci sequence, then I type:

def fibs: Stream[Int] = unfold((0,1))((a,b) => Some(a,(b,a+b)))

I get these errors:

Missing parameter type b
Expression of type Some[((Int,Int),(Nothing,String))] doesn't conform to expected type Option[(A_,(Int,Int))]

If I use the case keyword inside the anonymous function passed to unfold, like:

{ case (a,b) => Some(a,(b,a+b))}

everything's fine.

So my question is: what's the difference between the two implementations? Is it something about type inference that I don't understand?

Possible duplicate of [What is the formal difference in Scala between braces and parentheses, and when should they be used?](http://stackoverflow.com/questions/4386127/what-is-the-formal-difference-in-scala-between-braces-and-parentheses-and-when) — soote, Nov 17 '16 at 14:46

score 5 · Answer 1 · answered Nov 17 '16 at 14:49

 { (a,b) => Some(a, (b, a+b)) }

Is a function that takes two arguments - a and b, and returns an option (of a tuple). This is not what you need. You want to define a function that takes a single (tuple) argument. One way to do that would be something like this:

 { tuple => Some(tuple._1, (tuple._2, tuple._1 + tuple._2)) }

Which you could expand into something like this:

 { tuple => 
     val a = tuple._1
     val b = tuple._2
     // Can also do it shorter, with automatic unapply here:
     // val (a,b) = tuple
     // this is already pretty similar to what you have with `case`, right?
     Some(a, (b, a+b))
 }

This looks long, but scala has a special syntax construct that lets you deconstruct complex parameters to anonymous functions "on the fly", using syntax similar to pattern matching (it is actually calling unapply on the input, same as pattern match would do):

 { case(a, b) => Some(a, (b, a+b)) }

This is exactly the same as above.

Compiler is not calling `unapply` here, it knows exact type, `match` works the same way. Looks like `unapply` is only applied to extractor objects. — Victor Moroz, Nov 17 '16 at 19:45
@VictorMoroz you are right, tuples are handled specially. I had a generic case in mind when I mentioned `unapply`, you _could_ use an extractor object in this context. — Dima, Nov 17 '16 at 22:07

radumanolescu · Answer 2 · 2016-11-17T15:14:46.783

It seems you have hit one of the rules about how the compiler interprets your code:

A normal function of one arg:

scala> val g = (x: Int) => x + 1
g: Int => Int = <function1>

The data type for a tuple of ints is Tuple2(Int, Int):
scala> (3,4)
res3: (Int, Int) = (3,4)

scala> val a: Tuple2[Int, Int] = (3,4)
a: (Int, Int) = (3,4)

But this does not work:

scala> val f = ((a,b): (Int, Int)) => a+b
<console>:1: error: not a legal formal parameter.
Note: Tuples cannot be directly destructured in method or function parameters.
      Either create a single parameter accepting the Tuple1,
      or consider a pattern matching anonymous function: `{ case (param1, param1) => ... }
val f = ((a,b): (Int, Int)) => a+b
              ^
This works:
scala> val f = (x: Tuple2[Int, Int]) => x._1 + x._2
f: ((Int, Int)) => Int = <function1>

This is what you thought you could do:

val f = ((a, b): (Int, Int)) => Some(a, (b, a + b))

and then (in the context of unfold) the (0,1) gets understood as type (Int, Int), so when you call unfold you can omit the type declaration and just write ((a, b)) => Some(a, (b, a + b)). But it does not work because "Tuples cannot be directly destructured in method or function parameters". The function f above does not compile even on its own, outside of your unfold. Instead, this compiles: val g = (x: Tuple2[Int, Int]) => Some(x._1, (x._2, x._1 + x._2))

Pattern matching in anonymous function in Scala

2 Answers2