Programming in Scala”

Chapter notes 44
trait Translate[F[_],G[_]] {
}
def apply[A](f: F[A]): G[A]
Although values must be monomorphic, methods in Scala can of course be polymorphic, so we
simply introduce a new first-class type containing a polymorphic method. Unfortunately, this means
that various polymorphic methods we might have lying around must be explicitly wrapped in
Translate:
def headOption[A](a: List[A]): Option[A]
Even though headOption is polymorphic, we would need to explicitly wrap it in a Translate[List,Option]
if we ever needed to use it polymorphically in a first-class way. Another drawback of this approach
is that we require separate versions of Translate for different “shapes” of the input and output type
constructors–for instance, in chapter 14, we define a type RunnableST, which would typically just
be represented using a universally quantified ordinary value, without needing wrapping in a new
type.
Links
See Free Monads and Free Monoids¹⁸⁰ for more information about what “free” means.
Notes on chapter 14: Local effects and mutable state
The ST data type covered in this chapter was first introduced in Lazy Functional State Threads¹⁸¹.
The general idea, of using universal quantification to uniquely tag variables and enforce scoping,
is also useful in other situations. For instance, we can use the same idea to enforce a ‘safe’ API for
accessing file handles, preventing a file handle from being referenced after it passes out of scope.
Here is a sketch of an API:
¹⁸⁰http://blog.higher-order.com/blog/2013/08/20/free-monads-and-free-monoids/
¹⁸¹http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.50.3299