przepisywanie kodu za pomocą dopasowywania do wzorca F #

Question

Witam Jestem bardzo nowy w F # i programowaniu. Próbuję się teraz tego nauczyć i zapisałem się na kurs, ale wciąż nie wydaje mi się, że to rozumiem. pls pomoc. Im próbuje przepisać poniższy kod:

let rec msort xs = 
    let sz = List.length xs 
    if sz < 2 then xs 
    else let n = sz/2 
     let ys = xs. [0..n-1] 
     let zs = xs.[n..sz-1] 
     in merge (msort ys) (msort zs) 

//************ Utility-funktion merge 

let rec merge xs ys = if List.isEmpty xs then ys else if 
List.isEmpty ys then xs else let x = List.head xs 
     let y = List.head ys 
     let xs = List.tail xs 
     let ys = List.tail ys 
     in if x < y then x :: merge xs (y::ys) 
       else y :: merge (x::xs) ys </i> 

Moje rozwiązanie - co nie jest praca:

let rec msort xs = 
    let sz = List.length xs 
    match sz with 
    | sz < 2 -> xs 
    |_ -> n = sz/2 
      let ys = xs. [0..n-1] 
      let zs = xs.[n..sz-1] 
      in merge (msort ys) (msort zs)  


//************ Utility-funktinen merge 

let rec merge xs ys = match xs with |[] -> [ys] 
    match ys with 
     |[] -> [xs] |_ -> 
     let x = List.head xs 
     let y = List.head ys 
     let xs = List.tail xs 
     let ys = List.tail ys if x < y then x :: merge xs (y::ys) 
            |_ -> 
             y :: merge (x::xs) y 

Answer 1

Zauważ że można dopasować w ciągu dwóch wartości pisząc je w krotce i zamiast pozwolić wiążące listy głowa i ogon można użyć dopasowania do wzoru na "kształcie" listy bezpośrednio w strażnikach, chociaż fakt, że ta sama nazwa jest używana na całej liście, a później na ogonie, jest trochę niefortunny, ponieważ może prowadzić do zamieszania, ale działa dobrze, ponieważ F # zaciemnia wartości:

let rec merge xs ys = 
    match (xs, ys) with 
    | [], _ -> ys 
    | _, [] -> xs 
    | x::xs, y::ys -> 
     if x < y then x :: merge xs (y::ys) 
     else y :: merge (x::xs) ys 

let rec msort xs = 
    let sz = List.length xs 
    match sz with 
    | sz when sz < 2 -> xs 
    |_ -> 
     let n = sz/2 
     let ys = xs. [0..n-1] 
     let zs = xs.[n..sz-1] 
     merge (msort ys) (msort zs) 

Brakowało Ci słowa kluczowego when w warunkach ochrony. Naprawiłem również drobne szczegóły w oryginalnym kodzie.