effect Fail with
fail: Unit -> I32
safe_div (x: I32) (y: I32) : I32 can Fail =
if y != 0
then x / y
else fail ()
// Unlike exceptions, we can choose to either stop on error, or resume with a value:
default_value (value: I32) (f: Unit -> a can Fail) : Unit =
handle f ()
| fail () -> resume value
safe_div 1 0 with default_value 42 //=> 42vec = mut Vec.of [1, 2, 3]
ref1 = &mut vec
ref2 = &mut vec
// Ok! It is safe to call `Vec.push` with shared mutable references
push ref1 4
push ref2 5
// Retrieving a reference to an element wouldn't be safe since another mutable
// reference could reallocate the vector and cause it to be a dangling reference
// error: `get` requires an owned reference. Try `get_cloned` instead
elem = get ref1 0// Generators are implemented via Algebraic Effects
effect Emit elem with
emit: elem -> Unit
// One advantage of Generators is that they are easier to write than Iterators
map (stream: Unit -> Unit can Emit a) (f: a -> b) can Emit b =
handle stream ()
| Emit elem ->
emit (f elem)
resume ()
// Stream is a helper trait to Emit all elements of a collection
parse_csv (text: s) : Vec (Vec String) given Stream s String =
lines text |> skip 1 |> map (split _ ",") |> collect
csv = parse_csv (File.open "input.csv")//A collection c of elements of type e
trait Collection c -> e with
len: c -> Usz
get: c -> index:Usz -> e
trait Show t with to_string: t -> String
effect Print with print: String -> Unit
// Inferred type:
// elem_to_string: a -> Usz -> String
// given Collection a b, Show b
// can Print
elem_to_string c i =
get c i |> to_string |> printRead the latest blog posts
Ante’s goal was always to be a slightly higher level language than Rust. I always imagined Ante to fill this gap in language design between higher-level garbage collected languages like Java, Python, and Haskell, and lower level non-garbage collected languages like C, C++, and Rust. I still think there’s room there for a language which tries to manage things by default but also allows users to manually do so if needed as an optimization.
Introduction Algebraic Effects are a useful abstraction for reasoning about effectful programs by letting us leave the interpretation of these effects to callers. However, most existing literature discusses these in the context of a pure functional language with pervasive sharing of values. What restrictions would we need to introduce algebraic effects into a language with ownership and borrowing - particularly Ante?1 Ownership Consider the following program: effect Read a with read : Unit -> a the_value (value: a) (f: Unit -> b can Read a) : b = handle f () | read () -> resume value This seems like it’d pass type checking at first glance, but we can easily construct a program that tries to use the same moved value twice:
This is part of Ante’s goal to loosen restrictions on low-level programming while remaining fast, memory-safe, and thread-safe. Background When writing low-level, memory-safe, and thread-safe programs, a nice feature that lets us achieve all of these is an ownership model. Ownership models have been used by quite a few languages, but the language which popularized them was Rust. In Rust, the compiler will check our code to ensure we have no dangling references and cannot access already-freed memory (among other errors).
Template by Bootstrapious. Ported to Hugo by DevCows.
