Shulou(Shulou.com)06/02 Report--

This article mainly explains "Scala Functional Programming Basic Explanation". The explanation content in this article is simple and clear, easy to learn and understand. Please follow the ideas of Xiaobian and go deep into it slowly to study and learn "Scala Functional Programming Basic Explanation" together.

3 Fundamentals of functional programming

In purely functional programming languages, variables are like algebraic matches in mathematical languages, once determined, they cannot be changed. It is because of this immutability that there is equivalence between functions and ordinary values. Functions are thus "first-class citizens" like ordinary values, and can be passed and manipulated like any other data type.

Scala is not a fully functional programming language, it advocates object-oriented programming at the top of the architecture, and uses functional programming for data and various low-level operations. Variables can be defined using val or var, so it does not require variables to be immutable. But in practice, scala recommends using val more often than var, which reduces the probability of error.

Definition and Use of Functions

Since a function is equivalent to an ordinary value, it should also have a distinction between value and type.

type

The type should specify the return value type of the function and the type of the passed parameter.

value

A value is a concrete implementation of a function.

For example:

scala> val counter:(Int) => Int = { value => value + 1}val counter: Int => Int = $Lambda$1089/230944166@1372696bscala> counter(5)val res8: Int = 6

The counter defined above is a function, and line 2 includes its incoming parameter types and return value type definitions, i.e.(Int) => Int.

The left side of the symbol => is the type of the passed parameter of the method, and the right side is the type of the return value of the method.

The content in braces after the equal sign "=" is the method body.

When a function needs to define multiple parameter lists:

scala> def mult(factor:Int)(x:Int) = x*factordef mult(factor: Int)(x: Int): Intscala> mult(90)(5)val res9: Int = 450 Higher order functions

When a function contains other functions as arguments or as return values, the function is called a higher-order function and can be said to operate on other functions.

scala> def sum(f:Int => Int, a:Int, b:Int):Int = { if(a>b) 0 else f(a)+sum(f,a+1,b)}def sum(f: Int => Int, a: Int, b: Int): Intscala> sum(x=>x*x, 1, 5)val res10: Int = 55

Calculation of the above function:

Initially a = 1, b = 5

sum(x=>x*x, 1, 5)

= f(1) + sum(f, 2, 5) = 1 + f(2) +sum(f, 3, 5) = 1 + 4 + f(3) + sum(4,5)

= 1 + 4 +9 + f(4) + sum (5,5) = 1 + 4 + 9 + 16 + f(5) + sum(6,5)

= 1+ 4 + 9 + 16 + 25 + 0 = 55

closure

Some functions execute depending only on the values of the parameters passed in, regardless of the context in which the function is called. A function is said to be closed when its execution depends on variables declared outside the function.

Partial Application Function and Curry

partial application function

A function parameter may take the same value many times in a special application scenario, and some parameters of this function are integrated into one parameter and passed into a new function, which is called partial application function.

scala> def sum(a:Int, b:Int, c:Int):Int = { a+b+c}def sum(a: Int, b: Int, c: Int): Intscala> sum(1,2,3)val res21: Int = 6scala> sum(1,2,4)val res22: Int = 7scala> val a = sum(1,2,_:Int)val a: Int => Int = $Lambda$1114/1028466661@5dd12d01scala> a(9)val res23: Int = 12

Define a new variable a, which fixes the values of the first and second arguments of the original sum function, and then we only need to pass the third argument of the original sum function to a.

Curry

Curry functions are functions that have multiple parameter lists and only one parameter in each parameter list.

Operations on containers

traversal

Scala's standard container traversal method is foreach. The prototype for this method is: def foreach[U](f: Elem => U): Unit

Let's start with an example:

scala> var list = List(1,2,3) var list: List[Int] = List(1, 2, 3)scala> var f = (i:Int) => println(i)var f: Int => Unit = $Lambda$1122/1187220855@4ad30ac5scala> list.foreach(f)123

As you can see, the foreach method returns a value of type Unit, which takes a function f as an argument.

The function f passes in an argument of type Elem, which is the type of the element in the container, and returns a value of type Unit.

In this example, we iterated through the elements in the List container, which has element type Int. The function argument f passed into foreach functions prints elements.

We can also use infix notation to call foreach: format container foreach method applied to container

scala> list foreach println123

mapping

Mapping refers to generating a new container by performing certain operations on elements in the container. There are two typical mapping methods in scala: the map method and the flatMap method.

