evanrelf

{-# LANGUAGE DataKinds #-}
{-# OPTIONS_GHC -Wall #-}

module X where

import Data.Kind (Type)
import GHC.TypeLits (KnownSymbol, Symbol)

type (:::) :: Symbol -> Type -> Type
data (:::) s a

evanrelf

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

#!/usr/bin/env bash

set -Eeuo pipefail
IFS=$'\n\t'

deferred=(true)

run_deferred() {
  local status="$1"
  abort() {

evanrelf

{-# 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

-- 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

#!/usr/bin/env runghc

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

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

evanrelf

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

module Main (main) where

import Control.Monad (when)
import Data.Proxy (Proxy (..))
import Data.String (IsString (..))
import Data.Void (Void)
import Type.Reflection

typeName
  :: forall a s proxy

evanrelf

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

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