dpwright

// Tested with clang version: Apple LLVM version 6.1.0 (clang-602.0.53) (based on LLVM 3.6.0svn)
// clang++ --std=c++11 enum-classes.cpp

#include <iostream>
#include <cassert>
#include <array>

enum class MaleNames {
	JACK,
	JOHN,

dpwright

{-# LANGUAGE RecursiveDo #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}

import Prelude   hiding (print, and, or)
import Data.Bits hiding (xor, bit)
import Data.Word

dpwright

import Foundation

//Dumb protocols... because protocols can't (afaik) take a generic type
//parameter, I can't define functions like fmap and bind in them, which are
//pretty essential for any kind of Functor/Monad implementation, but there you
//go...
//The bits in comments demonstrate what I'd *like* to do...
protocol Functor {
	typealias WrappedType
	typealias SelfGeneric

dpwright

# Threw together these two functions to demonstrate adding some immutable modification
# functions to Ruby's Array class.  "update" takes a hash of indices to values and
# returns a new array with the appropriate indices replaced by the supplied values.
# "modify" takes a list of indices and runs the block on those indices that match;
# like a version of "map" where you can specify the indices.

# Maybe you can already do this in Ruby, but I couldn't see anything in the docs so
# here's my hacky little monkey patch...

class Array

dpwright

import Data.Word8
import Data.Bits
import Data.Char
import Data.List

-- Sample text taken from Wikipedia
sampleText :: String
sampleText = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4="

-- splitEvery is defined in the Data.List.Splits library from package

dpwright

# Windows constructs the %PATH% environment variable by appending the user
# PATH to the system PATH, which means you can't override system-level programs
# with your own, user-specific version.

# To fix this, save this script and set it to run on logon by following these
# instructions: http://technet.microsoft.com/en-us/library/cc770908.aspx
# (If step 1 is a mystery to you, go to Start->Run and type "gpedit.msc")

# Requires Windows 7
# If your path is longer than 1024 characters, this might not work :-(

dpwright

Watchdog
========

Watchdog is a simple utility to spawn and monitor a process, respawning it if it
dies or is killed for whatever reason.  This is useful if you have a daemon
process that may encounter an unexpected error, or even just as a quick 'n' easy
upgrade mechanic -- just pop the new executable over the old one and shut the
process down!

There are a million of these, but I needed something quick 'n' dirty to

dpwright

Monadic operations in C++

This began as a further attempt to implement the Maybe monad in C++, but quickly spiralled out of control and now includes an implementation of the List monad as well (using std::list!). This is really for my own amusement rather than to try and do anything useful with them. It also gave me an excuse to try out C++ 11 lambda functions for the first time.

My original implementation defined a macro called MBind which caused a number of problems -- thankfully [PJayB][pjayb] managed to find a way around that so

dpwright

#include <iostream>
#include <cassert>
#include <cmath>

using namespace std;

template<typename a> class Maybe
{
        public:
                static Maybe<a> Just(a value) { return Maybe(value); }

dpwright

/* Basic tuple definitions */

#define ctuple1(a) union { struct { a hd; }; struct { a idx0; }; }
#define ctuple2(a, b) union { struct { a hd; ctuple1(b) tl; }; \
                              struct { a idx0; b idx1; }; }

#define ctuple3(a, b, c) union { struct { a hd; ctuple2(b, c) tl; }; \
                                 struct { a idx0; b idx1; c idx2; }; }

#define ctuple4(a, b, c, d) union { struct { a hd; ctuple3(b, c, d) tl; }; \