https://fsharpforfunandprofit.com/ Recent content on F# for Fun and Profit Hugo -- gohugo.io en-us Sun, 28 Dec 2025 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-weaving-software-2/ Sun, 28 Dec 2025 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-weaving-software-2/ This is the second post in a series on designing software for weavers. These posts contain random thoughts and musings based on design challenges that I come across as I build a real-world project. In the first post I give the context for this project and presented the code for a initial domain-driven design. In this post and the next one, we’ll move to the next stage, converting between a text representation and the domain model. https://fsharpforfunandprofit.com/posts/designing-weaving-software/ Fri, 19 Dec 2025 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-weaving-software/ This post is part of the 2025 F# Advent Calendar. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. Recently, I have taken up a new hobby, hand weaving. As a meditative, physical activity with tangible results, it’s a great antidote to doom-scrolling and spending too much time in front of a screen. The first time I tried it, something about the weaving process really appealed to me and I got a little bit obsessed with learning more. https://fsharpforfunandprofit.com/posts/return-of-the-edfh-3/ Tue, 16 Feb 2021 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/return-of-the-edfh-3/ In the first post in this series, we came up with some properties that could be used to test a run-length encoding implementation: The output must contain all the characters from the input, in the same order Two adjacent characters in the output cannot be the same The sum of the run lengths in the output must equal the total length of the input If the input is reversed, the output must also be reversed In the previous post, we tested various RLE implementations created by the Enterprise Developer From Hell and were happy that they all failed. https://fsharpforfunandprofit.com/posts/return-of-the-edfh-2/ Mon, 15 Feb 2021 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/return-of-the-edfh-2/ In the previous post we attempted to define some properties for a run-length encoding (RLE) implementation, but got stuck because the random values being generated by FsCheck were not very useful. In this post we’ll look at a couple of ways of generating “interesting” inputs, and how to observe them so that we can be sure that they are indeed interesting. Observing the generated data The first thing we should do is add some kind of monitoring to see how many of the inputs are interesting. https://fsharpforfunandprofit.com/series/return-of-the-edfh/ Sun, 14 Feb 2021 00:00:00 +0000 https://fsharpforfunandprofit.com/series/return-of-the-edfh/ This series of posts is a follow-up to my previous series on property-based testing and the Enterprise Developer From Hell. It revisits the fundamentals of property-based testing and how to use the EDFH to help design useful and effective tests. https://fsharpforfunandprofit.com/posts/return-of-the-edfh/ Sun, 14 Feb 2021 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/return-of-the-edfh/ In a previous series of posts, I introduced you to the burned-out and lazy programmer known as the Enterprise Developer From Hell, or the EDFH for short. As we saw, the EDFH loves to practice malicious compliance. Recently, the EDFH’s influence was apparent with this viral answer to an interview problem. Write a function that converts the input to the output. Input: “aaaabbbcca” Output: [(‘a’,4), (‘b’,3), (‘c’,2), (‘a’,1)] Of course the EDFH answer is simple: https://fsharpforfunandprofit.com/about/terms/ Fri, 01 Jan 2021 00:00:00 +0000 https://fsharpforfunandprofit.com/about/terms/ These terms and conditions form your agreement with this site (hereafter, the SITE) and ScottW (hereafter, ME). By reading this site, you agree to the following: You acknowledge that this SITE is written by one person, ME, over many years as I was learning, and that many of the posts may be out-of-date, incomplete, or just plain wrong. You also acknowledge that the ME of today is not happy with many of the old posts but has been too lazy to update them. https://fsharpforfunandprofit.com/posts/dependencies-5/ Thu, 24 Dec 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/dependencies-5/ In this series, we looked at six different approaches to dependency injection. In the first post, we looked at “dependency retention” (inlining the dependencies) and “dependency rejection”, or keeping I/O at the edges of your implementation. In the second post, we looked at injecting dependencies using standard function parameters. In the third post, we looked at dependency handling using classic OO-style dependency injection and the FP equivalent: the Reader monad. https://fsharpforfunandprofit.com/posts/dependencies-4/ Wed, 23 Dec 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/dependencies-4/ In this series, we are looking at six different approaches to dependency injection. In the first post, we looked at “dependency retention” (inlining the dependencies) and “dependency rejection” (keeping I/O at the edges of your implementation). In the second post, we looked at injecting dependencies using standard function parameters. In the third post, we looked at dependency handling using classic OO-style dependency injection and the FP equivalent: the Reader monad. https://fsharpforfunandprofit.com/posts/dependencies-3/ Tue, 22 Dec 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/dependencies-3/ In this series, we are looking at six different approaches to dependency injection. In the first post, we looked at “dependency retention” (inlining the dependencies) and “dependency rejection” (keeping I/O at the edges of your implementation). In the second post, we looked at injecting dependencies as standard function parameters. In this post, we’ll look at dependency handling using classic OO-style dependency injection and the FP equivalent: the Reader monad Revisiting the logging problem In the previous post, I briefly discussed the logging problem. https://fsharpforfunandprofit.com/posts/dependencies-2/ Mon, 21 Dec 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/dependencies-2/ In this series, we are looking at six different approaches to dependency injection. In the first post, we looked at “dependency retention” (inlining the dependencies) and “dependency rejection” (keeping I/O at the edges of your implementation). In this post, we’ll look at “dependency parameterization” as a way of managing dependencies. Dependency parameterization Given that you have made the effort to separate pure from impure code, you may still need to manage other dependencies. https://fsharpforfunandprofit.com/posts/dependencies/ Sun, 20 Dec 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/dependencies/ This post is part of the 2020 F# Advent Calendar. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. In this series of posts, we’ll look at six different approaches to doing “dependency injection”. This post was inspired by Mark Seemann’s similar series of posts, and covers the same ideas in a slightly different way. There are other good posts on this topic by Bartosz Sypytkowski and Carsten König. https://fsharpforfunandprofit.com/series/low-risk-ways-to-use-fsharp-at-work/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/low-risk-ways-to-use-fsharp-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. Your workplace has a “C# only” policy and won’t let you use F#. If you work in a typical enterprise environment, getting a new language approved will be a long drawn out process, involving persuading your teammates, the QA guys, the ops guys, your boss, your boss’s boss, and the mysterious bloke down the hall who you’ve never talked to. https://fsharpforfunandprofit.com/series/recursive-types-and-folds/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/recursive-types-and-folds/ In this series, we’ll look at recursive types and how to use them, and on the way, we’ll look at catamorphisms, tail recursion, the difference between left and right folds, and more. https://fsharpforfunandprofit.com/series/annotated-walkthroughs/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/annotated-walkthroughs/ One comment I hear often is a complaint about the gap between theory and practice in F# and functional programming in general. In other words, you know the theory, but how do you actually design and implement an application using FP principles? So I thought it might be useful to show you how I personally would go about designing and implementing some little applications from beginning to end. These will be sort of annotated live coding sessions. https://fsharpforfunandprofit.com/series/computation-expressions/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/computation-expressions/ In this series, you’ll learn what computation expressions are, some common patterns, and how to make your own. In the process, we’ll also look at continuations, the bind function, wrapper types, and more. https://fsharpforfunandprofit.com/series/dependency-cycles/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/dependency-cycles/ One of the most common complaints about F# is that it requires code to be in dependency order. That is, you cannot use forward references to code that hasn’t been seen by the compiler yet. In this series, I discuss dependency cycles, why they are bad, and how to get rid of them. https://fsharpforfunandprofit.com/series/designing-with-types/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/designing-with-types/ In this series, we’ll look at some of the ways we can use types as part of the design process. In particular, the thoughtful use of types can make a design more transparent and improve correctness at the same time. This series will be focused on the “micro level” of design. That is, working at the lowest level of individual types and functions. Higher level design approaches, and the associated decisions about using functional or object-oriented style, will be discussed in another series. https://fsharpforfunandprofit.com/series/expressions-and-syntax/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/expressions-and-syntax/ In this series of posts we’ll look at how functions and values are combined into expressions, and the different kinds of expressions that are available in F#. https://fsharpforfunandprofit.com/series/a-functional-approach-to-authorization/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/a-functional-approach-to-authorization/ In this series of posts, I’ll look at how you might handle the common security challenge of authorization. That is, how can you ensure that clients of your code can only do what you want them to do? This series will sketch out two different approaches, first using an approach called capability based security, and second using statically checked types to emulate access tokens. Interestingly, both approaches tend to produce a cleaner, more modular design as a side effect, which is why I like them! https://fsharpforfunandprofit.com/series/handling-state/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/handling-state/ In this series of posts, I’ll look at how you can thread state through a series of pure functions in a convenient way. To start with, I’ll tell the story of Dr Frankenfunctor and the Monadster, and how the Doctor needed a way to create “recipes” that were activated when lightning struck. The Doctor then devised ways to work with these recipes using functions such as map, bind and apply. https://fsharpforfunandprofit.com/series/object-oriented-programming-in-fsharp/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/object-oriented-programming-in-fsharp/ As has been stressed many times before, F# is fundamentally a functional language at heart, yet the OO features have been nicely integrated and do not have a “tacked-on” feeling. As a result, it is quite viable to use F# just as an OO language, as an alternative to C#, say. In this series, we’ll look at how F# supports object-oriented classes and methods. https://fsharpforfunandprofit.com/series/optimization/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/optimization/ This is a placeholder for a series I haven’t written yet. Please check back later! https://fsharpforfunandprofit.com/series/porting-from-csharp/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/porting-from-csharp/ Do you want to port C# code to F#? In this series of posts we’ll look at various approaches to this, and the design decisions and trade-offs involved. https://fsharpforfunandprofit.com/series/property-based-testing/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/property-based-testing/ This series of posts will introduce you to the fundamentals of property-based testing: how it is different from traditional example-based testing, why it is important, and how to work with properties in theory and practice. A follow-up series is available too: The Return of the Enterprise Developer From Hell. There is also a talk on property-based testing based on these posts. Slides and video here. https://fsharpforfunandprofit.com/series/a-recipe-for-a-functional-app/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/a-recipe-for-a-functional-app/ “I think I understand functional programming at the micro level, and I have written toy programs, but how do I actually go about writing a complete application, with real data, real error handling, and so on?" This is a very common question, so I thought that in this series of posts I’d describe a recipe for doing exactly this, covering design, validation, error handling, persistence, dependency management, code organization, and so on. https://fsharpforfunandprofit.com/series/thinking-functionally/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/thinking-functionally/ This series of posts will introduce you to the fundamentals of functional programming – what does it really mean to “program functionally”, and how this approach differs from object oriented or imperative programming. https://fsharpforfunandprofit.com/series/understanding-fsharp-types/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/understanding-fsharp-types/ F# is not just about functions; the powerful type system is another key ingredient. And just as with functions, understanding the type system is critical to being fluent and comfortable in the language. In addition to the common .NET types. F# has some other types that are very common in functional languages but not available in imperative languages like C# or Java. This series introduces these types and how to use them. https://fsharpforfunandprofit.com/series/understanding-monoids/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/understanding-monoids/ In this series, we’ll look at a very common “pattern” known as a monoid. Monoids are not really a design pattern; more an approach to working with many different types of values in a common way. In fact, once you understand monoids, you will start seeing them everywhere! https://fsharpforfunandprofit.com/series/why-use-fsharp/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/why-use-fsharp/ This series of posts will give you a guided tour through the main features of F# and then show you ways that F# can help you in your day-to-day development. https://fsharpforfunandprofit.com/series/map-and-bind-and-apply-oh-my/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/map-and-bind-and-apply-oh-my/ 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). This is a follow-up post to my talk on functional patterns. Yes, I know that I promised not to do this kind of thing, but for this post I thought I’d take a different approach from most people. Rather than talking about abstractions such as type classes, I thought it might be useful to focus on the core functions themselves and how they are used in practice. https://fsharpforfunandprofit.com/series/understanding-parser-combinators/ Wed, 01 Jan 2020 00:00:00 +0000 https://fsharpforfunandprofit.com/series/understanding-parser-combinators/ In this series, we’ll look at how so-called “applicative parsers” work. In order to understand something, there’s nothing like building it for yourself, and so we’ll create a basic parser library from scratch, then some useful “parser combinators”, and then finish off by building a complete JSON parser. https://fsharpforfunandprofit.com/posts/against-railway-oriented-programming/ Fri, 20 Dec 2019 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/against-railway-oriented-programming/ This post is part of the 2019 F# Advent Calendar. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. Six and half years ago, I wrote a post and did a talk on what I called “Railway Oriented Programming”. It was a way for me to explain to myself and others how to use Result/Either to for chaining together error-generating functions. https://fsharpforfunandprofit.com/posts/fsharp-is-the-best-enterprise-language/ Thu, 20 Dec 2018 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/fsharp-is-the-best-enterprise-language/ This post is part of the 2018 F# Advent Calendar. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. “Why F# is the best enterprise language” is not meant to be a clickbait title – it is my sincere opinion, and in this post I will attempt to justify it. If you stick around to the end, I hope that you will agree, or at least be a little bit persuaded. https://fsharpforfunandprofit.com/posts/serializing-your-domain-model/ Wed, 20 Dec 2017 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/serializing-your-domain-model/ This post is part of the F# Advent Calendar in English 2017 project. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. In most discussions of functional design principles, we focus on implementing business workflows as pure functions with inputs and outputs. But where do these inputs come from? And where do the outputs go? They come from, or go to, some infrastructure that lives outside our workflow – a message queue, a web request, and so on. https://fsharpforfunandprofit.com/posts/dependency-injection-1/ Mon, 05 Dec 2016 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/dependency-injection-1/ This post is part of the F# Advent Calendar in English 2016 project. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. UPDATE: This post is superceded by a newer one here. For people who are learning functional programming techniques, one of the more common questions is: “how do you do dependency injection?” This series of posts addresses that topic. https://fsharpforfunandprofit.com/posts/happy-fsharp-day-2/ Tue, 12 Apr 2016 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/happy-fsharp-day-2/ Last year, I wrote a post called “Happy F# Day”, explaining why I thought F# needed a “birthday” that we could celebrate as a community. Here we are one year later! I’m going to promote that date (April 12th) again, and use it an excuse to review what has happened in the last year in the world of F#. And a lot has happened in the last year. Here’s my personal take. https://fsharpforfunandprofit.com/posts/13-ways-of-looking-at-a-turtle-3/ Mon, 07 Dec 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/13-ways-of-looking-at-a-turtle-3/ UPDATE: Slides and video from my talk on this topic In this, the third part of my two-part mega-post, I’m continuing to stretch the simple turtle graphics model to the breaking point. In the first and second post, I described thirteen different ways of looking at a turtle graphics implementation. Unfortunately, after I published them, I realized that there were some other ways that I had forgotten to mention. So in this post, you’ll get to see two BONUS ways. https://fsharpforfunandprofit.com/posts/13-ways-of-looking-at-a-turtle-2/ Sun, 06 Dec 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/13-ways-of-looking-at-a-turtle-2/ UPDATE: Slides and video from my talk on this topic This post is part of the F# Advent Calendar in English 2015 project. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. In this two-part mega-post, I’m stretching the simple turtle graphics model to the limit while demonstrating partial application, validation, the concept of “lifting”, agents with message queues, dependency injection, the State monad, event sourcing, stream processing, and an interpreter! https://fsharpforfunandprofit.com/posts/13-ways-of-looking-at-a-turtle/ Sat, 05 Dec 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/13-ways-of-looking-at-a-turtle/ UPDATE: Slides and video from my talk on this topic This post is part of the F# Advent Calendar in English 2015 project. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. I was discussing how to implement a simple turtle graphics system some time ago, and it struck me that, because the turtle requirements are so simple and so well known, it would make a great basis for demonstrating a range of different techniques. https://fsharpforfunandprofit.com/posts/understanding-parser-combinators-4/ Fri, 13 Nov 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/understanding-parser-combinators-4/ UPDATE: Slides and video from my talk on this topic In this series, we are looking at how applicative parsers and parser combinators work. In the first post, we created the foundations of a parsing library. In the second post, we built out the library with many other useful combinators. In the third post, we improved the error messages. In this last post, we’ll use the library we’ve written to build a JSON parser. https://fsharpforfunandprofit.com/posts/understanding-parser-combinators-3/ Thu, 12 Nov 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/understanding-parser-combinators-3/ UPDATE: Slides and video from my talk on this topic In this series, we are looking at how applicative parsers and parser combinators work. In the first post, we created the foundations of a parsing library. In the second post, we built out the library with many other useful combinators. In this post, we’ll rework the library to provide more helpful error messages. 1. Labelling a Parser In some of the failing code examples from earlier posts, we got confusing errors: https://fsharpforfunandprofit.com/posts/understanding-parser-combinators-2/ Wed, 11 Nov 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/understanding-parser-combinators-2/ UPDATE: Slides and video from my talk on this topic In this series, we are looking at how applicative parsers and parser combinators work. In the first post, we created the foundations of a parsing library. In this post, we’ll build out the library with many other useful combinators. The combinator names will be copied from those used by FParsec, so that you can easily migrate to it. 1. https://fsharpforfunandprofit.com/posts/understanding-parser-combinators/ Tue, 10 Nov 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/understanding-parser-combinators/ UPDATE: Slides and video from my talk on this topic In this series, we’ll look at how so-called “applicative parsers” work. In order to understand something, there’s nothing like building it for yourself, and so we’ll create a basic parser library from scratch, and then some useful “parser combinators”, and then finish off by building a complete JSON parser. Now terms like “applicative parsers” and “parser combinators” can make this approach seem complicated, but rather than attempting to explain these concepts up front, we’ll just dive in and start coding. https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-3b/ Tue, 25 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-3b/ This post is the sixth in a series. In the previous post, we briefly looked at some generic types. In this post, we’ll do some deeper dives into some real-world examples of using trees and folds. Series contents Here’s the contents of this series: Part 1: Introduction to recursive types and catamorphisms A simple recursive type Parameterize all the things Introducing catamorphisms Benefits of catamorphisms Rules for creating a catamorphism Part 2: Catamorphism examples Catamorphism example: File system domain Catamorphism example: Product domain Part 3: Introducing folds A flaw in our catamorphism implementation Introducing fold Problems with fold Using functions as accumulators Introducing foldback Rules for creating a fold Part 4: Understanding folds Iteration vs. https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-3/ Mon, 24 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-3/ This post is the fifth in a series. In the previous post, we spent some time understanding folds for specific domain types. In this post, we’ll broaden our horizons and look at how to use generic recursive types. Series contents Here’s the contents of this series: Part 1: Introduction to recursive types and catamorphisms A simple recursive type Parameterize all the things Introducing catamorphisms Benefits of catamorphisms Rules for creating a catamorphism Part 2: Catamorphism examples Catamorphism example: File system domain Catamorphism example: Product domain Part 3: Introducing folds A flaw in our catamorphism implementation Introducing fold Problems with fold Using functions as accumulators Introducing foldback Rules for creating a fold Part 4: Understanding folds Iteration vs. https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-2b/ Sun, 23 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-2b/ This post is the fourth in a series. In the previous post, I introduced “folds”, a way of creating top-down iterative functions for recursive types. In this post, we’ll spend some time understanding folds in more detail. Series contents Here’s the contents of this series: Part 1: Introduction to recursive types and catamorphisms A simple recursive type Parameterize all the things Introducing catamorphisms Benefits of catamorphisms Rules for creating a catamorphism Part 2: Catamorphism examples Catamorphism example: File system domain Catamorphism example: Product domain Part 3: Introducing folds A flaw in our catamorphism implementation Introducing fold Problems with fold Using functions as accumulators Introducing foldback Rules for creating a fold Part 4: Understanding folds Iteration vs. https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-2/ Sat, 22 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-2/ This post is the third in a series. In the first post, I introduced “catamorphisms”, a way of creating functions for recursive types, and in the second post, we created a few catamorphism implementations. But at the end of the previous post, I noted that all the catamorphism implementations so far have had a potentially serious flaw. In this post, we’ll look at the flaw and how to work around it, and in the process look at folds, tail-recursion and the difference between “left fold” and “right fold”. https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-1b/ Fri, 21 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recursive-types-and-folds-1b/ This post is the second in a series. In the previous post, I introduced “catamorphisms”, a way of creating functions for recursive types, and listed some rules which can be used to implement them mechanically. In this post, we’ll use these rules to implement catamorphisms for some other domains. Series contents Here’s the contents of this series: Part 1: Introduction to recursive types and catamorphisms A simple recursive type Parameterize all the things Introducing catamorphisms Benefits of catamorphisms Rules for creating a catamorphism Part 2: Catamorphism examples Catamorphism example: File system domain Catamorphism example: Product domain Part 3: Introducing folds A flaw in our catamorphism implementation Introducing fold Problems with fold Using functions as accumulators Introducing foldback Rules for creating a fold Part 4: Understanding folds Iteration vs. https://fsharpforfunandprofit.com/posts/recursive-types-and-folds/ Thu, 20 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recursive-types-and-folds/ In this series, we’ll look at recursive types and how to use them, and on the way, we’ll look at catamorphisms, tail recursion, the difference between left and right folds, and more. Series contents Here’s the contents of this series: Part 1: Introduction to recursive types and catamorphisms A simple recursive type Parameterize all the things Introducing catamorphisms Benefits of catamorphisms Rules for creating a catamorphism Part 2: Catamorphism examples Catamorphism example: File system domain Catamorphism example: Product domain Part 3: Introducing folds A flaw in our catamorphism implementation Introducing fold Problems with fold Using functions as accumulators Introducing foldback Rules for creating a fold Part 4: Understanding folds Iteration vs. https://fsharpforfunandprofit.com/posts/list-module-functions/ Fri, 14 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/list-module-functions/ There’s more to learning a new language than the language itself. In order to be productive, you need to memorize a big chunk of the standard library and be aware of most of the rest of it. For example, if you know C#, you can pick up Java-the-language quite quickly, but you won’t really get up to speed until you are comfortable with the Java Class Library as well. Similarly, you can’t really be effective in F# until you have some familiarity with all the F# functions that work with collections. https://fsharpforfunandprofit.com/posts/type-size-and-design/ Thu, 13 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/type-size-and-design/ 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. Getting started I’m going to define the “size” of a type by thinking of it as a set, and counting the number of possible elements. For example, there are two possible booleans, so the size of the Boolean type is two. https://fsharpforfunandprofit.com/posts/elevated-world-7/ Sat, 08 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/elevated-world-7/ Series summary Well, this series turned out to be longer than I originally planned. Thanks for making it to the end! I hope that this discussion has been helpful in understanding the various function transformations like map and bind, and given you some useful techniques for dealing with world-crossing functions – maybe even demystified the m-word a bit! If you want to start using these kinds of functions in your own code, I hope that you can see how easy they are to write, but you should also consider using one of the excellent F# utility libraries that contain these and much more: https://fsharpforfunandprofit.com/posts/elevated-world-6/ Fri, 07 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/elevated-world-6/ This post is the sixth in a series. In the first two posts, I described some of the core functions for dealing with generic data types: map, bind, and so on. In the third post, I discussed “applicative” vs “monadic” style, and how to lift values and functions to be consistent with each other. In the fourth and previous posts, I introduced traverse and sequence as a way of working with lists of elevated values, and we saw this used in a practical example: downloading some URLs. https://fsharpforfunandprofit.com/posts/elevated-world-5/ Thu, 06 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/elevated-world-5/ This post is the fifth in a series. In the first two posts, I described some of the core functions for dealing with generic data types: map, bind, and so on. In the third post, I discussed “applicative” vs “monadic” style, and how to lift values and functions to be consistent with each other. In the previous post, I introduced traverse and sequence as a way of working with lists of elevated values. https://fsharpforfunandprofit.com/posts/elevated-world-4/ Wed, 05 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/elevated-world-4/ This post is one in a series. In the first two posts, I described some of the core functions for dealing with generic data types: map, bind, and so on. In the previous post, I discussed “applicative” vs “monadic” style, and how to lift values and functions to be consistent with each other. In this post, we’ll look at a common problem: working with lists of elevated values. Series contents Here’s a list of shortcuts to the various functions mentioned in this series: https://fsharpforfunandprofit.com/posts/elevated-world-3/ Tue, 04 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/elevated-world-3/ This post is the third in a series. In the previous two posts, I described some of the core functions for dealing with generic data types: map, apply, bind, and so on. In this post, I’ll show how to use these functions in practice, and will explain the difference between the so-called “applicative” and “monadic” styles. Series contents Here’s a list of shortcuts to the various functions mentioned in this series: https://fsharpforfunandprofit.com/posts/elevated-world-2/ Mon, 03 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/elevated-world-2/ This post is the second in a series. In the previous post, I described some of the core functions for lifting a value from a normal world to an elevated world. In this post, we’ll look at “world-crossing” functions, and how they can be tamed with the bind function. Series contents Here’s a list of shortcuts to the various functions mentioned in this series: Part 1: Lifting to the elevated world The map function The return function The apply function The liftN family of functions The zip function and ZipList world Part 2: How to compose world-crossing functions The bind function List is not a monad. https://fsharpforfunandprofit.com/posts/elevated-world/ Sun, 02 Aug 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/elevated-world/ 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). This is a follow-up post to my talk on functional patterns. Yes, I know that I promised not to do this kind of thing, but for this post I thought I’d take a different approach from most people. Rather than talking about abstractions such as type classes, I thought it might be useful to focus on the core functions themselves and how they are used in practice. https://fsharpforfunandprofit.com/posts/typesafe-performance-with-compiler-directives/ Tue, 21 Jul 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/typesafe-performance-with-compiler-directives/ 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. Domain Modelling vs. Performance I am a big fan of using types for domain modelling – lots and lots and lots of types! These types act both as documentation and as a compile time constraint to ensure that only valid data is used. https://fsharpforfunandprofit.com/posts/introvert-vs-extrovert/ Sat, 18 Jul 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/introvert-vs-extrovert/ What’s the difference between an introvert and extrovert mathematician? An introvert mathematician looks at his shoes while talking to you; an extrovert mathematician looks at your shoes. For a long time, I’ve been aware of differences in how programming languages present themselves to the outside world. If programming languages had personalities, I would be tempted to call some of them “introvert”, and some of them “extrovert”. An extrovert programming language is all about the outside world, never happier than when partying with IO and external data sources. https://fsharpforfunandprofit.com/posts/fsharp-decompiled/ Wed, 15 Jul 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/fsharp-decompiled/ 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. This shows you the C# code you would have to write to get the same functionality as the F# code. Generally, the F# code is much shorter than the equivalent C# code – due to things like one-line type definitions, lack of curly braces, and so on. https://fsharpforfunandprofit.com/posts/monadster-3/ Thu, 09 Jul 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/monadster-3/ UPDATE: Slides and video from my talk on this topic Warning! This post contains gruesome topics, strained analogies, discussion of monads Welcome to the third installment in the gripping tale of Dr Frankenfunctor and the Monadster! We saw in the first installment how Dr Frankenfunctor created life out of dead body parts using “Monadster part generators” (or “M"s for short), that would, on being supplied with some vital force, return a live body part. https://fsharpforfunandprofit.com/posts/monadster-2/ Wed, 08 Jul 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/monadster-2/ UPDATE: Slides and video from my talk on this topic Warning! This post contains gruesome topics, strained analogies, discussion of monads Welcome to the gripping tale of Dr Frankenfunctor and the Monadster! We saw in the previous installment how Dr Frankenfunctor created life out of dead body parts using “Monadster part generators” (or “M"s for short), that would, on being supplied with some vital force, return a live body part. https://fsharpforfunandprofit.com/posts/monadster/ Tue, 07 Jul 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/monadster/ UPDATE: Slides and video from my talk on this topic Warning! This post contains gruesome topics, strained analogies, discussion of monads For generations, we have been captivated by the tragic story of Dr Frankenfunctor. The fascination with vital forces, the early experiments with electricity and galvanism, and finally the breakthrough culminating in the bringing to life of a collection of dead body parts – the Monadster. But then, as we all know, the creature escaped and the free Monadster rampaged through computer science conferences, bringing fear to the hearts of even the most seasoned programmers. https://fsharpforfunandprofit.com/posts/no-uml-diagrams/ Tue, 30 Jun 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/no-uml-diagrams/ In my talk on functional DDD, I often use this slide (in context): Which is of course is a misquote of this famous scene. Oops, I mean this one. Ok, I might be exaggerating a bit. Some UML diagrams are useful (I like sequence diagrams for example) and in general, I do think a good picture or diagram can be worth 1000 words. But I believe that, in many cases, using UML for class diagrams is not necessary. https://fsharpforfunandprofit.com/posts/happy-fsharp-day/ Sun, 12 Apr 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/happy-fsharp-day/ I’ve been thinking for a while that F# needs a “birthday” that we can celebrate as a community. Of course, like any long term project, there is rarely a single date that you can point to as a birthday. Even the 4th of July and the Queen’s birthday are not as straightforward as they seem. Nevertheless, it’s fun to celebrate a date, even if it’s not accurate! So what date would best symbolize the “birth” of F#? https://fsharpforfunandprofit.com/posts/enterprise-tic-tac-toe-2/ Mon, 16 Feb 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/enterprise-tic-tac-toe-2/ 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. I pick a small project and show you my thought processes as I go about designing and implementing it from beginning to end. In the previous post, I did a design for a Tic-Tac-Toe (aka Noughts and Crosses) game. https://fsharpforfunandprofit.com/posts/enterprise-tic-tac-toe/ Thu, 12 Feb 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/enterprise-tic-tac-toe/ 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. I pick a small project and show you my thought processes as I go about designing and implementing it from beginning to end. For the next project in this series of posts, I’m going to do a walkthrough of a Tic-Tac-Toe (aka Noughts and Crosses) implementation, written in a functional style. https://fsharpforfunandprofit.com/posts/is-your-language-unreasonable/ Mon, 26 Jan 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/is-your-language-unreasonable/ 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. But as functional idioms have become more mainstream, and C# has added functional capabilities such as lambdas and LINQ, it seems like C# is “catching up” with F# more and more. So, ironically, I’ve now started to hear people say things like this: “C# already has most of the features of F#, so why should I bother to switch? https://fsharpforfunandprofit.com/posts/capability-based-security-3/ Tue, 20 Jan 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/capability-based-security-3/ 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. But in most of the examples so far, we’ve been relying on self-discipline to avoid using the global capabilities, or by trying to hide the “raw” capabilities using the internal keyword. It’s a bit ugly – can we do better? In this post, we’ll show that we can by using types to emulate “access tokens”. https://fsharpforfunandprofit.com/posts/capability-based-security-2/ Mon, 19 Jan 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/capability-based-security-2/ 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. And I demonstrated this with a simple application that changed a configuration flag. In this post, we’ll look at how to constrain capabilities based on the current user’s identity and role. So let’s switch from the configuration example to a typical situation where stricter authorization is required. https://fsharpforfunandprofit.com/posts/capability-based-security/ Sun, 18 Jan 2015 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/capability-based-security/ 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. That is, how can you ensure that clients of your code can only do what you want them to do? This series will sketch out two different approaches, first using an approach called capability based security, and second using statically checked types to emulate access tokens. https://fsharpforfunandprofit.com/posts/property-based-testing-5/ Mon, 15 Dec 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/property-based-testing-5/ In the previous two posts, we looked at applying property-based testing to lists and roman numerals. Now let’s look at one more example problem, and see if we can find properties for it. This sample is based on the well-known Dollar example described in Kent Beck’s “TDD By Example” book. We’re not going to attempt to critique the design itself and make it more type-driven – others have done that. Instead, we’ll take the design as given and see what properties we can come up with. https://fsharpforfunandprofit.com/posts/property-based-testing-4/ Sun, 14 Dec 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/property-based-testing-4/ In the previous post, we tested some list functions using various properties. Let’s keep going and test some more code in the same way. For this post, our challenge will be to test roman numeral conversion logic. “Two heads are better than one” applied to two different implementations “There and back again” applied to encoding and decoding roman numerals “Solving a smaller problem” applied to decoding roman numerals “Some things never change”. https://fsharpforfunandprofit.com/posts/property-based-testing-3/ Sat, 13 Dec 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/property-based-testing-3/ In the previous post, we looked at some common patterns for finding properties. In this post, we’ll apply these approaches to see if we can come up with properties for some simple functions such as “sort a list” and “reverse a list”. As we work, we’ll always being thinking about the Enterprise Developer From Hell (see earlier post) and how the EDFH could trick our tests into passing. “Different paths, same destination” applied to sorting a list “Different paths, same destination” applied to reversing a list “There and back again” applied to reversing a list “Hard to prove, easy to verify” applied to splitting a string “Hard to prove, easy to verify” applied to sorting a list “Some things never change”. https://fsharpforfunandprofit.com/posts/property-based-testing-2/ Fri, 12 Dec 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/property-based-testing-2/ UPDATE: I did a talk on property-based testing based on these posts. Slides and video here. In the previous two posts, I described the basics of property-based testing, and showed how it can save a lot of time by generating random tests. But here’s a common problem. Everyone who sees a property-based testing tool like FsCheck or QuickCheck thinks that it is amazing… but when it comes time to start creating your own properties, the universal complaint is: “what properties should I use? https://fsharpforfunandprofit.com/posts/property-based-testing-1/ Tue, 02 Dec 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/property-based-testing-1/ UPDATE: I did a talk on property-based testing based on these posts. Slides and video here. In the previous post, I described the basics of property-based testing, and showed how it could save a lot of time by generating random tests. But how does it actually work in detail? That’s the topic of this post. Understanding FsCheck: Generators The first thing that FsCheck does is generate random inputs for you. https://fsharpforfunandprofit.com/posts/property-based-testing/ Mon, 01 Dec 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/property-based-testing/ This post is part of the F# Advent Calendar in English 2014 project. Check out all the other great posts there! And special thanks to Sergey Tihon for organizing this. UPDATE: I did a talk on property-based testing based on these posts. Slides and video here. Also, there is now a post on how to choose properties for property-based testing Let’s start with a discussion that I might have had once (topic changed to protect the guilty): https://fsharpforfunandprofit.com/posts/calculator-complete-v2/ Thu, 16 Oct 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/calculator-complete-v2/ In this series of posts, I’ve been developing a simple pocket calculator app. In the first post, we completed a first draft of the design, using type-first development. and in the second post, we created an initial implementation. In the previous post, we created the rest of the code, including the user interface, and attempted to use it. But the final result was unusable! The problem wasn’t that the code was buggy, it was that I didn’t spend enough time thinking about the requirements before I started coding! https://fsharpforfunandprofit.com/posts/calculator-complete-v1/ Wed, 15 Oct 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/calculator-complete-v1/ In this post, I’ll continue developing a simple pocket calculator app. In the first post, we completed a first draft of the design, using only types (no UML diagrams!). and in the previous post, we created an initial implementation that exercised the design and revealed a missing requirement. Now it’s time to build the remaining components and assemble them into a complete application Creating the services We have a implementation. https://fsharpforfunandprofit.com/posts/calculator-implementation/ Tue, 14 Oct 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/calculator-implementation/ 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!). Now it’s time to create a trial implementation that uses the design. Doing some real coding at this point acts as a reality check. It ensures that the domain model actually makes sense and is not too abstract. And of course, it often drives more questions about the requirements and domain model. https://fsharpforfunandprofit.com/posts/calculator-design/ Mon, 13 Oct 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/calculator-design/ One comment I hear often is a complaint about the gap between theory and practice in F# and functional programming in general. In other words, you know the theory, but how do you actually design and implement an application using FP principles? So I thought it might be useful to show you how I personally would go about designing and implementing some little applications from beginning to end. These will be sort of annotated “live coding” sessions. https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-5/ Thu, 24 Apr 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-5/ This post is the conclusion of the series on low-risk and incremental ways to use F# at work. To wrap up, we’ll look at a few more ways in which F# can help you with various development tasks around the edges, without impacting any core or mission critical code. Series contents Before moving on to the content of the post, here’s the full list of the twenty six ways: https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-4/ Wed, 23 Apr 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-4/ This post is a continuation of the previous series on low-risk and incremental ways to use F# at work. In this one, we’ll see how F# can be unexpectedly helpful when it comes to database related tasks. Series contents Before moving on to the content of the post, here’s the full list of the twenty six ways: Part 1 - Using F# to explore and develop interactively https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-3/ Tue, 22 Apr 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-3/ 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? In this one, we’ll talk about using F# for testing. Series contents Before moving on to the content of the post, here’s the full list of the twenty six ways: https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-2/ Mon, 21 Apr 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work-2/ This post is a continuation of the series on low-risk ways to use F# at work. I’ve been suggesting a number of ways you can get your hands dirty with F# in a low-risk, incremental way, without affecting any mission critical code. In this one, we’ll talk about using F# for builds and other development and devops scripts. If you’re new to F#, you might want to read the sections on getting started and working with NuGet in the previous post. https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-at-work/ Sun, 20 Apr 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/low-risk-ways-to-use-fsharp-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. Your workplace has a “C# only” policy and won’t let you use F#. If you work in a typical enterprise environment, getting a new language approved will be a long drawn out process, involving persuading your teammates, the QA guys, the ops guys, your boss, your boss’s boss, and the mysterious bloke down the hall who you’ve never talked to. https://fsharpforfunandprofit.com/posts/roslyn-vs-fsharp-compiler/ Sat, 12 Apr 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/roslyn-vs-fsharp-compiler/ 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). Immediately, I got a request to do a follow up to my previous analysis of C# and F# code “in the wild” and apply a similar analysis to Roslyn, comparing it with the (already open source) F# compiler. You might ask, is it really fair to compare such different projects? https://fsharpforfunandprofit.com/posts/roman-numeral-kata/ Sun, 12 Jan 2014 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/roman-numeral-kata/ I recently watched a video called “Roman Numerals Kata with Commentary”. In it, Corey Haines demonstrates how to implement the Arabic to Roman Numerals Kata in Ruby using a TDD approach. This video annoyed me intensely. I mean no disrespect to Corey Haines' programming skills, and many people seem to have found the video useful, but I just found it exasperating. I thought that in this post I’d try to explain why I got annoyed, and to present my alternative approach to problems like this. https://fsharpforfunandprofit.com/posts/monoids-part3/ Fri, 25 Oct 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/monoids-part3/ In the previous posts in this series, we only dealt with things that were proper monoids. But what if the thing you want to work with is not a monoid? What then? Well, in this post, I’ll give you some tips on converting almost anything into a monoid. In the process, we’ll be introduced to a number of important and common functional design idioms, such as preferring lists rather than singletons, and using the option type at every opportunity. https://fsharpforfunandprofit.com/posts/monoids-part2/ Thu, 24 Oct 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/monoids-part2/ In the previous post, we looked at the definition of a monoid. In this post, we’ll see how to implement some monoids. First, let’s revisit the definition: You start with a bunch of things, and some way of combining them two at a time. Rule 1 (Closure): The result of combining two things is always another one of the things. Rule 2 (Associativity): When combining more than two things, which pairwise combination you do first doesn’t matter. https://fsharpforfunandprofit.com/posts/monoids-without-tears/ Wed, 23 Oct 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/monoids-without-tears/ 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. There are plenty of idioms such as partial application, and error handling techniques, but no apparent patterns in the GoF sense. In this post, we’ll look at a very common “pattern” known as a monoid. Monoids are not really a design pattern; more an approach to working with many different types of values in a common way. https://fsharpforfunandprofit.com/posts/railway-oriented-programming-carbonated/ Sat, 22 Jun 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/railway-oriented-programming-carbonated/ 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. A large part of this post was directly stolen from inspired by Dave Fayram’s post on FizzBuzz, with some additional ideas from raganwald. FizzBuzz: The imperative version As a reminder, here are the requirements for the FizzBuzz problem: Write a program that prints the numbers from 1 to 100. https://fsharpforfunandprofit.com/posts/cycles-and-modularity-in-the-wild/ Tue, 28 May 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/cycles-and-modularity-in-the-wild/ (Updated 2013-06-15. See comments at the end of the post) (Updated 2014-04-12. A follow up post that applies the same analysis to Roslyn) (Updated 2015-01-23. A much clearer version of this analysis has been done by Evelina Gabasova. She knows what she is talking about, so I highly recommend you read her post first!) This is a follow up post to two earlier posts on module organization and cyclic dependencies. https://fsharpforfunandprofit.com/posts/cyclic-dependencies/ Mon, 27 May 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/cyclic-dependencies/ One of three related posts on module organization and cyclic dependencies. One of the most common complaints about F# is that it requires code to be in dependency order. That is, you cannot use forward references to code that hasn’t been seen by the compiler yet. Here’s a typical example: “The order of .fs files makes it hard to compile… My F# application is just over 50 lines of code, but it’s already more work than it’s worth to compile even the tiniest non-trivial application. https://fsharpforfunandprofit.com/posts/removing-cyclic-dependencies/ Mon, 27 May 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/removing-cyclic-dependencies/ In the previous post, we looked at the concept of dependency cycles, and why they are bad. In this post, we’ll look at some techniques for eliminating them from your code. Having to do this may seem annoying at first, but really, you’ll come to appreciate that in the long run, “it’s not a bug, it’s a feature!” Classifying some common cyclic dependencies Let’s classify the kinds of dependencies you’re likely to run into. https://fsharpforfunandprofit.com/posts/recipe-part3/ Sun, 26 May 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recipe-part3/ Before we move on to any coding in the recipe, let’s look at the overall structure of a F# project. In particular: (a) what code should be in which modules and (b) how the modules should be organized within a project. How not to do it A newcomer to F# might be tempted to organize code in classes just like in C#. One class per file, in alphabetical order. https://fsharpforfunandprofit.com/posts/why-i-wont-be-writing-a-monad-tutorial/ Tue, 14 May 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/why-i-wont-be-writing-a-monad-tutorial/ “A ‘newbie’, in Haskell, is someone who hasn’t yet implemented a compiler. They’ve only written a monad tutorial” - Pseudonymn Let’s start with a story… Alice learns to count Young Alice and her father (who happens to be a mathematician) are visiting a petting zoo… Alice: Look at those kitties. Daddy: Aren’t they cute. There are two of them. Alice: Look at those doggies. Daddy: That’s right. https://fsharpforfunandprofit.com/posts/recipe-part2/ Sat, 11 May 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recipe-part2/ UPDATE: Slides and video from a more comprehensive presentation available here (and if you understand the Either monad, read this first!). UPDATE 2: This is one of my most popular posts, and it is a useful approach to error handling, but please don’t overuse the idea! See my post on “Against Railway-Oriented Programming”. In the previous post, we saw how a use case could be broken into steps, and all the errors shunted off onto a separate error track, like this: https://fsharpforfunandprofit.com/posts/recipe-part1/ Fri, 10 May 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/recipe-part1/ “I think I understand functional programming at the micro level, and I have written toy programs, but how do I actually go about writing a complete application, with real data, real error handling, and so on?" This is a very common question, so I thought that in this series of posts I’d describe a recipe for doing exactly this, covering design, validation, error handling, persistence, dependency management, code organization, and so on. https://fsharpforfunandprofit.com/posts/ten-reasons-not-to-use-a-functional-programming-language/ Fri, 12 Apr 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/ten-reasons-not-to-use-a-functional-programming-language/ Are you fed up with all the hype about functional programming? Me too! I thought I’d rant about some reasons why sensible people like us should stay away from it. Just to be clear, when I say “statically typed functional programming language”, I mean languages that also include things such as type inference, immutability by default, and so on. In practice, this means Haskell and the ML-family (including OCaml and F#). https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part6/ Wed, 30 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part6/ We’re coming into the home stretch now. There are only a few more builder methods that need to be covered, and then you will be ready to tackle anything! These methods are: While for repetition. TryWith and TryFinally for handling exceptions. Use for managing disposables Remember, as always, that not all methods need to be implemented. If While is not relevant to you, don’t bother with it. One important note before we get started: all the methods discussed here rely on delays being used. https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part5/ Tue, 29 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part5/ In a previous post, we saw how to avoid unnecessary evaluation of expressions in a workflow until needed. But that approach was designed for expressions inside a workflow. What happens if we want to delay the whole workflow itself until needed. Note that the “builder” in the context of a computation expression is not the same as the OO “builder pattern” for constructing and validating objects. There is a post on the “builder pattern” here. https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part4/ Mon, 28 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part4/ In this post, we’ll take a detour and look at some tricks you can do with methods in a computation expression builder. Ultimately, this detour will lead to a dead end, but I hope the journey might provide some more insight into good practices for designing your own computation expressions. Note that the “builder” in the context of a computation expression is not the same as the OO “builder pattern” for constructing and validating objects. https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part3/ Sun, 27 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part3/ In the last few posts we have covered all the basic methods (Bind, Return, Zero, and Combine) needed to create your own computation expression builder. In this post, we’ll look at some of the extra features needed to make the workflow more efficient, by controlling when expressions get evaluated. Note that the “builder” in the context of a computation expression is not the same as the OO “builder pattern” for constructing and validating objects. https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part2/ Sat, 26 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part2/ In this post we’re going to look at returning multiple values from a computation expression using the Combine method. Note that the “builder” in the context of a computation expression is not the same as the OO “builder pattern” for constructing and validating objects. There is a post on the “builder pattern” here. The story so far… So far, our expression builder class looks like this: https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part1/ Fri, 25 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-builder-part1/ Having covered bind and continuations, and the use of wrapper types, we’re finally ready to take on the full set of methods associated with “builder” classes. Note that the “builder” in the context of a computation expression is not the same as the OO “builder pattern” for constructing and validating objects. There is a post on the “builder pattern” here. If you look at the MSDN documentation, you’ll see not just Bind and Return, but also other strangely named methods like Delay and Zero. https://fsharpforfunandprofit.com/posts/computation-expressions-wrapper-types-part2/ Thu, 24 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-wrapper-types-part2/ In the previous post, we looked at the concept of “wrapper types” and their relation to computation expressions. In this post, we’ll investigate what types are suitable for being wrapper types. What kinds of types can be wrapper types? If every computation expression must have an associated wrapper type, then what kinds of type can be used as wrapper types? Are there any special constraints or limitations that apply? https://fsharpforfunandprofit.com/posts/computation-expressions-wrapper-types/ Wed, 23 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-wrapper-types/ In the previous post, we were introduced to the “maybe” workflow, which allowed us to hide the messiness of chaining together option types. A typical use of the “maybe” workflow looked something like this: let result = maybe { let! anInt = expression of Option<int> let! anInt2 = expression of Option<int> return anInt + anInt2 } As we saw before, there is some apparently strange behavior going on here: In the let! https://fsharpforfunandprofit.com/posts/computation-expressions-bind/ Tue, 22 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-bind/ In the last post we talked about how we can think of let as a nice syntax for doing continuations behind scenes. And we introduced a pipeInto function that allowed us to add hooks into the continuation pipeline. Now we are ready to look at our first builder method, Bind, which formalizes this approach and is the core of any computation expression. Note that the “builder” in the context of a computation expression is not the same as the OO “builder pattern” for constructing and validating objects. https://fsharpforfunandprofit.com/posts/computation-expressions-continuations/ Mon, 21 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-continuations/ In the previous post we saw how some complex code could be condensed using computation expressions. Here’s the code before using a computation expression: let log p = printfn "expression is %A" p let loggedWorkflow = let x = 42 log x let y = 43 log y let z = x + y log z //return z And here’s the same code after using a computation expression: let loggedWorkflow = logger { let! https://fsharpforfunandprofit.com/posts/computation-expressions-intro/ Sun, 20 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/computation-expressions-intro/ By popular request, it is time to talk about the mysteries of computation expressions, what they are, and how they can be useful in practice (and I will try to avoid using the forbidden m-word). In this series, you’ll learn what computation expressions are, how to make your own, and some common patterns involving them. In the process, we’ll also look at continuations, the bind function, wrapper types, and more. https://fsharpforfunandprofit.com/posts/designing-with-types-conclusion/ Sat, 19 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-conclusion/ In this series, we’ve looked at some of the ways we can use types as part of the design process, including: Breaking large structures down into small “atomic” components. Using single case unions to add semantic meaning and validation to key domain types such EmailAddress and ZipCode. Ensuring that the type system can only represent valid data (“making illegal states unrepresentable”). Using types as an analysis tool to uncover hidden requirements Replacing flags and enums with simple state machines Replacing primitive strings with types that guarantee various constraints For this final post, let’s see them all applied together. https://fsharpforfunandprofit.com/posts/designing-with-types-non-strings/ Fri, 18 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-non-strings/ In this series we’ve seen a lot of uses of single case discriminated unions to wrap strings. There is no reason why you cannot use this technique with other primitive types, such as numbers and dates. Let’s look a few examples. Single case unions In many cases, we want to avoid accidentally mixing up different kinds of integers. Two domain objects may have the same representation (using integers) but they should never be confused. https://fsharpforfunandprofit.com/posts/designing-with-types-more-semantic-types/ Thu, 17 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-more-semantic-types/ In a previous post, I talked about avoiding using plain primitive strings for email addresses, zip codes, states, etc. By wrapping them in a single case union, we could (a) force the types to be distinct and (b) add validation rules. In this post, we’ll look at whether we can extend that concept to an even more fine grained level. When is a string not a string? Let’s look a simple PersonalName type. https://fsharpforfunandprofit.com/posts/designing-with-types-representing-states/ Wed, 16 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-representing-states/ In this post we will look at making implicit states explicit by using state machines, and then modelling these state machines with union types. Background In an earlier post in this series, we looked at single case unions as a wrapper for types such as email addresses. module EmailAddress = type T = EmailAddress of string let create (s:string) = if System.Text.RegularExpressions.Regex.IsMatch(s,@"^\S+@\S+\.\S+$") then Some (EmailAddress s) else None This code assumes that either an address is valid or it is not. https://fsharpforfunandprofit.com/posts/designing-with-types-discovering-the-domain/ Tue, 15 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-discovering-the-domain/ In the last post, we looked at how we could represent a business rule using types. The rule was: “A contact must have an email or a postal address”. And the type we designed was: type ContactInfo = | EmailOnly of EmailContactInfo | PostOnly of PostalContactInfo | EmailAndPost of EmailContactInfo * PostalContactInfo Now let’s say that the business decides that phone numbers need to be supported as well. The new business rule is: “A contact must have at least one of the following: an email, a postal address, a home phone, or a work phone”. https://fsharpforfunandprofit.com/posts/designing-with-types-making-illegal-states-unrepresentable/ Mon, 14 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-making-illegal-states-unrepresentable/ In this post, we look at a key benefit of F#, which using the type system to “make illegal states unrepresentable” (a phrase borrowed from Yaron Minsky). Let’s look at our Contact type. Thanks to the previous refactoring, it is quite simple: type Contact = { Name: Name; EmailContactInfo: EmailContactInfo; PostalContactInfo: PostalContactInfo; } Now let’s say that we have the following simple business rule: “A contact must have an email or a postal address”. https://fsharpforfunandprofit.com/posts/designing-with-types-single-case-dus/ Sun, 13 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-single-case-dus/ At the end of the previous post, we had values for email addresses, zip codes, etc., defined like this: EmailAddress: string; State: string; Zip: string; These are all defined as simple strings. But really, are they just strings? Is an email address interchangeable with a zip code or a state abbreviation? In a domain driven design, they are indeed distinct things, not just strings. So we would ideally like to have lots of separate types for them so that they cannot accidentally be mixed up. https://fsharpforfunandprofit.com/posts/designing-with-types-intro/ Sat, 12 Jan 2013 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-with-types-intro/ In this series, we’ll look at some of the ways we can use types as part of the design process. In particular, the thoughtful use of types can make a design more transparent and improve correctness at the same time. This series will be focused on the “micro level” of design. That is, working at the lowest level of individual types and functions. Higher level design approaches, and the associated decisions about using functional or object-oriented style, will be discussed in another series. https://fsharpforfunandprofit.com/posts/porting-to-csharp-getting-started/ Thu, 02 Aug 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/porting-to-csharp-getting-started/ Before we get started on the detailed examples, we’ll go back to basics and do some simple porting of trivial examples. In this post and the next, we’ll look at the nearest F# equivalents to common C# statements and keywords, to guide you when doing direct ports. Basic syntax conversion guidelines Before starting a port, you need to understand how F# syntax is different from C# syntax. https://fsharpforfunandprofit.com/posts/porting-to-csharp-intro/ Wed, 01 Aug 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/porting-to-csharp-intro/ NOTE: Before reading this series, I suggest that you read the following series as a prerequisite: “thinking functionally”, “expressions and syntax”, and “understanding F# types”. For many developers, the next step after learning a new language might be to port some existing code over to it, so that they can get a good feel for the differences between the two languages. As we pointed out earlier, functional languages are very different from imperative languages, and so trying to do a direct port of imperative code to a functional language is often not possible, and even if a crude port is done successfully, the ported code will probably not be using the functional model to its best advantage. https://fsharpforfunandprofit.com/posts/object-expressions/ Tue, 17 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/object-expressions/ So as we saw in the previous post, implementing interfaces in F# is a bit more awkward than in C#. But F# has a trick up its sleeve, called “object expressions”. With object expressions, you can implement an interface on-the-fly, without having to create a class. Implementing interfaces with object expressions Object expressions are most commonly used to implement interfaces. To do this, you use the syntax new MyInterface with . https://fsharpforfunandprofit.com/posts/interfaces/ Mon, 16 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/interfaces/ Interfaces are available and fully supported in F#, but there are number of important ways in which their usage differs from what you might be used to in C#. Defining interfaces Defining an interface is similar to defining an abstract class. So similar, in fact, that you might easily get them confused. Here’s an interface definition: type MyInterface = // abstract method abstract member Add: int -> int -> int // abstract immutable property abstract member Pi : float // abstract read/write property abstract member Area : float with get,set And here’s the definition for the equivalent abstract base class: https://fsharpforfunandprofit.com/posts/inheritance/ Sun, 15 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/inheritance/ This is a follow-on from the previous post on classes. This post will focus on inheritance in F#, and how to define and use abstract classes and interfaces. Inheritance To declare that a class inherits from another class, use the syntax: type DerivedClass(param1, param2) = inherit BaseClass(param1) The inherit keyword signals that DerivedClass inherits from BaseClass. In addition, some BaseClass constructor must be called at the same time. https://fsharpforfunandprofit.com/posts/classes/ Sat, 14 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/classes/ This post and the next will cover the basics of creating and using classes and methods in F#. Defining a class Just like all other data types in F#, class definitions start with the type keyword. The thing that distinguishes them from other types is that classes always have some parameters passed in when they are created – the constructor – and so there are always parentheses after the class name. https://fsharpforfunandprofit.com/posts/object-oriented-intro/ Fri, 13 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/object-oriented-intro/ In this series, we’ll look at how F# supports object-oriented classes and methods. Should you use object-oriented features at all? As has been stressed many times before, F# is fundamentally a functional language at heart, yet the OO features have been nicely integrated and do not have a “tacked-on” feeling. As a result, it is quite viable to use F# just as an OO language, as an alternative to C#, say. https://fsharpforfunandprofit.com/posts/printf/ Thu, 12 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/printf/ In this post, we’ll take a small detour and look at how to create formatted text. The printing and formatting functions are technically library functions, but in practice they as used as if they were part of the core language. F# supports two distinct styles of formatting text: The standard .NET technique of “composite formatting” as seen in String.Format, Console.WriteLine and other places. The C-style technique of using printf and the associated family of functions such as printfn, sprintf and so on. https://fsharpforfunandprofit.com/posts/cli-types/ Tue, 10 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/cli-types/ In this post we’ll take a quick look at how F# handles the standard types that are built into .NET. Literals F# uses the same syntax for literals that C# does, with a few exceptions. I’ll divide the built-in types into the following groups: miscellaneous types (bool, char, etc. ) string types integer types (int, uint and byte, etc) float types (float, decimal, etc) pointer types (IntPtr, etc) The following tables list the primitive types, with their F# keywords, their suffixes if any, an example, and the corresponding . https://fsharpforfunandprofit.com/posts/units-of-measure/ Tue, 10 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/units-of-measure/ As we mentioned earlier in the “why use F#?” series, F# has a very cool feature which allows you to add extra unit-of-measure information to as metadata to numeric types. The F# compiler will then make sure that only numerics with the same unit-of-measure can be combined. This can be very useful to stop accidental mismatches and to make your code safer. Defining units of measure A unit of measure definition consists of the attribute [<Measure>], followed by the type keyword and then a name. https://fsharpforfunandprofit.com/posts/enum-types/ Mon, 09 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/enum-types/ The enum type in F# is the same as the enum type in C#. Its definition is superficially just like that of a union type, but there are many non-obvious differences to be aware of. Defining enums To define an enum you use exactly the same syntax as a union type with empty cases, except that you must specify a constant value for each case, and the constants must all be of the same type. https://fsharpforfunandprofit.com/posts/type-inference/ Mon, 09 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/type-inference/ Before we finish with types, let’s revisit type inference: the magic that allows the F# compiler to deduce what types are used and where. We have seen this happen through all the examples so far, but how does it work and what can you do if it goes wrong? How does type inference work? It does seem to be magic, but the rules are mostly straightforward. The fundamental logic is based on an algorithm often called “Hindley-Milner” or “HM” (more accurately it should be called “Damas-Milner’s Algorithm W”). https://fsharpforfunandprofit.com/posts/stack-based-calculator/ Sat, 07 Jul 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/stack-based-calculator/ In this post, we’ll implement a simple stack based calculator (also known as “reverse Polish” style). The implementation is almost entirely done with functions, with only one special type and no pattern matching at all, so it is a great testing ground for the concepts introduced in this series. If you are not familiar with a stack based calculator, it works as follows: numbers are pushed on a stack, and operations such as addition and multiplication pop numbers off the stack and push the result back on. https://fsharpforfunandprofit.com/posts/roman-numerals/ Sat, 30 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/roman-numerals/ Last time we looked at parsing a command line. This time we’ll look at another pattern matching example, this time using Roman numerals. As before, we will try to have a “pure” internal model with separate stages to convert the input to the internal model, and then another separate stage to convert from the internal model to the output. Requirements Let’s start with the requirements: 1) Accept a string of letters like "MMMXCLXXIV" as a string and convert it to an integer. https://fsharpforfunandprofit.com/posts/pattern-matching-command-line/ Fri, 29 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/pattern-matching-command-line/ Now that we’ve seen how the match expression works, let’s look at some examples in practice. But first, a word about the design approach. Application design in F# We’ve seen that a generic function takes input and emits output. But in a sense, that approach applies at any level of functional code, even at the top level. In fact, we can say that a functional application takes input, transforms it, and emits output: https://fsharpforfunandprofit.com/posts/match-expression/ Thu, 28 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/match-expression/ Pattern matching is ubiquitous in F#. It is used for binding values to expressions with let, and in function parameters, and for branching using the match..with syntax. We have briefly covered binding values to expressions in a post in the “why use F#?” series, and it will be covered many times as we investigate types. So in this post, we’ll cover the match..with syntax and its use for control flow. https://fsharpforfunandprofit.com/posts/the-option-type/ Thu, 07 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/the-option-type/ Now let’s look at a particular union type, the Option type. It is so common and so useful that it is actually built into the language. You have already seen the option type discussed in passing, but let’s go back to basics and understand how it fits into the type system. A very common situation is when you want to represent missing or invalid values. Using a diagram, the domain would look like this: https://fsharpforfunandprofit.com/posts/discriminated-unions/ Wed, 06 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/discriminated-unions/ Tuples and records are examples of creating new types by “multiplying” existing types together. At the beginning of the series, I mentioned that the other way of creating new types was by “summing” existing types. What does this mean? Well, let’s say that we want to define a function that works with integers OR booleans, maybe to convert them into strings. But we want to be strict and not accept any other type (such as floats or strings). https://fsharpforfunandprofit.com/posts/records/ Tue, 05 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/records/ As we noted in the previous post, plain tuples are useful in many cases. But they have some disadvantages too. Because all tuple types are pre-defined, you can’t distinguish between a pair of floats used for geographic coordinates say, vs. a similar tuple used for complex numbers. And when tuples have more than a few elements, it is easy to get confused about which element is in which place. In these situations, what you would like to do is label each slot in the tuple, which will both document what each element is for and force a distinction between tuples made from the same types. https://fsharpforfunandprofit.com/posts/tuples/ Mon, 04 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/tuples/ We’re ready for our first extended type – the tuple. Let’s start by stepping back again and looking at a type such as “int”. As we hinted at before, rather than thinking of “int” as a abstract thing, you can think of it as concrete collection of all its possible values, namely the set {…,-3, -2, -1, 0, 2, 3, …}. So next, imagine two copies of this “int” collection. We can “multiply” them together by taking the Cartesian product of them; that is, making a new list of objects by picking every possible combination of the two “int” lists, as shown below: https://fsharpforfunandprofit.com/posts/type-abbreviations/ Sun, 03 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/type-abbreviations/ Let’s start with the simplest type definition, a type abbreviation or alias. It has the form: type [typename] = [existingType] where “existing type” can be any type: one of the basic types we have already seen, or one of the extended types we will be seeing soon. Some examples: type RealNumber = float type ComplexNumber = float * float type ProductCode = string type CustomerId = int type AdditionFunction = int->int->int type ComplexAdditionFunction = ComplexNumber-> ComplexNumber -> ComplexNumber And so on – pretty straightforward. https://fsharpforfunandprofit.com/posts/overview-of-types-in-fsharp/ Sat, 02 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/overview-of-types-in-fsharp/ Before we dive into all the specific types, let’s look at the big picture. What are types for? If you are coming from an object-oriented design background, one of the paradigm shifts involved in “thinking functionally” is to change how you think about types. A well designed object-oriented program will have a strong focus on behavior rather than data, so it will use a lot of polymorphism, either using “duck-typing” or explicit interfaces, and will try to avoid having explicit knowledge of the actual concrete classes being passed around. https://fsharpforfunandprofit.com/posts/types-intro/ Fri, 01 Jun 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/types-intro/ NOTE: Before reading this series, I suggest that you read the “thinking functionally” and “expressions and syntax” series as a prerequisite. F# is not just about functions; the powerful type system is another key ingredient. And just as with functions, understanding the type system is critical to being fluent and comfortable in the language. Now, so far we have seen some basic types that can be used as input and output to functions: https://fsharpforfunandprofit.com/posts/exceptions/ Mon, 21 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/exceptions/ Just like other .NET languages, F# supports throwing and catching exceptions. As with the control flow expressions, the syntax will feel familiar, but again there are a few catches that you should know about. Defining your own exceptions When raising/throwing exceptions, you can use the standard system ones such as InvalidOperationException, or you can define your own exception types using the simple syntax shown below, where the “content” of the exception is any F# type: https://fsharpforfunandprofit.com/posts/control-flow-expressions/ Sun, 20 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/control-flow-expressions/ In this post, we’ll look at the control flow expressions, namely: if-then-else for x in collection (which is the same as foreach in C#) for x = start to end while-do These control flow expressions are no doubt very familiar to you. But they are very “imperative” rather than functional. So I would strongly recommend that you do not use them if at all possible, especially when you are learning to think functionally. https://fsharpforfunandprofit.com/posts/naming-conventions/ Sat, 19 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/naming-conventions/ If you are coming to F# from an imperative language such as C#, then you might find a lot of the names shorter and more cryptic than you are used to. In C# and Java, the best practice is to have long descriptive identifiers. In functional languages, the function names themselves can be descriptive, but the local identifiers inside a function tend to be quite short, and piping and composition is used a lot to get everything on a minimal number of lines. https://fsharpforfunandprofit.com/posts/fsharp-syntax/ Fri, 18 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/fsharp-syntax/ The syntax for F# is mostly straightforward. But there are a few rules that you should understand if you want to avoid common indentation errors. If you are familiar with a language like Python that also is whitespace sensitive, be aware that that the rules for indentation in F# are subtly different. Indentation and the “offside” rule In soccer, the offside rule says that in some situations, a player cannot be “ahead” of the ball when they should be behind or level with it. https://fsharpforfunandprofit.com/posts/let-use-do/ Thu, 17 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/let-use-do/ As we’ve have already seen, there are no “variables” in F#. Instead there are values. And we have also seen that keywords such as let, use, and do act as bindings – associating an identifier with a value or function expression. In this post we’ll look at these bindings in more detail. “let” bindings The let binding is straightforward, it has the general form: let aName = someExpression But there are two uses of let that are subtly different. https://fsharpforfunandprofit.com/posts/understanding-fsharp-expressions/ Thu, 17 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/understanding-fsharp-expressions/ In this post we’ll look at the different kinds of expressions that are available in F# and some general tips for using them. Is everything really an expression? You might be wondering how “everything is an expression” actually works in practice. Let’s start with some basic expression examples that should be familiar: 1 // literal [1;2;3] // list expression -2 // prefix operator 2 + 2 // infix operator "string". https://fsharpforfunandprofit.com/posts/expressions-vs-statements/ Wed, 16 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/expressions-vs-statements/ In programming language terminology, an “expression” is a combination of values and functions that are combined and interpreted by the compiler to create a new value, as opposed to a “statement” which is just a standalone unit of execution and doesn’t return anything. One way to think of this is that the purpose of an expression is to create a value (with some possible side-effects), while the sole purpose of a statement is to have side-effects. https://fsharpforfunandprofit.com/posts/expressions-intro/ Tue, 15 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/expressions-intro/ NOTE: Before reading this series, I suggest that you read the “thinking functionally” series as a prerequisite. In this series we’ll look at how functions and values are combined into expressions, and the different kinds of expressions that are available in F#. We’ll also look at some other basic topics, such as let bindings, F# syntax, pattern matching, and outputting text with printf. This series is not meant to be exhaustive or definitive. https://fsharpforfunandprofit.com/posts/type-extensions/ Fri, 11 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/type-extensions/ Although we have focused on the pure functional style so far, sometimes it is convenient to switch to an object oriented style. And one of the key features of the OO style is the ability to attach functions to a class and “dot into” the class to get the desired behavior. In F#, this is done using a feature called “type extensions”. And any F# type, not just classes, can have functions attached to them. https://fsharpforfunandprofit.com/posts/organizing-functions/ Thu, 10 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/organizing-functions/ Now that you know how to define functions, how can you organize them? In F#, there are three options: functions can be nested inside other functions. at an application level, the top level functions are grouped into “modules”. alternatively, you can also use the object-oriented approach and attach functions to types as methods. We’ll look at the first two options in this post, and the third in the next post. https://fsharpforfunandprofit.com/posts/function-signatures/ Wed, 09 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/function-signatures/ It may not be obvious, but F# actually has two syntaxes - one for normal (value) expressions, and one for type definitions. For example: [1;2;3] // a normal expression int list // a type expression Some 1 // a normal expression int option // a type expression (1,"a") // a normal expression int * string // a type expression Type expressions have a special syntax that is different from the syntax used in normal expressions. https://fsharpforfunandprofit.com/posts/defining-functions/ Tue, 08 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/defining-functions/ We have seen how to create typical functions using the “let” syntax, below: let add x y = x + y In this section, we’ll look at some other ways of creating functions, and tips for defining functions. Anonymous functions (a.k.a. lambdas) If you are familiar with lambdas in other languages, this will not be new to you. An anonymous function (or “lambda expression”) is defined using the form: https://fsharpforfunandprofit.com/posts/function-composition/ Mon, 07 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/function-composition/ Function associativity If we have a chain of functions in a row, how are they combined? For example, what does this mean? let F x y z = x y z Does it mean apply the function y to the argument z, and then take the result and use it as an argument for x? In which case it is the same as: let F x y z = x (y z) Or does it mean apply the function x to the argument y, and then take the resulting function and evaluate it with the argument z? https://fsharpforfunandprofit.com/posts/partial-application/ Sun, 06 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/partial-application/ In the previous post on currying, we looked at breaking multiple parameter functions into smaller one parameter functions. It is the mathematically correct way of doing it, but that is not the only reason it is done – it also leads to a very powerful technique called partial function application. This is a very widely used style in functional programming, and it is important to understand it. The idea of partial application is that if you fix the first N parameters of the function, you get a function of the remaining parameters. https://fsharpforfunandprofit.com/posts/currying/ Sat, 05 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/currying/ After that little digression on basic types, we can turn back to functions again, and in particular the puzzle we mentioned earlier: if a mathematical function can only have one parameter, then how is it possible that an F# function can have more than one? The answer is quite simple: a function with multiple parameters is rewritten as a series of new functions, each with only one parameter. And this is done automatically by the compiler for you. https://fsharpforfunandprofit.com/posts/how-types-work-with-functions/ Fri, 04 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/how-types-work-with-functions/ Now that we have some understanding of functions, we’ll look at how types work with functions, both as domains and ranges. This is just an overview; the series “understanding F# types” will cover types in detail. First, we need to understand the type notation a bit more. We’ve seen that the arrow notation “->” is used to show the domain and range. So that a function signature always looks like: https://fsharpforfunandprofit.com/posts/function-values-and-simple-values/ Thu, 03 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/function-values-and-simple-values/ Let’s look at the simple function again let add1 x = x + 1 What does the “x” mean here? It means: Accept some value from the input domain. Use the name “x” to represent that value so that we can refer to it later. This process of using a name to represent a value is called “binding”. The name “x” is “bound” to the input value. So if we evaluate the function with the input 5 say, what is happening is that everywhere we see “x” in the original definition, we replace it with “5”, sort of like search and replace in a word processor. https://fsharpforfunandprofit.com/posts/mathematical-functions/ Wed, 02 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/mathematical-functions/ The impetus behind functional programming comes from mathematics. Mathematical functions have a number of very nice features that functional languages try to emulate in the real world. So first, let’s start with a mathematical function that adds 1 to a number. Add1(x) = x+1 What does this really mean? Well it seems pretty straightforward. It means that there is an operation that starts with a number, and adds one to it. https://fsharpforfunandprofit.com/posts/thinking-functionally-intro/ Tue, 01 May 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/thinking-functionally-intro/ Now that you have seen some of the power of F# in the “why use F#" series, we’re going to step back and look at the fundamentals of functional programming – what does it really mean to “program functionally”, and how this approach is different from object oriented or imperative programming. Changing the way you think It is important to understand that functional programming is not just a stylistic difference; it is a completely different way of thinking about programming, in the way that truly object-oriented programming (in Smalltalk say) is also a different way of thinking from a traditional imperative language such as C. https://fsharpforfunandprofit.com/posts/why-use-fsharp-conclusion/ Mon, 30 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/why-use-fsharp-conclusion/ This completes the tour of F# features. I hope that the examples have given you some appreciation of the power of F# and functional programming. If you have any comments on the series as a whole, please leave them at the bottom of this page. In later series I hope to go deeper into data structures, pattern matching, list processing, asynchronous and parallel programming, and much more. But before those, I recommend you read the “thinking functionally” series, which will help you understand functional programming at a deeper level. https://fsharpforfunandprofit.com/posts/completeness-anything-csharp-can-do/ Sun, 29 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/completeness-anything-csharp-can-do/ As should be apparent, you should generally try to prefer functional-style code over object-oriented code in F#, but in some situations, you may need all the features of a fully fledged OO language – classes, inheritance, virtual methods, etc. So just to conclude this section, here is a whirlwind tour of the F# versions of these features. Some of these will be dealt with in much more depth in a later series on . https://fsharpforfunandprofit.com/posts/completeness-seamless-dotnet-interop/ Sat, 28 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/completeness-seamless-dotnet-interop/ We have already seen many examples of F#’s use with the .NET libraries, such as using System.Net.WebRequest and System.Text.RegularExpressions. And the integration was indeed seamless. For more complex requirements, F# natively supports .NET classes, interfaces, and structures, so the interop is still very straightforward. For example, you can write an ISomething interface in C# and have the implementation be done in F#. But not only can F# call into existing . https://fsharpforfunandprofit.com/posts/completeness-intro/ Fri, 27 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/completeness-intro/ In this final set of posts, we will look at some other aspects of F# under the theme of “completeness”. Programming languages coming from the academic world tend to focus on elegance and purity over real-world usefulness, while more mainstream business languages such as C# and Java are valued precisely because they are pragmatic; they can work in a wide array of situations and have extensive tools and libraries to meet almost every need. https://fsharpforfunandprofit.com/posts/concurrency-reactive/ Thu, 26 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/concurrency-reactive/ Events are everywhere. Almost every program has to handle events, whether it be button clicks in the user interface, listening to sockets in a server, or even a system shutdown notification. And events are the basis of one of the most common OO design patterns: the “Observer” pattern. But as we know, event handling, like concurrency in general, can be tricky to implement. Simple event logic is straightforward, but what about logic like “do something if two events happen in a row but do something different if only one event happens” or “do something if two events happen at roughly the same time”. https://fsharpforfunandprofit.com/posts/concurrency-actor-model/ Wed, 25 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/concurrency-actor-model/ In this post, we’ll look at the message-based (or actor-based) approach to concurrency. In this approach, when one task wants to communicate with another, it sends it a message, rather than contacting it directly. The messages are put on a queue, and the receiving task (known as an “actor” or “agent”) pulls the messages off the queue one at a time to process them. This message-based approach has been applied to many situations, from low-level network sockets (built on TCP/IP) to enterprise wide application integration systems (for example RabbitMQ or IBM WebSphere MQ). https://fsharpforfunandprofit.com/posts/concurrency-async-and-parallel/ Tue, 24 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/concurrency-async-and-parallel/ In this post we’ll have a look at a few ways to write asynchronous code in F#, and a very brief example of parallelism as well. Traditional asynchronous programming As noted in the previous post, F# can directly use all the usual .NET suspects, such as Thread AutoResetEvent, BackgroundWorker and IAsyncResult. Let’s see a simple example where we wait for a timer event to go off: https://fsharpforfunandprofit.com/posts/concurrency-intro/ Mon, 23 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/concurrency-intro/ We hear a lot about concurrency nowadays, how important it is, and how it is “the next major revolution in how we write software”. So what do we actually mean by “concurrency” and how can F# help? The simplest definition of concurrency is just “several things happening at once, and maybe interacting with each other”. It seems a trivial definition, but the key point is that most computer programs (and languages) are designed to work serially, on one thing at a time, and are not well-equipped to handle concurrency. https://fsharpforfunandprofit.com/posts/designing-for-correctness/ Sun, 22 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/designing-for-correctness/ In this post, we’ll see how you can design for correctness (or at least, for the requirements as you currently understand them), by which I mean that a client of a well designed model will not be able to put the system into an illegal state – a state that doesn’t meet the requirements. You literally cannot create incorrect code because the compiler will not let you. For this to work, we do have to spend some time up front thinking about design and making an effort to encode the requirements into the types that you use. https://fsharpforfunandprofit.com/posts/correctness-type-checking/ Sat, 21 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/correctness-type-checking/ You are familiar with static type checking through languages such as C# and Java. In these languages, the type checking is straightforward but rather crude, and can be seen as an annoyance compared with the freedom of dynamic languages such as Python and Ruby. But in F# the type system is your friend, not your enemy. You can use static type checking almost as an instant unit test – making sure that your code is correct at compile time. https://fsharpforfunandprofit.com/posts/correctness-exhaustive-pattern-matching/ Fri, 20 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/correctness-exhaustive-pattern-matching/ We briefly noted earlier that when pattern matching there is a requirement to match all possible cases. This turns out be a very powerful technique to ensure correctness. Let’s compare some C# to F# again. Here’s some C# code that uses a switch statement to handle different types of state. enum State { New, Draft, Published, Inactive, Discontinued } void HandleState(State state) { switch (state) { case State.Inactive: ... case State. https://fsharpforfunandprofit.com/posts/correctness-immutability/ Thu, 19 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/correctness-immutability/ To see why immutability is important, let’s start with a small example. Here’s some simple C# code that processes a list of numbers. public List<int> MakeList() { return new List<int> {1,2,3,4,5,6,7,8,9,10}; } public List<int> OddNumbers(List<int> list) { // some code } public List<int> EvenNumbers(List<int> list) { // some code } Now let me test it: public void Test() { var odds = OddNumbers(MakeList()); var evens = EvenNumbers(MakeList()); // assert odds = 1,3,5,7,9 -- OK! https://fsharpforfunandprofit.com/posts/correctness-intro/ Wed, 18 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/correctness-intro/ As a programmer, you are constantly judging the code that you and others write. In an ideal world, you should be able to look at a piece of code and easily understand exactly what it does; and of course, being concise, clear and readable is a major factor in this. But more importantly, you have to be able to convince yourself that the code does what it is supposed to do. https://fsharpforfunandprofit.com/posts/convenience-active-patterns/ Tue, 17 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/convenience-active-patterns/ F# has a special type of pattern matching called “active patterns” where the pattern can be parsed or detected dynamically. As with normal patterns, the matching and output are combined into a single step from the caller’s point of view. Here is an example of using active patterns to parse a string into an int or bool. // create an active pattern let (|Int|_|) str = match System.Int32.TryParse(str:string) with | (true,int) -> Some(int) | _ -> None // create an active pattern let (|Bool|_|) str = match System. https://fsharpforfunandprofit.com/posts/convenience-partial-application/ Mon, 16 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/convenience-partial-application/ A particularly convenient feature of F# is that complicated functions with many parameters can have some of the parameters fixed or “baked in” and yet leave other parameters open. In this post, we’ll take a quick look at how this might be used in practice. Let’s start with a very simple example of how this works. We’ll start with a trivial function: // define a adding function let add x y = x + y // normal use let z = add 1 2 But we can do something strange as well – we can call the function with only one parameter! https://fsharpforfunandprofit.com/posts/convenience-functions-as-interfaces/ Sun, 15 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/convenience-functions-as-interfaces/ An important aspect of functional programming is that, in a sense, all functions are “interfaces”, meaning that many of the roles that interfaces play in object-oriented design are implicit in the way that functions work. In fact, one of the critical design maxims, “program to an interface, not an implementation”, is something you get for free in F#. To see how this works, let’s compare the same design pattern in C# and F#. https://fsharpforfunandprofit.com/posts/convenience-types/ Sat, 14 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/convenience-types/ One nice thing about F# is that most types immediately have some useful “out-of-the-box” behavior such as immutability and built-in equality, functionality that often has to be explicitly coded for in C#. By “most” F# types, I mean the core “structural” types such as tuples, records, unions, options, lists, etc. Classes and some other types have been added to help with .NET integration, but lose some of the power of the structural types. https://fsharpforfunandprofit.com/posts/convenience-intro/ Fri, 13 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/convenience-intro/ In the next set of posts, we will explore a few more features of F# that I have grouped under the theme of “convenience”. These features do not necessarily result in more concise code, but they do remove much of the drudgery and boilerplate code that would be needed in C#. Useful “out-of-the-box” behavior for types. Most types that you create will immediately have some useful behavior, such as immutability and built-in equality – functionality that has to be explicitly coded for in C#. https://fsharpforfunandprofit.com/posts/conciseness-pattern-matching/ Thu, 12 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/conciseness-pattern-matching/ So far we have seen the pattern matching logic in the match..with expression, where it seems to be just a switch/case statement. But in fact pattern matching is much more general – it can compare expressions in a number of ways, matching on values, conditions, and types, and then assign or extract values, all at the same time. Pattern matching will be discussed in depth in later posts, but to start with, here is a little taster of one way that it aids conciseness. https://fsharpforfunandprofit.com/posts/conciseness-functions-as-building-blocks/ Wed, 11 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/conciseness-functions-as-building-blocks/ A well-known principle of good design is to create a set of basic operations and then combine these building blocks in various ways to build up more complex behaviors. In object-oriented languages, this goal gives rise to a number of implementation approaches such as “fluent interfaces”, “strategy pattern”, “decorator pattern”, and so on. In F#, they are all done the same way, via function composition. Let’s start with a simple example using integers. https://fsharpforfunandprofit.com/posts/conciseness-extracting-boilerplate/ Tue, 10 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/conciseness-extracting-boilerplate/ In the very first example in this series, we saw a simple function that calculated the sum of squares, implemented in both F# and C#. Now let’s say we want some new functions which are similar, such as: Calculating the product of all the numbers up to N Counting the sum of odd numbers up to N The alternating sum of the numbers up to N Obviously, all these requirements are similar, but how would you extract any common functionality? https://fsharpforfunandprofit.com/posts/conciseness-type-definitions/ Mon, 09 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/conciseness-type-definitions/ In C#, there is a disincentive for creating new types – the lack of type inference means you need to explicitly specify types in most places, resulting in brittleness and more visual clutter. As a result, there is always a temptation to create monolithic classes rather than modularizing them. In F# there is no penalty for making new types, so it is quite common to have hundreds if not thousands of them. https://fsharpforfunandprofit.com/posts/conciseness-type-inference/ Sun, 08 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/conciseness-type-inference/ As you have already seen, F# uses a technique called “type inference” to greatly reduce the number of type annotations that need to be explicitly specified in normal code. And even when types do need to be specified, the syntax is less longwinded compared to C#. To see this, here are some C# methods that wrap two standard LINQ functions. The implementations are trivial, but the method signatures are extremely complex: https://fsharpforfunandprofit.com/posts/conciseness-intro/ Sat, 07 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/conciseness-intro/ After having seen some simple code, we will now move on to demonstrating the major themes (conciseness, convenience, correctness, concurrency and completeness), filtered through the concepts of types, functions and pattern matching. With the next few posts, we’ll examine the features of F# that aid conciseness and readability. An important goal for most mainstream programming languages is a good balance of readability and conciseness. Too much conciseness can result in hard-to-understand or obfuscated code (APL anyone? https://fsharpforfunandprofit.com/posts/key-concepts/ Fri, 06 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/key-concepts/ In the next few posts we’ll move on to demonstrating the themes of this series: conciseness, convenience, correctness, concurrency and completeness. But before that, let’s look at some of the key concepts in F# that we will meet over and over again. F# is different in many ways from a standard imperative language like C#, but there are a few major differences that are particularly important to understand: Function-oriented rather than object-oriented Expressions rather than statements Algebraic types for creating domain models Pattern matching for flow of control In later posts, these will be dealt with in much greater depth – this is just a taster to help you understand the rest of this series. https://fsharpforfunandprofit.com/posts/fvsc-download/ Thu, 05 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/fvsc-download/ In this example, we will compare the F# and C# code for downloading a web page, with a callback to process the text stream. We’ll start with a straightforward F# implementation. // "open" brings a .NET namespace into visibility open System.Net open System open System.IO // Fetch the contents of a web page let fetchUrl callback url = let req = WebRequest.Create(Uri(url)) use resp = req.GetResponse() use stream = resp.GetResponseStream() use reader = new IO. https://fsharpforfunandprofit.com/posts/fvsc-quicksort/ Wed, 04 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/fvsc-quicksort/ In this next example, we will implement a quicksort-like algorithm for sorting lists and compare an F# implementation to a C# implementation. Here is the logic for a simplified quicksort-like algorithm: If the list is empty, there is nothing to do. Otherwise: 1. Take the first element of the list 2. Find all elements in the rest of the list that are less than the first element, and sort them. 3. https://fsharpforfunandprofit.com/posts/fvsc-sum-of-squares/ Tue, 03 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/fvsc-sum-of-squares/ To see what some real F# code looks like, let’s start with a simple problem: “sum the squares from 1 to N”. We’ll compare an F# implementation with a C# implementation. First, the F# code: // define the square function let square x = x * x // define the sumOfSquares function let sumOfSquares n = [1..n] |> List.map square |> List.sum // try it sumOfSquares 100 The mysterious looking |> is called the pipe operator. https://fsharpforfunandprofit.com/posts/fsharp-in-60-seconds/ Mon, 02 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/fsharp-in-60-seconds/ Here is a very quick overview on how to read F# code for newcomers unfamiliar with the syntax. It is obviously not very detailed but should be enough so that you can read and get the gist of the upcoming examples in this series. Don’t worry if you don’t understand all of it, as I will give more detailed explanations when we get to the actual code examples. The two major differences between F# syntax and a standard C-like syntax are: https://fsharpforfunandprofit.com/posts/why-use-fsharp-intro/ Sun, 01 Apr 2012 00:00:00 +0000 https://fsharpforfunandprofit.com/posts/why-use-fsharp-intro/ This series of posts will give you a guided tour through the main features of F# and then show you ways that F# can help you in your day-to-day development. Key benefits of F# compared with C# If you are already familiar with C# or Java, you might be wondering why it would be worth learning yet another language. F# has some major benefits which I have grouped under the following themes: https://fsharpforfunandprofit.com/about/license/ Mon, 01 Jan 0001 00:00:00 +0000 https://fsharpforfunandprofit.com/about/license/ Text and images All text and images copyright (c) 2012-2021 Scott Wlaschin MIT License for code Code copyright (c) 2012-2021 Scott Wlaschin All code on this site is released under the free MIT License as follows: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: https://fsharpforfunandprofit.com/search/ Mon, 01 Jan 0001 00:00:00 +0000 https://fsharpforfunandprofit.com/search/ (function() { var cx = '005822461080256964871:ukp7bevhyrw'; var gcse = document.createElement('script'); gcse.type = 'text/javascript'; gcse.async = true; gcse.src = 'https://cse.google.com/cse.js?cx=' + cx; var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(gcse, s); })(); https://fsharpforfunandprofit.com/csharp/union-types-in-csharp/ Mon, 01 Jan 0001 00:00:00 +0000 https://fsharpforfunandprofit.com/csharp/union-types-in-csharp/ This is an appendix to the post on “designing for correctness”. In that post, I had some requirements for a simple shopping cart. I showed some bad C# code, and some F# code that implemented the requirements easily. There are some responses that come up when a C# developer looks at the F# code, such as “why not just use an interface?” or “what about the visitor pattern?” In this post, I’ll demonstrate why the solution is not as straightforward as you might think. https://fsharpforfunandprofit.com/subscribe/ Mon, 01 Jan 0001 00:00:00 +0000 https://fsharpforfunandprofit.com/subscribe/ I’m not doing a newsletter currently!