## Scala type level encoding of the SKI calculus

29 01 2010

In one of my posts on type level meta programming in Scala the question of Turing completeness came up already. The question is whether Scala’s type system can be used to force the Scala compiler to carry out any calculation which a Turing machine is capable of. Various of my older posts show how Scala’s type system can be used to encode addition and multiplication on natural numbers and how to encode conditions and bounded loops.

Motivated by the blog post More Scala Typehackery which shows how to encode a version of the Lambda calculus which is limited to abstraction over a single variable in Scala’s type system I set out to further explore the topic.

### The SKI combinator calculus

Looking for a calculus which is relatively small, easily encoded in Scala’s type system and known to be Turing complete I came across the SKI combinator calculus. The SKI combinators are defined as follows:

$Ix \rightarrow x$,
$Kxy \rightarrow x$,
$Sxyz \rightarrow xz(yz)$.

They can be used to encode arbitrary calculations. For example reversal of arguments. Let $R \equiv S(K(SI))K$. Then

$R x y \equiv$
$S(K(SI))K x y \rightarrow$
$K(SI)x(Kx)y \rightarrow$
$SI(Kx)y \rightarrow$
$Iy(Kxy) \rightarrow$
$Iyx \rightarrow yx$.

Self application is used to find fixed points. Let $\beta \equiv S(K\alpha)(SII)$ for some combinator $\alpha$. Then $\beta\beta \rightarrow \alpha(\beta \beta)$. That is, $\beta\beta$ is a fixed point of $\alpha$. This can be used to achieve recursion. Let $R$ be the reversal combinator from above. Further define

$A_0 x \equiv c$ for some combinator $c$ and
$A_n x \equiv x A_{n-1}$.

That is, combinator $A_n$ is the combinator obtained by applying its argument to the combinator $A_{n-1}$. (There is a bit of cheating here: I should actually show that such combinators exist. However since the SKI calculus is Turing complete, I take this for granted.) Now let $\alpha$ be $R$ in $\beta$ from above (That is we have $\beta \equiv S(KR)(SII)$ now). Then

$\beta\beta A_0 \rightarrow c$

and by induction

$\beta\beta A_n \rightarrow \beta\beta A_{n-1} \rightarrow c$.

### Type level SKI in Scala

Encoding the SKI combinator calculus in Scala’s type system seems not too difficult at first. It turns out however that some care has to be taken regarding the order of evaluation. To guarantee that for all terms which have a normal form, that normal form is actually found, a lazy evaluation order has to be employed.

Here is a Scala type level encoding of the SKI calculus:

trait Term {
type ap[x <: Term] <: Term
type eval <: Term
}

// The S combinator
trait S extends Term {
type ap[x <: Term] = S1[x]
type eval = S
}
trait S1[x <: Term] extends Term {
type ap[y <: Term] = S2[x, y]
type eval = S1[x]
}
trait S2[x <: Term, y <: Term] extends Term {
type ap[z <: Term] = S3[x, y, z]
type eval = S2[x, y]
}
trait S3[x <: Term, y <: Term, z <: Term] extends Term {
type ap[v <: Term] = eval#ap[v]
type eval = x#ap[z]#ap[y#ap[z]]#eval
}

// The K combinator
trait K extends Term {
type ap[x <: Term] = K1[x]
type eval = K
}
trait K1[x <: Term] extends Term {
type ap[y <: Term] = K2[x, y]
type eval = K1[x]
}
trait K2[x <: Term, y <: Term] extends Term {
type ap[z <: Term] = eval#ap[z]
type eval = x#eval
}

// The I combinator
trait I extends Term {
type ap[x <: Term] = I1[x]
type eval = I
}
trait I1[x <: Term] extends Term {
type ap[y <: Term] = eval#ap[y]
type eval = x#eval
}


Further lets define some constants to act upon. These are used to test whether the calculus actually works.

trait c extends Term {
type ap[x <: Term] = c
type eval = c
}
trait d extends Term {
type ap[x <: Term] = d
type eval = d
}
trait e extends Term {
type ap[x <: Term] = e
type eval = e
}


