Discussion :

[Nemerle]

Deux questions "simples".

1. j'aimerais construire couple :: [a] -> [[a]] qui me donnerait toutes les paires [x,y]. Je précise que je démarre depusi hier (ça vous le savez ... ), juste avec la doc.

La fonction générale pour les sous-tuples est ok:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
combinations :: Int -> [a] -> [[a]]
combinations 0 _  = [ [] ]
combinations n xs = [ y:ys | y:xs' <- tails xs
                           , ys <- combinations (n-1) xs']

Mais est-il possible de la simplifier pour ne tenir compte que de n=2 ? J'ai essayé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
couple :: [a] -> [[a]]
couple xs = [y:ys | y:xs' <- tails xs
			, ys <- tails xs']

qui bien sûr ne marche pas, et même

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
couple :: [a] -> [[a]]
couple xs = [y:ys | y:xs' <- tails xs
			, ys <- head.tails xs']

mais ce head qui me resoudrait le problème ne fonctionne pas!

2. Une fois la fct couple ok, j'obtiendrai donc une liste [[x1,y1],[x2,y2],...], et étant donné une fonction f:Integer -> Integer -> Integer, j'aimerais l'appliquer à cette liste; c'est avec zipWith, c'est cela?

Merci pour ceux qui pourront aider un dilletante ...

[SpiceGuid]

J'ai regardé dans mes fonctions persos et celle-ci me semble correspondre à ce que tu cherche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
# let rec pair_list l =
  match l with
  | []  -> []
  | a::t -> (List.map (fun b -> a,b) t) @ pair_list t;;
val pair_list : 'a list -> ('a * 'a) list = <fun>

Remarques:

• désolé, c'est du Caml
• désolé, je ne saurais pas faire avec une liste 'en compréhension'
• j'ai supposé que la fonction à appliquer est commutative, c'est-à-dire que si la liste renvoyée contient le couple (a,b) alors elle ne contient pas le couple (b,a)

[Jedai]

Alors, pour toutes les parties à deux éléments d'une liste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

couple xs = [ [x,y] | x:ys <- tails xs, y <- ys]

Mais je ne suis pas sûr que tu veuilles vraiment une liste de liste, ne veut tu pas plutôt une liste de tuples ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

couple xs = [ (x,y) | x:ys <- tails xs, y <- ys]

Par ailleurs zipWith prend deux listes en paramêtre, pas une liste de tuple, il faudrait d'abord utiliser unzip pour pouvoir utiliser zipWith, il serait plus simple de faire un simple map (si j'ai bien compris le but) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

applyToCoupleList f = map (uncurry f)

(mon nom manque d'imagination...)

--
Jedaï

[Nemerle]

Merci Jedai. Je pense avoir trouvé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
couple xs = [ (x,y) | x:ys <- tails xs, y <- ys]   
compa c cc = (foldl (\x y -> x+y) 0 (zipWith (\x y -> if x>y then x-y else y-x) c cc))
compar = (uncurry compa)

Ca marche, mais y-a-t'il mieux pour la fct compa?

[Jedai]

Je ne suis pas très sûr de ce que tu veux dire par "ça marche" vu que je n'ai pas vu d'exemple d'application, mais pour compa, voilà ce que j'aurais écris (principalement des améliorations esthétiques) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

compa xs ys = sum $ zipWith (\x y-> abs $ x-y) xs ys

(Par ailleurs je l'aurais sans doute directement écrit en style non-curryfié, sauf si j'en avais besoin ailleurs bien sûr (mais ça ressemble à un bon candidat pour l'inclusion dans un "where", du moins avec les informations dont je dispose)).

--
Jedaï

[Nemerle]

merc pour la rq Jedai. OUi, ça va être utilisé dans un where.

Ceci dit, je me rends compte qu'ayant commencé "en direct" Haskell, je découvre les fct de base au fur et à mesure! En fait j'utilsie l'index pour chercher des lsites de fct... j'utilise la recherche sur "tails" pour obtenir les fct datalist, etc.

Il me faudra encore bien du temps avant d'appréhender toute la puissance d'Haskell...