Peteris Erins Pet3ris

This article has been given a more permanent home on my blog. Also, since it was first written, the development of the Promises/A+ specification has made the original emphasis on Promises/A seem somewhat outdated.

You're Missing the Point of Promises

Promises are a software abstraction that makes working with asynchronous operations much more pleasant. In the most basic definition, your code will move from continuation-passing style:

getTweetsFor("domenic", function (err, results) {
 // the rest of your code goes here.

	# These are my notes from the PragProg book on CoffeeScript of things that either
	# aren't in the main CS language reference or I didn't pick them up there. I wrote
	# them down before I forgot, and put it here for others but mainly as a reference for
	# myself.

	# assign arguments in constructor to properties of the same name:
	class Thingie
	constructor: (@name, @url) ->

	# is the same as:

	(ns logic.y
	(:refer-clojure :exclude [== reify inc])
	(:use [clojure.core.logic minikanren prelude
	nonrel match]))

	(defna findo [x l o]
	([_ [[?y :- o] . _] _]
	(project [x ?y] (== (= x ?y) true)))
	([_ [_ . ?c] _] (findo x ?c o)))

	;; Adam Foltzer
	;; amb with ivars

	(load "pmatch.scm")

	;;;; Global scheduler queue and helpers; ugly!
	(define q '())

	(define push-right!
	(lambda (x)

	#!/usr/bin/env sh

	##
	# This is script with usefull tips taken from:
	# https://github.com/mathiasbynens/dotfiles/blob/master/.osx
	#
	# install it:
	# curl -sL https://raw.github.com/gist/2108403/hack.sh \| sh
	#

	Latency Comparison Numbers Time Light Distance Approximate Light Distance
	-------------------------- ---- -------------- --------------------------
	L1 cache reference 0.5 ns 0.15 m Diagonal across your smartphone
	Branch mispredict 5 ns 1.5 m Height of Natalie Portman
	L2 cache reference 7 ns 2.1 m Height of Shaq
	Mutex lock/unlock 25 ns 7.5 m Height of a school flag pole
	Main memory reference 100 ns 30 m Half a Manhattan city block (North/South)
	Compress 1K bytes with Zippy 3,000 ns 900 m Width of Central Park
	Send 1K bytes over 1 Gbps network 10,000 ns 3,000 m Width of Manhattan
	Read 4K randomly from SSD* 150,000 ns 45,000 m NYC to Hempstead on Long Island

	(define (return v) (lambda (s ks kf) (ks v s)))
	(define fail (lambda (s ks kf) (kf)))

	; >>=
	(define (bind a f)
	(lambda (s ks kf)
	(a s
	(lambda (av s1) ((f av) s1 ks kf))
	kf)))

	#!/usr/bin/env python2
	import os
	import gym
	import sys
	import random
	import itertools
	from time import time
	from copy import copy
	from math import sqrt, log

	/// A type equality guarantee is capable of safely casting one value to a
	/// different type. It can only be created when `S` and `T` are statically known
	/// to be equal.
	struct TypeEqualityGuarantee<S, T> {
	private init() {}

	/// Safely cast a value to the other type.
	func cast(_ value: T) -> S {
	return value as! S
	}

	/*
	If you're willing to write a little bit of boilerplate you can have type-safe GADT in Swift today.
	This is accomplished using a wrapper struct with a phantom type parameter that wraps a private enum value.
	Static factory methods on the struct wrap each case returning a value with the phantom type bound as necessary.
	An extension is created for each phantom type binding providng a `switch` method that requires each case
	with a matching type to be covered and uses `fatalError` for cases where values will never be created.
	New members are added in extensions that bind the phantom type and make use of the `switch` method.

	The example below is drawn from https://en.m.wikibooks.org/wiki/Haskell/GADT
	*/