LSLeary’s gists

LSLeary / Pool.hs

Created August 19, 2024 13:17

Transparently hand off jobs to a pool of workers.

	{-# LANGUAGE DerivingVia, LambdaCase, BlockArguments #-}

	module Pool (
	Pool,
	runPool,
	schedule,
	withRunInIO,
	) where

	-- base

LSLeary / Sum.hs

Last active August 12, 2024 10:29

An implementation of anonymous sums (AKA variants) with O(1) access, without resorting to Typeable or unsafeCoerce.

	{-# LANGUAGE LambdaCase, GADTs #-}

	module Sum where

	import Data.Type.Equality ((:~:)(..))
	import Data.Functor ((<&>))

	type f ~> g = forall x. f x -> g x

LSLeary / Transform.hs

Last active July 23, 2023 04:58

Deriving semidirect products for transformation monoids

	{-# LANGUAGE DerivingVia, PatternSynonyms #-}
	{-# LANGUAGE UndecidableInstances, MonoLocalBinds #-}

	module Transform where

	import Data.Functor ((<&>))
	import Data.Monoid (Sum(..), Product(..), Ap(..))


	test1a :: Transformable p s => Transform p s

LSLeary / Local.hs

Created July 17, 2023 13:36

A "local" quasiquoter, such that [local|<name>|] = Current.Module.<name>.

	module Local (local) where

	import Data.Char (isUpper)
	import Data.Functor ((<&>))

	import Language.Haskell.TH.Syntax
	( Q, Exp(VarE, ConE), Type(ConT)
	, Module(..), Name(..), OccName(..), NameFlavour(NameQ)
	)
	import Language.Haskell.TH.Lib (thisModule)

LSLeary / Triangles.hs

Created July 5, 2023 21:35

Fancy if-then-else with triangles!

	module Triangles ((<\|), (\|>)) where

	(<\|) :: a -> Bool -> Maybe a
	a <\| True = Just a
	_ <\| False = Nothing
	infix 2 <\|

	(\|>) :: Maybe a -> a -> a
	Just a \|> _ = a
	Nothing \|> a = a

LSLeary / Fresh.hs

Created June 21, 2023 14:06

Generate fresh Typeable types.

	module Fresh
	( Fresh, runFresh, withFresh
	) where

	import Data.Typeable

	import Control.Monad.State (StateT, evalStateT, get, put)
	import Control.Monad.Trans (MonadTrans)

LSLeary / Sub.hs

Last active June 9, 2023 21:58

Parametrickery: Subtyping & Monotonicity

	{-# LANGUAGE DataKinds #-}

	module Sub where


	data Sub = S Sub

	data Three (s :: Sub) a b c where
	One :: a -> Three s a b c
	Two :: b -> Three (S s ) a b c

LSLeary / Cube.hs

Created April 10, 2023 22:59

See: https://www.reddit.com/r/haskell/comments/12hq6z6/the_free_boolean_cube_an_exploration_of_things/

	module Cube where

	import Data.Functor.Const (Const(..))
	import Data.Functor.Product (Product(..))
	import Data.Functor.Sum (Sum(..))


	type (&&) = Product
	type (\|\|) = Sum

LSLeary / watchfile

Last active September 6, 2024 04:52

A reasonable approximation of ghcid for arbitrary files and interpreters, with nice scrolling and searching via less. Only needs inotifywait on the $PATH.

	#! /usr/bin/env sh

	# Example usage:
	# $ watchfile Test.idr idris2 --check
	# $ watchfile test.sh shellcheck
	# $ watchfile Main.hs -- cabal test


	file=$1; shift
	tmp="/tmp/watch.$(basename "$file")"

LSLeary / Incremental.hs

Last active August 20, 2024 18:42

A thread-safe IC implementation supporting both eager parallel propagation and lazy demand driven evaluation.

	{-# LANGUAGE DerivingVia, BlockArguments, LambdaCase #-}

	module Control.Concurrent.Incremental (

	Adaptive, adaptively,
	static, dynamic,

	ICVar, newICVar, newICVarIO,
	demand, propagate,
	compute, await,

	module Triangles ((<\|), (\|>)) where

	(<\|) :: a -> Bool -> Maybe a
	a <\| True = Just a
	_ <\| False = Nothing
	infix 2 <\|

	(\|>) :: Maybe a -> a -> a
	Just a \|> _ = a
	Nothing \|> a = a

Leary LSLeary