hình thức Point-miễn phí so với phong cách

Question

Bạn có thể chuyển đổi

-- 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) 

để pointfree phong cách trong khi duy trì sự rõ ràng (tôi biết chương trình 'pointfree', nhưng không muốn xáo trộn mã thậm chí nhiều hơn)?

Dù bằng cách nào, những thay đổi nào có thể được thực hiện để cải thiện phong cách của chức năng hoặc làm cho mục đích của nó rõ ràng hơn? Chức năng này được thiết kế để sử dụng như dưới đây.

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

Quy ước đặt tên tốt hơn để sử dụng (xem các biến ps, ps ', es và es') là gì?

Answer 1

Đây là những gì tôi có. Cần Control.Arrow (&&&) và Control.Applicative (<$>).

Không thể cắt giảm nhiều hơn nữa mà không làm cho nó hoàn toàn khó hiểu.

EDIT Mặc dù không có điểm, đây là rõ ràng nhất Tôi có thể thực hiện. Cần 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

Cá nhân tôi nghĩ rằng nó khá rõ ràng rồi, nhưng làm thế nào về điều này:

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 

Các Kleisli thành phần điều hành >=> (từ Control.Monad) rất hữu ích cho việc tạo ra các chức năng monadic pointfree.

Answer 3

một chút khó hiểu hơn (cố gắng đọc từ phải sang trái):

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

EDIT:
kết hợp của mũi tên và hàm hợp để chế biến

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

và sử dụng hầu hết các mũi tên (chức năng xử lý đọc từ trái sang phải t)

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

lưu ý rằng vào mũi tên chức năng (>>>) tương đương với lật (.)