18656 Functional Programming in Practice Week 2

字数统计: 2.9k字   |   阅读时长≈ 17分

This Note contains:

  • Function Syntax Reminder, Function as Values, Function Scope
  • Lambda Expression
  • Currying
  • Function Composition
  • Building an app from functions
  • Pattern Matching for structural decomposition
  • Match Expressions: Advanced

Functions Syntax Reminder

1
2
let cylinderVolume radius length =
	length * 3.14159 * radius * radius

  • Declared with let keyword and a name

  • Parameters added after a space, their type automatically inferred

  • Indentation mandatory to indicate a function body

  • Last expression evaluates to the return value

1
2
let cylinderVolume radius length =
	length * 3.14159 * radius * radius

Input / Output type

Type inference avoids the need to declare input / output types

To specify a return type, add a colon and the type after the parameters list

1
2
let cylinderVolume radius length : float =
	length * 3.14159 * radius * radius

For input parameters, encompass each om brackets and provide type after a colon.

1
2
let cylinderVolume (radius : float) (length : float) : float =
	length * 3.14159 * radius * radius

Local Identifier

It can contain definitions of of local identifies and functions

  • Accessible only in scope of the body of the current function
1
2
3
let cylinderVolume radius length =
	let pi = 3.14159
	length * pi * radius * radius

Function Scope

Names can be reused at any level other than module scope.

  • Later declaration shadow previous one
1
2
3
4
5
let list1 = [1;2;3]
let list1 = []
let function1 () = 
	let list1 = []
	list1

​ Error: duplicate definition

​ This code Error because Name reused in implicit top-level module

This code will run if we comment line 2 out and the function will return a empty records.

Functions as values

All function are considered values.

Function accept another function as parameter.

Function can return another function as the value of the function call.

High order function: a function that takes another function as a parameter, or a function that returns another function as a value, or a function that does both.

High order function example

1
2
3
4
5
6
7
8
9
let twice f v = // this function will call f function twice with parameter v and (f v)
	f (f v) 

let add4 x = 
	x + 4

twice add4 10

(*The output is 18*)

Twice is a higher order function because it accepts a function as parameter and returns a function

1
2
3
4
5
6
7
let applyToPair f (x, y) =  // parameter: f as function, (x, y) as tuple
	(f x, f y)
	
let square x = 
	x * x
	
applyToPair square (10, 100)

High Order Function: Key Take ways

  • A frequently used technique to construct new function from existing functions and reuse them
  • Allow to express algorithms and pass functionality as parameters

Lambda Expression

Lambda Expression is a function without a name (anonymous).

  • It defined by using the fun keyword
  • -> separates the arguments from the function body
1
fun x y -> x + y
  • Multi-line lambda are encompassed by paratheses
1
2
(fun elem a ->
	printfn $"A long line to format the value: %d{a + elem}")
  • A lambda expression can be assigned to an identifier
1
2
let square = fun x -> x * x
let result = square 6  // function evaluation

Closure

A function using identifier from the lexical scope that is defined within. 

1
let square = fun x -> x * x
  • parameter of both square function and lambda expression *”close over”*
1
let result = square 6 // function evaluation
  • The bidirectional interaction allow function to “remember” identifiers fron their environment when they were created.

Usage

  1. Passed as argument to other function (sort, filter, …)

  2. A function is used a limited number of times

  3. Creation of small helper functions on the spot

Currying

A functional method of handling argument

Reminder:

  • Function can accept only 1 parameter
  • Function values can be returned from a function

Technique for simulating a multi-parameter function by sequentially returning different single parameter

Example #1

1
2
let printTwoParameters x y = 
	printfn 'x=%i y =%i' x y

To , Translate the definition into one-parameterfunction.

Inside, construct a function that takes in the nex parameter.

1
2
3
let printTwoParameter x = 
	let innerFun y = 
		printfn 'x=%i y =%i' x y // x in scope of innerFun

It return the newly created subfunction innerFun.

Exercise #1

Re-write as a set of curried functions: 

1
2
let addThreeParameters x y z = 
	x + y + z

