In F # ist die Verwendung des Pipe-Forward-Operators |>ziemlich häufig. In Haskell habe ich jedoch nur die Funktionszusammensetzung gesehen (.), die verwendet wurde. Ich verstehe, dass sie verwandt sind , aber gibt es einen sprachlichen Grund, warum Pipe-Forward in Haskell nicht verwendet wird, oder ist es etwas anderes?

Ich bin ein wenig spekulativ ...

Kultur : Ich denke, |>ist ein wichtiger Operator in der F # "Kultur", und vielleicht ähnlich mit .für Haskell. F # hat einen Funktionskompositionsoperator, <<aber ich denke, die F # -Community verwendet tendenziell weniger punktefreien Stil als die Haskell-Community.

Sprachunterschiede : Ich weiß nicht genug über beide Sprachen, um sie zu vergleichen, aber vielleicht sind die Regeln für die Verallgemeinerung von Let-Bindungen ausreichend unterschiedlich, um dies zu beeinflussen. Zum Beispiel weiß ich in F # manchmal schreiben

let f = exp

wird nicht kompiliert und Sie benötigen eine explizite eta-Konvertierung:

let f x = (exp) x   // or x |> exp

um es kompilieren zu lassen. Dies lenkt die Menschen auch vom punktfreien / kompositorischen Stil weg und zum Pipelining-Stil. Außerdem erfordert die Inferenz vom Typ F # manchmal ein Pipelining, sodass links ein bekannter Typ angezeigt wird (siehe hier ).

(Ich persönlich finde den punktefreien Stil unlesbar, aber ich nehme an, dass jedes neue / andere Ding unlesbar erscheint, bis Sie sich daran gewöhnt haben.)

Ich denke, beide sind in beiden Sprachen potenziell lebensfähig, und Geschichte / Kultur / Unfall können definieren, warum sich jede Gemeinde bei einem anderen "Attraktor" niedergelassen hat.

In F # (|>)ist wegen der Links-Rechts-Typprüfung wichtig. Beispielsweise:

List.map (fun x -> x.Value) xs

Im Allgemeinen wird der Typcheck nicht überprüft, da selbst wenn der Typ von xsbekannt ist, der Typ des Arguments xfür das Lambda zum Zeitpunkt des Typecheckers nicht bekannt ist und daher nicht weiß, wie es aufgelöst werden soll x.Value.

Im Gegensatz

xs |> List.map (fun x -> x.Value)

wird gut funktionieren, weil die Art von xswird dazu führen, dass die Art xbekannt ist.

Die Typüberprüfung von links nach rechts ist aufgrund der Namensauflösung erforderlich, die bei Konstrukten wie z x.Value. Simon Peyton Jones hat einen Vorschlag geschrieben , Haskell eine ähnliche Art der Namensauflösung hinzuzufügen. Er schlägt jedoch vor, lokale Einschränkungen zu verwenden, um zu verfolgen, ob ein Typ stattdessen eine bestimmte Operation unterstützt oder nicht. In der ersten Stichprobe würde die Anforderung, xdie eine ValueEigenschaft benötigt, so lange vorgetragen, bis xssie erkannt wurde und diese Anforderung gelöst werden könnte. Dies erschwert jedoch das Typsystem.

Weitere Spekulationen, diesmal von der überwiegend Haskell-Seite ...

($)ist das Umdrehen von (|>), und seine Verwendung ist ziemlich häufig, wenn Sie keinen punktfreien Code schreiben können. Der Hauptgrund, (|>)der in Haskell nicht verwendet wird, ist, dass sein Platz bereits von eingenommen wird ($).

Aus ein wenig F # -Erfahrung heraus denke ich, dass (|>)es im F # -Code so beliebt ist, weil es der Subject.Verb(Object)Struktur von OO ähnelt . Da F # eine reibungslose Funktions- / OO-Integration anstrebt, Subject |> Verb Objectist dies ein ziemlich reibungsloser Übergang für neue Funktionsprogrammierer.

Persönlich denke ich auch gerne von links nach rechts, also benutze ich es (|>)in Haskell, aber ich glaube nicht, dass es viele andere Leute tun.

Ich denke, wir verwirren die Dinge. Haskells ( .) entspricht F # ( >>). Nicht zu verwechseln mit F # 's ( |>), das nur eine invertierte Funktionsanwendung ist und Haskells ( $) ähnelt - umgekehrt:

let (>>) f g x = g (f x)
let (|>) x f = f x

Ich glaube, Haskell-Programmierer verwenden $oft. Vielleicht nicht so oft wie F # -Programmierer |>. Auf der anderen Seite verwenden einige F # -Typen >>in lächerlichem Maße: http://blogs.msdn.com/b/ashleyf/archive/2011/04/21/programming-is-pointless.aspx

Wenn Sie F # |>in Haskell verwenden möchten, ist in Data.Function der &Operator (seit base 4.8.0.0).

Komposition von links nach rechts in Haskell

Einige Leute verwenden auch in Haskell den Stil von links nach rechts (Nachrichtenübermittlung). Siehe zum Beispiel die mps- Bibliothek zu Hackage. Ein Beispiel:

euler_1 = ( [3,6..999] ++ [5,10..999] ).unique.sum

