Erlang中的排列示例

Question

I have a question about an Erlang Perms implementation:

 perms([]) -> [[]];
 perms(L) -> [[H|T] || H <- L, T <- perms(L--[H])].

The code above is from a book named Erlang Programming , it looks very simple but run perfectly. What I'm confusing about is how it works. For example, let's run it with a parameter like perms("12") , then if we analyze the process of recursion. I think that the first return's result will be like [[1|perms[2]->[[2]|[[]]]] and this equals [[1|[[2]|[[]]]] . But it is a wrong expression in Erlang shell.

Answer 1

The general behavior of list comprehension is to generate the cross product of all generators (after applying the defined filters). It is better illustrated by an example:

1> [{X,Y} || X <- [1,2,3], Y <- [a,b,c]].
[{1,a},{1,b},{1,c},{2,a},{2,b},{2,c},{3,a},{3,b},{3,c}]
2> 

in the permutation code example, the list comprehension is executed this way:

H <- L is a generator, it will generate one value for each term of the input list L. in your case, L = "12", it will generate 2 terms the characters $1 and $2 , and it will build the cross product with the result of the second generator: T <- perms(L--[H])

Here there is something very smart, the second generator depends on the first one, each element of the first generator will be combined with its own list from the second generator. So $1 will be combine with the generated terms from perms(L--[$1]) = perms("2")

If you try to evaluate perms("2") , the same analysis shows that the first generator generates one single term $2 to combine with perms([])

the last term evaluate to [[]] and will generate an empty list.

we can build now the intermediate result: [[H|T]] = [[$2|[]]] = [[$2]] .

This result will generate the single term [$2] . So the top level result will be (taking into account all generated terms) [[$1|[$2]],[$2|[$1]] = [[$1,$2],[$2,$1]] = ["12","21"] .