Introduction

S++ is a modern, general-purpose systems programming language, inheriting the syntax of a Rust-Python fusion. It is strongly and statically typed, and has a specific focus on memory safety, runtime performance, and ease of use. There are a number of features in S++ that make it a powerful language for systems programming, such as: full type inference, pattern matching, generics, modules and coroutines.

S++ aims to be completely memory-safe, type-safe, and thread-safe, while providing the performance of a low-level language, with no bizarre syntax or complex rules. A blend of techniques is used to enforce memory safety, including second-class borrows, the law of exclusivity, and ownership tracking.

Philosophy

  • Performance: S++ is designed as a high-performance language, achieved by compiling S++ code to native code, using an LLVM backend. This allows S++ to have performance statistics comparable to C++ and Rust.

  • Readability: S++ is designed to be simple to read, with a left-to-right, top-to-bottom reading rule for every block of code. Whilst loosely based on the C-family syntax, a number of changes were made to remove legacy syntax.

  • Orthogonal: S++ is designed to be consistent in all aspects. A key example is treating integers, booleans, tuples, arrays, variants and functions all as first-class object, with no specific behaviour or context rules for any of them.

  • Versatile: S++ is designed to be a low level language with a high level syntax. This allows it to be used for a wide range of applications, from systems programming to desktop applications.

  • Efficient: User and machine efficiency were considered throughout the design of S++. This includes stripping out legacy features, forcing type inference, and maintaining “one correct way to do things”.

  • Safety: S++ enforces memory safety, thread safety, and type safety using a range of features. This allows the high performance, low level nature of the language to be used without the risk of crashes or undefined behaviour.

Key Features

  • Expression Oriented: In S++, almost every “statement” is an expression, including conditional branching, conditional looping, contextual blocks, etc.

  • Advanced Type System: All types in S++ are first-class. Flow typing, type shorthands, type inference, type aliasing, and a full generic system are all supported.

  • Memory Safety: S++ follows Rust in having a strong emphasis on memory safety. It uses a blend of techniques to ensure that memory is managed safely and efficiently, mitigating memory bugs.

  • Class System: The class system in S++ is split into state and behaviour. Each class definition includes state only (attributes). All methods and inheritance are defined using superimposition.

  • Superimposition: Similar to Rust impl, behaviour blocks or isolated type extension blocks with controlled override capability.

  • Module System: Module definitions, namespaces and directory structures are all the same in S++, providing a structured and simple module system. All modules are “imported” but namespaced.

  • Functions: Function and methods support overloading and recursion, and type-afe variadic parameters. Functions can be called asynchronously, and closures can capture variables from their enclosing scope.

  • Generics: S++ has a powerful generics system, supporting generic functions, types and methods. Generic types can be constrained. Generic types can also be variadic, allowing for a variable number of type arguments.

  • Asynchronous functions: S++ uses Golang like syntax for asynchronous functions, where the asynchronous convention is defined at the function call site, not the function definition, mitigating the “function color” problem.

  • Concurrency: Coroutines form the concurrency model in S++. They can be suspended and resumed, support bilateral data movement, and can yield borrowed values. They form the basis of iteration.

  • Parallelism: S++ uses threads, and their associated primitives, such as mutexes and condition variables, for parallelism. This is pulled from C++, withAPIs have been modernized to fit S++.

  • Error Handling: S++ uses a result-type for error handling, similar to Rust. This allows for more expressive error handling. The ? operator cn be used to propagate errors up the call stack.

  • Pattern Matching: S++ has a powerful pattern matching system. This allows for complex destructuring of tuples, arrays, object and variants, and can be used in conjunction with flow typing.

  • Loop Control Flow. S++ provides the ability to exit or skip an iteration of an n-depth loop. This alsop allows variables to be returned out of loops. 4Operator Overloading: S++ supports operator overloading, allowing for operators to be defined for custom types.