1. Functional programming treats computation as the evaluation of mathematical and avoids state and mutable data. Scala encourages an expression-oriented programming(EOP)
  1) In expression-oriented programming every statement is an expression. A statement executes code, but does not return any value. An expression returns value. Note that an expression-oriented programming language is a programming language where every construct is an expression, and thus evaluates to a value.

scala> val test = if(>) "true" else "false"
test: String = true

  The relating java code:

boolean test =  >  ? true : false;

  Scala has unified the concept of ?: with its blocks and so Scala has no ?: syntax.

  2) An expression is referentially transparent(引用透明) if it can be substituted(替代) by its resulting value, without changing the behavior of the program, regardless of where the expression is used in the program. The keystones of functional programming are: referential transparency, higher-order function, and immutable value. A pure function does not mutate the input parameters and always returns the same value for the same input.
  The syntax for a function literal(函数字面量) with a parenthesized comma-separated list of arguments followed by an arrow and the body of the function. It's also called an anonymous function.
  A function value is a function object and you can invoke the function object in the same manner as you invoke any other function. The function object extends one of the FunctionN traits, FunctionN depends on the number of arguments.

scala> val add = (x: Int, y: Int) => x + y
add: (Int, Int) => Int = <function2>
scala> add(,)
res0: Int =

  The invocation of this function is converted to a call to the apply method of the Function class instance.

scala> val areaOfRectangle:(Int, Int) => Int = (width: Int, height: Int) => {width*height}
areaOfRectangle: (Int, Int) => Int = <function2>
scala> areaOfRectangle(,)
res1: Int =

  Trait scala.Function2 in the Scala package:

  trait Function2[-T1, -T2, +R] extends AnyRef { ... abstract def apply( v1 :T1, v2 :T2 ) : R ... }

scala> val areaOfRectangle: Function2[Int,Int,Int] = (width: Int, height: Int) => width*height
areaOfRectangle: (Int, Int) => Int = <function2>

  You can explicitly call the apply method:

scala> areaOfRectangle.apply(,)
res4: Int =

  You can even define a function by implementing an appropriate Function Trait and define its required apply method.

scala> val areaOfRectangle: (Int, Int) => Int = new Function2[Int, Int, Int]{
| def apply(width: Int, height: Int):Int = {
| width*height
| }
| }
areaOfRectangle: (Int, Int) => Int = <function2>

2. A first-class function is a function that can be: 1) Assigned to variables, 2) Passed as an argument to the other function, and 3) Returned as values from the other function. And such functions, which take functions as arguments or return a function, are called higher-order(高阶) functions.

  1) Function as Variable

scala> val doubler = (i: Int) => {i*}
doubler: Int => Int = <function1>
scala> doubler()
res0: Int =

  The variable doubler is an instance of a function, known as a function value.

  2) Function as Parameter

scala> def operation(functionparam: (Int, Int) => Int){
| println(functionparam(,))}
operation: (functionparam: (Int, Int) => Int)Unit
scala> val add = (x: Int, y: Int) => {x+y}
add: (Int, Int) => Int = <function2>
# Any function that matches this signature can be passed into the operation method
scala> operation(add) scala> val subtract = (x: Int, y: Int) => {x-y}
subtract: (Int, Int) => Int = <function2>
scala> operation(subtract) scala> val multiply = (x: Int, y: Int) => {x*y}
multiply: (Int, Int) => Int = <function2>
scala> operation(multiply)

  3) Returning a Function

  You can return a function from a function or method. In order to do this, first define an anonymous function.

# define an anonymous function
scala> def greeting = (name: String) => {"hello "+name}
greeting: String => String
# now you can assign greeting() to a variable
scala> val greet = greeting
greet: String => String = <function1>
scala> greet("World")
res4: String = hello World

  4) Closure

  A closure is a function, whose return value depends on the value of one or more variables declared outside this function.

scala> var y =
y: Int =
scala> val multiplier = (x: Int) => x * y
multiplier: Int => Int = <function1>
scala> multiplier()
res0: Int =
scala> y =
y: Int =
scala> multiplier()
res2: Int =

  The multiplier function references y and reads its current value each time. The Scala compiler creates a closure that encompass the variable in the enclosing scope.

  5) Partially Applied Function
  When all parameters are passed to the function you have fully applied the function to all the parameters.

