C++ Prelude#

Modern C++ makes me sad when I look at it. So this is my attempt to change several of the defaults we use to code in C++.

Types#

A mix of the naming scheme in Rust and HolyC is very aesthetically pleasing. Types become terse with only the information you need at a first glance. Furthermore, for consistency, all types should begin with capital letters.

Numeric Types#

These changes beg the question: What is wrong with int? Well int would be a perfectly valid type if C++ supported Big Integers like Java does. The problem is int is fixed to a type that is sometimes 32-bits and other times something else. I think this is very inelegant and needlessly terse. It is better to simply know what kind of integer and bit-width it takes up.

The only exception to this rule being Size since we do want to preserve the ability to scale depending on what system runs the binary.

Other Types#

In most situations, it is clearer to write the type as a Ptr<T> than a T*. Same goes for Ref<T>. This also remains consistent with the implementation of smart pointers in the standard library, for example std::unique_ptr<T>.

std::string_literals are enabled by default.

Keywords#

You define terms as let x = 0;. If you need the term to be of any specific numeric type then use suffixes like: let x = 0u; (x is unsigned). If you need a variable term then use the var keyword instead. The motivation for this is that you should prefer immutable terms before considering mutable variables.

All functions should be [[nodiscard]] and be annotated with trailing return types. If you need to ignore the return value of a function then use ignore = ... to explicitly ignore it. Additionally, the term fn (function) should be used in its most literal mathematical sense, for a given input it will always produce the same output. If you want to do something that requires side effects then use the proc (procedure) keyword instead.

fst, snd and thr naming conventions are taken from Haskell. The motivation being that std::get<#> is extremely verbose for accessing the first/second/third/etc members of that tuple.

Short example#

Solution for Rosetta Code "Balanced Brackets", using this prelude.

#include <algorithm>
#include <format>
#include <numeric>
#include <random>
#include "prelude.hpp"

proc generate(I32 n, Char left = '[', Char right = ']') -> String
{
	var rd = std::random_device();
	var str = std::string(n, left) + std::string(n, right);
	std::shuffle(str.begin(), str.end(), std::mt19937(rd()));

	return str;
}

fn balanced(std::string_view str, Char left = '[', Char right = ']') -> Bool
{
	var count = 0;
	for (let& ch : str) {
		if (ch == left)
			count++;
		else if (ch == right)
			if (--count < 0)
				return false;
	}

	return count == 0;
}

proc main() -> I32
{
	for (var i = 0; i < 9; ++i) {
		let s = std::string(generate(i));
		ignore = println(
		    std::format(" {}: {}", balanced(s) ? "ok" : "bad", s));
	}
}

TODO:#

• Sensible IO operations
• [o] Add examples
• Define applicative operations for standard containers
• Improve declarative and pipeline-esque operations
• Add algorithms