F# for Fun and Profit

There’s more to learning a new language than the language itself.

In this post, we’ll look at how to calculate the “size”, or cardinality, of an algebraic type, and see how this knowledge can help us with design decisions.

Series summary Well, this series turned out to be longer than I originally planned.

This post is the sixth in a series.

This post is the fifth in a series.

This post is one in a series.

This post is the third in a series.

This post is the second in a series.

In this series of posts, I’ll attempt to describe some of the core functions for dealing with generic data types (such as Option and List).

TL;DR; An experiment: you can use lots of domain modelling types at development time and swap them out for a more performant implementation later using compiler directives.

What’s the difference between an introvert and extrovert mathematician?

The complete code for this post is available on GitHub A favorite trick of F# proponents is to take some F# code, compile it, and then decompile the result to C# using a tool such as ILSpy.

UPDATE: Slides and video from my talk on this topic Warning!

UPDATE: Slides and video from my talk on this topic Warning!

UPDATE: Slides and video from my talk on this topic Warning!

In my talk on functional DDD, I often use this slide (in context): Which is of course is a misquote of this famous scene.

I’ve been thinking for a while that F# needs a “birthday” that we can celebrate as a community.

UPDATE: Slides and video from my talk on this topic This post is one of series in I which I hope to close the gap between theory and practice in functional programming.

UPDATE: Slides and video from my talk on this topic This post is one of series in I which I hope to close the gap between theory and practice in functional programming.

As should be obvious, one of the goals of this site is to persuade people to take F# seriously as a general purpose development language.

UPDATE: Slides and video from my talk on this topic In the previous posts (link, link) we looked at “capabilities” as the basis for locking down code.

UPDATE: Slides and video from my talk on this topic In the previous post, we started looking at “capabilities” as the basis for ensuring that code could not do any more than it was supposed to do.

UPDATE: Slides and video from my talk on this topic In this series of posts, I’ll look at how you might handle the common security challenge of authorization.

In the previous two posts, we looked at applying property-based testing to lists and roman numerals.

In the previous post, we tested some list functions using various properties.

In the previous post, we looked at some common patterns for finding properties.

UPDATE: I did a talk on property-based testing based on these posts.

UPDATE: I did a talk on property-based testing based on these posts.

This post is part of the F# Advent Calendar in English 2014 project.

In this series of posts, I’ve been developing a simple pocket calculator app.

In this post, I’ll continue developing a simple pocket calculator app.

In this post, I’ll continue developing a simple pocket calculator app, like this: In the previous post, we completed a first draft of the design, using only types (no UML diagrams!).

One comment I hear often is a complaint about the gap between theory and practice in F# and functional programming in general.

This post is the conclusion of the series on low-risk and incremental ways to use F# at work.

This post is a continuation of the previous series on low-risk and incremental ways to use F# at work.

This post is a continuation of the previous series on low-risk and incremental ways to use F# at work – how can you get your hands dirty with F# in a low-risk, incremental way, without affecting any mission critical code?

This post is a continuation of the series on low-risk ways to use F# at work.

So you’re all excited about functional programming, and you’ve been learning F# in your spare time, and you’re annoying your co-workers by ranting about how great it is, and you’re itching to use it for serious stuff at work… But then you hit a brick wall.

After a long wait, the Roslyn project (C# compiler and analysis tools) has finally been released to much excitement (HN and Reddit and introductory post here).

I recently watched a video called “Roman Numerals Kata with Commentary”.

In the previous posts in this series, we only dealt with things that were proper monoids.

In the previous post, we looked at the definition of a monoid.

If you are coming from an OO background, one of the more challenging aspects of learning functional programming is the lack of obvious design patterns.

As a follow up to the Railway Oriented Programming post, I thought I’d apply the same technique to the FizzBuzz problem, and compare it with other implementations.

(Updated 2013-06-15.

In the previous post, we looked at the concept of dependency cycles, and why they are bad.

One of three related posts on module organization and cyclic dependencies.

Before we move on to any coding in the recipe, let’s look at the overall structure of a F# project.

“A ‘newbie’, in Haskell, is someone who hasn’t yet implemented a compiler.

UPDATE: Slides and video from a more comprehensive presentation available here (and if you understand the Either monad, read this first!).