Unterschied zwischen falten und reduzieren?

Der Versuch, F # zu lernen, war jedoch verwirrt, als er versuchte, zwischen Falten und Reduzieren zu unterscheiden . Fold scheint dasselbe zu tun , benötigt jedoch einen zusätzlichen Parameter. Gibt es einen legitimen Grund für die Existenz dieser beiden Funktionen oder sind sie dazu da, Menschen mit unterschiedlichem Hintergrund aufzunehmen? (ZB: String und String in C #)

Hier ist ein Code-Snippet, das aus dem Beispiel kopiert wurde:

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])

FoldNimmt einen expliziten Anfangswert für den Akkumulator, während reducedas erste Element der Eingabeliste als anfänglicher Akkumulatorwert verwendet wird.

Dies bedeutet, dass der Akkumulator und damit der Ergebnistyp mit dem Listenelementtyp übereinstimmen müssen, während sie sich unterscheiden können, foldda der Akkumulator separat bereitgestellt wird. Dies spiegelt sich in den Typen wider:

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

Darüber hinaus reducelöst eine Ausnahme auf eine leere Eingabeliste.

Zusätzlich zu dem, was Lee sagte, können Sie festlegen , reducein Bezug auf fold, aber nicht (leicht) umgekehrt:

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

Die Tatsache, dass foldein expliziter Anfangswert für den Akkumulator verwendet wird, bedeutet auch, dass das Ergebnis der foldFunktion einen anderen Typ haben kann als der Wertetyp in der Liste. Beispielsweise können Sie einen Akkumulator vom Typ verwenden, stringum alle Zahlen in einer Liste zu einer Textdarstellung zu verketten:

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

Bei Verwendung entspricht reduceder Akkumulatortyp dem Wertetyp in der Liste. Wenn Sie also eine Liste mit Zahlen haben, muss das Ergebnis eine Zahl sein. Um das vorherige Beispiel zu implementieren, müssen Sie stringzuerst die Zahlen in konvertieren und dann akkumulieren:

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

Schauen wir uns ihre Unterschriften an:

> 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>

Es gibt einige wichtige Unterschiede:

• Während nur reducefür einen foldElementtyp gearbeitet wird , können sich der Akkumulator und die Listenelemente in unterschiedlichen Typen befinden.

• Mit reducewenden Sie eine Funktion fauf jedes Listenelement ab dem ersten an:

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

  Mit foldbewerben Sie sich fab dem Akku s:

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

Daher wird reduceeine ArgumentExceptionleere Liste angezeigt. Darüber hinaus foldist generischer als reduce; Sie können verwenden fold, um reduceeinfach zu implementieren .

In einigen Fällen ist die Verwendung reduceprägnanter:

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

oder bequemer, wenn es keinen vernünftigen Akku gibt:

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

Im Allgemeinen foldist mit einem Akkumulator eines beliebigen Typs leistungsfähiger:

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

foldist eine viel wertvollere Funktion als reduce. Sie können viele verschiedene Funktionen in Bezug auf definieren fold.

reduceist nur eine Teilmenge von fold.

Definition der Falte:

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

Beispiele für Funktionen, die in Bezug auf Fold definiert sind:

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