mers

Mers is a high-level programming language. It is designed to be safe (it doesn't crash at runtime) and as simple as possible.

what makes it special

Simplicity

Mers is simple. There are only few expressions:

• Values (1, "my string", ...)
• Blocks ({})
• Tuples (())
• Assignments (=)
• Variable initializations (:=)
• Variables (my_var, &my_var)
• If statements (if <condition> <then> [else <else>])
• Functions (arg -> <do something>)
• Function calls arg.function

Everything else is implemented as a function.

Types and Safety

Mers is built around a type-system where a value could be one of multiple types.

x := if condition { 12 } else { "something went wrong" }

In mers, the compiler tracks all the types in your program, and it will catch every possible crash before the program even runs: If we tried to use x as an int, the compiler would complain since it might be a string, so this does not compile:

list := (1, 2, if true 3 else "not an int")
list.sum.println

Type-safety for functions is different from what you might expect. You don't need to tell mers what type your function's argument has - you just use it however you want as if mers was a dynamically typed language:

sum_doubled := iter -> {
  one := iter.sum
  (one, one).sum
}
(1, 2, 3).sum_doubled.println

We could try to use the function improperly by passing a string instead of an int:

(1, 2, "3").sum_doubled.println

But mers will catch this and show an error, because the call to sum inside of sum_doubled would fail.

(note: type-checks aren't implemented for all functions yet - some are just todo!()s, so mers will crash while checking your program. you may need to use --check no to get around this and deal with runtime panics for now)

Error Handling

Errors in mers are normal values. For example, ("ls", ("/")).run_command has the return type ({Int/()}, String, String)/RunCommandError. This means it either returns the result of the command (exit code, stdout, stderr) or an error (a value of type RunCommandError).

So, if we want to print the programs stdout, we could try

(s, stdout, stderr) := ("ls", ("/")).run_command
stdout.println

But if we encountered a RunCommandError, mers couldn't assign the value to (s, stdout, stderr), so this doesn't compile. Instead, we need to handle the error case, using the try function:

(
  ("ls", ("/")).run_command,
  (
    (s, stdout, stderr) -> stdout.println,
    error -> error.println,
  )
).try

docs

docs will be available in some time. for now, check mers_lib/src/program/configs/*