Идиоматический способ "слить" несколько списков одинаковой длины в F#?

Question

У меня есть несколько списков - каждый экземпляр которого содержит 9 чисел с плавающей запятой. Что мне действительно нужно сделать, это создать один новый список, который берет первый элемент из каждого из моих списков и добавляет их вместе в качестве моего первого элемента, затем добавляет второй элемент из каждого списка в качестве моего второго элемента и т. Д.

Так эффективно, если мои данные выглядят примерно так:

List1 = [a1; b1; c1; d1; e1; f1; g1; h1; i1]
List2 = [a2; b2; c2; d2; e2; f2; g2; h2; i2]
...
Listn = [an; bn; cn; dn; en; fn; gn; hn; in]

Затем мне нужно создать новый список Listx, такой, что

Listx = [a1 + a2 + ... + an; b1 + b2 + ... + bn; ... ]

Количество списков, которые я буду объединять, будет различным (иногда у меня может быть только один список из 9 чисел, а иногда более 100 списков, всегда длиной 9 элементов), поэтому мне было интересно, есть ли у кого-нибудь какие-либо советы по поводу хорошего идиоматического способа делать это?

Я взглянул на этот вопрос и этот, но оба, похоже, выступают за промежуточный этап: сначала нужно проиндексировать мои элементы, а затем использовать групповую. Это меня беспокоит, потому что а) у меня возникает ощущение, что может быть более элегантное решение для моего конкретного случая, и б) производительность может быть проблемой позже - я не хочу преждевременно оптимизировать, но я также не хочу стрелять в себя в ногу.

Answer 1

Вот решение, которое работает со списком списков одинаковой длины:

let mapN f = function
   | []  -> []
   | xss -> List.reduce (List.map2 f) xss

let inline merge xss = mapN (+) xss

// Usage
let yss = List.init 1000 (fun i -> [i+1..i+9])
let ys = merge yss

Answer 2

Я бы пошел через что-то более простое, как матрица:

let merge xss =
  let m = matrix xss
  List.map (m.Column >> Seq.sum) [0..m.NumCols-1]

Answer 3

Вот один из подходов:

let merge lists =
  let rec impl acc lists =
    match List.head lists with
    | [] -> List.rev acc
    | _  -> let acc' = (lists |> List.map List.head |> List.reduce (+))::acc
            let lists' = List.map List.tail lists
            impl acc' lists'
  impl [] lists

Некоторые заметки:

• List.reduce (+) используется вместо List.sum или же List.sumBy потому что последние работают только для числовых типов, тогда как (+) может работать, например, string,

• merge выводится как тип int list list -> int list вместо того, чтобы быть общим из-за тонкостей оператора пути + работает. Если вам нужно только это для работы с одним типом, и этот тип не int (например float), затем добавление аннотации типа merge будет достаточно:

  let merge (lists:float list list) =
  

• merge можно отметить inline и тогда будет работать для любого типа, который поддерживает оператор +, но это приведет к большому раздутию в вашем IL, если имеется более одного или двух колл-сайтов. Если у вас есть несколько типов, с которыми нужно работать merge, и все известны заранее, то хороший обходной путь здесь должен сделать mergeinline (и, возможно, private) затем определить различные специфичные для типа функции, которые реализуются в терминах общего merge:

  let inline merge lists =
    let rec impl acc lists =
      match List.head lists with
      | [] -> List.rev acc
      | _  -> let acc' = (lists |> List.map List.head |> List.reduce (+))::acc
              let lists' = List.map List.tail lists
              impl acc' lists'
    impl [] lists
  
  let mergeInts (lists:int list list) = merge lists
  let mergeFloats (lists:float list list) = merge lists
  let mergeStrings (lists:string list list) = merge lists
  

  Если вы тогда вызываете только для конкретного типа merges, раздувание IL должно быть незначительным.

• Наконец, если производительность действительно важна, используйте массивы, а не списки.

Answer 4

// Shamelessly stolen from:
// http://hackage.haskell.org/packages/archive/base/latest/doc/html/src/Data-List.html#transpose
let rec transpose = function
  | [] -> []
  | ([] :: xss) -> transpose xss
  | ((x :: xs) :: xss) -> (x :: List.map List.head xss) :: transpose (xs :: List.map List.tail xss)

let fuse = transpose >> List.map List.sum

printfn "%A" (fuse [[3; 4]; [1; 90]; [34; 89]]) // prints [38; 183]

Answer 5

Вот альтернативный вкладыш со значениями по умолчанию, когда список списков пуст:

let sumVertically length = List.fold (List.map2 (+)) (List.replicate length 0)

//usage
//stolen from pad's answer
let listOfLists = List.init 1000 (fun i -> [i+1..i+9])
sumVertically 9 listOfLists