endolith

ּ_בּ
בּ_בּ
טּ_טּ
כּ‗כּ
לּ_לּ
מּ_מּ
סּ_סּ
תּ_תּ
٩(×̯×)۶
٩(̾●̮̮̃̾•̃̾)۶

brson

Edit: This list is now maintained in the rust-anthology repo.

• Introduction
  • Understanding Over Guesswork
  • An Alternative Introduction to Rust
  • Rust and CSV Parsing
• Ownership
  • Where Rust Really Shines
  • Rust Means Never Having to Close a Socket
• The Problem with Single-threaded Shared Mutability

malarkey

When times get tough and people get nasty, you’ll need more than a killer smile. You’ll need a killer contract.

Used by 1000s of designers and developers Clarify what’s expected on both sides Helps build great relationships between you and your clients Plain and simple, no legal jargon Customisable to suit your business Used on countless web projects since 2008

…………………………

spacejam

using rust with rr

rr is a great debugging tool. it records a trace of a program's execution, as well as the results of any syscalls it executes, so that you can "rewind" while you debug, and get deterministic forward and reverse instrumented playback. it works with rust, but by default if you try it out, it could be pretty ugly when you inspect variables. if this bothers you, configure gdb to use a rust pretty-printer

rr is probably in your system's package manager.

usage

nsf

#!/bin/bash

rm -rf *.o *.[568] test_*

luser

.cpp	3111001
.h	1272859
.c	1207323
.cc	303090
.rs	246356
.mm	57859
.hh	15850
.cxx	14731
.api	1854
.hxx	802

Gankra

Rust RFC 2005 "Match Ergonomics" was just accepted. However there was a copy-paste error in the summary that led to some confusion about what it was actually doing. Here's a quick run down of the details that matter to users:

TL;DR version:

Before this change, matching on references works like this:

let by_ref: &MyEnum;
let by_mut: &mut MyEnum;

Gankra

struct List<T> {
    head: Option<Box<Node<T>>>
}

struct Node<T> {
    elem: T,
    next: Option<Box<Node<T>>>,
}

impl<T> List<T> {

playground.rs

#![feature(unboxed_closures, fn_traits)]

fn get_fn_ptr<A, C: Fn<A>>(_: &C) -> extern "rust-call" fn(&(), A) -> C::Output {
    let fn_ptr: extern "rust-call" fn(&(), A) -> C::Output = unsafe {
        std::mem::transmute(<C as std::ops::Fn<A>>::call as usize)
    };
    fn_ptr
}

fn main() {

playground.rs

#![feature(unboxed_closures, fn_traits)]

fn get_fn_ptr<C: Fn() -> ()>(_: &C) -> extern "rust-call" fn(&(), ()) -> () {
    let fn_ptr: extern "rust-call" fn(&(), ()) -> () = unsafe { std::mem::transmute(<C as std::ops::Fn<()>>::call as usize) };
    fn_ptr
}

fn main() {
    let closure = ||{ println!("hi") };
    let ptr = get_fn_ptr(&closure);