andrewthad

{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE ExistentialQuantification #-}

andrewthad

{-# LANGUAGE MagicHash #-}

import Data.Bits
import GHC.Prim
import GHC.Word
import Text.Printf
import Data.Char (ord)

hasBetween# :: Word# -> Word# -> Word# -> Word#
hasBetween# x m n =

andrewthad

{-# OPTIONS_GHC -O2 -fforce-recomp -ddump-simpl -dsuppress-all -dsuppress-coercions #-}
{-# LANGUAGE BangPatterns #-}                                                      
{-# LANGUAGE MultiWayIf #-}                                                        
                                                                                   
import Data.Bits                                                                   
import qualified Data.Vector.Unboxed as UV                                         
                                                                                   
main :: IO ()                                                                      
main = do                                                                          
  v <- readLn                                                                      

andrewthad

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TemplateHaskell #-}

import Data.Bits
import Data.Vector (Vector)
import qualified Data.Vector.Unboxed as UV
import qualified Data.Vector as V
import qualified Data.List as L
import Test.QuickCheck.All (quickCheckAll)

andrewthad

{-# LANGUAGE MagicHash #-}
{-# LANGUAGE UnboxedTuples #-}
module Example
  ( Stable
  , stabilize
  , destabilize
  ) where

import GHC.Prim
import GHC.ST

andrewthad

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE MagicHash #-}

{-# OPTIONS_GHC -O2 -Wall -threaded -fforce-recomp #-}

import Criterion.Main
import Control.Monad (when)
import Control.Monad.ST.Unsafe (unsafeDupableInterleaveST,unsafeInterleaveST)
import GHC.ST (ST(..))
import GHC.Prim (spark#,seq#)

andrewthad

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE MagicHash #-}

{-# OPTIONS_GHC -O2 -Wall -threaded -fforce-recomp #-}

import Criterion.Main
import Control.Monad (when)
import Control.Parallel.Strategies (runEval,rpar,rseq)
import Control.Concurrent (forkIO)
import Control.Concurrent.MVar (newEmptyMVar,takeMVar,putMVar)

andrewthad

Quantifier	Dependency	Relevance	Visibility	Matchability
∀ (a :: τ ). ...	dep.	irrel.	inv. (unification)	unmatchable
∀ (a :: τ ) → ...	dep.	irrel.	vis.	unmatchable
Π (a :: τ ). ...	dep.	rel.	inv. (unification)	unmatchable
Π (a :: τ ) → ...	dep.	rel.	vis.	unmatchable
τ ⇒ ...	non-dep.	rel.	inv. (solving)	unmatchable
τ → ...	non-dep.	rel.	vis.	unmatchable

andrewthad

{-# language BangPatterns #-}

import Prelude hiding (lookup)
import Data.Primitive

main :: IO ()
main = do
  print $ lookup [17,15,6,999]

data Tree a = Tree (Tree a) a (Tree a)

andrewthad

{-# language PolyKinds #-}
{-# language TypeOperators #-}
{-# language LambdaCase #-}
{-# language BangPatterns #-}
{-# language KindSignatures #-}
{-# language DataKinds #-}
{-# language GADTs #-}
{-# language RankNTypes #-}
{-# language TypeFamilies #-}
{-# language TypeFamilyDependencies #-}