Alien-Factory

1. Hello Fantom!

The classic "Hello World!" program

** Doc comments are a form of *Markdown*
** See [Fandoc]`fandoc::index`
class HelloWorld {

    Void main() {
        echo("Hello World!") 
    }
}

Find Out More! ...

Differences from C#

Semi-colons; after every line are optional;
Document comments are in Fandoc, not XML. (Fantom's version of Markdown)
Methods are public scope by default
main() does not need to be static or take args
Void is an object! (But not a very useful one!)
Call echo() instead of Console.WriteLine()

2. Literals

select all

class DataTypes {
  Void main() {
    easy   := true          // --> Bool
    count  := 3             // --> Int
    pi     := 3.14f         // --> Float
    name   := "Space Alien" // --> Str
    range  := (1..3)        // --> Range

    google := `http://www.google.com` // Uri
    moment := 2sec                    // Duration
    method := DataTypes#main          // Slot

    // example of Str interpolation
    iSpy   := "I see ${count} Aliens"
  }
}

Differences from C#

Types are inferred, no need to specify the class!
Use := to declare and assign a variable
Useful types Uri, Duration and Range are built in!
Reflection has never been easier!
No primatives, everything is an Object, example: 3.toStr()
Use ${...} for Str and Uri interpolation

3. Maps and Lists

select all

class MapsAndLists {
  Void main() {
    list := ["one", "two"]     // declare List
    item := list[1]            // get item
    list.add("beer")           // add item

    map := ["foo":1, "bar":2]  // declare Map
    val := map["bar"]          // get value
    map["beer"] = 3            // set value

    emptyList := [,]
    emptyMap  := [:]
  }
}

Differences from C#

Only 1 List type and 1 Map type!
Cool syntax for declaration
Built in Generics
Maps may be ordered or case-insensitive

4. Fields

select all

class Fields {
  Int simple
  Int complex {
    get { return &complex + 1 }
    set { &complex = it * 2   }
  }

  Void main() {
    simple = 2
    echo(simple)   // --> 2

    complex = 2
    echo(complex)  // --> 5
  }
}

Differences from C#

All fields are properties!
No more boiler plate getters and setters!
Fields have public scope by default
Easy reflection: Fields#complex.get()

5. Methods

select all

class Methods {
  Str simple() {
    "Simon"
  }

  Int maths(Int x, Int y := 2) {
    return x + y
  }

  Void main() {
    a := simple       // --> "Simon"
    b := maths(4)     // --> 6
    c := maths(4, 5)  // --> 9
  }
}

Differences from C#

Brackets() optional when calling methods with no arguments. E.g. simple() vs. simple
return keyword optional for single statement methods
Method parameters can have default values
Methods have public scope by default
Fantom does not support method overloading:
- 90% of cases solved with default parameter values
- 10% of cases solved by renaming the method
Easy reflection: Methods#simple.call()

6. Classes

select all

class MyClass {
  new makeFromStr(Str str) {
    echo("Made with ${str}")
  }
}

class Class2 {
  Void main() {
    obj1 := MyClass.makeFromStr("Love")

    // ctor name is optional 
    obj2 := MyClass("Love")
  }
}

Differences from C#

Ctors are methods that return new
Name ctors anything you like. (By convention they start with 'make')
Instantiate classes by calling ctors like static methods. (Don't use new keyword)
Instantiating with ctor name is optional.

7. Mixins

select all

class MyMixin : MyOtherMixin {
  // num must be implemented in subclasses
  abstract Int num

  // add1() *must* be overridden
  abstract Void add1(Int i)

  // add2() *cannot* be overridden
  Void add2(Int i) { echo(num + i) }

  // add3() *may* be overridden
  virtual Void add3(Int i) { echo(num + i) }

  // use the override keyword to override
  override Str toStr() { num.toStr }
}

Differences from C#

Interfaces are called mixins
Mixin methods can have implementations!
Mixins can define fields, but can not hold their values.
Fields may override simple methods.
Similar to a C# abstract class:
- All abstract methods have to be overridden.
- Only virtual methods may be overridden.

8. Packaging

select all

// import entire pods
using xml
// import single classes
using util::Random
// import and rename single classes
using util::Random as Wibble

class Packaging {
  // XParser is in the 'xml' pod
  html := XParser("<html/>".in).parse

  num1 := Random().next

  num2 := Wibble().next
}

Differences from C#

Fantom libraries are called pods, not assemblies.
There are no hierarchical Namespaces or directory structures, only pods!
Use entire pods or single classes.
Rename imported classes to avoid name clashes.
Build pods with Fantom scripts named build.fan (No need for Visual Studio...)
pods may also contain source code, documentaion, images, resources...

9. Unit Testing

select all

   
class MyUnitTest : Test {

  // called before every test method
  override Void setup() { ... }
  // called before after test method
  override Void teardown() { ... }

  // test method
  Void testStuff() {
    // verify methods are in Test 
    super.verifyEq(21 * 2, 42)
    // 'super' is optional
    verifyNotNull(43)
  }
}

Differences from C#

Fantom has Unit testing Built-in!
Just extend the Test class.
setup and teardown methods.
Run from the cmd line with:
C:\>fant MyUnitTest.fan

10. Null or Not-Null!?

select all

class Nullables {
  Void main() {
    Str  neverNull := "hello"
    Str? maybeNull := "moto"

    neverNull = null  // compilation error
    maybeNull = null  // okay

    // null-safe operator 
    maybeNull?.reverse()

    // elvis operator
    notNull := maybeNull ?: "wotever"
  }
}

Differences from C#

No more NullReferenceExceptions!
Every type has a nullable and not-nullable version
Only nullable types can be null - you're in control!
Null safe shortcut operators
Elvis operators

Beginner

Fun

Popular

Fantom Syntax for C# Programmers

This slideshow shows some of the syntactical differences between Fantom and C#. Each slide displays a concise Fantom code example and explains how it differs from C#.

Click a title below to show the slide above, then mouse hover over it to prevent cycling.

Try out any example online, with the Fantom Coding Ground!

Edits

29 July 2016 - Restyled and reworded as part of the article migration to alienfactory.co.uk.

3 November 2015 - Original article.

Written by Steve Eynon ( ) on 3rd November 2015
Last edited on 29th July 2016
Tags: Beginner, C#, Fun, Popular

Syntax Showdown - Fantom vs C#

1. Hello Fantom!

Differences from C#

2. Literals

Differences from C#

3. Maps and Lists

Differences from C#

4. Fields

Differences from C#

5. Methods

Differences from C#

6. Classes

Differences from C#

7. Mixins

Differences from C#

8. Packaging

Differences from C#

9. Unit Testing

Differences from C#

10. Null or Not-Null!?

Differences from C#

Fantom Syntax for C# Programmers

Edits

Discuss