Différence entre plier et réduire?

Essayer d'apprendre F # mais être confus en essayant de faire la distinction entre plier et réduire . Fold semble faire la même chose mais prend un paramètre supplémentaire. Existe-t-il une raison légitime pour que ces deux fonctions existent ou sont-elles là pour accueillir des personnes d'horizons différents? (Par exemple: chaîne et chaîne en C #)

Voici un extrait de code copié à partir de l'exemple:

let sumAList list =
    List.reduce (fun acc elem -> acc + elem) list

let sumAFoldingList list =
    List.fold (fun acc elem -> acc + elem) 0 list

printfn "Are these two the same? %A " 
             (sumAList [2; 4; 10] = sumAFoldingList [2; 4; 10])

Foldprend une valeur initiale explicite pour l'accumulateur tandis que reduceutilise le premier élément de la liste d'entrée comme valeur initiale de l'accumulateur.

Cela signifie que l'accumulateur et donc le type de résultat doivent correspondre au type d'élément de liste, alors qu'ils peuvent différer foldcar l'accumulateur est fourni séparément. Cela se reflète dans les types:

List.fold : ('State -> 'T -> 'State) -> 'State -> 'T list -> 'State
List.reduce : ('T -> 'T -> 'T) -> 'T list -> 'T

De plus, reducelance une exception sur une liste d'entrée vide.

En plus de ce que Lee a dit, vous pouvez définir reduceen termes de fold, mais pas (facilement) l'inverse:

let reduce f list = 
  match list with
  | head::tail -> List.fold f head tail
  | [] -> failwith "The list was empty!"

Le fait que cela foldprenne une valeur initiale explicite pour l'accumulateur signifie également que le résultat de la foldfonction peut avoir un type différent du type de valeurs dans la liste. Par exemple, vous pouvez utiliser un accumulateur de type stringpour concaténer tous les nombres d'une liste en une représentation textuelle:

[1 .. 10] |> List.fold (fun str n -> str + "," + (string n)) ""

Lors de l'utilisation reduce, le type d'accumulateur est le même que le type de valeurs dans la liste - cela signifie que si vous avez une liste de nombres, le résultat devra être un nombre. Pour implémenter l'exemple précédent, vous devez d'abord convertir les nombres string, puis les accumuler:

[1 .. 10] |> List.map string
          |> List.reduce (fun s1 s2 -> s1 + "," + s2)

Regardons leurs signatures:

> List.reduce;;
val it : (('a -> 'a -> 'a) -> 'a list -> 'a) = <fun:clo@1>
> List.fold;;
val it : (('a -> 'b -> 'a) -> 'a -> 'b list -> 'a) = <fun:clo@2-1>

Il existe des différences importantes:

• Bien que cela ne reducefonctionne que sur un seul type d'éléments, les éléments d'accumulateur et de liste dans foldpeuvent être de types différents.

• Avec reduce, vous appliquez une fonction fà chaque élément de liste en commençant par le premier:

  f (... (f i0 i1) i2 ...) iN.

  Avec fold, vous appliquez à fpartir de l'accumulateur s:

  f (... (f s i0) i1 ...) iN.

Par conséquent, il en reducerésulte une ArgumentExceptionliste vide. De plus, foldest plus générique que reduce; vous pouvez utiliser foldpour mettre en œuvre reducefacilement.

Dans certains cas, l'utilisation reduceest plus succincte:

// Return the last element in the list
let last xs = List.reduce (fun _ x -> x) xs

ou plus pratique s'il n'y a pas d'accumulateur raisonnable:

// Intersect a list of sets altogether
let intersectMany xss = List.reduce (fun acc xs -> Set.intersect acc xs) xss

En général, foldest plus puissant avec un accumulateur de type arbitraire:

// Reverse a list using an empty list as the accumulator
let rev xs = List.fold (fun acc x -> x::acc) [] xs

foldest une fonction beaucoup plus précieuse que reduce. Vous pouvez définir de nombreuses fonctions différentes en termes de fold.

reduceest juste un sous-ensemble de fold.

Définition du pli:

let rec fold f v xs =
    match xs with 
    | [] -> v
    | (x::xs) -> f (x) (fold f v xs )

Exemples de fonctions définies en termes de pli:

let sum xs = fold (fun x y -> x + y) 0 xs

let product xs = fold (fun x y -> x * y) 1 xs

let length xs = fold (fun _ y -> 1 + y) 0 xs

let all p xs = fold (fun x y -> (p x) && y) true xs

let reverse xs = fold (fun x y -> y @ [x]) [] xs

let map f xs = fold (fun x y -> f x :: y) [] xs

let append xs ys = fold (fun x y -> x :: y) [] [xs;ys]

let any p xs = fold (fun x y -> (p x) || y) false xs 

let filter p xs = 
    let func x y =
        match (p x) with
        | true -> x::y
        | _ -> y
    fold func [] xs