chooseType for List, Array and Seq modules

[sergey-tihon]

Enumerable.OfType equivalent for List, Array and Seq modules

I propose to extend List, Array and Seq modules with equivalent to Enumerable.OfType

The existing way of approaching this problem in F# is

// Option 1
itemsArray |> Array.choose (function | :? 'a as x -> Some(x) | _ -> None)
// Option 2
itemsArray.OfType<TResult>() |> Seq.toArray

more options a mentioned on StackOverflow

Pros and Cons

The advantages of making this adjustment to F# are:

• Improvements of code readability and succinctness
• Avoidance of the LINQ usage.

The disadvantages of making this adjustment to F#

• ???

Extra informtion

Estimated cost (XS, S, M, L, XL, XXL): XS

Related suggestions: (put links to related suggestions here)

Affidavit (must be submitted)

Please tick this by placing a cross in the box:

• This is not a question (e.g. like one you might ask on stackoverflow) and I have searched stackoverflow for discussions of this issue
• I have searched both open and closed suggestions on this site and believe this is not a duplicate
• This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it.

Please tick all that apply:

• This is not a breaking change to the F# language design
• I would be willing to help implement and/or test this
• I or my company would be willing to help crowdfund F# Software Foundation members to work on this

[slang25]

I'd like to vote for ofType being defined in each module. At the moment in a lot of my projects I use this:

Module Seq = 
    let ofType<'a> (items: _ seq)= items |> Seq.choose(fun i -> match box i with | :? 'a as a -> Some a |_ -> None)

I think this makes it discoverable, and where people might expect to find it.

[ErikSchierboom]

Nice suggestion! I assume this is a relatively small feature, so could this be something that someone new to the F# compiler (like me) can pick up? If so, I'd love to give it a go.

[Happypig375]

Has this been approved yet?

[cartermp]

@Happypig375 Nope, that requires the approved-in-principle label.

[dsyme]

@cartermp What do you think about this?

• Historically we haven't particularly emphasized runtime-type-based classification/filtering/querying as a technique in FSharp.Core. But it's entirely consistent with the rest of F# to do so.

• There are no downvotes, a good number of upvotes.

So I'd say yes, we could do this, there's no real reason not to

[cartermp]

My only question would be if this is also considered valid for Fable usage, but otherwise I don't see a reason not to add this

[deviousasti]

Fable can test the run-time type limited to classes.

let isOfT = k :? T

export const isOfT = k instanceof T;

[Liminiens]

It’s reasonable to have such functions at core library when you do interop with frameworks like Xamarin, where you sometimes have to get a collection of a more concrete type. Or find first element that satisfies some type. Example is Effects on a Xamarin.Forms control.

[Happypig375]

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

[Happypig375]

This should be called chooseType instead of ofType because functions starting with of in F# signify creation from another type which is not the case here, instead this function is more similar to choose.

[Happypig375]

RFC discussion here: https://github.com/fsharp/fslang-design/blob/main/archived/FS-1103-chooseType-function-for-collection-modules.md

[dsyme]

The RFC has been archived as we decided not to progress it. I will close this suggestion as declined