Add Number and String formatting, closes #1, closes #3

Author: sharkdp

README.md

@@ -4,12 +4,21 @@ Type-safe, printf-style formatting for PureScript.
 
 ## Usage
 ``` purs
-> formatInt (width 6) 123
+> format (width 6) 123
 "   123"
 
-> formatInt (signed <> width 6) 123
+> format (signed <> width 6) 123
 "  +123"
 
-> formatInt (width 6 <> fillZeros) (-123)
+> format (zeroFill <> width 6) (-123)
 "-00123"
+
+> format (width 8 <> precision 3) pi
+"   3.142"
+
+> format (width 8 <> precision 3) 10.0
+"  10.000"
+
+> format (width 8) "foo"
+"     foo"
 ```

bower.json

@@ -3,6 +3,10 @@
   "authors": [
     "David Peter <[email protected]>"
   ],
+  "repository": {
+      "type": "git",
+      "url": "git://github.com/sharkdp/purescript-format.git"
+  },
   "license": "MIT",
   "ignore": [
     "**/.*",
@@ -12,7 +16,8 @@
   ],
   "dependencies": {
     "purescript-strings": "^0.7.1",
-    "purescript-arrays": "^0.4.5"
+    "purescript-arrays": "^0.4.5",
+    "purescript-math": "^0.2.0"
   },
   "devDependencies": {
     "purescript-test-unit": "^4.1.0"

src/Text/Format.purs

@@ -1,14 +1,152 @@
+-- | A module to format strings and numbers in a way similar to `printf` in
+-- | C-style languages.
+
 module Text.Format
-  ( padLeft
+  ( Properties()
+  , width
+  , zeroFill
+  , signed
+  , precision
+  , class Format
+  , format
   ) where
 
 import Prelude
 
-import Data.String (length, fromCharArray)
+import Control.Alt ((<|>))
 import Data.Array (replicate)
+import Data.Int as Int
+import Data.Maybe (Maybe(..), fromMaybe)
+import Data.Monoid (class Monoid)
+import Data.String (length, fromCharArray, dropWhile)
+import Math (round, pow, abs)
 
 -- | Pad a string on the left up to a given maximum length. The padding
 -- | character can be specified.
 padLeft :: Char -> Int -> String -> String
 padLeft c len str = prefix <> str
   where prefix = fromCharArray (replicate (len - length str) c)
+
+type PropertiesRecord =
+  { width :: Maybe Int
+  , padChar :: Maybe Char
+  , signed :: Maybe Boolean
+  , precision :: Maybe Int
+  }
+
+default :: PropertiesRecord
+default =
+  { width: Nothing
+  , padChar: Nothing
+  , signed: Nothing
+  , precision: Nothing
+  }
+
+data Properties = Properties PropertiesRecord
+
+instance eqProperties :: Eq Properties where
+  eq (Properties rec1) (Properties rec2) =
+    rec1.width     == rec2.width &&
+    rec1.padChar   == rec2.padChar &&
+    rec1.signed    == rec2.signed &&
+    rec1.precision == rec2.precision
+
+instance semigroupProperties :: Semigroup Properties where
+  append (Properties rec1) (Properties rec2) = Properties rec
+    where
+      -- These are combined such that options to the right take precedence:
+      -- width 3 <> width 4 == width 4
+      rec = { width:     rec2.width      <|> rec1.width
+            , padChar:   rec2.padChar    <|> rec1.padChar
+            , signed:    rec2.signed     <|> rec1.signed
+            , precision: rec2.precision  <|> rec1.precision
+            }
+
+instance monoidProperties :: Monoid Properties where
+  mempty = Properties default
+
+-- | The minium width of the output.
+width :: Int -> Properties
+width n = Properties (default { width = Just n })
+
+-- | Fill the free space with zeros instead of spaces.
+zeroFill :: Properties
+zeroFill = Properties (default { padChar = Just '0' })
+
+-- | Explicitely show a '+' sign for positive numbers. Gets ignored for
+-- | non-numeric types.
+signed :: Properties
+signed = Properties (default { signed = Just true })
+
+-- | Number of decimal places. Gets ignored for non-numeric types.
+precision :: Int -> Properties
+precision digits = Properties (default { precision = Just digits })
+
+-- | A class for types that can be formatted using the specified properties.
+class Format a where
+  format :: Properties -> a -> String
+
+instance formatString :: Format String where
+  format (Properties rec) str =
+    case rec.width of
+      Just len -> padLeft padChar len str
+      Nothing -> str
+   where
+     padChar = fromMaybe ' ' rec.padChar
+
+instance formatInt :: Format Int where
+  format prop@(Properties rec) num | fromMaybe 0 rec.precision > 0 =
+    format prop (Int.toNumber num)
+
+  format (Properties rec) num =
+    case rec.width of
+      Just len ->
+        if padChar == ' '
+          then
+            padLeft padChar len (numSgn <> show numAbs)
+          else
+            numSgn <> padLeft padChar (len - length numSgn) (show numAbs)
+      Nothing -> numSgn <> show numAbs
+
+   where
+     isSigned = fromMaybe false rec.signed
+     padChar = fromMaybe ' ' rec.padChar
+     isPositive = num > 0
+     numAbs = if isPositive then num else (-num)
+     numSgn = if isPositive
+                then (if isSigned then "+" else "")
+                else "-"
+
+instance formatNumber :: Format Number where
+  -- Format as an integer if the precision is set to 0
+  format prop@(Properties rec) num | rec.precision == Just 0 =
+    format prop (Int.round num)
+
+  format (Properties rec) num' =
+    case rec.width of
+      Just len ->
+        if padChar == ' '
+          then
+            padLeft padChar len (numSgn <> numAbsStr)
+          else
+            numSgn <> padLeft padChar (len - length numSgn) numAbsStr
+      Nothing -> numSgn <> numAbsStr
+
+   where
+     num = case rec.precision of
+             Nothing -> num'
+             Just digits ->
+               let f = 10.0 `pow` Int.toNumber digits
+               in  round (f * num') / f
+     isSigned = fromMaybe false rec.signed
+     padChar = fromMaybe ' ' rec.padChar
+     isPositive = num > 0.0
+     numAbsStr' = show (abs num)
+     numAbsStr = case rec.precision of
+                   Nothing -> numAbsStr'
+                   Just p -> numAbsStr' <> paddedZeros p
+     paddedZeros p = let d = length (dropWhile (_ /= '.') numAbsStr') - 1
+                     in fromCharArray (replicate (p - d) '0')
+     numSgn = if isPositive
+                then (if isSigned then "+" else "")
+                else "-"