Discord is now Scala’s main chat platform. Please join us at https://discord.com/invite/scala
first: the initial view was that you should use things like MonadState and MonadReader, as opposed to
MyDbAlg and MyHttpAlg
this is an evolution that happened in Haskell as well, although direct use of mtl typeclasses is still common
remember that this is way before scato
@mdedetrich not on its own. Final tagless solves that natively. Free needs additional machinery in the form of Coproduct injection (
Data types a la carte). It's a way clunkier solution than final tagless for that)
e.g.
MonadError cannot be refactored as a final tagless effect
it’s just a type parameter
the general name
algebra?
then I rephrase:
MonadError cannot be refactored as an algebra, because it has F[_] in contravariant position (and the algebra could not have an FFunctor, or FunctorK as cats calls it)
@lihaoyi it's a type parameter plus the idea of encoding languages as their interpreters. The business logic application of it is quite simple. In the context of DSLs more in general, there's more to that like optimisations and parsing. But even the basic idea looks simple, but papers discovering were very innovative. Hindsight is 20/20: the expression problem and having typed languages with no tags or GADTs were not solved problems before. It's so innovative that an OO paper that basically rediscovered the same thing (and named it object algebras), won a best paper award (
Extensibility for the masses)
e.g. I just had a use case for a BigQuery DSL which translates to json directly
I loathe to call that a data type
I would agree that is an algebra
@fommil Ah true, didn't think of that. The more precise question: is there any loop fusion happening on anything from the stdlib? My works codebase uses
Seq. I'm looking into mostly using directly List but I'm scared that it could make matters worse as it doesn't fuse and some of the collections hidden behind some of the Seq might do it.
the ideas behind final tagless are two:
- An algebra is represented in terms of its eliminators == a language is represented as its interpreter == you encode things using functions.
- the result is expressed as a type param.
This is a genius idea, not trivial at all, and the technique definitely deserves a name, especially when you take it in its entirety (e.g. do parsing or optimisations on final tagless languages)
MTL didn't even exist
it was influenced by that paper
also if you look into the DSL space then you'll find that final tagless is definitely talked about
it's also not specific to typeclasses
well, there is a whole bunch of libraries that tries to improve on
mtl
that is basically researching final tagless problems
like, a lot of libraries and different approaches
e.g
MonadLayers,monad-control, and so on