Solution

1
2
3
4
5
6
7
8
9
10
11
let addThreeParameters x = 
	let subMethod1 y = 
		let subMethod2 z = 
			x + y + z
		subMethod2
	subMethod1
(*
subMethod1 return subMethod2
addThreeParameter return subMethod2
subMethod2 do the job which calculate x + y + z
*)

For both implementation, they have the same function signature.

Key takeaways

It ensure all F# functions accept only 1 input and evaluate to 1 output

It shows a lot of syntactic sugar exist in F#

Example #2

1
2
let sum x y =
	x + y
  • Fix the x parameter and vary y only
1
2
3
sum 2 3
sum 2 4
sum 2 5
  • Write a function to make 2 a constant parameter
1
let sumBy2 y = sum 2 y

Wrapper Function

Example: creation of DateTime Object

1
2
3
4
open system
let buildDt year month day = DateTime(year, month, day)
let buildDtThisYear month day = buildDt DateTime.UtcNow.Year month day
let buildDtThisMonth day = buildDtThisYear DateTime.YtcNow.Month day
  • Function refactored to bake-in parameters
1
2
3
4
open system
let buildDt year month day = DateTime(year, month, day)
let buildDtThisYear = buildDt DateTime.UtcNow.Year
let buildDtThisMonth = buildDtThisYear DateTime.UtcNow.Month

Partial Application: the act of calling a curried function to get back a new function

Exercise #2

Create a wrapper function, writeToFile, for writing data to a text file :

  • The function should take in 3 argument in this specific order:
    • date - The current date (DateTime type)
    • filename - a filename
    • text - the text to write out
  • The body should create a filename in the form {date}-{filename}.txt
  • Construct date part of the filename by using ToString("yyMMdd")

Solution

1
2
3
4
5
open System

let writeToFile (date:DateTime) filename text = 
	let path = date.ToString("yyMMdd") + filename + ".txt"
	System.IO.File.WriteAllText(path, text)

Step 2

Create more-constrained version of writeToFile:

  1. a version of the function to print with today’s date (hint: use DateTime.Today)
  2. a version of the function to print with a specific fixed file name and today’s date
  3. a version of function where only the text is fixed with “test”

Solution

1
2
3
4
5
6
7
8
9
10
open System

// 1
let writeToFileToday = writeToFile DateTime.today
	
// 2 
let writeToFileSpecificName = writeToFile "some specific name"
	
// 3
let writeFixedText = writeToFile date filename "test"

Function Composition

Function can be composed by *”gluing them together”* to create a new function

  • given functions a -> b and b -> c
  • generate a new function a -> c

Compose >> operater is used for this purpose

1
2
3
4
5
6
7
8
9
10
11
let function1 x = x + 1
let function2 x = x * 2

let h = function1 >> function2

let result = h 100

(*
First, 100 apply to function1 which output 101
Then, 101 apply to function2, the final result is 202
*)

Types

Function can be composed as long as the output type of the first one is the same as the input type of the second one

1
2
let f (x:int) = float x * 3.0
let g (x:float) = x > 4.0
  • Output of f is compatible with input of g hence functions can be composed
1
2
3
let h = f >> g

// the function signature of h is int to boolean

Backwards Compose

<< operator composes two functions in reverse order

1
2
3
4
5
6
let square x = x * x
let substractTwo x = x - 2
let negate x = -x
let composedFunction = square << subtractTwo << negate
let result = composedFunction 5
// final result is 49

Function composition is a way to achieve information hiding in F#

Exercise

Which of the following lines will compile? If there is and issue, what is it? 

1
2
3
4
5
6
7
8
9
let add n x = x + n
let times n x = x * n
let compare a b = (a = b)

let composed1 = add >> times >> compare
let composed2 = (add, times) >> compare
let composed3 = times << add 2
let composed4 = add 2 >> times
let composed5 = add 2 << times

Solution

composed1 won’t compile because compare is short of one parameter. times only output one parameter

composed2 won’t compile because (add, times) is one object as a tuple but 2 value expect

composed3 will compile which partial application makes this work

