Rufus is a programming language for people that build and operate fault tolerant systems.
module main
import "fmt"
func main() {
fmt.Println("Hello, world!")
}
Primitive types:
transport atom = :bicycle
truthy bool = true
answer int = 42
pi float = 3.14159265359
greeting string = "Hello, world!"
Constants:
const Pi = 3.14159265359
Collection types:
list[int]
empty = list[int]{}
numbers = list[int]{1, 2, 3, 4, 5}
list[int]{head|tail} = numbers
map[atom]string
empty = map[atom]string{}
alice = map[atom]string{:name => "Alice", :age => "34"}
set[int]
empty = set[int]{}
primes = set[int]{2, 3, 5, 7}
tuple[string,int]
alice = tuple[string,int]{"Alice", 34}
type Person tuple[string,int]
alice = Person{"Alice", 34}
type Person struct {
Name string
Age int
}
alice = Person{Name => "Alice", Age => 34}
fmt.Printf("%s is age %d", [alice.Name, alice.Age])
Function types:
func Echo(text string) string {
text
}
Higher order functions:
func Map(items list[int], fn func(int) int) list[int] {
mapOver(list[int]{}, items, fn)
}
func mapOver(acc list[int], list[int]{head|tail}, fn func(int) int) list[int] {
map(list[int]{fn(head)|acc}, tail, fn)
}
func mapOver(acc list[int], list[int]{}, func(int) int) list[int] {
List.Reverse(acc)
}
Anonymous function with multiple heads:
fn = func {
match (int) int ->
// ...
match (string) string ->
// ...
}
Named tuple:
type Point tuple[X int, Y int, Z int]
point = Point{X => 2, Y => 5, Z => -1}
point.X = 2
Anonymous union type:
func Teleport(point Point) :ok | Error {
// ...
}
Named union type:
type Outcome :ok | Error
func Teleport(point Point) Outcome {
// ...
}
Pattern match expression:
point = Point{X => 3, Y => -6, Z => 13}
case Teleport(point) {
match :ok ->
// ...
match err error.T ->
// ...
}
Modules and imports:
module server
import (
"log"
"github.com/rufus-lang/echo"
)
Generics:
func Map(items list[T?], fn func(T?) T?) list[T?] {
mapOver(list[T?]{}, items, fn)
}
func mapOver(acc list[T?], list[T?]{head|tail}, fn func(T?) T?) list[T?] {
mapOver(list[T?]{fn(head)|acc}, tail, fn)
}
func mapOver(acc list[T?], list[T?]{}, func(T?) T?) list[T?] {
List.Reverse(acc)
}
The first type that binds to T? is substitued everywhere T? is mentioned.
Error handling:
file = os.OpenFile("/path/to/file")
try {
// ...
} catch os.ReadError {
// ...
} after {
os.CloseFile(file)
}
try {
os.OpenFile("/path/to/file")
} catch {
match os.FileNotFound ->
// ...
match RuntimeError ->
// ...
}
file = os.OpenFile("/path/to/file")
try {
// ...
} after {
os.CloseFile(file)
}