Is there a "headNtail" like operation available in F#?

[The-Futurist]

I was wondering if there's a way to consume a sequence and avoid the duplicate iterating we get with Seq.head and Seq.tail.

If a function is passed a sequence and needs to consume the head element and then (perhaps recursively) consume the "rest" of the sequence we end up iterating the sequence twice (I think), that is we must enumerate the sequence one step to get head and we must enumerate it one step to get tail because in each case we are starting with the same sequence.

So we could avoid this if there was a function "headNtail" that accepted a sequence and returned a tuple that contained the head and the tail so that the tail is automatically available and already "pointing at" the correct position.

A crude C# mockup of this is here:

List<int> nums = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 };

var enumerator = nums.GetEnumerator();

var e1 = enumerator.fastHead();

var e2 = e1.Remaining.fastHead();

var e3 = e2.Remaining.fastHead();

public static class Extensions
{
    public static (T Value, IEnumerator<T> Remaining) fastHead<T>(this IEnumerator<T> Input)
    {
        while (Input.MoveNext())
        {
            return (Input.Current, Input);
        }

        return (default, Input);
    }
}

Here we return the partially "consumed" enumerator each time, so I was wondering if there's any merit in such a thing being available in the F# Seq library in some way? This cropped in during a discussion here in Discord.

---- UPDATE

I played around with this after looking at the Seq source code, it seems to do part of what I'm speaking of but I don't think its right:

let headNtail (source : seq<_>) =
    use e = source.GetEnumerator()
    if (e.MoveNext()) then (e.Current, seq { while (e.MoveNext()) do yield e.Current})
    else invalidArg "source" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString

---- UPDATE

These two functions kind of work in unison, the first gets the ball rolling then the second can be called recursively where snd applied to the returned result each time refers to the remaining sequence...

let headNtail_1 (source : seq<_>) =
    use enumerator = source.GetEnumerator()
    if (enumerator.MoveNext()) then (enumerator.Current, enumerator)
    else invalidArg "source" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString

let headNtail_2 (enumerator : System.Collections.Generic.IEnumerator<_>) =
    if (enumerator.MoveNext()) then (enumerator.Current, enumerator)
    else invalidArg "source" LanguagePrimitives.ErrorStrings.InputSequenceEmptyString

Anyway I'm sure you get the idea, I'm clearly a novice with F# but this idea seems to have merit.

[dsyme]

There isn't, and in general FSharp.Core doesn't expose anything working with enumerators.

You can code one up pretty much as you've shown

[The-Futurist]

There isn't, and in general FSharp.Core doesn't expose anything working with enumerators.

You can code one up pretty much as you've shown

OK and I guess an explicit enumerator like this is basically a mutable thing, so not desirable generally.

[dsyme]

It certainly makes coding "interesting" :)