General Syntax

Type Binding

Some name may be bound to some type by using the : (colon) syntax.

name: Type

Type bindings are used for all such occurrences. This includes:

Value Binding

Some name may be bound to some value by using the := syntax.

name := value
name: Type := value

Comments

Comments are lines where the first non-whitespace characters are --. This was selected for ease of typing paired with low visual noise.

-- this is a comment
-- this is another comment
let x := "foo" -- this will not compile, comments cannot be mixed with code

Ava does not support multi-line comments.

Code Documentation

Code documentation is written using comments that both directly-precede certain definitions and have 3 - characters:

--- This function does some foo as well as some bar.
--- @param x Documentation for the `x` parameter.
fn foo_bar: (x: String) => Int32

Block Definitions

All block definitions are closed by a companion end keyword that refers to the initating keyword.

fn foo: () => ()
    ()
end fn

given A
class Bar
    fn foo2: () => ()
end class

instance Bar[A]
    fn foo2: () => ()
        ()
    end fn
end instance

enum Color
    object Red
    object Green
    object Blue
end enum

fn control_if: () => ()
    if 1 + 1 > 2 then
        ()
    else if 2 + 2 > 4 then
        ()
    else
        ()
    end if
end fn

fn control_do: () => Option[Int32]
    do
        x <- Some(1)
        y <- Some(2)
    return x + y
end fn

fn control_match: () => Int32
    match "foo"
        case "foo" => 1
        case _ => 0
    end match
end fn

infix plus: (left: Int32, right: Int32) => Int32
    left + right
end infix

1.8 KiB Raw Blame History