tel

/* eslint-disable new-cap */

/**
 * Lens types.
 * ===========
 *
 * a * b = {fst: a, snd: b}
 * a + b = {index: Boolean, value: a | b}
 *
 * Iso   s t a b = forall (~>) . Profunctor (~>) => (a ~> b) -> (s ~> t)

bhauman

(ns todo-server.core
  (:require
   [cljs.nodejs :as nodejs]
   [figwheel.client :as fw]))

(nodejs/enable-util-print!)

(defonce express (nodejs/require "express"))
(defonce serve-static (nodejs/require "serve-static"))
(defonce http (nodejs/require "http"))

paf31

This blog post series has moved here.

You might also be interested in the 2016 version.

richhickey

(require '[clojure.core.async :as a])

(def xform (comp (map inc)
              (filter even?)
              (dedupe)
              (flatmap range)
              (partition-all 3)
              (partition-by #(< (apply + %) 7))
              (flatmap flatten)
              (random-sample 1.0)

john2x

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

Vectors and Sequences

Denommus

(* I'm using the new syntax sugars on 4.08, which are (let+), (and+) and ( let* ) *)

module type FUNCTOR = sig
  type 'a t
  val map : ('a -> 'b) -> 'a t -> 'b t
  val (let+): 'a t -> ('a -> 'b) -> 'b t
end

module DefaultLetPlus(M: sig
    type 'a t

conal

From section 9 of John Backus's 1977 Turing Award lecture Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs:

Denotational semantics and its foundations provide an extremely helpful mathematical understanding of the domain and function spaces implicit in programs. When applied to an applicative language (...), its foundations provide powerful tools for describing the language and for proving properties of programs. When applied to a von Neumann language, on the other hand, it provides a precise semantic description and is helpful in identifying trouble spots in the language. But the complexity of the language is mirrored in the complexity of the description, which is a bewildering collection of productions, domains, functions, and equations that is only slightly more helpful in proving facts about programs than the reference manual of the language, since it is less ambiguous.

...

Thus

staltz

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

---

emallson

;;; nodejs-repl-eval.el --- Summary
;;; Commentary:
;;;
;;; Evaluation functions for the `nodejs-repl' package.  Written on a stormy
;;; night between days of node hacking.
;;; 
;;; Code:

(require 'js2-mode)
(require 'nodejs-repl)

kseo

#! /usr/bin/env ocamlscript
Ocaml.ocamlflags := ["-thread"];
Ocaml.packs := [ "core" ]
--
open Core.Std

type term =
  | Ident of string
  | Lambda of string * term
  | Apply of term * term