Erlang learning 02

fun

fun： Basic Abstract units , stay Erlang The data type used to represent functions in is called fun.
Standard library lists The module exports some with fun As a function of parameters . The most useful of them is lists:map(F, L). This function returns a list , It gives the list L Each element in the application fun F Generate .
Another useful function is lists:filter(P, L), It returns a new list , contains L All qualified elements in

9> L=[1,2,3,4].
[1,2,3,4]
10> lists:map(fun(X) -> 2*X end,L).
[2,4,6,8]

11> Even=fun(X) ->(X rem 2) =!= 0 end.
* 1: syntax error before: '!'
11> Even=fun(X) ->(X rem 2) =:= 0 end.
#Fun<erl_eval.6.118419387>
12> Even(3).
false
13> Even(2).
true
14> lists:map(Even,[1,2,3,4,5,6,8]).
[false,true,false,true,false,true,true]
15> lists:filter(Even,[1,2,3,4,5,6,8]).
[2,4,6,8]

map and filter Such functions can perform some operation on the whole list in one call , We call them one list at a time （list-at-a-time） Type operation . Use one list operation at a time to make the program smaller , And it's easy to understand . The reason why it is easy to manage The solution is that we can regard each operation on the whole list as a single conceptual step of the program . otherwise , You must align the columns Each operation of the table element is regarded as a separate step of the program . 

Functions can not only be used fun As a parameter （ for example map and filter）, You can go back to fun.

1> Fruit=[apple,pear,orange].
[apple,pear,orange]
2> MakeTest=fun(L) -> (fun(X)-> lists:member(X,L) end) end.
#Fun<erl_eval.6.118419387>
3> IsFruit=MakeTest(Fruit).
#Fun<erl_eval.6.118419387>
4> IsFruit(pear).
true

5> lists:filter(IsFruit,[dog,orange,cat,pear,apple]).
[orange,pear,apple]

-module(shop2).
-export([total/1]).
-import(lists,[map/2,sum/1]).

total(L) ->
	sum(map(fun({What,N}) -> shop:cost(What)*N end,L)).

11> c(shop2).
{ok,shop2}
12> Buy=[{oranges,4},{newspaper,1},{apples,10},{pears,6},{milk,3}].
[{oranges,4},{newspaper,1},{apples,10},{pears,6},{milk,3}]
13> L1=lists:map(fun({What,N}) -> shop:cost(What)*N end,Buy).
[20,8,20,54,21]
14> lists:sum(L1).
123

You should also pay attention to the module -import and -export Usage of declarations .  -import(lists, [map/2, sum/1]). The statement means map/2 Function is from lists Imported from the module , The back is the same . That means we can use map(Fun, ...) Instead of lists:map(Fun, ...) It's written in .cost/1 Not declared in the import declaration , So you have to use “ Completely limited ”（fully qualified） The name of shop:cost.

-export([total/1]) The statement means total/1 The function can be in shop2 Call outside the module . Only from one Only functions exported from modules can be called outside the module .

The list of deduction

The list of deduction （list comprehension） No need to use fun、map or filter You can create the expression of the list . It makes the program shorter , Easier to understand .

Use map

1> L=[1,2,3,4,5].
[1,2,3,4,5]
2> lists:map(fun(X)-> 2*X end,L).
[2,4,6,8,10]

Use list derivation

3> [2*X || X <- L].
[2,4,6,8,10]

[ F(X) || X <- L] The mark means “ from F(X) A list of components （X From the list L Extract from ）”. therefore ,[2*X || X <- L ] It means “ from 2*X A list of components （X From the list L Extract from ）”.