Skip to content

Instantly share code, notes, and snippets.


Florian Klein docteurklein

View GitHub Profile
hikari-no-yume / 0_hello-world.c
Last active Feb 24, 2021
What would C look like if you compiled it to LLVM IR and back again? (
View 0_hello-world.c
#include <stdio.h>
int main(void)
printf("hello, world\n");
View flake.nix
description = "a skeleton haskell flake";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixos-20.09";
flake-utils.url = "github:numtide/flake-utils";
outputs = { self, nixpkgs, flake-utils, ... }:
flake-utils.lib.eachDefaultSystem (system:
pkgs = import nixpkgs {
lynn / PrettyParseError.hs
Last active Oct 20, 2020
Pretty ParseErrors for Text.Parsec
View PrettyParseError.hs
module PrettyParseError (
) where
import Data.List (intercalate, nub)
import Text.Parsec
import Text.Parsec.Error
import Text.Parsec.Pos
View plot.awk
#!/usr/bin/awk -f
# This program is a copy of guff, a plot device.
# My copy here is written in awk instead of C, has no compelling benefit.
# Public domain. @thingskatedid
# Run as awk -v x=xyz ... or env variables for stuff?
# Assumptions: the data is evenly spaced along the x-axis
# TODO: moving average
reinink / query.sql
Last active Apr 21, 2021
Text search across multiple tables using MySQL
View query.sql
left join
companies on = users.company_id
where ( like 'TERM%' or
first_name like 'TERM%' or


It’s folklore that if you’re summing a list of numbers, then you should always use strict foldl. Is that really true though? foldr is useful for lists when the function we use is lazy in its second argument. For (+) :: Int -> Int -> Int this is tyically not the case, but in some sense that’s because Int is “too strict”. An alternative representation of numbers is to represent them inductively. If we do this, sumation can be lazy, and foldr can do things that foldl simply can’t!

First, let’s define natural numbers inductively, and say how to add them:

data Nat = Zero | OnePlus Nat deriving Show

one :: Nat
clementd-fretlink / Environment.hs
Created Mar 23, 2020
Env var parsing with free applicatives
View Environment.hs
#!/usr/bin/env stack
-- stack --resolver lts-14.20 --install-ghc runghc --package either --package free
{-# LANGUAGE DeriveFunctor #-}
module Main
import Control.Applicative.Free
import Data.Bifunctor (first)
import Data.Either.Combinators (maybeToRight)
import Data.Either.Validation
atacratic /
Last active Jan 7, 2021
Unison abilities - unofficial alternative tutorial

This tutorial explains how Unison handles 'effectful' computations, like storing state or performing I/O, using abilities. It assumes you haven't come across abilities before, and covers everything from the ground up.

This is an unofficial tutorial, written before the one on The approach taken here is slow and methodical. Your first stop should be the official tutorial, if you haven't seen it already.

This doc is a Unison transcript - the source is here.

Terminology note: other languages with ability systems typically call them 'effect handlers' or 'algebraic effects', but many of the ideas are the same.

Introducing abilities

View event.hs
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NumericUnderscores #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
-- |
-- To reproduce with curl, run mainTls (from ghci) and use
-- @
View Optics