Wie kann man f (g x) (h x) punktfrei in Haskell implementieren?

Question

Von this answer lernt man, wie man die Funktion \x y z -> f x (g y z) sinnlos in Haskell implementiert, wo f und g Funktionen sind. Und meine Frage ist

Wie schreibe ich die Funktion \x -> f (g x) (h x) in einer pointfree Weise in Haskell? Hier sind fgh Funktionen, für die f (g x) (h x) definiert ist.

Die Idee, die ich derzeit im Auge habe, ist etwas wie folgt.

uncurry f (mapTuple ($ x) (g, h)) 

Aber mehrere Versuche zeigen, dass dies irreführend ist; selbst der Teil map ($ x) [g, h] ist verdächtig: Was, wenn g und h unterschiedliche Bereiche haben?

Darüber hinaus ist Lesbarkeit nicht zu viel ein Problem hier.

Jede Hilfe wird herzlichst geschätzt.

Answer 1

Als melpomene vorgeschlagen, entspricht \x -> f (g x) (h x)liftM2 f g h.

Wenn Sie Fragen haben, wie Sie Haskell Code in Pointfree Haskell Code konvertieren, können Sie einfach Pointfree.io versuchen.

Es ist ein großes Werkzeug, das kann man oft sagen, wenn sie nicht pointfree Code zu verwenden, da es manchmal völlig unleserlich geht :-)

Answer 2

Die arrow Version wäre

uncurry f . (g &&& h) 

oder

(g &&& h) >>> uncurry f 

Als Diagramm:

 g ──── 
     ╱   ╲ 
──── &&&  >>> uncurry f ─── 
     ╲   ╱ 
     h ──── 

Answer 3

Applicative Stil

f <$> g <*> h 

Control.Compose

join ((g ~> h ~> id) f) 

Data.Function.Meld

join (f $* g $$ h *$ id) 

Data.Function.Tacit

lurryA @N1 (f <$> (g <$> _1) <*> (h <$> _1)) 
lurryA @N4 (_1 <*> (_2 <*> _4) <*> (_3 <*> _4)) f g h 

Answer 4

Dies dient nur dazu, die Antworten in den Kommentaren zu sammeln und in Reihenfolge zu bringen. Nach den Abstraktion-Eliminierungsverfahren in dem Link in dem Kommentar von @ PetrPudlák können wir auch

S (S (K f) (S (K g) I)) (S (K h) I), 

oder nach eta Reduktion,

S (S (K f) g) h, 

wo

S x y z = x z (y z) 
K x y = x 

schreiben Speziell in Haskell, dank @melpomene für den Hinweis darauf, wird die Rolle von S von ap und vongespieltvon const. Deshalb können wir

ap (ap (const f) g) h 

In der Tat schreiben wir weiter reduzieren:

ap (const f) g = f . g 

So können unsere Funktion geschrieben werden als:

ap (f . g) h 

Wenn zu Applicative Stil übersetzt, so erhalten wir:

f <$> g <*> h 

Dann kann dieser systematische Ansatz auf alle Lambda-Terme angewendet werden und gibt den Punkt-freien Stil. :)