Vérifiez si une liste et un tableau sont égaux à F #
J'essaie de comparer une liste et un tableau et voir s'ils sont égaux. Disons que nous avons une liste list = [1;2;3;4]
et un tableau ar = [|1;2;3;4|]
. La fonction doit renvoyer true
si elle est égale et false
si elle n'est pas égale. Je l'ai fait comme ça:
let list = [1;2;3;4]
let ar = [|1;2;3;4|]
let list' = Array.toList ar
(list = list')
Donc, fondamentalement, ce que je fais est simplement de convertir et de comparer deux listes. Ma question est est-ce qu'il y a une autre façon de faire cela, je veux dire qui ne convertit pas simplement entre liste et tableau et qui ne repose pas entièrement sur les fonctions de la bibliothèque.
Réponses
Vous pouvez utiliser le fait que les listes et les tableaux (ainsi que la plupart des autres collections) implémentent l' seq<'a>
interface ( IEnumerable<T>
dans les termes .NET) et que vous pouvez donc simplement les passer aux fonctions du Seq
module sans aucune conversion. Il s'agit simplement d'utiliser une interface, donc il n'y a pas de frais généraux.
La fonction la plus simple à laquelle je puisse penser pour vérifier si deux séquences sont identiques est forall2
, qui prend deux séquences et vérifie qu'un prédicat est valable pour les éléments par paires. Dans ce cas, le prédicat est juste un test d'égalité (fun a b -> a = b)
que vous pouvez abbervier comme (=)
:
let list = [1;2;3;4]
let ar = [|1;2;3;4|]
Seq.forall2 (=) list ar
Il existe de nombreuses façons de procéder. En voici un qui compare les éléments par paires:
if list.Length = ar.Length then
Seq.zip list ar
|> Seq.forall (fun (a, b) -> a = b)
else false
Les documents F # disent:
Vous comparez deux séquences à l'aide de la fonction Seq.compareWith. La fonction compare les éléments successifs à tour de rôle et s'arrête lorsqu'elle rencontre la première paire inégale. Les éléments supplémentaires ne contribuent pas à la comparaison.
Ce qui dans votre cas devient oneliner:
0 = Seq.compareWith (Comparer<_>.Default) list ar
Je n'ai pas vérifié s'il compile. Utilisez Comparer.Default pour comparer les primitives, sinon, pour les types personnalisés complexes, vous devrez peut-être fournir les vôtres.
Avec Linq;
Enumerable.SequenceEqual (list, ar)
Sur cette base
let l = [1;2;3;4]
let a = [|1;2;3;4|]
let result = Seq.compareWith Operators.compare l a