Ich denke, dieser Stil sieht in manchen Situationen gut aus, ist aber schwieriger zu lesen (man muss die Bibliothek und alle ihre Operatoren kennen, die Neudefinition (.)ist auch störend).

In Control.Category , einem Teil des Basispakets , gibt es auch Kompositionsoperatoren von links nach rechts sowie von rechts nach links . Vergleichen >>>und <<<jeweils:

ghci> :m + Control.Category
ghci> let f = (+2) ; g = (*3) in map ($1) [f >>> g, f <<< g]
[9,5]

Es gibt einen guten Grund, manchmal die Komposition von links nach rechts zu bevorzugen: Die Bewertungsreihenfolge folgt der Lesereihenfolge.

Ich habe gesehen >>>, wie man es benutzt flip (.), und ich benutze es oft selbst, besonders für lange Ketten, die am besten von links nach rechts verstanden werden.

>>> ist eigentlich von Control.Arrow und funktioniert mit mehr als nur Funktionen.

Abgesehen von Stil und Kultur läuft dies darauf hinaus, das Sprachdesign für reinen oder unreinen Code zu optimieren.

Der |>Operator ist in F # vor allem deshalb üblich, weil er dazu beiträgt, zwei Einschränkungen zu verbergen, die bei überwiegend unreinem Code auftreten:

• Typinferenz von links nach rechts ohne strukturelle Subtypen.
• Die Wertebeschränkung.

Beachten Sie, dass die erstere Einschränkung in OCaml nicht existiert, da die Untertypisierung strukturell statt nominal ist, sodass der Strukturtyp im Verlauf der Typinferenz leicht durch Vereinheitlichung verfeinert werden kann.

Haskell geht einen anderen Kompromiss ein und konzentriert sich auf überwiegend reinen Code, bei dem diese Einschränkungen aufgehoben werden können.

Ich denke, F # 's Pipe Forward Operator ( |>) sollte vs ( & ) in haskell sein.

// pipe operator example in haskell

factorial :: (Eq a, Num a) =>  a -> a
factorial x =
  case x of
    1 -> 1
    _ -> x * factorial (x-1)

// terminal
ghic >> 5 & factorial & show

Wenn Sie den &Operator ( ) nicht mögen , können Sie ihn wie F # oder Elixir anpassen:

(|>) :: a -> (a -> b) -> b
(|>) x f = f x
infixl 1 |>

ghci>> 5 |> factorial |> show

Warum infixl 1 |>? Siehe das Dokument in Datenfunktion (&)

infixl = infix + linke Assoziativität

infixr = infix + rechte Assoziativität

(.)

( .) bedeutet Funktionszusammensetzung. Es bedeutet (fg) (x) = f (g (x)) in Mathe.

foo = negate . (*3)

// ouput -3
ghci>> foo 1
// ouput -15
ghci>> foo 5

es ist gleich

// (1)
foo x = negate (x * 3) 

oder

// (2)
foo x = negate $ x * 3 

( $) Operator ist auch in Data-Function ($) defind .

( .) wird zum Erstellen Hight Order Functionoder verwendet closure in js. Siehe Beispiel:

// (1) use lamda expression to create a Hight Order Function
ghci> map (\x -> negate (abs x)) [5,-3,-6,7,-3,2,-19,24]  
[-5,-3,-6,-7,-3,-2,-19,-24]


// (2) use . operator to create a Hight Order Function
ghci> map (negate . abs) [5,-3,-6,7,-3,2,-19,24]  
[-5,-3,-6,-7,-3,-2,-19,-24]

Wow, weniger (Code) ist besser.

Vergleiche |>und.

ghci> 5 |> factorial |> show

// equals

ghci> (show . factorial) 5 

// equals

ghci> show . factorial $ 5 

Es ist der Unterschied zwischen left —> rightund right —> left. ⊙﹏⊙ |||

Humanisierung

|>und &ist besser als.

weil

ghci> sum (replicate 5 (max 6.7 8.9))

// equals

ghci> 8.9 & max 6.7 & replicate 5 & sum

// equals

ghci> 8.9 |> max 6.7 |> replicate 5 |> sum

// equals

ghci> (sum . replicate 5 . max 6.7) 8.9

// equals

ghci> sum . replicate 5 . max 6.7 $ 8.9

Wie funktioniert man in objektorientierter Sprache?

Bitte besuchen Sie http://reactivex.io/

IT-Unterstützung :

• Java: RxJava
• JavaScript: RxJS
• C #: Rx.NET
• C # (Einheit): UniRx
• Scala: RxScala
• Clojure: RxClojure
• C ++: RxCpp
• Lua: RxLua
• Ruby: Rx.rb.
• Python: RxPY
• Los: RxGo
• Groovy: RxGroovy
• JRuby: RxJRuby
• Kotlin: RxKotlin
• Swift: RxSwift
• PHP: RxPHP
• Elixier: reaxiv
• Dart: RxDart

Dies ist mein erster Tag, an dem ich Haskell ausprobiert habe (nach Rust und F #), und ich konnte den Operator |> von F # definieren:

(|>) :: a -> (a -> b) -> b
(|>) x f = f x
infixl 0 |>

und es scheint zu funktionieren:

factorial x =
  case x of
    1 -> 1
    _ -> x * factorial (x-1)

main =     
    5 |> factorial |> print

Ich wette, ein Haskell-Experte kann Ihnen eine noch bessere Lösung bieten.