C3 0.8.0 replaces builtins, simplifies reflection, and rethinks unsigned sizes

C3 0.8.0 The Core Language Is Settling - C3 Programming Language Skip to content

Initializing search

Language Overview C to C3 Language Fundamentals Language Common Generic Programming Build Your Project Language Rules Misc Advanced Implementation Details Standard Library FAQ

Get Involved

Thank You

Blog

Single Page Docs

Enums and constdef Operator overloading Compile time enhancements Contracts Generics Syntax changes Toolchain changes Stdlib changes Fixes Summarizing Thank yous

C3 0.8.0 The Core Language Is Settling C3 is a programming language that evolves C – the same low-level model but with modern ergonomics. With 0.8.0, we're getting our first real glimpse of what C3 1.0 will look like: the core language design is now locking into its final shape. Two changes are big enough to deserve their own posts. The compile time reflection system has been reworked into its final form — and in the process we got to kill off half the builtins: link. And we're making the move to signed by default, correcting what turned out to be a five-year mistake: link. As with all 0.x.0 releases, we've tried to collect all the breaking changes into this single release, so the rest of the 0.8.x line can stay backwards compatible. Aside from the reflection changes, these are the major changes: Distinct types¶ Distinct types now defaults to be "structlike"¶ 0.7.4 introduced the concept of @structlike which meant a distinct type could not implicitly convert from a literal. With 0.8.0 we flip the defaults: by default distinct types do not convert from literals, but with @constinit they do: // 0.7.4 distinct Foo7 = int; distinct Bar7 @structlike = int;

Foo7 f = 1; // Ok // Bar7 b = 1; ERROR! Bar7 b = (Bar7)1; // Ok

// 0.8.0 distinct Foo8 @constinit = int; distinct Bar8 = int;

Foo8 f = 1; // Ok // Bar8 b = 1; ERROR! Bar8 b = (Bar8)1; // Ok

Often people were assuming "structlike" behaviour, cause accidental bugs. For this reason we flipped the defaults. Enums and constdef¶ No more +/-¶ Doing addition on enums is no longer possible: // 0.7.4 MyEnum foo = BAR; MyEnum baz = foo + 1; // OK!

// 0.8.0 MyEnum foo = BAR; // MyEnum baz = foo + 1; ERROR! MyEnum baz = (MyEnum)(foo.ordinal + 1); // OK

Enhanced ++/--¶ Enums still support ++/-- and get implicit wrapping when overshooting the ends: enum MyEnum ABC, DEF, GHI fn void test() MyEnum e = ABC; e++; // e is now DEF e++; // e is now GHI e++; // e is now ABC through overflow wrapping e--; // e is now GHI through underflow wrapping

Removed inline enums¶ To simplify the language, inline enums were dropped. // Ok in 0.7.x, error in 0.8.0 enum YourEnum : inline int TEST

int x = YourEnum.TEST; // Valid due to inline

Implicit conversion to ordinal when used as index¶ Enums will now implicitly convert to ordinals when used as index: enum YourEnum8 HELLO, WORLD

fn void test() int[2] x; x[YourEnum8.WORLD] = 123; // Same as x[1] = 123

.nameof has become .description¶ enum Foo TESTING, THE, NEW, DESCRIPTION

// 0.7.11 String s = TESTING.nameof; // "TESTING"

// 0.8.0 String s = TESTING.description; // "TESTING"

Constdef now infers through unary negations¶ Unary negation would previously prevent constdef inference constdef Abc ABC = 4, DEF = -4

Abc a = ABC; // Ok Abc b = -ABC; // Ok in 0.8.0 Abc c = ~ABC; // Ok in 0.8.0

Operator overloading¶ Overloads for comparisons¶ @operator( is now added, so that a type which overloads both and == can participate in all comparisons. @operator(!=) removed¶ @operator(!=) was removed as it had limited usefulness. Compile time enhancements¶ Shadow an a = ... parameter if it's not defined¶ Shadowing is now allowed: macro @foo(a = ...) $if !$defined(a) var a = 123; // Previously a shadowing error $endif return a * 2;

Use $eval as the name of a named parameter¶ foo(arg: 2);

// Possible since 0.8.0: foo($eval("arg"): 2);

untypedlist as a new builtin type¶ During compile time, some compile time arrays get the type "untypedlist", containing a (possibly heterogenous) list of values. Previously it was possible to create it, but it wasn't possible to directly reference the type. This changes with 0.8.0: // 0.7.11 - 'var' is the only possibility var $foo = { 1, "hello", 3.14 };

// 0.8.0 untypedlist $foo2 = { 1, "hello", 3.14 };

The main use is to be able to test whether an expression is an untyped list or not. Regular variables cannot have this type, it's a compile time type only. Added a tags property¶ An often requested functionality is getting all the tags on a type or member. This is now finally possible in 0.8.0: struct Foo @tag("a", "hello") @tag("b", "test") int x @tag("c", 5);

int a_global @tag("d", 3.14);

String[] $tags_of_foo = Foo::tags; // { "a", "b" } String[] $tags_of_x = $reflect(Foo.x).tags; // { "c" } String[] $tags_of_a_global = $reflect(a_global).tags; // { "d" }

Also note that name for retrieving and testing for tags have changed to get_tag and...

C3 0.8.0 replaces builtins, simplifies reflection, and rethinks unsigned sizes

Related Articles

Elevated error rates on requests to multiple models

Donald Trump and sons to be 'forever' exempt from tax audits

PopuLoRA: Co-Evolving LLM Populations for Reasoning Self- Play

Old Reddit Is Down

The ultimate female fantasy – A feminist critique of Beauty and the Beast