interpolate-0.1.0/0000755000000000000000000000000012412201673012222 5ustar0000000000000000interpolate-0.1.0/LICENSE0000644000000000000000000000206212412201673013227 0ustar0000000000000000Copyright (c) 2013 Simon Hengel Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. interpolate-0.1.0/interpolate.cabal0000644000000000000000000000234212412201673015535 0ustar0000000000000000name: interpolate version: 0.1.0 license: MIT license-file: LICENSE copyright: (c) 2013 Simon Hengel author: Simon Hengel maintainer: Simon Hengel build-type: Simple cabal-version: >= 1.8 category: Data, Text stability: experimental synopsis: String interpolation done right description: String interpolation done right source-repository head type: git location: https://github.com/sol/interpolate library ghc-options: -Wall hs-source-dirs: src exposed-modules: Data.String.Interpolate Data.String.Interpolate.IsString Data.String.Interpolate.Util other-modules: Data.String.Interpolate.Internal.Util Data.String.Interpolate.Parse Data.String.Interpolate.Compat build-depends: base == 4.* , template-haskell , haskell-src-meta test-suite spec type: exitcode-stdio-1.0 ghc-options: -Wall hs-source-dirs: src, test main-is: Spec.hs build-depends: base == 4.* , template-haskell , haskell-src-meta , text , bytestring , hspec >= 1.5 , QuickCheck , quickcheck-instances interpolate-0.1.0/Setup.lhs0000644000000000000000000000011412412201673014026 0ustar0000000000000000#!/usr/bin/env runhaskell > import Distribution.Simple > main = defaultMain interpolate-0.1.0/test/0000755000000000000000000000000012412201673013201 5ustar0000000000000000interpolate-0.1.0/test/Spec.hs0000644000000000000000000000005412412201673014426 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-} interpolate-0.1.0/src/0000755000000000000000000000000012412201673013011 5ustar0000000000000000interpolate-0.1.0/src/Data/0000755000000000000000000000000012412201673013662 5ustar0000000000000000interpolate-0.1.0/src/Data/String/0000755000000000000000000000000012412201673015130 5ustar0000000000000000interpolate-0.1.0/src/Data/String/Interpolate.hs0000644000000000000000000000353012412201673017753 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} module Data.String.Interpolate ( -- * String interpolation done right -- | -- The examples in this module use `QuasiQuotes`. Make sure to enable the -- corresponding language extension. -- -- >>> :set -XQuasiQuotes -- >>> import Data.String.Interpolate i ) where import Language.Haskell.TH.Quote (QuasiQuoter(..)) import Language.Haskell.Meta.Parse.Careful (parseExp) import Data.String.Interpolate.Internal.Util import Data.String.Interpolate.Parse import Data.String.Interpolate.Compat (Q, Exp, appE, reportError) -- | -- A `QuasiQuoter` for string interpolation. Expression enclosed within -- @#{...}@ are interpolated, the result has to be in the `Show` class. -- -- It interpolates strings -- -- >>> let name = "Marvin" -- >>> putStrLn [i|name: #{name}|] -- name: Marvin -- -- or integers -- -- >>> let age = 23 -- >>> putStrLn [i|age: #{age}|] -- age: 23 -- -- or arbitrary Haskell expressions -- -- >>> let profession = "\955-scientist" -- >>> putStrLn [i|profession: #{unwords [name, "the", profession]}|] -- profession: Marvin the λ-scientist i :: QuasiQuoter i = QuasiQuoter { quoteExp = toExp . parseNodes , quotePat = err "pattern" , quoteType = err "type" , quoteDec = err "declaration" } where err name = error ("Data.String.Interpolate.i: This QuasiQuoter can not be used as a " ++ name ++ "!") toExp:: [Node] -> Q Exp toExp nodes = case nodes of [] -> [|""|] (x:xs) -> f x `appE` toExp xs where f (Literal s) = [|showString s|] f (Expression e) = [|(showString . toString) $(reifyExpression e)|] reifyExpression :: String -> Q Exp reifyExpression s = case parseExp s of Left _ -> do reportError "Parse error in expression!" [|""|] Right e -> return e interpolate-0.1.0/src/Data/String/Interpolate/0000755000000000000000000000000012412201673017416 5ustar0000000000000000interpolate-0.1.0/src/Data/String/Interpolate/Compat.hs0000644000000000000000000000221012412201673021170 0ustar0000000000000000{-# LANGUAGE CPP #-} module Data.String.Interpolate.Compat ( readMaybe , module Language.Haskell.TH #if !MIN_VERSION_template_haskell(2,8,0) , reportError #endif ) where import Language.Haskell.TH import Text.Read #if !MIN_VERSION_base(4,6,0) import qualified Text.ParserCombinators.ReadP as P #endif #if !MIN_VERSION_base(4,6,0) -- | Parse a string using the 'Read' instance. -- Succeeds if there is exactly one valid result. -- A 'Left' value indicates a parse error. readEither :: Read a => String -> Either String a readEither s = case [ x | (x,"") <- readPrec_to_S read' minPrec s ] of [x] -> Right x [] -> Left "Prelude.read: no parse" _ -> Left "Prelude.read: ambiguous parse" where read' = do x <- readPrec lift P.skipSpaces return x -- | Parse a string using the 'Read' instance. -- Succeeds if there is exactly one valid result. readMaybe :: Read a => String -> Maybe a readMaybe s = case readEither s of Left _ -> Nothing Right a -> Just a #endif #if !MIN_VERSION_template_haskell(2,8,0) reportError :: String -> Q () reportError = report True #endif interpolate-0.1.0/src/Data/String/Interpolate/IsString.hs0000644000000000000000000000113412412201673021513 0ustar0000000000000000{-# LANGUAGE TemplateHaskell #-} module Data.String.Interpolate.IsString (i) where import Data.String import Language.Haskell.TH.Quote (QuasiQuoter(..)) import qualified Data.String.Interpolate as I -- | -- Like `I.i`, but constructs a value of type -- -- > IsString a => a i :: QuasiQuoter i = QuasiQuoter { quoteExp = \s -> [|fromString $(quoteExp I.i $ s)|] , quotePat = err "pattern" , quoteType = err "type" , quoteDec = err "declaration" } where err name = error ("Data.String.Interpolate.IsString.i: This QuasiQuoter can not be used as a " ++ name ++ "!") interpolate-0.1.0/src/Data/String/Interpolate/Util.hs0000644000000000000000000000436712412201673020701 0ustar0000000000000000module Data.String.Interpolate.Util (unindent) where import Control.Arrow ((>>>)) import Data.Char -- | Remove indentation as much as possible while preserving relative -- indentation levels. -- -- `unindent` is useful in combination with `Data.String.Interpolate.i` to remove leading spaces that -- resulted from code indentation. That way you can freely indent your string -- literals without the indentation ending up in the resulting strings. -- -- Here is an example: -- -- >>> :set -XQuasiQuotes -- >>> import Data.String.Interpolate -- >>> import Data.String.Interpolate.Util -- >>> :{ -- putStr $ unindent [i| -- def foo -- 23 -- end -- |] -- :} -- def foo -- 23 -- end -- -- To allow this, two additional things are being done, apart from removing -- indentation: -- -- - One empty line at the beginning will be removed and -- - if the last newline character (@"\\n"@) is followed by spaces, the spaces are removed. unindent :: String -> String unindent = lines_ >>> removeLeadingEmptyLine >>> trimLastLine >>> removeIndentation >>> concat where isEmptyLine :: String -> Bool isEmptyLine = all isSpace lines_ :: String -> [String] lines_ [] = [] lines_ s = case span (/= '\n') s of (first, '\n' : rest) -> (first ++ "\n") : lines_ rest (first, rest) -> first : lines_ rest removeLeadingEmptyLine :: [String] -> [String] removeLeadingEmptyLine xs = case xs of y:ys | isEmptyLine y -> ys _ -> xs trimLastLine :: [String] -> [String] trimLastLine (a : b : r) = a : trimLastLine (b : r) trimLastLine [a] = if all (== ' ') a then [] else [a] trimLastLine [] = [] removeIndentation :: [String] -> [String] removeIndentation ys = map (dropSpaces indentation) ys where dropSpaces 0 s = s dropSpaces n (' ' : r) = dropSpaces (n - 1) r dropSpaces _ s = s indentation = minimalIndentation ys minimalIndentation = safeMinimum 0 . map (length . takeWhile (== ' ')) . removeEmptyLines removeEmptyLines = filter (not . isEmptyLine) safeMinimum :: Ord a => a -> [a] -> a safeMinimum x xs = case xs of [] -> x _ -> minimum xs interpolate-0.1.0/src/Data/String/Interpolate/Parse.hs0000644000000000000000000000112312412201673021021 0ustar0000000000000000module Data.String.Interpolate.Parse where import Data.String.Interpolate.Internal.Util data Node = Literal String | Expression String parseNodes :: String -> [Node] parseNodes = go "" where go :: String -> String -> [Node] go acc input = case input of "" -> [(lit . reverse) acc] '\\':x:xs -> go (x:'\\':acc) xs '#':'{':xs -> case span (/= '}') xs of (ys, _:zs) -> (lit . reverse) acc : Expression ys : go "" zs (_, "") -> [lit (reverse acc ++ input)] x:xs -> go (x:acc) xs lit :: String -> Node lit = Literal . unescape interpolate-0.1.0/src/Data/String/Interpolate/Internal/0000755000000000000000000000000012412201673021172 5ustar0000000000000000interpolate-0.1.0/src/Data/String/Interpolate/Internal/Util.hs0000644000000000000000000001057512412201673022453 0ustar0000000000000000module Data.String.Interpolate.Internal.Util where import Data.Char import Data.Maybe import qualified Numeric as N import Data.String.Interpolate.Compat toString :: Show a => a -> String toString a = let s = show a in fromMaybe s (readMaybe s) {-# NOINLINE toString #-} {-# RULES "toString/String" toString = id #-} {-# RULES "toString/Int" toString = show :: Int -> String #-} {-# RULES "toString/Integer" toString = show :: Integer -> String #-} {-# RULES "toString/Float" toString = show :: Float -> String #-} {-# RULES "toString/Double" toString = show :: Double -> String #-} -- Haskell 2010 character unescaping, see: -- http://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-200002.6 unescape :: String -> String unescape = go where go input = case input of "" -> "" '\\' : 'x' : x : xs | isHexDigit x -> case span isHexDigit xs of (ys, zs) -> (chr . readHex $ x:ys) : go zs '\\' : 'o' : x : xs | isOctDigit x -> case span isOctDigit xs of (ys, zs) -> (chr . readOct $ x:ys) : go zs '\\' : x : xs | isDigit x -> case span isDigit xs of (ys, zs) -> (chr . read $ x:ys) : go zs '\\' : input_ -> case input_ of '\\' : xs -> '\\' : go xs 'a' : xs -> '\a' : go xs 'b' : xs -> '\b' : go xs 'f' : xs -> '\f' : go xs 'n' : xs -> '\n' : go xs 'r' : xs -> '\r' : go xs 't' : xs -> '\t' : go xs 'v' : xs -> '\v' : go xs '&' : xs -> go xs 'N':'U':'L' : xs -> '\NUL' : go xs 'S':'O':'H' : xs -> '\SOH' : go xs 'S':'T':'X' : xs -> '\STX' : go xs 'E':'T':'X' : xs -> '\ETX' : go xs 'E':'O':'T' : xs -> '\EOT' : go xs 'E':'N':'Q' : xs -> '\ENQ' : go xs 'A':'C':'K' : xs -> '\ACK' : go xs 'B':'E':'L' : xs -> '\BEL' : go xs 'B':'S' : xs -> '\BS' : go xs 'H':'T' : xs -> '\HT' : go xs 'L':'F' : xs -> '\LF' : go xs 'V':'T' : xs -> '\VT' : go xs 'F':'F' : xs -> '\FF' : go xs 'C':'R' : xs -> '\CR' : go xs 'S':'O' : xs -> '\SO' : go xs 'S':'I' : xs -> '\SI' : go xs 'D':'L':'E' : xs -> '\DLE' : go xs 'D':'C':'1' : xs -> '\DC1' : go xs 'D':'C':'2' : xs -> '\DC2' : go xs 'D':'C':'3' : xs -> '\DC3' : go xs 'D':'C':'4' : xs -> '\DC4' : go xs 'N':'A':'K' : xs -> '\NAK' : go xs 'S':'Y':'N' : xs -> '\SYN' : go xs 'E':'T':'B' : xs -> '\ETB' : go xs 'C':'A':'N' : xs -> '\CAN' : go xs 'E':'M' : xs -> '\EM' : go xs 'S':'U':'B' : xs -> '\SUB' : go xs 'E':'S':'C' : xs -> '\ESC' : go xs 'F':'S' : xs -> '\FS' : go xs 'G':'S' : xs -> '\GS' : go xs 'R':'S' : xs -> '\RS' : go xs 'U':'S' : xs -> '\US' : go xs 'S':'P' : xs -> '\SP' : go xs 'D':'E':'L' : xs -> '\DEL' : go xs '^':'@' : xs -> '\^@' : go xs '^':'A' : xs -> '\^A' : go xs '^':'B' : xs -> '\^B' : go xs '^':'C' : xs -> '\^C' : go xs '^':'D' : xs -> '\^D' : go xs '^':'E' : xs -> '\^E' : go xs '^':'F' : xs -> '\^F' : go xs '^':'G' : xs -> '\^G' : go xs '^':'H' : xs -> '\^H' : go xs '^':'I' : xs -> '\^I' : go xs '^':'J' : xs -> '\^J' : go xs '^':'K' : xs -> '\^K' : go xs '^':'L' : xs -> '\^L' : go xs '^':'M' : xs -> '\^M' : go xs '^':'N' : xs -> '\^N' : go xs '^':'O' : xs -> '\^O' : go xs '^':'P' : xs -> '\^P' : go xs '^':'Q' : xs -> '\^Q' : go xs '^':'R' : xs -> '\^R' : go xs '^':'S' : xs -> '\^S' : go xs '^':'T' : xs -> '\^T' : go xs '^':'U' : xs -> '\^U' : go xs '^':'V' : xs -> '\^V' : go xs '^':'W' : xs -> '\^W' : go xs '^':'X' : xs -> '\^X' : go xs '^':'Y' : xs -> '\^Y' : go xs '^':'Z' : xs -> '\^Z' : go xs '^':'[' : xs -> '\^[' : go xs '^':'\\' : xs -> '\^\' : go xs '^':']' : xs -> '\^]' : go xs '^':'^' : xs -> '\^^' : go xs '^':'_' : xs -> '\^_' : go xs xs -> go xs x:xs -> x : go xs readHex :: String -> Int readHex xs = case N.readHex xs of [(n, "")] -> n _ -> error "Data.String.Interpolate.Util.readHex: no parse" readOct :: String -> Int readOct xs = case N.readOct xs of [(n, "")] -> n _ -> error "Data.String.Interpolate.Util.readHex: no parse"