Fire Script

123        // integer (64bit)
123u       // unsigned integer (64bit)
0b101101   // binary integer
0o765      // octal integer
0xBEEFED   // hexadecimal integer
42d        // integer (32bit)
42h        // integer (16bit)
42ud       // unsigned integer (32bit)
12.3       // floating point (64bit)
12.3f      // floating point (32bit)
'@'        // unicode character
b'@'       // byte / ASCII character
42b        // byte (8bit integer, unsigned)
"lava"     // string (UTF-8)
b"lava"    // bytes (ASCII string)
"""abc"""  // raw string (here doc)
b"""abc""" // raw bytes
("abc",42) // tuple
[1, 2, 3]  // list
[]:[Byte]  // empty list (type can be specified or inferred from context)
{}         // empty block, has type () -> () (no parameters, no return value)
()         // empty tuple (value of zero size)
void       // alias of ()

a = """Hello"""     // `Hello`
b = """
    stripped
    """             // `stripped`
c = """
    \n\0\ <- not special
    """             // `\n\0\ <- not special`
d = """
    no indent removal
"""                 // `    no indent removal`
e = """
    partial indent removal
  """               // `  partial indent removal`
f = """not stripped
"""                 // `not stripped<nl>`
g = """
    not stripped""" // `<nl>    not stripped`
h = """

first/last nl stripped

"""                 // `<nl>first/last nl stripped<nl>`
i = """
    \""""escaped quotes\""""
    """             // `""""escaped quotes""""`
j = """
    \""""
    \\""""
    \\\""""
    """             // `""""<nl>\""""<nl>\\""""`
k = """\""" <- escaped! """
l = """
\
"""                 // `\` (trailing backslash requires multi-line)

// define some names in a scope:
{ a = 1; b = 2 }    // the whole expression evaluates to ()
a                   // ERROR - `a` is not defined in outer scope

// block returns `a`, `c` evaluates to `1`
c = { a = 1; a }

// the outer scope is visible inside the block
x = 1; y = { x + 2 }

neg 42           // => -42
add (1, 2)       // => 3
sub (1 + 2, 3)   // => 0
(1, 2) .add      // dot-call
1 .add 2         // infix style dot-call

foo .push bar
"string".len

one = 1; one.add 2    // ok, but bad style
1.add 2               // parse error, "add" might be float suffix
(1).add 2             // ok, but better add a space before the dot
one. add 2            // ok, but bad style
1 . add 2             // ok, but bad style

"{} {}" .format ("hello", 91)
"string".len

1 .add 2 .mul 3  // => 9
(1 .add 2).mul 3  // => 9
1 .add (2 .mul 3)  // => 7

// all these lines are equivalent
uniq (sort (a_list))        // forced right-to-left evaluation
a_list .sort .uniq          // implicit left-to-right evaluation
((a_list) .sort) .uniq      // the same, explicit

// also equivalent, the general rule still applies
list_1 .cat (list_2, list_3) .sort .uniq
cat (list_1, list_2, list_3) .sort .uniq

neg 1 .add 2  // => 1
(neg 1) .add 2  // equivalent
f 1 .combine 2 3  // evaluated left-to-right
((f 1).combine 2) 3  // equivalent

1 + 2 / 3 == 1 + (2 / 3)
-(1 + 2)

// type is inferred
i = 1

// right-hand side can be any expression
j = 1 + 2
k = add (1, 2)

// error, redefinition of a name
k = 1; k = 2

// ok, inner `l` has its own scope
l = 1; { l = 2 }

// error: type of 'm' cannot be inferred
// (the third 'm' refers to the second one, not the first, outer one)
m = 1; { m = m + 1 }

// variable type can be explicitly declared
l:Int32 = k
s:String = "XCI"

a = 1                // [1.] literal value
b = add (1, 2)       // [2.] result of expression
data c = add (1, 2)  // [3.] constant value initialized with a result of a (constant) expression

a = write "hello\n"      // eager: prints "hello" immediately
a = { write "hello\n" }  // lazy: `a` becomes a function that prints "hello" when called

write "Hello "
flush
write "World!\n"

add2 = fun (a, b) {a + b}   // generic function - works with any type supported by op+
add2 (1, 2)
add2 (1.0, 2.0)

add2b = fun<T> (a:T, b:T) -> T {a + b}      // same as above, but with explicit type variable
add2c = fun (a:Int, b:Int) -> Int {a + b}   // specific, with type declarations
add2d : (Int, Int) -> Int = fun (a, b) {a + b}  // type declaration on left side (i.e. disable type inference)

// function definition can span multiple lines
add2e = fun (a:Int, b:Int) -> Int {
    a + b
}

// possible program main function
main = fun args:[String] -> Void {
    write "Hello World!\n"
}

type MyBook = (name: String, author: String, isbn: Int)
make_book = fun (name:String, author:String, isbn:Int) -> MyBook { (name, author, isbn):MyBook }
make_book (name="Title", author="Karel IV", isbn=12345)

eval2 = fun (f, a, b) { f (a, b) }
eval2 (add2, 1, 2)                  // calls `add2 (1, 2)`
eval2 (fun (a, b) {a + b}, 1, 2)    // calls anonymous function

sub2 = fun (a, b) { a - b }
choose = fun x { if (x == "add") then add2 else sub2 }
choose "add" (1, 2)
choose "sub" (1, 2)

block1 = { c = add2 (1, 2); c }    // returns closure c
block2 = { c = add2 (1, 2) }       // returns ()
block1  // evaluate the block (actually, it might have been evaluated above - that's up to compiler)

a = {f = fun x {5}}; f    // ERROR - block creates new scope - f is undefined outside
a = (f = fun x {5}); f    // ok - f is declared in outer scope

// C++ style operators, with similar precedence rules
// (exception is comparison operators)
1 + 2 * 3 ** 4 == 1 + (2 * (3 ** 4))
// Bitwise operators
1 | 2 & 3 >> 1 == 1 | (2 & (3 >> 1))

type MyRecord = (name: String, age: Int)
rec = ("A name", 42):MyRecord
rec.name    // dot operator

f : Int -> Int = fun a { a }
f : Float -> Float = fun a { a }
f : String -> String = fun a { a }

f = fun a:Int -> Int { a }
f = fun a:Float -> Float { a }  // error: redefined name f

a : Int = 2
a : String = "two"
a           // error - cannot be uniquely resolved
a:Int       // -> 2
a:String    // -> "two"
a:Int64     // error - cannot be uniquely resolved

// comment line

print "hello " /* inline comment */ "world"

/* multiline
   comment */

if x == "add" then add2 else sub2

a = if x > 0 then x
    if y > 0 then y
    if z > 0 then z
    else 0

if a > 1 then
    if a > 10 then 10
    else 1
else 0

if (
   x == "add" ||
   x == "add2"
)
then {
    fun a, b { a + b }
}
else {
    fun a, b { a - b }
}

class MyEq T {
    my_eq : (T, T) -> Bool
    my_ne : (T, T) -> Bool
}

class MyOrd T (MyEq T) {
    my_lt : (T, T) -> Bool
    my_gt : (T, T) -> Bool
    my_le : (T, T) -> Bool
    my_ge : (T, T) -> Bool
}

instance MyEq Int32 {
    my_eq = fun (a, b) { a == b }
    my_ne = fun (a, b) { a != b }
}

my_eq (3, 4)

match an_int {
    1         => "one"
    2         => "two"
    3 | 4 | 5 => "three to five"
    _         => "other"
}

match an_int { 1 => "one"; 2 => "two"; _ => "other" }

type MyVariant = int Int | string String | none
a : MyVariant = int 42
match a {
    int x     => x.to_string
    string x  => x
    none      => "<none>"
}

match a_list {
    []     => 0
    [x]    => x
    [x, y] => x + y
    [*z]   => sum(z)
}

let [first, *rest] = a_list

with (out=(open "/tmp/file.txt" "w"), err=stderr, in=stdin) {
    // output stream is now redirected to a file
    write "this goes to file.txt"
    flush
    // ...
}

type Streams = (in: Stream, out: Stream, err: Stream)
enter : Streams -> Streams
leave : Streams -> Void

with (open "/tmp/file.txt" "w")
    write "this goes to file.txt"

try {
    throw (Exception "Catch me!")
} catch ex:Exception {
    log "Exception caught!"
}

try this_may_throw
catch ex:Exception
    log "Exception caught!"

try
    this_may_throw
catch ex:T
    log "Exception caught!"

12d, 12:Int32       // Int32
12, 12:Int64        // Int64 (alias Int)
1.2f, 1.2:Float32   // Float32
1.2, 1.2:Float64    // Floaf64 (alias Float)
true, false         // Bool
b'a', 'a':Byte      // Byte=UInt8     -- ASCII
27b, 27:UInt8       // UInt8          -- binary 0..255
'a', 97:Char        // Char          -- Unicode (32bit code point)

b"abc"              // [Byte]
[10b, 11b, 13b]     // [Byte]         -- equivalent to the "bytes" literal
"Hello."            // String         -- UTF-8 string
['a', 'b', 'c']     // [Char]         -- compatible with String, but not the same
[1, 2, 3]           // [Int]          -- a list
("Hello", 33)       // (String, Int)  -- a tuple
()                  // () aka Void    -- empty tuple

ok = true           // inferred type Bool
c = 'a'             // inferred type Char
byte = 27b          // inferred type Byte
b1:Byte = 12        // ok
b2:Byte = 300       // error
b3:Byte = c         // error, not a literal, must be casted explicitly
b4:Byte = c:Byte    // cast ok, value clipped

