Has<M, Env, VALUE> vs. IHas<RT>

[flachman03]

Hi all! I've been using Language-Ext in production for about 6 months and now about half my team uses it as well. It's been amazing for our code quality so first just a thank you.

Now my question - I'm a bit confused on how to use the Has<M, Env, VALUE> and what benefit it provides vs. my IHas implementation. Here is what I've implemented before I realized the Has<> existed.

public interface IHas<RT>
{
    RT Value { get; }
}

public static class IHasExtensions
{
    public static TDependency Get<TDependency, RT>(this RT runtime)
        where RT : struct, IHas<TDependency>
    {
        return runtime.Value;
    }
}

Using it would look like this. Where the runtime env dependencies are defined on the function level rather that the class or record.

public static Eff<RT, Address> GetValidAddress<RT>(string address)
        where T : struct, IHas<IHttpClientFactory> =>
        from payload in AddressValidationPayload.ParseAddress<RT>(address)
        from result in payload.ValidateAddress<RT>()
        select result;

Getting a specific dependency when the function requires multiple looks like this

public static Eff<RT, RESULT> Execute<RT>(REQUEST request)
        where RT :
        struct,
        IHas<IHttpClientFactory>,
        IHas<LogQueue> =>
        from rt in runtime<RT>()
        from q in rt.Get<LogQueue, RT>()
        ....

My first thoughts are possibly that Has<> handles disposing in a better way than I'm handling. Would anyone be able to show me a better way of handling this with Has<> or help me understand the functional benefits of the pattern that's already been implemented?
I've looked through the discussions for this but if I missed it please let me know.

[aloslider]

1. In your version it makes no sense for RT part: it's literally saying that IHas<T> is an interface that requires to have implementation a getter of type T, what does RT (runtime) have to do with anything?
2. Has<M, TRAIT> and Has<M, ENV TRAIT> not only get the value, but also wrap it in M.

3. Getting a specific dependency when the function requires multiple looks like this

Is that so? Get extension method returns just TDependency. Your example can't be compiled:

public static Eff<RT, RESULT> Execute<RT>(REQUEST request)
        where RT :
        struct,
        IHas<IHttpClientFactory>,
        IHas<LogQueue> =>
        from rt in runtime<RT>() // gets rt of type RT from Eff<RT, RT>, so the context monad is Eff
        from q in rt.Get<LogQueue, RT>() // rt.Get returns RT, but should return Eff<RT> to satisfy "linq expression monad context"
        ....

4. My first thoughts are possibly that Has<> handles disposing in a better way than I'm handling.

It doesnt track and release disposable, IO and Eff do.

5. I've looked through the discussions for this but if I missed it please let me know.

I can remember only this announcement talking about Has trait. Also didn't know there is Mutable one.

[flachman03]

1. Thank you for the link. While I have looked at the Has Trait, the announcement was what I needed to finally put the last piece together to get how it works.
2. I didn't know Mutable existed either. What is the benefit of that over using RWST if mutating state is necessary?
3. Let me provide you a more robust example of what I was doing. Hopefully seeing the two implementations could help someone else understand a bit better if they are thinking the same as I did.
4. Is there a situation where implementing the "Has" contract for what the runtime guarantees should be on the individual method as opposed to the class?
5. The announcement described needing to solve for multiple traits leading to ambiguous RT.Ask. The IHas.Get<TDependency, RT> was my solution when I ran into the same issue. I hope this makes sense but using the provided trait makes more sense now that I know how it works and a bit more about ReaderT (still not much).

public class HasTests
{
    [Fact]
    public void TestOne()
    {
        var mockS3 = new Mock<IAmazonS3>();
        var mockSqs = new Mock<IAmazonSQS>();
        mockS3.Setup(x => x.GetPreSignedURL(It.IsAny<GetPreSignedUrlRequest>())).Returns("Test-URL");
        mockSqs.Setup(x => x.SendMessageAsync("", "", default)).ReturnsAsync(new SendMessageResponse());
        
        var runtime = new RuntimeOne(mockS3.Object, mockSqs.Object);
        
        var result = TestFunctions.Combined<RuntimeOne>().Run(runtime);
    }

    [Fact]
    public void TestTwo()
    {
        var mockS3  = new Mock<IAmazonS3>();
        var mockSqs = new Mock<IAmazonSQS>();
        mockS3.Setup(x => x.GetPreSignedURL(It.IsAny<GetPreSignedUrlRequest>())).Returns("Test-URL");
        mockSqs.Setup(x => x.SendMessageAsync("", "", default)).ReturnsAsync(new SendMessageResponse());
        
        var runtime = new RuntimeTwo(new RuntimeTwoEnv(mockS3.Object, mockSqs.Object));
        
        var result = TestFunctionsTwo<RuntimeTwo>.Combined().Run(runtime);

    }
    
}

public struct RuntimeOne(IAmazonS3 s3, IAmazonSQS sqs) : 
    IHas<IAmazonS3>, 
    IHas<IAmazonSQS>
{
    IAmazonS3 IHas<IAmazonS3>.Value => s3;

    IAmazonSQS IHas<IAmazonSQS>.Value => sqs;
}


