grahamking

trait Position<T> {
    fn pos(&self) -> T;
}

struct Location {
    lat: f32,
    lon: f32,
}

impl Position<String> for Location {

grahamking

trait Nameable<T> {
    fn set_name(&mut self, T);
}

struct Cyborg{
    name: Option<String>,
}

impl Nameable<&str> for Cyborg {
    fn set_name(&mut self, s: &str) {

grahamking

struct Sponge {
    name: String,
}

impl std::ops::Add for Sponge {
    type Output = Self;
    fn add(self, other: Self) -> Self {
        Sponge {
            name: self.name + "X" + &other.name,
        }

grahamking

trait SurelyNot {
    fn can_we_build_it(&self);
}
impl SurelyNot for String {
    fn can_we_build_it(&self) {
        println!("Yes we can");
    }
}

fn main() {

grahamking

struct StdoutLogger {}

impl std::fmt::Display for StdoutLogger {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "I am StdoutLogger")
    }
}

fn main() {
    let l = StdoutLogger {};

grahamking

trait Logger {
    fn log(&self, s: &str);
    fn err(&self, e: &str) {
        self.log(e);
    }
}

struct StdoutLogger {}

impl Logger for StdoutLogger {

grahamking

trait Logger {
    fn log(&self, s: &str);
    fn err(&self, e: &str);
}

struct StdoutLogger {}

impl Logger for StdoutLogger {
    fn log(&self, s: &str) {
        println!("{}", s);

grahamking

package util

import (
	"errors"
	"strings"
)

// Errs is an error that collects other errors, for when you want to do
// several things and then report all of them.
type Errs struct {

grahamking

.text

.global _start

_start:
        mov $12, %rax   # brk syscall number
        mov $0, %rdi    # 0 is invalid, want to get current position
        syscall

        mov %rax, %rsi  # rsi now points to start of heap mem we'll allocate

grahamking

package main

import (
	"math/rand"
	"testing"
	"time"
)

const (
	numItems = 100 // change this to see how number of items affects speed