Verständnis Haskell Typ-Signaturen

Ich bin in den Prozess des Lehrens selbst Haskell und ich wunderte mich über die folgende Signaturen:

Prelude> :t ($)
($) :: (a -> b) -> a -> b
Prelude>

Wie soll ich das verstehen (kein Wortspiel beabsichtigt), dass?

Semi-ähnliches Ergebnis ist auch erweist sich als rätselhaft:

Prelude> :t map
map :: (a -> b) -> [a] -> [b]
Prelude>

InformationsquelleAutor CaitlinG | 2014-03-11

30

Beginnen werde ich mit map. Die map Funktion wendet eine operation auf jedes element einer Liste. Wenn ich
```
add3 :: Int -> Int
add3 x = x + 3
```
Dann könnte ich diese anwenden, um eine ganze Liste von Ints mit map:
```
> map add3 [1, 2, 3, 4]
[4, 5, 6, 7]
```
So, wenn man sich die Typ-Signatur
```
map :: (a -> b) -> [a] -> [b]
```
Du wirst sehen, dass das erste argument ist (a -> b), die nur eine Funktion, die einen a und gibt einen b. Das zweite argument ist [a], die eine Liste von Werten des Typs a, und der Rückgabetyp [b] eine Liste von Werten des Typs b. Also im Klartext, die map - Funktion wendet eine Funktion auf jedes element einer Liste von Werten, und gibt dann die Werte als eine Liste.

Dies ist, was macht map eine höherer Ordnung Funktion, es nimmt eine Funktion als argument und macht Sachen mit ihm. Eine andere Weise, darauf zu schauen map ist, fügen Sie einige Klammern geben Sie die Signatur, um es
```
map :: (a -> b) -> ([a] -> [b])
```
So können Sie auch denken, es als eine Funktion transformiert eine Funktion von a zu b in eine Funktion aus [a] zu [b].

Die Funktion ($) hat der Typ
```
($) :: (a -> b) -> a -> b
```
Verwendet und ist wie
```
> add3 $ 1 + 1
5
```
Alle es tut, ist, nehmen Sie, was der Recht, in diesem Fall 1 + 1 und übergibt Sie an die Funktion auf der Links, hier add3. Warum ist das wichtig? Es hat eine handliche Festigkeit, oder Rangfolge, die es macht, entspricht
```
> add3 (1 + 1)
```
Also auch immer um das Recht bekommt, im wesentlichen eingewickelt in Klammern vor der übergabe an den linken. Dies macht es nützlich für die Verkettung mehrere Funktionen zusammen:
```
> add3 $ add3 $ add3 $ add3 $ 1 + 1
```
ist schöner als
```
> add3 (add3 (add3 (add3 (1 + 1))))
```
weil Sie nicht haben, zu schließen Klammern.
- gibt es praktische Unterschiede zwischen add3 $ add3 $ add3 $ add3 $ 1 + 1 und add3 . add3 . add3 . add3 $ 1 + 1?
InformationsquelleAutor bheklilr
7

Naja, wie schon gesagt, $ leicht verstanden werden können, wenn Sie einfach vergessen, über currying und sehen, wie es, sagen wir, in C++
```
template<typename A, typename B>
B dollar(std::function<B(A)> f, A x) {
  return f(x);
}
```
Aber tatsächlich, es gibt mehr zu diesem als nur die Anwendung einer Funktion auf einen Wert! Die offensichtliche ähnlichkeit zwischen den Signaturen der $ und map hat in der Tat eine ziemlich Tiefe der Kategorie-Theorie Bedeutung: beide sind Beispiele für die morphismus-Aktion der Funktor!

In der Kategorie Hask, mit denen wir arbeiten die ganze Zeit, Objekte Typen. (Das ist ein bisschen confusionsome, aber keine Sorge). Die morphismen sind die Funktionen.

Den meisten gut bekannt (endo-)funktoren sind die, die eine Instanz von die namensgebende Art Klasse. Aber eigentlich, mathematisch gesehen, ein Funktor ist nur etwas, dass die Karten beide Objekte auf Objekte und morphismen auf morphismen¹. map (Wortspiel beabsichtigt, nehme ich an!) ein Beispiel: es nimmt ein Objekt (also Typ) A und ordnet Sie zu einer Art [A]. Und für zwei Arten A und B dauert es einen morphismus (d.h. Funktion) A -> B, und ordnet Sie der entsprechenden Liste-Funktion von Typ [A] -> [B].

