Quand utiliser une séquence dans F # par opposition à une liste?

Je comprends qu’une liste contient des valeurs et une séquence est un alias pour IEnumerable . Dans le développement pratique de F #, quand devrais-je utiliser une séquence plutôt qu’une liste?

Voici quelques raisons pour lesquelles je peux voir une séquence mieux:

  • Lors de l’interaction avec d’autres langages ou bibliothèques .NET nécessitant IEnumerable .
  • Besoin de représenter une séquence infinie (probablement pas vraiment utile dans la pratique).
  • Besoin d’évaluation paresseuse.

Y en a-t-il d’autres?

Je pense que votre résumé pour choisir quand Seq est assez bon. Voici quelques points supplémentaires:

  • Utilisez Seq par défaut lors de l’écriture de fonctions, car elles fonctionnent avec toute collection .NET
  • Utilisez Seq si vous avez besoin de fonctions avancées telles que Seq.windowed ou Seq.pairwise

Je pense que choisir Seq par défaut est la meilleure option, alors quand choisirais-je un type différent?

  • Utiliser la List lorsque vous avez besoin d’un traitement récursif à l’aide de la structure head::tail
    (pour implémenter des fonctionnalités qui ne sont pas disponibles dans la bibliothèque standard)

  • Utiliser la List lorsque vous avez besoin d’une structure de données simple et immuable que vous pouvez créer pas à pas
    (par exemple, si vous devez traiter la liste sur un seul thread – pour afficher certaines statistiques – et continuer à créer la liste sur un autre thread lorsque vous recevez plus de valeurs, par exemple depuis un service réseau)

  • Utiliser la List lorsque vous travaillez avec des listes courtes – la liste est la meilleure structure de données à utiliser si la valeur représente souvent une liste vide , car elle est très efficace dans ce scénario

  • Utilisez Array lorsque vous avez besoin de grandes collections de types de valeur
    (les tableaux stockent des données dans un bloc de mémoire plat, de sorte qu’ils sont plus efficaces en termes de mémoire dans ce cas)

  • Utilisez Array lorsque vous avez besoin d’un access aléatoire ou de performances supplémentaires (et de la localité du cache)

Préférez également seq quand:

  • Vous ne voulez pas contenir tous les éléments en mémoire en même temps.

  • La performance n’est pas importante.

  • Vous devez faire quelque chose avant et après l’énumération, par exemple, vous connecter à une firebase database et fermer la connexion.

  • Vous n’êtes pas en Seq.append concaténer ( Seq.append répété va emstackr le débordement).

Préférer la list quand:

  • Il y a peu d’éléments.

  • Vous allez préparer et décapiter beaucoup.

Ni seq ni la list sont bons pour le parallélisme, mais cela ne signifie pas nécessairement qu’ils sont mauvais non plus. Par exemple, vous pouvez utiliser l’un ou l’autre pour représenter un petit groupe d’éléments de travail distincts à faire en parallèle.

Juste un petit point: Seq et Array sont meilleurs que List pour le parallélisme.

Vous avez plusieurs options: PSeq de F # PowerPack, module Array.Parallel et Async.Parallel (calcul asynchrone). La liste est horrible pour une exécution en parallèle en raison de sa nature séquentielle ( head::tail composition).

la liste est plus fonctionnelle, mathématique. Lorsque chaque élément est égal, 2 listes sont égales.

séquence n’est pas.

 let list1 = [1..3] let list2 = [1..3] printfn "equal lists? %b" (list1=list2) let seq1 = seq {1..3} let seq2 = seq {1..3} printfn "equal seqs? %b" (seq1=seq2) 

entrer la description de l'image ici

Vous devez toujours exposer Seq dans vos API publiques. Utilisez List et Array dans vos implémentations internes.