JSON is not Object Notation

This is a silly nit to pick, but here goes. JSON doesn't denote objects, it denotes finite, initial state which is exactly why it's useful. So, JSON isn't an "object notation", only JavaScript itself is.

Typing Transducers (as Kleisli arrows)

There's been a little flurry of activity around analyzing Clojure's upcoming transducers using Haskell types. This post outlines an isomorphism between one such representation and list "binding functions" a -> [b]. This suggests that flatMap is central to the idea of transduction.

Some Points About Type Safety

The technical concept "type safety", and even the underlying technical concept "type", is often misunderstood due to being conflated with marketing terms or given undue technical weight. This post enumerates some useful intuition pumps for better understanding, talking about, and consuming material related to type safety.

Codata Diagonalization

Modern programming has something that was often talked about but never formalized throughout much of modern mathematics, codata. This post sketches a constructive proof of diagonalization using codata in Haskell notation.

Immutable Enumeration in Swift

Enumeration of container types is a very important programming technique. In immutable languages, one mechanism for this is to have a generic "left view" interface. This interface corresponds exactly to Stream codata and Swift is powerful enough to (almost) implement all of the above directly.

Calkin-Wilf in Swift

A reimplementation of my lazy, infinite Calkin-Wilf enumeration of rationals post in Swift. Some commentary here talks about how to make heavily self-recursive data types compile in early betas of Swift.

The Types of Data (in Swift)

Swift is a new functional language developed by Apple. It has sufficiently nice types to directly represent most of what I discussed in The Types of Data. Let's see what they look like!

The Types of Data

If you think of programming as arising as something natural from the structure of our world—and there's good reason to do so—then we can see the types of data which correspond to basic, universal logic as fundamental. This post describes these types and hints heavily at why they are so basic and universal.

Mutable Algorithms in Immutable Languages, Part 3

The final post in the Mutable Algorithms in Immutable Languages exploration series. We discover how to use the type system to stop "border crossing" and, accidentally, reimplement a powerful Haskell feature, ST.

Mutable Algorithms in Immutable Languages, Part 2

The bridging of the Mutable Algorithms in Immutable Languages exploration series. Here we implement types satisfying the interfaces to Mem and identify an inherent weakness!