scala> val add = (x: Int, y: Int) => x + y
add: (Int, Int) => Int = <function2>
scala> add(,)
res3: Int =

  When you give only a subset of the parameters to the function, the result of the expression is a partially applied function. It shows partiallyAdd is a fuction that implements the Function1 trait.

scala> val partiallyAdd = add(, _:Int)
partiallyAdd: Int => Int = <function1>
scala> partiallyAdd()
res4: Int =

  The first argument 1 was passed int the original add function and the new function named partiallyAdd was created, which is a partially applied function; then, the second argument 10 was passed into partiallyAdd. When you provide all the parameters, the original function is executed, yielding the result.

  6) Curried Function
  Currying converts a function with multiple parameters creating a chain of function, each expecting a single parameter.

scala> val add = (x: Int, y: Int) => x + y
add: (Int, Int) => Int = <function2>
# curried functions
scala> def add(x: Int)(y: Int) = x + y
add: (x: Int)(y: Int)Int
scala> add()()
res10: Int =
# another form
scala> def add(x: Int) = (y: Int) => x + y
add: (x: Int)Int => Int
scala> add()()
res11: Int =

  7) Function Composition

An implication of composability is that functions can be treated as values.

sealed trait Expr # sealed仅能被同文件中的类继承
case class Add(left: Expr, right: Expr) extends Expr
case class Mul(left: Expr, right: Expr) extends Expr
case class Val(value: Int) extends Expr
case class Var(name: String) extends Expr

  We can build expressions like:

+ => Add(Val(), Val())
* ( + ) => Mul(Val(),Add(Val(), Val())
a * => Mul(Var("a"), Val())
scala> def calc(expr: Expr, vars: Map[String, Int]):Int = expr match{
| case Add(left,right) => calc(left, vars) + calc(right, vars)
| case Mul(left,right) => calc(left, vars) + calc(right, vars)
| case Val(v) => v
| case Var(name) => vars(name)
| }

  If expr is an Add, we extract the left and right parameters, which are themselves Exprs. We call calc to calculate the value of the left and right parameters and add the results.

  8) Tail Calls and Tail Call Optimization
  A recursive function is one that may invoke itself.

scala> def factorial(number: Int): Int = {
| if(number == )
| return
| number * factorial(number-)
| }
factorial: (number: Int)Int
scala> println(factorial())

  The Scala compiler can optimize recursive functions with tail recursion so that recursive calls do not use all the stack space, therefore not running into stack-overflow error. Only functions whose last statement is the recursive invocation can be optimized for tail-recursion by the Scala compiler.

  Scala provides an annotation available to mark a function to be optimized for tail-recursion. A function marked with the annotation causes an error at compilation time if it cannot be optimized for tail-recursion. Add @annotation.tailrec before the function definition.

# The recursive call is not the last statement
scala> @annotation.tailrec
| def factorial(number: Int): Int = {
| if(number == )
| return
| number * factorial(number - )
| }
<console>:: error: could not optimize @tailrec annotated method factorial: it contains a recursive call not in tail position
number * factorial(number - )
^
scala> @annotation.tailrec
| def factorial(accumulator: Int, number: Int): Int = {
| if(number == 1)
| return accumulator
| factorial(number * accumulator, number - 1)
| }
factorial: (accumulator: Int, number: Int)Int

  A successful compile guarantees that the function will be optimized with tail recursion, so that each successive call will not add new stack frames.

  9) Call-by-Name, Call-by-Value, and General Laziness
  In java programs, when you call a method with parameters, the value of the parameters are all calculated before the method is called. There are some cases when you want parameters to be optionally evaluated or repeatedly evaluated. In this case, Scala provides the call-by-name mechanism.

# java code of log messages
if(logger.level().intValue() >= INFO.intValue()){
logger.log(INFO,"The value is "+value)
}
# Call-by-name has the ability to delay the evaluation of the String to log only  if that String will actually be logged
def log(level: Level, msg: => String) =
if(logger.level().intValue() >= INFO.intValue())
logger.log(level, msg)
# Call this code
log(INFO, "The value is "+value)

  The log method will access '"The value is "+value' only if the log message is going to be printed. In order to make something call-by-name, just put => before the type.

  The first use of call-by-name is passing an expression that takes a long time to evaluate that may not be evaluated. The second use for call-by-name is the situation where we want to evaluate the expression many times in the target method.

