[RFC FS-1103] "chooseType" function for collection modules

[Happypig375]

RFC: https://github.com/fsharp/fslang-design/blob/main/archived/FS-1103-chooseType-function-for-collection-modules.md
Suggestion: fsharp/fslang-suggestions#527

[charlesroddie]

This is a bad addition as it hides downcasting. The symbol ? in the explicit downcast operator indicates that it is circumenting the type system, and is easy to flag in code review as a code smell. itemsArray.OfType<TResult>() |> Seq.toArray doesn't have anything that looks wrong about it until you investigate the type signature of OfType. So it is harder to keep F# codebases clean with this addition.

It should not be in FSharp.Core but if it must go in can we restrict it so you have to open TypeHierarchies to use it?

[Happypig375]

But each downcast is guaranteed to be safe because otherwise the resulting collection will not have the element. When interacting with external libraries built with object orientation instead of functional in mind, you can't really say it's a code smell when you do with Seq.choose (function :? TResult as x -> Some x | _ -> None).

[charlesroddie]

Safe only in the sense that it won't throw an exception.

Cases:

1. There is a seq<'T>, and we want an seq<'U>, where 'T :> 'U : very safe but this is not this suggestion as choosing is trivial.
2. There is a seq<'T>, and we want an seq<'U>, where 'U :> 'T . Allows dealing with type hierarchies that are OK in a .Net context but generally inferior to F# since F# has DUs. But better to force this to be written out with the :? to indicate that there is interop with less pure code.
3. There is a seq<'T>, and we want an seq<'U>, where we don't know that 'U :> 'T or 'T :> 'U: clearly terrible and I can't think of an example where you would try to do this.
4. There is an IEnumerable (or IEnumerable<obj>) and we want an seq<'U>. There is no excuse to work with non-generic IEnumerables in .Net and so the type signature IEnumerable -> seq<'T> is a code smell. Same for raw objs. So to allow this to be done without a written apology is terrible.

Overall the only case that has some (small) benefit is 2, but to support that well would require a 'U :> 'T type constraint and an seq<'T>->seq<'U> signature. Supporting 3 or 4 is terrible.

you can't really say it's a code smell when you do with Seq.choose (function :? TResult as x -> Some x | _ -> None)

The :? indicates that a type test is being done so makes clear that we are leaving the realm of pure F# types. It's something very visible that can be picked up in code review easily as something that requires justification. I.e. easily smelled.

[jackfoxy]

The link to the RFC is broken.

[Happypig375]

It hasn't been merged yet.

[dsyme]

I've gone cold on adding this to FSharp.Core. It is indeed just so easy to use Seq.choose or a seq { ... } and making the type testing explicit.

I'm proposing to archive this RFC and close out the suggestion.