Let's create a value for the sake of this question:
val a = 1 :: Nil
now, I can demonstrate that the anonymous functions can be written in shorthand form like this:
a.map(_*2)
is it possible to write a shorthand of this function?:
a.map((x) => x)
my solution doesn't work:
a.map(_)
For the record, a.map(_) does not work because it stands for x => a.map(x), and not a.map(x => x). This happens because a single _ in place of a parameter stands for a partially applied function. In the case of 2*_, that stands for an anonymous function. These two uses are so close that is very common to get confused by them.
m _ syntax; Programming in Scala uses it first for m _ and then for m(_). But f(_) is syntactically like if (_). "Partial applications" get help inferring the param type.
val pFunc = a.map(_) ?
pFunc's type. Not that map takes a function, so x in x => a.map(x) would be a function from Int to some type. There's no way to infer what type that would be, therefore, you need to specify the type for pFunc, at which point Scala will gladly accept that line.Your first shorthand form can also be written point-free
a map (2*)
Thanks to multiplication being commutative.
As for (x) => x, you want the identity function. This is defined in Predef and is generic, so you can be sure that it's type-safe.
x=>x is four characters while identity is eight. This is why I never use identity.
identity may be 8 letters, but it's still a single identifier and so is easier to parse (for humans and compilers alike)You should use identity function for this use case.
a.map(identity)
identity is defined in scala.Predef as:
implicit def identity[A](x: A): A = x
