Refactorisation d'une fonction F# pour utiliser l'opérateur forward-pipe

Question

type Range = int * int
type Domain = Range array

type Gene = int
type Individual = Gene array
type Population = Individual array

let genPop (domain:Domain) popSize =
  let genInd (domain:Domain) : Individual =
    let genGene (range:Range) = genNum (fst range) (snd range)
    Array.map genGene domain
  Array.init popSize (fun _ -> genInd domain)

Donc, un Population n'est rien d'autre qu'un tableau de Individual s. Chaque Individual consiste en un tableau de Gene qui ne sont rien d'autre qu'un alias pour les entiers. genNum va juste générer un entier aléatoire pour nous.

Je ne suis pas particulièrement satisfait de mon genPop mise en œuvre. Bien que cela fonctionne bien et comme prévu, j'aimerais essayer une implémentation qui utiliserait l'opérateur "forward pipe". |> au lieu de ces sous-fonctions.

Des conseils sur la façon de procéder ? Idéalement, je dirais que l'on pourrait commencer par popSize qui se transformerait en une population, dont les membres seraient des individus constitués de gènes. Le problème est que nous devons généralement faire les choses dans l'autre sens. Nous devons d'abord créer les Gènes, puis les Individus, et seulement ensuite nous pouvons avoir une Population !

Comment mettriez-vous cela en œuvre (autrement que de la manière dont je l'ai fait) ? Peut-être existe-t-il d'autres moyens qui ne me sont pas apparus ?

Answer 1

Sustituir fst y snd avec une correspondance de motifs :

let genGene (x, y) = genNum x y

Votre fonction entière peut devenir :

let genPop domain popSize =
  Array.init popSize (fun _ -> Array.map (fun (x, y) -> genNum x y) domain)

ou :

let genPop domain popSize =
  [|for _ in 1..popSize ->
      [|for x, y in domain ->
          genNum x y|]|]

Answer 2

La fonction peut être réduite à (en utilisant un tuyau) :

let uncurry f = fun(a,b) -> f a b //Helper function

let genPop (domain:Domain) popSize : Population  =
  (fun _ -> domain)
  |> Array.init popSize 
  |> Array.map ((uncurry genNum) |> Array.map)

Answer 3

Voici mon (deuxième) essai :

let genPop (domain : Domain) popSize : Individual [] =
    (fun _ ->
    domain
    |> Array.map (fun (a, b) -> genNum a b))
    |> Array.init popSize
    |> Array.map (Array.copy)