Eventually the following definition of Equals lets us check types for equality:

case class Equals[A >: B <:B , B]()

Equals[Int, Int]     // compiles fine
Equals[String, Int] // won't compile


Now lets see whether we can evaluate some combinators.

  // Ic -> c
Equals[I#ap[c]#eval, c]

// Kcd -> c
Equals[K#ap[c]#ap[d]#eval, c]

// KKcde -> d
Equals[K#ap[K]#ap[c]#ap[d]#ap[e]#eval, d]

// SIIIc -> Ic
Equals[S#ap[I]#ap[I]#ap[I]#ap[c]#eval, c]

// SKKc -> Ic
Equals[S#ap[K]#ap[K]#ap[c]#eval, c]

// SIIKc -> KKc
Equals[S#ap[I]#ap[I]#ap[K]#ap[c]#eval, K#ap[K]#ap[c]#eval]

// SIKKc -> K(KK)c
Equals[S#ap[I]#ap[K]#ap[K]#ap[c]#eval, K#ap[K#ap[K]]#ap[c]#eval]

// SIKIc -> KIc
Equals[S#ap[I]#ap[K]#ap[I]#ap[c]#eval, K#ap[I]#ap[c]#eval]

// SKIc -> Ic
Equals[S#ap[K]#ap[I]#ap[c]#eval, c]

// R = S(K(SI))K  (reverse)
type R = S#ap[K#ap[S#ap[I]]]#ap[K]
Equals[R#ap[c]#ap[d]#eval, d#ap[c]#eval]


Finally lets check whether we can do recursion using the fixed point operator from above. First lets define $\beta$.

  // b(a) = S(Ka)(SII)
type b[a <: Term] = S#ap[K#ap[a]]#ap[S#ap[I]#ap[I]]


Further lets define some of the $A_n$s from above.

trait A0 extends Term {
type ap[x <: Term] = c
type eval = A0
}
trait A1 extends Term {
type ap[x <: Term] = x#ap[A0]#eval
type eval = A1
}
trait A2 extends Term {
type ap[x <: Term] = x#ap[A1]#eval
type eval = A2
}


Now we can do iteration on the type level using a fixed point combinator:

  // Single iteration
type NN1 = b[R]#ap[b[R]]#ap[A0]
Equals[NN1#eval, c]

// Double iteration
type NN2 = b[R]#ap[b[R]]#ap[A1]
Equals[NN2#eval, c]

// Triple iteration
type NN3 = b[R]#ap[b[R]]#ap[A2]
Equals[NN3#eval, c]


Finally lets check whether we can do ‘unbounded’ iteration.

trait An extends Term {
type ap[x <: Term] = x#ap[An]#eval
type eval = An
}
// Infinite iteration: Smashes scalac's stack
type NNn = b[R]#ap[b[R]]#ap[An]
Equals[NNn#eval, c]


Well, we can ;-)

$scalac SKI.scala Exception in thread "main" java.lang.StackOverflowError at scala.tools.nsc.symtab.Types$SubstMap.apply(Types.scala:3165)
at scala.tools.nsc.symtab.Types$SubstMap.apply(Types.scala:3136) at scala.tools.nsc.symtab.Types$TypeMap.mapOver(Types.scala:2735)


## Implementing Java Interfaces and Generics

30 08 2009

In an earlier post I asked for an implementation of the following Java interface in Scala:

public interface Iterator2 extends java.util.Iterator {}


The solution was to use a combination of self types and existential types. However, some comments made me aware of Ticket #1737 where a more general form of the problem is discussed. Given the following Java code:

public interface A<T> {
void run(T t);
T get();
}

public abstract class B implements A {}


How could B be implemented in Scala? My previous approach is not sufficient here since for implementing the run() method, one needs to be able to refer to the existential type in run()‘s parameter list:

class C extends B {
this: A[_] =>

def run(t:???) {} // What should go here for t's type?
def get = "hello world"
}


So what we need is a way to name the existential type used in the self type (that is the type parameter to A) such that we can refer to it in the parameter list of the run() method. Here is my shot:

class D {
type Q = X forSome { type X; }
}

class C extends B {
this: A[D#Q] =>

def run(t:D#Q ) {}
def get: D#Q = "hello world"
}


Unfortunately this results in a compilation error with Scala 2.7.5

error: class C needs to be abstract, since method run in trait A of type (T)Unit is not defined


and in a AssertionError for Scala 2.8.0.r18604-b20090830020201

Exception in thread "main" java.lang.AssertionError: assertion failed: michid.iterator.A[T]
at scala.Predef$.assert(Predef.scala:107) at scala.tools.nsc.symtab.Types$TypeRef.transform(Types.scala:1417)
at scala.tools.nsc.symtab.Types$TypeRef$$anonfun$baseTypeSeq\$3.apply(Types.scala:1588)
...


I created Ticket #2091 for these problems.

## Scala for Sling @ Jazzon 09

26 06 2009

Yesterday I gave a presentation at Jazoon 09 about using Scala for scripting RESTful web applications with Apache Sling.

In the session I showed how to take advantage of Scala to create RESTful web applications with Apache Sling. I demonstrated how to uses its DSL capability and support for XML literals to create type safe web site templates. In contrast to conventional web site template mechanisms (e.g. JSP), this does not rely on a pre-processor but rather uses pure Scala code.

There are Session slides and support material available here. The support material contains a fully workable demo application. A Scala scripting bundle for Sling is also included.

## Puzzle: implement this (solution)

24 06 2009

Well, I wasn’t aware of Ticket #1737 when I was trying to find a solution to the problem from my previous post. Thanks to Jorge Ortiz for pointing this out. However, I reviewed my approach to solving this and didn’t find sever limitations. Maybe someone else does…

When I initially stumbled on this, I remembered that existential types where introduced into Scala for coping with Java’s raw types. But there is an additional twist here, we need to tell the compiler that our MyIterator implementation actually ‘is an instance of a raw type’. So combining existential types with self types led me to the following solution:

class MyIterator extends Iterator2 {
this: java.util.Iterator[_] =>
def hasNext = true
def remove = throw new Error
def next = "infinity"
}


We can now safely use instances of MyIterator.

  def test1(it: MyIterator) = {
println(it.next)
}

def test2(it: java.util.Iterator[_]) = {
println(it.next)
}

val it = new MyIterator
val v: String = it.next
println(v)

test1(it)
test2(it)


The approach using existential types in combination with self types makes sure that values returned from the next method always are typed correctly.

## Puzzle: implement this

19 06 2009

This is something I stumbled on recently when trying to implement javax.jcr.NodeIterator in Scala.

Assume you are using a library which exports an Iterator2 interface:

public interface Iterator2 extends java.util.Iterator {}


Note that Iterator is a raw type and Iterator2 does not take any type parameters. So how would you implement Iterator2 in Scala?

Here is a start:

class MyIterator extends Iterator2 {
def hasNext = false
def remove = throw new Error
def next: Nothing = throw new Error
}


But if the next method should return an actual value, what would be it’s return type? It turn’s out that any other type than Nothing results in a compiler error:

error overriding method next in trait Iterator of type ()E;
method next has incompatible type ()Any


So how would you implement Iterator2?

## Meta-Programming with Scala: Conditional Compilation and Loop Unrolling

29 10 2008

The kind of comments I keep getting on my static meta-programming with Scala blogs are often along the lines of: “The ability to encode Church Numerals in Scala still seems uselessly academic to me, but cool none-the-less”. In this blog I will show how meta-programming can be applied in practice – at least theoretically.

In my previous blogs I introduced a technique for static meta-programing with Scala. This technique uses Scala’s type system to encode values and functions on these values. The Scala compiler acts as interpreter of such functions. That is, the type checking phase of the Scala compiler actually carries out calculations like addition and multiplication.

In this post I show how to apply meta-programming for two practical problems: conditional compilation and loop unrolling. The examples make use of type level encoding for booleans and natural numbers. While I introduced an encoding for natural numbers before, I use an alternative method which is more powerful in this post. Previously it was not possible to build nested expressions having expressions as operands themselves. The new encoding supports such expressions. However, in general the new encoding depends on the -Yrecursion compiler flag which is experimental and as of now only available in the Scala trunk. The type level encoding for booleans is along the same lines as the one for natural numbers.

### Conditional Compilation

Conditional compilation is useful for example for enabling or disabling debugging or logging statements. Ideally code which is excluded by a compile time condition does not have any effect on the run-time behavior of the rest of the code. That is, the rest of the code behaves exactly as if the excluded code were not there at all. Optimizing compilers generally remove code which is unreachable. This is where meta-programming fits in: type level encoded functions (meta-functions) are evaluated at run-time. The result of the evaluation is a type. Now we only need to trick the compiler into compiling a block of code or not compiling it depending on that type.

Lets first define meta-booleans and some operations on them (full code here):

object Booleans {
trait BOOL {
type a[t <: BOOL, f <: BOOL] <: BOOL
type v = a[TRUE, FALSE]
}
final class TRUE extends BOOL {
type a[t <: BOOL, f <: BOOL] = t
}
final class FALSE extends BOOL{
type a[t <: BOOL, f <: BOOL] = f
}
trait IF[x <: BOOL, y <: BOOL, z <: BOOL] extends BOOL {
type a[t <: BOOL, f <: BOOL] = x#a[y, z]#a[t, f]
}
trait NOT[x <: BOOL] extends BOOL {
type a[t <: BOOL, f <: BOOL] = IF[x, FALSE, TRUE]#a[t, f]
}
trait AND[x <: BOOL, y <: BOOL] extends BOOL {
type a[t <: BOOL, f <: BOOL] = IF[x, y, FALSE]#a[t, f]
}
trait OR[x <: BOOL, y <: BOOL] extends BOOL {
type a[t <: BOOL, f <: BOOL] = IF[x, TRUE, y]#a[t, f]
}

// aliases for nicer syntax
type ![x <: BOOL] = NOT[x]
type ||[x <: BOOL, y <: BOOL] = OR[x, y]
type &&[x <: BOOL, y <: BOOL] = AND[x, y]
}


The following pre-processor object contains an implicit method for converting a value of type TRUE to an Include object whose apply method executes a block of code. Similarly it contains an implicit method for converting a value of type FALSE to an Exclude object whose apply method simply does nothing. The strange line where null is being cast to B is a trick for getting a witnesses of a value of type B.

object PreProc {
def IF[B] = null.asInstanceOf[B]

object Include {
def apply(block: => Unit) {
block
}
}

object Exclude {
def apply(block: => Unit) { }
}

implicit def include(t: TRUE) = Include
implicit def exclude(f: FALSE) = Exclude
}


Using these definitions is quite convenient now:

object IfDefTest {
import PreProc._

type LOG = TRUE
type ERR = TRUE
type WARN = FALSE

def errTest() {
IF[(LOG && ERR)#v] {
println("err")
}
}

def warnTest() {
IF[(LOG && WARN)#v] {
println("warn")
}
}

def main(args: Array[String]) {
errTest()
warnTest()
}
}


Running the above code will print err but wont print warn to the console.

### Loop Unrolling

Another application for static meta-programming is loop unrolling. When the number of iterations of a loop is small and only depends on quantities known at compile time, run time performance might profit from unrolling that loop. Instead of resorting to copy paste, we can use similar techniques like above.

Again let’s first define meta-naturals and their operations (full code here):

object Naturals {
trait NAT {
type a[s[_ <: NAT] <: NAT, z <: NAT] <: NAT
type v = a[SUCC, ZERO]
}
final class ZERO extends NAT {
type a[s[_ <: NAT] <: NAT, z <: NAT] = z
}
final class SUCC[n <: NAT] extends NAT {
type a[s[_ <: NAT] <: NAT, z <: NAT] = s[n#a[s, z]]
}
type _0 = ZERO
type _1 = SUCC[_0]
type _2 = SUCC[_1]
type _3 = SUCC[_2]
type _4 = SUCC[_3]
type _5 = SUCC[_4]
type _6 = SUCC[_5]

trait ADD[n <: NAT, m <: NAT] extends NAT {
type a[s[_ <: NAT] <: NAT, z <: NAT] = n#a[s, m#a[s, z]]
}
trait MUL[n <: NAT, m <: NAT] extends NAT {
trait curry[n[_[_], _], s[_]] { type f[z] = n[s, z] }
type a[s[_ <: NAT] <: NAT, z <: NAT] = n#a[curry[m#a, s]#f, z]
}

// aliases for nicer syntax
type +[n <: NAT, m <: NAT] = ADD[n, m]
type x[n <: NAT, m <: NAT] = MUL[n, m]
}


The pre-processor object defines a trait Loop having an apply method which takes a block of code as argument. Again there are two implicit conversion methods. One which converts the zero type to a Loop with an empty apply function. An another one which convert the type N + 1 to a a Loop with an apply function which executes the block once and then applies itself to the type N.

object PreProc {
def LOOP[N] = null.asInstanceOf[N]

trait Loop[N] {
def apply(block: => Unit)
}

implicit def loop0(n: ZERO) = new Loop[ZERO] {
def apply(block: => Unit) { }
}

implicit def loop[N <: NAT](n: SUCC[N])(implicit f: N => Loop[N]) = new Loop[SUCC[N]] {
def apply(block: => Unit) {
block
null.asInstanceOf[N].apply(block)
}
}
}


Again using this is easy and convenient:

object LoopUnroll {
import PreProc._

def unrollTest() {
// The following line needs the -Yrecursion 1 flag
// LOOP[(_3 x _2)#v] {
LOOP[_6] {
println("hello world")
}
}

def main(args: Array[String]) {
unrollTest()
}
}


The above code prints the string “hello word” six times to the console.

### Conclusion

Scala’s type system is powerful enough for encoding commonly encountered functions. Together with Scala’s strong capability for creating internal DSLs, this results in convenient techniques for static meta-programming. Such techniques can be applied to practical problems – at least in theory. In practice Scala’s support is not (yet?) there. For one the technique presented here depends on an experimental compiler flag (-Yrecursion). Further the types required for meta-programming might causes an exponential growth in compilation time which is not desirable. And finally an analysis with c1visualizerwith showed, that the compiler seems not to remove all unnecessary calls.

## Meta-Programming with Scala Part III: Partial function application

27 08 2008

In my previous post about Meta-Programming with Scala I suspected that there was no way to express partial function application in Scala’s type system. However Matt Hellige proofed me wrong in his comment.

His solution uses a trait for partially applying a function to some of its arguments. An abstract type exposed by the trait represents the resulting function which takes the remaining arguments.

object Partial {
// Partial application of f2 to x
trait papply[f2[_, _], x] {
type f1[y] = f2[x, y]
}

// apply f to x
type apply[f[_], x] = f[x]

trait X
trait Y
trait F[A1, A2]

// Test whether applying the partial application of
// F to X to Y equals in the type F[X, Y]
case class Equals[A >: B <: B, B]
Equals[apply[papply[F, X]#f1, Y], F[X, Y]]
}


Having this solved we can define a type which encodes multiplication on the Church Numerals.

    trait curry[n[_[_], _], s[_]] {
type f[z] = n[s, z]
}

// Multiplication for this encoding
type mult[m[_[_], _], n[_[_], _], s[_], z] = m[curry[n, s]#f, z]


A full working example is available from my code page. Note, the code takes forever (i.e. some minutes) to compile. Matt also noted an issue with squares. With my version of the compiler (Ecipse plugin 2.7.2.r15874-b20080821120313) the issue does not show up however.