Bern Language Documentation

Basics

Literals

In Bern, literals are automatically interpreted and printed. You can write values directly and they'll be evaluated immediately:

"Hello, World!"
23
3.14
true

Variables

Variables are defined using the simple name = value syntax. Bern supports various data types including integers, doubles, strings, and booleans:

integer = 2
double = 3.14
helloworld = "Hello, World!"
isActive = true

Evaluation

Like literals, variables can be called directly and will be properly evaluated. Simply write the variable name to see its value:

helloworld
-- Output: "Hello, World!"

integer
-- Output: 2

Type Checking and Length

Bern provides two special operators for introspection:

• :: (typeof) - Returns the type of a value as a string
• :> (length) - Returns the length of a list, set, or string

typeof_integer = :: 2
-- Output: "Int"

typeof_string = :: "hello"
-- Output: "String"

length_list = :> [1,2,3,4] 
-- Output: 4

length_string = :> "hello"
-- Output: 5

Conditionals

Bern supports conditional execution through if-then-else statements. These allow your code to make decisions based on conditions.

If-Then-Else Statement

The basic conditional structure lets you execute different code based on whether a condition is true or false:

age = 18
if age >= 18 then
    "You are an adult."
else
    "You are a minor."
end
-- Output: "You are an adult."

Else-If Chains

For multiple conditions, use else if to check additional cases in sequence:

score = 85
if score >= 90 then
    "You got an A."
else if score >= 80 then
    "You got a B."
else if score >= 70 then
    "You got a C."
else
    "You need to improve."
end
-- Output: "You got a B."

numbers = [1..100]
for n : numbers do 
    if n % 15 == 0 then 
        "FizzBuzz"
    else if n % 3 == 0 then
        "Fizz"
    else if n % 5 == 0 then
        "Buzz"
    else
        n
    end
end

Functions

Bern functions are powerful and flexible, supporting pattern matching, inline arrow syntax, and block bodies with explicit returns.

Simple Function Definition

For one-line functions, use the arrow syntax def name(params) -> expr:

def add(x, y) -> x + y
add(2, 3)
-- Output: 5

def square(x) -> x * x
square(4)
-- Output: 16

Pattern Matching

Define multiple clauses for a function. Bern will use the first matching pattern:

def sign(0) -> "zero"
def sign(n) -> "positive"

sign(0)
-- Output: "zero"

sign(42)
-- Output: "positive"

Wildcards and Literal Matching

Use _ to ignore parameters, or match specific literal values:

def greet("Alice") -> "Hi, Alice!"
def greet(_) -> "Hello, someone else!"

greet("Alice")
-- Output: "Hi, Alice!"

greet("Bob")
-- Output: "Hello, someone else!"

Block-Bodied Functions

For complex functions, use do ... end blocks with explicit return statements:

def sumList(xs) do
    total = 0
    for n : xs do
        total = total + n
    end
    return total
end

sumList([1,2,3])
-- Output: 6

Lambda Functions

Anonymous functions use backslash syntax and can be assigned to variables or passed as arguments:

inc = \x -> x + 1
pairSwap = \a, b -> [b, a]

inc(10)
-- Output: 11

pairSwap(1, 2)
-- Output: [2, 1]

Higher-Order Functions

Functions can accept other functions as parameters:

def applyTwice(f, x) -> f(f(x))

applyTwice(\n -> n * 2, 5)
-- Output: 20 (5 * 2 * 2)

Loops

Bern uses Odin-inspired loop syntax where for is the only loop keyword. The behavior changes based on how you use it.

Repeat For

Execute a block a specific number of times:

for 3 do
    "Hello, Loops!"
end
-- Output: "Hello, Loops!" (three times)

Conditional For

Repeat while a condition is true (like a while loop):

counter = 2
for counter > 0 do
    "Hello, Loops!"
    counter = counter - 1
end
-- Output: "Hello, Loops!" (twice)

Infinite Loop

Create an infinite loop with for true:

for true do
    "This runs forever!"
end

For-In Loop

Iterate over elements in lists, sets, or strings:

text = "Bern"
for char : text do
    "Current char is: " + char
end
-- Output: 
-- "Current char is: B"
-- "Current char is: e"
-- "Current char is: r"
-- "Current char is: n"

For-In with Index

Get both the element and its index during iteration:

text = "Bern"
for char, index : text do
    "Char: " + char + " at index: " + index
end
-- Output:
-- "Char: B at index: 0"
-- "Char: e at index: 1"
-- "Char: r at index: 2"
-- "Char: n at index: 3"

Lists

A list is an ordered collection of elements of the same type. Lists allow duplicates and preserve insertion order. In Bern, strings are also treated as lists of characters.

Declaring Lists

numbers_list = [1,2,3,4,5]
numbers_list
-- Output: [1,2,3,4,5]

Range Syntax

