CodingDojo and gentle introduction into Fantom

Last Saturday I was participating in  CodingDojo organized by Szczecin JUG. Our task was to write simple parser that will take a text representation of minefield like “.*..*” (asterisk are mines, dots are empty fields) and transform it into string like this “1*11*”. In other words we was creating heart of the Saper game). It was unusual task because there was only one laptop and one projector, each of participants has 5 minutes to write some code (tests or implementation, of course we use TDD). After few hours of coding and discussions about approaches, data structures and algorithm that would be used we manage to write fully functional parser.

This was really strange experience for me, and to be honest I was little bit scared of … from one point of view this is strange, because I shared lots of code in EGit and other open source project and for sure I’m not scared by showing my code to other developers … but writing it in front of other people, and this filling that they are watching while I’m typing was really strange! But honestly I really like this and can recommend such experiment to everyone!

On my way back I’ve started thinking how same quasi-aplication could be implemented in Fantom. I’m almost sure that you are wondering “what the heck is Fantom”. Fantom is (yet another) JVM language … but it is quite different from others (at least from that I’ve herd about). What is different ? First of all it uses each own byte code; yes, this has some performance penalty, but with such approach its binaries can run on JVM, CLR, browser (yes its compile to JavaScript) and LLVM. Secondly it has build in test framework, build framework, modularity support, actors, truly immutable objects, object-to-string serialization etc. Last but not least, it distinguish nullable and not-nullable objects therefore you have null-contract build in in language syntax, compiler and documentation.  And of course it has support for functional programming and is statically typed … more information you  can find on

Now when you know what is Fantom, we can dive into some code samples. My example application would be mentioned above minefield-parser. I would start from tests, and then move to implementation.

As I mentioned before Fantom has build in test framework, just create a file with fan extension, you can call it how you want but by convention file name is same as class name that would be inside (but this isn’t a hard rule). Yours test class need to extend Test (to be more specific sys::Test, sys is name of pod (pods are more or less equivalent with jars)).

class SaperTest : Test {

  Void testEmptyInput() {
    // given
    input := ""

    // when
    result := Parser().parse(input)

    // then
    verifyEq(result, "")

Test methods must return Void type (notice uppercased notation) and name must start from ‘test’ (same as in JUnit3). To assert use verifyXY methods, simple as that. Below you will see full test suite for my Parser.parse method, you don’t need to scan/read all of them just look on first two.

  Void testTrowErrWhenIllegalCharactedIsPresent() {
    // given
    input := ".a"

    // when
    verifyErr(ArgErr#) {

As you can notice,  first test has a strange notation in ‘then’ section, there is verifyErr(ArgErr#) { Parser().parse(input) }, what it means ? This is an assertion method that check does given line throws and ArgErr (with is an argument exception). ArgErr# is more or less equivalent to ArgErr.class (or IllegalArgumentException.class) in java. Second parameter for verifyErr method (yes, statement in curly brackets is an parameter) is actually code that should throw given exception. This actually example of passing function as a parameter and when it last (or single parameter) it can be passed as a block statement after method non-functional parameters.

Another thing that you can notice is that there is no new keyword or equivalent. Fantom constructors are some how similar to factory methods, you just mark them with ‘new‘ keyword in class definition fallowed with unique name (make is default one) and you have yours constructor.

Same as in other modern JVM languages default access level to method/constructor/class is ‘public’ and you don’t need to type it explicitly, also semicolons are not required at end of the line. Another commonly used feature in new JVM language is type inference, but comparing to Scala’s type inference, one used in Fantom is really simple, it can only infer variable types, you must explicitly declare return type and parameters types.

Rest of test test code is pretty much the same, so lets move to more interesting part … the implementation! Method parse should be understandable for every one since it is only calling private methods.

class Parser {

  Str parse(Str input) {
    lines := input.splitLines
    result := createMatrix(lines.size, lines[0].size)

    lines.each |line, i| {
      parseLine(line, result, i);

    return convertToStr(result)

Only code in line 8 and 9 could be little bit strange. So lines variable is an List of Str‘s (yes it is shorten notation of String), and we are calling each method on this array (when method takes no arguments or one function argument brackets can be skip); each method takes function with two parameters first is value of element, second is it position. Notation |value, i| { parseLine(…) } is declaration of function that takes two parameters with name value and i , types of those parameters are infer from each method parameter signature. So, this simple two line notation calls parseLine method on each input line, it is that simple! Lets move with rest of the code!

  private Void validateInput(Str[] lines) {
    firstLineSize := lines[0].size
    if (!lines.all |line| {
      line.size == firstLineSize && line.all |c| { c == '.' || c == '*' }
      throw ArgErr("Line size mismatch or illegal character was used")

Another strange notation can be found on line 17 and 18. In both lines we are calling all method that is defined on Str and List classes. In both cases it checks does all elements matches given boolean condition. This “simple” if statement checks does each line have same number of elements and don’t contain other chars then dots and asterisk. Yet another hint, if yours function/closure/method has only one statement you don’t need to use return keyword.

  private Int[][] createMatrix(Int row, Int cols) {
    Int[][] result := [,]
    row.times {
      result.add([,].fill(0, cols))

    return result

Next strange notation you can find in line 24. What the heck is that [,] ? This is sort cut for creating empty List. As you can notice type inference in Fantom works both ways, now it figures out that this empty list should be type of List[][].

In Fantom you don’t need to use for loops to repeat some code X times. There is times method on Int type, it takes function as a argument and it will call this function X times. Example of using this method can be found in line 25.

In line 26 you  can find example usage of fill method defined on List class. An empty list is created and then filled with zeros. So method createMattrix will return matrix with given size filled in with zeros. Simple as that .. and it only has 4 lines of code!

  private Void parseLine(Str input, Int[][] result, Int i) {
    input.each |c, j| {
      if (c == '*') {
        prevCol := j - 1
        nextCol := j + 1
        result[i][j] = -10
        if (j > 0)
        if (j < input.size - 1)
        range := prevCol.max(0)..nextCol.min(result[i].size - 1)
        if (i > 0)
          incrementInRange(result[i - 1], range)
        if (i < result.size -1)
          incrementInRange(result[i + 1], range)

In line 33 we meet once again each method, I hope that you already know what it does 😉

Another interesting thing can be found in line 42; double dot operator. This is a code sugar for creating Range objects (it will be used in line 52), they are simplifying iterating over only range of elements. You just pass bottom boundary double-dots upper boundary and Fantom generates everything in between. There is also ‘..<‘ operator  for exclusive range.

  private Void incrementInRange(Int[] row, Range range) {
    row.eachRange(range) |value, p| {

eachRange, yet another useful and interesting method in List class! I’m using it in line 52 to increment values in neighbourhood of filed with mine. Here I’m only interested in position of element (the p variable), but because position is second parameter of function I also need declare variable that will hold element value.

This is pretty much it, now rest of code in this gist should be understandable for you, if not (or you have further questions) leave me comment under this post.