Estrai singolo elemento dalla lista in F #

Question

Voglio estrarre un singolo elemento da una sequenza in F #, o dare un errore se non ce n'è uno o più di uno. Qual è il modo migliore per farlo?

Al momento ho

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

sembra funzionare, ma è davvero il modo migliore?

Edit: Come mi è stato fatto nella direzione giusta, mi si avvicinò con il seguente:

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

Credo che sia un po 'più bello.

Answer 1

La sequenza ha una funzione di ricerca.

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

, ma se si vuole garantire che la ss ha un solo elemento, quindi facendo un Seq.filter, poi prendere la lunghezza dopo il filtro e assicurarsi che è uguale a uno, e poi prendere la testa. Tutto in Seq, non c'è bisogno di convertire in una lista.

Edit: Su un lato nota, ho era andando a suggerire controllando che il coda di un risultato è vuoto (O (1), invece di utilizzare la funzione di length (O (n)) di coda. non è una parte di ss, ma penso che si può elaborare un buon modo per emulare tale funzionalità.

Answer 2

fatto nello stile della sequenza esistente funzioni 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 

si potrebbe fare un'implementazione puro ma finirà per saltare mortali per essere corretta ed efficiente (che chiude rapidamente sul secondo match chiama davvero per una bandiera dicendo 'ho trovato gia')

Answer 3

Utilizzare questa:

> 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

I miei due centesimi ... questo funziona con il tipo di opzione in modo che io possa usarlo nella mia custom forse monad. potrebbe essere modificato molto facilmente però per lavorare con le eccezioni invece

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

Cosa c'è di sbagliato nell'usare la funzione di libreria esistente?

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

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

Answer 6

Aggiornato risposta sarebbe quella di utilizzare Seq.exactlyOne che solleva un ArgumentException