Extrait un seul élément de la liste dans F #

Question

Je veux extraire un seul élément d'une séquence en F #, ou donner une erreur s'il n'y en a pas ou plus d'une. Quelle est la meilleure façon de procéder?

J'ai actuellement

let element = data |> (Seq.filter (function | RawXml.Property (x) -> false | _ -> true)) 
        |> List.of_seq 
        |> (function head :: [] -> head | head :: tail -> failwith("Too many elements.") | [] -> failwith("Empty sequence")) 
        |> (fun x -> match x with MyElement (data) -> x | _ -> failwith("Bad element.")) 

Il semble fonctionner, mais est-ce vraiment la meilleure façon?

Edit: Comme je l'ai été souligné dans la bonne direction, je suis venu avec ce qui suit:

let element = data |> (Seq.filter (function | RawXml.Property (x) -> false | _ -> true)) 
        |> (fun s -> if Seq.length s <> 1 then failwith("The sequence must have exactly one item") else s) 
        |> Seq.hd 
        |> (fun x -> match x with MyElement (_) -> x | _ -> failwith("Bad element.")) 

Je pense qu'il est un peu plus agréable.

Answer 1

La séquence a une fonction de recherche.

val find : ('a -> bool) -> seq<'a> -> 'a 

mais si vous voulez vous assurer que les suivants ne comporte qu'un seul élément, puis en faisant un Seq.filter, puis prendre la longueur après filtre et assurez-vous qu'il est égal à un, puis prendre la tête. Tout en Seq, pas besoin de convertir en liste.

Edit: Sur une note de côté, je était va suggérer de vérifier que la queue d'un résultat est vide (O (1), au lieu d'utiliser la fonction length (O (n)) Queue. ne fait pas partie des suivants, mais je pense que vous pouvez trouver une bonne façon d'imiter cette fonctionnalité.

Answer 2

fait dans le style de la séquence existante des fonctions standard

#light 

let findOneAndOnlyOne f (ie : seq<'a>) = 
    use e = ie.GetEnumerator() 
    let mutable res = None 
    while (e.MoveNext()) do 
     if f e.Current then 
      match res with 
      | None -> res <- Some e.Current 
      | _ -> invalid_arg "there is more than one match"   
    done; 
    match res with 
     | None -> invalid_arg "no match"   
     | _ -> res.Value 

vous pouvez faire une mise en œuvre pur mais il finira par sauter à travers des cerceaux pour être correcte et efficace (se terminant rapidement sur le deuxième match appelle vraiment un drapeau en disant: «Je l'ai trouvé déjà)

Answer 3

Utilisez ceci:

> let only s = 
    if not(Seq.isEmpty s) && Seq.isEmpty(Seq.skip 1 s) then 
     Seq.hd s 
    else 
     raise(System.ArgumentException "only");; 
val only : seq<'a> -> 'a 

Answer 4

Mes deux cents ... cela fonctionne avec le type d'option, donc je peux l'utiliser dans mon custom peut-être monad. pourrait être modifié très facile bien que de travailler avec des exceptions à la place

let Single (items : seq<'a>) = 
    let single (e : IEnumerator<'a>) = 
     if e.MoveNext() then 
      if e.MoveNext() then 
       raise(InvalidOperationException "more than one, expecting one") 
      else 
       Some e.Current 
     else 
      None 
    use e = items.GetEnumerator() 
    e |> single 

Answer 5

Quel est le problème avec l'utilisation de la fonction de bibliothèque existante?

let single f xs = System.Linq.Enumerable.Single(xs, System.Func<_,_>(f)) 

[1;2;3] |> single ((=) 4) 

Answer 6

réponse Mise à jour serait d'utiliser Seq.exactlyOne qui soulève une ArgumentException