composed4 will compile and it’s equivalent of composed3

composed5 won’t compile because times is lack of parameter and will evaluated first

Building an app from functions

  1. Basic functions as building blocks

  2. Composing multiple basic functions to service

  3. Composing services into a business workflow

  4. Composing workflows into an application

Match Expression

F# Example: 

1
2
3
4
5
6
7
8
let x = 2
let text =
	match x with // test expression
	| 0 -> "zero”
	| 1 -> "one"
	| 2 -> "two"  // pattern -> result expression
	| _ -> "other”
// result is "two"

Syntax

  • The match keyword, preceding the expression to be evaluated
  • The with keyword, indicating start of the values to compare against
  • The vertical pipe character (|) for every pattern that will be evaluated for a match
  • The arrow (->), preceding the expression to execute if the match is found
  • Pattern matching compares a test expression with a set of patterns
  • Upon a match, the corresponding result-expression is evaluated.
  • Resulting value is returned from the match expression. test expression

Expression

Expressions are constructs that evaluate to a value.
Statements are actions that a program takes.

Functional programming paradigm firmly encourages expressions as the default way of working

  • No notion of void functions
  • Branching mechanisms are expressions

Return Value

  • A match expression always returns a value
  • All clauses in the match expression must yield compatibly

Incomplete match expression will give a warnning

1
2
3
4
5
6
7
let name = "Rafal"
let result = 
	match name with 
	| "John" -> "the name is John"
	| "Bob" -> "Hi Bob"
	
// Compiler: warning FS0025: Incomplete pattern matches on this expression

Wildcard Operator

“_” matches any value

Anything that doesn’t match against preceding clauses will match against this one

1
2
3
4
5
6
let name = "Rafal”
let result =
	match name with
	| "John" -> "The name is John”
	| "Bob" -> "Hi Bob!”
	| _ -> "I don't know you!

Pattern matching works top down. Put the most specific patterns first and the most general last.

Nested Match Expressions

Nesting match expressions introduces code complexity and should be used only for a significant number of repeated elements.

1
2
3
4
5
6
7
8
9
10
let customer = ("good", 0)
let limit =
	match customer with
	| "medium", 1 -> 500
	| "good", years ->
			match years with
			| 0 | 1 -> 750
			| 2 -> 1000
			| _ -> 2000
	| _ -> 250

Guard

When clause (guard) allows to specify additional conditions in a match expression.

A guard allows to introduce any form of a check within a pattern rather than just matching against values

1
2
3
4
5
6
7
8
let customer = ("good", 0)
let limit =
	match customer with
	| "medium", 1 -> 500
	| "good", years when years <2 -> 750
	| "good", 2 -> 1000
	| "good", _ -> 2000
	| _ -> 250

Comparing the bound values from a test expression.

1
2
3
4
5
6
7
// comparing values in a when clause
let makeOrdered aTuple =
	match aTuple with
	// swap if x is bigger than y
	| (x,y) when x > y -> (y,x)
	// otherwise leave alone
	| _ -> aTuple

Testing properties as part of the when clause.

1
2
3
4
let isAm aDate =
	match aDate:System.DateTime with 
	| x when x.Hour <= 12 -> printfn "AM"
	| _ -> printfn "PM"

When not to use when?

The compiler won’t figure out anything that happens inside the guard.

  • Exhaustive pattern matching is not performed.
  • One needs to define the default (wildcard operator) case.

Shortcut Syntax

Parameter and match .. with can be omitted thanks to currying

1
2
3
4
5
6
7
8
9
10
11
12
let getPrice1 food =
	match food with
	| "banana" -> 0.79
	| ”apple" -> 2.1
	| "tofu" -> 3.09
	| _ -> 0.0

let getPrice = function
	| "banana" -> 0.79
	| ”apple" -> 2.1
	| "tofu" -> 3.09
	| _ -> 0.0

Pattern Matching for Structural Decomposition

Extraction and binding of specific data from within a data structure.

Pattern matching is available for all the built-in F# types.

Tuple

“,“ (comma) is needed to construct (and deconstruct) tuples

