diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,11 @@ +# 0.0.0.4 + +* Added `format` from `text-format`, because in some cases it's nicer than brackets. + +* Renamed `padCenterF` to `padBothF`. + +* Modified `indent` and `indent'` to always add newlines. + # 0.0.0.3 * Wrote documentation. diff --git a/fmt.cabal b/fmt.cabal --- a/fmt.cabal +++ b/fmt.cabal @@ -1,5 +1,5 @@ name: fmt -version: 0.0.0.3 +version: 0.0.0.4 synopsis: Nice formatting library description: Nice formatting library diff --git a/lib/Fmt.hs b/lib/Fmt.hs --- a/lib/Fmt.hs +++ b/lib/Fmt.hs @@ -1,7 +1,7 @@ {- Acknowledgements ~~~~~~~~~~~~~~~~~~~ -* 'prefixF', 'suffixF', 'padCenterF', 'groupInt' are taken from +* 'prefixF', 'suffixF', 'padBothF', 'groupInt' are taken from Written by Github user @mwm @@ -48,6 +48,11 @@ (>%%<<), (>>%%<), + -- * Old-style formatting + format, + formatLn, + TF.Format, + -- * Helper functions fmt, fmtLn, @@ -82,7 +87,7 @@ suffixF, padLeftF, padRightF, - padCenterF, + padBothF, -- ** Hex hexF, @@ -116,11 +121,11 @@ import Data.Monoid import Lens.Micro -- Text -import qualified Data.Text as T import qualified Data.Text.Lazy as TL -- 'Buildable' and text-format import Data.Text.Buildable import qualified Data.Text.Format as TF +import qualified Data.Text.Format.Params as TF -- Text 'Builder' import Data.Text.Lazy.Builder hiding (fromString) -- 'Foldable' and 'IsList' for list/map formatters @@ -316,9 +321,21 @@ infixr 1 >%%<< ---------------------------------------------------------------------------- --- Main functions +-- Old-style formatting ---------------------------------------------------------------------------- +format :: (FromBuilder b, TF.Params ps) => TF.Format -> ps -> b +format f ps = fromBuilder (TF.build f ps) +{-# INLINE format #-} + +formatLn :: (FromBuilder b, TF.Params ps) => TF.Format -> ps -> b +formatLn f ps = fromBuilder (TF.build f ps <> "\n") +{-# INLINE formatLn #-} + +---------------------------------------------------------------------------- +-- Helper functions +---------------------------------------------------------------------------- + {- | 'fmt' converts things to 'String', 'Text' or 'Builder'. Most of the time you won't need it, as strings produced with ('%<') and @@ -368,6 +385,8 @@ >>> listF ["hello", "world"] "[hello, world]" + +For multiline output, use 'jsonListF'. -} listF :: (Foldable f, Buildable a) => f a -> Builder listF = listF' build @@ -509,10 +528,12 @@ #endif {- | A simple JSON-like map formatter; works for Map, HashMap, etc, as well as -ordinary lists of pairs. Doesn't handle multiline elements (for that you need 'blockMapF' or 'jsonMapF'). +ordinary lists of pairs. >>> mapF [("a", 1), ("b", 4)] "{a: 1, b: 4}" + +For multiline output, use 'jsonMapF'. -} mapF :: #if __GLASGOW_HASKELL__ >= 708 @@ -809,22 +830,22 @@ padRightF = TF.right {- | -@padCenterF n c@ pads the string with character @c@ from both sides until +@padBothF n c@ pads the string with character @c@ from both sides until it becomes @n@ characters wide (and does nothing if the string is already that long, or longer): ->>> padCenterF 5 '=' "foo" +>>> padBothF 5 '=' "foo" "=foo=" ->>> padCenterF 5 '=' "foobar" +>>> padBothF 5 '=' "foobar" "foobar" When padding can't be distributed equally, the left side is preferred: ->>> padCenter 8 '=' "foo" +>>> padBoth 8 '=' "foo" "===foo==" -} -padCenterF :: Buildable a => Int -> Char -> a -> Builder -padCenterF i c = +padBothF :: Buildable a => Int -> Char -> a -> Builder +padBothF i c = fromLazyText . TL.center (fromIntegral i) c . toLazyText . build {- | @@ -983,23 +1004,15 @@ - 1 - 2 - 3 + +The output will always end with a newline, even when the input doesn't. -} indent :: Int -> Builder -> Builder -indent n a = go (toLazyText a) +indent n a = case TL.lines (toLazyText a) of + [] -> fromLazyText (spaces <> "\n") + xs -> fromLazyText $ TL.unlines (map (spaces <>) xs) where - spaces = fromText (T.replicate n (T.singleton ' ')) - -- We don't use 'lines' because it doesn't distinguish between trailing - -- newline being present/absent. We want the following behavior: - -- >>> indent 2 "hi" - -- " hi" - -- >>> indent 2 "hi\n" - -- " hi\n" - go t | TL.null t = mempty - go t = let (l, t') = TL.break ((==) '\n') t - in spaces <> if TL.null t' - then fromLazyText l - else fromLazyText l <> singleton '\n' <> - go (TL.tail t') + spaces = TL.replicate (fromIntegral n) (TL.singleton ' ') ---------------------------------------------------------------------------- -- TODOs @@ -1023,16 +1036,11 @@ (and maybe not in the middle as well) * the problem is that the user might want to combine them so I guess we can't make a separate combinator for each -* there don't seem to be any cases when 'listF' is better than 'jsonListF', - so we'd want to leave only one of those, but there are cases when 'mapF' is - better than 'jsonMapF' (i.e. when you want everything to be on one - line). What to do? Maybe rename 'jsonMapF' to 'mapF' and 'mapF' to ??? - (can't think of a name)? -} {- docs -* add an examples section in the beginning +* write explicitly that 'build' can be used and is useful sometimes * provide a formatting→fmt transition table * mention that fmt doesn't do the neat thing that formatting does with (<>) (or maybe it does? there's a monoid instance for functions after all, @@ -1045,13 +1053,10 @@ * clarify philosophy (“take a free spot in design space; write the best possible library around it, not just a proof of concept”) * clarify what exactly is hard about writing `formatting` formatters -* write that [(a,b)] works too and could be used -} {- others -* rename 'padCenterF' -* change indentation to always add newlines * something to format a record nicely (with generics, probably) * something like https://hackage.haskell.org/package/groom * something for wrapping lists (not indenting, just hard-wrapping) @@ -1060,7 +1065,7 @@ * should it be called 'listBlock' or 'blockList'? * add NL or _NL for newline? or (<\>) or (<>\)? and also (>%\)? * have to decide on whether it would be >%< or >%%< or maybe >|< -* actually, what about |< and >|? +* actually, what about |< and >|? also <% and %> are good * what effect does it have on compilation time? what effect do other formatting libraries have on compilation time? * use 4 spaces instead of 2? diff --git a/lib/Fmt/Internal.hs b/lib/Fmt/Internal.hs --- a/lib/Fmt/Internal.hs +++ b/lib/Fmt/Internal.hs @@ -179,14 +179,9 @@ -- assumes that the prefix doesn't contain newlines indent' :: Int -> T.Text -> Builder -> Builder -indent' n pref a = go True (toLazyText a) +indent' n pref a = case TL.lines (toLazyText a) of + [] -> fromText pref <> "\n" + (x:xs) -> fromLazyText $ + TL.unlines $ (TL.fromStrict pref <> x) : map (spaces <>) xs where - spaces = fromText (T.replicate n (T.singleton ' ')) - go isFirst t - | TL.null t = if isFirst then fromText pref else "" - | otherwise = let (l, t') = TL.break ((==) '\n') t - in (if isFirst then fromText pref else spaces) <> - if TL.null t' - then fromLazyText l - else fromLazyText l <> singleton '\n' <> - go False (TL.tail t') + spaces = TL.replicate (fromIntegral n) (TL.singleton ' ') diff --git a/tests/Main.hs b/tests/Main.hs --- a/tests/Main.hs +++ b/tests/Main.hs @@ -75,18 +75,18 @@ describe "formatters" $ do describe "'indent'" $ do it "simple examples" $ do - indent 0 "hi" ==#> "hi" + indent 0 "hi" ==#> "hi\n" indent 0 "\nhi\n\n" ==#> "\nhi\n\n" - indent 2 "hi" ==#> " hi" + indent 2 "hi" ==#> " hi\n" indent 2 "hi\n" ==#> " hi\n" - indent 2 "" ==#> "" - indent 2 "hi\nbye" ==#> " hi\n bye" + indent 2 "" ==#> " \n" + indent 2 "hi\nbye" ==#> " hi\n bye\n" indent 2 "hi\nbye\n" ==#> " hi\n bye\n" it "formatting a block" $ do ("Some numbers:\n"<> indent 2 ( "odd: "%%"\n"<> - "even: "%%"")) ==#> "Some numbers:\n odd: 25\n even: 26" + "even: "%%"")) ==#> "Some numbers:\n odd: 25\n even: 26\n" describe "'listF'" $ do it "simple examples" $ do @@ -474,18 +474,18 @@ padRightF 6 '!' ("hello" :: Text) ==#> "hello!" padRightF 7 '!' ("hello" :: Text) ==#> "hello!!" padRightF 7 '!' ("" :: Text) ==#> "!!!!!!!" - it "padCenterF" $ do - padCenterF (-1) '!' ("hello" :: Text) ==#> "hello" - padCenterF 0 '!' ("hello" :: Text) ==#> "hello" - padCenterF 1 '!' ("hello" :: Text) ==#> "hello" - padCenterF 5 '!' ("hello" :: Text) ==#> "hello" - padCenterF 6 '!' ("hello" :: Text) ==#> "!hello" - padCenterF 7 '!' ("hello" :: Text) ==#> "!hello!" - padCenterF 7 '!' ("hell" :: Text) ==#> "!!hell!" - padCenterF 7 '!' ("hel" :: Text) ==#> "!!hel!!" - padCenterF 8 '!' ("hell" :: Text) ==#> "!!hell!!" - padCenterF 8 '!' ("hel" :: Text) ==#> "!!!hel!!" - padCenterF 8 '!' ("" :: Text) ==#> "!!!!!!!!" + it "padBothF" $ do + padBothF (-1) '!' ("hello" :: Text) ==#> "hello" + padBothF 0 '!' ("hello" :: Text) ==#> "hello" + padBothF 1 '!' ("hello" :: Text) ==#> "hello" + padBothF 5 '!' ("hello" :: Text) ==#> "hello" + padBothF 6 '!' ("hello" :: Text) ==#> "!hello" + padBothF 7 '!' ("hello" :: Text) ==#> "!hello!" + padBothF 7 '!' ("hell" :: Text) ==#> "!!hell!" + padBothF 7 '!' ("hel" :: Text) ==#> "!!hel!!" + padBothF 8 '!' ("hell" :: Text) ==#> "!!hell!!" + padBothF 8 '!' ("hel" :: Text) ==#> "!!!hel!!" + padBothF 8 '!' ("" :: Text) ==#> "!!!!!!!!" describe "integer" $ do it "octF" $ do