文档章节

《programming in scala》2ed chap8学习笔记

谦谦君子
 谦谦君子
发布于 2013/12/26 11:02
字数 939
阅读 17
收藏 0
import scala.io.Source

/**
 * Created by ly on 13-12-26.
 */
object FunctionsAndClosures {
  def main(args: Array[String]) {
    // 8.1 Methods, like in Java

    /*
    8.2 Local functions
    an important design principle of the functional programming style:
programs should be decomposed into many small functions that each do a
well-defined task.

避免命名冲突,将helper function放在function里面(比private更好)
     */
    def processFile(filename: String, width: Int) {
      def processLine(line: String) {
        if (line.length > width)
          println(filename +": "+ line) // 可以放外外围函数的参数
      }
      val source = Source.fromFile(filename)
      for (line <- source.getLines())
        processLine(line)
    }

    /*
    8.3 First-class functions

A function literal is compiled into a class that when instantiated at runtime is a function value.

Function values are objects, so you can store them in variables if you like.
They are functions, too, so you can invoke them using the usual parentheses
function-call notation.
     */

    /*
    8.4 Short forms of function literals
     */
    val someNumbers = List(-11, -10, -5, 0, 5, 10)
    someNumbers.filter((x: Int) => x > 0)
    someNumbers.filter((x) => x > 0) // target typing
    someNumbers.filter(x => x > 0) // eave out parentheses around a parameter whose type is inferred.

    /* 8.5 Placeholder syntax

you can use underscores as placeholders for one or more parameters, so long as each parameter appears
only one time within the function literal.

The first underscore represents the first parameter, the second underscore the second parameter,
the third underscore the third parameter, and so on.
     */
    someNumbers.filter(_ > 0) //
    val f = (_: Int) + (_: Int) // scala不能类型推断的时候需要显示指明type

    /*
    8.6 Partially applied functions

    A partially applied function is an expression in which you don’t supply all
of the arguments needed by the function. Instead, you supply some, or none,
of the needed arguments.
     */
    someNumbers.foreach(println _) // the underscore in this case is not a placeholder for a single parameter. It is a placeholder for an entire parameter list.

    /*
    Although you can’t assign a
method or nested function to a variable, or pass it as an argument to another
function, you can do these things if you wrap the method or nested function
in a function value by placing an underscore after its name.
     */

    someNumbers.foreach(println) // allowed only in places where a function is required, such as the invocation of foreach in this example.
    def sum(a: Int, b: Int, c: Int) = a + b + c
    //val x = sum // compile error!
    val y = sum _


    /*
    8.7 Closures

    The function value (the object) that’s created at runtime from this function
literal is called a closure. The name arises from the act of “closing” the func-
tion literal by “capturing” the bindings of its free variables. A function literal
with no free variables, such as (x: Int) => x + 1 , is called a closed term,
where a term is a bit of source code. Thus a function value created at run-
time from this function literal is not a closure in the strictest sense, because
(x: Int) => x + 1 is already closed as written. But any function literal with
free variables, such as (x: Int) => x + more , is an open term. Therefore,
any function value created at runtime from (x: Int) => x + more will by
definition require that a binding for its free variable, more , be captured. The
resulting function value, which will contain a reference to the captured more
variable, is called a closure, therefore, because the function value is the end
product of the act of closing the open term, (x: Int) => x + more .
     */
    var more = 10
    def increase = (x: Int) => {val xplus = x + more; more += 10; xplus} // more is a free variable, x is a bound variable
    println(increase(1))
    println(more) // closure可以改变free variable

    more = 11
    println(increase(1)) // closure可以看到more的变化

    /*
    the instance used is the one that was active at the time the closure was created.

    The Scala compiler rearranges things in cases like this so that the captured parameter lives out on the heap, instead of the
    stack, and thus can outlive the method call that created it.
     */
    def makeIncreaser(more: Int) = (x: Int) => x + more
    val inc1 = makeIncreaser(1)
    val inc9999 = makeIncreaser(9999)

    /*
    8.8 Special function call forms
     */
    // Repeated parameters
    def echo(args: String*) =
      for (arg <- args) println(arg) // args: Array[String]
    val arr = Array("What's", "up", "doc?")
    echo(arr: _*) // 将Array打散

    // Named arguments
    def speed(distance: Float, time: Float): Float =
      distance / time

    println(speed(time = 10, distance = 100)) // 可以将顺序打乱, It is also possible to mix positional and named arguments. In that case, the positional arguments come first.

    // Default parameter values
    // Named arguments are most frequently used in combination with default parameter values.
    def printTime2(out: java.io.PrintStream = Console.out, divisor: Int = 1) =
      out.println("time = "+ System.currentTimeMillis()/divisor)

    printTime2()
    printTime2(Console.out)
    printTime2(out = Console.out)
    printTime2(divisor = 100)

    /*
    8.9 Tail recursion

    Often, a recursive solution is more elegant and concise than a loop-based one. If the solution is tail recursive, there
won’t be any runtime overhead to be paid.
     */
    // -g:notailcalls来查看stack frame
    /*
    Limits of tail recursion

    tail-call optimization is limited to situations in which a method or nested function calls itself directly as its
last operation, without going through a function value or some other intermediary.
下面几个都不行
     */
    def isEven(x: Int): Boolean =
      if (x == 0) true else isOdd(x - 1)
    def isOdd(x: Int): Boolean =
      if (x == 0) false else isEven(x - 1)

    val funValue = nestedFun _
    def nestedFun(x: Int) {
      if (x != 0) { println(x); funValue(x - 1) }
    }
  }

}


