dmwit

-- dmwit style

module Parser where

import Data.Time

data Transaction = Transaction
    { amount :: Double
    , time :: UTCTime
    , tags :: [String]

dmwit

class Stream
	def initialize(&more)
		@sofar = []
		@more = more
	end

	def [](i)
		while i >= @sofar.length do
			@sofar += @more.call(@sofar)
		end

dmwit

{-# LANGUAGE FlexibleInstances #-}
import Data.Functor.Compose
import Control.Monad

joinEntry :: Maybe [Maybe [a]] -> Maybe [a]
joinEntry = fmap join . join . fmap sequenceA

instance Monad (Compose Maybe []) where
	-- or use liberal applications of coerce to avoid the calls to Compose and getCompose
	x >>= f = Compose . joinEntry . getCompose . fmap (getCompose . f) $ x

dmwit

#!/bin/zsh

set -e
setopt null_glob

case $# in
    1) true;;
    *)
        echo Usage: ghc-version VERSION
        ghc --version || true

dmwit

{-# LANGUAGE TypeFamilies #-}
class Foo a where
	type I a t
	foo :: I a t -> t -> a

instance Foo () where
	type I () t = ()
	foo _ _ = ()

instance Foo b => Foo (a, b) where

dmwit

\xs -> sum $ map (sum . toDigits) xs
= { f $ x = f x }
\xs -> sum (map (sum . toDigits) xs)
= { function application associates to the left }
\xs -> sum ((map (sum . toDigits)) xs)
= { (f . g) x = f (g x), with f = sum, g = (map (sum . toDigits)) }
\xs -> (sum . (map (sum . toDigits))) xs
= { eta reduction }
(sum . (map (sum . toDigits)))
= { remove unnecessary clarifying parentheses }

dmwit

{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE DataKinds #-}
import GHC.Exts

type family AllAllowed k xs where
	AllAllowed k '[] = ()
	AllAllowed k (x : xs) = (Allowed k x, AllAllowed k xs)

dmwit

{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE TypeFamilies #-}
import GHC.Exts
class (forall a. A t a => A t [a]) => B t where type A t a :: Constraint
instance B t => B [t] where type A [t] a = A t a

dmwit

import Control.Monad.Writer hiding (liftIO)
import Data.Functor.Compose

type InitIO = Compose (Writer (IO ())) IO

-- | Do no initialization
liftIO :: IO a -> InitIO a
liftIO = Compose . pure

liftInit :: IO () -> InitIO ()

dmwit

import Data.List
import Data.Maybe
import Data.Ord

shareArea = 85
pizzaArea size = pi * (size/2)^2
totalPizzaArea = sum . map pizzaArea

sufficient area sizes | area < 0 = [[]]
sufficient area [] = []