A Proper Constant Function in Scala

This evening there was a discussion in #scala on Freenode about how to define a properly quantified and appropriately lazy constant function in Scala. In short, the following does not suffice for two reasons:

def const[A,B](a: A) = (b: B) => a

Firstly, it’s too strict. The B argument is always evaluated, so this fails:

scala> val x = const(7)(error("too strict"))
java.lang.RuntimeException: too strict

Secondly, it’s not properly quantified:

scala> val x = const _
x: (Nothing) => (Any) => Nothing = <function1>

That type should be [A,B](A => B => A). That is, the function x should be polymorphic in its arguments.

This exposes a shortcoming with a fundamental design decision about how functions are represented in Scala. The representation is a little bit naive, but suffices for most day-to-day coding. But, for higher-order programming (like abstracting over combinator libraries), specifically to properly encode the constant function, what’s needed is a representation similar to this:

// The identity functor that maps every type to itself
type Id[A] = A

// A constant functor that maps every type to A
trait Const[A] { type Apply[B] = A }

// A natural transformation between functors
trait ~>[F[_],G[_]] { def apply[B](f: => F[B]): G[B] }

// A natural transformation from the identity functor to the constant functor,
// or if you like, the type of functions that return A but are
// polymorphic in their argument.
type K[A] = Id ~> Const[A]#Apply

// The non-strict, universally quantified constant function.
def const = new (Id ~> K) {
  def apply[A](a: => A) = new K[A] {
    def apply[B](b: => B) = a
  }
}

This is now sufficiently lazy and properly quantified:

scala> val x = const
x: java.lang.Object with ~>[Id,K] = $anon$1@8f84a7

scala> val y = x(7)
y: K[Int] = $anon$1$$anon$2@1eb89ca

scala> val z = y(error("too strict"))
z: Int = 7

We can implicitly convert various applications of ~> to regular old Function1. For example:

implicit def kToFn[A,B](f: K[A]) = (b: B) => f(b): A

Which lets us now use our universally quantified nonstrict constant function in the usual manner:

scala> val x = List(1,2,3) map const(7)
x: List[Int] = List(7, 7, 7)

Advertisement