Bend Programming Language

The bend keyword creates recursive data structures by binding a variable to the return of an inline recursive function.

Inside the when arm, the fork function is available to call the function recursively. fork must receive the same number of arguments as the number of state variables defined in the bend statement.

main =
  bend x = 0 {
    when (< x 3):
      (Tree/Node (fork (+ x 1)) (fork (+ x 1)))
    else:
      (Tree/Leaf x)
  }

You can initialize multiple state variables:

bend x = 0, y = 1 ... {
  when (condition x y ...):
    ...
}

In Bend/HVM, you can encode boolean datatypes as $\lambda$-calculus terms using Church encoding.

• true is represented as λt λf t (takes two arguments and returns the first).
• false is represented as λt λf f (takes two arguments and returns the second).

To perform conditional logic (matching), simply call the boolean value with the case_true and case_false branches as arguments.

true = λt λf t
false = λt λf f

# Matching logic
if boolean case_true case_false = (boolean case_true case_false)

# Example usage
main = (if true 42 37)
# Outputs 42

None represents the eraser * or the absence of a value. It is commonly used to indicate that a function does not return a value.

def none -> None:
  return *

Scopeless lambdas are a powerful feature of Bend/HVM where variables bound by a lambda can be accessed outside the lambda's body. This is achieved by prefixing the variable name with a dollar symbol ($).

While regular lambdas restrict their bound variables to their own scope, a scopeless lambda allows the bound variable to persist in the environment after the lambda is applied.

Key constraints:

• Bound variables are local to each term; they do not bind across definitions (e.g., a global variable cannot be bound by a scopeless lambda defined elsewhere).
• In the imp syntax, scopeless lambdas are written using the lambda $x: body pattern.

# Standard syntax
main = (((λ$x 1) 2), $x)
# Outputs (1, 2)

# imp syntax
def main() -> _:
  f = lambda $x: 1
  return (f(2), $x)

Constructors are functions. You can use two syntaxes to create a constructor expression:

1. Constructor syntax: Requires all field names.
2. Function syntax: Uses parentheses and can use named or positional arguments.

# Constructor syntax
Type/Ctr { field1: 4, field2: 8 }

# Function syntax
Type/Ctr(field1 = 4, field2 = 8)
Type/Ctr(4, field2 = 8)
Type/Ctr(4)

When you run bend run <file> arg1 arg2 ..., Bend treats the program as a function and applies the provided arguments to it.

For example, if your program uses the following Imp syntax:

def main(x1, x2, x3):
  return MainBody(x1 x2 x3)

Executing bend run <file> arg1 arg2 arg3 is equivalent to the following fun syntax application:

main = (λx1 λx2 λx3 (MainBody x1 x2 x3) arg1 arg2 arg3)

# Imp syntax
def main(x1, x2, x3):
  return MainBody(x1 x2 x3)

# Calling with `bend run <file> arg1 arg2 arg3`, it becomes:
main = (λx1 λx2 λx3 (MainBody x1 x2 x3) arg1 arg2 arg3)

Bend has a built-in binary tree map data structure where keys are u24 (numbers, characters, or symbols). Maps are defined using { key: value } syntax.

# Map definition
my_map = { 0: 4, `hi`: "bye", 'c': 2 + 3 }

# Assignment and access
my_map[0] = 5
val = my_map[0]

{ 0: 4, `hi`: "bye", 'c': 2 + 3 }
x[0] = 5
return x[0]

The Ctr(...) syntax represents a constructor type. This is used to define custom data types or algebraic data types (ADTs), and constructors can contain other types as parameters.

def head(list: List(T)) -> Option(T):
  match list:
    case List/Nil:
      return Option/None
    case List/Cons:
      return Option/Some(list.head)

Bend uses two types of path resolution for imports:

1. Relative Paths: Paths starting with ./ or ../ are resolved relative to the file containing the import statement.
2. Absolute Paths: Paths that do not start with ./ or ../ are resolved relative to the folder of the main file of the project.

Note: When importing a file, names from that file are bound using the file name as a prefix (e.g., helper/calc).

# Relative imports
from ./utils import helper
import ../utils/helper

# Absolute imports (relative to main file)
from utils import math
import utils/math

Patterns in Bend are evaluated from top to bottom. This means more specific patterns should be placed above more general patterns or wildcards (*). A wildcard can cover multiple specific cases if placed correctly in the order of definition.

# Patterns are checked top-to-bottom
pred_if Bool/False * if_false = if_false
pred_if Bool/True  p *        = (- p 1)
pred_if Bool/True  0 *        = 0

In Bend, recursive datatypes are defined using the type keyword. To allow a field to be recursive, prefix the field name with a tilde ~.

Example of a binary tree definition:

type Tree:
  Node { ~left, ~right }
  Leaf { value }

Bend provides dedicated syntax for common recursive types like binary trees:

• ![a, b] is equivalent to Tree/Node { left: a, right: b }
• !x is equivalent to Tree/Leaf { value: x }

type Tree:
  Node { ~left, ~right }
  Leaf { value }

# Using dedicated syntax for a tree:
tree = ![![!1, !2],![!3, !4]]