The superlinq from viceroypenguin

Permutations
RandomSubset
Subsets
Shuffle

Add .Move() overload that takes a Range

Add `ValueTuple` version of `Cartesian` operator

Add a basic Dijkstra's algorithm function

.Replace() operator

public static IEnumerable<TSource> Replace<TSource>(this IEnumerable<TSource> source, Index index, TSource value);

Used to replace a single item at a specific index while streaming a sequence.

Improve Join functions

~~Add .LoopJoin() [Inner, Left outer, Cross Apply, Outer Apply]~~ This is just .Select()/.SelectMany()
~~Add .HashJoin() [Inner, Left outer, Right outer, Full outer]~~ .Join()/.GroupJoin() uses hash join - just need to clean up .LeftJoin()/.RightJoin(); maybe improve .FullJoin()
Add .MergeJoin() [Inner, Left outer, Right outer, Full outer]
Update existing methods (.FullJoin(), OrderedMerge(), etc.) as implementations of above

Debate: Add .LoopJoin() and .HashJoin() as aliases to .Select() and .Join(), for completeness/equivalence to .MergeJoin()?

MaxElementsBy removal

I updated to the latest package and see MaxElementsBy has been removed. In the doc I see that the recommended method to use instead is PartialSortBy but no example is provided.

I want to return all of the items that share the maximum count (there can be more than one and I don't want to set a limit). So before I had code like:

var maxItems = items.MaxElementsBy(item => item.Value);

So now it looks like the code should be like the following to achieve the same results:

var maxItems = items.PartialSortBy(int.MaxValue, (item) => item.Value);

I switched to this package from MoreLinq as I agree with the idea of deprecating Linq methods that the common library adds. But in this case the base method has different functionality (MaxBy only returns one item). PartialSortBy with int.MaxValue was not intuitive to figure out but if it works the same I guess I will use it

Equivalent support for IAsyncEnumerable

For each current method, add an equivalent method for IAsyncEnumerables.

Progress:

Add async .Merge()

See morelinq/MoreLINQ#793

Some methods missing explanations for why not implemented in async

For example:

SuperLinq/README.md

Lines 141 to 146 in f52cca2

    
           | ToDataTable					  | ✔️ | ❌ | 
        
           | ToDelimitedString				  | ✔️ | ❌ | 
        
           | ToDictionary					  | ✔️ | ❌ | 
        
           | ToLookup						  | ✔️ | ❌ | 
        
           | Trace							  | ✔️ | ❌ | 
        
           | Transpose						  | ✔️ | ❌ |

These methods are not listed as obsolete in the sync versions; should there be backlog items for them?

Replace T4 code generation with a C# source generator

morelinq/MoreLINQ#799

Improve `Zip*` performance

Benchmarking shows that current code can be improved by up to 50% with separate versions for 2/3/4 inputs

#160
#161

Improve PartialSort

See morelinq/MoreLINQ#840

Reduced Allocation `Batch` and `Window`

Figure out a way to add a reduced (or zero) -allocation version of Batch and Window (and other buffer calls). Possibly by receiving an array or by allocating only a single array and passing it as a ReadOnlySpan<> to a projection method.

ZipMap

See morelinq/MoreLINQ#763

Add `List<T>` item finding methods

List<T> has some useful finding methods that should be implemented for IEnumerable<T>

IndexOf<T>(this IEnumerable<T> source, T value[, Index index])
LastIndex<T>(this IEnumerable<T> source, T value[, Index index])
FindIndex<T>(this IEnumerable<T> source, [Index index,] Func<T, bool> predicate)
FindLastIndex<T>(this IEnumerable<T> source, [Index index,] Func<T, bool> predicate)
Update (Last)IndexOf to proxy to Find(Last)Index

AreCollectionsSame

See morelinq/MoreLINQ#814

Take(Range)/ElementAt(Index)

Allow slicing an I(Async)Enumerable by a System.Range (see morelinq/MoreLINQ#748); ElementAt/Take implemented in .NET 6, but backport for IEnumerable

Mark Batch as obsolete due to Chunk

https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.chunk?view=net-6.0

`TestingSequence`

A review of all current unit tests should be taken to confirm that TestingSequence is being used everywhere.

Add async Traversal functions

TraverseBreadthFirst
TraverseDepthFirst
GetShortestPath

Possible error in `GetShortestPath`

I was using GetShortestPath for a certain online Christmas challenge, but it was returning unstable results. After switching to QuikGraph, my code worked great. Either I am using GetShortestPath wrong, or it has a bug. Could you help looking into it?

Here is an xUnit test demonstrating the error. It constructs a graph, shuffles the outgoing nodes, and computes the shortest distance from AA to UM. It can easily be seen that going through QT, the shortest distance is 3. However, it yields distances such as 6, 9 and 14 (and also 3).

using QuikGraph;
using QuikGraph.Algorithms;
using SuperLinq;
using Xunit;

namespace AdventOfCode.Tests;

public class GraphTests
{
    class Valve
    {
        public string Name { get; init; }
        public Valve[] Next { get; set; }
    }

    [Fact]
    public void Test()
    {
        var data = """
            EJ => MC
            WC => OW, RU
            NP => VR, KL
            AA => QT, AP, EZ, AK, XV
            VO => KM, RF, HS, LJ, IA
            CB => UI, UP
            TE => JT
            CZ => UP, OW
            LJ => DV, VO
            UP => SK, CB, CZ
            FP => OW, RE
            KM => SE, VO
            DV => LJ, UM
            FL => AH, TS
            VR => DM, TF, NP
            IA => VS, VO
            RF => VO, JF
            RT => UM, SE
            RU => AR, WC
            SE => GU, KM, CX, RT
            MC => EJ, AR
            TF => AH, VR
            CX => SE, TO
            GL => UY, KL, CY
            GU => SE, EZ
            VS => XN, IA
            EZ => AA, GU
            GK => FI, HZ
            JT => TE, XN
            DM => VR, HZ
            AR => UI, RU, MC
            XN => XP, JT, VS, GT, CY
            CY => XN, GL
            QT => UM, AA
            KL => GL, NP
            SK => XV, UP
            OW => CZ, WC, FP
            AK => AA, HS
            XV => AA, SK
            GT => XN, UM
            FI => JF, GK
            UY => JF, GL
            UM => DV, GT, RT, QT
            IQ => HZ, AH
            JF => RF, FI, UY, RE, TS
            TS => JF, FL
            AH => IQ, FL, TF
            HS => AK, VO
            HZ => IQ, DM, GK
            TO => CX
            XP => AP, XN
            AP => XP, AA
            RE => JF, FP
            UI => AR, CB
            """;

        var lines = data.Trim().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
        var nodes = new Dictionary<string, Valve>();

        // Create vertices
        foreach (var line in lines)
        {
            var name = line.Split(" => ")[0];
            nodes.Add(name, new Valve { Name = name });
        }

        // Create edges
        foreach (var line in lines)
        {
            var name = line.Split(" => ")[0];
            var outNodesNames = line.Split(" => ")[1].Split(", ");
            var outNodes = outNodesNames.Select(outName => nodes[outName]).ToArray();
            nodes[name].Next = outNodes;
        }

        // Compute shortest path a few times
        for (var i = 0; i < 1000; i++)
        {
            foreach (var node in nodes.Values)
            {
                node.Next = node.Next.RandomSubset(node.Next.Length).ToArray();
            }

            // Expect AA -> QT -> UM
            Assert.Equal(3, SuperEnumerable.GetShortestPath<Valve, int>(
                nodes["AA"], 
                (v, c) => v.Next.Select(n => (n, 1)),
                nodes["UM"]
            ).Count());
        }
    }
}

Improve `ZipLongest` Performance

Benchmarking shows that current code can be improved by up to 50% with separate versions for 2/3/4 inputs

Correct `WindowImpl` behavior

See #156

Restore `EquiZip`

EquiZip was removed as being redundant to Enumerable.Zip; however, Enumerable.Zip has behavior matching ZipShortest, not EquiZip. EquiZip should be restored as an operator.

ZipShortest should be reviewed further as an independent operator or proxy function for corelib Enumerable.Zip

ToArray() and ToList() with length

I created a PR (#70) about simple overload for ToArray() and ToList() with lenght parameter. With lenght we can avoid multiple creations of array/list when rewriting IEnumerable to these collections.

System.Interactive

Reference System.Interactive and remove duplicate methods

RankBy and DenseRankBy

See morelinq/MoreLINQ#826

Rank
RankBy

AdjacentDistinctBy()

See morelinq/MoreLINQ#836

Add .SortedMergeBy()

Add ExtremaElementsBy

MaxElementsBy
MinElementsBy

Add `GetShortestPath` overload

It would be nice to have another overload of GetShortestPath/GetShortestPathCost that receives a Func<TState, bool> predicate instead of a TState end for identifying the end position.

Migrate generators to Scriban

`.WithIndex()` to easily get an index in `foreach`

Credit to https://thomaslevesque.com/2019/11/18/using-foreach-with-index-in-c/

It's a small convenience, but I thought I'd suggest adding .WithIndex() to this lib in case you like it.

using System.Linq;
...

public static IEnumerable<(T item, int index)> WithIndex<T>(this IEnumerable<T> source)
{
    return source.Select((item, index) => (item, index));
}

foreach (var (item, index) in collection.WithIndex())
{
    DoSomething(item, index);
}

Improve `ZipShortest` performance

Benchmarking shows that current code can be improved by up to 50% with separate versions for 2/3/4 inputs

Reliance on https://github.com/dotnet/reactive - is this good? is this temporary?

Newbie question...

I've recently started to work with IAsyncEnumerable<T>, and found the lack of ToListAsync, SelectAsync, FirstOrDefaultAsync etc. in official .NET 6 a little surprising.

I then looked into System.Linq.Async via https://github.com/dotnet/reactive and found it quite impenetrable, and ended up writing my own, simple ToListAsync method to satisfy my immediate, simple needs.

Mark Heath's excellent article then helped me understand System.Linq.Async a lot better, so I might use that package next time. But I also saw a link to this repo, which initially looked promising re. providing async versions of familiar LINQ methods. And there's documentation!

But... the docs don't include ToListAsync, SelectAsync, FirstOrDefaultAsync etc. How could this be?

Then I found...

<PackageReference Include="System.Interactive.Async" Version="6.0.1" />
<PackageReference Include="System.Linq.Async" Version="6.0.1" />

:-)

I wonder if this reliance on https://github.com/dotnet/reactive is a good thing... Perhaps it's just a temporary thing(?) It seems to me that we are now reliant on another package, with its own issues (bugs, lack of docs).

In the fullness of time it might be nice if SuperLinq was a one-stop shop, in charge of its own destiny, without the reactive dependency.

If the reactive dependency is likely to continue for a while, should this be signposted on the front page of the repo?

Restore Tests for `MinItemsBy`/`MaxItemsBy`

Restore netstandard 2.0 support

This will require selectively hiding methods with Index/Range parameters

Add Range method with step

See (morelinq/MoreLINQ#827)

`.CopyTo()`

In order to improve allocations (ex: ArrayPool.Rent()) or to copy data to a specific pre-existing place, it may be useful to copy a sequence. Following APIs to be implemented:

void CopyTo<T>(this IEnumerable<T> source, Span<T> span); 
void CopyTo<T>(this IEnumerable<T> source, IList<T> list);
void CopyTo<T>(this IEnumerable<T> source, IList<T> list, Index index);

Semantics:

void CopyTo<T>(this IEnumerable<T> source, IList<T> list); will throw an exception if the source is longer than array. If source is shorter than array, then the remainder of array will be untouched.

	\| ToDataTable \| ✔️ \| ❌ \|
	\| ToDelimitedString \| ✔️ \| ❌ \|
	\| ToDictionary \| ✔️ \| ❌ \|
	\| ToLookup \| ✔️ \| ❌ \|
	\| Trace \| ✔️ \| ❌ \|
	\| Transpose \| ✔️ \| ❌ \|

viceroypenguin / superlinq Goto Github PK

superlinq's Introduction

👋 Hello, folks!

✍ Blog & Writing

🔧 Technologies & Tools

📈 GitHub Stats

superlinq's People

Contributors

Stargazers

Watchers

Forkers

superlinq's Issues

Recommend Projects

Recommend Topics

Recommend Org