eyston

// possibly tail recursive :p

open System.IO

// Seq.toList because I don't know how to pattern match an empty sequence :)
let folderWithDepth' path depth = 
    try
        System.IO.Directory.EnumerateDirectories(path) |> Seq.toList |> List.map (fun d -> (d, depth))
    with
    | _ -> []

eyston

// controller

[CanViewProfile]
public ActionResult Show(int id)
{
    var view = new ShowProfileQuery(id).Execute();
    return View(view);
}

// before filter

eyston

import akka.actor.Actor

// defining messages -- Object = singleton, case class = DTO (sorta, generally)
object Born
case class Evolve(numberOfNeighbors: Int)
object Status

// receive is the method that handles incoming messages.
// alive: Receive and dead: Receive are defining alternative ways to respond to messages
// these will be switched on during runtime

eyston

module MessageBus
  class MessageBus
    @handlers = {}

    def self.subscribe message, handler, method
      @handlers[message] ||= []
      @handlers[message] << { :handler => handler, :method => method }
    end

    def self.send message, args

eyston

class EventBus

  def self.publish event args
    @subscribers[event].each do |sub|
      # whatever meta stuff sends event to method on object (handler) :p
    end
  end

  def self.subscribe event, handler, method
    @subscribers[event] = { :handler => handler, :method => method }

eyston

// Scala's for comprehensions can be used like Haskell's do notation for monadic code, ie. its a compact way to string together computations sequentially. 

val f = for {
  a <- Future(10 / 2) // 10 / 2 = 5
  b <- Future(a + 1)  //  5 + 1 = 6
  c <- Future(a - 1)  //  5 - 1 = 4
} yield b * c         //  6 * 4 = 24

val result = f.get()

eyston

def MPQ path
  path
end

class ReplayFile
  def initailize path
    @archive = MPQ(path)
  end
end

eyston

struct foo {
	float *stuff;
	int offset;

	float operator[](size_t i) const
	{
		return stuff[i + offset];
	}

	float &operator[](size_t i)