mbadran

alias cd="pushd $@ > /dev/null"

igstan

push = (element) -> (stack) ->
  newStack = [element].concat stack
  {value: element, stack: newStack}

pop = (stack) ->
  element = stack[0]
  newStack = stack.slice 1
  {value: element, stack: newStack}

bind = (stackOperation, continuation) -> (stack) ->

davidnunez

pm list packages -f

jboner

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

hellerbarde

Latency numbers every programmer should know

L1 cache reference ......................... 0.5 ns
Branch mispredict ............................ 5 ns
L2 cache reference ........................... 7 ns
Mutex lock/unlock ........................... 25 ns
Main memory reference ...................... 100 ns             
Compress 1K bytes with Zippy ............. 3,000 ns  =   3 µs
Send 2K bytes over 1 Gbps network ....... 20,000 ns  =  20 µs
SSD random read ........................ 150,000 ns  = 150 µs

Read 1 MB sequentially from memory ..... 250,000 ns = 250 µs

briancavalier

//-------------------------------------------------------------
//
// Hypothesis:
//
// Promises/A is a Monad
//
// To be a Monad, it must provide at least:
// - A unit (aka return or mreturn) operation that creates a corresponding
//   monadic value from a non-monadic value.
// - A bind operation that applies a function to a monadic value

seanparsons

scala> import scalaz._
import scalaz._

scala> import Scalaz._
import Scalaz._

scala> val a = (value: Int) => value * 2
a: Int => Int = <function1>

scala> val b = (value: Int) => value + 1

hallettj

/*
 * Example of a state monad in use.  This is adapted from an example on
 * the Haskell Wiki:
 * http://www.haskell.org/haskellwiki/State_Monad#Complete_and_Concrete_Example_1
 */
require(['state', 'qunit'], function(state, qunit) {

    /*
     * playGame() is a recursive function that given an array of moves
     * defines an algorithm for constructing a final game score.  Along

JackNova

//BASIC PIECES, 3 functions: unit, bind and the bind argument
//function unit(value)
//function bind(monad, function(value))
//all three functions return a monad

/* The unit function is a constructor (returns a monad object) 
* The magic is in the bind function
* 
* There are AXIOMS:
* bind(unit(value)), f) === f(value)

Gozala

// Utility function for detecting generators.
let isGenerator = x => {
  return Function.isGenerator &&
         Function.isGenerator.call(x)
}

// Data type represents channel into which values
// can be `put`, or `received` from. Channel is
// very much like queue where reads and writes are
// synchronized via continuation passing.