Centril

// For debugging purposes:

impl<I, O, E=u32> IResult<I, O, E> {
    fn map_rem<R, F: FnOnce(I) -> R>(self, f: F) -> IResult<R, O, E> {
        use IResult::*;
        match s {
            Done(i, o) => Done(f(i), o),
            Error(e)   => Error(e),
            Incomplete(n) => Incomplete(n),
        }

Centril

#![feature(try_from)]

use std::str::FromStr;
use std::convert::TryFrom;

macro_rules! str_to_enum {
    ($typ: path, $($var: ident),+) => {
        impl std::str::FromStr for $typ {
            type Err = ();
            fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {

Centril

#![feature(alloc, heap_api)]
extern crate alloc;

use std::rc::Rc;
use std::mem::{align_of, align_of_val, size_of, size_of_val};

fn to_rc<T: ?Sized>(b: Box<T>) -> Rc<T> {
  // super duper undefined behavior!
  struct InnerRcBox<T: ?Sized> {
    strong: usize,

Centril

Keybase proof

I hereby claim:

• I am Centril on github.
• I am centril (https://keybase.io/centril) on keybase.
• I have a public key whose fingerprint is 17DC 71EF 7AD7 4032 4B5D 112E 818B 6F39 DE23 A081

To claim this, I am signing this object:

Centril

#![feature(core)]
#![feature(std_misc)]

use std::thread::{Thread, JoinGuard};

fn callback(v: usize) -> usize { v * 2 }

struct S {
    cb: Box<Fn(usize) -> usize + Send>,
}

Centril

fn main() {
    use std::mem::{size_of, size_of_val};

    let susize = size_of::<usize>();

    // usize is size_t.

    // "hello" is in static memory, x is on the stack and like: (char*, usize).
    // &'static str is a fat pointer.
    // It is not null terminated.

Centril

//******************************************************************************
// "const_trait_system"
//******************************************************************************

/*
Dependency DAG of proposal:

[A, B] -> []
[C] -> [B] and/or [A]  -- NOTE: C is moot without B or A.
[D, E] -> [B]

Centril

Notes on adding Constraint Kinds to Rust

Background: Constraint Kinds

a trait can be thought of as a type operator generating a "constraint" - what in Rust would usually be called a bound. For example:

// Declares a new item `Foo` with kind `type -> constraint`
trait Foo { }

Centril

Keyword policy

Upsides of proper keywords (with no availability on old editions)

• Avoid monotonically increasing tech debt
  • In particular, if contextual keywords accumulate over time, their grammatical interactions are going to get continually trickier
• Forward-compatible with introducing contextual keywords on older editions
• Forward-compatible with future uses that can’t be contextual
  • In case we decide 1.5 year hence that we want to do something new with the keyword.
• Arguably can give better error messages
• Cleaner

Centril

Unnamed structs

Nominal type equivalence

Let ≡n be the equivalence class of nominally equivalent types. A ≡n B denotes that A and B are nominally the same type.

{ foo: T, bar: U } ≡n { bar: U, foo: T } // Order does not matter.