計算機顧名思義，執行計算功能。然而通常計算機是通過重復計算得出結果。例如計算從1到100的求和，就是一個個數進行累加。這樣的重復性工作，人類顯然不太擅長，所以人發明了算法。高斯小朋友就實現了一個等差數列的求和算法。

既然計算機通過快速的重復計算得出結果。那么對數據源進行循環處理就是一種基本的控制結構。經典的循環控制都是通過while，for語句實現。很可惜，elixr中并沒有這樣的語句。不過不用擔心，elixir提供了優雅而強大的遞歸來進行循環迭代處理。

遞歸

在函數內調用函數自身即為遞歸。正常情況下，打印一些一些自然數可以這么寫：

# python
In [1]: for i in range(1, 6):
   ...:     print i
   ...:
1
2
3
4
5

In [4]: n = 1

In [5]: while n <= 5:
   ...:     print n
   ...:     n += 1
   ...:
1
2
3
4
5

Elixir 中使用遞歸則為：

defmodule Nums do

    def print(1), do: IO.puts 1

    def print(n) do
     print(n - 1)
     IO.puts n
    end

end

iex(1)> Nums.print(5)
1
2
3
4
5
:ok

列表遞歸

Lisp擁有很高的聲譽，它本身就是指列表進行計算。前面我們提及，List的實現是鏈表結構，因此讀取列表第一個元素將會很快。elixir還提供了|操作符。下面就使用列表來完成加和計算：

defmodule Math do
    
    def sum([]) do
        0
    end 

    def sum([head|tail]) do
        head + sum(tail)
    end

end


IO.puts Math.sum([1, 2, 3, 4, 5])

尾遞歸

使用遞歸來做循環控制是函數式語言的一大特點。別的語言通常在處理遞歸的時候存在著一個最大遞歸深度。而elixir對遞歸在編譯上做了優化。當然并不是針對所有遞歸，而是專門指尾遞歸（tail recursion）。至于尾遞歸和遞歸的差別，可以閱讀遞歸和尾遞歸。其形式大概就是自己調用自己的時候，并不是作為表達式，大概形式如下：

def original_fun(...) do
    ...
    another_fun(...)    # Tail call 
end

上述加和操作用尾遞歸重寫如下：

defmodule Math do
    
    def sum(list) do
        _sum(list, 0)
    end

    defp _sum([], accumulator) do
        accumulator
    end

    defp _sum([head|tail], accumulator) do
        _sum(tail, head + accumulator)
    end

end


IO.puts Math.sum([1, 2, 3, 4, 5])

更多遞歸

上述遞歸的控制基于函數參數的模式匹配，關于條件的控制，還有case和cond宏，下面結合這些控制結構來重寫上述的求和計算。

Lisp中常用cond結構，下面情況cond的結果：

defmodule Math do
    
    def sum(list) do
        _sum(list, 0)
    end

    def _sum(list, accumulator) do
        
        cond do
            list == [] -> 
                accumulator
            
            [head|tail] = list -> 
                _sum(tail, head+accumulator)
        end

    end

end


IO.puts Math.sum([1, 2, 3, 4, 5])

再看case的結果：

defmodule Math do
    
    def sum(list) do
        _sum(list, 0)
    end

    def _sum(list, accumulator) do
        
        case list do
            [] -> accumulator
            [head|tail] -> _sum(tail, head + accumulator)
        end
    end
end


IO.puts Math.sum([1, 2, 3, 4, 5])

由此可見，使用遞歸實現循環控制，遇到條件判斷的時候，即可以使用函數參數的模式匹配，也可以使用cond和case方式進行判斷。其中cond和case內部邏輯分支也是基于模式匹配。

列表解析

todo

總而言之，使用elixir的遞歸實現迭代功能，盡量使用尾遞歸。尾遞歸經過編譯器優化，不會因為調用棧出現問題，也不會引起額外的內存開銷。普通遞歸則會出現最大遞歸棧的問題。實際上，函數式語言的特點就是函數。在實現循環的功能，Elixir提供了一些高階函數用來處理，通過這些高階函數的抽象，隱藏了遞歸調用的細節。開發者掌握這些高階函數，更有利于實現功能需求。Enum和Stream提供了大部分所需要的函數，下一節繼續探索高階函數。