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 SurelyNot {
    fn can_we_build_it(&self);
}
impl SurelyNot for String {
    fn can_we_build_it(&self) {
        println!("Yes we can");
    }
}

fn main() {

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

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

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

impl Position<String> for Location {

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

package main

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

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

grahamking

use std::error::Error;
use std::io::{stdin, Read};
use std::time;

fn main() -> Result<(), Box<dyn Error>> {
    let mut v: Vec<u8> = vec![0; 65536];
    let mut howmany = 0;
    let s = stdin();
    let mut cin = s.lock();
    let mut n = 1;

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

#!/bin/bash
#
# Usage: runperf ./my-benchmark-binary
#
# Script to run a benchmark / performance test in decent conditions. Based on:
# - https://www.llvm.org/docs/Benchmarking.html
# - "Performance Analysis and Tuning on Modern CPU" by Denis Bakhvalov, Appendix A.
# - https://github.com/andikleen/pmu-tools
#
# Note that this doesn't do any actual benchmarking, your binary must be able to do that all by itself.

grahamking

#![allow(dead_code)]

use anyhow::Context;
use std::alloc::AllocError;
use std::alloc::{Allocator, Layout};
use std::ffi::{c_char, c_uint, CStr, CString};
use std::io;
use std::mem::MaybeUninit;
use std::os::fd::AsRawFd;
use std::process;