Предотвращение дублирования кода в F#

Как прокомментировал Рекс, если вы хотите этого только для двух случаев, у вас, вероятно, не будет никаких проблем, если вы оставите код как есть. Однако, если вы хотите извлечь общий шаблон, вы можете написать функцию, которая разбивает список на подсписки указанной длины (2 или 3 или любое другое число). Как только вы это сделаете, вы будете использовать только map , чтобы превратить каждый список указанной длины в Vector .

Функция разделения списка недоступна в библиотеке F # (насколько я могу судить), поэтому вам придется реализовать ее самостоятельно. Это можно сделать примерно так:

let divideList n list = 
  // 'acc' - accumulates the resulting sub-lists (reversed order)
  // 'tmp' - stores values of the current sub-list (reversed order)
  // 'c'   - the length of 'tmp' so far
  // 'list' - the remaining elements to process
  let rec divideListAux acc tmp c list = 
    match list with
    | x::xs when c = n - 1 -> 
      // we're adding last element to 'tmp', 
      // so we reverse it and add it to accumulator
      divideListAux ((List.rev (x::tmp))::acc) [] 0 xs
    | x::xs ->
      // add one more value to 'tmp'
      divideListAux acc (x::tmp) (c+1) xs
    | [] when c = 0 ->  List.rev acc // no more elements and empty 'tmp'
    | _ -> failwithf "not multiple of %d" n // non-empty 'tmp'
  divideListAux [] [] 0 list      

Теперь вы можете использовать эту функцию для реализации двух ваших преобразований следующим образом:

seq { for [x; y] in floatList |> divideList 2 -> Vector2(x,y) }
seq { for [x; y; z] in floatList |> divideList 3 -> Vector3(x,y,z) }

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

Это аналог решения kvb, но не использует частичный активный шаблон.

let rec listToSeq convert (list:list<_>) =
    seq {
        if not(List.isEmpty list) then
            let list, vec = convert list
            yield vec
            yield! listToSeq convert list
        }

let vec2Seq = listToSeq (function
    | x::y::tail -> tail, Vector2(x,y)
    | _ -> failwith "float array not multiple of 2?")

let vec3Seq = listToSeq (function
    | x::y::z::tail -> tail, Vector3(x,y,z)
    | _ -> failwith "float array not multiple of 3?")

Честно говоря, то, что у вас есть, почти настолько хорошо, насколько это возможно, хотя вы могли бы сделать немного более компактным, используя это:

// take 3 [1 .. 5] returns ([1; 2; 3], [4; 5])
let rec take count l =
    match count, l with
    | 0, xs -> [], xs
    | n, x::xs -> let res, xs' = take (count - 1) xs in x::res, xs'
    | n, [] -> failwith "Index out of range"

// split 3 [1 .. 6] returns [[1;2;3]; [4;5;6]]
let rec split count l =
    seq { match take count l with
          | xs, ys -> yield xs; if ys <> [] then yield! split count ys }

let vec3Seq l = split 3 l |> Seq.map (fun [x;y;z] -> Vector3(x, y, z))
let vec2Seq l = split 2 l |> Seq.map (fun [x;y] -> Vector2(x, y))

Теперь процесс разбиения ваших списков перенесен в его собственные общие функции «взять» и «разбить», так что гораздо проще сопоставить его с желаемым типом.