Comment accéder à une liste dans OCaml

Question

Je veux écrire une fonction qui pourrait vérifier chaque élément d'une liste est vrai ou faux. Si au moins un élément est faux, il retournera vrai, de sorte que:

assert_eq "checkFalse [true; false; true]" (checkFalse [true; true; true]) false; assert_eq "checkFalse [false; false]" (checkFalse [false; true]) true; Je suis un débutant absolu dans OCaml et je ne sais pas comment aborder cela. J'ai essayé d'utiliser une boucle, quelque chose comme:

let rec checkFalse (bools: bool list) : bool = 
for i = 0 to bools.length do 
    if bools.length == false then false 
    else... (I don't know how to continue) 

Ensuite, il dit "champ d'enregistrement Unbound ...."

J'ai aussi essayé d'utiliser comme trouver: if (find false bools != Not_found) then true else false

Mais mes voies a fait ne fonctionne pas. Je viens d'un arrière-plan Java.

Merci beaucoup!

Answer 1

Jetez un oeil sur le module List: http://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html spécifiquement la méthode exists. Pour ce que vous voulez, vous pouvez simplement faire ceci:

List.exists (fun x -> not x) [true;true;...;false;...] 

La fonction exists renvoie true si un élément dans la liste satisfait le prédicat (la fonction). Dans ce cas, le prédicat est fun x -> not x qui retournera vrai si x est faux.

Pour accès à la liste générale, vous faites généralement en utilisant cette correspondance de motif et récursivité, ou en utilisant les fonctions iter, map, fold_left et fold_right (entre autres). Voici une implémentation de exists en utilisant la correspondance de motif:

let rec exists f l = match l with 
    | [] -> false (* the list is empty, return false *) 
    | h::t -> if (f h) then true (* the list has a head and a (possibly empty) tail. Check the return value of the predicate 'f' when applied to the head *) 
    else exists f t (* the predicate is false, recursively call the `exists` function on the tail *) 

edit: Chuck a affiché, au lieu de fun x -> not x vous pouvez simplement utiliser simplement not.

Une autre possibilité est d'utiliser la fonction mem:

List.mem false bools 

Answer 2

let rec checkFalse xs = 
    match xs with [] -> false 
    | false :: _ -> true 
    | _ :: tl -> checkFalse tl;; 

Answer 3

La façon serait juste let checkFalse = List.exists not simple.

prend une fonction et une liste en tant qu'arguments, et indique si la fonction que vous avez transmise est vraie pour tout élément de la liste. not renvoie la négation d'un booléen.

Answer 4

laisser checkFalse = List.exists (élém amusant -> élém = false) your_list dans

doc: val existe: ('a -> bool) ->' une liste -> bool

existe p [a1; ...; an] vérifie si au moins un élément de la liste satisfait le prédicat p.

Autrement dit, il renvoie (p a1) || (p a2) || ... || (la poêle).