Question

简而言之 - 我不明白为什么这会编译：

var a : Any = null
type MyType = () => Unit
a match { case f : MyType => }

虽然这不是

var a : Any = null
a match { case f : () => Unit => }

Answer 1

在case f : () => Unit =>部分， case语句在其看到的第一个平箭头（=>）中将类型与操作分开。

a match { case f : MyType => }
//                        ^

所以在后面的例子中，它打破了如下声明，

a match { case f : () => Unit => }
//                    ^

并尝试匹配()类型，而不是() => Unit，这不是一种类型。

Answer 2

因为您有两个'=＆gt;'实例，所以您需要使用匿名函数类型的括号：

null match { 
  case f: (() => Unit) => println("yep")
  case _ => println("nope")                      // prints nope


var i = 1

// input is a function with no args, returning Unit (not invoked)
{() => {i = i + 1; print("outer i=" + i + "  ")} } match { 
  case f : (() => Unit) => println("yep")       // prints yep
  case _ => print("nope")
}

也可以使用方法执行此操作：

// input is a function with no args, returning Unit (not invoked)
def myProc(a: () => Unit) = a match {
  case f: (() => Unit) => println("yep") 
  case _ => println("nope")
}

var i = 1
myProc({() => {i = i + 1; print("outer i=" + i + "  ")} })  // prints yep

参数a是一个函数。在调用之前未确定函数结果 - 而是在调用之前计算定义函数的表达式。然后每次在方法中评估（调用）参数时评估函数结果（即0次，因为它仅用于模式匹配，从未被调用为a()）

// here, a is invoked 3 times
def myProc(a: () => Unit) = for (j <- 1 to 3) a()

var i = 1
myProc({() => {i = i + 1; print("outer i=" + i + "  ")} })  
// prints outer i=2  outer i=3  outer i=4

使用非函数参数（即表达式/值）可以完成类似（但不完全相同）的事情。而不是声明a: SomeType（传值值参数，在调用之前计算表达式），而不是a: => SomeType（一个名为pass-by-name的参数，其中表达式之前不会被评估）调用，但每次在方法中引用参数时进行评估：

// input is a pass-by-name Unit expression
def myProc(a: => Unit) = a match {
  case f: Unit => println("yep") 
}

var i = 1
myProc({i = i + 1; print("outer i=" + i + "  ")})  // prints yep 

// input is a pass-by-name Unit expression
def myProc(a: => Unit) = {
  for (j <- 1 to 3) yield a
  a
}

var i = 1
myProc({i = i + 1; print("outer i=" + i + "  ")})  
// prints outer i=2  outer i=3  outer i=4  outer i=5

匹配功能类型？

2 个答案: