bencope.land

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,

godot

.NET 6 in Godot 4 Alpha

It looks like the Godot 4 alpha will be getting .NET 6 soon, according to this recent news. This is pretty exciting. I look forward to trying it out and may end up doing a guide on setting up F# in Godot 4. I'm particularly interested to see

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.

reactive programming

Reactive Programming - Tower Defense for Data

Following a reactive approach to development is like setting up defenses in a tower defense game. You set up your pipeline of operators,  each with its own skill and its own preferred target - and that’s it. Allow  the application to send in the events and watch the operators

react

RxJS for Functional State Management

Since it is bundled with Angular, RxJS does not tend to get much attention as a means to have state in a functional React application. However, RxJS is a powerful way to have state with little boilerplate and high resilience. It is light in boilerplate because it can achieve immutable,

functional programming

Isolating Unused, Nil Expressions in React

A functional-first approach to programming discourages a number of typical JavaScript practices, including some practices that are even typical for React. In particular, React conventions nudge us towards having unused expressions, and to have expressions that are nil (undefined or null) with its useEffect hook. Let's consider how

functional programming

Lambda Calculus and Arguments

Functions in the lambda calculus are always unary - they only take one argument. Functional programming is based on the lambda calculus, and it is useful to learn to appreciate unary functions. One useful way to train your brain to think functionally is, when you find yourself writing an n-ary

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'

functional programming

FP Lint

ESLint can help you enforce functional-first standards. Below is a functional eslint setup I like, followed by some explaination. { "root": true, "parser": "@typescript-eslint/parser", "plugins": [ "@typescript-eslint", "fp", "prefer-let" ], "extends": [ "airbnb", "plugin:

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

functional programming

Semantic Focus

In his book Stylish F#, Kit Eason describes a few unstylish pitfalls that developers may fall into. One of these pitfalls he calls lack of semantic focus. I'll describe the kind of code that isn't readable with minimum context as having poor semantic focus. In other

functional programming

Functional Reactive Programming

There's something about FRP specifically that makes programming an absolute pleasure. Designing an elegant reactive application is a great feeling and opens you're mind to just how rewarding it can be to focus on decoupling. Thinking in reactive (message driven) streams has clear benefits between multiple

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

lambda calculus

Application Function

Function application function is represented by the term λf.λx.f x. It accepts a function as an argument and applies it to the argument of the function it returns. // λf.λx.f x let apply f x = f x let addOne c = c + 1 let applyAddOne = addOne |> apply

lambda calculus

Self Application Function

The function λx.x x is the self application function. It applies its argument to its argument. // λx.x x const sa = x => x(x) Like the identity function, it doesn't seem helpful at first glance but it has some interesting applications. Consider the twice function λf.

lambda calculus

Identity Function

Identity function is the simplest of the lambda calculus functions, represented by λa.a. It simply returns the argument that it was given. // F# fun a -> a // JS a => a # Python lambda a: a While it is a simple function, it still has significance in composing functions

functional programming

Pipes Again

Python's PyMonad library provides some neat utilities for functional programming. Here's a Python pipe function from a previous post. pipe = lambda *fns: lambda x: reduce(lambda y, f: f(y), list(fns), x) g = lambda n: n + 1 f = lambda n: n * 2 h = pipe(g,

game development

Invisible

Just completed a prototype for Weekly Game Jam #147. The theme was "invisible". What we came up with was a space adventure where you must reach a base, but the base is cloaked until a certain objective is met. We had lofty goals and only produced a subset

game development

Game Jams

Game jams are a nice way to develop a game under a set of constraints so that you don't get bogged down with too many details, or end up with an eternal side project. I'd like to do a few this year hopefully with some friends