C3 - Programming language

C3 is an open source programming language created in 2019 by Christoffer Lernö.

#156on PLDB

5Years Old

Download source code:

git clone https://github.com/c3lang/c3c

C3 is a programming language that builds on the syntax and semantics of the C language, with the goal of evolving it while still retaining familiarity for C programmers.

Tags: programming language
C3 is developed on GitHub and has 1,665 stars
Early development of C3 happened in The C3 Language Project
C2 and C influenced the design of C3
C3 is written in C, Markdown, JSON, YAML, Python, Yacc, CMake, C++, Lex, Bourne shell, Dockerfile, Make
Explore C3 snippets on Rosetta Code
c3-lang.org was registered in 2019
Read more about C3 on the web: 1. 2.
1 PLDB concepts link to C3: C2

Example from the web:

module stack <Type>;
// Above: the parameterized type is applied to the entire module.
import std::mem;

struct Stack
{
    usize capacity;
    usize size;
    Type* elems;
}

// The type methods offers dot syntax calls,
// so this function can either be called
// Stack.push(&my_stack, ...) or
// my_stack.push(...)
fn void Stack.push(Stack* this, Type element)
{
    if (this.capacity == this.size)
    {
        this.capacity *= 2;
        this.elems = mem::realloc(this.elems, $sizeof(Type) * this.capacity);
    }
    this.elems[this.size++] = element;
}

fn Type Stack.pop(Stack* this)
{
    assert(this.size > 0);
    return this.elems[--this.size];
}

fn bool Stack.empty(Stack* this)
{
    return !this.size;
}

Language features

Feature	Supported	Example	Token
hasReservedWords	✓
Switch Statements	✓	switch(expression) { case 1: do_something(); case 2: if (x > 0) nextcase 1; // Jump to 1 nextcase; // Jump to the next case. default: foo(); }
Structs	✓	struct Test { int x; float y; String z; }
Strings	✓	String s = "hello"; String t = `I say "hello"`;
Ternary operators	✓	int foo = x ? 1 : 0;
Scientific Notation	✓
While Loops	✓	while (int x = foo(); x > 0) { sum += x; }
Conditionals	✓
Assignment	✓	a = b;
Case Sensitivity	✓
Pointers	✓
Variadic Functions	✓	fn void foo_typed(int x, int... arg) { ... } fn void foo_untyped(int x, ...arg) ... foo_typed(1, 2, 3); foo_untyped(1, "hello", 1.2);
Module Pattern	✓	module my_module::submodule; ...
Operator Overloading	✓	fn int IntList.get(IntList* this, int idx) @operator([]) { return this.vals[idx]; } ... IntList x = ... foo(x[1]);
Multiline Strings	✓	String s = `this string is multiline`;
MultiLine Comments	✓	/* Multiline comment */	/* */
Methods	✓	fn int Foo.get_value(Foo* this) { return this.value; }
File Imports	✓	import std::io;
hasForEachLoops	✓	foreach (x : list) { foo(x); }
Macros	✓	macro square(x) { return x * x; }
Union Types	✓	union Foo { int x; float f; struct { char[2] z; } }
Single-Type Arrays	✓
Unary Operators	✓
Enums	✓	enum TestEnum : int { FOO, BAR, BAZ }
Doc comments	✓	/** * @param [in] foo "The foo value" * @return "the toal foo count" **/
Constants	✓	const FOO = 123; const void* BAR = null;
Access Modifiers	✓
Zero-based numbering	✓
Default Parameters Pattern	✓	fn void test(int x = 10) { ... }
Assert Statements	✓	assert(a > 0, "Expected a positive number"); $assert(Foo.sizeof == 8, "Foo sizecheck at compile time failed");
Manual Memory Management	✓
Increment and decrement operators	✓	i++; --j;
Integers	✓	int x = 314159;
Namespaces	✓	import std::io; ... io::printf("%d", i);
Type Casting	✓	double d = 3.3; int x = (int)d;
Binary Literals	✓	51
Null	✓
Lazy Evaluation	✓	fn void print(String s) { io::printfn("Said: %s", s); } macro @foo(bool run, #lazy) { if (run) #lazy; } // Only "Said: Hello" is printed: @foo(false, print("Bye")); @foo(true, print("Hello"));
Labels	✓	while FOO: (x > 0) { for (int i = 0; i < 10; i++ { x = baz(); if (x > i) break FOO; } }
Inheritance	✓
Functions	✓
Implicit Type Casting	✓
hasIfElses	✓
hasIfs	✓
Hexadecimals	✓
hasForLoops	✓
Expressions	✓
hasEscapeCharacters	✓	"\e\n\r"
hasContinue	✓
hasBreak	✓
hasBoundedCheckedArrays	✓
hasArraySlicingSyntax	✓	int[] slice1 = array[0..5]; // start..end int[] slice2 = array[0:6]; // start:length
Octals	✓	127
Bitwise Operators	✓	int i = b << 4 + x; // Same as (b << 4) + x
Booleans	✓		true false
Comments	✓	// A comment /* Another comment */
Line Comments	✓	// A comment	//
Garbage Collection	X
Gotos	X
Case Insensitive Identifiers	X
Constructors	X
Variable Substitution Syntax	X
hasUserDefinedOperators	X
Units of Measure	X
Unicode Identifers	X
Abstract Types	X
Classes	X
Directives	X
Multiple Inheritance	X
S-Expressions	X
Pipes	X
Message Passing	X
Magic Getters and Setters	X
Homoiconicity	X
Function Composition	X
Function Overloading	X
Here Document	X
Dynamic Properties	X
Duck Typing	X
hasBuiltInRegex	X
Async Await	X
Semantic Indentation	X
Regular Expression Syntax Sugar	X