NathanHowell

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE OverlappingInstances #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}

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

NathanHowell

{-# LANGUAGE OverloadedStrings #-}

module Main (main) where

import Control.Concurrent (forkIO)
import Control.Concurrent.STM
import Control.Monad (when)
import Control.Monad.Trans (liftIO)
import Network.HTTP.Types
import Network.Wai as Wai

NathanHowell

{-# LANGUAGE FlexibleContexts #-}

import Control.Monad.Base
import Control.Monad.Trans.Control
import Control.Concurrent.MSem as MSem

withMSem :: (MonadBaseControl IO m, Integral i) => MSem i -> m a -> m a
withMSem = liftBaseOp_ . MSem.with

NathanHowell

{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE StandaloneDeriving #-}

NathanHowell

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE TypeOperators #-}

import Data.Proxy
import GHC.Generics

NathanHowell

import Control.Concurrent
import System.IO

t :: ThreadId -> IO ()
t tid = print ("mah thread", tid)

main :: IO ()
main = do
  _tid <- fixIO (forkIO . t)
  threadDelay 100000000

NathanHowell

#include <Cmm.h>

getInfoTable (P_ a)
{
  W_ clos, info, type;
  clos = UNTAG(a);
  info = %GET_STD_INFO(clos);
  return (info);
}