在 Scala 中 = > 和() = > 意味着什么

=> is syntactic sugar for creating instances of functions. Recall that every function in scala is an instance of a class.

For example, the type Int => String, is equivalent to the type Function1[Int,String] i.e. a function that takes an argument of type Int and returns a String.

  scala> val f: Function1[Int,String] = myInt => "my int: "+myInt.toString
f: (Int) => String = <function1>


scala> f(0)
res0: String = my int: 0


scala> val f2: Int => String = myInt => "my int v2: "+myInt.toString
f2: (Int) => String = <function1>


scala> f2(1)
res1: String = my int v2: 1

Here myInt is bound to the argument value passed to f and f2.

() => T is the type of a function that takes no arguments and returns a T. It is equivalent to Function0[T]. () is called a zero parameter list I believe.

 scala> val f: () => Unit = () => { println("x")}
f: () => Unit = <function0>


scala> f()
x


scala> val f2: Function0[Unit] = () => println("x2")
f: () => Unit = <function0>


scala> f2()
x2

=> is the "function arrow". It is used both in function type signatures as well as anonymous function terms. () => Unit is a shorthand for Function0[Unit], which is the type of functions which take no arguments and return nothing useful (like void in other languages).

() => Unit means: "Type function that takes no parameters and return nothing"

So if you declare a value f to be a function that takes no parameters and returns nothing its type would be:

val f : () => Unit

Since this is a val you have to assign a value, for instance a function that prints Hola mundo

val f : () => Unit  = () => println("Hola Mundo")

That reads: *"f is a function that takes no parameters and returns nothing initialized with the code println("Hola Mundo")

Since in Scala you can use type inference you don't have to declare the type so the following would be equivalent:

val f = () => println("Hola Mundo")

To invoke it you can just:

f()


>"Hola mundo"

Or, since the functions are also objects you can invoke the apply method:

f.apply()
> "Hola Mundo"

That's why in your declaration you're saying "I'll have a list that will hold functions with no params and no return types" hence List[()=>Unit]

I hope this helps.

=> has several meanings in Scala, all related to its mathematical meaning as implication.

• In a value, it introduces a function literal, or lambda. e.g. the bit inside the curly braces in List(1,2,3).map { (x: Int) => x * 2 }

• In a type, with symbols on both sides of the arrow (e.g. A => T, (A,B) => T, (A,B,C) => T, etc.) it's sugar for Function<n>[A[,B,...],T], that is, a function that takes parameters of type A[,B...], and returns a value of type T.

  • Empty parens on the left hand side (e.g. () => T) indicate that the function takes no parameters (also sometimes called a "thunk");

  • Empty parens on the right hand side denote that it returns ()—the sole value of type Unit, whose name can also be written ()—confused yet? :)

    A function that returns Unit is also known as a procedure, normally a method that's called only for its side effect.

• In the type declaration for a method or function parameter, with no symbol on the left hand side (e.g. def f(param: => T)) it's a "by-name parameter", meaning that is evaluated every time it's used within the body of the function, and not before. Ordinary "by-value" parameters are evaluated before entry into the function/method.

• In a case clause, they separate the pattern (and optional guard) from the result expression, e.g. case x => y.

As the most simplified answer, you can substitute whatever is on the left-hand side of => with the word "LEFT" and whatever is on the right-hand side with the word "RIGHT".

Then, the meaning of "LEFT => RIGHT" becomes:

Take LEFT then do RIGHT.

This means that if you have a "()=>" that you can take nothing (that is, no parameters) and then do whatever is on the right-hand side.

This is the most common meaning.