Punkt wolna forma kontra stylu

Question

można przekonwertować

-- tupleUnfold :: forall a. ((forall b. a -> b)) -> a -> ((b)) 
tupleUnfold :: Int -> ExpQ 
tupleUnfold n = do 
    xs <- forM [1 .. n] (const . newName $ "x") 
    y <- newName "y" 
    let y' = varE y 
     g (ps', es') x = (varP x : ps', appE (varE x) y' : es') 
     (ps, es) = foldl' g ([], []) xs 
    lamE [tupP ps, varP y] (tupE es) 

do pointfree styl przy zachowaniu jasności (wiem programu „pointfree”, ale wolałby, aby nie zaciemniać kodu nawet więcej)?

Tak czy inaczej, jakie zmiany można wprowadzić, aby poprawić styl funkcji, lub w inny sposób czynią ją bardziej zrozumiałą? Funkcja jest przeznaczona do użycia jak poniżej.

$(tupleUnfold 3) ((+ 1), (+ 2), (+ 3)) 2 
-- (3, 4, 5) 

Jakie są lepsze konwencje nazewnictwa (zobacz zmienne ps, ps ', es i es)?

Answer 1

Oto, co mam. Wymaga Control.Arrow (&&&) i Control.Applicative (<$>).

Nie można w nim skrócić znacznie, nie czyniąc go całkowicie niezrozumiałym.

EDIT Chociaż nie wskazują darmo, tutaj jest najwyraźniejszy mogłem zrobić. Potrzebuje Data.Function (on)

tupleUnfold :: Int -> ExpQ 
tupleUnfold n = do 
    y <- newName "y" 
    xs <- replicateM n (newName "x") 
    let exps = tupE $ zipWith appVars xs (repeat y) 
     pats = tupP $ map varP xs 
    lamE [pats, varP y] exps 
    where 
    appVars = appE `on` varE 

Answer 2

Osobiście myślę, że to już całkiem jasne, ale jak o tym:

tupleUnfold :: Int -> ExpQ 
tupleUnfold = mapM (const . newName $ "x") . enumFromTo 1 >=> \xs -> do 
    y <- newName "y" 
    let y' = varE y 
     g (ps', es') x = (varP x : ps', appE (varE x) y' : es') 
     f ps = lamE [tupP ps, varP y] . tupE 
    uncurry f $ foldl' g ([],[]) xs 

Kleisli skład operator >=> (od Control.Monad) jest przydatna do tworzenia pointfree funkcje monadycznego.

Answer 3

trochę bardziej niezrozumiałe (spróbuj czytać od prawej do lewej):

tupleUnfold n = do 
    y <- newName "y" 
    uncurry lamE . ((:[varP y]) . tupP *** tupE) . unzip . 
    map (varP &&& (`appE` varE y) . varE) <$> replicateM n (newName "x") 

EDIT:
mieszankę strzałkami i złożenie funkcji do przetwarzania

tupleUnfold n = do 
    y <- newName "y" 
    uncurry lamE . ((tupP >>> (:[varP y])) *** tupE) . unzip . 
    map (varP &&& (varE >>> (`appE` varE y))) <$> replicateM n (newName "x") 

i za pomocą głównie strzałek (funkcja przetwarzania odczytu od lewej do prawej t)

tupleUnfold n = do 
    y <- newName "y" 
    (map (varP &&& (varE >>> (`appE` varE y))) >>> unzip >>> 
    ((tupP >>> (:[varP y])) *** tupE) >>> uncurry lamE) <$> replicateM n (newName "x") 

zauważyć, że funkcja strzałka (>>>) odpowiada klapki (.)