Skip to content

Instantly share code, notes, and snippets.


  • Somewhere, Earth
Block or report user

Report or block bjorn3

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
edmundsmith /
Created Jul 7, 2019
Method for Emulating Higher-Kinded Types in Rust

Method for Emulating Higher-Kinded Types in Rust


I've been fiddling about with an idea lately, looking at how higher-kinded types can be represented in such a way that we can reason with them in Rust here and now, without having to wait a couple years for what would be a significant change to the language and compiler.

There have been multiple discussions on introducing higher-ranked polymorphism into Rust, using Haskell-style Higher-Kinded Types (HKTs) or Scala-looking Generalised Associated Types (GATs). The benefit of higher-ranked polymorphism is to allow higher-level, richer abstractions and pattern expression than just the rank-1 polymorphism we have today.

As an example, currently we can express this type:


Raw Trait Objects 1.0

This is the sketch of a proposal for making it possible to manipulate some trait objects in stable rust.

Proposed new/stabilized API:

mod std::raw {
johnhw /
Last active Aug 31, 2019
1 million prime UMAP layout
### JHW 2018
import numpy as np
import umap
# This code from the excellent module at:
import random
mikeyhew /
Last active Jun 5, 2018
DerefMove and DerefInto
#![feature(arbitrary_self_types, specialization)]
use std::{
mem::{self, ManuallyDrop},
ptr::{self, NonNull},
ops::{Deref, DerefMut},
struct Move<'a, T: 'a + ?Sized> {
cessen /
Last active Jan 26, 2018
#Rust2018 blog post


This is my contribution to the call for Rust blog posts.

I've been using Rust for various personal projects for quite a while now, and I confess that I have a lot to say about it! In fact, I've already said quite a bit about it before.

My experience with Rust has been overwhelmingly positive, and most of the things I still want (e.g. NLL, const functions, const generic parameters, SIMD intrinsics, etc.) are already well known and being worked on, so it seems silly to repeat them. Therefore, in this post I'm just going to highlight three small-ish things that have been mildly frustrating to me over the last year, but which I haven't seen mentioned recently.

BidirectionalIterator trait

kyleheadley /
Created Aug 2, 2017
Implement the untyped lambda calculus in the Rust type system.
// Booleans
struct True;
struct False;
trait BoolOr<B> {type BoolOr;}
impl<B> BoolOr<B> for True {type BoolOr=True;}
impl BoolOr<True> for False {type BoolOr=True;}
impl BoolOr<False> for False {type BoolOr=False;}
suhr /
Last active Jan 1, 2019
Monochord: implementing a musical tunings library

First at all, falsehoods programmers believe about musical tuning:

  • C♯ and D♭ are the same notes
  • C𝄪 and D are the same notes
  • Semitone is 100 cents wide
  • There's only 12 notes in the octave
    • There's only 24 notes
    • Okay, 31 notes
    • Come on, 72 notes per octave is enough for everybody
    • You're kidding, right?
kristovatlas / cssbanner-beautified2.js
Last active Mar 9, 2018
cleaned up version of cssbanner.js
View cssbanner-beautified2.js
//beautified at with default options
//and then manually modified
/*jslint bitwise: true */
self.onmessage = function (msg) {
var thecode =;
* Ostensibly unused function
View rolling_sphere.txt
precision highp float;
precision mediump float;
uniform vec2 resolution;
#define FTIME_PERIOD 16.0
uniform float ftime;
uniform float subsecond;
You can’t perform that action at this time.