类似于转化符号，=> 指明这个函数把左边的东西（任何整数x）转变成右边的东西（x + 1）。所以，这是一个把任何整数x映射为x + 1的函数。
例如：
var increase = (x: Int) => x + 1
increase(10)
res0: Int = 11
Scala中的=>符号可以看做是创建函数实例的语法糖。例如：A => T，A,B => T表示一个函数的输入参数类型是“A”，“A,B”，返回值类型是T。请看下面这个实例：
scala> val f: Int => String = myInt => "The value of myInt is: " + myInt.toString()
f: Int => String = <function1>
scala> println(f(3))
The value of myInt is: 3
上面例子定义函数f：输入参数是整数类型，返回值是字符串。
另外，() => T表示函数输入参数为空，而A => Unit则表示函数没有返回值。
在提供点例子，自己慢慢感悟函数式编程：
object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
printlnobject SymbolBasic {
def main(args: Array[Stringject SymbolBasicobject SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
valn(argsing]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(xect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3objectgs: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => xobject Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Intobject SymbolBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2ect SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = xobject SymbolBasicobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Intin(argsng]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((xobject SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(ying]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, yobjectgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * yobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Intt SymbolBasic defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defect SymbolBasicobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3c {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (xobject SymbolBasic]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Int) => (y: Int) => x + y;
println(b.apply(5object(argsing]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Int) => (y: Int) => x + y;
println(b.apply(5object(argsng]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => xobject SymbolBasic {
def main(args: Array SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Intobjectgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xt SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def dobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Intc {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
printlnobject SymbolBasic]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int(argsy[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Ints: Arrayobject SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(xSymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Int) => (y: Int) => x + yain(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Int) => (yobject(argsay[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Int) => (yobject SymbolBasic {
def main(argstring]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(xSymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3object SymbolBasic {
def main(argsobject SymbolBasic {
def main(argsobject SymbolBasic {
def main(argsobject SymbolBasic {
def mainobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (IntmbolBasic {
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(dobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, IntymbolBasic {
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val bobjectn(argsing]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def cobjectobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2objectobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(xobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((xobject Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(ct SymbolBasic defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => xc {
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
valobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val bobject SymbolBasicring]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (xobjectn(argsing]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(xect SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(cobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3 Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Intobject SymbolBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = xobjectobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Intobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Intobject SymbolBasicing]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
valobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => xobjectgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Intt SymbolBasic defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defect SymbolBasicobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Int) => (y: Int) => x(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
valobject(args[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defct SymbolBasicobject SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(yin(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c SymbolBasic
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Intobject(argsray[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def dobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Intobjectsic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2t SymbolBasicobject SymbolBasic {
def main(argsobject SymbolBasic {
def mainobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3objectn(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (xect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2ect SymbolBasicobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
printlnobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defect SymbolBasicobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
printlnolBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Intf mainobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val bn(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(xect SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => IntolBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2objectobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => xobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Intt SymbolBasicdefobject SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(xobject SymbolBasic Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, yobjectgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Intobject Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(xt SymbolBasicdefobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(yobject SymbolBasicArrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: IntolBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xect SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(xobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def dobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * yobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * yobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
deft SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + yobject SymbolBasicay[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
defobject SymbolBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => xobject SymbolBasicray[Stringobject SymbolBasic {
def main(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xsic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3t SymbolBasicc {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Intobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
printlnlBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Intect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((xobjectasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2ect SymbolBasicobject SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2object SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = xf mainobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
valn(args Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2ect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: IntolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => xect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(cgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xt SymbolBasicdefobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defect SymbolBasicobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(dobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = xect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobjectobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, yobjectgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * yobject Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Intt SymbolBasicdefobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3object(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3object SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
printlnect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, yobjectgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3 Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
deft SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => xobject SymbolBasicay[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def SymbolBasic
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int(argsobject SymbolBasic {
def main(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def cobject SymbolBasicdefobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Intt SymbolBasicc {
deff mainobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Intobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(dlBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3object(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3ect SymbolBasic
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2objectasic {
defobject SymbolBasic {
def main(args: Array[Stringect SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2olBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
printlnolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(xect SymbolBasicobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Intf mainobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x main(argsobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2olBasic {
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2ect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobjectobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => xgs: Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Intt SymbolBasicdefobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((xf mainobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2ect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3object SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intect SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Intobject SymbolBasic {
def mainobject SymbolBasic {
def main(args: Array[Stringobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def dobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => xobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Intobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Intobject SymbolBasicobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => xobject Arrayobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
defobject SymbolBasic {
def main(args: Array[String]) {
/**
* 从下面来看,首先,我定义了一个函数d,参数类型是Int=>Int的函数,返回值根据上下文推算是Int。
* 返回值: 发现没有,返回值是x(2),它调用了传入函数。结果自然就是6了。
*/
def d(x: (Int) => Int) = x(2);
println(d((x: Int) => x * 3));
// 继续增加难度,我设置2个值。仔细看变化,你会明白的
def c(x: (Int, Int) => Int) = x(2, 3);
println(c((x: Int, y: Int) => x * y * 3));
// 在加深一点难度,大家看看这个函数,b第一次调用返回函数(y: Int) => x + y,在一次调用返回结果。
// 相关文章参考快学scala 第十二章 高阶函数 145页
val b = (x: Int) => (y: Int) => x + y;
println(b.apply(5).apply(6));
}
}
