eyston

// is there a way to make this an awesome for comprehension or whatever?
// or maybe a built in Map method to do what I want? ;p

val codes: List[String] = ...
val configs: Map[String, Configuration] = ...
val defaultConfig: Configuration = ...

val config: Configuration = codes
  .find(configs.contains) // find the first code that the configs map contains
  .flatMap(configs.get) // grab the config for that first code

eyston

{:name nil
           :description nil
           :email nil
           :repositories {:count nil
                          :filters {:first {:count 50}
                                    :after {:cursor 22046023}}
                          :edges {:cursor nil
                                  :node {:id nil
                                         :name nil
                                         :full_name nil

eyston

(defn paged-http-get
  ([url]
   (paged-http-get url 1))
  ([url page]
   (let [sink (s/stream)]
     (d/loop [page page]
       (d/chain (http-get url {:query-params {"page" page}})
                (fn [response]
                  (let [body (:body response)]
                    (if (seq body)

eyston

(def graph {:roots {} :nodes {}})

;; end up wit ha structure like this after adding a node
(def graph {:roots {} :nodes {'Organization {:fields {:id {}}}}})

;; do I do this?
(let [field (get-in graph [:nodes 'Organization :fields :id])]
  ;; ...
  )

eyston

struct foo {
	float *stuff;
	int offset;

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

	float &operator[](size_t i)

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

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

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

// controller

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

// before filter

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
    | _ -> []