Übersetzen Merge-Funktion von Haskell zu F #

Question

Ich habe diese Funktion in Haskell, die ich in F # mit nativer Syntax und nicht die Array-Funktionen wie map2 codieren möchte.

Haskell:

merge [] ys = ys 
merge (x:xs) ys = x:merge ys xs 

Dieser Code führt zwei Listen Index weise wie folgt aus:

INPUT: [1,2,3,4,5] [11,12,13,14] 
OUTPUT: [1,11,2,12,3,13,4,14,5] 

ich es in F # versuchte dabei und bekam dies aber natürlich nicht kompiliert:

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

Ich habe wirklich Mühe, mit zwei Arrays im Mustervergleich zu arbeiten, danke für jeden helfen Sie können geben.

Answer 1

Die Haskell-Funktion stimmt nicht mit den beiden Parametern überein. Es passt nur auf den ersten Parameter und übernimmt den zweiten Parameter unverändert.

In F # können Sie auf dem ersten Argument übereinstimmt, und eine Funktion zurück, die das zweite Argument verarbeitet:

let rec mux = function 
    | [] -> (function ys -> ys) 
    | x::xt -> (function ys -> x :: mux ys xt) 

Aber ich finde es klarer (und ich denke, dass es effizienter ist - zumindest ist es in OCaml) sofort in allen anderen Argumenten zu nehmen, analysieren dann das Argument, Sie müssen diskriminieren auf:

let rec mux xs ys = 
    match xs with 
    | [] -> ys 
    | x::xt -> x :: mux ys xt 

Wenn Sie auf beiden Variablen passen wollte, würde es mehrere Lösungen sein. Sie könnten Nest function Konstrukte:

let rec mux = function 
    | [] -> (function [] -> … | y::yt -> …) 
    | x::xt -> (function [] -> … | y::yt -> …) 

Aber auch hier ziehe ich Verschachtelung match Konstrukte:

let rec mux xs ys = 
    match xs with 
    | [] -> (match ys with 
      | [] -> … 
      | y::yt -> …) 
    | x::xt -> (match ys with 
      | [] -> … 
      | y::yt -> …) 

Alternativ ist es oft schöner auf dem Paar von Eingängen zu entsprechen; Es hängt davon ab, wie stark die beiden Eingänge gekoppelt sind.

let rec mux xs ys = 
    match xs, ys with 
    | [], [] -> … 
    | [], y::yt -> … 
    | x::xt, [] -> … 
    | x::xt, y::yt -> …