Wie stelle ich die Effizienz bei Teilanwendungen in reinem Haskell sicher?

Question

Ich habe einige Codes, die Struktur entspricht dies hat:

import Debug.Trace 

newtype SomeExpensiveHiddenType = SCHT Double 

expensive :: Double -> Double -> SomeExpensiveHiddenType 
expensive a b = SCHT $ trace "call expensive" (*) a b 

cheap :: SomeExpensiveHiddenType -> Double -> Double 
cheap (SCHT x) c = trace "call cheap" (+) x c 

f1 :: Double -> Double -> Double -> Double 
f1 a b c = let x = expensive a b in cheap x c 

d.h. f1 ist eine Funktion, die ein teures Ergebnis auf der Grundlage der ersten beiden Argumente berechnet, und verwendet dann diese mit dem dritten Argumente. Ich hatte gehofft, dass eine teilweise Anwendung auf die ersten beiden Argumente und die wiederholte Anwendung des dritten Arguments dazu führen würden, dass die teure Berechnung nur einmal ausgeführt würde. Leider ist dies nicht der Fall:

test1 = do 
    putStrLn "test 1" 
    let p = f1 2 3 
    print (p 0.1) 
    print (p 0.2) 
    print (p 0.3) 

Ergebnisse in:

*Main> test1 
test 1 
call cheap 
call expensive 
6.1 
call cheap 
call expensive 
6.2 
call cheap 
call expensive 
6.3 
*Main> 

ich habe kommen mit, was scheint eine Lösung zu sein:

newtype X a = X { unX :: a } 
f2 :: Double -> Double -> X (Double -> Double) 
f2 a b = let x = expensive a b in X (cheap x) 

test2 = do 
    putStrLn "test 2" 
    let p = unX $ f2 2 3 
    print (p 0.1) 
    print (p 0.2) 
    print (p 0.3) 

in resultierenden:

*Main> test2 
test 2 
call cheap 
call expensive 
6.1 
call cheap 
6.2 
call cheap 
6.3 
*Main> 

Aber das scheint ziemlich chaotisch . Gibt es eine sauberere Möglichkeit, die redundanten Aufrufe an die teure Kalkulation zu vermeiden?

Answer 1

Sie können einfach das dritte Argument innerhalb der let setzen, so dass x freigegeben ist.

f2 a b = let x = expensive a b in \c -> cheap x c 

(In diesem Fall f2 a b = let x = expensive a b in cheap x auch funktioniert.)

---

Was Sie suchen ist-Compiler angetrieben partial evaluation, und das ist ein schwieriges Problem ... zumindest ist es ausreichend hart ist richtig implementieren, dass es nicht in GHC ist.