stathissideris

(defn tree-seq-depth
  "Returns a lazy sequence of vectors of the nodes in a tree and their
  depth as [node depth], via a depth-first walk.  branch? must be a fn
  of one arg that returns true if passed a node that can have
  children (but may not).  children must be a fn of one arg that
  returns a sequence of the children. Will only be called on nodes for
  which branch? returns true. Root is the root node of the tree."
  [branch? children root]
  (let [walk (fn walk [depth node]
               (lazy-seq

ruby0x1

import Map;

class OrderedMapIterator<K,V> {

    var map : OrderedMap<K,V>;
    var index : Int = 0;

    public function new(omap:OrderedMap<K,V>)
        map = omap;
    public function hasNext() : Bool

deankarn

// LogResponseWritter wraps the standard http.ResponseWritter allowing for more
// verbose logging
type LogResponseWritter struct {
	status int
	size   int
	http.ResponseWriter
}

// func NewMyResponseWriter(res http.ResponseWriter) *MyResponseWriter {
// 	// Default the status code to 200

mattdsteele

Paprika doesn't have their API documented, so this is me reverse-engineering it from an Android device

Live Demo

https://knowing-grain.glitch.me/

Code: https://glitch.com/edit/#!/knowing-grain

Sync

callmecavs

import React, { Component, PropTypes } from 'react'
import ReactDOM from 'react-dom'

import throttle from 'lodash/throttle'

import { INTERVAL } from './constants.js'

let bound       // are the event handlers bound?
let current     // current scroll position, from top of document
let queue       // array of React Components to check

haxiomic

import haxe.macro.Context;
import haxe.macro.Expr;
import haxe.macro.TypeTools;

#if !macro
@:genericBuild(PartialMacro.build())
#end
class Partial<T> {}

class PartialMacro {

mihow

# The initial version
if [ ! -f .env ]
then
  export $(cat .env | xargs)
fi

# My favorite from the comments. Thanks @richarddewit & others!
set -a && source .env && set +a

Saissaken

# Repo: someuser/myframework
# Fork: superteam/myframework

# Track:
git clone https://github.com/superteam/myframework.git
cd myframework
git remote add upstream https://github.com/someuser/myframework.git

# Update:
git fetch upstream

rhoit

def multipart_encoder(params, files):
    boundry = uuid.uuid4().hex
    lines = list()
    for key, val in params.items():
        if val is None: continue
        lines.append('--' + boundry)
        lines.append('Content-Disposition: form-data; name="%s"'%key)
        lines.extend([ '', val ])

    for key, uri in files.items():

djspiewak

Thread Pools

Thread pools on the JVM should usually be divided into the following three categories:

1. CPU-bound
2. Blocking IO
3. Non-blocking IO polling

Each of these categories has a different optimal configuration and usage pattern.