Dies ist nur ein spezieller Fall der functor-Klasse-Signatur operation:
```
fmap :: Functor f   =>   (a->b) -> (f a->f b)
```
Mathematik erfordert nicht diese fmap zu haben, einen Namen, obwohl. Und so kann auch die Identität Funktor, die einfach ordnet jedem Typ selbst. Und jeden morphismus auf sich:
```
($) :: (a->b) -> (a->b)
```
"Identität" existiert offensichtlich mehr im Allgemeinen, Sie können auch die map-Werte eines beliebigen Typs zu sich selbst.
```
id :: a -> a
id x = x
```
Und sicher genug, eine mögliche Implementierung ist dann
```
($) = id
```
¹Geist, nicht alles, dass die Karten-Objekte und-morphismen ist ein Funktor... es muss genügen Funktor Gesetze.
- Sehr interessant. Danke!
InformationsquelleAutor leftaroundabout
6

($) ist nur Funktion der Anwendung. Es wird eine Funktion des Typs a->b ein argument vom Typ a werden, gilt die Funktion und gibt einen Wert vom Typ b.

map ist ein wunderbares Beispiel dafür, wie das Lesen einer Funktion geben Sie die Signatur hilft es zu verstehen. map's erste argument ist eine Funktion, die nimmt a und zurück b werden soll, das zweite argument ist eine Liste von Typ [a].
So map wendet eine Funktion vom Typ a->b um eine Liste der a Werte. Und der Ergebnis-Typ ist in der Tat der Typ [b] - eine Liste von b Werte!

(a->b)->[a]->[b] kann interpretiert werden als "Akzeptiert eine Funktion und eine Liste und gibt eine andere Liste", und auch als "Akzeptiert eine Funktion vom Typ a->b und gibt eine weitere Funktion des Typs [a]->[b]".
Wenn man es auf diese Weise map "upgrade" f (der Begriff "Aufzug" wird oft in diesem Zusammenhang) zu arbeiten, die auf Listen: wenn double ist eine Funktion, Doppel-integer, dann map double ist eine Funktion, Doppel-jede ganze Zahl in einer Liste.
- Ist die Tatsache, dass die a -> b in Klammern eingeschlossen ist maßgeblich? Es wird angezeigt, um anzugeben Vorrang.
- Du hast Recht! Der Pfeil ist rechts-assoziativ, so ist a->b->c ist gleich a-> b->c) - das ist eine Funktion, die ein argument vom Typ a und gibt eine weitere Funktion des Typs b->c. Wenn Sie möchten, eine Funktion als ein argument, müssen Sie die Klammern.
- Ja, es ist signifikant. Die Rangfolge ist in der Regel von rechts nach Links, so dass f :: a -> b -> c und f :: a -> (b -> c) gleichwertig sind. Diese ist wirklich, weil Haskell-Funktionen werden teilweise angewendet (anwenden f einige a gibt eine Funktion von b nach c). Wenn g :: (a -> b) -> c wird stattdessen verwendet, es ist speziell Kennzeichnen, Sie müssen eine Funktion g ist, und dass Sie nicht nur teilweise gelten.g) die
- Vielen Dank für die Hilfe allen. In dem bemühen, sich zu verfestigen, mein Verständnis, wenn jemand schrieb: map (*2) [1..50] untersucht und die Typ-Signatur für Karte, (a -> b) entspricht der map-Funktion und der (*2) jeweils? Die [a] ist die Liste von 1 bis 50, und die [b] ist das Resultat? Es scheint, als ob wir zwingen die Links-Assoziativität mit den Klammern. (a -> b) gibt eine Funktion, die nimmt eine Liste vom Typ 'a' und gibt eine Liste vom Typ 'b'? Wäre das eine korrekte interpretation?
- (a -> b) entspricht (*2), da a und b sind Int in unserem Beispiel, und (*2)::Int -> Int. (a -> b) ist eine Funktion, die akzeptiert einen einzelnen Wert vom Typ a und gibt einen einzelnen Wert zurück vom Typ b. Aber map (*2), aufgrund der teilweisen Anwendung, ist der Typ [a]->[b] - akzeptiert eine Liste von a aus und liefert eine Liste von b.
- Hinzugefügt ein paar mehr Infos zu der Antwort.
InformationsquelleAutor Benesh

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.