diff --git a/neat-interpolation.cabal b/neat-interpolation.cabal --- a/neat-interpolation.cabal +++ b/neat-interpolation.cabal @@ -1,30 +1,133 @@ -name: neat-interpolation -version: 0.1.1 -cabal-version: >=1.8 -build-type: Simple -license: MIT -license-file: LICENSE -copyright: (c) 2013, Nikita Volkov -author: Nikita Volkov -maintainer: Nikita Volkov -stability: experimental -homepage: https://github.com/nikita-volkov/neat-interpolation -bug-reports: https://github.com/nikita-volkov/neat-interpolation/issues -synopsis: A quasiquoter for neat and simple multiline text interpolation -description: NeatInterpolation provides a quasiquoter for producing `Text` data with a simple interpolation of input values. It removes the excessive indentation from the input text and accurately manages the indentation of all lines of interpolated variables. -category: Text, String, QuasiQoutes +name: + neat-interpolation +version: + 0.2.0 +synopsis: + A quasiquoter for neat and simple multiline text interpolation +description: + NeatInterpolation provides a quasiquoter for producing strings + with a simple interpolation of input values. + It removes the excessive indentation from the input and + accurately manages the indentation of all lines of interpolated variables. +category: + String, QuasiQoutes +license: + MIT +license-file: + LICENSE +copyright: + (c) 2013, Nikita Volkov +author: + Nikita Volkov +maintainer: + Nikita Volkov +homepage: + https://github.com/nikita-volkov/neat-interpolation +bug-reports: + https://github.com/nikita-volkov/neat-interpolation/issues +build-type: + Simple +cabal-version: + >=1.10 -library - hs-source-dirs: src - extensions: PatternGuards - exposed-modules: NeatInterpolation - other-modules: NeatInterpolation.Parsing - NeatInterpolation.String - build-depends: base >= 4.5 && < 5, - classy-prelude >= 0.5.3, - template-haskell, - parsec source-repository head - type: git - location: git://github.com/nikita-volkov/neat-interpolation.git + type: + git + location: + git://github.com/nikita-volkov/neat-interpolation.git + + +library + hs-source-dirs: + src + exposed-modules: + NeatInterpolation + other-modules: + NeatInterpolation.Prelude + NeatInterpolation.Parsing + NeatInterpolation.String + build-depends: + parsec, + template-haskell, + base >= 4.5 && < 5 + default-extensions: + NoImplicitPrelude + PatternGuards + MultiWayIf + LambdaCase + Arrows + MultiParamTypeClasses + NoMonomorphismRestriction + FlexibleInstances + FlexibleContexts + GADTs + EmptyDataDecls + StandaloneDeriving + ConstraintKinds + RankNTypes + TypeFamilies + TypeOperators + DataKinds + ImpredicativeTypes + LiberalTypeSynonyms + OverloadedStrings + TemplateHaskell + QuasiQuotes + GeneralizedNewtypeDeriving + DeriveDataTypeable + DeriveGeneric + DefaultSignatures + ScopedTypeVariables + BangPatterns + RecordWildCards + TupleSections + default-language: + Haskell2010 + + +executable neat-interpolation-demo + hs-source-dirs: + src + main-is: + Demo.hs + ghc-options: + -threaded + "-with-rtsopts=-N" + build-depends: + parsec, + template-haskell, + base >= 4.5 && < 5 + default-extensions: + NoImplicitPrelude + PatternGuards + MultiWayIf + LambdaCase + Arrows + MultiParamTypeClasses + NoMonomorphismRestriction + FlexibleInstances + FlexibleContexts + GADTs + EmptyDataDecls + StandaloneDeriving + ConstraintKinds + RankNTypes + TypeFamilies + TypeOperators + DataKinds + ImpredicativeTypes + LiberalTypeSynonyms + OverloadedStrings + TemplateHaskell + QuasiQuotes + GeneralizedNewtypeDeriving + DeriveDataTypeable + DeriveGeneric + DefaultSignatures + ScopedTypeVariables + BangPatterns + RecordWildCards + TupleSections + default-language: + Haskell2010 diff --git a/src/Demo.hs b/src/Demo.hs new file mode 100644 --- /dev/null +++ b/src/Demo.hs @@ -0,0 +1,26 @@ + +import NeatInterpolation.Prelude +import NeatInterpolation + +main = do + let a' = [string| + function startsWith( start, string ){ + return string.lastIndexOf( start ) == 0 + } + |] + let pattern = [string| { + + + $a' + + single inlining: ( $a' ) + + + { + multiple inlining: ( $a' ) ( $a' ) + } + + + } + |] + putStrLn pattern diff --git a/src/NeatInterpolation.hs b/src/NeatInterpolation.hs --- a/src/NeatInterpolation.hs +++ b/src/NeatInterpolation.hs @@ -1,20 +1,20 @@ -{-# LANGUAGE QuasiQuotes, TemplateHaskell, DeriveDataTypeable, OverloadedStrings #-} {-# OPTIONS_GHC -fno-warn-missing-fields #-} --- | NeatInterpolation provides a quasiquoter for producing `Text` data with a --- simple interpolation of input values. It removes the excessive indentation --- from the input text and accurately manages the indentation of all lines of --- interpolated variables. But enough words, the code shows it better. +-- | +-- NeatInterpolation provides a quasiquoter for producing strings +-- with a simple interpolation of input values. +-- It removes the excessive indentation from the input and +-- accurately manages the indentation of all lines of interpolated variables. +-- But enough words, the code shows it better. -- -- Consider the following declaration: -- -- > {-# LANGUAGE QuasiQuotes, OverloadedStrings #-} -- > -- > import NeatInterpolation --- > import qualified Data.Text.IO as Text -- > --- > f :: Text -> Text -> Text +-- > f :: String -> String -> String -- > f a b = --- > [text| +-- > [string| -- > function(){ -- > function(){ -- > $a @@ -25,7 +25,7 @@ -- -- Executing the following: -- --- > main = Text.putStrLn $ f "1" "2" +-- > main = putStrLn $ f "1" "2" -- -- will produce this (notice the reduced indentation compared to how it was -- declared): @@ -37,9 +37,9 @@ -- > return 2 -- > } -- --- Now let's test it with multiline text parameters: +-- Now let's test it with multiline string parameters: -- --- > main = Text.putStrLn $ f +-- > main = putStrLn $ f -- > "{\n indented line\n indented line\n}" -- > "{\n indented line\n indented line\n}" -- @@ -60,10 +60,9 @@ -- -- See how it neatly preserved the indentation levels of lines the -- variable placeholders were at? -module NeatInterpolation (text, indentQQPlaceholder) where +module NeatInterpolation (string, indentQQPlaceholder) where -import Prelude () -import ClassyPrelude +import NeatInterpolation.Prelude import Language.Haskell.TH import Language.Haskell.TH.Quote @@ -72,24 +71,27 @@ import NeatInterpolation.Parsing - -text :: QuasiQuoter -text = QuasiQuoter {quoteExp = quoteExprExp} +-- | +-- The quasiquoter. +string :: QuasiQuoter +string = QuasiQuoter {quoteExp = quoteExprExp} -indentQQPlaceholder :: Int -> Text -> Text +-- | +-- A function used internally by quasiquoter. Just ignore it. +indentQQPlaceholder :: Int -> String -> String indentQQPlaceholder indent text = case lines text of - head:tail -> intercalate "\n" $ head : map (replicate indent " " ++) tail + head:tail -> intercalate "\n" $ head : map (replicate indent ' ' ++) tail [] -> text -quoteExprExp :: [Char] -> Q Exp +quoteExprExp :: String -> Q Exp quoteExprExp input = case parseLines $ normalizeQQInput input of Left e -> fail $ show e Right lines -> appE [|unlines|] $ linesExp lines linesExp :: [Line] -> Q Exp -linesExp [] = [|([] :: [Text])|] +linesExp [] = [|([] :: [String])|] linesExp (head : tail) = (binaryOpE [|(:)|]) (lineExp head) @@ -114,7 +116,7 @@ Nothing -> fail $ "Value `" ++ name ++ "` is not in scope" msumExps :: [Q Exp] -> Q Exp -msumExps = fold (binaryOpE mappendE) memptyE +msumExps = foldr (binaryOpE mappendE) memptyE memptyE = [|mempty|] mappendE = [|mappend|] diff --git a/src/NeatInterpolation/Parsing.hs b/src/NeatInterpolation/Parsing.hs --- a/src/NeatInterpolation/Parsing.hs +++ b/src/NeatInterpolation/Parsing.hs @@ -1,9 +1,8 @@ -{-# LANGUAGE NoMonomorphismRestriction #-} module NeatInterpolation.Parsing where -import Prelude () -import ClassyPrelude hiding (try, (<|>)) +import NeatInterpolation.Prelude hiding (try, (<|>), many) import Text.Parsec hiding (Line) +-- import qualified Data.Attoparsec.Text as AP data Line = Line {lineIndent :: Int, lineContents :: [LineContent]} diff --git a/src/NeatInterpolation/Prelude.hs b/src/NeatInterpolation/Prelude.hs new file mode 100644 --- /dev/null +++ b/src/NeatInterpolation/Prelude.hs @@ -0,0 +1,52 @@ +module NeatInterpolation.Prelude + ( + module Exports, + (?:), + traceM, + ) + where + +-- base +import Prelude as Exports hiding (concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, FilePath, id, (.)) +import Control.Monad as Exports hiding (mapM_, sequence_, forM_, msum, mapM, sequence, forM) +import Control.Applicative as Exports +import Control.Arrow as Exports hiding (left, right) +import Control.Category as Exports +import Data.Monoid as Exports +import Data.Foldable as Exports +import Data.Traversable as Exports hiding (for) +import Data.Maybe as Exports +import Data.List as Exports hiding (concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl') +import Data.Tuple as Exports +import Data.Ord as Exports (Down(..)) +import Data.String as Exports +import Data.Int as Exports +import Data.Word as Exports +import Data.Ratio as Exports +import Data.Fixed as Exports +import Data.Ix as Exports +import Data.Data as Exports +import Text.Read as Exports (readMaybe, readEither) +import Control.Exception as Exports hiding (tryJust) +import Control.Concurrent as Exports hiding (yield) +import System.Timeout as Exports +import System.Exit as Exports +import System.IO.Unsafe as Exports +import System.IO as Exports (Handle, hClose) +import System.IO.Error as Exports +import Unsafe.Coerce as Exports +import GHC.Exts as Exports (groupWith, sortWith) +import GHC.Generics as Exports (Generic) +import GHC.IO.Exception as Exports +import Debug.Trace as Exports +import Data.IORef as Exports +import Data.STRef as Exports +import Control.Monad.ST as Exports + + +(?:) :: Maybe a -> a -> a +maybeA ?: b = fromMaybe b maybeA +{-# INLINE (?:) #-} + +traceM :: (Monad m) => String -> m () +traceM s = trace s $ return () diff --git a/src/NeatInterpolation/String.hs b/src/NeatInterpolation/String.hs --- a/src/NeatInterpolation/String.hs +++ b/src/NeatInterpolation/String.hs @@ -1,10 +1,7 @@ -{-# LANGUAGE OverloadedStrings, NoMonomorphismRestriction #-} module NeatInterpolation.String where -import Prelude () -import ClassyPrelude +import NeatInterpolation.Prelude import Data.Char -import Data.Foldable (foldr) normalizeQQInput :: [Char] -> [Char]