© 著作权归作者所有

共有 人打赏支持
谦谦君子
粉丝 37
博文 61
码字总数 56919
作品 0
成都
程序员
私信 提问
《programming in scala》2ed chap13学习笔记

scala的private访问权限 class Outer { class Inner { class InnerMost { f() // OK (new Inner).f } private[Outer] def d() { println("d") } private def f() { println("f") } (new Inne......

谦谦君子
2014/01/13
0
0
《programming in scala》2ed chap15学习笔记

package chap15 sealed abstract class Expr // 加了sealed,其他文件里不能extends Exprcase class Var(name: String) extends Exprcase class Number(num: Double) extends Exprcase clas......

谦谦君子
2014/01/14
0
0
Scala 的学习笔记系列(持续更新中)

最近学习 Scala,因它是灵活的函数式编程,还有就是能为 PlayFramework 2.0 服务,看的是 《Programming in Scala》 那本书,并记下自己认为值得记录的东西,列举 Scala 用元组/列表类型实现...

YanbinQ
2012/10/26
0
1
Spark 学习资源收集

(一)spark 相关安装部署、开发环境 1、Spark 伪分布式 & 全分布式 安装指南 http://my.oschina.net/leejun2005/blog/394928 2、Apache Spark探秘:三种分布式部署方式比较 http://dongxic...

openthings
2016/05/29
164
0
Spark 学习资源收集【Updating】

(一)spark 相关安装部署、开发环境 1、Spark 伪分布式 & 全分布式 安装指南 http://my.oschina.net/leejun2005/blog/394928 2、Apache Spark探秘:三种分布式部署方式比较 http://dongxic...

大数据之路
2014/09/08
0
1

没有更多内容

加载失败,请刷新页面

加载更多

Word Pattern(leetcode290)

Given a pattern and a string str, find if str follows the same pattern. Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empt......

woshixin
10分钟前
0
0
Kubernetes 1.13.1快速升级

Kubernetes 1.13.1已经正式发布,快速升级(含国内镜像快速下载链接)包括升级kubeadm/kubectl/kubelet版本、拉取镜像、升级Kubernetes集群三个主要步骤。注意Kubernetes 1.12.3版本暂时不支...

openthings
13分钟前
1
0
多线程的实现方式

多线程是指 一个程序运行时,产生或使用了不止一个线程。 线程的生命周期是怎么样的,下面这张图我们可以看出些端倪: 这章我们主要讨论多线程实现的方式,基础知识部分我们可以下来再恶补。...

搬砖大侠
25分钟前
1
0
新人千万不要在 Windows 上使用 Ruby on Rails

标题:新人千万不要在 Windows 上使用 Ruby on Rails 副标题:鼓励新人在 Linux 和 Mac 上使用 Ruby on Rails ! 原则:要走寻常路,不要学美特斯邦伟! "在 Windows上 使用 Ruby on Rails "是...

Jason909
33分钟前
1
0
day177-2018-12-14-英语流利阅读-待学习

艾滋病的治愈方法是否触手可及? Daniel 2018-12-14 1.今日导读 几十年来,艾滋病一直是世界上最难对付的“超级绝症”之一,从人类历史上第一次诊断出艾滋病病例的 20 世纪 80 年代早期到 20...

飞鱼说编程
59分钟前
9
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部