获取未指定长度列表的范围范围？

Question

I'm trying to build up a library of extension methods and would like to integrate using Range objects into it where appropriate.

So I've created a class to represent a lightweight view into any arbitrary list and is defined in terms of a given Range .

public static class ListSlice
{
    public static IReadOnlyList<T> Create<T>(IReadOnlyList<T> list, Range range) => new ListSlice<T>(list, range);
    public static IReadOnlyList<T> Create<T>(IReadOnlyList<T> list, Index start, Index end) => Create(list, new Range(start, end));
}

public class ListSlice<T> : IReadOnlyList<T>
{
    public ListSlice(IReadOnlyList<T> list, Range range)
    {
        (List, Range) = list is ListSlice<T> slice
            ? (slice.List, slice.Range.Apply(range)) // range of range
            : (list, range);
    }
    public IReadOnlyList<T> List { get; }
    public Range Range { get; }

    public T this[int index] => List[Range.GetOffsetAndLength(List.Count).Offset + index];
    public int Count => Range.GetOffsetAndLength(List.Count).Length;

    public IEnumerator<T> GetEnumerator()
    {
        var (offset, length) = Range.GetOffsetAndLength(List.Count);
        foreach (var i in Enumerable.Range(0, length))
            yield return List[offset + i];
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

There is one corner case where I want to get a slice of a slice. I could work out the math to calculate the new effective range given the length of the original list... but is it even possible just looking at ranges alone?

As far as I can see, it's pretty straight forward when the ranges have definite starts and ends. But I'm having trouble visualizing how it would work when dealing with ranges that have starts or ends that are relative to the end. How do I do the math for this?

eg,

// absolute start/end, length is immediately known, difference between the two
0..20    // len: 20
5..10    // len: 5
5..15    // len: 10

// if both starts and ends relative to end, length is still the difference
^20..^0  // len: 20
^15..^10 // len: 5
^15..^5  // len: 10

// how do I get the length if it's open ended?
 0..^10  // len: ???
^5..20   // len: ???
 0..     // len: ??? (equivalent to: 0..^1)

I thought maybe using an arbitrary length as a stand in and go from there, I feel like I'm missing some cases.

public static class RangeExtensions
{
    public static Range Apply(this Range range, int baseLength, Range subRange)
    {
        var (offset1, length1) = range.GetOffsetAndLength(baseLength);
        var (offset2, length2) = subRange.GetOffsetAndLength(length1);
        return (offset1 + offset2)..(offset1 + offset2 + length2);
    }

    public static Range Apply(this Range range, Range subRange)
    {
        // easy case: (5..10)(..2) -> (5..7)
        // weird case: (5..10)(^2..) -> ???
        var dummyLength = 100; // not sure about this
        var (offset1, length1) = range.GetOffsetAndLength(dummyLength);
        var (offset2, length2) = subRange.GetOffsetAndLength(length1);
        var offset = offset1 + offset2;
        return offset..(offset + length2); // somehow have to offset the dummyLength
    }
}

Answer 1

Like you've correctly identified, if IsFromEnd match, then you can easily find the result by adding the Value s. In the other branches you have to subtract the inner offset instead, and set IsFromEnd accordingly. Sketching each case on paper helps.

Note: In your other code, you may want to consider the case where a range's start falls after its end.

public static Range Within(this Range inner, Range outer)
{
    Index start;

    if (inner.Start.IsFromEnd)
    {
        if (outer.End.IsFromEnd)
            start = ^(outer.End.Value + inner.Start.Value);
        else
            start = outer.End.Value - inner.Start.Value;

    }
    else
    {
        if (outer.Start.IsFromEnd)
            start = ^(outer.Start.Value - inner.Start.Value);
        else
            start = outer.Start.Value + inner.Start.Value;
    }

    Index end;

    if (inner.End.IsFromEnd)
    {
        if (outer.End.IsFromEnd)
            end = ^(outer.End.Value + inner.End.Value);
        else
            end = outer.End.Value - inner.End.Value;
    }
    else
    {
        if (outer.Start.IsFromEnd)
            end = ^(outer.Start.Value - inner.End.Value);
        else
            end = outer.Start.Value + inner.End.Value;
    }

    return start..end;
}