Wyodrębnij pojedynczy element z listy w F #

Question

Chcę wyodrębnić pojedynczy element z sekwencji w F # lub podać błąd, jeśli nie ma go lub jest więcej niż jeden. Jaki jest najlepszy sposób na zrobienie tego?

Obecnie mam

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

wydaje się działać, ale jest to naprawdę najlepszy sposób?

Edit: Jak już wskazano we właściwym kierunku, wpadłem na następujący:

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

myślę, że to trochę ładniejszy.

Answer 1

Sekwencja ma funkcję wyszukiwania.

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

ale jeśli chcesz mieć pewność, że nast ma tylko jeden element, a następnie robi Seq.filter, a następnie podjąć długość po filtrze i upewnić się, że równa się jeden, a następnie podjąć głową. Wszystko w Seq, nie trzeba konwertować do listy.

Edit: Na marginesie, ja był zamiar zaproponować sprawdzenie czy ogon od wyniku jest pusta (O (1), zamiast korzystać z funkcji length (O (n)) Tail. nie jest częścią seq, ale myślę, że można wypracować dobry sposób, aby naśladować tę funkcjonalność.

Answer 2

zrobione w stylu istniejącej sekwencji standardowe funkcje

#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 

można zrobić czystą wdrożenia ale skończy się skakaniem przez obręcze być poprawny i efektywny (szybko kończące się na drugim meczu naprawdę domaga flagą z napisem „Znalazłem go już”)

Answer 3

użyj:

> 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

Moje dwa centy ... to działa z typ opcji, dzięki czemu mogę go użyć w mojej niestandardowej monadzie. może być modyfikowany bardzo łatwo, ale działa z wyjątkami zamiast:

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

Co jest nie tak z wykorzystaniem istniejącej funkcji biblioteki?

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

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

Answer 6

Updated odpowiedzią byłoby użyć Seq.exactlyOne który podnosi ArgumentException