{-# LANGUAGE CPP,QuasiQuotes,TemplateHaskell,DeriveDataTypeable,PatternGuards #-}
{-# OPTIONS_GHC -fno-warn-missing-fields #-} 

-- | This module defines a quasiquoter for interpolated strings. For example:
--
--  @
--  import qualified Data.Text.Lazy as LT
--  let fb x | x \`mod\` 15 == 0 = \"FizzBuzz\" 
--           | x \`mod\` 5 == 0 = \"Buzz\" 
--           | x \`mod\` 3 == 0 = \"Fizz\" 
--           | otherwise = LT.pack (show x)
-- @
--
-- >>> LT.take 85 [str|#x in [1..]:$fb x$|, #|] <> ".. "
-- "1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz, 16, 17, Fizz.. "
--  
--
module Data.String.Interpolation(str,prnt,endline,tab) where
import Language.Haskell.TH as TH
import Language.Haskell.TH.Quote
import Data.Data
import Data.Maybe
import Data.Monoid
import Data.Char
import Data.String
-- import Data.List(intercalate)



quoteExprExp :: String -> TH.ExpQ
-- | Quasiquote 'str' implements multiline strings with interpolation.
--   Interpolating a value into the string is done by 
--   $\<String expression\>$
--   and interpolating anything with instance Show is 
--   $:\<Show expression\>$. Due to pretty deep limitations, the parser
--   is not able to properly deduce associtivity of infix operators,
--   so use lots and lots of parenthesis.
--
--   Repetitive patterns can be made with # symbol: 
--
--  @
--  \#\<pattern\> in \<list\>: \<interpolated string\> (|\<interpolated string\>)\#
--  @
--   
--   Where (|\<interpolated string\>) denotes optional separator for the 
--   elements.
--   
--   Multiline indentation is handled by aligning on smallest un-empty
--   line after the first. Neither pattern matching nor nested #-patterns
--   are supported, however, see example below.
--
--   Normal '\\n' style escaping of special characters
--   is intentionally not supported. Please use $endline$ or $"\n"$ 
--   style instead. 
--
--   As an example, let's plot set of vectors with gnuplot:
--    
--   @
--   plotVecs :: [(String,[Double])] -> String
--   plotVecs vs =  
--       [$str| \#\# Plot multiple vectors
--              plot \#(n,_) in vs:'-' with lines lw 5 title $:n$ |, \#
--              \#d in map snd vs:$singleVec d$$endline$e$endline$\# |]
--   where
--    singleVec n = [$str|\#(e,i) in zip n [1..]: $:i$ $:e$|$endline$\#|]
--   @
--   
--   @
--  *Gnuplotter> plotVecs [(\"A\",[1..5]),(\"B\",[2..6])]
--  \# Plot multiple vectors
--   plot '-' with lines lw 5 title \"A\" , '-' with lines lw 5 title \"B\" 
--    1 1.0
--    2 2.0
--    3 3.0
--    4 4.0
--    5 5.0
--   
--   e
--    1 2.0
--    2 3.0
--    3 4.0
--    4 5.0
--    5 6.0
--   
--   e
--   @
--

-- | Quasiquoter for interpolating strings. Produces values of `(Monoid m, IsString m) => m`
str  :: QuasiQuoter
str :: QuasiQuoter
str  = QuasiQuoter {quoteExp :: String -> Q Exp
quoteExp = String -> Q Exp
quoteExprExp}

-- | Quasiquoter for printing an interpolated String
prnt  :: QuasiQuoter
prnt :: QuasiQuoter
prnt  = QuasiQuoter {quoteExp :: String -> Q Exp
quoteExp = String -> Q Exp
quoteExprPExp}
-- ** Predefined strings

-- | End of the line  
endline :: IsString a => a
endline :: forall a. IsString a => a
endline = String -> a
forall a. IsString a => String -> a
fromString String
"\n"

-- | Tab
tab :: IsString a => a
tab :: forall a. IsString a => a
tab = String -> a
forall a. IsString a => String -> a
fromString String
"\t"


--
quoteExprExp :: String -> Q Exp
quoteExprExp String
s = PieceString -> Q Exp
psToStringE (String -> PieceString
parParse (String -> PieceString) -> String -> PieceString
forall a b. (a -> b) -> a -> b
$ String -> String
norming String
s)

quoteExprPExp :: String -> ExpQ
quoteExprPExp :: String -> Q Exp
quoteExprPExp = Q Exp -> Q Exp -> Q Exp
forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
TH.appE [|putStr|] (Q Exp -> Q Exp) -> (String -> Q Exp) -> String -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Q Exp
quoteExprExp  

--

psToStringE :: PieceString -> TH.Q TH.Exp
psToStringE :: PieceString -> Q Exp
psToStringE [] = [|mempty|] --TH.stringE ""
psToStringE (StringBits
x:PieceString
xs) =  ([| mappend |]) Q Exp -> Q Exp -> Q Exp
forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`TH.appE`
                      (StringBits -> Q Exp
sbitToExp StringBits
x)   Q Exp -> Q Exp -> Q Exp
forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`TH.appE`   
                      (PieceString -> Q Exp
psToStringE PieceString
xs)

runEither :: (Monad m) => [Char] -> Either [Char] t -> m t
runEither :: forall (m :: * -> *) t. Monad m => String -> Either String t -> m t
runEither String
_ (Right t
x) = t -> m t
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return t
x
runEither String
s (Left String
e)  = String -> m t
forall a. HasCallStack => String -> a
error (String -> m t) -> String -> m t
forall a b. (a -> b) -> a -> b
$ String
s String -> String -> String
forall a. [a] -> [a] -> [a]
++String
" : "String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e

appM :: String -> ExpQ
appM :: String -> Q Exp
appM String
expr = Name -> Q Exp
forall (m :: * -> *). Quote m => Name -> m Exp
TH.varE (Name -> Q Exp) -> Name -> Q Exp
forall a b. (a -> b) -> a -> b
$ String -> Name
TH.mkName String
expr

sbitToExp :: StringBits -> ExpQ
sbitToExp :: StringBits -> Q Exp
sbitToExp (Str String
x) =  [| fromString |] Q Exp -> Q Exp -> Q Exp
forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`appE` String -> Q Exp
forall (m :: * -> *). Quote m => String -> m Exp
TH.stringE String
x 
sbitToExp (Var String
x)  =  String -> Q Exp
appM String
x 
sbitToExp (SVar String
x) = Q Exp -> Q Exp -> Q Exp
forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
TH.appE  [| fromString . show |]--(TH.varE (TH.mkName "show"))
                        (StringBits -> Q Exp
sbitToExp (String -> StringBits
Var String
x))

sbitToExp (RepVar String
varName String
lstName PieceString
rep Maybe PieceString
sep) 
    = [|intercalate $(Q Exp
sepr) (map $(Q Exp
lam) $(Q Exp
lstN))|]
    where
     sepr :: Q Exp
sepr = PieceString -> Q Exp
psToStringE (PieceString -> Maybe PieceString -> PieceString
forall a. a -> Maybe a -> a
fromMaybe [String -> StringBits
Str String
""] Maybe PieceString
sep)
     lam :: Q Exp
lam  = [Q Pat] -> Q Exp -> Q Exp
forall (m :: * -> *). Quote m => [m Pat] -> m Exp -> m Exp
TH.lamE [Q Pat
varN] (PieceString -> Q Exp
psToStringE PieceString
rep)
     varN :: Q Pat
varN = Name -> Q Pat
forall (m :: * -> *). Quote m => Name -> m Pat
TH.varP (Name -> Q Pat) -> Name -> Q Pat
forall a b. (a -> b) -> a -> b
$ String -> Name
TH.mkName String
varName
     lstN :: Q Exp
lstN = Name -> Q Exp
forall (m :: * -> *). Quote m => Name -> m Exp
TH.varE (Name -> Q Exp) -> Name -> Q Exp
forall a b. (a -> b) -> a -> b
$ String -> Name
TH.mkName String
lstName



type PieceString = [StringBits]
data StringBits = Str String | Var String | SVar String
                  | RepVar String String 
                    PieceString (Maybe PieceString)
                deriving (StringBits -> StringBits -> Bool
(StringBits -> StringBits -> Bool)
-> (StringBits -> StringBits -> Bool) -> Eq StringBits
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StringBits -> StringBits -> Bool
== :: StringBits -> StringBits -> Bool
$c/= :: StringBits -> StringBits -> Bool
/= :: StringBits -> StringBits -> Bool
Eq,Eq StringBits
Eq StringBits =>
(StringBits -> StringBits -> Ordering)
-> (StringBits -> StringBits -> Bool)
-> (StringBits -> StringBits -> Bool)
-> (StringBits -> StringBits -> Bool)
-> (StringBits -> StringBits -> Bool)
-> (StringBits -> StringBits -> StringBits)
-> (StringBits -> StringBits -> StringBits)
-> Ord StringBits
StringBits -> StringBits -> Bool
StringBits -> StringBits -> Ordering
StringBits -> StringBits -> StringBits
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StringBits -> StringBits -> Ordering
compare :: StringBits -> StringBits -> Ordering
$c< :: StringBits -> StringBits -> Bool
< :: StringBits -> StringBits -> Bool
$c<= :: StringBits -> StringBits -> Bool
<= :: StringBits -> StringBits -> Bool
$c> :: StringBits -> StringBits -> Bool
> :: StringBits -> StringBits -> Bool
$c>= :: StringBits -> StringBits -> Bool
>= :: StringBits -> StringBits -> Bool
$cmax :: StringBits -> StringBits -> StringBits
max :: StringBits -> StringBits -> StringBits
$cmin :: StringBits -> StringBits -> StringBits
min :: StringBits -> StringBits -> StringBits
Ord,Int -> StringBits -> String -> String
PieceString -> String -> String
StringBits -> String
(Int -> StringBits -> String -> String)
-> (StringBits -> String)
-> (PieceString -> String -> String)
-> Show StringBits
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StringBits -> String -> String
showsPrec :: Int -> StringBits -> String -> String
$cshow :: StringBits -> String
show :: StringBits -> String
$cshowList :: PieceString -> String -> String
showList :: PieceString -> String -> String
Show,Typeable,Typeable StringBits
Typeable StringBits =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> StringBits -> c StringBits)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StringBits)
-> (StringBits -> Constr)
-> (StringBits -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StringBits))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StringBits))
-> ((forall b. Data b => b -> b) -> StringBits -> StringBits)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StringBits -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StringBits -> r)
-> (forall u. (forall d. Data d => d -> u) -> StringBits -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StringBits -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> StringBits -> m StringBits)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StringBits -> m StringBits)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StringBits -> m StringBits)
-> Data StringBits
StringBits -> Constr
StringBits -> DataType
(forall b. Data b => b -> b) -> StringBits -> StringBits
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> StringBits -> u
forall u. (forall d. Data d => d -> u) -> StringBits -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StringBits -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StringBits -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StringBits
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StringBits -> c StringBits
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StringBits)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StringBits)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StringBits -> c StringBits
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StringBits -> c StringBits
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StringBits
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StringBits
$ctoConstr :: StringBits -> Constr
toConstr :: StringBits -> Constr
$cdataTypeOf :: StringBits -> DataType
dataTypeOf :: StringBits -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StringBits)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StringBits)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StringBits)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StringBits)
$cgmapT :: (forall b. Data b => b -> b) -> StringBits -> StringBits
gmapT :: (forall b. Data b => b -> b) -> StringBits -> StringBits
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StringBits -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StringBits -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StringBits -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StringBits -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StringBits -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> StringBits -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StringBits -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StringBits -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StringBits -> m StringBits
Data)

-- Split to string into pieces. This needs proper error messages.
-- Perhaps parsec?
parParse :: [Char] -> [StringBits]
parParse :: String -> PieceString
parParse [] = []

parParse (Char
'$':Char
'$':String
s) = String -> StringBits
Str String
"$"StringBits -> PieceString -> PieceString
forall a. a -> [a] -> [a]
:String -> PieceString
parParse String
s -- Parse escapes
parParse (Char
'#':Char
'#':String
s) = String -> StringBits
Str String
"#"StringBits -> PieceString -> PieceString
forall a. a -> [a] -> [a]
:String -> PieceString
parParse String
s

parParse (Char
'$':Char
':':String
s) = String -> StringBits
SVar ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'$') String
s) -- Parse antiquotes
                        StringBits -> PieceString -> PieceString
forall a. a -> [a] -> [a]
:String -> PieceString
parParse (Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
1 ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'$') String
s))

parParse (Char
'$':String
s) = String -> StringBits
Var ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'$') String
s)
                    StringBits -> PieceString -> PieceString
forall a. a -> [a] -> [a]
:String -> PieceString
parParse (Int -> String -> String
forall a. Int -> [a] -> [a]
drop Int
1 ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'$') String
s))

parParse (Char
'#':String
s) = let (String
bind,String
exprS) = Char -> String -> String -> (String, String)
forall t. Eq t => t -> String -> [t] -> ([t], [t])
escapingBreak (Char
':') 
                                       (String
"Repetition <"String -> String -> String
forall a. [a] -> [a] -> [a]
++String
sString -> String -> String
forall a. [a] -> [a] -> [a]
++String
"> missing body") 
                                        (String -> (String, String)) -> String -> (String, String)
forall a b. (a -> b) -> a -> b
$ String
s
                       (Bool
hasSep,String
expr,String
sepS) = String -> String -> (Bool, String, String)
takeRep 
                                             (String
"Repetition <"String -> String -> String
forall a. [a] -> [a] -> [a]
++String
sString -> String -> String
forall a. [a] -> [a] -> [a]
++String
"> missing #")(String -> (Bool, String, String))
-> String -> (Bool, String, String)
forall a b. (a -> b) -> a -> b
$ String
exprS
                       (String
sep,String
restS) = Char -> String -> String -> (String, String)
forall t. Eq t => t -> String -> [t] -> ([t], [t])
escapingBreak (Char
'#')
                                       (String
"Repetition <"String -> String -> String
forall a. [a] -> [a] -> [a]
++String
sString -> String -> String
forall a. [a] -> [a] -> [a]
++String
"> missing #")
                                         (String -> (String, String)) -> String -> (String, String)
forall a b. (a -> b) -> a -> b
$ String
sepS
                       rest :: String
rest = String
restS
                       ([String]
varNameS,[String]
listNameS) = (String -> Bool) -> [String] -> ([String], [String])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (String -> String -> Bool
forall a. Eq a => a -> a -> Bool
==String
"in") ([String] -> ([String], [String]))
-> (String -> [String]) -> String -> ([String], [String])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
words
                                            (String -> ([String], [String])) -> String -> ([String], [String])
forall a b. (a -> b) -> a -> b
$ String
bind
                       listName :: String
listName = [String] -> String
unwords ([String] -> String)
-> ([String] -> [String]) -> [String] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [String] -> [String]
forall a. Int -> [a] -> [a]
drop Int
1 ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ [String]
listNameS
                       varName :: String
varName  = [String] -> String
unwords [String]
varNameS
                    in if Bool
hasSep 
                        then String -> String -> PieceString -> Maybe PieceString -> StringBits
RepVar String
varName String
listName 
                             (String -> PieceString
parParse String
expr) (PieceString -> Maybe PieceString
forall a. a -> Maybe a
Just (PieceString -> Maybe PieceString)
-> PieceString -> Maybe PieceString
forall a b. (a -> b) -> a -> b
$ String -> PieceString
parParse String
sep) 
                             StringBits -> PieceString -> PieceString
forall a. a -> [a] -> [a]
: String -> PieceString
parParse String
rest
                        else String -> String -> PieceString -> Maybe PieceString -> StringBits
RepVar String
varName String
listName 
                             (String -> PieceString
parParse String
expr) (Maybe PieceString
forall a. Maybe a
Nothing) 
                             StringBits -> PieceString -> PieceString
forall a. a -> [a] -> [a]
: String -> PieceString
parParse String
sepS

parParse String
s = String -> StringBits
Str ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (String -> Char -> Bool
forall a. Eq a => [a] -> a -> Bool
notIn String
"$#") String
s)
                 StringBits -> PieceString -> PieceString
forall a. a -> [a] -> [a]
: String -> PieceString
parParse ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (String -> Char -> Bool
forall a. Eq a => [a] -> a -> Bool
notIn String
"$#") String
s) 

notIn :: (Eq a) => [a] -> a -> Bool
notIn :: forall a. Eq a => [a] -> a -> Bool
notIn [a]
s a
x =Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ a -> [a] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem a
x [a]
s 

takeRep :: String -> String -> (Bool,String,String)
takeRep :: String -> String -> (Bool, String, String)
takeRep String
e String
x = String -> String -> (Bool, String, String)
takeRep' String
x []
 where
    takeRep' :: String -> String -> (Bool,String,String)
    takeRep' :: String -> String -> (Bool, String, String)
takeRep' [] String
_ = String -> (Bool, String, String)
forall a. HasCallStack => String -> a
error (String -> (Bool, String, String))
-> String -> (Bool, String, String)
forall a b. (a -> b) -> a -> b
$ String
e
    takeRep' (Char
'|':Char
'|':String
s) String
acc = String -> String -> (Bool, String, String)
takeRep' String
s (Char
'|'Char -> String -> String
forall a. a -> [a] -> [a]
:String
acc)
    takeRep' (Char
'|':String
s) String
acc = (Bool
True,String -> String
forall a. [a] -> [a]
reverse String
acc,String
s)
    takeRep' (Char
'#':String
s) String
acc = (Bool
False,String -> String
forall a. [a] -> [a]
reverse String
acc,String
s)
    takeRep' (Char
r:String
s) String
acc = String -> String -> (Bool, String, String)
takeRep' String
s (Char
rChar -> String -> String
forall a. a -> [a] -> [a]
:String
acc)

escapingBreak :: (Eq t) => t -> [Char] -> [t] -> ([t], [t])
escapingBreak :: forall t. Eq t => t -> String -> [t] -> ([t], [t])
escapingBreak t
s String
e [t]
st = [t] -> [t] -> ([t], [t])
eBreak [] [t]
st 
  where 
    eBreak :: [t] -> [t] -> ([t], [t])
eBreak [t]
acc (t
a:t
b:[t]
c) | t
at -> t -> Bool
forall a. Eq a => a -> a -> Bool
==t
sBool -> Bool -> Bool
&&t
bt -> t -> Bool
forall a. Eq a => a -> a -> Bool
==t
s = [t] -> [t] -> ([t], [t])
eBreak (t
st -> [t] -> [t]
forall a. a -> [a] -> [a]
:[t]
acc) [t]
c
                       | t
at -> t -> Bool
forall a. Eq a => a -> a -> Bool
==t
s = ([t] -> [t]
forall a. [a] -> [a]
reverse [t]
acc,t
bt -> [t] -> [t]
forall a. a -> [a] -> [a]
:[t]
c)
                       | Bool
otherwise = [t] -> [t] -> ([t], [t])
eBreak (t
at -> [t] -> [t]
forall a. a -> [a] -> [a]
:[t]
acc) (t
bt -> [t] -> [t]
forall a. a -> [a] -> [a]
:[t]
c)
    eBreak [t]
acc (t
a:[t]
c) | t
at -> t -> Bool
forall a. Eq a => a -> a -> Bool
==t
s   = ([t] -> [t]
forall a. [a] -> [a]
reverse [t]
acc,[t]
c) 
                     | Bool
otherwise = [t] -> [t] -> ([t], [t])
eBreak (t
at -> [t] -> [t]
forall a. a -> [a] -> [a]
:[t]
acc) [t]
c
    eBreak [t]
_ [] = String -> ([t], [t])
forall a. HasCallStack => String -> a
error String
e

-- Normalize the indentation to match second line

norming :: String -> String
norming :: String -> String
norming = String -> [String] -> String
forall a. Monoid a => a -> [a] -> a
intercalate String
"\n" ([String] -> String) -> (String -> [String]) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> [String]
norming' ([String] -> [String])
-> (String -> [String]) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
lines (String -> [String]) -> (String -> String) -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Char -> Bool
isSpace

norming':: [String] -> [String]
norming' :: [String] -> [String]
norming' [] = []
norming' (String
l:[String]
lst) = String
lString -> [String] -> [String]
forall a. a -> [a] -> [a]
:(String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> String -> String
forall a. Int -> [a] -> [a]
drop (Int
n)) [String]
lst
    where 
     n :: Int
n = Int -> [Int] -> Int
forall a. Ord a => a -> [a] -> a
minimumD Int
0 ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ (String -> Int) -> [String] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length (String -> Int) -> (String -> String) -> String -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
' ') ) 
         ([String] -> [Int]) -> [String] -> [Int]
forall a b. (a -> b) -> a -> b
$ ((String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not(Bool -> Bool) -> (String -> Bool) -> String -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.String -> Bool
isEmpty) [String]
lst)
     isEmpty :: String -> Bool
isEmpty = (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Char -> Bool
isSpace)


minimumD :: (Ord a) => a -> [a] -> a
minimumD :: forall a. Ord a => a -> [a] -> a
minimumD a
d [] = a
d
minimumD a
_ [a]
x  = [a] -> a
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum [a]
x


-- Re-implementation of intercalate and intersperse using monoid instead of lists

intersperse             :: a -> [a] -> [a]
intersperse :: forall a. a -> [a] -> [a]
intersperse a
_   []      = []
intersperse a
sep (a
x:[a]
xs)  = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: a -> [a] -> [a]
forall a. a -> [a] -> [a]
prependToAll a
sep [a]
xs


prependToAll            :: a -> [a] -> [a]
prependToAll :: forall a. a -> [a] -> [a]
prependToAll a
_   []     = []
prependToAll a
sep (a
x:[a]
xs) = a
sep a -> [a] -> [a]
forall a. a -> [a] -> [a]
: a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: a -> [a] -> [a]
forall a. a -> [a] -> [a]
prependToAll a
sep [a]
xs

intercalate :: Monoid a => a -> [a] -> a
intercalate :: forall a. Monoid a => a -> [a] -> a
intercalate a
xs [a]
xss = [a] -> a
forall a. Monoid a => [a] -> a
mconcat (a -> [a] -> [a]
forall a. a -> [a] -> [a]
intersperse a
xs [a]
xss)