Я хочу слить 2 списка в F # чисто функциональным способом. Мне сложно понять синтаксис.
Скажем, у меня есть кортеж ([5;3;8],[2;9;4])
Когда я вызываю функцию, она должна возвращать [5;2;3;9;8;4]
Вот почему я до сих пор, что неправильно, я уверен. Если бы кто-то мог объяснить это простым способом, я был бы благодарен.
let rec interleave (xs,ys) = function
|([], ys) -> ys
|(x::xs, y::ys) -> x :: y:: interleave (xs,ys)
Ваша функция почти правильная. let f = function является сокращением для let f x = match x with, поэтому вам не нужны явные аргументы. Кроме того, ваш алгоритм нуждается в некоторой настройке.
let rec interleave = function //same as: let rec interleave (xs, ys) = match xs, ys with
|([], ys) -> ys
|(xs, []) -> xs
|(x::xs, y::ys) -> x :: y :: interleave (xs,ys)
interleave ([5;3;8],[2;9;4]) //output: [5; 2; 3; 9; 8; 4]
Важным моментом является то, что функция неверна. Он терпит неудачу с входом ([1;2;3], []), так как вы пропустили случай (xs, []) в сопоставлении с образцом. Более того, аргументы лучше в карри, чтобы их было проще использовать с частичным приложением. Вот исправленная версия:
let rec interleave xs ys =
match xs, ys with
| [], ys -> ys
| xs, [] -> xs
| x::xs', y::ys' -> x::y::interleave xs' ys'
Вы можете видеть, что функция не является хвостовой рекурсивной, так как она использует конструктор cons (::) дважды после возврата рекурсивного вызова. Один интересный способ сделать его хвостовым рекурсивным - использовать выражение последовательности:
let interleave xs ys =
let rec loop xs ys =
seq {
match xs, ys with
| [], ys -> yield! ys
| xs, [] -> yield! xs
| x::xs', y::ys' ->
yield x
yield y
yield! loop xs' ys'
}
loop xs ys |> List.ofSeq
Вы можете использовать эту возможность, чтобы определить более общую функцию более высокого порядка - zipWith, а затем использовать interleave, используя ее.
let rec zipWith f xlist ylist =
match f, xlist, ylist with
| f, (x :: xs), (y :: ys) -> f x y :: zipWith f xs ys
| _, _, _ -> []
let interleave xs ys = zipWith (fun a b -> [a; b]) xs ys |> List.concat
Edit:
Как указано ниже, F # уже имеет zipWith под именем List.map2. Поэтому вы можете переписать interleave следующим образом:
let interleave xs ys = List.map2 (fun a b -> [a; b]) xs ys |> List.concat
Из OP не понятно, что должно произойти, если списки имеют разную длину, но здесь общая, хвосто-рекурсивная реализация, которая полностью потребляет оба списка:
// 'a list -> 'a list -> 'a list
let interleave xs ys =
let rec imp xs ys acc =
match xs, ys with
| [], [] -> acc
| x::xs, [] -> imp xs [] (x::acc)
| [], y::ys -> imp [] ys (y::acc)
| x::xs, y::ys -> imp xs ys (y::x::acc)
imp xs ys [] |> List.rev
Примеры:
> interleave [5;3;8] [2;9;4];;
val it : int list = [5; 2; 3; 9; 8; 4]
> interleave [] [1..3];;
val it : int list = [1; 2; 3]
> interleave [1..3] [42];;
val it : int list = [1; 42; 2; 3]
> interleave [1..3] [42;1337];;
val it : int list = [1; 42; 2; 1337; 3]
> interleave [42; 1337] [1..3];;
val it : int list = [42; 1; 1337; 2; 3]
Начиная с F # 4.5 (я думаю), предполагая, что вы хотите продолжать получать элементы из более длинной последовательности, когда короткая исчерпана, вы можете просто сделать:
let interleave = Seq.transpose >> Seq.concat >> Seq.toList
> interleave [ [5;3;8]; [2;9;4] ];;
val it : int list = [5; 2; 3; 9; 8; 4]
> interleave [ [1;2;3]; [4;5]; [6;7;8;9] ];; // also works for any number of lists
val it : int list = [1; 4; 6; 2; 5; 7; 3; 8; 9]
(Обратите внимание, List.transpose выбрасывает List.transpose если последовательности имеют разную длину, а Seq.transpose - нет, поэтому вам нужно использовать последнее.)