typenum: a Rust library for type-level arithmetic

• Title: typenum
• Author/s: Paho Lurie-Gregg, and contributors
• Language/s: Rust
• Year/s of development: 2015-2025

Code snippet:

// Simply negating the result of e.g. `U::I8` will result in overflow for `std::i8::MIN`. Instead,
// we use the fact that `U: NonZero` by subtracting one from the `U::U8` before negating.
impl<U: Unsigned + NonZero> Integer for NInt<U> {
    const I8: i8 = -((U::U8 - 1) as i8) - 1;
    const I16: i16 = -((U::U16 - 1) as i16) - 1;
    const I32: i32 = -((U::U32 - 1) as i32) - 1;
    const I64: i64 = -((U::U64 - 1) as i64) - 1;
    #[cfg(feature = "i128")]
    const I128: i128 = -((U::U128 - 1) as i128) - 1;
    const ISIZE: isize = -((U::USIZE - 1) as isize) - 1;

    // snip...
}

(This code excerpt can be found on Github).

Context:

This code snippet is in the Rust programming language. Rust is a lower-level programming language intended to replace C and C++ code, but with additional safety features that allow the Rust compiler to prove that a program will not exhibit certain kinds of bugs before the code is compiled. As part of these safety features, Rust has a robust and complex type system that can catch certain kinds of bugs (e.g., if a function accepts numbers, but is given a string). The specific code above is from a Rust library called typenum, a Rust library that allows for programmers to perform arithmetic computation within types. This allows for certain kinds of behaviors to be enforced while code is being compiled (e.g., you could prove that some code that concatenates two arrays produces an array whose length is equal to the sum of the lengths of the individual arrays). This specific code snippet implements a means of negating a type-level number.

The typenum library is largely concerned with safety---preventing potential logic errors in code at compile-time---and provides as example use cases:

dimensioned which does compile-time type checking for arbitrary unit systems and generic-array which provides arrays whose length you can generically refer to.

I've always been super fascinated at the genre of "programs that perform type-level computation using language features unintended for that task." There are many examples of this kind of performance in the wild: Brainfuck implemented in the Typescript type system [1,2], Forth implemented with Rust traits [3]. What excites me most about these kinds of projects is their queer (mis)use of simpler language features, ostensibly designed to provide easy-to-reason about guarantees to the programmer. The trait system in Rust is intended to provide folks with certain guarantees about their program---a type that implements a trait has guarantees on what methods it will implement, and what those methods will do. In this case, typenum is participating in queer use of the trait system---type-level computation---but in service of the same goals of the trait system itself: safety and security, to strengthen the compile-time guarantees provided by the language.

In reading this code snippet, I found myself returning to Tara McPherson's articulation of the UNIX operating system as being co-constitutive with race. McPherson notes that UNIX articulates security through modularity---separation of concerns and an atomization of programs, a reflection of the rise of neoliberalism in the 1960s. I would argue that Rust articulates security through abstraction. One of Rust's primary selling points is its zero-cost abstractions: "the ability to move certain behaviors to compile time execution or analysis." [4] The way it achieves guarantees around memory safety and execution time---the borrow-checker---relies on abstraction of the computer's memory model as a series of memory regions (an idea borrowed from the Cyclone language). The trait system being exploited/queered here is a mechanism for abstraction---being able to call methods on a trait without relying on implementation details of that trait. Rust exploits abstraction in service of securitization: guaranteeing that programs will not have data-races, use-after-frees, or runtime type errors.

In the contemporary U.S. American context, queerness is contending with its own kinds of abstraction. In the reactionary conservative imagination, "gender ideology" has become a phantasm, as Judith Butler puts it, into which anything and everything---DEI programs in colleges, drag shows, ethnic studies, trans and queer folks generally existing---can be slotted into. Jasbir Puar reminds us of how homonationalism recruits queerness into projects of nationalist exceptionalism, e.g., the U.S. using protection of queer folks to justify military intervention abroad, thus abstracting the meaning of "queerness" in the same vein as "democracy." These concerns are material to the Rust community itself. On one hand, there are thriving queer subcommunities within the Rust language, and queer folks are able to show up in the Rust community in ways unique to Rust. On the other hand, the security guarantees Rust provides gives it widespread corporate appeal, and Rust has become increasingly used at the companies at the heart of the U.S. American tech oligopoly.

Thus, I'd like to play with what it would mean to say the sentence: "We read Rust as co-constitutive with queerness." I'm curious how we can read the code of typenum as co-constitutive with queerness and its relationship with abstraction: examining the ways in which frameworks of abstraction and securitization are queered in typenum and Rust as an index into the social formations of U.S. American life.

Questions:

• How do we feel about these kinds of language feature shenanigans :^)

  • What makes typenum's code interesting, subversive, or queer?
  • What does it mean for these shenanigans to be "useful?"
  • What are other examples of creative ways to use, subvert, or queer language features, either for or against their original use cases?

• How can we read programming language design as intertwined with predominant social formations?

  • What does the development of typenum, or Rust, say about the sociopolitical moment we're living in right now?
  • What are other possible organizing metaphors for Rust?

Links:

[1] https://github.com/QuiiBz/tsfuck
[2] https://github.com/sno2/bf
[3] https://github.com/Ashymad/fortraith
[4] https://doc.rust-lang.org/beta/embedded-book/static-guarantees/zero-cost-abstractions.html