val (eval) is a simple arbitrary precision calculator language built on top of chumsky and ariadne.
val should run on any system, including Linux, MacOS, and the BSDs.
The easiest way to install it is by using cargo, the Rust package manager:
Pre-built binaries for Linux, MacOS, and Windows can be found on the releases page.
The primary way to use val is via the provided command-line interface. There is currently ongoing work on a Rust library and web playground, which will provide a few extra ways to interact with the runtime.
Below is the output of val --help, which describes some of the arguments/options we support:
Running val on its own will spawn a repl (read–eval–print loop) environment, where you can evaluate arbitrary val code and see its output immediately. We use rustyline for its implementation, and we support a few quality of life features:
- Syntax highlighting (see image above)
- Persistent command history
- Emacs-style editing support by default
- Filename completions
- Hints (virtual text pulled from history)
The val language supports not only expressions, but quite a few statements as well. You may want to save val programs and execute them later, so the command-line interface provides a way to evaluate entire files.
For instance, lets say you have the following val program at factorial.val:
You can execute this program by running val factorial.val, which will write to standard output 120.
Lastly, you may want to evaluate a val expression and use it within another program. The tool supports executing arbitrary expressions inline using the --expression or -e option:
n.b. The --expression option and filename argument are mutually exclusive.
This section describes some of the language features val implements in detail, and should serve as a guide to anyone wanting to write a val program.
val supports a few statement constructs such as if, while, loop, fn, return, etc. Check out the grammar for all of the various statement types.
Here's an example showcasing most of them in action:
val supports a variety of expressions that can be combined to form more complex operations:
| Arithmetic | Addition | a + b | 1 + 2 |
| Subtraction | a - b | 5 - 3 | |
| Multiplication | a * b | 4 * 2 | |
| Division | a / b | 10 / 2 | |
| Modulo | a % b | 7 % 3 | |
| Exponentiation | a ^ b | 2 ^ 3 | |
| Negation | -a | -5 | |
| Logical | And | a && b | true && false |
| Or | a || b | true || false | |
| Not | !a | !true | |
| Comparison | Equal | a == b | x == 10 |
| Not Equal | a != b | y != 20 | |
| Less Than | a < b | a < b | |
| Less Than or Equal | a <= b | i <= 5 | |
| Greater Than | a > b | count > 0 | |
| Greater Than or Equal | a >= b | value >= 100 | |
| Other | Function Call | function(args) | sin(x) |
| List Indexing | list[index] | numbers[0] | |
| List Creation | [item1, item2, ...] | [1, 2, 3] | |
| List Concatenation | list1 + list2 | [1, 2] + [3, 4] | |
| String Concatenation | string1 + string2 | "Hello, " + name | |
| Variable Reference | identifier | x |
val has several primitive value types:
Numeric values are represented as double-precision floating point numbers:
Boolean values represent truth values:
Text values enclosed in single or double quotes:
Collections of values of any type:
A function is a value, and can be used in assignments, passed around to other functions, etc.
Check out the higher order functions example for how this works.
val offers a ton of built-in functions and constants. Below documents them:
| Constants | pi | Mathematical constant π (≈3.14159) | area = pi * r^2 |
| e | Mathematical constant e (≈2.71828) | growth = e^rate | |
| Trigonometric | sin(x) | Sine of x (radians) | sin(pi/2) |
| cos(x) | Cosine of x (radians) | cos(0) | |
| tan(x) | Tangent of x (radians) | tan(pi/4) | |
| csc(x) | Cosecant of x (radians) | csc(pi/6) | |
| sec(x) | Secant of x (radians) | sec(0) | |
| cot(x) | Cotangent of x (radians) | cot(pi/4) | |
| Inverse Trig | asin(x) | Arc sine (-1≤x≤1) | asin(0.5) |
| acos(x) | Arc cosine (-1≤x≤1) | acos(0.5) | |
| arc(x) | Arc tangent | arc(1) | |
| acsc(x) | Arc cosecant (abs(x)≥1) | acsc(2) | |
| asec(x) | Arc secant (abs(x)≥1) | asec(2) | |
| acot(x) | Arc cotangent | acot(1) | |
| Hyperbolic | sinh(x) | Hyperbolic sine | sinh(1) |
| cosh(x) | Hyperbolic cosine | cosh(1) | |
| tanh(x) | Hyperbolic tangent | tanh(1) | |
| Logarithmic | ln(x) | Natural logarithm | ln(e) |
| log2(x) | Base-2 logarithm | log2(8) | |
| log10(x) | Base-10 logarithm | log10(100) | |
| e(x) | e raised to power x | e(2) | |
| Numeric | sqrt(x) | Square root (x≥0) | sqrt(16) |
| ceil(x) | Round up to integer | ceil(4.3) | |
| floor(x) | Round down to integer | floor(4.7) | |
| abs(x) | Absolute value | abs(-5) | |
| Collections | len(x) | Length of list or string | len("hello") |
| sum(list) | Sum list elements | sum([1,2,3]) | |
| Conversion | int(x) | Convert to integer | int("42") |
| float(x) | Convert to float | float("3.14") | |
| bool(x) | Convert to boolean | bool(1) | |
| list(x) | Convert to list | list("abc") | |
| I/O | print(...) | Print without newline | print("Hello") |
| println(...) | Print with newline | println("World") | |
| input([prompt]) | Read line from stdin | name = input("Name: ") | |
| String | split(str, delim) | Split string | split("a,b,c", ",") |
| join(list, delim) | Join list elements | join(["a","b"], "-") | |
| Program | exit([code]) | Exit program | exit(1) |
| quit([code]) | Alias for exit | quit(0) |
bc(1) - An arbitrary precision calculator language
English (US) ·