文档章节

《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) }
    }
  }

}


© 著作权归作者所有

共有 人打赏支持
谦谦君子
粉丝 38
博文 59
码字总数 50480
作品 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
免费的计算机编程类中文书籍

免费的编程中文书籍索引,欢迎投稿。 国外程序员在 stackoverflow 推荐的程序员必读书籍,中文版。 stackoverflow 上的程序员应该阅读的非编程类书籍有哪些? 中文版 github 上的一个流行的编...

justjavac
2014/08/13
2.6K
10

没有更多内容

加载失败,请刷新页面

加载更多

Java并发编程:volatile关键字解析

volatile这个关键字可能很多朋友都听说过,或许也都用过。在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果。在Java 5之后,volatile关键字才得以重获生...

engeue
25分钟前
0
0
通过ajax访问远程天气预报服务

http://www.webxml.com.cn/zh_cn/index.aspx 更改wsdl文件 打开文件将15行,51行,101行去掉 然后把文件复制到c盘 然后在桌面上面就生成了文件 将文件打成jar包 package cn.it.ws.weather;...

江戸川
今天
1
0
聊聊storm的tickTuple

序 本文主要研究一下storm的tickTuple 实例 TickWordCountBolt public class TickWordCountBolt extends BaseBasicBolt { private static final Logger LOGGER = LoggerFactory.getLogg......

go4it
今天
1
0
自动装箱和自动拆箱

自动装箱和自动拆箱 Java 提供了 8 种基本数据类型,每种数据类型都有其对应的包装类型,包装类是面向对象的类,是一种高级的数据类型,可以进行一些比较复杂的操作,它们是引用类型而不再基...

tsmyk0715
今天
2
0
简易审计系统

1、有时候我们需要对线上用户的操作进行记录,可以进行追踪,出现问题追究责任,但是linux自带的history并不会实时的记录(仅仅在内存中,当用户正常退出(exit logout )时才会记录到history文件里...

芬野de博客
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部