1
2
let z = 1, true, "hello", 3.14 // "construct" a tuple
let z1, z2, z3, z4 = z // "deconstruct" a tuple
  • A new set of individual identifiers are bound to values from inside the tuple

“_“ matches any input, but that the input is discarded instead of assigned to an identifier

1
2
let z = 1, true, "hello", 3.14
let _,z5,_,z6 = z // ignore 1st and 3rd elements

Exercise

For the code snippet below write down patterns to extract :

  1. The value 3 from a and bind it to the identifier t
  2. The value 3 from a and true from b and bind them to the identifiers c and d respectively.

Implement it in 1 line (you can start with a 2-line notation first)
3. The values true and 83 from b and bind them to the identifiers eand f respectively

1
2
let a = 2, 3
let b = 9.0, true, ((5, 83), a)
Solution:
1
2
3
let _ , t = a // solution 1
let (_, c), (_, d, _) = a , b // solution 2
let _, e, ((_, f), _) = b // solution 3

Records

“=“ sign is used to create record values

1
type ComplexNumber = {Real: float; Imaginary: float}

Construction and deconstruction syntaxes are Symmetric

1
2
let myComplexNumber = { Real = 1.1; Imaginary = 2.2 }
let {Real = a; Imaginary = b} = myComplexNumber

“_“ discards part of a record one doesn’t need

1
let {Real = a ; Imaginary = _} = myComplexNumber

Alternatively, one can simply ignore an unwanted label from a Record

1
let {Real = a} = myComplexNumber

Discriminated Union

Use a “constructor” that refers to one of the possible union cases

1
2
3
4
5
6
7
type CardType = Debit | Credit
type Payment =
	| CreditCard of CardType
	| Cash of float // simple type (“wrapper” DU)
	
let myPayment = CreditCard Debit // use “CreditCard” constructor
let yourPayment = Cash 120.1 // use “Cash” constructo

Each case must return the same data type (Payment)

1
2
3
4
let deconstructor x =
	match x with
	| CreditCard cardType -> CreditCard cardType
	| Cash amount -> Cash amount

Evaluate “deconstructor” match expression to deconstruct a discriminated union

1
2
3
4
let myPayment = CreditCard Debit // use “CreditCard” constructor
let yourPayment = Cash 120.1 // use “Cash” constructor
let result1 = deconstructor myPayment
let result2 = deconstructor yourPayment

A payment processing function that accepts Debit cards and cash only

1
2
3
4
5
let processPayment payment =
	match payment with
	| CreditCard Debit -> printfn ”Payment with Debit card"
	| CreditCard _ -> printfn "This card is not accepted" // wildcard operator
	| Cash amount -> printfn ”Cash payment of %f" amount

Exercise Quiz

In programming, assignment refers to the process of storing a value in a variable. It is typically performed using the assignment operator, represented by the equals sign (=).

In functional programming, binding is the action of linking an identifier and a value. In F# it is typically performed using the let keyword.

There are four important differences between “assignment” and pattern-matching & binding.

Please fill in the text below using the following options (each is used only once):

  1. assignment

  2. assignment

  3. binding

  4. shadowing

  5. pattern-matching,

  6. pattern-matching.

  7. ___ cannot fail

    ___ can

  8. Assignment must assign a value to at least one variable. ___ does not necessarily result in any identifiers being bound.

  9. ___ always makes a copy

    ___ never causes any copies to be made

  10. Re-assignment to an existing variable changes the value that is linked to that variable name. Rebinding a name does not affect any existing binding. What takes place is instead is ____.

    This means that the new binding takes precedence over the existing one.

Answer

  1. Assignment cannot fail.

    Pattern-matching can.

  2. Assignment must assign a value to at least one variable. Pattern-matching does not necessarily result in any identifiers being bound.

  3. Assignment always makes a copy

    Binding never causes any copies to be made

  4. Re-assignment to an existing variable changes the value that is linked to that variable name. Rebinding a name does not affect any existing binding. What takes place is instead is Shadowing.

    This means that the new binding takes precedence over the existing one.

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true