Typesafe Activator

Lolcode DSL and reactive interpreter

Lolcode DSL and reactive interpreter

June 5, 2014
scala dsl akka lolcode scaladays2014

Lolcode DSL and its reactive interpreter.This activator template aims to use Scala as a powerfull tool for embedding domain specific languages, as well as Akka for implementing reactive processes.

How to get "Lolcode DSL and reactive interpreter" on your computer

There are several ways to get this template.

Option 1: Choose lolcode-dsl in the Typesafe Activator UI.

Already have Typesafe Activator (get it here)? Launch the UI then search for lolcode-dsl in the list of templates.

Option 2: Download the lolcode-dsl project as a zip archive

If you haven't installed Activator, you can get the code by downloading the template bundle for lolcode-dsl.

  1. Download the Template Bundle for "Lolcode DSL and reactive interpreter"
  2. Extract the downloaded zip file to your system
  3. The bundle includes a small bootstrap script that can start Activator. To start Typesafe Activator's UI:

    In your File Explorer, navigate into the directory that the template was extracted to, right-click on the file named "activator.bat", then select "Open", and if prompted with a warning, click to continue:

    Or from a command line:

     C:\Users\typesafe\lolcode-dsl> activator ui 
    This will start Typesafe Activator and open this template in your browser.

Option 3: Create a lolcode-dsl project from the command line

If you have Typesafe Activator, use its command line mode to create a new project from this template. Type activator new PROJECTNAME lolcode-dsl on the command line.

Option 4: View the template source

The creator of this template maintains it at https://github.com/JSantosP/lolcode-dsl#master.

Option 5: Preview the tutorial below

We've included the text of this template's tutorial below, but it may work better if you view it inside Activator on your computer. Activator tutorials are often designed to be interactive.

Preview the tutorial

What is LolCode ?

LOLCODE is an esoteric programming language inspired by lolspeak, the language expressed in examples of the lolcat Internet meme.The language was created in 2007 by Adam Lindsay, researcher at the Computing Department of Lancaster University. These short snippets show how Scala empowers you to create new embedded domain specific languages with its powerfull features.

This short DSL allows you to write and execute lolcode with this appearence:

			"val myProgram =
				HAI (
					AWSUM THX {
					} O_NOES {
				) KTHXBYE"

It's not exactly the same syntax, I know, but it works for taking account of provided mechanisms to do this embedding process.

The reactive interpreter

The interpreter for processing this kind of programs has been thought as an actor that receives a program with a set of statements. If you can imagine a program as a stateful value with some environment, imported libraries and so, then it's possible to design an interpreter like this

			"class Interpreter(logger: ActorRef) extends Actor {
			  def receive = {
			    case program: Program => 
			      if (!program.isSyntaxOk) 
			      	sender ! WrongSyntax(program)
			      else program.statements.toList match {
			      	case (head::tail) => 
			      		val (updatedProgram,output) = head.execute(
			      		logger ! output
			      		self ! updatedProgram
			      	case _ => 
			      		logger ! Finished(program)

This way, the basic mechanism to process a program is to perform the execution of each statement and sending to itself the same program but updated without the executed statment. Ah, and it also sends the output of last execution to some logger actor.


For instance, if we want to create a statement that represents the effect of importing a library, in LOLCODE it's used CAN HAS STDIO ?.

Using infix syntax, we can build the first part of the statement with object CAN { def HAS(x: X): Y = ??? }.

You can notice 'HAS' method needs some way to set which library we need. So 'X' type should be 'Library':

			"trait Library { val name: String }
			object CAN { def HAS(library: Library): Y = ??? }"

By now, we could call CAN HAS STDIO if we declared a

			case object STDIO extends Library { val name = "stdio" }

But there's still missing the interrogation mark. How can we achieve this? By using a helper class like this:

			"class Can(l: Library) {
				def ?: Statement = ???

We can now build a whole new statement and at the end we should have:

			"class Can(l: Library){
				def ? : Statement = ImportStatement(l)
			object CAN {
				def HAS(library: Library): Can = new Can(library)

If you enjoyed this example, feel free to have a look on the other statements at source code.

comments powered by Disqus