soc.me

Overview When designing bytecode operations for unions, encoding what is being done (instead of how) leads to desirable design properties: Higher resilience against changes to the union definition, which in turn improves support for separate compilation.

Union types in the sense of typed unions share many similarities with other kinds of unions when it comes to representing union values in memory, but also pose a few question unique to typed unions.

TLDR: Use multiple colors to make the various components of your number literals easily distinguishable.

The recent development of Java is an interesting case, as it faces these questions more acutely with the introduction of value types in Project Valhalla.

(Inspired by Almost Rules.)

Many languages’ Option and Result types suffer from an organically-grown and therefore inconsistently named set of functions.

Rust has distinct syntactic facilities for … invoking functions initializing structs and enums initializing tupled structs and enums … that provide different affordances and features: method arguments are positional and cannot be named initializer argumen…

TL;DR: Regardless on where you stand on the “Rust 2.0”, Rust’s current approach to language evolution is not sustainable.

TL;DR: Optimize for the common case, not the exotic ones.

simple if expression if x == 1.0 { "a" } else { "z" } This translates straight-forward to Rust: if x == 1.0 { "a" } else { "z" } multiple cases, equality relation if x ... == 1.0 { "a" } ... == 2.0 { "b" } else { "z" } In Rust, using

I was never too happy with the existing naming approaches for the Result type: Success/Failure pro: both names have the same length, like Option’s Some/None con: quite long, concern that people may use Option over Result Ok/Err pro: short con: names don’t…

Most people think only in terms of the dichotomy between Nominal-Manifest-Static-Strong and Structural-Inferred-Dynamic-Weak in any given discussion of programming language type system design.

TLD;DR: Your compiler should treat schema definitions as a valid (alternate) source syntax of your programming language.

get sugar Rule x.get(y) can be written as x(y) Explanation Instead of special-purpose syntax that is used for indexing operations (reading) in many languages, like int firstValue = someArray[0]; one can write let firstValue = someArray(0) /* same as */ l…

Merit Points Item -100 Adding a language feature to do something that can already be done -90 Adding a language feature to do something that can be implemented in a library -80 Adding a language feature to do something that can be achieved by fixing a com…

TL;DR: Properties are a hack employed to retrofit “nice” syntax into languages that already shipped with fields and methods.

In the past, many languages did not pick up easily adoptable language design improvements and opted for familiarity instead, often in a misguided attempt to keep perceived language complexity down.

Rust designers recognized the issues with Haskell’s approach, but were not able to address the issues with Rust’s Eq and PartialEq traits.

Projections Function Name Code Example Explanation map(<fun>) List(1, 2, 3).map(_ + 1) --> List(2, 3, 4) Returns a stream in which fun is applied to each element. mapMany(<fun>) mapMulti flatMap mapFlat mapAndFlatten List(1, 2).mapMany(x -> List(x, x)) -->

Function Name Code Example Explanation – List(12.3, 45.6)(0) --> Some(12.3) Map("key", "val")("key") --> Some("val") retrieves the value at the given index/key at(idx) Array(12.3, 45.6).at(1) --> Some(Ref(arr, 1)) returns a reference to the given position…

There is no good reason¹ why some type names need to start with a lower-case letter (int, float, str, …) and others with an upper-case letter (String, BigInt, Array, …).

Kotlin Kotlin gave up on it, as they couldn’t figure out how to recognize annotation usages as early in the compiler pipeline as modifiers previously.

TL;DR: If your language has annotations1, it doesn’t need modifiers.

Overview Syntactic Wrapping No Syntactic Wrapping No Runtime Tags untagged union (C union, C++ union, Rust union) union type (TypeScript union type) Runtime Tags discriminated union/tagged union (Rust enum, F# discriminated union) typed union (Algol united

static members properties (see) <> for generics (see) [] for arrays (see) Type ident instead of ident: Type (see) having if-then-else and switch/case and a ternary operator (see) having both modifiers and annotations (see) async/await separate namespaces…

TL;DR: Use [] instead of <> for generics.

A smaller language, not a bigger one namespaces: types, terms, packages , fields , methods , labels modifiers: keywords , annotations nesting: packages , modules, static members: fields, methods, properties control flow: if-then-else, return, while, break…

As a first approximation – especially if an existing language shall be adapted – it makes sense to build a feature-reduced version of unified condition expressions using a different keyword, in parallel to existing syntax.

TL;DR: Unary operators are a waste of a language’s complexity budget.

TL;DR: Use methods.

Basic goals, as mentioned in the previous parts: You should not lose values inside a data structure.

Similarly to equality and identity, most languages have severely restricted facilities to handle distinct ordering relationships like comparison and sorting.

6 letters namespacing – declaring and managing namespaces: module (unifies “object” and “package”) import export 5 letters “big” definitions (types): class (reference type) value (value type, alternative to struct) union (alternative to enum) trait (inter…

Function Name Code Example Explanation to array.toList int32Value.toFloat64 dictionary.to[Queue] implies a (potentially lossy) conversion of a value result type might use Option or Result types to encode failures as int64Value.asFloat64 int64Value.as[Floa…

Function Name Code Example Explanation – List(1, 2, 3) Array(12.3, 45.6) Set("a", "b", "c") primary way of construction resulting instance contains provided arguments verbatim of(val1, ...)

A reasonable question that might be asked is whether this design can be extended to also handle thrown exceptions, and whether such an extension could completely replace the try-catch-finally idiom.

Rust’s Into Rust’s std::convert::Into let’s you define conversion functions for structs like Person: pub struct Person { name: String } impl Into<String> for Person { fn into(self: Person) -> String { self.name } } This way functions can be defined…

Idea Replace the different syntactic forms of if statements/expressions switch on values match on patterns and pattern guards if-let constructs with a single, unified condition expression that scales from simple one-liners to complex pattern matches.

Scala has the concept of package objects which allow the declaration of methods, classes etc. that appear as if they existed directly inside a package, not enclosed in an object or a class.

Let’s take a step back and think about what these equality operations do: Reference equality acts as a built-in, hard-coded comparison of the references themselves.

Containment The core issue is that equality on its own is insufficient to implement some, rather mundane, algorithms.

Most languages have a notion of equality comparisons based on value equality.

(A random grabbag of things that I haven’t managed to include into the main article yet.)

In expressive languages, developers generally need to use fewer temporary variables.

Two interconnected design decisions achieve a particularly interesting sweet-spot in language design: The ident: Type syntax allows consistent and straight-forward placement of generics, compared to languages which use Type ident1: Generics ([T]) always f…

As Rust 2.0 is not going to happen, Rust users will never get these language design fixes:1234 A note on the lower bar of a hypothetical Rust 2.0 An article touching on "Rust 2.0" and its reactionary reception made it apparent that language evolution has…

TL;DR: The desire to make unrelated types act as if they were in a sub-typing relationship, which neither exists nor should exist, combined with syntax sugar that makes static dispatch look like dynamic dispatch creates a perfect storm of unintended, harm…