Hans Höglund hanshoglund

(Quick notes written up in response to a discussion on defaulting in GHC.)

Though I argued that implicitly imported defaults should be opt-in, I have a use case for them in this library. It makes heavy use of "custom literals", defined thus:

class IsPitch a where
  c :: a
  d :: a
  -- etc

In the following, we'll assume a setting with a Git repo, master branch and pull requests (e.g. Github). We'll also assume that some tests are run on each pull request to verify correctness of a commit which is a candidate to be the next state of the master branch, of which is a direct descendant (whether this candidate is authored by a user or the result of an auto-merge between a user-authored commit and the last master branch doesn't matter).

What is a "normal test"?

A predicate run on the candidate commit x. P :: Commit -> Bool.

What is a "golden test"?

In principle a function Commit -> A (e.g. running a compiler on some source code) and some predicate A -> A -> Bool (e.g. ==).

Useful Dhall operations/tools:

Common subexpr elimination:

[ < L | R | X >.L, < L | R | X >.R ] 
  =cse=> 
let _ = < L | R | X > in [ _.L, _.R ]

For any expr e

The Monoid instance for Data.Map comes with a left-biased Monoid instance:

> Map.fromList [(1,'a')] <> Map.fromList [(1,'b'),(2,'x')]
Map.fromList [(1,'a'),(2,'x')]

While this is a perfectly valid monoid it might not alwasy be the one that you want. Thanks to -XDerivingVia we can now choose our own instance. This newtype behaves like a traditional map, except that it merges colliding elements pointwise.

RIO and impure monads

This post was prompted by a colleague asking for my opinion about the RIO type. In brief, I like it and recommend it, but for impure monads only.

To recap, RIO is defined like this:

data RIO env a = RIO { runRIO :: env -> IO a }

	// Memory-safe and leak-free Zig
	// By using no heap allocation
	// All data is in the single state var, allocated up-front
	// Also thread-safe by being single thread (if concurrency needed, use separate message queue/pipes)

	const std = @import("std");

	const Employee = struct {
	id: i32,
	name: [10]u8,

	from typing import Generic, TypeVar, final
	from typing import Callable
	from dataclasses import dataclass

	L = TypeVar("L")
	R = TypeVar("R")

	class Either(Generic[L,R]): ...

	@final

	# mypy 1.8.0, python 3.12
	# supports recursion + generics unlike (https://gist.github.com/hanshoglund/cd4302f2c1e07370649b5983bead320e)
	# OTOH, no exhaustive checks in match clasuses. And issues like: https://gist.github.com/hanshoglund/d255b3a9ff0a07cf7504a3b4313d6d7c
	#
	# Note: if we ONLY use frozen dataclasses as here, we have Eq,Ord,Show,Hashable, so the need for ad-hoc polymorphism is greatly reduced
	from typing import Generic, TypeVar, final
	from typing import Callable
	from dataclasses import dataclass

	T = TypeVar("T")

	# tested with mypy 1.7.1, python 3.12

	# Recursive ADT with exhaustive pattern matching
	# Adapted from http://blog.ezyang.com/2020/10/idiomatic-algebraic-data-types-in-python-with-dataclasses-and-union/
	#
	# No generic/param polymorphic trees :(
	# In many cases generic builtins (list, dict) + non-generic recursive ADTs (dataclasses) is enough
	# How about optional/either. In go NIL us used, in mypy there is optional and either can be encoded (though there are bugs):
	# https://github.com/python/mypy/issues/6748
	#

	(* supertype *)
	type (_, _) st =
	\| Refl : ('a, 'a) st
	\| Fst : ('a, 'a * 'b) st
	\| Snd : ('a, 'b) st -> ('a, 'c * 'b) st
	\| Left : (('a, 'b) result, 'a) st

	type _ ttype =
	\| Int : int ttype
	\| Bool : bool ttype