The map method performs the specified operation on each element in the collection to generate a new element, returning a new container of the same type and size as the original container.

scala> val bao = List("chen","rui","bo")val bao: List[String] = List(chen, rui, bo)scala> bao.map(s => s.length)val res32: List[Int] = List(4, 3, 2)

The flatMap method performs a specified operation on each element of the collection, returns a container for each element, and merges all the resulting containers into a single container and returns it. The returned container is of the same type as the original container, but the size may be different, and the element type may also be different.

scala> bao.flatMap(s => s.toList)val res36: List[Char] = List(c, h, e, n, r, u, i, b, o)

ps: List is a list that stores duplicate elements.

filtration

Filtering, as the name implies, filters the elements in the container according to actual requirements. The most classic filtering methods in scala are filters, exists, and find.

Here is an example of how to use filter:

scala> val university = Map("XMU"->"Xiamen University","THU"->"Tsinghua University", "PKU"->"Peking University")val university: scala.collection.immutable.Map[String,String] = Map(XMU -> Xiamen University, THU -> Tsinghua University, PKU -> Peking University)scala> f = university filter{ kv => kv._ 2 contains "Xiamen"} val res39: scala.collection.immutable.Map[String,String] = Map(XMU -> Xiamen University)

The whole process is to first create a Map container, then traverse the entire container, find the key-value pairs with the value "Xiamen," filter, and get a new Map container. where kv._ 2 is used to access the value of a key-value pair, and accordingly, if you want to access the key of that key-value pair, use kv._ 1。

Similarly, exists is used to find whether a container contains an element, and find is used to find the first element that matches the condition.

statute

A reduction is to perform a pairwise operation on the elements of a container and "reduce" them to a value.

Let's take a look at the most common methods of reduction:

scala> val list = List(1,2,3,4,5)val list: List[Int] = List(1, 2, 3, 4, 5)scala> list.reduce(_+_)val res41: Int = 15

Reduce takes a binary function f (with 2 elements) as an argument, and then performs an operation, the final result is 15, this process can be expressed as: (((1+2)+3)+4)+5).

So reduce accepts elements 1 and 2 for the first time, then 3 and 3, then 6 and 4, and finally 10 and 5, adds the two elements each time, and then uses the result of the addition as the first of the two elements received next time. The reduction operation proceeds until the traversal of the elements in the container is complete.

For a container with ordered elements such as List, the default order of reduce is from left to right. To customize the traversal order, you can use reduceLeft or reduceRight. The result of the convention is also related to the operation performed and the order of the convention. Addition and multiplication obey the commutative law and the associative law. There is no difference from left to right and from right to left, but there is a difference for subtraction.

For a container with disordered elements such as Set, the final result may be uncertain due to the undetermined order.

Similar to reduce, there is fold.

split

Split operations divide elements in a container into subcontainers according to certain rules. Common splitting methods are: partition, groupedBy, grouped, and sliding.

The partition method takes a Boolean function, iterates over the container and uses the Boolean function to determine whether each element meets the condition, and then returns two containers as a binary set, one for the set of elements that meet the condition and the other for the set of elements that do not.

scala> val list = List(1,2,3,4,5,6,7)val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7)scala> list.partition(_ val gby = list.groupBy(x=>x%3)val gby: scala.collection.immutable.Map[Int,List[Int]] = HashMap(0 -> List(3, 6), 1 -> List(1, 4, 7), 2 -> List(2, 5))

The grouped method takes an integer parameter n, divides the container into child containers of size n in left-to-right order, the last container possibly smaller than n, and returns an iterator of child containers.

scala> val group = list.grouped(2)val group: Iterator[List[Int]] = scala> group foreach printlnList(1, 2)List(3, 4)List(5, 6)List(7)

The sliding method takes an integer parameter n, truncates the container into sliding windows of length n in left-to-right order, and returns an iterator composed of subcontainers.

scala> val slidingwindow = list.sliding(3)val slidingwindow: Iterator[List[Int]] = scala> slidingwindow foreach printlnList(1, 2, 3)List(2, 3, 4)List(3, 4, 5)List(4, 5, 6)List(5, 6, 7)

Thank you for reading, the above is the "Scala functional programming basics explain" content, after the study of this article, I believe we have a deeper understanding of Scala functional programming basics explain this problem, the specific use of the situation also needs to be verified by practice. Here is, Xiaobian will push more articles related to knowledge points for everyone, welcome to pay attention!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.