public record RuntimeTwoEnv(IAmazonS3 s3, IAmazonSQS sqs);
public record RuntimeTwo(RuntimeTwoEnv Env) :
    Has<Eff<RuntimeTwo>, IAmazonS3>,
    Has<Eff<RuntimeTwo>, IAmazonSQS>

{
    static K<Eff<RuntimeTwo>, IAmazonS3> Has<Eff<RuntimeTwo>, IAmazonS3>.Ask => 
    liftEff<RuntimeTwo, IAmazonS3>(rt => rt.Env.s3);

    static K<Eff<RuntimeTwo>, IAmazonSQS> Has<Eff<RuntimeTwo>, IAmazonSQS>.Ask =>
    liftEff<RuntimeTwo, IAmazonSQS>(rt => rt.Env.sqs);
}

public static class TestFunctions
{
    public static Eff<RT, string> GetUrl<RT>()
        where RT : IHas<IAmazonS3> =>
        from rt in runtime<RT>()
        from result in liftEff(() => rt.Value.GetPreSignedURL(new GetPreSignedUrlRequest()))
        select result;

    public static Eff<RT, SendMessageResponse> Send<RT>()
        where RT : IHas<IAmazonSQS> =>
        from rt in runtime<RT>()
        from result in liftEff(() => rt.Value.SendMessageAsync("", "", default))
        select result;
    
    public static Eff<RT, Unit> Combined<RT>()
    where RT : IHas<IAmazonS3>, IHas<IAmazonSQS> =>
        from url in GetUrl<RT>()
        from message in Send<RT>()
        select unit;
    
    public static Eff<RT, Unit> AltCombined<RT>()
        where RT : struct, IHas<IAmazonS3>, IHas<IAmazonSQS> =>
        from rt in runtime<RT>()
        let s3 = rt.Get<IAmazonS3, RT>()
        let sqs = rt.Get<IAmazonSQS, RT>()
        from url in liftEff(() => s3.GetPreSignedURL(new GetPreSignedUrlRequest()))
        from message in liftEff(() => sqs.SendMessageAsync("", ""))
        select unit;
}

public record TestFunctionsTwo<RT> 
    where RT : 
    Has<Eff<RT>, IAmazonS3>,
    Has<Eff<RT>, IAmazonSQS>
{
    private static K<Eff<RT>, IAmazonS3> _s3 => Has<Eff<RT>, RT, IAmazonS3>.ask;
    private static K<Eff<RT>, IAmazonSQS> _sqs => Has<Eff<RT>, RT, IAmazonSQS>.ask;

    public static Eff<RT, string> GetUrl() => 
        from s3 in _s3.As()
        from url in liftEff(() => s3.GetPreSignedURL(new GetPreSignedUrlRequest()))
        select url;

    public static Eff<RT, SendMessageResponse> Send() =>
        from sqs in _sqs.As()
        from message in liftEff(() => sqs.SendMessageAsync("", "", default))
        select message;
    
    public static Eff<RT, Unit> Combined() =>
        from url in GetUrl()
        from message in Send()
        select unit;
}

public static class IHasExtensions
{
    public static TDependency Get<TDependency, RT>(this RT runtime)
        where RT : struct, IHas<TDependency>
    {
        return runtime.Value;
    }
}

public interface IHas<T>
{
    T Value { get; }
}

[aloslider]

1. I undestand what you are trying to do with interface, but again: getting a dependencies from a runtime usually a side-effect that we usually wrap to IO or Eff. I mean, you don't quite need a runtime that should implement, say, Has<HttpClient> when you can just create a simple static function GetHttpClient in some Helpers static class, where you configure and return your client. The way you use your interface and extension method is pointless and just make things more complex than it needs to be: your extension method doesn't add anything to the codeflow, except of struct constraint to RT (that is strange for v5, as it now uses static abstract feature added in .NET8 instead of default(RT) trick that was used in v4 to make zero-allocations when getting injected runtime's properties)
2. In your initial example you wrote:

from rt in runtime<RT>()
from q in rt.Get<LogQueue, RT>() // this obviously doesn't compile

but now you fixed it with let=rt.Get<LogQueue, RT>(), that is totally compilable, so I guess you just made a typo in OP that confused me.

3. I didn't know Mutable existed either. What is the benefit of that over using RWST if mutating state is necessary?

As I said, I don't know as well 😄. From this announcement:

The Mutates trait now derives from Has and provides a Mutable property that exposes an Atom
The idea being that your 'runtime' environment contains mutable values that can be atomically updated via Mutates
But, you can also access an atomic snapshot via Ask
This, I think, is the best way to allow for mutation in a 'readable' environment

4. The IHas.Get<TDependency, RT> was my solution when I ran into the same issue

I understand, but with this solution you are locking your self to using Eff monad and depriving youself from using a generic outer monad with runtime reading capabilities. Not saying it's bad or not working, just saying you should understand consequences it brings.

5. Where the runtime env dependencies are defined on the function level rather that the class or record

Also, I still don't understand why would you prefer copypasting constraints for each function in a module where you can declare it on the module itself once for all its functions.

[louthy]

The Newsletter sample demos the functionality in real world setting: https://github.com/louthy/language-ext/tree/main/Samples/Newsletter/Newsletter