F＃如何避免两次投射

Question

Case 1

1. Take elements while is Some value from sequense
2. Print values of some

let a = seq { yield Some 1; yield Some 2; yield Some 3; yield None }

a
|> Seq.takeWhile Option.isSome // cast 1
|> Seq.map Option.get          // cast 2
|> Seq.iter (printfn "%A")

Case 2

1. Filter sequense of Some vaue
2. Print values of Some

a
|> Seq.filter Option.isSome    // cast 1
|> Seq.map Option.get          // cast 2
|> Seq.iter (printfn "%A")

Case 3

1. Group by elements by type
2. Print values of each group

type AB =
    | A of a : int
    | B of b : string

let a = seq{
    yield A 1
    yield A 2
    yield B "ds"
    yield B "fsdf"
}

let (|As|Bs|) = function
    | A _ -> As
    | B _ -> Bs

let matcher = function
    | A a-> printfn "%A" a
    | B b -> printfn "%A" b

a
|> Seq.groupBy (|As|Bs|)       // cast 1
|> Seq.map snd
|> Seq.iter (Seq.iter matcher) // cast 2

Why do I need to avoid double casting?

• To keep the code cleaner
• To avoid throwing exceptions

Answer 1

For "Case 2" you can use Seq.choose with the identity function, id :

a
|> Seq.choose id
|> Seq.iter (printfn "%A")

The documentation for Seq.choose says

Applies the given function to each element of the list and returns the list comprised of the results for each element where the function returns Some with some value.

Passing it the identity function will therefore return the content of every Option value that is Some .

Answer 2

If you're working with lists, you can do the same thing you do in Haskell (which, judging by your comments, you know already). F# also has pattern matching, and it works much the same way, except the language is not lazy, so you'd have to account for that. For example:

let rec case2 xs = 
    match xs with
    | (Some x)::rest -> printfn "%A" x; case2 rest
    | None::rest -> case2 rest
    | [] -> ()

(note: if you're doing explicit recursion, it's a good idea to keep it to the "tail" variety; in Haskell this doesn't matter much due to laziness, but in .NET you can easily blow the stack if you're not careful)

---

If you're working with sequences, the situation is a bit more complicated. For some things you can use computation expressions (they are somewhat related to the do notation in Haskell):

let case2 xs = seq {
    for x in xs do
        match x with | Some a -> yield a | None -> ()
}

Or in some cases, standard library functions:

let case2 xs = Seq.choose id xs

(note: the above example can't be eta-reduced due to value restriction)

But your first example ("early stop") can't be expressed declaratively like that. You still have to use takeWhile , but at least you can then use choose instead of map to avoid using partial functions:

let case1 xs = xs |> Seq.takeWhile Option.isSome |> Seq.choose id

If you really-really want to have a single pattern match instead of two, it is possible to go one level deeper and use the IEnumerable interface directly:

let case1 (xs: seq<_>) = seq {
  use e = xs.GetEnumerator()
  let mutable stop = false

  while not stop && e.MoveNext() do
    match e.Current with
    | Some x -> yield x
    | None -> stop <- true
}

Note that this uses mutable variables, and while it looks ugly at first glance, it's worth remembering that iterating over .NET sequences (aka IEnumerable<'t> ) is an inherently mutation-based process. Look above: the e.MoveNext() call changes the state of enumerator e . You have to deal with this fact if you want to go down to this level.

And of course, I could have eliminated the stop variable by replacing it with recursion:

let case1 (xs: seq<_>) = seq {
  use e = xs.GetEnumerator()

  let rec loop() = seq {
    if e.MoveNext() then
      match e.Current with
      | Some x -> yield x; yield! loop()
      | None -> ()
  }

  yield! loop()
}

But this is rather silly: if I'm willing to deal with the mutable enumerator, I might as well just go all in.

---

As for your third example - I don't understand what you're even trying to do there. Or, rather, I do understand what it does, but I don't see what it would mean to get rid of the second match. Perhaps you could illustrate how you'd do the same thing in Haskell?