对 F# 中 List.mapi 的行为感到困惑

Question

我正在 F# 中构建一些方程，在处理我的多项式类时，我使用 List.mapi 发现了一些奇怪的行为

基本上，每个多项式都有一个数组，因此 3*x^2 + 5*x + 6 将是数组中的 [|6, 5, 3|]，因此，在添加多项式时，如果一个数组比另一个数组长，那么我只需将额外的元素附加到结果中，这就是我遇到问题的地方。

稍后我想将其概括为不总是使用 float，但这将是在我进行更多工作之后。

所以，问题是我期望 List.mapi 返回一个 List 而不是单个元素，但是，为了将列表放在一起，我必须将 [ ] 围绕我对 mapi 的使用，我很好奇为什么会出现这种情况。

这比我预期的更复杂，我认为我应该能够告诉它从某个索引开始创建一个新的 List ，但我找不到任何函数。

type Polynomial() =
    let mutable coefficients:float [] = Array.empty
    member self.Coefficients with get() = coefficients
    static member (+) (v1:Polynomial, v2:Polynomial) =
        let ret = List.map2(fun c p -> c + p) (List.ofArray v1.Coefficients) (List.ofArray v2.Coefficients)
        let a = List.mapi(fun i x -> x)
        match v1.Coefficients.Length - v2.Coefficients.Length with
            | x when x < 0 ->
                ret :: [((List.ofArray v1.Coefficients) |> a)]
            | x when x > 0 ->
                ret :: [((List.ofArray v2.Coefficients) |> a)]
            | _ -> [ret]

Answer 1

我认为在这种情况下，使用列表和递归的直接实现会更简单。 Polynomial 类的替代实现可能大致如下所示：

// The type is immutable and takes initial list as constructor argument
type Polynomial(coeffs:float list) = 
  // Local recursive function implementing the addition using lists
  let rec add l1 l2 = 
    match l1, l2 with
    | x::xs, y::ys -> (x+y) :: (add xs ys)
    | rest, [] | [], rest -> rest

  member self.Coefficients = coeffs

  static member (+) (v1:Polynomial, v2:Polynomial) = 
    // Add lists using local function
    let newList = add v1.Coefficients v2.Coefficients
    // Wrap result into new polynomial
    Polynomial(newList)

值得注意的是，您实际上并不需要类中的可变字段，因为 + 运算符创建并返回该类型的新实例，因此该类型是完全不可变的（正如您在 F# 中通常希望的那样）。

add 函数的好处是，在处理完两个列表中可用的所有元素后，您可以简单地将非空列表的尾部作为其余元素返回。

---

如果您想使用数组实现相同的功能，那么最好使用简单的 for 循环（因为数组原则上是命令式的，通常的命令式模式通常是处理问题的最佳选择）与他们）。但是，我不认为有任何特别的理由选择数组（也许是性能，但这必须在开发过程中稍后进行评估）。

正如 Pavel 指出的，:: 运算符将单个元素附加到列表的前面（请参阅上面的 add 函数，它演示了这一点）。您可以使用连接列表的 @ 或使用 Array.concat （连接数组序列）来编写您想要的内容。

使用高阶函数和数组的实现也是可能的 - 我能想到的最佳版本如下所示：

let add (a1:_[]) (a2:_[]) =
  // Add parts where both arrays have elements
  let l = min a1.Length a2.Length
  let both = Array.map2 (+) a1.[0 .. l-1] a2.[0 .. l-1]  
  // Take the rest of the longer array
  let rest = 
    if a1.Length > a2.Length 
    then a1.[l .. a1.Length - 1] 
    else a2.[l .. a2.Length - 1]
  // Concatenate them
  Array.concat [ both; rest ]

add [| 6; 5; 3 |] [| 7 |]  

这使用切片（例如a.[0 .. l]< /code>) 为您提供数组的一部分 - 您可以使用它们来获取两个数组都有元素的部分以及较长数组的剩余部分。

Answer 2

我认为您误解了运算符 :: 的作用。它不用于连接两个列表。它用于将单个元素添加到列表中。因此，它的类型是：

'a -> 'a list -> 'a list

在您的情况下，您将 ret 作为第一个参数，而 ret 本身就是一个浮点列表。因此，它期望第二个参数的类型为 float list list - 这就是为什么你需要向第二个参数添加额外的 [] 来使其编译 - 并且这也将是您的运算符 + 的结果类型，这可能不是您想要的。

您可以使用List.concat连接两个（或更多）列表，但这效率很低。在您的示例中，我根本看不到使用列表的意义 - 所有这些转换回来 &未来将是昂贵的。对于数组，可以使用Array.append，效果更好。

顺便说一句，您根本不清楚代码中 mapi 的用途。它与 map 完全相同，除了索引参数之外，但您没有使用它，并且您的映射是恒等函数，因此它实际上是一个无操作。是关于什么的？