jtobin

{-# LANGUAGE BangPatterns #-}

import Control.DeepSeq
import qualified Data.Vector.Unboxed as U
import System.Random.MWC
import Control.Monad
import Criterion.Main
import Criterion.Config

newtype AffineTransform = AffineTransform {

jtobin

module Main where

import Control.Monad
import Control.Monad.Primitive
import System.Environment
import System.Random.MWC

data Child = Boy | Girl deriving (Eq, Show)

instance Variate Child where

jtobin

{-# OPTIONS_GHC -fno-warn-missing-methods #-}
{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
{-# OPTIONS_GHC -fno-warn-type-defaults #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE TypeFamilies #-}

module Minimal where

import Control.Applicative
import Data.Graph

jtobin

{-# OPTIONS_GHC -fno-warn-missing-methods #-}

module HOAS where

data Expr =
    Lit Int
  | Add Expr Expr
  | Let Expr (Expr -> Expr)

instance Num Expr where

jtobin

{-# OPTIONS_GHC -fno-warn-missing-methods #-}
{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
{-# OPTIONS_GHC -fno-warn-type-defaults #-}
{-# LANGUAGE RankNTypes #-}

module PHOAS where

data Expr a =
    Lit Int
  | Var a

jtobin

{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -fno-warn-missing-methods #-}
{-# LANGUAGE PatternGuards #-}

import Control.Applicative
import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as HashMap
import Data.Monoid
import Data.Traversable
import System.Exit

jtobin

Keybase proof

I hereby claim:

• I am jtobin on github.
• I am jtobin (https://keybase.io/jtobin) on keybase.
• I have a public key whose fingerprint is 3422 6DCF 974D 5AF1 2114 488A 710A 5FDA E32D 77E7

To claim this, I am signing this object:

jtobin

module Ordered where

import Data.Function (on)
import Data.List (sort, maximumBy)

longestOrdered :: Ord a => [[a]] -> Maybe [a]
longestOrdered dict = safeMaximumBy (compare `on` length)
  [word | word <- dict, sort word == word]

safeMaximumBy :: (a -> a -> Ordering) -> [a] -> Maybe a

jtobin

{-# LANGUAGE DeriveFunctor #-}

import Data.List.Ordered (merge)
import Data.Functor.Foldable
import Prelude hiding (Foldable, succ)

data NatF r =
    ZeroF
  | SuccF r
  deriving (Show, Functor)

jtobin

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE UndecidableInstances #-}

import Prelude hiding (succ)

newtype Fix f = Fix (f (Fix f))

deriving instance (Show (f (Fix f))) => Show (Fix f)