Create lists using Haskell-style range notation:

range_list = [5..10]
-- Output: [5,6,7,8,9,10]

small_range = [1..5]
-- Output: [1,2,3,4,5]

Indexing

Access specific elements using zero-based indexing:

range_list = [5..10]
range_list[3]
-- Output: 8 (fourth element)

List Arithmetic

Arithmetic operations with a scalar apply to every element:

[1,2] + 2
-- Output: [3,4]

[10,20,30] * 2
-- Output: [20,40,60]

Operations between two lists require equal lengths:

[1,2,3] + [4,5,6]
-- Output: [5,7,9]

[10,20] - [5,3]
-- Output: [5,17]

List Set Operations

Lists support set-like operations while preserving order and allowing duplicates:

• <> - Union (concatenation)
• </> - Difference (elements in first but not second)
• |> - Intersection (common elements)
• <| - Symmetric difference (elements in either but not both)

[1,2,3] <> [3,4,5]
-- Output: [1,2,3,3,4,5]

[1,2,3]  [2,3]
-- Output: [1]

[1,2,3] |> [2,3]
-- Output: [2,3]

[1,2,3] <| [2,3]
-- Output: [1]

result = ([1,2,3,4] <> [3..5]) <| ([2,3,4] |> [4,5])  [1]
-- Combines concatenation, symmetric difference, 
-- intersection, and regular difference

Sets

A set is an unordered collection of unique elements that can be of different types. Sets automatically remove duplicates and don't preserve order.

Declaring Sets

numbers_set = {1,2,3,4,5}
numbers_set
-- Output: {1,2,3,4,5}

mixed_set = {1, "hello", 3.14}
-- Sets can contain different types

Indexing

While sets are unordered, you can still access elements by index:

numbers_set = {1,2,3,4,5}
numbers_set[2]
-- Output: (some element from the set)

Set Arithmetic

Adding to a set inserts elements (if not already present):

{1,2} + 3
-- Output: {1,2,3}

{1,2} + {3,4}
-- Output: {1,2,3,4}

{1,2,3} + 2
-- Output: {1,2,3} (2 already exists)

Subtraction removes elements:

{1,2,3} - 2
-- Output: {1,3}

Set Operations

Mathematical set operations with automatic duplicate removal:

{1,2,3} <> {3,4,5}
-- Union: {1,2,3,4,5}

{1,2,'a',3.5} <> {3,4,'b',1}
-- Union with mixed types: {1,2,'a',3.5,3,4,'b'}

{1,2,3} |> {2,3,4}
-- Intersection: {2,3}

{1,2,3}  {2,3,4}
-- Difference: {1}

{1,2,3} <| {2,3}
-- Symmetric difference: {1}

Objects

Bern supports objects (hashmaps/hashtables) using the #{...}# notation for key-value pairs.

Declaring Objects

obj = #{
    key: "value",
    hello: "world"
}#
obj
-- Output: #{key: "value", hello: "world"}#

Updating Values

Reassign values using bracket notation:

obj["key"] = "new_value"
obj
-- Output: #{key: "new_value", hello: "world"}#

Adding Fields

Add new key-value pairs by assigning to a new key:

obj["new_key"] = "added_value"
obj
-- Output: #{key: "new_value", hello: "world", new_key: "added_value"}#

Nested Objects

Objects can contain other objects. Access nested values with multiple indexing:

obj["test"] = #{
    nested_key: "nested_value"
}#

obj["test"]["nested_key"]
-- Output: "nested_value"

person = #{
    name: "Alice",
    age: 25,
    address: #{
        city: "Boston",
        zip: "02101"
    }#
}#

person["address"]["city"]
-- Output: "Boston"

Algebraic Data Types (ADTs)

ADTs allow you to define custom data types with multiple constructors, similar to enums or tagged unions in other languages.

Defining ADTs

Use the adt keyword followed by type name and constructors:

adt Shape = Circle Double | Rectangle Double Double

Each constructor can have zero or more fields of specific types.

Creating Instances

Call constructors like functions to create instances:

c = Circle(5.0)
r = Rectangle(3.0, 4.0)

Pattern Matching with ADTs

Destructure ADTs in function definitions to access their fields:

def area(Circle(r)) -> 3.14159 * r * r
def area(Rectangle(w, h)) -> w * h

area(c)
-- Output: 78.53975 (π * 5²)

area(r)
-- Output: 12.0 (3 * 4)

The Maybe Type

A common ADT pattern for representing optional values:

adt Maybe = Just Int | None

def safeDivide(n, 0) -> None()
def safeDivide(n, m) -> Just(n / m)

safeDivide(10, 3)
-- Output: Just(3)

safeDivide(5, 0)
-- Output: None()

Standard Library Reference

Bern comes with several standard libraries and bundled vendor modules. Import standard libraries with import library_name and vendor modules with full paths like import vendor/csv.

