Как я могу реализовать добавление хвостового рекурсивного списка?

Question

Простая функция добавления, как это (в F#):

let rec app s t =
   match s with
      | [] -> t
      | (x::ss) -> x :: (app ss t)

потерпит крах, когда s станет большим, так как функция не является хвостовой рекурсивной. Я заметил, что стандартная функция добавления F# не падает с большими списками, поэтому она должна быть реализована по-другому. Вот я и подумал: как выглядит хвостовое рекурсивное определение append? Я придумал что-то вроде этого:

let rec comb s t =
   match s with
      | [] -> t
      | (x::ss) -> comb ss (x::t)
let app2 s t = comb (List.rev s) t 

который работает, но выглядит довольно странно. Есть ли более элегантное определение?

Answer 1

Традиционный (не хвостовой рекурсивный)

let rec append a b =
    match a, b with
    | [], ys -> ys
    | x::xs, ys -> x::append xs ys

С аккумулятором (хвост-рекурсивный)

let append2 a b =
    let rec loop acc = function
        | [] -> acc
        | x::xs -> loop (x::acc) xs
    loop b (List.rev a)

С продолжениями (хвостовая рекурсия)

let append3 a b =
    let rec append = function
        | cont, [], ys -> cont ys
        | cont, x::xs, ys -> append ((fun acc -> cont (x::acc)), xs, ys)
    append(id, a, b)

Довольно просто преобразовать любую нехвостую рекурсивную функцию в рекурсивную с продолжениями, но я лично предпочитаю аккумуляторы для прямой читабельности.

Answer 2

В дополнение к тому, что опубликовала Джульетта:

Использование выражений последовательности
Внутренне, выражения последовательности генерируют хвост-рекурсивный код, так что это работает просто отлично.

let append xs ys = 
  [ yield! xs
    yield! ys ]

Использование изменяемых типов.NET
Дэвид упомянул, что списки F# могут быть видоизменены - однако они ограничены только базовыми библиотеками F# (и эта функция не может использоваться пользователями, поскольку она нарушает функциональные концепции). Вы можете использовать изменяемые типы данных.NET для реализации версии на основе мутаций:

let append (xs:'a[]) (ys:'a[]) = 
  let ra = new ResizeArray<_>(xs)
  for y in ys do ra.Add(y)
  ra |> List.ofSeq

Это может быть полезно в некоторых сценариях, но я обычно избегаю мутаций в коде F#.

Answer 3

С первого взгляда на источники F# кажется, что хвост внутренне изменчив. Простым решением было бы обратить первый список, прежде чем объединить его элементы во второй список. Это, наряду с обращением списка, тривиально реализовать рекурсивную реализацию tail.