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.

[ThereIsNoPie]

I'm running into issues because for the definition below because "F" is constrained at time of creation of the lens.

public record Lens<F, S, T, A, B>(Func<Func<A, K<F, B>>, Func<S, K<F, T>>> runLens)
    where F : Functor<F>;

Below is invalid syntax

public record Lens<S, T, A, B>(Func<Func<A, K<F, B>>, Func<S, K<F, T>>> where F : Functor<F> runLens);

I've ended up with this definition but it's obviously lacking.

public record LensF<S, T, A, B>(Func<S, A> get, Func<S, Func<B, T>> set)
{
    public K<F, T> RunLens<F>(Func<A, K<F, B>> afb, S s)
        where F : Functor<F>
    {
        return F.Map(set(s), afb(get(s)));
    }
}

Question:
I'm working with the following and so I've defined LensM. (and a function LensF -> LensM). Does a similar construct already exist (even in the Haskell base library)? Or is there an idiomatic other way to handle nested optional fields and optional functions?

public record ExampleRecord(Option<ExampleField> Field);

public record LensM<M, S, T, A, B>(Func<S, K<M, A>> get, Func<S, Func<B, K<M, T>>> set)
    where M : Monad<M>
{
    public K<M, T> RunLens(Func<A, K<M, B>> afb, S s)
    {
        return from a in get(s) from b in afb(a) from t in set(s)(b) select t;
    }
}

[louthy]

You could use inheritance to avoid having multiple Lens types to handle. So, first create an abstract base-record that can represent any lens:

public abstract record Lens<F, S, T, A, B>
{
    public abstract K<F, T> Run(Func<A, K<F, B>> afb, S s);
}

Then create a private derived lens-type for the functor:

record LensFunctor<F, S, T, A, B>(Func<S, A> get, Func<S, Func<B, T>> set) : Lens<F, S, T, A, B>
    where F : Functor<F>
{
    public override K<F, T> Run(Func<A, K<F, B>> afb, S s) => 
        F.Map(set(s), afb(get(s)));
}

And one for the monad:

record LensMonad<M, S, T, A, B>(Func<S, K<M, A>> get, Func<S, Func<B, K<M, T>>> set) : Lens<M, S, T, A, B>
    where M : Monad<M>
{
    public override K<M, T> Run(Func<A, K<M, B>> afb, S s) =>
        from a in get(s)
        from b in afb(a)
        from t in set(s)(b)
        select t;
}

Now you can create a static class with constructor functions in and they can all return the base Lens<F, S, T, A, B>:

public static class MkLens
{
    public static Lens<F, S, T, A, B> Functor<F, S, T, A, B>(Func<S, A> get, Func<S, Func<B, T>> set) 
        where F : Functor<F> =>
        new LensFunctor<F, S, T, A, B>(get, set);
    
    public static Lens<M, S, T, A, B> Monad<M, S, T, A, B>(Func<S, K<M, A>> get, Func<S, Func<B, K<M, T>>> set) 
        where M : Monad<M> =>
        new LensMonad<M, S, T, A, B>(get, set);    
}

These constructor functions can be where the, per lens type, constraints come in.

Does that help?

[ThereIsNoPie]

Sorry for the slow response. Here's the crux of my confusion.

In Haskell, Lens is defined like this:

type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t

This means if I have someLens :: Lens s t a b. Then I can give it ANY functor and it'll give me a function (a -> f b) -> s -> f t

I can't seem to express the same thing in c#. In c# I need to create Lens<F,S,T,A,B> someLens. But at this point someLens is already constrained to a SPECIFIC functor.

I think (but could be wrong) that if I can find a way to express Lens<S,T,A,B> (without the F), I can solve my Monad problem (and a couple of other problems) more elegantly.

[hermanda19]

I believe the only way to define something in C# equivalent to forall f. is to use generic abstract methods (inside either abstract class or interface).

interface ILens<S, T, A, B>
{
    // F is chosen by caller, and therefore the implementor of ILens<S, T, A, B> 
    // must implement this method to work for any type F.
    Func<S, K<F, T>> Run<F>(Func<A, K<F, B>> f) 
        where F : Functor<F>;
}

You could also modify this interface so that Run<F> is static abstract.