Welcome to Theta! If you're into modern, functional programming languages with a clean syntax and powerful features, you're in the right place. Theta combines the best of functional programming with a strong type system and expressive syntax to help you write clean, efficient, and maintainable code. Whether you're building data-driven applications or just tinkering with new ideas, Theta is here to make your coding experience smoother and more enjoyable
View the formal language grammar in BNF, if you're into that kind of thing.
- Strong Typing: Catch errors early and ensure type safety throughout your codebase.
- Functional Paradigms: Enjoy first-class functions, immutability, and higher-order functions.
- Pattern Matching: Simplify your code with built-in pattern matching and destructuring.
- Modular Design: Organize your code into reusable modules, known as capsules.
- Interactive REPL: Experiment with code in real-time using the Interactive Theta (ITH) REPL.
Check out some Theta code to get a feel for its clean and expressive syntax:
capsule MathFunctions {
add<Function<Number>> = (a<Number>, b<Number>) -> a + b
factorial<Function<Number>> = (n<Number>) -> {
match (n) {
0 -> 1
n -> n * factorial(n - 1)
}
}
}
link Theta.IO
capsule DataStructures {
struct Point {
x<Number>
y<Number>
}
distance<Function<Number>> = (p1<Point>, p2<Point>) -> {
return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2)
}
main<Function<String>> -> {
points<List<Point>> = [
@Point{ x: 0, y: 0 },
@Point{ x: 3, y: 4 }
]
dist<Number> = distance(points[0], points[1])
Theta.IO.println("Distance: " + dist)
}
}
- C++ Compiler: Make sure you have a compiler that supports C++17.
- Clone the Repository:
git clone https://github.com/alexdovzhanyn/ThetaLang.git
cd ThetaLang- Initialize Submodules:
git submodule update --init --recursive- Install Wasmer
curl https://get.wasmer.io -sSfL | WASMER_DIR=lib/wasmer sh- Build the Project:
./build.shor, if on Windows:
./build-windows.shTo make sure Theta is set up correctly, run:
theta --versionYou should see the current version of Theta displayed.
Thanks for checking out Theta! We’re excited to have you contribute. Here’s how you can get started:
- Fork the Repository: Create a fork on GitHub.
- Create a Branch:
git checkout -b some-feature-branch- Make Changes: Implement your changes and commit them.
- Run the Tests:
./build/LexerTest
./build/ParserTest- Submit a Pull Request: Push your changes to your fork and open a pull request.
Theta has an Interactive Theta (ITH) REPL. Just type theta into the terminal. Note that it currently only supports single-line expressions. The REPL will show you the AST generated from your code.
For running Theta code, you can use the Theta Browser Playground.
If you find any issues or have suggestions, please use the Issues page. We appreciate your feedback and contributions!
Identifiers are used to name variables, functions, capsules, and structs. They must start with a letter or underscore and can contain letters, digits, and underscores.
Identifier = Letter (Letter | Digit | "_")*
Letter = "A".."Z" | "a".."z" | "_"
Digit = "0".."9"Reserved words that have special meaning in Theta:
link, capsule, struct, true, false, void, Number, String, Boolean, Symbol, Enum
Single-line comments start with // and extend to the end of the line. Multi-line comments
start with /- and extend until reaching a -/.
Example:
// This is a single line comment
// This is another
/-
This is a multiline comment.
It extends over multiple lines.
-/
String: Represented by single quotes'example'.Boolean: Represented bytrueorfalse.Number: Represents both integers and floating-point numbers.List: Represented by square brackets[ ].Dict: Represented by curly braces{ }.Symbol: Represented by a colon followed by an identifier, e.g.,:symbol.
User-defined data structures composed of primitives or other structs. Structs can only be defined within capsules. Structs can be referenced by name within the capsule that they are defined, but must be prefixed by their containing capsule if used in another capsule
struct StructName {
fieldName<Type>
...
}
Example:
capsule Messaging {
struct MessageRequest {
hostname<String>
port<Number>
path<String>
method<String>
headers<MessageRequestHeaders>
}
}
// If referenced in another capsule
Messaging.MessageRequest
Enumerated types with custom values represented as symbols. Enum names must be in Pascal case. Enums are scoped the same as variables, therefore an enum defined in a capsule will be accessible from outside the capsule, while an enum defined within a function will be scoped to that function.
enum EnumName {
:ENUM_1
:ENUM_2
...
}
Within a capsule:
capsule Networking {
enum Status {
:SUCCESS
:FAILURE
:PENDING
}
}
// Used like so:
myVar == Networking.Status.SUCCESS
// Or like so, if being referenced from within the capsule:
myVar == Status.SUCCESS
Within a function:
capsule Networking {
isNetworkRequestSuccess<Boolean> = request<NetworkRequest> -> {
enum PassingStatuses {
:SUCCESS
:REDIRECT
}
return Enumerable.includes(PassingStatuses, request.status)
}
isNetworkRequestFailure<Boolean> = request<NetworkRequest> -> {
// PassingStatuses is not available in here
}
}
Variables are declared by their name, suffixed with their type, followed by an equal sign and their value. Variables are immutable.
variableName<Type> = value
Example:
greeting<String> = 'Hello, World'
Functions are defined as variables pointing to a block. The return type is specified after the function name.
functionName<ReturnType> = (param1<Type1>, param2<Type2>, ...) -> {
// function body
}
Example:
add<Number> = (a<Number>, b<Number>) -> a + b
Functions can be composed using the => operator, where the value on the left is passed as the first argument to the function on the right.
value => function
Example:
requestParams => Json.encodeStruct() => Http.request()
Capsules are static groupings of related functions, variables, and structs, providing modularity and namespace management. All code in Theta must be contained within capsules.
capsule CapsuleName {
// variable, function, and struct definitions
}
Example:
capsule Math {
add<Number> = (a<Number>, b<Number>) -> a + b
subtract<Number> = (a<Number>, b<Number>) -> a - b
struct Point {
x<Number>
y<Number>
}
origin<Point> = @Point { x: 0, y: 0 }
}
Capsules are imported using the link keyword.
link CapsuleName
Example:
link Http
link Json
Pattern matching allows for intuitive matching of data structures.
match value {
pattern1 -> result1
pattern2 -> result2
...
_ -> defaultResult
}
Example:
matchStatus<String> = status<Enum> -> {
match status {
:SUCCESS -> 'Operation was successful'
:FAILURE -> 'Operation failed'
_ -> 'Unknown status'
}
}
Theta supports list, dictionary, and struct destructuring during variable assignment. It is a powerful way to pattern match values out of variables, based on the shape of the data:
myList<List<Number>> = [ 1, 2, 3 ]
// a is 1, b is 2, and c is 3. Notice that you don't have to specify the types of
// a, b, and c here. That is because the compiler can infer the types, because it
// knows we are destructuring a List<Number>, so its values must all be of type Number
[ a, b, c ] = list
myDict<Dict<Number>> = { x: 1, y: 2, z: 3 }
// x is 1, y is 2, z is 3
{x, y, z} = dict
Theta code files are saved with the extension .th
Putting it all together, here is a complete example using the discussed features:
// in Math.th
capsule Math {
struct Point {
x<Number>
y<Number>
}
distance<Number> = (point1<Point>, point2<Point>) -> {
// Calculate distance...
}
dimensionalDistanceX<Number> = (point1<Point>, point2<Point>) -> {
{ x: point1X } = point1
{ x: point2X } = point2
return point2X - point1X
}
}
// in Main.th
link Math
capsule Main {
point1 = @Math.Point { x: 0, y: 0 }
point2 = @Math.Point { x: 3, y: 4 }
distance = Math.distance(point1, point2)
}