# we could collect all the Strings returned from an expression until we encounter a null
def allString(expr: => String): List[String] = expr match {
case null => Nil
case s => s :: allStrings(expr)
}
scala> import java.io._
import java.io._
scala> val br = new BufferedReader(new FileReader("nohup.out"))
br: java.io.BufferedReader = java.io.BufferedReader@2d33ee43
scala> allString(br.readLine)
res5: List[String] = List(,,,)
scala> for(str <- res5) println(str) # scala method
import scala.io.Source
if(args.length > ){
for(line <- Source.fromFile(args()).getLines())
println(line.length+" "+line)
}else
Console.err.println("Please enter filename")

Beginning Scala study note(4) Functional Programming in Scala的更多相关文章

  1. Beginning Scala study note(3) Object Orientation in Scala

    1. The three principles of OOP are encapsulation(封装性), inheritance(继承性) and polymorphism(多态性). examp ...

  2. Beginning Scala study note(1) Geting Started with Scala

    1. Scala is a contraction of "scalable" and "language". It's a fusion of objecte ...

  3. Beginning Scala study note(6) Scala Collections

    Scala's object-oriented collections support mutable and immutable type hierarchies. Also support fun ...

  4. Beginning Scala study note(9) Scala and Java Interoperability

    1. Translating Java Classes to Scala Classes Example 1: # a class declaration in Java public class B ...

  5. Beginning Scala study note(5) Pattern Matching

    The basic functional cornerstones of Scala: immutable data types, passing of functions as parameters ...

  6. Beginning Scala study note(2) Basics of Scala

    1. Variables (1) Three ways to define variables: 1) val refers to define an immutable variable; scal ...

  7. Beginning Scala study note(8) Scala Type System

    1. Unified Type System Scala has a unified type system, enclosed by the type Any at the top of the h ...

  8. Beginning Scala study note(7) Trait

    A trait provides code reusability in Scala by encapsulating method and state and then offing possibi ...

  9. Coursera公开课Functional Programming Principles in Scala习题解答:Week 2

    引言 OK.时间非常快又过去了一周.第一周有五一假期所以感觉时间绰绰有余,这周中间没有假期仅仅能靠晚上加周末的时间来消化,事实上还是有点紧张呢! 后来发现每堂课的视频还有相应的课件(Slide).字幕 ...

随机推荐

  1. Codis——分布式Redis服务的解决方案

    Codis——分布式Redis服务的解决方案 之前介绍过的 Twemproxy 是一种Redis代理,但它不支持集群的动态伸缩,而codis则支持动态的增减Redis节点:另外,官方的redis 3. ...

  2. ASP.NET MVC Filter- 登录验证 【异步刷新列表视图】

    public class TAjaxListLoginValidateAttribute : FilterAttribute, IAuthorizationFilter { public void O ...

  3. Ubuntu GNURadio gr-Radar 的安装

    1.安装Ubuntu 进行磁盘管理,设置不少于50G的未分配空间 使用rufus-2.8制作Ubuntu 16.4安装盘 保持U盘插入,重启电脑,开机时进入BIOS设置从该安装盘启动并安装 2.激活w ...

  4. mysql基于“时间”的盲注

    无需页面报错,根据页面响应时间做判断! mysql基于时间的盲注 =================================================================== ...

  5. CSS Sprites优缺点

    利用CSS Sprites能很好地减少网页的http请求,从而大大的提高页面的性能,这也是CSS Sprites最大的优点,也是其被广泛传播和应用的主要原因: CSS Sprites能减少图片的字节, ...

  6. NSIS检测.NET Framework并在线下载

    Section -.NET Framework ;检测是否是需要的.NET Framework版本 Call GetNetFrameworkVersion Pop $R1 ;${If} $R1 < ...

  7. NDK 笔记(一)

    参考:https://developer.android.com/studio/projects/add-native-code.html#link-gradle 使用Android Studio 2 ...

  8. 【Android】Android属性allowBackup安全风险

    allowBackup值为true或false,Android API Level 8及其以上Android系统提供了为应用程序数据的备份和恢复功能,当allowBackup标志为true时,用户即可 ...

  9. 编程轶事-java中的null-遁地龙卷风

    1.null是个奇妙的东西,可以理解为对象占位符 User user = null; System.out.println(user.getCredits()); 可以通过编译, User user; ...

  10. 3. Longest Substring Without Repeating Characters(c++) 15ms

    Given a string, find the length of the longest substring without repeating characters. Examples: Giv ...