ReaderT | epub reader with AppUI effect

As the error message says, your associated type FooCtx depends only on ctx, but not on m, thus creating a potential for ambiguity like this:

I'm not sure why you choose to define your services this way but if your question is to avoid calling run in sumAndShow you could lift your Reader/IO into ReaderTs with lift/liftF and compose them with a ReaderT.ask:

I think this achieves what you want:

It seems like the machinery of Servant doesn't make assumptions about the underlying monad in which you choose to define the handlers. This means it can't force you to choose any particular monad (like, say, ReaderT) in response to some combinator present in the routes, and it doesn't "react" to your choice of monad in order to enable some behavior.

In the case of servant-auth, we need to provide some extra information to servant about how to handle cookies and the like.

What the Context system does it to collect that extra information in a positional parameter for route, hoistServerWithContext and serveWithContext, while still letting you choose whatever monad you wish. The exact type of the parameter depends on what route combinators are present in the API.

The servant tutorial has some paragraphs about Contexts:

When someone makes a request to our "private" API, we’re going to need to provide to servant the logic for validating usernames and passwords. [...] Servant 0.5 introduced Context to handle this. [...] the idea is simple: provide some data to the serve function, and that data is propagated to the functions that handle each combinator.

As for

Furthermore, serveWithContext appears to be passing these values in twice

I'm not sure, but I suspect checkCreds taking cs and jwts as parameters is done only as an example of how authentication would be performed if done purely in handlers, without help from Servant itself. In contrast, the protected endpoint already receives the result of the authentication as a parameter; it doesn't have to perform it itself.

In a real-world application, server wouldn't take those parameters, they would only be passed in the Context.

I believe your problem is caused by a lack of understanding of monads. There are plenty of tutorials on the web, so allow me to simplify the issue and explain it in the context of your code.

When in Haskell we write x :: Int, we mean that x is an integer value. In the definition of x we can write

GHC 8.10.3 does complain about this with -Wall (after I changed initConfig to readConfig in your code):

A do-notation statement discarded a result of type ‘IO ()’
Suppress this warning by saying ‘_ <- print <$> readConfig c’

You have readConfig c of type IO Int. Then you fmap print, giving something with a type of IO (IO ()). Since the result isn't bound to a variable in the do block, it is thrown away.

In the fmap's type Functor f => (a -> b) -> f a -> f b we have f being IO, a being Int, and b being IO (). So it is used with the type (Int -> IO ()) -> IO Int -> IO (IO ()).

This would work:

At the time of writing this answer there is no way to have extension methods visible to trait constraints, although there is a longstanding RFC and PR in the F# compiler to implement it.

So, for the time being in order to add a type to an abstraction (like Monad) you need to either edit the type's source to add the required method or the abstraction source.

The former is basically impossible for IObservable I mean you can try submit them a PR, but the latter option is more feasible in the short term: submit a PR or at least open an issue in F#+ to add IObservable directly as Monad.

Okay after some deep diving into the source code and looking at the tests in the indents GitHub repository I managed to create a working example.

The following code can parse a simple indented list:

You can ignore all the monadic parts of getBy's type signature. Provided you get your code to type check, counterEntity has type Maybe (Entity Counter), and that's all that's important here.

The counterEntity is Nothing if the query fails (i.e., no record in the table for that counter). Otherwise, it's Just an Entity Counter containing the retrieved record: