Updates for 0.12

Author: paulyoung

bower.json

@@ -22,18 +22,18 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-const": "^3.0.0",
-    "purescript-functors": "^2.0.0",
-    "purescript-lists": "^4.0.0",
-    "purescript-parsing": "^4.0.0",
-    "purescript-partial": "^1.2.0",
-    "purescript-precise": "^2.0.0",
-    "purescript-prelude": "^3.0.0",
-    "purescript-sets": "^3.0.0",
-    "purescript-strings": "^3.0.0",
-    "purescript-strongcheck": "^3.0.0",
-    "purescript-unicode": "^3.0.1",
-    "purescript-validation": "^3.0.0",
-    "purescript-datetime": "^3.0.0"
+    "purescript-const": "^4.0.0",
+    "purescript-datetime": "^4.0.0",
+    "purescript-decimals": "^4.0.0",
+    "purescript-functors": "^3.0.0",
+    "purescript-lists": "^5.0.0",
+    "purescript-ordered-collections": "^1.0.0",
+    "purescript-parsing": "^5.0.1",
+    "purescript-partial": "^2.0.0",
+    "purescript-prelude": "^4.0.1",
+    "purescript-strings": "^4.0.0",
+    "purescript-strongcheck": "^4.1.1",
+    "purescript-unicode": "^4.0.1",
+    "purescript-validation": "^4.0.0"
   }
 }

package.json

@@ -5,10 +5,13 @@
     "build": "pulp build -- --censor-lib --strict",
     "test": "pulp test"
   },
+  "dependencies": {
+    "decimal.js": "7.1.1"
+  },
   "devDependencies": {
-    "pulp": "^11.0.0",
-    "purescript": "^0.11.4",
-    "purescript-psa": "^0.5.0",
+    "pulp": "^12.3.0",
+    "purescript": "^0.12.0",
+    "purescript-psa": "^0.6.0",
     "rimraf": "^2.5.4"
   }
 }

src/Text/Markdown/SlamDown/Parser.purs

@@ -11,8 +11,8 @@ import Data.Foldable (any, all)
 import Data.List ((:))
 import Data.List as L
 import Data.Maybe as M
-import Data.Monoid (mempty)
-import Data.String as S
+import Data.String (Pattern(..), Replacement(..), drop, length, replace, split, take, trim) as S
+import Data.String.CodeUnits (countPrefix, dropWhile, singleton) as S
 import Data.String.Regex as RGX
 import Data.String.Regex.Unsafe as URX
 import Data.String.Regex.Flags as RXF
@@ -59,7 +59,7 @@ allChars p = all p <<< S.split (S.Pattern "")
 
 removeNonIndentingSpaces ∷ String → String
 removeNonIndentingSpaces s
-  | S.count (isSpace <<< S.singleton) s < 4 = S.dropWhile (isSpace <<< S.singleton) s
+  | S.countPrefix (isSpace <<< S.singleton) s < 4 = S.dropWhile (isSpace <<< S.singleton) s
   | otherwise = s
 
 isRuleChar ∷ String → Boolean
@@ -77,15 +77,15 @@ isRule s =
 isATXHeader ∷ String → Boolean
 isATXHeader s =
   let
-    level = S.count (\c → S.singleton c == "#") s
+    level = S.countPrefix (\c → S.singleton c == "#") s
     rest = S.drop level s
   in
     level >= 1 && level <= 6 && S.take 1 rest == " "
 
 splitATXHeader ∷ String → { level ∷ Int, contents ∷ String }
 splitATXHeader s =
   let
-    level = S.count (\c → S.singleton c == "#") s
+    level = S.countPrefix (\c → S.singleton c == "#") s
     contents = S.drop (level + 1) s
   in
     { level: level
@@ -120,7 +120,7 @@ splitBlockquote ss =
   blockquoteContents s = S.drop (if S.take 2 s == "> " then 2 else 1) s
 
 countLeadingSpaces ∷ String → Int
-countLeadingSpaces = S.count (isSpace <<< S.singleton)
+countLeadingSpaces = S.countPrefix (isSpace <<< S.singleton)
 
 isBulleted ∷ String → Boolean
 isBulleted s =
@@ -139,7 +139,7 @@ isBulleted s =
 isOrderedListMarker ∷ String → Boolean
 isOrderedListMarker s =
   let
-    n = S.count (isDigit <<< S.singleton) s
+    n = S.countPrefix (isDigit <<< S.singleton) s
     next = S.take 1 (S.drop n s)
     ls = countLeadingSpaces (S.drop (n + 1) s)
   in
@@ -149,14 +149,14 @@ listItemType ∷ String → SD.ListType
 listItemType s
   | isBulleted s = SD.Bullet (S.take 1 s)
   | otherwise =
-      let n = S.count (isDigit <<< S.singleton) s
+      let n = S.countPrefix (isDigit <<< S.singleton) s
       in SD.Ordered (S.take 1 (S.drop n s))
 
 listItemIndent ∷ String → Int
 listItemIndent s
   | isBulleted s = 1 + min 4 (countLeadingSpaces (S.drop 1 s))
   | otherwise =
-      let n = S.count (isDigit <<< S.singleton) s
+      let n = S.countPrefix (isDigit <<< S.singleton) s
       in n + 1 + min 4 (countLeadingSpaces (S.drop (n + 1) s))
 
 isListItemLine ∷ String → Boolean
@@ -210,7 +210,7 @@ splitIndentedChunks ss =
 isCodeFence ∷ String → Boolean
 isCodeFence s = isSimpleFence s || (isEvaluatedCode s && isSimpleFence (S.drop 1 s))
   where
-  isSimpleFence s' = S.count (isFenceChar <<< S.singleton) s' >= 3
+  isSimpleFence s' = S.countPrefix (isFenceChar <<< S.singleton) s' >= 3
 
 isEvaluatedCode ∷ String → Boolean
 isEvaluatedCode s = S.take 1 s == "!"
@@ -243,7 +243,7 @@ splitCodeFence indent fence ss =
     }
   where
   isClosingFence ∷ String → Boolean
-  isClosingFence s = S.count (\c → S.singleton c == fence) (removeNonIndentingSpaces s) >= 3
+  isClosingFence s = S.countPrefix (\c → S.singleton c == fence) (removeNonIndentingSpaces s) >= 3
 
   removeIndentTo ∷ String → String
   removeIndentTo s = S.drop (min indent (countLeadingSpaces s)) s

src/Text/Markdown/SlamDown/Parser/Inline.purs

@@ -15,15 +15,16 @@ import Data.Bifunctor (lmap)
 import Data.Char.Unicode (isAlphaNum)
 import Data.Const (Const(..))
 import Data.DateTime as DT
+import Data.Decimal as D
 import Data.Either (Either(..))
 import Data.Enum (toEnum)
 import Data.Foldable (elem)
 import Data.Functor.Compose (Compose(..))
-import Data.HugeNum as HN
 import Data.Int as Int
 import Data.List as L
 import Data.Maybe as M
-import Data.String as S
+import Data.String (joinWith, trim) as S
+import Data.String.CodeUnits (fromCharArray, singleton, toCharArray) as S
 import Data.Traversable (traverse)
 import Data.Tuple (Tuple(..), fst, snd)
 import Data.Validation.Semigroup as V
@@ -93,7 +94,7 @@ hash = void $ PS.string "#"
 type TextParserKit
   = { plainText ∷ P.Parser String String
     , natural ∷ P.Parser String Int
-    , decimal ∷ P.Parser String HN.HugeNum
+    , decimal ∷ P.Parser String D.Decimal
     , numericPrefix ∷ P.Parser String Unit
     }
 
@@ -278,7 +279,7 @@ inlines = L.many inline2 <* PS.eof
         M.Nothing → pure $ Right $ SD.TextBox $ SD.transTextBox (const $ Compose M.Nothing) template
         M.Just _ → do
           PU.skipSpaces
-          mdef ← PC.optionMaybe $ PC.try $ parseTextBox (_ /= ')') (expr id) template
+          mdef ← PC.optionMaybe $ PC.try $ parseTextBox (_ /= ')') (expr identity) template
           case mdef of
             M.Just def → do
               PU.skipSpaces
@@ -386,8 +387,8 @@ inlines = L.many inline2 <* PS.eof
     dropDown ∷ P.Parser String (SD.FormField a)
     dropDown = do
       let item = SD.stringValue <<< S.trim <$> manyOf \c → not $ c `elem` ['{','}',',','!','`','(',')']
-      ls ← PU.braces $ expr id $ (PC.try (PU.skipSpaces *> item)) `PC.sepBy` (PU.skipSpaces *> PS.string ",")
-      sel ← PC.optionMaybe $ PU.skipSpaces *> (PU.parens $ expr id $ item)
+      ls ← PU.braces $ expr identity $ (PC.try (PU.skipSpaces *> item)) `PC.sepBy` (PU.skipSpaces *> PS.string ",")
+      sel ← PC.optionMaybe $ PU.skipSpaces *> (PU.parens $ expr identity $ item)
       pure $ SD.DropDown sel ls
 
   other ∷ P.Parser String (SD.Inline a)
@@ -485,7 +486,7 @@ parseTextBox isPlainText eta template =
           M.Nothing →
             pure M.Nothing
 
-      HN.fromString (ms <> "." <> M.fromMaybe "" ns)
+      D.fromString (ms <> "." <> M.fromMaybe "" ns)
         # M.maybe (P.fail "Failed parsing decimal") pure
 
     parsePlainTextValue =

src/Text/Markdown/SlamDown/Parser/References.purs

@@ -7,7 +7,8 @@ import Prelude
 import Data.Array as A
 import Data.Either as E
 import Data.Maybe as M
-import Data.String as S
+import Data.String (trim) as S
+import Data.String.CodeUnits (fromCharArray) as S
 
 import Text.Parsing.Parser as P
 import Text.Parsing.Parser.Combinators as PC

src/Text/Markdown/SlamDown/Parser/Utils.purs

@@ -10,7 +10,7 @@ module Text.Markdown.SlamDown.Parser.Utils
 import Prelude
 
 import Data.Either (fromRight)
-import Data.String (singleton)
+import Data.String.CodeUnits (singleton)
 import Data.String.Regex as R
 import Data.String.Regex.Flags as RF
 

src/Text/Markdown/SlamDown/Pretty.purs

@@ -7,16 +7,16 @@ import Prelude
 
 import Data.Array as A
 import Data.DateTime as DT
+import Data.Decimal as D
 import Data.Foldable (fold, elem)
 import Data.Functor.Compose (Compose)
-import Data.HugeNum as HN
 import Data.Identity (Identity(..))
 import Data.List as L
 import Data.Maybe as M
 import Data.Enum (fromEnum)
-import Data.Monoid (mempty)
 import Data.Newtype (unwrap)
-import Data.String as S
+import Data.String (Pattern(..), indexOf, joinWith, length, split, stripSuffix) as S
+import Data.String.CodeUnits (fromCharArray) as S
 import Data.Unfoldable as U
 
 import Text.Markdown.SlamDown.Syntax as SD
@@ -117,8 +117,8 @@ prettyPrintTextBoxValue t =
   case t of
     SD.PlainText (Identity def) → def
     SD.Numeric (Identity def) →
-      let s = HN.toString def in
-      M.fromMaybe s $ S.stripSuffix (S.Pattern ".") $ HN.toString def
+      let s = D.toString def in
+      M.fromMaybe s $ S.stripSuffix (S.Pattern ".") $ D.toString def
     SD.Date (Identity def) → prettyPrintDate def
     SD.Time prec (Identity def) → prettyPrintTime prec def
     SD.DateTime prec (Identity def) → prettyPrintDateTime prec def
@@ -174,11 +174,11 @@ prettyPrintTextBox t =
     prettyPrintDefault ∷ SD.TextBox SD.Expr → String
     prettyPrintDefault =
       case _ of
-        SD.PlainText def → prettyPrintExpr id id def
-        SD.Numeric def → prettyPrintExpr id HN.toString def
-        SD.Date def → prettyPrintExpr id prettyPrintDate def
-        SD.Time prec def → prettyPrintExpr id (prettyPrintTime prec) def
-        SD.DateTime prec def → prettyPrintExpr id (prettyPrintDateTime prec) def
+        SD.PlainText def → prettyPrintExpr identity identity def
+        SD.Numeric def → prettyPrintExpr identity D.toString def
+        SD.Date def → prettyPrintExpr identity prettyPrintDate def
+        SD.Time prec def → prettyPrintExpr identity (prettyPrintTime prec) def
+        SD.DateTime prec def → prettyPrintExpr identity (prettyPrintDateTime prec) def
 
 
 prettyPrintFormElement ∷ ∀ a. (SD.Value a) ⇒ SD.FormField a → String
@@ -200,8 +200,8 @@ prettyPrintFormElement el =
     SD.CheckBoxes (SD.Unevaluated bs) (SD.Unevaluated ls) →
       "[!`" <> bs <> "`] !`" <> ls <> "`"
     SD.DropDown sel lbls →
-      braces (prettyPrintExpr id (A.fromFoldable >>> map SD.renderValue >>> S.joinWith ", ") lbls)
-        <> M.maybe "" (parens <<< prettyPrintExpr id SD.renderValue) sel
+      braces (prettyPrintExpr identity (A.fromFoldable >>> map SD.renderValue >>> S.joinWith ", ") lbls)
+        <> M.maybe "" (parens <<< prettyPrintExpr identity SD.renderValue) sel
     _ → "Unsupported form element"
 
 prettyPrintExpr ∷ ∀ a. (String → String) → (a → String) → SD.Expr a → String

src/Text/Markdown/SlamDown/Syntax.purs

@@ -10,13 +10,12 @@ module Text.Markdown.SlamDown.Syntax
 import Prelude
 
 import Data.List as L
-import Data.Monoid (class Monoid, mempty)
 import Test.StrongCheck.Arbitrary as SCA
 import Test.StrongCheck.Gen as Gen
 
-import Text.Markdown.SlamDown.Syntax.Block as SDB
-import Text.Markdown.SlamDown.Syntax.FormField as SDF
-import Text.Markdown.SlamDown.Syntax.Inline as SDI
+import Text.Markdown.SlamDown.Syntax.Block (Block(..), CodeBlockType(..), ListType(..)) as SDB
+import Text.Markdown.SlamDown.Syntax.FormField (class Value, Expr(..), FormField, FormFieldP(..), TextBox(..), TimePrecision(..), getLiteral, getUnevaluated, renderValue, stringValue, transFormField, transTextBox, traverseFormField, traverseTextBox) as SDF
+import Text.Markdown.SlamDown.Syntax.Inline (Inline(..), LinkTarget(..)) as SDI
 
 -- | `SlamDownP` is the type of SlamDown abstract syntax trees which take values in `a`.
 data SlamDownP a = SlamDown (L.List (SDB.Block a))

src/Text/Markdown/SlamDown/Syntax/FormField.purs

@@ -31,8 +31,8 @@ import Partial.Unsafe (unsafePartial)
 import Test.StrongCheck.Arbitrary as SCA
 import Test.StrongCheck.Gen as Gen
 
-import Text.Markdown.SlamDown.Syntax.TextBox as TB
-import Text.Markdown.SlamDown.Syntax.Value as Value
+import Text.Markdown.SlamDown.Syntax.TextBox (TextBox(..), TimePrecision(..), transTextBox, traverseTextBox) as TB
+import Text.Markdown.SlamDown.Syntax.Value (class Value, renderValue, stringValue) as Value
 
 data FormFieldP f a
   = TextBox (TB.TextBox (Compose M.Maybe f))
@@ -102,7 +102,7 @@ instance eqFormField ∷ (Functor f, Eq (f a), Eq (TB.TextBox (Compose M.Maybe f
     case _, _ of
       TextBox tb1, TextBox tb2 → tb1 == tb2
       RadioButtons sel1 ls1, RadioButtons sel2 ls2 → sel1 == sel2 && ls1 == ls2
-      CheckBoxes sel1 ls1, CheckBoxes sel2 ls2 → (Set.fromFoldable <$> sel1 == Set.fromFoldable <$> sel2) && ls1 == ls2
+      CheckBoxes sel1 ls1, CheckBoxes sel2 ls2 → ((Set.fromFoldable <$> sel1) == (Set.fromFoldable <$> sel2)) && ls1 == ls2
       DropDown sel1 ls1, DropDown sel2 ls2 → sel1 == sel2 && ls1 == ls2
       _, _ → false
 
@@ -155,7 +155,7 @@ unsafeElements ∷ ∀ a. L.List a → Gen.Gen a
 unsafeElements =
   Gen.elements
     <$> (unsafePartial M.fromJust <<< L.head)
-    <*> id
+    <*> identity
 
 instance arbitraryFormField ∷ (SCA.Arbitrary a, Eq a) ⇒ SCA.Arbitrary (FormFieldP Expr a) where
   arbitrary = do

src/Text/Markdown/SlamDown/Syntax/TextBox.purs

@@ -8,9 +8,11 @@ module Text.Markdown.SlamDown.Syntax.TextBox
 import Prelude
 
 import Data.DateTime as DT
-import Data.HugeNum as HN
+import Data.Decimal as D
+import Data.Eq (class Eq1)
 import Data.Identity (Identity(..))
 import Data.Newtype (unwrap)
+import Data.Ord (class Ord1)
 
 import Test.StrongCheck.Arbitrary as SCA
 import Test.StrongCheck.Data.ArbDateTime as ADT
@@ -39,7 +41,7 @@ instance coarbitraryTimePrecision ∷ SCA.Coarbitrary TimePrecision where
 
 data TextBox f
   = PlainText (f String)
-  | Numeric (f HN.HugeNum)
+  | Numeric (f D.Decimal)
   | Date (f DT.Date)
   | Time TimePrecision (f DT.Time)
   | DateTime TimePrecision (f DT.DateTime)
@@ -60,23 +62,23 @@ traverseTextBox eta = case _ of
   Time prec def → Time prec <$> eta def
   DateTime prec def → DateTime prec <$> eta def
 
-instance showTextBox ∷ (Functor f, Show (f String), Show (f HN.HugeNum), Show (f DT.Time), Show (f DT.Date), Show (f DT.DateTime)) ⇒ Show (TextBox f) where
+instance showTextBox ∷ (Functor f, Show (f String), Show (f D.Decimal), Show (f DT.Time), Show (f DT.Date), Show (f DT.DateTime)) ⇒ Show (TextBox f) where
   show = case _ of
     PlainText def → "(PlainText " <> show def <> ")"
     Numeric def → "(Numeric " <> show def <> ")"
     Date def → "(Date " <> show def <> ")"
     Time prec def → "(Time " <> show prec <> " " <> show def <> ")"
     DateTime prec def → "(DateTime " <> show prec <> " " <> show def <> ")"
 
-derive instance eqTextBox ∷ (Functor f, Eq (f String), Eq (f HN.HugeNum), Eq (f DT.Time), Eq (f DT.Date), Eq (f DT.DateTime)) ⇒ Eq (TextBox f)
-derive instance ordTextBox ∷ (Functor f, Ord (f String), Ord (f HN.HugeNum), Ord (f DT.Time), Ord (f DT.Date), Ord (f DT.DateTime)) ⇒ Ord (TextBox f)
+derive instance eqTextBox ∷ (Functor f, Eq (f String), Eq (f D.Decimal), Eq (f DT.Time), Eq (f DT.Date), Eq (f DT.DateTime), Eq1 f) ⇒ Eq (TextBox f)
+derive instance ordTextBox ∷ (Functor f, Ord (f String), Ord (f D.Decimal), Ord (f DT.Time), Ord (f DT.Date), Ord (f DT.DateTime), Ord1 f) ⇒ Ord (TextBox f)
 
 instance arbitraryTextBox ∷ (Functor f, SCA.Arbitrary (f String), SCA.Arbitrary (f Number), SCA.Arbitrary (f ADT.ArbTime), SCA.Arbitrary (f ADT.ArbDate), SCA.Arbitrary (f ADT.ArbDateTime)) ⇒ SCA.Arbitrary (TextBox f) where
   arbitrary = do
     i ← Gen.chooseInt 0 5
     case i of
       0 → PlainText <$> SCA.arbitrary
-      1 → Numeric <<< map HN.fromNumber <$> SCA.arbitrary
+      1 → Numeric <<< map D.fromNumber <$> SCA.arbitrary
       2 → Date <<< map ADT.runArbDate <$> SCA.arbitrary
       3 → Time <$> SCA.arbitrary <*> (map (eraseMillis <<< ADT.runArbTime) <$> SCA.arbitrary)
       4 → DateTime <$> SCA.arbitrary <*> (map (DT.modifyTime eraseMillis <<< ADT.runArbDateTime) <$> SCA.arbitrary)
@@ -86,7 +88,7 @@ instance coarbitraryTextBox ∷ (Functor f, SCA.Coarbitrary (f String), SCA.Coar
   coarbitrary =
     case _ of
       PlainText d -> SCA.coarbitrary d
-      Numeric d -> SCA.coarbitrary $ HN.toNumber <$> d
+      Numeric d -> SCA.coarbitrary $ D.toNumber <$> d
       Date d -> SCA.coarbitrary (ADT.ArbDate <$> d)
       Time prec d -> do
         _ ← SCA.coarbitrary prec