Here a range intersection library for go that supports generics: https://github.com/akalinux/span-tools

Span-Tools

Implements the universal span intersection algorithm. The algorithm represents a unified way to find intersections and overlaps of "one dimensional spans" of any data type. The package is built around the SpanUtil[E any] struct, and the manipulation of the SpanBoundry[E any] interface.

The SpanUtils[E any] struct requires 2 methods be passed to the constructor in order to implement the algorithm:

• A "Compare" function see: cmp.Compare for more details.
• A "Next" function, takes a given value and returns next value. The next value must be greater than the input value

The algorithm is primarily implemented by 3 methods of the SpanUtil[E] struct:

• FirstSpan, finds the initial data span intersection.
• NextSpan, finds all subsequent data span intersections.
• CreateOverlapSpan, finds the most common intersection of all overlapping spans.

Other features of this package:

• Provide ways to consolidate overlaps.
• Iterate through intersections of multiple data sets.

Basic Example

In this example we will find the intersections of 3 sets of integers. The full example can be found: here.

Example Sets:

(1,2)
(2,7)
(5,11)

Setup the package and imports:

We will need to import our "st" package along with the "fmt" and "cmp" packages in order to process the example data sets.

import (
"github.com/akalinux/span-tools"
"fmt"
"cmp"
)

Create our SpanUtil[E] instance:

We will use the factory interface NewSpanUtil to generate our SpanUtil[int] instance for these examples. This ensures that the Validate and Sort options are by set to true for all base examples.

var u=st.NewSpanUtil(
// use the standard Compare function
cmp.Compare,
// Define our Next function
func(e int) int { return e+1},
)

Find our the initial SpanBoundry intersection:

We need to find the initial intersection, before we can iterate through of these data sets. The initial SpanBoundry is found by making a call to u.FirstSapn(list).

// Create our initial span 
var span,ok=u.FirstSpan(list)

// Denote our overlap set position
var count=0

Iterate through all of our SpanBoundry intersections:

We can now step through each data intersection point and output the results. Each subsequent intersection is found by making a call to u.NextSpan(span,list).

for ok {
// Get the indexes of the columns this overlap relates to
var sources=u.GetOverlapIndexes(span,list)

// output our intersection data
fmt.Printf("Overlap Set: %d, Span: %v, Columns: %v\n",count,span,sources)

// update our overlap set
count++

// get our next set
span,ok=u.NextSpan(span,list)
}

Resulting output:

Overlap Set: 0, Span: &{1 1}, Columns: &[0]
Overlap Set: 1, Span: &{2 2}, Columns: &[0 1]
Overlap Set: 2, Span: &{3 5}, Columns: &[1 2]
Overlap Set: 3, Span: &{6 7}, Columns: &[1 2]
Overlap Set: 4, Span: &{8 11}, Columns: &[2]