Vereinfachen eine zweiparametrige anonyme Funktion in Elm

Question

In Elm, wenn ich eine anonyme Funktion

(\f x -> f x) 

habe ich es zu

(<|) 

Kann das gleiche getan werden für eine Zwei-Parameter vereinfachen Funktion wo die Parameter Argumente für eine andere Funktion sind?

(\x y -> f x y |> g) 

Ich dachte, ich einfach

(f |> g) 

aber der Compiler beschwert sich über die Art nutzen könnten.

Insbesondere in einem der Fälle für meine update Funktion, ich habe so etwas wie dies:

let 
    msgNames = [Foo, Bar] 

    values = ["f", "b"] // These values are actually derived 
         // by a more complicated operation 

    model_ = List.map2 (<|) msgNames values 
       |> List.foldl (\msg mod -> update msg mod |> Tuple.first) 
         model 
in 
    (model_, Cmd.none) 

Ich versuche, die anonyme Funktion Argument List.foldl um so etwas wie (update |> Tuple.first) zu vereinfachen, aber ich bekomme die folgende Fehler vom Compiler:

The right side of (|>) is causing a type mismatch. 

159|          update |> Tuple.first) 
                ^^^^^^^^^^^ 
(|>) is expecting the right side to be a: 

    (Msg -> Model -> (Model, Cmd Msg)) -> a 

But the right side is: 

    ((Model, Cmd Msg)) -> Model 

Answer 1

Wir können ein paar Schritte folgen zu vereinfachen:

(\x y -> f x y |> g) 
... can be written as 
(\x y -> g (f x y)) 
... can be written as 
(\x -> g << f x) 

Ein weiterer Schritt und die Dinge ein wenig verwirrend:

(((<<) g) << f) 

Das passt, was Sie von bekommen (die Haskell ist, wo Funktion Zusammensetzung erfolgt über den . Operator):

(g .) . f 

Wenn Sie versuchen, die Lesbarkeit zu verbessern, möchten Sie vielleicht nur Ihre eigene Infix-Funktion erstellen:

infixr 9 <<< 
(<<<) : (c -> d) -> (a -> b -> c) -> (a -> b -> d) 
(<<<) g f x y = 
    g (f x y) 

Und jetzt können Sie es wie folgt verwendet werden:

(g <<< f)