Functional programming F#：整数到整数对

我有一个函数，它将整数列表作为参数，并返回一个对列表作为结果。例如，

[1；2；3；4]

应返回为

[（1，2）；（3，4）]

我已经为此实现了以下功能

let listToPairList (list: int list) = 
  let index,pairList = List.foldBack(fun elem (iAcc,listAcc) -> 
    if (iAcc % 2 = 0) then
      (iAcc - 1,(elem,list.[iAcc + 1])::listAcc)
    else
      (iAcc - 1,listAcc)) list (list.Length - 1, [])
  pairList

现在，我想使用

foldBack

函数，但不使用索引。有人能告诉我怎么做吗

---

任何帮助都将不胜感激。

您可以使用

int选项

跟踪折叠中的下一项：

let listToPairList (list: int list) = 
    let (_, pairList) = List.foldBack (fun elem (pairAcc, listAcc) -> 
                                        match pairAcc with
                                        | None -> (Some(elem), listAcc)
                                        | Some(next) -> (None, (elem, next) :: listAcc))
                                        list
                                        (None, [])
    pairList

---

请注意，如果输入包含奇数个元素，这将删除列表中的第一项。

您可以使用

int选项来跟踪折叠中的下一项：

let listToPairList (list: int list) = 
    let (_, pairList) = List.foldBack (fun elem (pairAcc, listAcc) -> 
                                        match pairAcc with
                                        | None -> (Some(elem), listAcc)
                                        | Some(next) -> (None, (elem, next) :: listAcc))
                                        list
                                        (None, [])
    pairList

请注意，如果输入包含奇数个元素，这将删除列表中的第一项。
为什么要使用折叠

一个简单的递归函数怎么样

let rec listToPairList = function
    | []       -> []
    | x::[]    -> [(x,x)]
    | x::y::xs -> (x,y)::listToPairList xs

或者一个尾部递归的：

let listToPairList lst =
    let rec aux acc = function
        | []         -> acc |> List.rev
        | x::[]      -> (x,x)::acc |> List.rev
        | x1::x2::xs -> aux ((x1,x2)::acc) xs
    aux [] lst

为什么要使用折叠式

一个简单的递归函数怎么样

let rec listToPairList = function
    | []       -> []
    | x::[]    -> [(x,x)]
    | x::y::xs -> (x,y)::listToPairList xs

或者一个尾部递归的：

let listToPairList lst =
    let rec aux acc = function
        | []         -> acc |> List.rev
        | x::[]      -> (x,x)::acc |> List.rev
        | x1::x2::xs -> aux ((x1,x2)::acc) xs
    aux [] lst

如果列表包含奇数个元素，您想做什么？最后一个元素与其自身配对如果列表包含奇数个元素，您想做什么？最后一个元素与其自身配对