TrySingle : xs → Zero | (x, One) | Many

[jimmcslim]

I'm wondering whether the community would think that TrySingle would be a useful addition to MoreLINQ.

public static Cardinality TrySingle<T>(this IEnumerable<T> values, out T result)
public enum Cardinality { Zero, One, Many }

Where the behaviour of TrySingle is to attempt to return the first, single element from the enumerable. If the enumerable has a single element, out result is populated with the item, and Cardinality.One is returned. However, if there are zero items in the enumerable then the method returns Cardinality.Zero; if there are multiple items in the enumerable then the method returns Cardinality.Many. In both of these cases the out result is null.

A consumer of this method can then distinctly handle the Zero or Many cases in whichever special way is required.

I'm happy to submit a PR if this is worthwhile.

[atifaziz]

Just curious, Take(2).ToArray() wouldn't cut it? The array length would provide the cardinality.

[jimmcslim]

True, that could be the implementation perhaps.

[atifaziz]

If we are going to add this, I would like to avoid introducing the Cardinality enum. I think the following is a lot more generic, a pure function and avoids by-ref, output, parameters:

public static TResult
    TrySingle<T, TCardinality, TResult>(this IEnumerable<T> values,
        TCardinality zero, TCardinality one, TCardinality many,
        Func<TCardinality, T, TResult> resultSelector)

In other words, the caller defines the three cardinality cases and the resultSelector will get to know which one was the case. The original signature and enum you proposed can then be implemented locally as follows:

public static Cardinality TrySingle<T>(this IEnumerable<T> values, out T result)
{
    Cardinality cardinality;
    (cardinality, result) =
        values.TrySingle(Cardinality.Zero,
                         Cardinality.One,
                         Cardinality.Many,
                         ValueTuple.Create);
    return cardinality;
}

[MkazemAkhgary]

very nice suggestion, but I think Cardinality is overkill. what about this?

public static IEnumerable<T> ExtractFirst<T>(this IEnumerable<T> values, out T result)
{
    result = default;

    using (var enumerator = values.GetEnumerator())
    {
        if (enumerator.MoveNext())
        {
            result = enumerator.Current;
            return GetRest();
        }
        return null;

        IEnumerable<T> GetRest()
        {
            while (enumerator.MoveNext())
            {
                yield return enumerator.Current;
            }
        }
    }
}

---

If null is returned, source contains no element.
If returned enumerable is empty, source contains single element.

returned enumerable is like source.Skip(1) but that one skipped element is the out parameter.

alternative signature:

public static T ExtractFirst<T>(this IEnumerable<T> values, out IEnumerable<T> rest);
public static bool ExtractFirst<T>(this IEnumerable<T> values, out T first, out IEnumerable<T> rest);

---

The last signature works nicely with ?: operator.

source.ExtractFirst(out var first, out var rest)
      ? // work with first and rest
      : Enumerable.Empty<T>();

[atifaziz]

@MkazemAkhgary Your ExtractFirst implementation (which appears to be CADR-like) has two major flaws:

1. It disposes the enumerator.
2. It changes the enumerator into an enumerable when they're not the same thing.

If null is returned, source contains no element.
If returned enumerable is empty, source contains single element.

If these are the rules, then it suffices to have something like this:

public static IEnumerator<T> TryMoveToFirst<T>(this IEnumerable<T> values)
{
    var enumerator = values.GetEnumerator();
    try
    {
        return enumerator.MoveNext() ? enumerator : null;
    }
    catch
    {
        enumerator.Dispose();
        throw;
    }
}

The Current property of the returned enumerator will contain the first element so you don't need a separate out-argument to capture it. Disposing the returned enumerator will be the caller's responsibility.

[MkazemAkhgary]

Good point on disposed enumerator. I totally missed that. apart from that changing enumerator to enumerable may cause underlying enumerator to never get disposed if the enumerable is not consumed completely.

My intention how ever was to make the syntax as short as possible. having to dispose the enumerator on caller makes some clutter.

I have to admit that if c# evolves some pattern matching in future (switch expressions) then usage with Cardinality enum would be nice and clean.

---

This one has limited usage but it fixes the problems that you mentioned.

public static bool ExtractFirst<T>(this IEnumerable<T> values, out T first, out T[] rest);
public static bool ExtractFirst<T>(this IEnumerable<T> values, int restLength, out T first, out T[] rest);

[atifaziz]

#590 could address this too and since there's been no further follow up from @jimmcslim, I'm going to close this issue.

[atifaziz]

Re-opening this issue now that there is a PR (#612) open for it.

[atifaziz]

I have moved this to the experimental namespace as I feel this needs more thought in terms of naming (and possibly design).