Was ist der Unterschied zwischen . (Punkt) und $ (dollar-Zeichen)?

Haben Sie unterschiedliche Typen und unterschiedliche Definitionen:

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

infixr 0 $
($) :: (a -> b) -> a -> b
f $ x = f x

($) ist als Ersatz für die normale Funktion der Anwendung, aber mit einer unterschiedlichen Rangfolge zur Vermeidung von Klammern. (.) ist für die Komposition von zwei Funktionen zusammen, um eine neue Funktion.

In einigen Fällen sind Sie austauschbar, aber das ist nicht wahr im Allgemeinen. Das typische Beispiel, wo Sie ist:

f $ g $ h $ x

==>

f . g . h $ x

In anderen Worten in eine Kette von $s, alle, aber die Letzte kann ersetzt werden durch .

InformationsquelleAutor Ganesh Sittampalam

($) können Funktionen verkettet werden, ohne das hinzufügen von Runden Klammern zur Steuerung der Auswertung Reihenfolge:

Prelude> head (tail "asdf")
's'

Prelude> head $ tail "asdf"
's'

Der compose-operator (.) erstellt eine neue Funktion ohne Angabe von Argumenten:

Prelude> let second x = head $ tail x
Prelude> second "asdf"
's'

Prelude> let second = head . tail
Prelude> second "asdf"
's'

Obigen Beispiel ist wohl der Veranschaulichung dienen, aber zeigen nicht wirklich die Bequemlichkeit der Verwendung der Zusammensetzung. Hier ist eine andere Analogie:

Prelude> let third x = head $ tail $ tail x
Prelude> map third ["asdf", "qwer", "1234"]
"de3"

Wenn wir nur verwenden, Dritten mal, können wir vermeiden, benennen Sie es mit einem lambda:

Prelude> map (\x -> head $ tail $ tail x) ["asdf", "qwer", "1234"]
"de3"

Schließlich, Zusammensetzung lässt uns vermeiden, die lambda:

Prelude> map (head . tail . tail) ["asdf", "qwer", "1234"]
"de3"

InformationsquelleAutor softmechanics

Einer Anwendung, die nützlich ist, und nahm mir einige Zeit, um herauszufinden, aus der sehr kurzen Beschreibung zu erfahren, dass Sie eine haskell: Seit:

f $ x = f x

und parenthesizing der rechten Seite eines Ausdrucks mit ein infix-operator wandelt es zu einem Präfix-Funktion, die man schreiben kann ($ 3) (4+) Analog zu (++", world") "hello".

Warum würde jemand das tun? Eine Liste der Funktionen, zum Beispiel. Beide:

map (++", world") ["hello","goodbye"]`

und:

map ($ 3) [(4+),(3*)]

sind kürzer als map (\x -> x ++ ", world") ... oder map (\f -> f 3) .... Offensichtlich ist die letztere Variante wäre besser lesbar für die meisten Menschen.

InformationsquelleAutor Christoph

Eine großartige Möglichkeit, zu lernen, mehr über alles (jede Funktion) ist daran zu erinnern, dass alles eine Funktion! Das Allgemeine mantra hilft, aber in bestimmten Fällen, wie Betreiber, hilft es, sich daran zu erinnern, diesem kleinen trick:

:t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

und

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

Denken Sie nur daran, :t liberal, und wickeln Sie den Betreiber in ()!

InformationsquelleAutor lol

Haskell: Unterschied zwischen . (dot) und der $ (dollar-Zeichen)

Was ist der Unterschied zwischen der dot (.) und die dollar-Zeichen ($)?. Wie ich es verstehe, sind Sie sowohl syntaktische Zucker für nicht benötigen, Klammern zu verwenden.

Sind Sie nicht syntaktische Zucker für nicht benötigen, Klammern zu verwenden - Sie sind Funktionen - infix, so können wir Sie nennen-Betreiber.

Komponieren, (.), und wenn es zu benutzen.

(.) ist die compose-Funktion. So

result = (f . g) x

ist der gleiche wie der Aufbau einer Funktion übergibt das Ergebnis seines Arguments übergeben g auf f.

h = \x -> f (g x)
result = h x

Verwenden (.) wenn Sie nicht über die Argumente übergeben, um die Funktionen, die Sie wollen zu Komponieren.

Recht assoziativen gelten, ($), und wenn es zu benutzen

($) ist rechts-assoziativ anwenden-Funktion mit geringer Bindung Vorrang. So ist es lediglich berechnet die Dinge, die sich rechts von der ersten. So,

result = f $ g x

ist die gleiche wie diese, prozedural (welche Fragen, da Haskell ausgewertet wird träge, wird es anfangen zu bewerten f zuerst):

h = f
g_x = g x
result = h g_x

oder prägnanter:

result = f (g x)

Verwenden ($) wenn man alle Variablen zu beurteilen, bevor Sie das vorhergehende Funktion zur Folge haben.

Sehen wir dies durch das Lesen der Quelle für jede Funktion.

Lesen Quelle

Hier ist die Quelle für (.):

-- | Function composition.
{ -# INLINE (.) #- }
-- Make sure it has TWO args only on the left, so that it inlines
-- when applied to two functions, even if there is no final argument
(.)    :: (b -> c) -> (a -> b) -> a -> c
(.) f g = \x -> f (g x)

Und hier ist die Quelle für ($):

-- | Application operator.  This operator is redundant, since ordinary
-- application @(f x)@ means the same as @(f '$' x)@. However, '$' has
-- low, right-associative binding precedence, so it sometimes allows
-- parentheses to be omitted; for example:
--
-- >     f $ g $ h x  =  f (g (h x))
--
-- It is also useful in higher-order situations, such as @'map' ('$' 0) xs@,
-- or @'Data.List.zipWith' ('$') fs xs@.
{ -# INLINE ($) #- }
($)                     :: (a -> b) -> a -> b
f $ x                   =  f x

Abschluss

Nutzen Zusammensetzung, wenn Sie nicht brauchen, um sofort die Funktion ausgewertet werden soll. Vielleicht möchten Sie übergeben der Funktion, die Ergebnisse aus der Zusammensetzung zu einer anderen Funktion.

Anwendung verwenden, wenn Sie liefert alle Argumente, die für eine vollständige Beurteilung.

Also für unser Beispiel wäre es semantisch vorzuziehen, zu tun,

f $ g x

wenn wir x (oder vielmehr g's Argumente), und tun:

f . g

wenn wir nicht.

InformationsquelleAutor Aaron Hall

Alle anderen Antworten sind ziemlich gut. Aber es ist ein wichtiger usability-Details darüber, wie ghc behandelt $,, dass der ghc-Typ-checker ermöglicht instatiarion mit höherem Rang/quantifiziert Arten. Wenn Sie Aussehen bei das Art von $ id finden Sie zum Beispiel it ' s gonna take eine Funktion, deren argument selbst ist eine polymorphe Funktion. Kleine Dinge wie, dass sind nicht die gleiche Flexibilität mit einem äquivalent verärgert Betreiber. (Eigentlich wundert mich, wenn $! verdient die gleiche Behandlung oder nicht )

InformationsquelleAutor Carter Tazio Schonwald