Syntax on TrustLang

Concept

Mon, 01 Jan 0001 00:00:00 +0000

Fundamental notions

The TrustLang syntax has several rules common to the whole language:

The language is built on grammar rules, not on keywords. The lexer and parser are single-pass, simple and fast, while the usual keyword notation (@if, @while, @func, …) is implemented on top of the base syntax through macros.
Terms of the source text are first recognized by the lexer and processed by the macro processor, and only then reach the parser. This makes it possible to modify even basic syntax constructs with macros.
Statements (operators) are separated by a semicolon ;.
Code blocks are written in curly braces { ... }.
Any construct (including a code block) is an expression and returns a value, so it can be nested inside other expressions.

The TrustLang syntax can be conventionally divided into several layers, each responsible for its own area:

Syntax

Mon, 01 Jan 0001 00:00:00 +0000

Naming of objects

Mon, 01 Jan 0001 00:00:00 +0000

As names of objects and names of data types you can use letters, digits and underscores in any combinations, provided that the first character of the name is not a digit.

A name cannot consist of a single underscore, since this is a special term used for service purposes.

To avoid name collisions you can use a namespace and a modular code structure, which TrustLang supports simultaneously. Overriding and overloading of functions are allowed.

Macros and DSL

Mon, 01 Jan 0001 00:00:00 +0000

Macros in TrustLang are elements of metaprogramming.

A macro is one or several consecutive terms that are replaced by another term or by a whole syntactic construct (a sequence of lexemes) and act as specialized regular expressions for searching and replacing sequences of terms.

Macros are processed by the lexer before sending tokens to the parser for syntax analysis, which makes it possible to change even the syntax of the language, for example, to turn the TrustLang syntax based on grammar rules into the more familiar keyword-based syntax, since such text is easier to perceive when subsequently reading the program source code.

Code hierarchy

Mon, 01 Jan 0001 00:00:00 +0000

Namespaces

TrustLang supports namespaces; the separator, as in C++, is the double colon ::. A namespace can be specified both for an individual identifier and for a whole code block.

Unlike namespace in C++, namespaces in TrustLang serve not only to organize code into logical groups and to avoid name conflicts: a name in which a namespace is explicitly specified refers to static objects (memory for which is allocated at compile time).

Memory management and shared access

Mon, 01 Jan 0001 00:00:00 +0000

No single memory management approach is the best or universal: different approaches win under different conditions:

Manual memory management can do anything, except one thing — guarantee the absence of errors.
Ownership and borrowing analysis at compile time makes it possible to prove the correctness of code without additional runtime checks, but some scenarios and algorithms cannot be proven statically at compile time.
Counting strong and weak references at runtime is convenient for shared ownership, but has a non-zero cost and does not protect against cyclic and cross dependencies.
Garbage collection simplifies working with complex cyclic structures, but has the most expensive overhead and non-deterministic execution.
None of the listed memory management approaches includes the issues of inter-thread memory access synchronization.

Therefore, choosing only one memory management approach in a programming language means deliberately limiting its capabilities and adding unnecessary overhead. For these reasons, the memory management concept of TrustLang allows extending the implementation of the memory management model with minimal impact on the language syntax and is defined by the requirements (guarantees) for working with memory.

If you think you know how "Expression" differs from "Statement", then most likely you are mistaken

Sun, 02 Aug 2026 00:00:00 +0000

I study the syntax of programming languages and try to separate fundamental regularities from historical accidents. One of such accidents is the almost ubiquitous use of the terms expression and statement when describing and classifying the syntax of programming languages.

Intuitively it seems that 2 + 2 and if (x) { foo(); } are completely different entities, but on a deeper analysis it turns out that such a separation is artificial and arose from the architectural features of computing machines almost half a century ago and since then simply “carries over” from language to language.

Why C++ or Rust can never replace Python

Tue, 28 Jul 2026 00:00:00 +0000

Articles analyzing the phenomenon of Python periodically appear on Habr — how one of the slowest programming languages became the king of neural networks, and the answer is always the same: thanks to a simple syntax and a developed ecosystem. But the ecosystem of C++ is significantly larger and richer, so it is not the ecosystem, and only the syntax remains. And if the problem really is the syntax, then there should also be an answer to another question: why did C++ not become the basis for research in this (or any other) area?

Building blocks of programming languages

Fri, 03 May 2024 00:00:00 +0000

As a result of the feedback on the article with reflections on structured programming, there were many comments and disputes in the comments, for which I want to say a big thank you to everyone.

And under the impression of the discussion of the previous article, I asked myself whether there exists a minimal set of lexemes, operators or syntactic constructs with the help of which one can build an arbitrary grammar for a modern general-purpose programming language?

Nuances of developing a parser for your own programming language

Wed, 29 Mar 2023 00:00:00 +0000

Recently I read an article on Habr, “My own language, or how I got tired of assembler and C”, and my eye involuntarily caught on one paragraph:

I decided not to bother too much, so I used the parglare library. It is very lightweight and convenient, I recommend it to everyone. To describe the syntax, the parser accepts a string in the corresponding format and uses regular expressions (do not judge regexes, they are omnipotent!).

DSL (domain-specific language) implementation with macros

Wed, 01 Mar 2023 00:00:00 +0000

Attention!!!

This article contains a description of the syntax of the previous version of NewLang.

The current version of the language syntax can be viewed here.

The release of the TrustLang language is approaching with a fundamentally new “feature”, a reworked version of the preprocessor that makes it possible to extend the syntax of the language to create various DSL dialects through macros.

And, as always, using the previously found lifehack Habr — a chamber of wisdom, I would like to get feedback from readers about the approach proposed below, which is planned to be implemented in the new TrustLang preprocessor.

A new programming language

Fri, 18 Feb 2022 00:00:00 +0000

Attention!!!

This article contains a description of the syntax of the previous version of NewLang.

The current version of the language syntax can be viewed here.

More than a year ago I began publishing articles describing the features of a new programming language. Much water has flowed under the bridge since then, many ideas were tested, in the end everything changed radically several times, and now I present to the readers a description of the pre-final version of the language and its features.

An unusual concept of the syntax of a programming language

Mon, 24 May 2021 00:00:00 +0000

Attention!!!

This article contains a description of the syntax of the previous version of NewLang.

The current version of the language syntax can be viewed here.

I want to present to the readers’ discussion a somewhat unusual concept of a programming language, which lacks the problem inherent in almost all industrial languages — the constant increase in the complexity of the language syntax due to its natural development as new versions are released and new features are added. This problem is described in the article “Simple complex programming” and What is the “ideal” goal of the development of programming languages?

International programming in natural languages

Sat, 05 Dec 2020 00:00:00 +0000

Attention!!!

This article contains a description of the syntax of the previous version of NewLang.

The current version of the language syntax can be viewed here.

Lately I often come across articles about new programming languages, as well as various ratings and forecasts related to the popularity of computer languages.

New tooling also announces itself, which in its work uses its own formats for describing configuration files or sequences of executed commands, which also brings them very close to the notion of a “programming language”.