mwhittaker

#! /bin/sh

usage() {
    echo "usage:"
    echo "    gitdown <markdown file>"
}

if test $# -lt 1; then
    usage;
    exit;

mwhittaker

#include <iostream>
#include <vector>

template<typename F>
int operator>>=(int i, F f) {
    if (i == 0) {
        return i;
    }
    return f(i);
}

mwhittaker

// Option bind for rust 0.10

fn inv(f: f32) -> Option<f32> {
    if f == 0.0 {
        None
    } 
    else {
        Some(1.0 / f)
    } 
}

mwhittaker

package main

import (
	"fmt"
	"net"
	"os"
	"time"
)

const (

mwhittaker

#![feature(macro_rules)] 

macro_rules! map(
    ()                                    => ({});
    ($a:expr)                             => ($a);
    ($a:expr -> $b:expr)                  => ($a.map($b));
    ($a:expr -> $b:expr -> $($c:expr)->*) => (map!($a.map($b) -> $($c)->*));
)

macro_rules! flatbind(

mwhittaker

\DefineNamedColor{named}{mongobrown}{RGB}{61,  41,  30}
\DefineNamedColor{named}{mongogold} {RGB}{129, 102, 75}
\DefineNamedColor{named}{mongogreen}{RGB}{55,  140, 40}
\DefineNamedColor{named}{darkgray}{cmyk}{0,0,0,0.90}

\mode<presentation>
\setbeamercolor{alerted text}{fg=red}
\setbeamercolor*{palette primary}{bg=mongobrown,fg=white}
\setbeamercolor*{palette secondary}{fg=white,bg=mongogreen}
\setbeamercolor*{palette tertiary}{fg=white,bg=darkgray}

mwhittaker

all: main_ounit.byte main_qcheck.byte main_pa_ounit.byte

main_ounit.byte: main_ounit.ml
	corebuild -pkg oUnit main_ounit.byte

main_pa_ounit.byte: main_pa_ounit.ml
	corebuild -pkg oUnit,pa_ounit,pa_ounit.syntax main_pa_ounit.byte

main_qcheck.byte: main_qcheck.ml
	corebuild -pkg qcheck main_qcheck.byte

mwhittaker

default: all

all: compile test

compile:
	cs3110 compile -t -p core -p async main.ml
	cs3110 compile -t -p core -p async main_test.ml

test: compile
	cs3110 test main_test.ml

mwhittaker

Google Cloud Platform

Table of Contents

• Common Commands
• Resources
  • Google Cloud Platform
  • Google Compute Engine
  • Google Cloud Dataflow

Common Commands

mwhittaker

use std::ops::Shr;
use Maybe::{Nothing, Just};

#[derive(Debug)]
enum Maybe<A> {
    Nothing,
    Just(A)
}

impl<A, B, F> Shr<F> for Maybe<A> where F: Fn(A) -> Maybe<B> {