Crates.io | skiff |
lib.rs | skiff |
version | 0.4.5 |
source | src |
created_at | 2021-06-14 23:27:03.28005 |
updated_at | 2021-09-06 23:50:32.594955 |
description | An immutability-first, functional scripting language with a friendly syntax and compiler/interpreter written in Rust! |
homepage | https://skiff.paulbiberstein.me/ |
repository | https://github.com/P-bibs/skiff |
max_upload_size | |
id | 410160 |
size | 175,164 |
A gradually-typed, functional scripting language with a friendly syntax and interpreter written in Rust!
You can run Skiff in the Skiff web editor (powered by WASM!).
If you prefer to use your own text editor, you can install Skiff from crates.io and run it from the command line
cargo install skiff
skiff <filename> # make sure installed crate binaries are in your PATH
Skiff started as a personal project for me to learn more about the design and implementation of programming languages. It was a mash-up of ideas and syntaxes from existing languages. As it evolved, however, it became a platform for me to learn about different algorithms like HM type inference and exhaustiveness checking of pattern match expressions.
Next on the road map is an exploration of gradual typing by adding a typed
keyword to distinguish fully type functions from partially typed functions. By default, Skiff will have very few static guarantees. However, you can opt into more checks within a given function by fully annotating the arguments and return type or using the typed
keyword to tell Skiff to infer a function type. The goal is to have a language that is as easy to use as a dynamically-typed language while offering some of the guarantees and in-code documentation of statically-typed languages.
# function definition (types are optional)
def fact(n: Number) -> Number:
match n:
| 1 => 1
| n =>
let next = fact(n - 1)
next * n
end
end
# conditionals
let cond: Boolean = true
if cond:
1
elif false:
2
else:
3
end
# algebraic datatypes (types are optional)
data Option:
| some(v: Number)
| empty()
end
# pattern matching
match some(1):
| some(n) => n
| empty() => 0
end
# anonymous functions
let increment: Number -> Number = lambda(n): n + 1 end
let add: (Number, Number) -> Number = lambda(a,b): a + b end
Full docs are a work in progress. To get an idea of what the features and syntax look like, you can look at the language tour test file.
Clone the repo to work on Skiff. You can run a local development version using
cargo run -- <filename>
For example:
cargo run -- tests/files/success/plus_and_times_precedence.boat
Language Features:
Tree Walk Interpreter | Bytecode Interpreter | |
---|---|---|
Arithmetic | ✓ | |
Equality Operators | ✓ | |
Conditionals | ✓ | |
Functions | ✓ | |
Recursion | ✓ | |
Lambdas | ✓ | |
Let binding | ✓ | |
Improved Error Reporting | ✓ | |
Type Annotations | ✓ | |
Type Inference | ✓ | |
Algebraic Datatypes | ✓ | |
Pattern Matching | ✓ | |
Exhaustiveness Checking | ✓ | |
Call Stack Traces | ✓ | |
Parameterized Types | ||
typed keyword |
||
Strings | ||
File Operations | ||
Testing Constructs |
Miscellaneous: