Language Reference

This document is work in progress!

This document is the official reference for Fold programming language.

• 1 Introduction
• 2 Comments
• 3 Literals
  • 3.1 Booleans
  • 3.2 Numbers
  • 3.3 Text
  • 3.4 Symbols
• 4 Expressions
  • 4.1 Arithmetic Operations
  • 4.2 Blocks
  • 4.3 Function Application
• 5 Control Flow
  • 5.1 Conditionals
    • 5.2 If Expressions
    • 5.3 When Expressions
  • 5.2 Pattern-matching
    • 5.2.1 Match Expressions
    • 5.2.2 Conditional Matching
    • 5.2.3 Pattern Views
  • 5.3 Exceptions
  • 5.4 Loops
    • 5.4.1 While Loops
    • 5.4.2 For Loops
    • 5.4.3 Recursion
• 6 Bindings
  • 6.1 Definitions
  • 6.2 Let Expressions
  • 6.3 Where Expressions
  • 6.4 Multiple Bindings
  • 6.5 References
  • 6.6 Monadic Bindings
• 7 Types
  • 7.1 Primitive Types
  • 7.2 Tuples
  • 7.3 Records
  • 7.4 Anonymous Records
  • 7.5 Parametric Types
  • 7.6 Union Types
  • 7.7 Abstract Data Types
• 8 Collections
  • 8.1 Lists
  • 8.2 Sets
  • 8.3 Arrays
  • 8.4 Dicts
• 9 Functions
  • 9.1 Anonymous Functions
  • 9.2 Function Definitions
  • 9.3 Named Arguments
  • 9.4 Custom Operators
• 10 Modules
  • 10.1 Module Definitions
  • 10.2 Signatures
  • 10.3 Type Modules
  • 10.4 Module Extensions
  • 10.5 Module Functions
  • 10.6 Imports and Includes
• 11 Error Handling
• 12 Metaprogramming
  • 12.1 Meta Attributes
  • 12.2 Static Introspection
  • 12.3 Macros

Syntax Elements

The language is made of expressions and the main elements of the expressions are:

• Atoms – simple values
• Forms – compounds of atoms

Core Syntax

The core syntax of Fold can be seen as a simplified Lisp.

expression =
  | atom
  | atom expression
  | '(' expression ')'

atom =
  | <bool>
  | <char>
  | <float>
  | <int>
  | <string>
  | <id>
  | <symbol>

Forms

• Arithmetic Forms
• Binding Forms
• Lambda Forms

Binding Terms

Binding forms are syntactic elements that give names to values.

x = 5

Lambda Forms

x y -> x + y

sum : int -> int -> int
sum x y = x + y

## Primitives

Boolean values and logical operators.

```haskell
-> True
:: Bool = True

-> False
:: Bool = False

-> True && not (True || False)
:: Bool = False

Note: the lines that start with an arrow, ->, are treated as the input of the interpreter, followed by the inferred type and the evaluated result.

Numeric values with diferent radixes are supported. Underscores in the numeric values can improve readability and are ignored by the compiler.

-> 123456789
:: Int = 123456789

-> 100_000_000
:: Int = 100000000

-> 0b0101010
:: Int = 42

-> 0xBADC0DE
:: Int = 195936478

-> 0o377
:: Int = 255

-> 3.1415926
:: Float = 3.1415926

-> 10.0 * 2 - 10.0 / 2
:: Float = 15.0

Strings and characters and multi-line strings.

-> 'a'
:: Char = 'a'

-> "hello"
:: String = "hello"

-> """
   Multi-line strings can span multiple lines and
   don't require escapes for "quotation marks"
   """
:: String = "Multi-line strings can span multiple lines and\ndon't require escapes for \"quotation marks\""

Unit – a special value that is used for expressions with no value. Unit has its own type () and only one value (). Mainly used as a return type for effectful functions with no return value.

Note: Unit values are always omitted from the interpreter's output.

-> ()

Regular expressions. The interpreter shows examples of matched strings.

-> /^[a-z0-9_.+-]+@[a-z0-9-]+\.[a-z]+$/
:: Regex = /^[a-z0-9_.+-]+@[a-z0-9-]+\.[a-z]+$/
-- Examples:
--   - "[email protected]"
--   - "[email protected]"

-- Bindings can be used to name values.
-> a = 42
a :: Int = 42

-- Use blocks to group multiple expressions.
-> do
     a = 2
     b = 2
     a + b
   end
:: Int = 4

-- Binding blocks introduce variables in a delimited scope.
-> let
     a = 2
     b = 2
   in
     a + b
   end
:: Int = 4

Collections

-- Tuples / Named Tuples (aka Records)
()
(1, "Hello")
(name: "Alan", age: 23)

-- Linked Lists
[]
[1, 2, 3, 4, 5]

-- Hash-maps
{"x": 89, "y": 32}

-- Arrays
([1, 2, 3, 4, 5] : Array Int)

Definitions

• =, let, where

name = value

let name = value
    name = value
    ...
in
  expression
end

expression where
  name = value
  name = value
  ...
end

• function, macro

function name arg args...
  ...
end

macro name arg args...
  ...
end

• module, interface

module Name
  ...
end

module Name(Arg : M)
  ...
end

interface Name
  ...
end

interface Name (Arg :: M)
  ...
end

• type

type name = t1
type name = t1, t2, ...

type name = A