sleexyz

const connectMiddleware = (...middleware) => (req, res) => {
    const doAt = (i) => () => {
        if (i === middleware.length) throw new Error ("MockError: out of middleware!");
        middleware[i](req, res, doAt(i+1));
    };
    doAt(0)();
}

module.exports = connectMiddleware;

sleexyz

const parseReqAndThen = (reqParser, onSuccess) => {
  return (req, res, next) => {
    const parseResult = reqParser(req);
    if (typeof parseResult !== 'undefined') {
      const successApp = connect()
        .use(onSuccess(parseResult))
        .use((req, res) => {next();});
      successApp(req, res);
      return;
    }

sleexyz

import React, {createClass, createElement, PropTypes} from "react";
const e = createElement;

const Fullscreen = (Component) => createClass({
  displayName: 'Fullscreen',
  getInitialState() {
    return {
      width: window.innerWidth,
      height: window.innerHeight
    };

sleexyz

{-# LANGUAGE GADTs #-}
module Jam_2016_12_02 where

import Util

output = toProgram $ vec4 (v, v, v, 0.1)
 -- & (const  (bbF1 (texture2D channel2) uvN * 0.1))
 & (+ (bbF2 1 (texture2D backBuffer) uvN * 0.9))
 -- & (+ (bbF2 2 (texture2D backBuffer) uvN * 0.45))
 -- & (+ (bbF2 4 (texture2D backBuffer) uvN * 0.3))

sleexyz

{createElement} = require 'react'
e = require 'react-e'
{build: _build} = require 'utils/container_helpers'
_ = require 'lodash'


#
# Utilities
#

sleexyz

e = require 'react-e'
{Component} = require 'react'
{HOC, generateClass} = require './utils/HOC'
lettersActions = require './actions/letters'
classroomUnitsActions = require './actions/classroom_units'

module.exports = generateClass 'ClassroomUnit',

  HOC.ensureContentLoadedBeforeMount 
    key: 'letters'

sleexyz

Flow

• website: https://flowtype.org/
• original announcment: https://code.facebook.com/posts/1505962329687926/flow-a-new-static-type-checker-for-javascript/
• paper: http://www.cs.umd.edu/~avik/papers/iogti.pdf
• inspection utility: https://github.com/flowtype/flow-inspect

Extrinsic type system (Curry style)

Contrast with intrinsic type systems (ML, Haskell, Java, Scala).

sleexyz

import sys

# Splits stdin into separate files, each of which contains {chunkBy} unique prefixes.
# as the first {charactersToCompareBy} characters of a line
def chunkByLinePrefix(outputPrefix, chunkBy, prefixLength):
    counter = 0 # updated every line
    lastChunk = None # the last prefix

    fileCounter = 0 # updated every file
    f = open(outputPrefix + str(fileCounter).zfill(4), 'a') # updated every file

sleexyz

// @flow

type $Output<A> = $ObjMap<A, <O>(mixed => O) => O>;

export const Record = <A: {}>(record: A): (mixed => $Output<A>) => (x) => {
  if (typeof(x) !== 'object' || x === null) {
    throw new Error('not object');
  }
  for (const key in record) {
    if (!(key in x)) {

sleexyz

{-# LANGUAGE GADTs #-}

module Jam_2017_05_21 where

import Util

output = toProgram $ bb
  where
    bb = bbF (texture2D backBuffer) uvN