Wo kommen Thesen Werte von in dieser Haskell Funktion kommen?

Question

Lassen Sie uns sagen, ich habe die folgende Funktion:

sumAll :: [(Int,Int)] -> Int
sumAll xs = foldr (+) 0 (map f xs)
  where f (x,y) = x+y

Das Ergebnis sumAll [(1,1),(2,2),(3,3)] wird 12 werden.

Was ich nicht verstehe, ist, wo die (x,y) Werte herkommen. Nun, ich weiß, sie kommen aus der xs variabel, aber ich verstehe nicht, wie. Ich meine, den Code zu tun oben direkt, ohne das Stichwort, wäre es so etwas wie diese:

sumAll xs = foldr (+) 0 (map (\(x,y) -> x+y) xs)

Und ich kann nicht in dem Top-Code verstehen, wie funktionieren die f Variable und (x,y) Variablen stellen den (\(x,y) -> x+y) Lambda-Ausdruck.

Answer 1

In Haskell, sind Funktionen der ersten Klasse-Datentypen.

Das heißt, Sie Funktionen um wie andere Arten von Daten wie ganze Zahlen und Strings passieren können.

In Ihrem Code über dir 'f' deklarieren eine Funktion zu sein, die in einem argumenta (ein Tupel von zwei Werten (x, y)) und gibt das Ergebnis von (x + y).

nimmt

foldr ist eine andere Funktion, die in 3 Argumente annimmt, eine binäre Funktion (in diesem Fall +) einen Startwert (0) und eine Reihe von Werten Iterator über.

Kurz gesagt 'wo f (x, y) = x + y' ist nur eine Abkürzung für scoped

sumAll :: [(Int,Int)] -> Int
sumAll xs = foldr (+) 0 (map myFunctionF xs)

myFunctionF :: (Int,Int) -> Int
myFunctionF (x,y) = x + y

Bearbeiten : Wenn Ihr nicht sicher, wie foldr funktioniert Besuche Haskell Referenz Zvon Im Folgenden ist eine beispielhafte Implementierung von foldl / Karte.

foldl :: (a -> b -> b) -> b -> [a] -> b
foldl _ x [] = x
foldl fx (y:ys) = foldl f (f y x) ys

map :: (a -> b) -> [a] -> [b]
map _ [] = []
map f (x:xs) = (f x) : (map f xs)

Answer 2

Dies wird hoffentlich helfen. Der Schlüssel ist, dass f auf die Elemente der Liste zugewiesen wird, die Paare sind.

sumAll [(1,1),(2,2),(3,3)] 
      -- definition of sumAll
    = foldr (+) 0 (map f [(1,1),(2,2),(3,3)])
      -- application of map
    = foldr (+) 0 (f (1,1) : map f [(2,2),(3,3)])
      -- application of foldr
    = 0 + foldr (+) (f (1,1)) (map f [(2,2),(3,3)])
      -- application of map
    = 0 + foldr (+) (f (1,1)) (f (2,2) : map f [(3,3)])
      -- application of foldr
    = 0 + (f (1,1) + foldr (+) (f (2,2)) (map f [(3,3)]))
      -- application of f
    = 0 + (2 + foldr (+) (f (2,2)) (map f [(3,3)]))
      -- application of map
    = 0 + (2 + foldr (+) (f (2,2)) (f (3,3) : map f []))
      -- application of foldr
    = 0 + (2 + (f (2,2) + foldr (+) (f (3,3)) (map f [])))
      -- application of f
    = 0 + (2 + (4 + foldr (+) (f (3,3)) (map f [])))
      -- application of map
    = 0 + (2 + (4 + foldr (+) (f (3,3)) []))
      -- application of foldr
    = 0 + (2 + (4 + f (3,3)))
      -- application of f
    = 0 + (2 + (4 + 6))
    = 0 + (2 + 10)
    = 0 + 12
    = 12

Answer 3

keine Antwort, aber ich dachte ich, dass Ihre Funktion f hinweisen sollte:

f (x, y) = x + y

kann ausgedrückt werden

f = uncurry (+)