How to nest a product type Records<F> where F is a higher-kinded type so that using 2 selectors for type A, B on type Records<Records<Reader>> returns Reader<A, B>

[ArsenalAlex108]

Hi, I'm have been taking a stab at FP; recently I have used the pattern below, inspired by the Visitor pattern, to constraint generic type parameters to a fixed set by requiring a selector that can pull a property from the given record type:

public readonly record struct TypeSet<F>
(
	K<F, TypeA> LiftedTypeA,
	K<F, TypeB> LiftedTypeB
);

public interface TypeSetElementSelector<T>
{
	K<F, T> Select<F>(TypeSet<F> typeSet);
}

public static class TypeSet
{
	public static TypeSetElementSelector<TypeA> SelectTypeA { get; }
	public static TypeSetElementSelector<TypeB> SelectTypeB { get; } 
}

Usage example:

Reader<Env, IO<Unit>> PrintElements<T>(TypeSetElementSelector<T> selector)
=>
    from typeSet in Reader.asks<Env, TypeSet<Seq>>(e => e.TypeSet)
    select lift(() => 
    Console.WriteLine(
        string.Join(
            ", ", 
            selector.Select(typeSet).As()
            )
        )
    )
    .ToIO();

void Test()
{
    TypeSet<Seq> typeSet = new(
        Seq<TypeA>(new(1), new(2)),
        Seq<TypeB>(new(3), new(4))
    );

    PrintElements(TypeSet.SelectTypeA)
        .Run(new Env(typeSet))
        .Run();
}

I have been wondering how to nest TypeSet<F> together to implement method Reader<A, B> GetReader(TypeSet<TypeSet<Reader>> typeSet, TypeSetElementSelector<A> selectorA, TypeSetElementSelector<B> selectorB)?

[ArsenalAlex108]

Nevermind, I solved it. The compiler enforce that all combinations be provided:

public readonly record struct TypeSet<F>
(
    K<F, TypeA> LiftedTypeA,
    K<F, TypeB> LiftedTypeB
);

public readonly record struct BiTypeSet<F, P>
(
    K<F, P, TypeA> LiftedTypeA,
    K<F, P, TypeB> LiftedTypeB
) : K<BiTypeSet<F>, P>;

public sealed class BiTypeSet<F>;
public abstract class TypeSetElementSelector<T>
{
    private protected TypeSetElementSelector() { }
    public abstract K<F, T> Select<F>(TypeSet<F> typeSet);
    public abstract K<F, P, T> Select<F, P>(BiTypeSet<F, P> typeSet);
}
public static class TypeSet
{
    public static TypeSetElementSelector<TypeA> SelectTypeA { get; } = new TypeASelector();
    public static TypeSetElementSelector<TypeB> SelectTypeB { get; } = new TypeBSelector();

    private class TypeASelector : TypeSetElementSelector<TypeA>
    {
        public override K<F, TypeA> Select<F>(TypeSet<F> typeSet) => typeSet.LiftedTypeA;

        public override K<F, P, TypeA> Select<F, P>(BiTypeSet<F, P> typeSet) => typeSet.LiftedTypeA;
    }

    private class TypeBSelector : TypeSetElementSelector<TypeB>
    {
        public override K<F, TypeB> Select<F>(TypeSet<F> typeSet) => typeSet.LiftedTypeB;

        public override K<F, P, TypeB> Select<F, P>(BiTypeSet<F, P> typeSet) => typeSet.LiftedTypeB;
    }

    public static BiTypeSet<F, A> As<F, A>(this K<BiTypeSet<F>, A> typeSet)
    {
        return (BiTypeSet<F, A>)typeSet;
    }

    internal static void Test()
    {
        TypeSet<Seq> typeSet = new(
            Seq<TypeA>(new(1), new(2)),
            Seq<TypeB>(new('3'), new('4'))
        );

        TypeSet<BiTypeSet<Reader>> nested = new(
            new BiTypeSet<Reader, TypeA>(
                new ReaderWrapper<TypeA, TypeA>(x => x), 
                new ReaderWrapper<TypeA, TypeB>(x => new TypeB((char)x.x))),
            new BiTypeSet<Reader, TypeB>(
                new ReaderWrapper<TypeB, TypeA>(x => new TypeA(x.y)), 
                new ReaderWrapper<TypeB, TypeB>(x => x))
        );

        var selectedTypeA = SelectTypeA.Select(nested).As();
        var finalSelectedTypeA = SelectTypeA.Select(selectedTypeA).As().ToReader();
    }
}

[louthy]

I see you answered your own question, but I'm not entirely sure what the problem is that you're trying to solve?

I see you're using Reader<Env, IO<Unit>>, which kinda makes me think you're trying to solve the monad-transformer problem with monads. Are you aware of the ReaderT<Env, M, A> monad-transformer? If not, then you can use ReaderT<Env, IO, A> to get a type that is a composition of both Reader and IO.

Monad-transformers are covered in my Higher Kinds series. I may be way off, but I thought I'd mention it just in case.