I read (for example here and here) that all of the base monads (Mabye, Error, ...) are derived from their corresponding monad transformers (MaybeT, ErrorT, ...) using the identity monad Identity. An example would be:
type Maybe a = MaybeT Identity a
But that of course doesn't result in a constructor for Maybe a. And in the sources MaybeT is defined as newtype MaybeT m a = MaybeT (m (Maybe a)).
Am I missing something important? How could one derive a base monad using the corresponding monad transformer and the identitiy monad resulting in a concrete
constructor that can be matched against?
Different approaches are being used here.
Sometimes, the base monad Foo is defined in terms of its transformer as FooT Identity. For example, State from transformer package, as Daniel Wagner points out.
Other times, the base monad Foo is defined independently. In these cases, it usually happens that Foo and FooT Indentity are distinct types, which however are isomorphic. This means that you can convert between both types without losing any information.
I guess that since Maybe is defined in the Haskell report as a Prelude type, we can not easily redefine it as the isomorphic MaybeT Identity. Indeed, since it's common to destruct/eliminate values in Maybe a by pattern matching against Nothing and Just _, we can't use another definition. If we had user-definable patterns we could use pattern Just x = Module.Just (Identity x), but we have not these (for now).
Instead, other monads such as State are not in the Prelude, nor in the Haskell report. They are also not typically destructed via pattern matching by whomever is importing Control.Monad.State. In such cases, it felt less harmful to move to the StateT Identity variant.
Collected from the Internet
Please contact [email protected] to delete if infringement.
Comments