Calculando el producto cartesiano de una lista de números con F #

Question

Soy nuevo en f #

estoy trato de calcular los productos cartesianos de una lista de números. Yo "tomé prestado" esto.

let xs = [1..99] 
let ys = [1..99] 
seq {for x in xs do for y in ys do yield x * y} 

¿Hay alguna manera mejor o más elegante?

Gary

Answer 1

Otra possibiltiy para abordar el problema sobre la base de la funcionalidad proporcionada por el módulo lista sería:

let xs = [1..99] 
let ys = [1..99] 
let zs = xs |> List.collect (fun x -> ys |> List.map (fun y -> x*y)) 

que evite las llamadas adicionales a .concat y también debe hacer el trabajo.

Pero me quedaré con su solución. Debería ser el más legible y el verdadero gancho. (Solo intente leer los códigos en voz alta. El suyo es perfectamente comprensible y los Noldorins o los míos no).

Answer 2

En efecto, existe una forma un poco más elegante (al menos en el sentido funcional) para calcular los productos cartesianos, que utiliza las funciones que existen dentro de la clase List. (No hay necesidad de involucrar a secuencias o bucles aquí, al menos no directamente.)

Prueba esto:

let xs = [1..99] 
let ys = [1..99] 
xs |> List.map(fun x -> ys |> List.map(fun y -> x * y)) |> List.concat 

Ligeramente más largo es cierto, aunque más funcional en el estilo, parecería.

Answer 3

Descargo de responsabilidad: No tengo una máquina con el F # actual instalado, así que no puedo probar mi código. Básicamente, sin embargo, si usted roba sequence de Haskell, se puede escribir el programa como

let cartesian = sequence >> List.map product 

y ejecutarlo como

cartesian [[1..99]; [1..99]] 

se explica cómo escribir sequence aquí. Es una versión generalizada de la expresión de secuencia que escribiste. Solo maneja un número ilimitado de listas: { for x in xs do for y in ys do for z in zs ... yield [x;y;z;...] }.

let rec sequence = function 
    | [] -> Seq.singleton [] 
    | (l::ls) -> seq { for x in l do for xs in sequence ls do yield (x::xs) } 
// also you'll need product to do the multiplication 
let product = Seq.fold_left1 (*) 

Entonces se puede escribir el programa como

let cartesian xs ys = [xs; ys] |> sequence |> List.map product 
// ... or one-argument, point-free style: 
let cartesian' = sequence >> Seq.map product 

Es posible que tenga que cambiar algunos Seq s a List s.

Sin embargo, la cantidad de personas que pueden adivinar el significado de su lista de comprensión no general es probablemente mucho mayor que la que reconocerá el nombre sequence, por lo que probablemente esté mejor con la lista comprendida. sequence es útil en cualquier momento que desee ejecutar una lista completa de expresiones de cálculo.