NathanHowell

import Data.Binary.Get
import qualified Data.ByteString as B
import qualified Data.Enumerator as E
import qualified Data.Enumerator.Binary as EB
import qualified Codec.Zlib.Enum as Z

unzipStream :: E.Iteratee B.ByteString IO b
            -> E.Iteratee B.ByteString IO b
unzipStream sink = do
  -- read four bytes off the wire into a bytestring

NathanHowell

#line 1 "ParseInt64.rl"
#include <HsFFI.h>


#line 7 "ParseInt64.c"
static const int ParseInt64_start = 1;
static const int ParseInt64_first_final = 3;
static const int ParseInt64_error = 0;

NathanHowell

	.file	"/tmp/ghc20442_0/ghc20442_0.bc"
	.file	1 "/home/nhowell/source/ghc-profiling/libraries/unix/dist-install/build/System/Posix/User.hs"
	.section	.debug_info,"",@progbits
.Lsection_info:
	.section	.debug_abbrev,"",@progbits
.Lsection_abbrev:
	.section	.debug_aranges,"",@progbits

	.section	.debug_macinfo,"",@progbits

NathanHowell

import Data.Aeson
import Data.Attoparsec
import qualified Data.Enumerator as E
import qualified Data.Enumerator.Binary as Eb
import qualified Data.Enumerator.List as El
import qualified Data.ByteString as BS

byteLines :: Monad m => E.Enumeratee BS.ByteString BS.ByteString m b
byteLines = Eb.splitWhen (== 10) -- 10 is LF

NathanHowell

{-# LANGUAGE DataKinds            #-}
{-# LANGUAGE GADTs                #-}
{-# LANGUAGE KindSignatures       #-}
{-# LANGUAGE RankNTypes           #-}
{-# LANGUAGE ScopedTypeVariables  #-}

module Main where

import Data.Proxy
import Data.Type.Equality

NathanHowell

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Forall where
import Control.Applicative
import Data.Aeson
import Control.Monad

data Bar = Bar Int
data Baz = Baz Int Int

NathanHowell

int someCall(int x)
{
     return x * x;
}

NathanHowell

import Data.Array.ST
import Control.Monad.ST
import Control.Monad.Reader

type Env = String

type ReaderST s = ReaderT Env (ST s)

foo :: ReaderST s [Int]
foo = do

NathanHowell

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveDataTypeable #-}

module AlphaHeavy.Exception
  ( setDefaultUncaughtExceptionHandler
  , lastException
  , uncaughtExceptionHandler
  ) where

import Control.Exception (Exception(..), SomeException(..))

NathanHowell

import Control.Concurrent.Chan (Chan, newChan)
import qualified Data.Map as M
import Control.Concurrent.STM
import Control.Monad.Trans (MonadIO, liftIO)
import GHC.Conc (unsafeIOToSTM)

type Id = Integer

getOrCreateChannel :: (MonadIO m) => Id -> TVar (M.Map Id (Chan a))  -> m (Chan a)
getOrCreateChannel cid t = liftIO . atomically $ do