Notes on reading: Functional Programming in Scala - Part 1

Part 1introduces functional programming, explains what it is, why you should care, and walks through the basic low-level techniques of FP, including how to organise and structure small functional programs, define functional data structures, and handle errors functionally.  

Chapter 1: What is functional programming

* Pure functions: functions that have noside effects(has no observable effect on the execution of the program other than to compute a result given its inputs)

* Referential transparency and purity: An expression e is referentially transparent if for all programs p, all occurrences of e in p can be replaced by the result of evaluating e, without affecting the observable behavior of p. A function f is pure if the expression f(x) is referentially transparent for all referentially transparent x.

* FP benefits: modularity. 

because it separates the logic of the computation itself from "what to do with the result" and "how to obtain the input";  Input is obtained in exactly one way:via the argument(s) to the function. And the output is simply computed and returned. By keeping each of these concerns separate, the logic of the computations more reusable

Chapter 2: Getting Started

* Modules, objects, namespaces

* Function objects: passing functions to functions

* Anonymous functions

* Polymorphic functions: abstracting over types

Chapter 3: Functional Data Structure

* Trait, class, object, type

* Variance

* Algebraic data type & Pattern matching

* High-order functions

* List & Trees

Chapter 4: Handling errors without exceptions

* Option

* Either: both ordinary value and exceptions

Chapter 5: Strictness and laziness

* Non-strict function: the function may choosenot to evaluate one or more of its arguments. Benefits: 

1)recovering some efficiency 

2)improve modularity by separating the description of an expression from the "howand when" of its evaluation. 

* Lazy list

Chapter 6: Purely functional state

* State

* Handle state in a purely functional way:  use a pure function that accepts a state as its argument, and it returns the new state alongside its result