Try optimize without allocation

[Advitalitum]

No description provided.

[azure-pipelines]

Azure Pipelines:
Successfully started running 3 pipeline(s).
13 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-collections
See info in area-owners.md if you want to be subscribed.

[Advitalitum]

@EgorBot -linux_amd -osx_arm64

using System.Collections.Frozen;
using System.Collections.Generic;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Benchmarks).Assembly).Run(args);

[MemoryDiagnoser]
public class Benchmarks
{
    private FrozenSet<int> _frozenSet = null!;
    
    private IEnumerable<int> _largerDisjointFrozenSet = null!;
    private IEnumerable<int> _largerFrozenSetWithLateMatch = null!;
    
    private IEnumerable<int> _largerDisjointHashSet = null!;
    private IEnumerable<int> _largerHashSetWithLateMatch = null!;
    
    private IEnumerable<int> _listWithImmediateMatch = null!;
    private IEnumerable<int> _largerDisjointList = null!;

    [GlobalSetup]
    public void Setup()
    {
        _frozenSet = Enumerable.Range(9_999, 100).ToFrozenSet();
        
        _largerDisjointFrozenSet = Enumerable.Range(0, 9_999).ToFrozenSet();
        _largerDisjointHashSet = new HashSet<int>(Enumerable.Range(0, 9_999));

        _largerFrozenSetWithLateMatch = Enumerable.Range(0, 9_999).Concat([9_999]).ToFrozenSet();

        HashSet<int> largerHashSetWithLateMatch = new(Enumerable.Range(0, 9_999));
        largerHashSetWithLateMatch.Add(9_999);
        _largerHashSetWithLateMatch = largerHashSetWithLateMatch;

        _listWithImmediateMatch = new List<int> { 9_999 };
        _largerDisjointList = new List<int>(Enumerable.Range(0, 9_999));
    }

    [Benchmark]
    public bool LargerFrozenSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointFrozenSet);
    }

    [Benchmark]
    public bool LargerFrozenSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerFrozenSetWithLateMatch);
    }

    [Benchmark]
    public bool LargerHashSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointHashSet);
    }

    [Benchmark]
    public bool LargerHashSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerHashSetWithLateMatch);
    }

    [Benchmark]
    public bool List_MatchFirst()
    {
        return _frozenSet.Overlaps(_listWithImmediateMatch);
    }

    [Benchmark]
    public bool LargerList_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointList);
    }
}

[Advitalitum]

@EgorBot -linux_amd -osx_arm64

using System.Collections.Frozen;
using System.Collections.Generic;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Benchmarks).Assembly).Run(args);

[MemoryDiagnoser]
public class Benchmarks
{
    private FrozenSet<int> _frozenSet = null!;
    
    private IEnumerable<int> _largerDisjointFrozenSet = null!;
    private IEnumerable<int> _largerFrozenSetWithLateMatch = null!;
    
    private IEnumerable<int> _largerDisjointHashSet = null!;
    private IEnumerable<int> _largerHashSetWithLateMatch = null!;
    
    private IEnumerable<int> _listWithImmediateMatch = null!;
    private IEnumerable<int> _largerDisjointList = null!;

    [GlobalSetup]
    public void Setup()
    {
        _frozenSet = Enumerable.Range(9_999, 100).ToFrozenSet();
        
        _largerDisjointFrozenSet = Enumerable.Range(0, 9_999).ToFrozenSet();
        _largerDisjointHashSet = new HashSet<int>(Enumerable.Range(0, 9_999));

        _largerFrozenSetWithLateMatch = Enumerable.Range(0, 9_999).Concat([9_999]).ToFrozenSet();

        HashSet<int> largerHashSetWithLateMatch = new(Enumerable.Range(0, 9_999));
        largerHashSetWithLateMatch.Add(9_999);
        _largerHashSetWithLateMatch = largerHashSetWithLateMatch;

        _listWithImmediateMatch = new List<int> { 9_999 };
        _largerDisjointList = new List<int>(Enumerable.Range(0, 9_999));
    }

    [Benchmark]
    public bool LargerFrozenSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointFrozenSet);
    }

    [Benchmark]
    public bool LargerFrozenSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerFrozenSetWithLateMatch);
    }

    [Benchmark]
    public bool LargerHashSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointHashSet);
    }

    [Benchmark]
    public bool LargerHashSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerHashSetWithLateMatch);
    }

    [Benchmark]
    public bool List_MatchFirst()
    {
        return _frozenSet.Overlaps(_listWithImmediateMatch);
    }

    [Benchmark]
    public bool LargerList_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointList);
    }
}

