[Slice] Allow slice syntax to use instance `Slice` method instead of requiring `GetSlice` method

[xperiandri]

I propose we convert slice syntax not only to GetSlice call but to Slice call that is now implemented by all collections

The existing way of approaching this problem in F# is implementing SRTP extension method

namespace System

open System.Runtime.CompilerServices

[<Extension>]
type SliceExtensions =

    [<Extension>]
    static member inline GetSlice<'c
            when 'c : (member Slice: int * int -> 'c)
            and  'c : (member Length: int)>
        (source: 'c, from: int option, ``to``: int option) =

        let from = from |> Option.defaultValue 0
        let ``to`` = ``to`` |> Option.defaultValue (source.Length - 1)
        source.Slice(from, ``to`` + 1 - from)

Pros and Cons

The advantages of making this adjustment to F# are all slicing available in C# will work in F#

The disadvantages of making this adjustment to F# are not exist

Extra information

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

Related suggestions:

Affidavit (please submit!)

Please tick these items by placing a cross in the box:

• [X] This is not a question (e.g. like one you might ask on StackOverflow) and I have searched StackOverflow for discussions of this issue
• [X] This is a language change and not purely a tooling change (e.g. compiler bug, editor support, warning/error messages, new warning, non-breaking optimisation) belonging to the compiler and tooling repository
• [X] 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
• [X] I have searched both open and closed suggestions on this site and believe this is not a duplicate

Please tick all that apply:

• [X] This is not a breaking change to the F# language design
• [X] I or my company would be willing to help implement and/or test this

For Readers

If you would like to see this issue implemented, please click the :+1: emoji on this issue. These counts are used to generally order the suggestions by engagement.

[smoothdeveloper]

I know GetSlice is kind of fresh, is there a sense that now "the BCL team has decided the name", we could deprecate GetSlice through a warning, and have Slice instead?

It seems the "framework design guidelines" trend of everything being a bit verbose and explicit, "GetX", are past history, and the BCL design team is looking at C++ (https://en.cppreference.com/w/cpp/numeric/valarray/slice) for choosing identifiers more than those original guidelines.

Maybe that will help us making the same, if we face again "let's do transversal feature that carries a name into F# libraries" but can't wait for BCL team to decide, we can pick from C++ if the concept exists there and is applicable.

[jwosty]

I run into this most frequently with Span.

[brianrourkeboll]

Is there a good reason not to add support for Slice?

The only downsides I can think of are:

• There would now be two ways to add sliceability to a type in F#. It's kind of annoying, but we've accepted this reality for extension methods, optional parameters, tuples, etc...
• For backwards compatibility's sake, the compiler would presumably need to prefer GetSlice if both it and Slice existed and were in scope.

But otherwise it seems silly to make everyone write an extension method to use the BCL collections' built-in slicing capabilities, forever, when the compiler could just do it for them.

[dsyme]

I'll mark this as approved in principle. It should be possible define Slice and have the F# slicing syntax light up.

Equally the SRTP workaround is pretty good!