Support K<F,A> on external types

[bmazzarol-bunnings]

It might be an idea to provide some wrapper types and very simple functions that can lift well known external types into K<F,A>.

To allow for supporting this on System types for example my trait instance for System.Array below.

There is a cost for allocating the wrapper; but the rest is as per the standard, once Lift is called on the type.

public interface K<F, A>;

public interface Functor<F> where F : Functor<F>
{
    public static abstract K<F, B> Map<A, B>(K<F, A> list, Func<A, B> f);
}

public sealed record ArrayWrapper<A>(A[] Array) : K<Array, A>
{
    public static implicit operator A[](ArrayWrapper<A> wrapper) => wrapper.Array;
}

public class Array : Functor<Array>
{
    public static A[] As<A>(K<Array, A> array) => (ArrayWrapper<A>)array;

    public static K<Array, B> Map<A, B>(K<Array, A> array, Func<A, B> f)
    {
        return new ArrayWrapper<B>([..As(array).Select(f).ToArray()]);
    }
}

public static class MappableExtensions
{
    public static K<Array, A> Lift<A>(this A[] array) => new ArrayWrapper<A>(array);

    public static K<F, B> Map<F, A, B>(this K<F, A> fa, Func<A, B> f)
        where F : Functor<F> =>
        F.Map(fa, f);
}

public static class Usage
{
    public static void Test()
    {
        var array = new[] { 1, 2, 3 };
        var lifted = array.Lift();
        var mapped = lifted.Map(x => x + 1);
        var result = Array.As(mapped);
        Console.WriteLine(string.Join(", ", result));
    }
}

[louthy]

Agreed. I've already started this process:

• EnumerableM
• StringM

StringM also inherits IdentifierLike which is a domain modeling trait that I'm prototyping right now (based on this article). Others include AmountLike, LocusLike, QuantityLike, VectorSpace, and DomainType. Still early days on that one.

In terms of system array, you can use the Arr<A> type to wrap up the array, although it is designed to be immutable, so not sure if it's entirely suited.