Antti Holvikari anttih

True Color (24-bit) and italics with alacritty + tmux + vim (neovim)

This should make True Color (24-bit) and italics work in your tmux session and vim/neovim when using Alacritty (and should be compatible with any other terminal emulator, including Kitty).

Testing colors

Running this script should look the same in tmux as without.

curl -s https://gist.githubusercontent.com/lifepillar/09a44b8cf0f9397465614e622979107f/raw/24-bit-color.sh >24-bit-color.sh

The question of "How do I design my application in Haskell?" comes up a lot. There's a bunch of perspectives and choices, so it makes sense that it's difficult to choose just one. Do I use plain monad transformers, mtl, just pass the parameters manually and use IO for everything, the ReaderT design pattern, free monads, freer monads, some other kind of algebraic effect system?!

The answer is: why not both/all?

Lately, I've been centering on a n application design architecture with roughly three layers:

Layer 1:

newtype AppT m a = AppT { unAppT :: ReaderT YourStuff m a } deriving ............ The ReaderT Design Pattern, essentially. This is what everything gets boiled down to, and what everything eventually gets interpreted in. This type is the backbone of your app. For some components, you carry around some info/state (consider [MonadMetrics](https://hackage

Effective Modern CMake

Getting Started

For a brief user-level introduction to CMake, watch C++ Weekly, Episode 78, Intro to CMake by Jason Turner. LLVM’s CMake Primer provides a good high-level introduction to the CMake syntax. Go read it now.

After that, watch Mathieu Ropert’s CppCon 2017 talk Using Modern CMake Patterns to Enforce a Good Modular Design (slides). It provides a thorough explanation of what modern CMake is and why it is so much better than “old school” CMake. The modular design ideas in this talk are based on the book [Large-Scale C++ Software Design](https://www.amazon.de/Large-Scale-Soft

Vim without NERD tree or CtrlP

I used to use NERD tree for quite a while, then switched to CtrlP for something a little more lightweight. My setup now includes zero file browser or tree view, and instead uses native Vim fuzzy search and auto-directory switching.

Fuzzy Search

There is a super sweet feature in Vim whereby you can fuzzy find your files using **/*, e.g.:

:vs **/*<partial file name><Tab>

Technical overview

A basic `Option` type

// Option.ts

// definition
export class None {
  readonly tag: 'None' = 'None'

	###
	### [2023-06-19] UPDATE: Just tried to use my instructions again on a fresh install and it failed in a number of places.
	###. Not sure if I'll update this gist (though I realise it seems to still have some traffic), but here's a list of
	###. things to watch out for:
	### - Check out the `nix-darwin` instructions, as they have changed.
	### - There's a home manager gotcha https://github.com/nix-community/home-manager/issues/4026
	###

	# I found some good resources but they seem to do a bit too much (maybe from a time when there were more bugs).
	# So here's a minimal Gist which worked for me as an install on a new M1 Pro.

	// Reference: https://asc.di.fct.unl.pt/~jleitao/pdf/dsn07-leitao.pdf

	module Protocols.Hyparview

	open System
	open System.Runtime.ExceptionServices
	open System.Threading

	type Endpoint = string
	type TTL = int

	-- This gist shows how we can use abilities to provide nicer syntax for any monad.
	-- We can view abilities as "just" providing nicer syntax for working with the
	-- free monad.

	ability Monadic f where
	eval : f a -> a

	-- Here's a monad, encoded as a first-class value with
	-- two polymorphic functions, `pure` and `bind`
	type Monad f = Monad (forall a . a -> f a) (forall a b . f a -> (a -> f b) -> f b)

	module Main where

	import Control.Comonad.Cofree (Cofree, explore, head, mkCofree, tail, unfoldCofree)
	import Control.Monad.Eff (Eff)
	import Control.Monad.Eff.Console (CONSOLE, log)
	import Control.Monad.Free (Free, liftF)
	import Data.Either (Either(..))
	import Data.Foldable (fold)
	import Data.Functor.Coproduct (Coproduct(..), left, right)
	import Data.Functor.Product (Product(..), product)

	/* @flow */

	import * as I from "immutable";

	/**
	* Define an immutable record intended for holding reducer state
	* @param spec - the keys and their default values
	* @return a state record factory function
	*/
	export function defineRecord<T: Object>(