Le filtre F # ne sort que la première occurrence de la liste

Question

J'ai une liste et je veux supprimer un élément correspondant à certains critères mais supprimer un seul élément.

let items = [1;2;3] 

let predicate x = 
    x >= 2 

let result = items |> List.fold ... 
// result = [1;3] 

Comment obtenir la liste de retour de méthode avec [1; 3]?

Answer 1

Vous pouvez utiliser une fonction récursive générique

let rec removeFirst predicate = function 
    | [] -> [] 
    | h :: t when predicate h -> t 
    | h :: t -> h :: removeFirst predicate t 

ou une récursif de la queue (si vous craignez un débordement de pile)

let removeFirst predicate list = 
    let rec loop acc = function 
     | [] -> List.rev acc 
     | h :: t when predicate h -> (List.rev acc) @ t 
     | h :: t -> loop (h :: acc) t 
    loop [] list 

Answer 2

let result = 
    items 
    |>List.scan (fun (removed, _) item -> 
     if removed then true, Some(item) //If already removed, just propagate 
     elif predicate item then true, None //If not removed but predicate matches, don't propagate 
     else false, Some(item)) //If not removed and predicate doesn't match, propagate 
     (false, None) 
    |>List.choose snd 

L'état est un tuple. Le premier élément est un drapeau booléen indiquant si nous avons déjà supprimé un élément de la liste. Le deuxième élément est une option: certains lorsque nous voulons émettre l'élément, aucun autrement.

La dernière ligne prend les deuxièmes éléments des états et pour chacun d'eux émet la valeur enveloppée (dans le cas de Some) ou ne fait rien (dans le cas de None).

Answer 3

Voici une courte alternative, qui dans mes tests a été plus rapide que les autres proposés jusqu'à présent:

let removeFirst p xs = 
    match List.tryFindIndex p xs with 
    | Some i -> List.take i xs @ List.skip (i+1) xs 
    | None -> xs 

Answer 4

Viser une solution intuitive.

let removeAt index list = 
    let left, right = List.splitAt index list 
    left @ (List.skip 1 right) 

let removeFirst predicate list = 
    match List.tryFindIndex predicate list with 
    | Some index -> removeAt index list 
    | None -> list 

Pour les performances (listes longues).

let removeFirst predicate list = 
    let rec finish acc rem = 
     match rem with 
     | [] -> acc 
     | x::xs -> finish (x::acc) xs 
    and find l p acc rem = 
     match rem with 
     | [] -> l 
     | x::xs -> 
      if p x then finish xs acc 
      else find l p (x::acc) xs 
    find list predicate [] list