michaelt

import System.IO
import Network
import Minecraft
import Control.Monad
import Control.Monad.Fix
import Control.Monad.Trans
import Control.Monad.BinaryProtocol
import Control.Concurrent
import Control.Concurrent.STM
import Control.Concurrent.STM.TChan

michaelt

{-#LANGUAGE OverloadedStrings#-}
module Jade where

import Text.Parsec
import qualified Text.Parsec.Token as L
import Text.Parsec.Language (emptyDef)
import Text.Parsec.Text (Parser)
import Data.Text (Text)
import Control.Monad (mzero)
import Control.Applicative ((<$>),(*>), (<*))

michaelt

(☃) :: Int -> Int -> Int 
x  ☃ y = x + y

main = print $ 0 ☃ 1 ☃ 2

michaelt

{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE DataKinds#-}
{-# LANGUAGE KindSignatures#-}
module RedBlackTree where

data Nat = Zero | Succ Nat deriving (Eq, Ord, Show)
type One = Succ Zero

michaelt

#!/usr/bin/env runghc

module Main where

{-
    Uninstall.hs - a Haskell uninstaller for Mac OS X
    
    This program is really far too big to be in a single file. However, I
    wanted it to be easily distributable and runnable, and so have kept it all
    together.

michaelt

import Control.Concurrent
import Control.Concurrent.Async
import Control.Applicative
import Control.Monad

import Data.Traversable

newtype Concurrently a = Concurrently { runConcurrently :: IO a }

instance Functor Concurrently where

michaelt

{-# LANGUAGE ImplicitParams, ParallelListComp,MonadComprehensions #-}
import Control.Monad
import Control.Monad.Fix
import Control.Monad.Zip
import Control.Applicative
import Control.Concurrent
import Control.Concurrent.MVar
import Control.Exception 
import Prelude -- hiding (catch)
import Data.IORef

michaelt

module HTML where

  class Tag a where
    toHTML :: a -> String


  data Attribute = Attribute {
    key :: String,
    value :: String
  } deriving Show

michaelt

countPackets p = 
  let v = AL.parse (CA.many packetValue) p
      r = fromMaybe [] $ AL.maybeResult v
  in r

michaelt

{-#LANGUAGE OverloadedStrings#-}

import Data.Aeson.Types
import Data.Aeson
import qualified Data.Vector as V
import qualified Data.ByteString.Lazy as L 
import Data.HashMap.Strict
import qualified Data.Text as T

-- this is backward maybe -- also doesn't crack open the Values