[Advitalitum]

@EgorBot -macos_arm

using System.Collections.Frozen;
using System.Collections.Generic;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Benchmarks).Assembly).Run(args);

[MemoryDiagnoser]
public class Benchmarks
{
    private FrozenSet<int> _frozenSet = null!;
    
    private IEnumerable<int> _largerDisjointFrozenSet = null!;
    private IEnumerable<int> _largerFrozenSetWithLateMatch = null!;
    
    private IEnumerable<int> _largerDisjointHashSet = null!;
    private IEnumerable<int> _largerHashSetWithLateMatch = null!;
    
    private IEnumerable<int> _listWithImmediateMatch = null!;
    private IEnumerable<int> _largerDisjointList = null!;

    [GlobalSetup]
    public void Setup()
    {
        _frozenSet = Enumerable.Range(9_999, 100).ToFrozenSet();
        
        _largerDisjointFrozenSet = Enumerable.Range(0, 9_999).ToFrozenSet();
        _largerDisjointHashSet = new HashSet<int>(Enumerable.Range(0, 9_999));

        _largerFrozenSetWithLateMatch = Enumerable.Range(0, 9_999).Concat([9_999]).ToFrozenSet();

        HashSet<int> largerHashSetWithLateMatch = new(Enumerable.Range(0, 9_999));
        largerHashSetWithLateMatch.Add(9_999);
        _largerHashSetWithLateMatch = largerHashSetWithLateMatch;

        _listWithImmediateMatch = new List<int> { 9_999 };
        _largerDisjointList = new List<int>(Enumerable.Range(0, 9_999));
    }

    [Benchmark]
    public bool LargerFrozenSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointFrozenSet);
    }

    [Benchmark]
    public bool LargerFrozenSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerFrozenSetWithLateMatch);
    }

    [Benchmark]
    public bool LargerHashSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointHashSet);
    }

    [Benchmark]
    public bool LargerHashSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerHashSetWithLateMatch);
    }

    [Benchmark]
    public bool List_MatchFirst()
    {
        return _frozenSet.Overlaps(_listWithImmediateMatch);
    }

    [Benchmark]
    public bool LargerList_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointList);
    }
}

[Advitalitum]

@EgorBot -macos_arm

using System.Collections.Frozen;
using System.Collections.Generic;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Benchmarks).Assembly).Run(args);

[MemoryDiagnoser]
public class Benchmarks
{
    private FrozenSet<int> _frozenSet = null!;
    
    private IEnumerable<int> _largerDisjointFrozenSet = null!;
    private IEnumerable<int> _largerFrozenSetWithLateMatch = null!;
    
    private IEnumerable<int> _largerDisjointHashSet = null!;
    private IEnumerable<int> _largerHashSetWithLateMatch = null!;
    
    private IEnumerable<int> _listWithImmediateMatch = null!;
    private IEnumerable<int> _largerDisjointList = null!;

    [GlobalSetup]
    public void Setup()
    {
        _frozenSet = Enumerable.Range(9_999, 100).ToFrozenSet();
        
        _largerDisjointFrozenSet = Enumerable.Range(0, 9_999).ToFrozenSet();
        _largerDisjointHashSet = new HashSet<int>(Enumerable.Range(0, 9_999));

        _largerFrozenSetWithLateMatch = Enumerable.Range(0, 9_999).Concat([9_999]).ToFrozenSet();

        HashSet<int> largerHashSetWithLateMatch = new(Enumerable.Range(0, 9_999));
        largerHashSetWithLateMatch.Add(9_999);
        _largerHashSetWithLateMatch = largerHashSetWithLateMatch;

        _listWithImmediateMatch = new List<int> { 9_999 };
        _largerDisjointList = new List<int>(Enumerable.Range(0, 9_999));
    }

    [Benchmark]
    public bool LargerFrozenSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointFrozenSet);
    }

    [Benchmark]
    public bool LargerFrozenSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerFrozenSetWithLateMatch);
    }

    [Benchmark]
    public bool LargerHashSet_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointHashSet);
    }

    [Benchmark]
    public bool LargerHashSet_MatchLastInOther()
    {
        return _frozenSet.Overlaps(_largerHashSetWithLateMatch);
    }

    [Benchmark]
    public bool List_MatchFirst()
    {
        return _frozenSet.Overlaps(_listWithImmediateMatch);
    }

    [Benchmark]
    public bool LargerList_Disjoint()
    {
        return _frozenSet.Overlaps(_largerDisjointList);
    }
}