chrisdone

{-# LANGUAGE CPP #-}
-- |

module Data.FileEmbed2
  ( makeRelativeToProject2
  , module Data.FileEmbed
  ) where

import Data.FileEmbed
import Language.Haskell.TH

chrisdone

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE GADTs #-}

-- | A restricted web type.

module Web
  ( Web(..)
  , runWebHandler

chrisdone

{-# LANGUAGE BangPatterns #-}

import Control.DeepSeq
import Data.List hiding (foldl)
import Prelude hiding (foldl)

foldl = \f accumulator list ->
  case list of
    [] -> accumulator
    x:xs -> foldlS f (f accumulator x) xs

chrisdone

Duet's folds example

Duet has this folding example:

data List a = Nil | Cons a (List a)
foldr = \f z l ->
  case l of
    Nil -> z
    Cons x xs -> f x (foldr f z xs)

chrisdone

-- | Execute the steps.
execute :: [SomeStep] -> RIO MainEnv ()
execute steps = do
  resources <- newIORef mempty
  mapRIO
    (\MainEnv {logger} -> ExecuteEnv {logger = logger . ExecuteLog, resources})
    (mapM_ executeSomeStep steps)

chrisdone

> :set -XOverloadedStrings
> :set -XTemplateHaskell

> import Language.Haskell.TH
> $(bsToExp "Hello, World" >>= stringE . show)
"AppE (VarE GHC.IO.Unsafe.unsafePerformIO) (AppE (AppE (VarE Data.ByteString.Unsafe.unsafePackAddressLen) \
\(LitE (IntegerL 12))) (LitE (StringPrimL [72,101,108,108,111,44,32,87,111,114,108,100])))"
> 

> :set -ddump-splices

chrisdone

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}

import           Data.Bifunctor

chrisdone

{-# LANGUAGE ScopedTypeVariables #-}

module Data.Graph.Shuffle where

-- | Shuffle a graph into a randomly sorted list, preserving
-- topological order.

{-

> quickCheckWith stdArgs {maxSuccess=10000} prop_identity

chrisdone

{-# LANGUAGE PartialTypeSignatures #-}
module StableShuffle where

import           Control.Monad
import           Control.Monad.Random
import           Data.Bifunctor
import           Data.List
import qualified Data.Map.Strict as M
import           Data.Maybe
import           Data.Ord

chrisdone

{-# LANGUAGE PartialTypeSignatures #-}
module StableShuffle where

import           Control.Monad
import           Control.Monad.Random.Class
import           Data.List
import qualified Data.Map.Strict as M
import           Data.Maybe
import           Data.Ord
import           System.Random.Shuffle