函数式编程阅读笔记

函数式编程的基础来源于“lambda calculus”，这是Alonzo Church的一个奇妙想法。
简单来讲，一个函数可以接受另一个函数作为参数也可以输出另一个函数作为结果。这跟关系数据库一样有着坚实的数学基础。
当然不是所有的lambda calculus都可以被表示为一个程序，因为数学的理想终究要接受物理的限制。
与日常的命令式编程不同的是，变量一旦输入便不可改变。
别吐槽，lambda表达式说的可不是，在一个变量的所有时期都不可变更，只不过兴趣点更多的是在于对于数据的操作。
当然理论上，lambda calculus等价于turing machine。
object func {
  def main(args: Array[String]): Unit = {
    val a = "sda"
    val a = "ds"
    println(a)
  }
}
这时就会报错
Error:(7, 9) a is already defined as value a
    val a = "ds"
你要问我怎么解决？那就是写函数保持状态，如果要改变状态则使用迭代的方式    
  def reverse(arg:String): String = {
    if (arg.length == 0) {
      return arg
    } else {
      return reverse(arg.substring(1, arg.length)) + arg.substring(0, 1)
    }
  }
 
ps:从内存管理的角度来看，这个确实很容易造成memory hot，但确实是函数式编程的风格

此外，我们来了解下副作用这个概念：
如果一个函数不仅仅只是返回一个值，而且还做了如下的事：
1.擅自修改一个变量
2.直接动了数据结构
3.设置一个对象的成员
4.抛出一个异常或以一个错误停止
5.打印到终端或读取用户的输入
6.读写文件
这个就是副作用的概念。函数式编程的解法就是通过一个纯的内核和一层很薄的外围来处理这个问题

严格的定义如下：
对于一个输入类型为A和输出类型为B的函数f,也就是A => B。任何的内部和外部状态都不会影响到f的转换。
这在编程中是很重要的一点。因为比如，.length方法就应该专注于求某个参数的长度，除此之外，啥也不应该做。
引用透明：
先来个例子
  def add(a:Int, b:Int): Int = {
    return a+b
  }
无论怎么变，输入同一组a,b，都不会改变程序的结果。也即是，函数无论进行了什么样的操作都可以用它的返回值来代替。
这样的操作使得等式推理变得异常简单

二、一些概念
这个在SICP里有提到过，就是把一个函数当作另一个参数传递给另一个函数

  def factorial(n:Int): Int = {
    def loop(n:Int, acc:Int): Int =
        if (n <= 0) acc
        else loop(n-1, n*acc)

    loop(n, 1)
  }
 
其实就是闭包的概念

类型参数：也就是说类型也应该是函数的一部分

  def findFirst[A](as:Array[A], p: A => Boolean): Int = {
    def loop(n: Int): Int =
        if (n >= as.length) -1
        else if (p(as(n))) n
        else loop(n + 1)

    loop(0)
  }

ps:怎么觉得这个就是所谓的动态类型

findFirst(Array(1,2,3), (x:Int) => x == 2)

这里使用了匿名函数的概念

package fpinscala.datastructures
sealed trait List[+A] /*list是一个泛型参数，类型参数用A来表示*/
case object Nil extends List[Nothing] /*用于表现空List的list数据构造器*/
case class Cons[+A](head： A，tail: List[A]) extends List[A]/*呈现非空的List,实际上可以视为一个单向链表*/
object List {
  /**
    * 用于创建List和List操作
    */
    def sum(ints: List[Int]): Int = ints match{
        case Nil => 0
        case Cons(x, xs) => x + sum(xs)
  }
    def product(ds: List[Double]): Double = ds match {
        case Nil => 1.0
        case Cons(0.0, _) => 0.0
        case Cons(x, xs) => x * product(xs)
    }
    def apply[A](as: A*): List[A] =
        if (as.isEmpty) Nil
        else Cons(as.head, apply(as.tail: _*))
}

object except {
  def main(args: Array[String]): Unit = {
    println(failingFn(12))
  }
  def failingFn(i: Int): Int = {
    val y: Int = throw new Exception("fail")
    try{
      val x = 42 +5
      x + y
    }
    catch {case e: Exception => 43}
  }
}

  def mean(xs: Seq[Double]): Double = 
      if (xs.isEmpty)
        throw new ArithmeticException("wrong")
      else xs.sum / xs.length

  def mean(xs:IndexedSeq[Double], onEmpty: Double): Double =
      if (xs.isEmpty) onEmpty
      else xs.sum / xs.length

  def mean(xs: Seq[Double]): Option[Double] =
      if (xs.isEmpty) None
      else Some(xs.sum / xs.length)

 List(1,2,3,4).map(_+10)
 -List[Int] = List(11, 12, 13, 14)

def square(x:Int): Int = x *x

scala> false && {println("!!");true}
res3: Boolean = false
scala> false && {println("!!");true}
res3: Boolean = false