Flattening K<M, Fin<T>> where M : Fallible<M>

[glendonjklassen]

Hi there,

I'm adapting the code in the Newsletter sample to create a Cosmos DB client wrapper to get a better feel for the new HKTs in v5 (which are awesome - thank you!) and I'm trying to adapt the following code, which works with an Option<T>:

public record Config(
    string MembersFolder,
    string TemplateFolder,
    string LettersFolder,
    string SiteUrl,
    int FeatureImageWidth,
    string ContentApiKey,
    Option<string> SendGridApiKey
);   
// ...
public static K<M, string> sendGridApiKey =>
        from k in configIO.Map(t => t.SendGridApiKey)
        from _ in when(k.IsNone, error<M>((Error)"SendGrid key not set.  No emails will be sent"))
        select (string)k;

To work with a Fin<T>, so something like:

public record SampleConfig(
    // for illustration only; I'm getting my value from somewhere that can have different kinds of errors
    // so wanted to use Fin instead of Option
    Fin<string> SendGridApiKey
    // ...
);   
// ...
public static K<M, string> sendGridApiKey =>
        from k in configIO.Map(t => t.SendGridApiKey)
        from _ in when(k.IsFail, error<M>((Error)"SendGrid key not set.  No emails will be sent"))
        //                                        ^^^here I want to pull in the error from the Fin if it fails
        select (string)k;

Here is the (non-compiling) code I'm working with:

public static class CosmosM<M, RT>
    where RT :
    Has<M, CosmosIO>
    where M :
    Monad<M>,
    Fallible<M>
{
    public static readonly K<M, CosmosIO> cosmos = RT.Ask;

    public static K<M, PartitionKey> partitionKey(List<string> partitionKeys)
    {
        return from k in cosmos.Map(a => a.PartitionKey(partitionKeys))
               from _ in when(k.IsNone, error<M>((Error)"Invalid partition key(s) provided"))
               select (PartitionKey)k;
    }

    public static K<M, QueryDefinition> queryDefinition(string query, Dictionary<string, DbQueryParameter> queryParameters)
    {
        return from t in  cosmos.Map(a => a.QueryDefinition(query, queryParameters))
               select t;
        //               ^ problems converting a K<M, Fin<T>> to a T
    }
}

What I want to do is something like cosmos.Map(a => a.QueryDefinition(query, queryParameters)).Map(a => a.Kind()).Flatten() since this is a K<M,K<Fin, QueryDefinition>> which my gut says should be flattenable if M : Fallible<M>.

Would someone be able to point me in the right direction? Maybe I'm going about this the wrong way - I am quite new to all of this.

Thank you so much for your time!

[louthy]

Flatten is monadic, not fallible, so there's no automatic way of flattening two different monad-types.

But, because Fin supports explicit casts to Error (and the when predicate has already tested that the Fin is in a Fail state), you should be able to just cast the k to Error

public static K<M, string> sendGridApiKey =>
    from k in configIO.Map(t => t.SendGridApiKey)
    from _ in when(k.IsFail, error<M>((Error)k)
    select (string)k;

There's potentially a way to do a natural-transformation between K<Fin, A> -> K<M, A> when M is Fallible, but right now none of the interfaces support that (although I am adding natural-transformations soon).

By the way, I'd be slightly wary of going all in with the K types like I did in the Newsletter sample. More than anything it was a proof-of-concept that the whole traits thing works. The key limitation is that because K<F, A> is an interface, it doesn't support any operators (like |, >>, etc). There are fluent-method equivalents, so taking the super-generic approach is still fully usable. But, I tend to find the operators are very useful, so prefer to work with concrete types more.

However, having said that, for reusable library components, like database access, it does give complete abstraction and allows the lifting into other monadic types. So there is that!

YMMV of course.

[glendonjklassen]

Thanks for the answer and the additional context. Much appreciated!

[glendonjklassen]

Just an update: when I try to run the code as above, the compiler allows the code but at runtime I get System.InvalidCastException: Specified cast is not valid. when the Fin is a Succ. (It works fine if the Fin is a Fail.)

Full stacktrace:

System.InvalidCastException: Specified cast is not valid.
   at LanguageExt.Fin.Succ`1.get_FailValue()
   at Cavallo.FunctionalCore.CosmosM`2.<>c.<queryDefinition>b__2_1(Fin`1 qd) in C:\elided\directories\MyMonad.cs:line 34
   at LanguageExt.MonadExtensions.<>c__DisplayClass3_0`4.<SelectMany>b__0(A a)
   at LanguageExt.Eff`1.<>c__DisplayClass75_0`2.<LanguageExt.Traits.Monad<LanguageExt.Eff<A>>.Bind>b__0(T a)
   at LanguageExt.ReaderT`3.<>c__DisplayClass20_1`1.<Bind>b__1(A x)
   at LanguageExt.IO`1.<>c__DisplayClass42_0`1.<Bind>b__0(A x)
   at LanguageExt.IOPure`1.Bind[B](Func`2 f)
   at LanguageExt.IO`1.Bind[B](Func`2 f)
   at LanguageExt.IO.LanguageExt.Traits.Monad<LanguageExt.IO>.Bind[A,B](K`2 ma, Func`2 f)
   at LanguageExt.ReaderT`3.<>c__DisplayClass20_0`1.<Bind>b__0(Env env)
   at LanguageExt.ReaderT`3.<>c__DisplayClass20_0`1.<Bind>b__0(Env env)
   at LanguageExt.ReaderT`3.<>c__DisplayClass20_1`1.<Bind>b__1(A x)
   at LanguageExt.IO`1.<>c__DisplayClass42_0`1.<Bind>b__0(A x)
   at LanguageExt.IOSync`1.<>c__DisplayClass13_0`1.<Bind>b__0(EnvIO e)
   at LanguageExt.IOSync`1.Run(EnvIO envIO)
   at LanguageExt.IOSync`1.<>c__DisplayClass13_0`1.<Bind>b__0(EnvIO e)
   at LanguageExt.IOSync`1.Run(EnvIO envIO)
   at LanguageExt.EffExtensions.Run[RT,A](K`2 ma, RT env, EnvIO envIO)

I'm on 5.0.0-beta-39 so if this is something that might be resolved later not a problem, I'll work around it for now.

[louthy]

Ah, it's because it needs to be evaluated regardless of the thruthiness of the Fin.IsFail

Away from the computer, so either you'll need a version of when that has a lazy (Func) handler. Or, use something like Match or IfSucc on the Fin with a default Error if the Fin is in a Succ state (Errors.None is a good default)

[glendonjklassen]

This works, thank you.

For reference: the final, working code is:

public static K<M, QueryDefinition> queryDefinition(string query, Dictionary<string, DbQueryParameter> queryParameters)
{
      return from qd in cosmos.Map(a => a.QueryDefinition(query, queryParameters))
             from _ in when(qd.IsFail, error<M>(qd.Map(_ => Errors.None).Match(a => a, a=> a)))
             select (QueryDefinition)qd;
}

I'll do some cleanup but this is sufficient to unblock my learning. Thank you again.