Extraer un solo elemento de la lista en F #

Question

Quiero extraer un único elemento de una secuencia en F #, o dar un error si no hay ninguno o más. ¿Cuál es la mejor manera de hacer esto?

Actualmente tengo

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.")) 

parece que funciona, pero ¿es realmente la mejor manera?

Edit: Como me señaló en la dirección correcta, me ocurrió lo siguiente:

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.")) 

supongo que es un poco más agradable.

Answer 1

La secuencia tiene una función de búsqueda.

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

pero si usted quiere asegurarse de que la SEC tiene un solo elemento, a continuación, haciendo un Seq.filter, luego tomar la longitud después del filtro y asegúrese de que es igual a uno, y luego tomar la cabeza. Todo en Seq, no es necesario convertirlo a una lista.

Editar: En una nota lateral, me fue va a sugerir la comprobación de que el cola de un resultado está vacía (O (1), en lugar de utilizar la función length (O (n)) de la cola. no es una parte de la SEC, pero creo que se puede trabajar a cabo una buena manera de emular esa funcionalidad.

Answer 2

hecho en el estilo de la secuencia existente funciones estándar

#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 

se podría hacer una aplicación pura pero terminará saltando por el aro para ser correcta y eficiente (que termina rápidamente en el segundo partido de verdad exige una bandera que dice 'me encontré con que ya')

Answer 3

Utilice esta:

> 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

Mis dos centavos ... esto funciona con el tipo de opción para que pueda usarlo en mi mónada tal vez personalizada. Sin embargo, podría modificarse muy fácilmente para trabajar con excepciones

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

¿Qué problema hay con el uso de la función de biblioteca existente?

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

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

Answer 6

Actualizado respuesta sería utilizar Seq.exactlyOne lo que plantea un ArgumentException