Programs

​

The smallest program

## The smallest program: one line of output (RFC-0013 §1, tracker row C10).
## `mz run examples/hello.mz` prints `hello, world`; CI compares it with hello.expected.
program hello

  fn main
    print("hello, world")
  end fn main

end program hello

$ mz run examples/hello.mz
hello, world

​

Functions, bindings and when

## Fibonacci numbers by recursion, in RFC-0013's foundation slice (§18.1): functions,
## calls, `let`, `var`, `when`, integer arithmetic and `print`, and no loops yet.
## `mz run examples/fib.mz` prints what fib.expected holds; CI compares the two.
program fib

  fn main
    print("fib(9) is {fib(9)}")
    let n = 20
    let f = fib(n)
    print("fib({n}) is {f}")
    var total = 0
    total = total + fib(10)
    total = total + fib(11)
    print("fib(10) + fib(11) is {total}, and that is fib(12): {total is fib(12)}")
    print(parity(f))
  end fn main

  fn fib(n: int): int
    when n < 2
      return n
    end
    return fib(n - 1) + fib(n - 2)
  end fn fib

  fn parity(n: int): text
    when n % 2 is 0 and n > 0
      return "{n} is even"
    else
      return "{n} is odd, or not positive"
    end
  end fn parity

end program fib

fib(9) is 34
fib(20) is 6765
fib(10) + fib(11) is 144, and that is fib(12): true
6765 is odd, or not positive

• fn name(a: int, b: text): int … end fn name: typed parameters, a return type or none, calls and recursion. Every path of a function with a return type returns (MZ0906); a wrong call is MZ0905, quoting the signature.
• let binds a value once; var binds one you assign with =. Scope is the block. There is no shadowing (MZ0921), a name is readable from the line after its binding to the end of its block (MZ0920), and assigning to a let is MZ0922. Python’s bare first assignment, Go’s := and Rust’s let mut each get a fix.
• when / else when / else, closed by end. A condition is a bool and nothing else: Mzizi has no truthiness (MZ0712).
• return ends a function early. print(value) writes one value’s text form and a newline; to print several, interpolate them into one text.
• Comments are lines starting with ##. // and # are MZ0911, with ## as the exact fix.

​

Values: int, float, bool and text

​

Expressions and operators

​

Control flow

  enum shape
    circle
    square
    triangle
  end

  fn fizzbuzz(n: int): text
    when n % 15 is 0
      return "FizzBuzz"
    else when n % 3 is 0
      return "Fizz"
    else when n % 5 is 0
      return "Buzz"
    end
    return "{n}"
  end fn fizzbuzz

  fn corners(s: shape): int
    match s
      case circle
        return 0
      case square
        return 4
      case triangle
        return 3
    end
  end fn corners

  fn odd_sum(limit: int): int
    var total = 0
    for each i in range(0, to = 100)
      when i >= limit
        break
      end
      when i % 2 is 0
        continue
      end
      total = total + i
    end
    return total
  end fn odd_sum

  fn collatz(start: int): int
    var n = start
    var steps = 0
    while n is not 1
      n = match n % 2
        case 0
          n / 2
        else
          3 * n + 1
      end
      steps = steps + 1
    end
    return steps
  end fn collatz

• match <value> takes case lines, each listing one or more values (case 6 7), then an optional else, over an enum, an int, a text or a bool. It is checked for exhaustiveness: a missing case is MZ0930, naming the missing variants, and a case that can never run is MZ0931, whose exact fix deletes it. A match over a float is MZ0711: compare a float with when.
• for each i in range(a, to = b) counts from a up to but not including b. range is read only on a for each line; for each over a list waits for lists.
• while <condition> is the one conditional loop; while true with a break is the loop that ends from inside. break and continue act on the innermost loop, and are MZ0935 outside one.
• when and match as values. Either may be the whole value of a let, a var, an assignment or a return, each branch one expression line; nowhere else, and there is no ternary (MZ0932).
• Other languages’ spellings are fixed. elif, else if, switch, default:, case _ and _ => are MZ0933; for x in xs, for (const x of xs), loop and range(n) are MZ0934, each with an exact fix. An else when chain over one enum’s variants is MZ0936, with a guess fix rewriting it as a match.

​

Errors: result, error and try

## Checks ages: one function fails with an error, its callers handle it with `match` or
## propagate it with `try`, and `main` itself returns a result (RFC-0013 §12).
program errors

  enum age_problem
    negative say "is below zero"
    too_old  say "is above 150"
  end

  fn main: result(none, age_problem)
    print(describe(42))
    print(describe(-3))
    print(describe(200))
    let total = try total_age(20, 22)
    print("20 and 22 make {total}")
    match total_age(20, 151)
      case ok sum
        print("20 and 151 make {sum}")
      case error problem
        print("20 and 151 were rejected: {problem} {problem.say}")
    end
  end fn main

  fn check_age(n: int): result(int, age_problem)
    when n < 0
      return error(negative)
    end
    when n > 150
      return error(too_old)
    end
    return n
  end fn check_age

  fn describe(n: int): text
    match check_age(n)
      case ok age
        return "age {age} is fine"
      case error problem
        return "{n} is rejected: {problem} {problem.say}"
    end
  end fn describe

  fn total_age(a: int, b: int): result(int, age_problem)
    return try check_age(a) + try check_age(b)
  end fn total_age

end program errors

age 42 is fine
-3 is rejected: negative is below zero
200 is rejected: too_old is above 150
20 and 22 make 42
20 and 151 were rejected: too_old is above 150

• A function that can fail returns result(T, E), or result(none, E). return v returns success, return error(e) returns failure, and return r passes a result of the function’s own type through.
• A caller matches the result, with exactly two cases, case ok <name> and case error <name>, or propagates its error with a prefix try, in a function that returns a result with the same error type.
• Any other use of a result is MZ0950: discarding it, printing it, comparing it, passing it or holding it in a var. A result is never a parameter, nor inside another result.
• fn main may return result(none, E). When it returns an error, the program writes mz: error MZ0992: main returned an error: <the error's text form> to standard error and exits 1.
• Other languages’ idioms are MZ0952: Ok(v) (exact v), Err(e) (exact error(e)), Rust’s postfix ? (exact prefix try), throw e and raise e (return error(e)), and .unwrap() and .expect(…), which have no fix: an error is never turned into a crash.

​

mz run

mz run [--release] <file.mz>     check, lower, build with cargo, run
mz build <file.mz> --out <dir>   write the same Rust package

1. Check. On any error it prints the diagnostics, exits 3, and does not build.
2. Lower. It writes a Cargo package with no dependencies into <name>-<path hash> under $MZ_CACHE_DIR, or mzizi/mz-run/ under $XDG_CACHE_HOME or ~/.cache. With none of the three set it exits 2 and names them; it never falls back to the system’s temporary directory.
3. Build. cargo build --offline --quiet, with --release when asked. No dependencies means no network.
4. Run. The binary runs with the terminal’s standard input, output and error. Standard output belongs to the program; everything mz run writes of its own goes to standard error.

​

Nesting is capped

​

What is not built

• Lists, maps and sets in a program, indexing, and for each over a list (C7).
• Text methods (C6), records and methods (C8), options in function bodies, and a decimal type.
• Named arguments beyond range’s to, try … via f (MZ0955), and a match stub as the fix for MZ0950.
• A program’s contract block, mz test, mz run --agent, and mz outline, mz ir and mz hash on a program, which exit 2.
• Modules: one program per file, and nothing is imported.