type MyVoid = ()     // empty tuple => Void
type MyType = Int    // make new type by giving other type a new name
type MyTuple = (String, Int)
type MyStruct = (name:String, age:Int)    // struct (a tuple with named fields)
type MyBool = false | true   // enum
type MyUnion = Int | String | Void   // tagged union
type MyVariant = int Int | string String | none   // tagged union with explicit names
type MyOptional T = some T | none   // generic type (a kind?)
type MyOptionalInt = MyOptional Int   // instance of the generic type
type MyFunction = ([Int], Int) -> Int

type Number = Int
f = fun (a:Number, b:Number) -> Number { a+b }  // `add` must be implemented for Number
f (11, 22)   // OK, literals coerce
a = 11; b = 22:Number
f (a, a)   // Error: `f` expects Number, not Int
f (b, b)   // OK
f (a:Number, b)   // OK, returns 33:Number

type MyStruct = (name:String, age:Int)
// All of these initializations are valid:
a: MyStruct = ("Luke", 10)
a: MyStruct = (name="Luke", age=10)
a = ("Luke", 10):MyStruct
a = (name="Luke", age=10):MyStruct
// Variables and function return values need explicit cast
a = ("Luke", 10)
b: MyStruct = a   // Error: cannot assign (String, Int) to MyStruct
b: MyStruct = a: MyStruct  // OK
b = a: MyStruct  // same, type of `b` is inferred

get_age = fun st:MyStruct -> Int { st.age }
get_age a   // Error, variable does not coerce
get_age { ("Luke", 10) }  // Error, the block's return value doesn't coerce
get_age a:MyStruct  // OK

// Anonymous struct
a: (name: String, age: Int) = ("Luke", 10)
// Alias - the type of `a` is still an anonymous struct
Record = (name: String, age: Int)
a: Record = ("Luke", 10)

MyInt = Int
MyFun = String -> String

(a:Int, b:Int) -> Int               // with parameter names
(Int, Int) -> Int                   // without parameter names
((Int, Int), Int) -> Int            // two arguments, first is tuple
(Int, Int) -> Int -> Int            // function returning another function
Int -> Int -> Int -> Int            // curried function (this is different type than the previous one)

f1 = fun (a:Int, b:Int) -> Int = { a + b }
f2 = fun a:Int -> Int -> Int { fun b:Int -> Int { a + b } }
f1 (1, 2)
f2 1 2

decl x:Int  // declare x
y={x}       // reference x inside a block
x=7         // define x
y           // -> 7

decl f: Int->Int     // declare function f
w = fun x {2 * f x} // reference f inside another function
f = fun x {x + 1}   // define function f
w 7                 // -> 16

42:Int64
a = 42; a:Byte
(1 + 2):Int64
['a', 'b', 'c']:String   // -> "abc"

a = 42:Int64
// is equivalent to
a = (cast 42):Int64
// also equivalent to
a:Int64 = cast 42
// this won't work - the target type has to be specified somehow
a = cast 42

instance Cast MyType Int {
    cast = fun x:MyType { /* convert MyType to Int */ }
}

instance Cast Int MyType {
    cast = fun x:Int { /* convert Int to MyType }
}

Int64(42)
a = 42; Byte(a)
Int64(1 + 2)
String ['a', 'b', 'c']   // -> "abc"

a:Int64 = init 42
(init 42):Int64

type MyType = (Int, String)
instance Init Int MyType {
    init = fun a { (a, "Foo"):MyType }
}
MyType(42)  // -> (42, "Foo")
42:MyType  // Error, cast doesn't fall back to init

(42).Int64
42 .Int64
42.Int64  // Syntax error: could be float literal suffix
a = 42; a.Byte
['a', 'b', 'c'].String   // -> "abc"

nums = [1, 2, 3, 4, 5]
chars = ['a', 'b', 'c', 'd', 'e']

len nums == 5
empty nums == false

head nums == 1
tail nums == [2, 3, 4, 5]
last nums == 5
init nums == [1, 2, 3, 4]

take 3 nums == [1, 2, 3]
take 10 nums == [1, 2, 3, 4, 5]
drop 3 nums == [4, 5]
drop 10 nums == []

reverse nums == [5, 4, 3, 2, 1]
min nums == 1
max nums == 5
sum nums == 15

// zero-based index
nums ! 3 == 4
// note that this calls `nums` with list arg `[3]`
nums [3]   // not subscription!

cat (nums, [6, 7])              // =>  [1, 2, 3, 4, 5, 6, 7]
cat ("hello", [' '], "world")   // =>  "hello world"
cons (0, nums)                  // =>  [0, 1, 2, 3, 4, 5]

[1..10] == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
['a'..'z']

[2*x for x in [1..10] if x > 3]
[2*x | x <= [1..10], x > 3]

1 + 2
3 * _

_0 = void
_1 = executor (fun _ { 1 + 2 } _0)
_2 = executor (fun _ { 3 * _ } _1)

my_mod = import "my_mod"    // import only Declarations
my_mod::func                // run function imported from module `my_mod`
my_mod                      // run all associated Invocations

catch
class
else
fun
if
import
instance
in
match
module
then
try
type
with