import core

map([1,2,3], \x -> x * 2)
-- Output: [2,4,6]

filter([1,2,3,4,5], \x -> x % 2 == 0)
-- Output: [2,4]

foldl([1,2,3], 0, \acc, x -> acc + x)
-- Output: 6

sum([1,2,3,4])
-- Output: 10

reverse([1,2,3])
-- Output: [3,2,1]

zip([1,2,3], ['a','b','c'])
-- Output: [[1,'a'], [2,'b'], [3,'c']]

to_int("42")
-- Output: 42

import math

pow(2, 8)
-- Output: 256

import strings

substring("Hello", 1, 4)
-- Output: "ell"

split("a,b,c", ",")
-- Output: ["a", "b", "c"]

trim("  hello  ")
-- Output: "hello"

replace("hello world", "world", "Bern")
-- Output: "hello Bern"

import random

get_random_int()
-- Output: (random integer)

random_choice(["apple", "banana", "cherry"])
-- Output: (random fruit)

get_random_string(10)
-- Output: "aB3xK9mP2q" (example)

import assert

assert_equals("Addition test", 2 + 2, 4)
-- Output: "Addition test PASS"

assert_equals("Wrong test", 2 + 2, 5)
-- Output: "Wrong test FAIL"

assert_approx("Pi test", 3.14159, 3.14, 0.01)
-- Output: "Pi test PASS"

import path

path_join("a/", "/b")
-- Output: "a/b"

path_join_many(["a", "b", "c"])
-- Output: "a/b/c"

path_normalize("a/./b/../c")
-- Output: "a/c"

path_normalize("/a//b/../c")
-- Output: "/a/c"

import url

url_encode_component("a b&c")
-- Output: "a%20b%26c"

build_query([["a", "1"], ["name", "bern lang"]])
-- Output: "a=1&name=bern%20lang"

parsed = parse_url("http://example.com:8080/docs/api?x=1#top")
parsed["host"]
-- Output: "example.com"

build_url("https", "example.com", 443, "/hello", "a=1", "frag")
-- Output: "https://example.com/hello?a=1#frag"

import crypto

crypto_random_hex(8)
-- Output: (16 hex chars)

uuid = crypto_uuid_v4_like()
-- Output: "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"

import vendor/csv

csv = "name,age\nAna,30\nBob,25"
rows = parse_csv(csv)
rows["0"]["name"]
-- Output: "Ana"

import vendor/http/http

server = http_server_start(8080)
http_server_get(server, "/", "hello from bern http")
http_server_add_route_json(server, "/health", "{\"ok\":true}")
http_server_serve_forever(server, 50)

Imports

Bern allows importing libraries to extend functionality. Use the import keyword to load standard libraries or custom modules.

Importing the Core Library

import core

Core Library Functions

Once imported, you can use functions like map, filter, and type conversions:

map([1,2,3,4,5], \x -> x + 2)
-- Output: [3,4,5,6,7]

def isEven(x) -> x % 2 == 0
filter([1,2,3,4,5,6,7,8,9,10], isEven)
-- Output: [2,4,6,8,10]

Type Conversion

The core library provides conversion functions for handling input:

import core
age_text = input("Type your age: ")
age = to_int(age_text)
"Your age in 5 years: " + (age + 5)

User Input

Capture user input with the input() function, similar to Python.

Basic Input

name = input("Type your name: ")
name
-- Displays whatever the user typed

Converting Input

By default, input() returns text. Convert to other types using core library functions:

import core
age_text = input("Type your age: ")
age = to_int(age_text)
"You'll be " + (age + 10) + " in 10 years"

Global Functions

Bern provides built-in functions for file operations and system utilities.

File Operations

• read_file(path) - Read file contents as a string
• write_file(path, content) - Write content to a file
• get_current_dir() - Get the current working directory

content = read_file("myfile.txt")
write_file("output.txt", "Hello, Bern!")
write_file("data.txt", content + "\nNew line")

System Information

Returns the system the user is running. Useful for bindings.

os = get_host_machine()
-- Returns OS/system information

fmap

Applies a function to each element of a collection. Used too in Algebraic Data Types (ADTs) to modify contained values without breaking functorial context.

ast Maybe = Just Int | None
fmap(Just(5), \x -> x * 2)

-- Output: Just(10)

C Bindings

You can call C functions directly from Bern using the foreign function interface (FFI). This allows you to leverage existing C libraries and system calls.

For this, you need to declare the C function signature using the foreign keyword, specifying the library, its function name, argument types and return type.

foreign example("lib.so", "int") -> "void"

Recommendation: Use get_host_machine() inside an auxiliary function to get the correct library path for multiple operating systems.

def get_path() do
    os = get_host_machine()
    if os == "mingw64" || os == "mingw32" then
        return "windows_lib.dll"
    else
        return "linux_lib.so.6"
    end
end