Lens<S,T,A,B>

[ThereIsNoPie]

Hey, I've noticed that the core library has Lens<A,B> but hasn't implemented Lens<S,T,A,B>.

I've got:

• types X, Y, Z
• Func<X,Y>
• Func<Y,Z>
• Func<Z, Func<X,X>>

So essentially I want a Lens<X, X, Y, Z>.

I'm considering trying to implement this myself. I'm not super experienced so just checking if there's any obvious reasons why this might be a bad idea. e.g.:

• Would Language-ext 5.0 deprecate this work?
• Were there any complications in C# that made Lens<S,T,A,B> hard to implement (which is why only Lens<A,B> exists)?
• Is there an easier way to get my desired functionality (i.e. Lens<X,X,Y,Z> -> Func<Y,Z> -> X -> X)

Thanks.

Update:

I wrote a version that copies the existing Lens<A,B> (plus a couple of concat functions)

    public readonly struct Lens<S, T, A, B>
    {
        public readonly Func<S, A> Get;
        public readonly Func<B, Func<S, T>> SetF;

        Lens(Func<S, A> get, Func<B, Func<S, T>> set)
        {
            Get = get;
            SetF = set;
        }

        public T Set(B value, S cont) => SetF(value)(cont);

        public static Lens<S, T, A, B> New(Func<S, A> Get, Func<B, Func<S, T>> Set) =>
            new Lens<S, T, A, B>(Get, Set);

        public Func<S, T> Update(Func<A, B> f)
        {
            var self = this;
            return s =>
            {
                var a = self.Get(s);
                var b = f(a);
                return self.Set(b, s);
            };
        }

        public T Update(Func<A, B> f, S value) => Set(f(Get(value)), value);
    }

I assume there's an easy way to define Lens<A,B> in terms of Lens<S,T,A,B> but I can't seem to find it. The following doesn't work

public readonly struct Lens<A, B> : Lens<A, A, B, B> { }

[louthy]

• Would Language-ext 5.0 deprecate this work?

Eventually, yes, but lenses are not quite on my radar right now. If you're thinking of doing a PR then I would advise against it for the time being, as I am not accepting any PRs until my v5 work is done and merged into main.

• Were there any complications in C# that made Lens<S,T,A,B> hard to implement (which is why only Lens<A,B> exists)?

Probably, but I really don't remember what they were. But now that we have proper support for higher-kinds the whole implementation could be revisited.

Is there an easier way to get my desired functionality (i.e. Lens<X,X,Y,Z> -> Func<Y,Z> -> X -> X)

Something like this would be the equivalent to the Haskell defintions:

// type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t
public record Lens<F, S, T, A, B>(Func<Func<A, K<F, B>>, Func<S, K<F, T>>> runLens)
    where F : Functor<F>;

// type Lens s a = Lens s s a a
public record Lens<F, S, A>(Func<Func<A, K<F, A>>, Func<S, K<F, S>>> runLens) 
    : Lens<F, S, S, A, A>(runLens) 
    where F : Functor<F>;

You could construct them like so:

public static Lens<F, S, T, A, B> lens<F, S, T, A, B>(
    Func<S, A> get,
    Func<S, Func<B, T>> set)
    where F : Functor<F> =>
    new (afb => s => F.Map(set(s), afb(get(s))));
    
public static Lens<F, S, A> lens<F, S, A>(
    Func<S, A> get,
    Func<S, Func<A, S>> set)
    where F : Functor<F> =>
    new (afb => s => F.Map(set(s), afb(get(s))));

Which is the equivalent of:

lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
lens sa sbt afb s = sbt s <$> afb (sa s)

This using the v5 functor trait. I haven't looked into how much further you could get by following this approach.

I assume there's an easy way to define Lens<A,B> in terms of Lens<S,T,A,B> but I can't seem to find it. The following doesn't work
public readonly struct Lens<A, B> : Lens<A, A, B, B> { }

You need the lenses to be non-value types for that to work, struct doesn't allow inheritance.