Fantom Cheat Sheet

using inet                  // example: import all of in inet pod
using xml::XNode            // example: import XNode from xml pod
using sys::Time as T        // import Time of sys pod, as "T"  

class Hello
{
  static Void main()
  {
     echo("Time is $T.now") 
  }
}

mixin class Audio
{
  abstract Int volume
  Void incrementVolume() { volume += 1 }
  Void decrementVolume() { volume -= 1 }
}

class Television : Audio
{
  // volume is abstract so has to be implemented
  override Int volume := 0
}

enum class Suits
{
  clubs("black"),
  diamonds("red"),

  private new make(Str color) { this.color = color; }
  const Str color;
}

Int id := 0  
{ 
  get { echo("get id"); return *id }; 
  set { echo("set id"); *id = val } 
}

class MyObject
{
// Static method(doesn't need an instance) that return the sum of arguments a and b
	static Int add(Int a, Int b) { return a + b }
// Instance method that increments the field called count
	Void sayHello() { echo("Hello world") }
// Instance method that sets this instance 'name' field to the value 'name'
	Int setName(Str name) { this.name=name }

// static method call (we don't need an instance of MyObject)
  MyObject.add(2,3)
// creating a MyObject instance to make methods call on
  myObj := MyObject()
// call setName method
  myObj.setName("JDoe")
// call sayHello - we drop parenthesis as there are no params
  myObj.sayHello
// Same but with a dynamic (runtime) call
  myObj->sayHello

	void parseString(String text, boolean removeLinebreaks) {/*code*/}
// then a shortcut method:
	void parseString(String text) {parseString(text, false)}

	Void parseString(Str text, bool removeLinebreaks := false) {/*code*/}

class MissingPerson
{
  Str name
  Bool wantedByFBI := false
//Default constructor, create MissingPerson withe given name
  new make(Str name) { this.name = name }
//Other constructor with chaining, calls the default constructor first then sets wantedByFBI
  new makeWanted(Str name) : this.make(name) { wantedByFBI = true }
}	

class MyClass
{
	static{echo "MyClass initialization"}
}

MissingPerson person := MissingPerson.make("John Doe")
// shorthand
person := MissingPerson("John Doe")

bool1:=true;    bool2:=false; // Bool

int1:=45;    int2:=-89_039;    int3:=0xcafebabe;    int4:=0xCAFE_BABE
int5:='?';   int6:='\n';       int7:='\u03ab';      int8:='\u00F2'

f1:=3.0f;    f2:=3f;    f3:=3.0F;    f4:=123_456.0f;
f5:=3e6f;    f6:=0.2e+6f;            f7:=1_2.3_7e-5_6f;

d1:=4d;    d2:=4.0;    d3:=4.00;    d4:=123_456d;
d5:=3e6;   d6:=0.2e+6D;             d7:=1_2.3_7e-5_6

// duration suffixes: ns, ms, sec, min, hr, day
d:=4ns;  d:=100ms;  d:=-0.5hr;

Str s:="hello"

// Multiline string supported (line feed becomes "\n";)
Str s:="It is 73\u00B0 
Fahrenheit outside!"  

Str s:="The price is $price or $ {price}"

echo("""Do you know "What lies beneath the shadow of the statue"?""")

echo(Str <|no \ or $ escapes need, and multi-line works too|>)

list1:=Int[10, 20, 30]     // list of the three Ints 10, 20, and 30
list2:=[10, 20, 30]        // same as above using type inference
list3:=Str[,]              // empty list of Strings
list4:=[[10,20], [30]]     // evaluates to Int[][]      
list5:=Int?[1,2,3]         // can store null Int?[]      

map1:=[Int:Str][1:"one", 2:"two"]  // map of Strs keyed by Int
map2:=Int:Str[1:"one", 2:"two"]    // same as above with shorthand type syntax
map3:=[1:"one", 2:"two"]           // same as above using type inference
map4:=Int:Str[:]                   // empty Int:Str map
map5:=[0:["one"]]                  // evaluates to Int:Str[]
Int:Str?[1:"one", 2:"two"]         // can store null String values

u1:=`/some/path/file.txt`
u2:=`http://fantom.org`
u3:=`/dir/$file` ; $file is interpolated variable.
u1.toStr; u2.encode;   // encode url

// can be use in loops etc....
0..5    // 0 to 5 (end is inclusive)
0..<5   // 0 to 4 (end is exclusive)
x..<y   // x to y-1 (end is exclusive)

Str#  // String type
acme::SomeType#

if(cond) dothis else if(cond2) dothat else donothing
if(cond) {dothis; dothat}    // multiple statement in block -> needs bracket

while (p != null)
  p = p.next

for (i:=0; i<10; ++i)  // can't use , as in Java/c++
  echo(i)

switch (method.upper)
{
  case "GET":  serviceGet
  case "POST": servicePost
  default:     methodNotSupported
}

try {something}              // Curly's are optional if only one statement in block
catch (CastErr e) {e.trace}  // trace to stdout
catch (Err e) {e.trace(log)} // trace to log
catch {/*catch all else*/}
finally {cleanup}

f := |Int a, Int b->Int| { return a + b }
nine := f(4, 5)

f := |,| { echo("hi there") }
f()

f := |->Str| { return first + " " + this.last } // binded var

evens := list.findAll() |Int v->Bool| { return v%2==0 }

list := ["one", "two", "three"]
list.each |Str val, Int index| { echo("$index = $val") }
list.each |Str val| { echo(val) }

list.each |v| { echo(v) }
odds = [1, 2, 3, 4, 5].findAll |v| { v.isOdd }

["a", "b", "c"].each |Str s| { echo(s.upper) }  // long hand
["a", "b", "c"].each { echo(it.upper) }         // short hand
["a", "b", "c"].each { echo(upper) }     // implicit it call

// Apply an IT block to an expression
list := Str[,].with { fill("x", 3) }   // explicit call to with
list := Str[,] { fill("x", 3) }        // implicit call to with

obj[0]                     //same as obj.get(0)
obj[-1]                    //same as obj.get(obj.size-1)
obj[0] = 3                 //same as obj.set(0,3)
obj[-1] = 3                //set last item in obj with value 3
obj[0..2]                  //slice of obj (0,1,2)
obj[0..<2]                 //slice of obj (0,1)

address := Address{street = "123 Happy Lane"; city   = "Houston";}

// old fashion
address := Address(); address.street="123 Happy Lane"; address.city="Houston";

// Notice the trailing comma after MenuItem definition, it does menu.add(menuItem);
menu := Menu{  text = "File";  MenuItem { text = "Open";}, }

//old fashion:
menuItem := MenuItem(); menuItem.text="Open";
menu := Menu(); menu.text = "File"; 
menu.add(menuItem);

Int#plus                      // Refer to Method plus of class Int
Pod.find("acmeFoo")           // lookup a pod (package)
someObj.typeof                // lookup an object type
Slot.find("myPod::Foo.xyz")   // lookup a slot(ex: method) by its name
method.call([arg0, arg1])     // invoke method using reflection

using [java] java.lang::Math
//....
Math.abs(someval)

@serializable
@version=Version("1.2")
class Account
{
}