BREAKING: New LanguageExt.Transformers package

[louthy]

The transformers extensions, which are a big set of T4 templates for generating extension methods for nested monadic types have now been broken out into their own package: LanguageExt.Transformers

If you use the following functions: BindT, MapT, FoldT, FoldBackT, ExistsT, ForAllT, IterT, FilterT, PlusT, SubtractT, ProductT, DivideT, SumT, CountT, AppendT, CompareT, EqualsT, or ApplyT - then you will get compile errors, and will need to add a reference to the LanguageExt.Transformers package.

I've done this for a couple of reasons:

• There's been an ongoing concern from a number of users of this library about the size of the LanguageExt.Core library. This change takes the Core package from 3,276 kb to 2,051 kb.
  • The Core library will always be quite chunky because of the sheer amount of features, but the transformer extension methods definitely aren't always needed, so breaking them out made sense
• I suspect issues around the .NET ReadyToRun usage will be alleviated somewhat by this change.
  • I can't prove this, but the C# tooling has had a hard time with those 10,000s of generated extension methods before - so rather than wait for Microsoft to fix their tooling, I'm trying to be proactive and see if this will help.

The main transformer extensions that remain in the Core library are:

• Traverse
• Sequence

These are so heavily used that I believe moving them out into the Transformers library would mean everyone would be obliged to use it, and therefore it wouldn't achieve anything. There may be an argument for bringing BindT and MapT back into the core at some point. I will see how this plays out (it wouldn't be a future breaking change if that were the case).

Any problems, please report via the Issues in the usual way.

---

This discussion was created from the release BREAKING: New LanguageExt.Transformers package.

[BrunoJuchli]

This function is now also gone from the core package:

public static IEnumerable<Either<L, B>> Select<L, A, B>(this IEnumerable<Either<L, A>> ma, Func<A, B> f) =>
        SeqTrans<MEnumerable<Either<L, A>>, IEnumerable<Either<L, A>>, MEither<L, A>, Either<L, A>, A>
            .Inst.Map<MEnumerable<Either<L, B>>, IEnumerable<Either<L, B>>, MEither<L, B>, Either<L, B>, B>(ma, f);

It used to be part of HKT.Extensions.cs.
It looks like it's gone for good and also not part of the transformers package (at least I can't find it in 4.2).
The async variant still exists in HKT.SyncAsync.Extensions.cs

---

I replaced it with:
someEnumerable
.Select(x =>
x.Map(right => map the right case)));

---

I noticed there's extensions for IEnumerable<Either<L,R>>:

• MapLeftT
• BiMapT

but the Map function for only mapping R is missing? Or am I misunderstanding something here?

[louthy]

@BrunoJuchli Thanks for the heads up, I'll take a look this evening.

[louthy]

It does appear to be generated in the Transformers source:

Make sure you're doing using LanguageExt to bring the extensions in. If that's not the problem, please let me know which version you're running. Either way, it should be deployed in the next release if it's missing from an old release.

but the Map function for only mapping R is missing? Or am I misunderstanding something here?

It's just MapT as that's the primary bound value of the Either functor.

[BrunoJuchli]

Thanks. I actually haven't tried the transformers package but just looked for the method in the source of the 4.2.0 tag (which is the latest 4.2 tag i could find in the repo). Sorry if you had to go looking for the method for nothing!

I just rewrote the code as this was the only dependency I have on the transformers package and want to try the ready for run stuff in order to speed up my Azure.Functions deployment.

It's just MapT as that's the primary bound value of the Either functor.

There's no MapT for IEnumerable<Either<L,R>>:

.. and the Map function is doing something else (it's basically just a redirect to IEnumerable<T>.Select via List.Map)

[louthy]

MapT is in transformers too. Anything with a T on the end of the name basically. There's a chance that the T4 generators hadn't run properly for one of the deployments (after the big refactor). I can see them in the source, so anything missing should be in the next release.

But yeah, you can absolutely just roll your own extensions for the types you need:

    IEnumerable<Either<L, B>> MapT<L, A, B>(this IEnumerable<Either<L, A>> mma, Func<A, B> f) =>
        mma.Map(ma => ma.Map(f));

I am going to look at writing a Source Generator for pairs of monadic types, so you can declare which pairs of types you want transformers for, and it generates the code (instead of the 20,000 extension methods created by the T4 templates in the Transformers project). This will work for types you create too (as long as they fit the patterns).