Evan Relf evanrelf

evanrelf / serde_special_case_field.rs

Created July 16, 2024 17:30

	use serde::{Deserialize, Deserializer, Serialize, Serializer};
	use serde_json;

	#[derive(Debug, Serialize, Deserialize)]
	struct Foo(String);

	#[derive(Debug, Serialize, Deserialize)]
	struct Bar(String);

	fn foo_ser<S>(value: &Foo, serializer: S) -> Result<S::Ok, S::Error>

evanrelf / defer

Last active July 11, 2024 22:14

evanrelf / syntax-tricks.hs

Last active June 13, 2024 23:24

	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE QualifiedDo #-}
	{-# LANGUAGE TypeFamilies #-}
	{-# LANGUAGE OverloadedLabels #-}

	module X where

	import Data.Functor.Identity (Identity (..))
	import Data.Kind (Type)
	import GHC.OverloadedLabels (IsLabel (..))

evanrelf / parser-combinators.hs

Last active June 2, 2024 03:16

	-- https://www.youtube.com/watch?v=dDtZLm7HIJs

	{-# LANGUAGE BlockArguments #-}

	module Main (main) where

	import Control.Applicative
	import Control.Monad (when)
	import Data.Char
	import Data.Foldable (for_)

evanrelf / fold-frozen-arithmetic.hs

Last active May 21, 2024 06:25

	#!/usr/bin/env runghc

	{-# LANGUAGE BlockArguments #-}
	{-# LANGUAGE DerivingStrategies #-}
	{-# LANGUAGE LambdaCase #-}
	{-# LANGUAGE NegativeLiterals #-}

	{-# OPTIONS_GHC -Wall #-}
	{-# OPTIONS_GHC -Wno-unused-top-binds #-}

evanrelf / a_b_tree_const.rs

Created May 13, 2024 06:07

	const A: usize = 2;
	const B: usize = 3;

	#[allow(clippy::assertions_on_constants)]
	const _: () = {
	assert!(2 <= A && A <= (B + 1) / 2, "Not a valid (a,b)-tree");
	assert!(A == (B / 2) + (B % 2), "Not a valid B-tree");
	};

evanrelf / type-name.hs

Last active May 10, 2024 23:54

evanrelf / exhaustive-map.hs

Last active July 18, 2024 17:56

	module ExhaustiveMap where

	import Data.Map.Strict (Map)
	import Data.Map.Strict qualified as Map
	import Data.Maybe (fromMaybe)
	import Prelude hiding (lookup, map)

	newtype ExhaustiveMap k v
	= ExhaustiveMap{ unExhaustiveMap :: k -> v }

evanrelf / repeatedly.hs

Created May 6, 2024 23:14

	module Repeatedly where

	import Data.Foldable (foldl', foldlM)

	repeatedly :: (Foldable t) => (a -> b -> b) -> (t a -> b -> b)
	repeatedly = flip . foldl' . flip

	repeatedlyM :: (Foldable t, Monad m) => (a -> b -> m b) -> (t a -> b -> m b)
	repeatedlyM = flip . foldlM . flip

evanrelf / ring-buffer.hs

Last active March 18, 2024 22:56

	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE DerivingStrategies #-}

	import Data.Bits (toIntegralSized)
	import Data.Function ((&))
	import Data.Kind (Type)
	import Data.Monoid (Sum (..))
	import Data.Proxy (Proxy (..))
	import Data.Sequence (Seq (..))
	import Data.Sequence qualified as Seq