diff --git a/EXAMPLES b/EXAMPLES
new file mode 100644
--- /dev/null
+++ b/EXAMPLES
@@ -0,0 +1,35 @@
+regexqq - EXAMPLES
+----------------------------------------------------------------------------------------
+
+-- Here is a pasteable-into-ghci version of the below:
+
+:m + Text.Regex.PCRE.QQ
+[$rx|([aeiou]).*(er|ing|tion)([\.,!\?]*)$|] "helloing.!?!?!"
+[$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+tail `fmap` [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+return . tail =<< [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+maybe [] tail $ [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+maybe [] tail $ [$rx|^([+-])?([0-9]+)\.([0-9]+)(.*)$|] (show (negate pi) ++ "asdx")
+
+----------------------------------------------------------------------------------------
+
+ghci> :m + Text.Regex.PCRE.QQ
+
+ghci> [$rx|([aeiou]).*(er|ing|tion)([\.,!\?]*)$|] "helloing.!?!?!"
+Just ["elloing.!?!?!","e","ing",".!?!?!"]
+
+ghci> [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+Just ["-3.141592653589793","-","3","141592653589793"]
+
+ghci> tail `fmap` [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+Just ["-","3","141592653589793"]
+ghci> return . tail =<< [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+Just ["-","3","141592653589793"]
+
+ghci> maybe [] tail $ [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+["-","3","141592653589793"]
+
+ghci> maybe [] tail $ [$rx|^([+-])?([0-9]+)\.([0-9]+)(.*)$|] (show (negate pi) ++ "asdx")
+["-","3","141592653589793","asdx"]
+
+----------------------------------------------------------------------------------------
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,26 @@
+Copyright (c) Matt Morrow.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+3. The names of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
+ permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
diff --git a/QQ.html b/QQ.html
new file mode 100644
--- /dev/null
+++ b/QQ.html
@@ -0,0 +1,144 @@
+
+
+
{-# LANGUAGE TemplateHaskell, QuasiQuotes #-}
+
+{-|
+ Module : Text.Regex.PCRE.QQ
+ Copyright : (c) Matt Morrow 2008
+ License : BSD3
+
+ Maintainer : mjm2002@gmail.com
+ Stability : unstable
+ Portability : non-portable (GHC QuasiQuotes)
+
+ A quasiquoter for Text.Regex.PCRE regexes.
+ This makes use of a new GHC extension known as QuasiQuotes.
+ See the README for the temporary location of the docs for
+ Language.Haskell.TH.Quote. See the EXAMPLES file for examples.
+
+ > ghci> [$rx|([aeiou]).*(er|ing|tion)([\.,\?]*)$|] "helloing.!?!?!"
+ > Just ["elloing.!?!?!","e","ing",".!?!?!"]
+-}
+
+module Text.Regex.PCRE.QQ (
+ rx -- the regex QuasiQuoter
+ , regexToExpQ -- String -> ExpQ
+ , regexToPatQ -- String -> PatQ
+
+ -- should these be being exported here??
+ , module Language.Haskell.TH.Quote
+ , module Language.Haskell.TH.Syntax
+ , module Language.Haskell.TH.Lib
+ , module Language.Haskell.TH.Ppr
+) where
+
+import Language.Haskell.TH.Quote
+import Language.Haskell.TH.Syntax
+import Language.Haskell.TH.Lib
+ hiding (match)
+import Language.Haskell.TH.Ppr
+import Text.Regex.PCRE.Light
+ (Regex,PCREOption,PCREExecOption)
+importqualified
+ Text.Regex.PCRE.Light as PCRE
+import Data.ByteString (ByteString)
+importqualified Data.ByteString as B
+import Data.ByteString.Internal (c2w,w2c)
+
+-----------------------------------------------------------------------------
+
+{- data QuasiQuoter
+ = QuasiQuoter { quoteExp :: String -> Q Exp,
+ quotePat :: String -> Q Pat}
+ -- Defined in Language.Haskell.TH.Quote -}
+
+{- |
+> ghci> maybe [] tail $ [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+> ["-","3","141592653589793"]
+-}
+rx :: QuasiQuoter
+rx = QuasiQuoter
+ regexToExpQ
+ regexToPatQ
+
+-- | Transform a string rep
+-- of a regex to an ExpQ. The
+-- resulting ExpQ, when spliced,
+-- results in a function of type
+-- @String -> Maybe [String]@,
+-- where the input is the String
+-- to match on. The result is
+-- Nothing on error, and Just
+-- a list of results on success.
+-- Note: I'm packing\/unpacking\/...
+-- the ByteString unnecessarily
+-- for convenience in testing
+-- out the first go at this.
+-- This will be dealt with in
+-- the future.
+regexToExpQ :: String -> ExpQ
+regexToExpQ s = case PCRE.compileM (pack s) pcreOpts of
+ Left err -> error err
+ -- Give an error at compile time
+ -- if the regex string is invalid
+ Right _ -> [|
+ (return . fmap unpack =<<)
+ . match (regex s) . pack
+ |]
+
+-- | Transform a string (presumably)
+-- containing a regex to a PatQ.
+-- NOTE: Given a regex, a pattern
+-- is constructed which matches
+-- a literal string containing
+-- the verbatim regex. It does
+-- this because I couldn't think
+-- of anything better for it to
+-- do off the cuff. This needs
+-- thought.
+regexToPatQ :: String -> PatQ
+regexToPatQ =
+ litP . stringL
+ . dropWhile (/='"')
+ . show . regex
+
+-- | Regex compilation. Temporarily uses
+-- hardcoded options @extended@ and
+-- @multiline@.
+regex :: String -> Regex
+regex = flip PCRE.compile pcreOpts . pack
+
+-- | Regex matching.
+match :: Regex -> B.ByteString -> Maybe [B.ByteString]
+match rx = flip (PCRE.match rx) pcreExecOpts
+
+-- | Adjust these to your tastes. An
+-- interface to options seems to be
+-- the next logical (and practical)
+-- step.
+pcreOpts :: [PCREOption]
+pcreOpts =
+ [ PCRE.extended
+ , PCRE.multiline ]
+ -- , dotall, caseless, utf8
+ -- , newline_any, PCRE.newline_crlf ]
+
+-- | Adjust these to your tastes. An
+-- interface to options seems to be
+-- the next logical (and practical)
+-- step.
+pcreExecOpts :: [PCREExecOption]
+pcreExecOpts = []
+ -- [ PCRE.exec_newline_crlf
+ -- , exec_newline_any, PCRE.exec_notempty
+ -- , PCRE.exec_notbol, PCRE.exec_noteol ]
+
+pack :: String -> ByteString
+pack = B.pack . fmap c2w
+
+unpack :: ByteString -> String
+unpack = fmap w2c . B.unpack
+
+-----------------------------------------------------------------------------
+
+
diff --git a/README b/README
new file mode 100644
--- /dev/null
+++ b/README
@@ -0,0 +1,14 @@
+regexqq - Matt Morrow, 2008.
+
+The current (as of 080623) location of the
+current template-haskell docs are temporarily
+(until they're located in the standard place)
+available at:
+
+http://code.haskell.org/~morrow/code/haskell/misc/template-haskell-HEAD_080623/
+
+An example:
+
+ghci> :m + Text.Regex.PCRE.QQ
+ghci> [$rx|([aeiou]).*(er|ing|tion)([\.,!\?]*)$|] "helloing.!?!?!"
+Just ["elloing.!?!?!","e","ing",".!?!?!"]
diff --git a/README.ghc-6.8 b/README.ghc-6.8
new file mode 100644
--- /dev/null
+++ b/README.ghc-6.8
@@ -0,0 +1,13 @@
+ghc-6.8.* doesn't yet support QuasiQuotes.
+
+BUT, there is a patched ghc-6.8.3 that *does*
+support QuasiQuotes at:
+
+http://code.haskell.org/~morrow/quasiquotes/ghc-6.8.3_QQ-0.1.tar.bz2
+
+NOTE:
+ ghc-6.8.3_QQ-0.1.tar.bz2 *already*
+ has the extralibs included.
+
+If you are unwilling/unable to use ghc-6.9, then building
+ghc-6.8.3_QQ-0.1 is the only option.
diff --git a/Setup.lhs b/Setup.lhs
new file mode 100644
--- /dev/null
+++ b/Setup.lhs
@@ -0,0 +1,4 @@
+> import Distribution.Simple
+> main :: IO ()
+> main = defaultMain
+
diff --git a/Text/Regex/PCRE/QQ.hs b/Text/Regex/PCRE/QQ.hs
new file mode 100644
--- /dev/null
+++ b/Text/Regex/PCRE/QQ.hs
@@ -0,0 +1,140 @@
+{-# LANGUAGE TemplateHaskell, QuasiQuotes #-}
+
+{-|
+ Module : Text.Regex.PCRE.QQ
+ Copyright : (c) Matt Morrow 2008
+ License : BSD3
+
+ Maintainer : mjm2002@gmail.com
+ Stability : unstable
+ Portability : non-portable (GHC QuasiQuotes)
+
+ A quasiquoter for Text.Regex.PCRE regexes.
+ This makes use of a new GHC extension known as QuasiQuotes.
+ See the README for the temporary location of the docs for
+ Language.Haskell.TH.Quote. See the EXAMPLES file for examples.
+
+ > ghci> [$rx|([aeiou]).*(er|ing|tion)([\.,\?]*)$|] "helloing.!?!?!"
+ > Just ["elloing.!?!?!","e","ing",".!?!?!"]
+-}
+
+module Text.Regex.PCRE.QQ (
+ rx -- the regex QuasiQuoter
+ , regexToExpQ -- String -> ExpQ
+ , regexToPatQ -- String -> PatQ
+
+ -- should these be being exported here??
+ , module Language.Haskell.TH.Quote
+ , module Language.Haskell.TH.Syntax
+ , module Language.Haskell.TH.Lib
+ , module Language.Haskell.TH.Ppr
+) where
+
+import Language.Haskell.TH.Quote
+import Language.Haskell.TH.Syntax
+import Language.Haskell.TH.Lib
+ hiding (match)
+import Language.Haskell.TH.Ppr
+import Text.Regex.PCRE.Light
+ (Regex,PCREOption,PCREExecOption)
+import qualified
+ Text.Regex.PCRE.Light as PCRE
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as B
+import Data.ByteString.Internal (c2w,w2c)
+
+-----------------------------------------------------------------------------
+
+{- data QuasiQuoter
+ = QuasiQuoter { quoteExp :: String -> Q Exp,
+ quotePat :: String -> Q Pat}
+ -- Defined in Language.Haskell.TH.Quote -}
+
+{- |
+> ghci> maybe [] tail $ [$rx|^([+-])?([0-9]+)\.([0-9]+)|] (show $ negate pi)
+> ["-","3","141592653589793"]
+-}
+rx :: QuasiQuoter
+rx = QuasiQuoter
+ regexToExpQ
+ regexToPatQ
+
+-- | Transform a string rep
+-- of a regex to an ExpQ. The
+-- resulting ExpQ, when spliced,
+-- results in a function of type
+-- @String -> Maybe [String]@,
+-- where the input is the String
+-- to match on. The result is
+-- Nothing on error, and Just
+-- a list of results on success.
+-- Note: I'm packing\/unpacking\/...
+-- the ByteString unnecessarily
+-- for convenience in testing
+-- out the first go at this.
+-- This will be dealt with in
+-- the future.
+regexToExpQ :: String -> ExpQ
+regexToExpQ s = case PCRE.compileM (pack s) pcreOpts of
+ Left err -> error err
+ -- Give an error at compile time
+ -- if the regex string is invalid
+ Right _ -> [|
+ (return . fmap unpack =<<)
+ . match (regex s) . pack
+ |]
+
+-- | Transform a string (presumably)
+-- containing a regex to a PatQ.
+-- NOTE: Given a regex, a pattern
+-- is constructed which matches
+-- a literal string containing
+-- the verbatim regex. It does
+-- this because I couldn't think
+-- of anything better for it to
+-- do off the cuff. This needs
+-- thought.
+regexToPatQ :: String -> PatQ
+regexToPatQ =
+ litP . stringL
+ . dropWhile (/='"')
+ . show . regex
+
+-- | Regex compilation. Temporarily uses
+-- hardcoded options @extended@ and
+-- @multiline@.
+regex :: String -> Regex
+regex = flip PCRE.compile pcreOpts . pack
+
+-- | Regex matching.
+match :: Regex -> B.ByteString -> Maybe [B.ByteString]
+match rx = flip (PCRE.match rx) pcreExecOpts
+
+-- | Adjust these to your tastes. An
+-- interface to options seems to be
+-- the next logical (and practical)
+-- step.
+pcreOpts :: [PCREOption]
+pcreOpts =
+ [ PCRE.extended
+ , PCRE.multiline ]
+ -- , dotall, caseless, utf8
+ -- , newline_any, PCRE.newline_crlf ]
+
+-- | Adjust these to your tastes. An
+-- interface to options seems to be
+-- the next logical (and practical)
+-- step.
+pcreExecOpts :: [PCREExecOption]
+pcreExecOpts = []
+ -- [ PCRE.exec_newline_crlf
+ -- , exec_newline_any, PCRE.exec_notempty
+ -- , PCRE.exec_notbol, PCRE.exec_noteol ]
+
+pack :: String -> ByteString
+pack = B.pack . fmap c2w
+
+unpack :: ByteString -> String
+unpack = fmap w2c . B.unpack
+
+-----------------------------------------------------------------------------
diff --git a/docs/Text-Regex-PCRE-QQ.html b/docs/Text-Regex-PCRE-QQ.html
new file mode 100644
--- /dev/null
+++ b/docs/Text-Regex-PCRE-QQ.html
@@ -0,0 +1,235 @@
+
+
+Text.Regex.PCRE.QQ
regexqq-0.1: A quasiquoter for Text.Regex.PCRE regexes.
A quasiquoter for Text.Regex.PCRE regexes.
+ This makes use of a new GHC extension known as QuasiQuotes.
+ See the README for the temporary location of the docs for
+ Language.Haskell.TH.Quote. See the EXAMPLES file for examples.
+
ghci> [$rx|([aeiou]).*(er|ing|tion)([\.,\?]*)$|] "helloing.!?!?!"
+ Just ["elloing.!?!?!","e","ing",".!?!?!"]
+
Transform a string rep
+ of a regex to an ExpQ. The
+ resulting ExpQ, when spliced,
+ results in a function of type
+ String -> Maybe [String],
+ where the input is the String
+ to match on. The result is
+ Nothing on error, and Just
+ a list of results on success.
+ Note: I'm packing/unpacking/...
+ the ByteString unnecessarily
+ for convenience in testing
+ out the first go at this.
+ This will be dealt with in
+ the future.
+
regexToPatQ :: String -> PatQ
Transform a string (presumably)
+ containing a regex to a PatQ.
+ NOTE: Given a regex, a pattern
+ is constructed which matches
+ a literal string containing
+ the verbatim regex. It does
+ this because I couldn't think
+ of anything better for it to
+ do off the cuff. This needs
+ thought.
+
Text