Overloaded Functional Types

As some of you may know, I’m working on a compiler infrastructure written in D. While the framework itself is rather high-level (it’s very close to actually being half of a compiler front end), an actual compiler implementation is needed to see if the whole thing will work out as well as I hope. Thus, [...]

Three Reasons I Love Functional Programming

I realize a lot of people reading my blog are imperative programmers who haven’t looked into functional programming before. I figured I’d write a bit about why I find functional programming interesting and worthwhile. You might think that I like functional programming because of first-class functions. You might think that I like it because of [...]

The Actor Model and Message-Passing

I’m sure people who have been following me and talking to me have noticed how I’ve been looking so much into actor/agent-based concurrency and message-passing – how I’ve been talking about Axum, TPL Dataflow, Erlang, and some of my homebrewn equivalents. I believe the future of concurrency lies in message-passing. My reason for saying this [...]

F# and XBuild (Debian)

Since some folks from ##fsharp on irc.freenode.net requsted it, I’m going to put up the stuff I actually remember about getting F# projects on Linux/Mono to compile under XBuild. This guide assumes that you have successfully built and installed the F# tooling from source. Most of the stuff that needs to be done is hacking. [...]

The Usefulness of C++

Let’s kick the new year off with a rant about C++! Also, let me warn you in advance: I’m not going to distinguish between language and runtime in this post. I’m going to use ‘language’ as the general term for the programming language, its runtime, as well as supporting framework libraries. I’m going to get [...]

F#: Inline IL

Finally a .NET language that lets me do this crazy stuff! module Arithmetic let inline add x y = (# “add.ovf” x y : int #) let inline sub x y = (# “sub.ovf” x y : int #) let inline mul x y = (# “mul.ovf” x y : int #) let inline div [...]

F#: Y Combinator

Functional code! let y f = let g = ref (fun _ -> null) g := f (fun a -> !g a) !g Obviously, I’d like to not have the null constraint on the type parameter ‘b, though (implied by g). Need to figure out a workaround. Update: And there we go! It’s not pretty, [...]