Autre fonction d'ordre supérieur de python Haskell

Question

je le code suivant:

import operator 

def stagger(l, w): 
    if len(l)>=w: 
     return [tuple(l[0:w])]+stagger(l[1:], w) 
    return [] 

def pleat(f, l, w=2): 
    return map(lambda p: f(*p), stagger(l, w)) 

if __name__=="__main__": 
    print pleat(operator.add, range(10)) 
    print pleat(lambda x, y, z: x*y/z, range(3, 13), 3) 
    print pleat(lambda x: "~%s~"%(x), range(10), 1) 
    print pleat(lambda a, b, x, y: a+b==x+y, [3, 2, 4, 1, 5, 0, 9, 9, 0], 4) 

partie importante: Pli prend toute fonction et toute séquence et transmet la première poignée d'éléments de cette séquence dans la fonction reçue en tant que paramètres .

Existe-t-il un moyen de faire ça chez Haskell ou est-ce que je rêve?

Answer 1

Les signatures de type ci-dessous sont en option:

 
stagger :: [a] -> Int -> [[a]] 
stagger l w 
    | length l >= w = take w l : stagger (tail l) w 
    | otherwise  = [] 

pleat :: ([a] -> b) -> [a] -> Int -> [b] 
pleat f l w = map f $ stagger l w 

main = do 
    print $ pleat (\[x, y] -> x+y) [0..9] 2 
    print $ pleat (\[x, y, z] -> x*y/z) [3..12] 3 
    print $ pleat (\[x] -> "~" ++ show x ++ "~") [0..9] 1 
    print $ pleat (\[a, b, x, y] -> a+b == x+y) [3, 2, 4, 1, 5, 0, 9, 9, 0] 4 

L'idée est que la fonction est explicite au sujet de prendre une liste de longueur inconnue comme argument, il est donc pas très type sécurisé. Mais il s'agit à peu près d'un mappage 1-à-1 du code Python.