Operator kropki w Haskell: Potrzebujesz więcej wyjaśnień

sum jest funkcją w preludium Haskella, a nie argumentem sumEuler. Posiada Typ

Num a => [a] -> a

Operator składu funkcji . mA typ

(b -> c) -> (a -> b) -> a -> c

Więc mamy

sum                        :: Num a => [a] -> a
map                        :: (a -> b) -> [a] -> [b]
euler                      :: Int -> Int
mkList                     :: Int -> [Int]
(map euler)                :: [Int] -> [Int]
(map euler) . mkList       :: Int -> [Int]
sum . (map euler) . mkList :: Int -> Int

Zauważ, że Int jest instancją Num.

The . operator komponuje funkcje. Na przykład,

a . b

Gdzie a i b są funkcjami jest nową funkcją , która uruchamia b na swoich argumentach, a następnie a na tych wynikach. Twój kod

sumEuler = sum . (map euler) . mkList

Jest dokładnie takie samo jak:

sumEuler myArgument = sum (map euler (mkList myArgument))

Ale mam nadzieję, że łatwiejsze do odczytania. Powodem, dla którego istnieją pareny wokół mapy Eulera jest to, że wyjaśnia to, że złożone są 3 Funkcje: suma, Mapa euler i mkList - Mapa Eulera jest funkcją pojedynczą.

The . operator jest używany do składu funkcji. Podobnie jak matematyka, jeśli masz funkcje f (x) i g (x) f . g staje się f (g (x)).

Map jest wbudowaną funkcją, która stosuje funkcję do listy. Poprzez umieszczenie funkcji w nawiasach funkcja jest traktowana jako argument. Termin na to to currying . Powinieneś to sprawdzić.

To, co robi, to to, że przyjmuje funkcję z dwoma argumentami, stosuje argument Eulera. / align = "left" / a rezultatem jest nowa funkcja, która przyjmuje tylko jeden argument.

Sum . (Mapa Eulera). mkList jest w zasadzie fantazyjnym sposobem na złożenie tego wszystkiego razem. Muszę powiedzieć, że mój Haskell jest trochę zardzewiały, ale może uda Ci się złożyć tę ostatnią funkcję samodzielnie?

Operator kropki stosuje funkcję po lewej (sum) do wyjścia funkcji po prawej. W Twoim przypadku łączysz ze sobą kilka funkcji-przekazujesz wynik mkList do (map euler), a następnie przekazujesz wynik tego do sum. ta strona ma dobre wprowadzenie do kilku pojęć.

Operator kropki w Haskell

Próbuję zrozumieć, co operator kropki robi w tym kodzie Haskella:

sumEuler = sum . (map euler) . mkList

Krótka odpowiedź

Odpowiednik kodu bez kropek, czyli po prostu

sumEuler = \x -> sum ((map euler) (mkList x))

Lub bez lambdy

sumEuler x = sum ((map euler) (mkList x))

Ponieważ kropka (.) wskazuje skład funkcji.

Dłuższa odpowiedź

Najpierw uprośćmy częściowe zastosowanie euler do map:

map_euler = map euler
sumEuler = sum . map_euler . mkList

From the source:

(.)    :: (b -> c) -> (a -> b) -> a -> c
(.) f g = \x -> f (g x)

Zatem (.) jest operatorem składowym .

Skomponuj

W matematyce możemy zapisać skład funkcji, f (x) i g (x), czyli f(g(x)), jako

(f ∘ g) (x)

Które można odczytać jako "F złożone z g".

Więc w Haskell, f ∘ g, lub F złożone z g, można zapisać:

f . g

Skład jest asocjacyjny, co oznacza, że f (g (h (x))), zapisany operatorem kompozycji, może bez niejednoznaczności pominąć nawiasy.

Czyli z (f ∘ g) ∘ H jest równoważny do F ∘ (g ∘ h), możemy po prostu napisać F ∘ g ∘ s.

Krąży wstecz

Wracając do naszego wcześniejszego uproszczenia, to:

sumEuler = sum . map_euler . mkList

Oznacza po prostu, że sumEuler jest nieujemnym składem tych funkcji:

sumEuler = \x -> sum (map_euler (mkList x))