F#

A collection of 28 posts

F#

F# Discriminated Unions with SQL Enumerations

💡This post is part of F# Advent Calendar 2024. Having worked extensively with both C# (including Entity Framework) and F#, I've found that F# allows us to elegantly model the business domain while seamlessly bridging the gap between code and database. In this post, I'll outline

F#

Cross-Boundary ADTs

Modeling a domain with algebraic data types (ADTs) is a powerful, expressive way to design code that is both concise and readable. Too often, code that does too little with too many lines negatively impacts readability and maintainability. ADTs, when supported by a language, provide a way to do more

functional programming

Stacks

A few stacks that come to mind for that next web app project. * Full stack Rust with WASM * Full stack F# with Fable and a typical JS library on front-end * Elixir with Pheonix * Gleam with Pheonix * Full stack F# with Bolero (F# WASM) * Any of the above backends with Flutter

dart

Finding Delight in Unfamiliar Languages

Sometimes, languages we are unfamiliar with end up being delightful. At one point, I opted to compile F# to Dart for a Flutter project rather than use Dart directly because certain tasks were more verbose than I desired. While F# compiled to Dart quite flawlessly and impressively, I later decided

F#

Choosing Elegance: The Case for F# in Application Development

This post is for Day 6 of F# Advent Calendar. We all know the go-to languages for most companies in application software development: Java, C#, TypeScript, and Python, to name a few. There's obviously nothing wrong with using these ubiquitous languages, but there's a tendency to

functional programming

Functional Basics: First Class Functions

In functional programming, the concept of first-class functions is fundamental. A function is considered to be a first-class citizen if it can be treated like any other value. This means that, similar to other values, functions can be assigned to variables, stored in data structures, passed as arguments to other

F#

Ray Tracer Challenge in F#

Notes from my README. This repository is a for-fun project I'm working on as I have some free time. I'm going through Jamis Buck's book ray tracer challenge, which is a language-agnostic book on how to build a ray tracer, guiding primarily through cucumber-style

functional programming

Functional Basics: Expressions

The journey to master functional programming involves shifting one's approach of even the simplest problems. It is a different paradigm after all. But don't be intimidated, because this journey is best travelled by embracing small shifts in thinking. Unlearning small things and learning other (perhaps smaller)

functional programming

Functional Basics: Identity Function

The identity function is an unassuming little function with a signature of 'a -> 'a. It returns the value of the argument it's given. At first glance it can seem rather pointless but it serves a purpose in both practical and theoretical contexts. The identity

F#

Modeling Domain Logic With Algebraic Data Types

There are a number of ways one might approach designing the logic of a domain problem. Most enterprise software engineers may be accustomed to modeling the problem using object-oriented programming, where classes encapsulate behavior and data. In this approach, the design often reflects the use of various design patterns, such

F#

Mapping Database Values to Discriminated Unions for Domain-Driven Design

Let's explore two strengths of F# and their application in a typical enterprise app, using an example that is relevant to any subscription-based service - working with a user's subscription status in both the code and the database. The first strength is it's focus

F#

Composable Database Connection Middleware with Giraffe

If someone is new to Giraffe and approaching it with familiarity of the built-in .NET server utilities, then utilizing the compose combinator ( >=>) may take some getting used to. This post will explore using the compose combinator through utilizing it to supply http route handlers with a database connection.

F#

Domain-Driven Microservices with F#

It is well-known, or at least well-documented, that F# is an excellent language for doing type-driven development using domain driven design, although it may be less well known that F# is an excellent language for microservices. Indeed, microservices benefit greatly from F#'s typesystem - making it easy to

game development

Godot 4 and F#

Update: After beginning to make a game, it turned out not to be as straightfoward as this post implies. Primarily because Godot 4 requires that the C# class be a partial class extending the corresponding Godot entity. F# doesn't have a direct translation of partial classes as far

F#

Flutter State in F# with Fable and Redux

Fable 4.0 is on the horizon 🎉 and with it comes the ability to compile F# code to Dart. Although Fable 4 is still pre-release, the Dart compilation works great - so great that I was able to migrate the entirety of my Redux state management in a Flutter app

F#

Function Composition vs Pipelines

A composed function can be thought of as being more generalized than a pipeline, as a pipeline needs a value to start with while a composed function receives an argrument directly. let clickHandler (value: string) = value |> parse |> sanitize |> serialize |> sendPayload The function above takes an argument,

F#

Generate Signed S3 URL in F#

If you have a single page application, you may be wanting to upload files directly to S3 from the browser rather than using your own server side application as a middle man between the two. In F# this can be done with the Amazon S3 package Via dotnet cli: dotnet

functional programming

Function Application

Consider this function: let makeName (firstName: string) (lastName: string) = $"{firstName} {lastName}" Let's apply it different ways with and without pipes, and with and without partial application. Application without pipeline: let name = makeName "Bob" "Vila" Partial application without pipeline: let applyLastName = "Bob&

F#

.NET 6 Minimal API with F# and Giraffe

Here's my setup for an F# .NET 6 minimal API. Start by opening up the main modules we'll be using in Startup.fs (or Program.fs as I tend to name it). open System open System.Text open Dapper open Microsoft.AspNetCore.Builder open Microsoft.AspNetCore.

F#

Type-safe JavaScript Development with F# and Fable

F# is a suitable alternative to TypeScript for writing a JavaScript application with type-safety. But you also get the additional benefits of F#'s powerful type inference. TypeScript interface Person { firstName: string lastName: string } let people: Person[] = [ { firstName: 'John', lastName: 'Doe' }, { firstName: 'Jane'

game development

GetNode()

GDScript has a convenient shortcut for grabbing a child node reference within a script. For example, grabbing an AnimatedSprite and setting it to play a certain animation can be done with $AnimatedSprite.animation = "animation name". Getting a node in C# and F# is a bit more verbose. In

game development

Preferring Immutability in Godot

Game engine development tends to rely on mutability, such as keeping up with an object's position on-screen. Typically, the game object is represented by a single class with a "position" property, and as the object moves around that property mutates to reflect its new value. This

game development

Exporting Godot Variables in F#

In Godot, it's convenient to export variables so that they can be updated via the Inspector tab. Doing so in C# looks like this: using Godot; public class Player : Area2D { [Export] public float Speed = 2f; public override void _Ready() {} public override void _Process(float delta) {} } Here the Speed

lambda calculus

Argument Selection Function

The argument selection function λfirst.λsecond.first accepts a function as an argument and returns a function which, when given an argument, returns the first argument. // λfirst.λsecond.first const selectFirst = x => y => x const double = a => a * 2 const triple = a => a * 3 const applyDouble

game development

Godot and F#

Over the weekend I got a game started with Godot Mono and F#. It works out pretty well, although it relies on using C# to extend types defined in F#. Out of the gate I've taken up a convention of defining a namespace just for defining a type