# Example of some things you can do with the 'fun' syntax
# Define functions like this:
# By default they accept and return any type
(Def1) = ((λa a) (λb b))
# You can call a definition by just referencing its name.
# It will be substituted in place of the reference.
(Def2) = ((λa a) Def1)
# Definitions and variables can have names in upper and lower case and
# contain numbers, '.', '-', '_' and '/'.
# Names defined in a more inner position shadow names in an outer position.
(def3) = ((λDef1 Def1) (λx λx x))
# You can annotate a function with the expected types and Bend will check them.
# The parentheses on the left side of the definition are optional.
const (a: A) (b: B) : A = a
# There are three types of native numbers available: u24, i24 and f24.
# u24: Unsigned 24-bit integers
# i24: Signed 24-bit integers
# f24: Floating point numbers with 24-bit precision
(unsigneds (x1: u24) (x2: u24)) : u24 = (* (+ x1 1) (/ (- x2 2) 1))
# '+' or '-' are mandatory for i24.
(signeds (x1: i24) (x2: i24)) : i24 = (* (+ x1 +1) (/ (- x2 -2) +1))
# The '.' is mandatory for f24.
(floats (x1: f24) (x2: f24)) : f24 = (* (+ x1 1.0) (/ (- x2 -2.0) +1.0))
# Numeric operations are only meaningful on native numbers.
# You can force the compiler to do it anyway by using untyped values.
id = λx x # 'id' wasn't given a type so it's inferred as 'Any'.
bad_nums : Any = (+ id 1)
# You can use numbers on the native match expression
# The `+` arm binds the `scrutinee`-1 variable to the value of the number -1
(Num.pred) = λn
switch n {
0: 0
_: n-1
}
# Write new data types like this
type Option = (Some val) | None
type Bool = True | False
# You can have pattern matching on definitions
# Use `*` to ignore a pattern
(Option.unwrap_or (Option/Some val) *) = val
(Option.unwrap_or Option/None or) = or
(Bool.or Bool/True *) = Bool/True
(Bool.or * Bool/True) = Bool/True
(Bool.or * *) = Bool/False
# Or using a match expression
(Bool.not) = λbool
match bool {
Bool/True: Bool/False
Bool/False: Bool/True
}
# Data types can store values
type Boxed T = (Box (val: T))
# Types with only one constructor can be destructured using `open`,
# a single matching definition or a 'match'.
(Box.map (Boxed/Box val) f) = (Boxed/Box (f val))
(Box.unbox (box: (Boxed T))): T = open Boxed box; box.val
# Use tuples to store two values together without needing to create a new data type
(Tuple.new fst snd) =
let pair = (fst, snd)
pair
# Then you can destructure it inside the definition or using `let`
(Tuple.fst (fst, snd)) = fst
(Tuple.snd) = λpair
let (fst, snd) = pair
snd
# You can give type annotations to type definitions as well.
# The recursive fields should be annotated with a '~'.
type ListList T =
(Cons (head: (List T)) ~(tail: (ListList T))) |
Nil
# Bend functions usually center around recursion
sum (List/Nil) = 0
sum (List/Cons x xs) = (+ x (sum xs))
sum_list (ListList/Nil) = List/Nil
sum_list (ListList/Cons x xs) = (List/Cons (sum x) (sum_list xs))
# To create local recursive functions that consume a recursive type, you can use 'fold'.
sum_list2 ll = fold ll {
# The fold is implicitly called for fields marked with '~' in their definition.
# In this case, 'll.tail' is replaced with a recursive call to the fold.
ListList/Cons: (List/Cons (sum ll.head) ll.tail)
ListList/Nil: List/Nil
}
# To do the opposite and create a recursive structure, you can use 'bend'.
# 'bend' can be seen as a tree-like generalization of a while loop.
new_list = bend x = 0 {
when (< x 10):
# 'fork' calls the bend recursively with the provided values.
(List/Cons x (fork (+ x 1)))
else:
List/Nil
}
# To make programs that are more parallelizable, you generally want to
# avoid lists and use tree-like structures with multiple recursion instead.
sum_nums from to =
if (< from to) {
(+
(sum_nums from (/ 2 (+ from to)))
(sum_nums (+ 1 (/ 2 (+ from to))) to))
} else {
from
}
# Internally, each variable is only used once. If you use a variable
# is used more than once, the compiler will insert duplications for you.
#
# You can also write them manually with 'let {a b} = ...', but then
# your function needs to be unchecked, either by not annotating it
# with types or by marking it as unchecked.
unchecked (def4) = λz let {z1 z2} = z; (z1 ((λx (x x x x x)) z2))
# Duplicating a term that duplicates a variable is not allowed and will break the program.
map f (List/Cons x xs) = (List/Cons (f x) (map f xs)) # 'f' is duplicated here
map f (List/Nil) = List/Nil
# 'map' duplicated the lambda which duplicates 'a'.
# Although this is well defined, it does not produce a sound lambda-calculus result.
VeryBad (a: u24) (xs: (List u24)) : (List u24) =
(map
λ x (+ (* a x) a) # 'a' is duplicated here
[1, 2, 3, 4, 5])
# All files must have a main definition to run.
# You can execute a program in Bend with "bend run <path to file>"
# Other options are "check" to just see if the file is well formed
# and "gen-hvm" to output hvm code.
(main) =
let tup = (Tuple.new Option/None (Num.pred 5))
let fst = (Tuple.fst tup)
let snd = (Tuple.snd tup)
let box = (Boxed/Box fst)
let map = (Box.map box Option.unwrap_or)
let unboxed = ((Box.unbox map) snd)
(unsigneds 3 unboxed)