rauschma

Methods of regular expressions:

	Flags	Start matching	Anchored to	Result if match	No match	re.lastIndex
exec()	–	0	–	Match object	null	unchanged
	/g	re.lastIndex	–	Match object	null	index after match
	/y	re.lastIndex	re.lastIndex	Match object	null	index after match
	/gy	re.lastIndex	re.lastIndex	Match object	null	index after match
test()	(Any)	(like exec())	(like exec())	true	false	(like exec())

paf31

module Control.Monad.List.Trans where

import Prelude

import Data.List
import Data.Either

import Control.Apply
import Control.Bind
import Control.Monad.Eff

paulirish

What forces layout / reflow

All of the below properties or methods, when requested/called in JavaScript, will trigger the browser to synchronously calculate the style and layout*. This is also called reflow or layout thrashing, and is common performance bottleneck.

Generally, all APIs that synchronously provide layout metrics will trigger forced reflow / layout. Read on for additional cases and details.

Element APIs

Getting box metrics

• elem.offsetLeft, elem.offsetTop, elem.offsetWidth, elem.offsetHeight, elem.offsetParent

gaearon

function mapValues(obj, fn) {
  return Object.keys(obj).reduce((result, key) => {
    result[key] = fn(obj[key], key);
    return result;
  }, {});
}

function pick(obj, fn) {
  return Object.keys(obj).reduce((result, key) => {
    if (fn(obj[key])) {

staltz

let Rx = require(`rx`)

function makeRequestProxies(drivers) {
  let requestProxies = {}
  for (let name in drivers) {
    if (drivers.hasOwnProperty(name)) {
      requestProxies[name] = new Rx.ReplaySubject(1)
    }
  }
  return requestProxies

fumieval

{-# LANGUAGE DataKinds, TypeOperators, KindSignatures, GADTs, StandaloneDeriving, ScopedTypeVariables, Rank2Types, PolyKinds, DeriveTraversable #-}
import Unsafe.Coerce
import GHC.TypeLits
import Data.Type.Equality
import Data.Proxy
import Prelude hiding (drop)
import Data.Foldable

data Tree :: Nat -> Nat -> * -> * where
  Bin :: a -> Tree i j a -> Tree j k a -> Tree k (1 + j + k) a

justinwoo

import React from 'react';

/**
 * Counter.js
 *
 * exposes:
 *   init
 *   update
 *   view
 */

lambdahands

Huh?

So basically FlowType doesn't know about CSS Modules, a really handy way of dealing with the plagues of CSS in codebases (global variables and dependency wackiness mainly).

What WebPack allows us to do is "require" CSS files and use their class names:

import styles from "my_styles.css";
import React from "react";

jlongster

A lot of people mentioned other immutable JS libraries after reading my post. I thought it would be good to make a list of available ones.

There are two types of immutable libraries: simple helpers for copying JavaScript objects, and actual persistent data structure implementations. My post generally analyzed the tradeoffs between both kinds of libraries and everything applies to the below libraries in either category.

Libraries are sorted by github popularity.

Persistent Data Structures w/structural sharing

kangax

quicksort :: (Ord a) => [a] -> [a]    
quicksort [] = []    
quicksort (x:xs) =     
    let smallerSorted = quicksort (filter (<=x) xs)  
        biggerSorted = quicksort (filter (>x) xs)   
    in  smallerSorted ++ [x] ++ biggerSorted