OCaml: Permutation de chaque valeur dans deux ensembles? (comment traduire cela à partir de Java)

Question

J'ai deux ensembles, retournés par Set.Make (t). Je voudrais générer toutes les combinaisons possibles des valeurs dans les deux. Comment puis-je faire ceci?

Cela fonctionne pour générer des paires, mais pas tous:

List.combine (IntSet.elements odp) (IntSet.elements ftw) 

Cela ferait en Java:

for (int i : ktr) { 
    for (int m : mnx) { 
     System.out.println(i + ", " + m); 
    } 
} 

Answer 1

Si xs et ys sont deux listes, alors leur produit cartésien (renvoyant une liste de paires) peut être calculé comme suit:

List.concat (List.map (fun x -> List.map (fun y -> (x, y)) 
             ys) 
         xs) 

Dans ce cas, votre xs et ys sont IntSet.elements odp et IntSet.elements ftw

Answer 2

Vous recherchez le produit cartésien de deux ensembles.

Cette question a été posée in a thread sur la liste de diffusion de OCaml. Cette réponse est proposée par Brian Hurt: Pour

module TypeSet = Set.Make(Type);;

Créer, pour représenter le produit:

module TypeType = struct 
    type t = Type.t * Type.t;; 
    let compare (x1, x2) (y1, y2) = 
     let r = Type.compare x1 y1 in 
     if r == 0 then 
      Type.compare x2 y2 
     else 
      r 
    ;; 
end;; 

module TypeTypeSet = Set.Make(TypeType);; 

Générez ensuite le produit avec:

let cartesian_product s1 s2 = 
    let f x y t = TypeTypeSet.add (x, y) t in 
    let g x t = TypeSet.fold (f x) s2 t in 
    TypeSet.fold g s1 TypeTypeSet.empty 
;; 

Answer 3

En combinant la solution de @ David Crawshaw (qui est récursive) avec @ newacct de (ce qui est totalement générique):

let cartesian_product xs ys = 
    List.fold_left (fun acc x -> 
    List.fold_left (fun acc y -> 
     (x,y) :: acc) 
     acc ys) 
    [] xs 

let product = 
    cartesian_product (IntSet.elements odb) (IntSet.elements ftw) 

Cela inversera l'ordre naturel. Il peut être récupéré en appliquant List.rev au résultat (List.rev est également récursif de la queue).