Update for compiler 0.12

bower.json

@@ -16,21 +16,18 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-prelude": "^3.0.0",
-    "purescript-parsing": "^4.2.1",
-    "purescript-fixed-points": "^4.0.0",
-    "purescript-datetime": "^v3.3.0",
-    "purescript-transformers": "^3.4.0",
-    "purescript-lists": "^4.3.0",
-    "purescript-generics-rep": "^5.0.0"
+    "purescript-fixed-points": "^5.0.0",
+    "purescript-datetime": "^v4.0.0",
+    "purescript-generics-rep": "^6.0.0",
+    "purescript-transformers": "^4.1.0",
+    "purescript-lists": "^5.0.0",
+    "purescript-prelude": "^4.0.1",
+    "purescript-parsing": "^5.0.0"
   },
   "devDependencies": {
-    "purescript-aff": "^3.0.0",
-    "purescript-console": "^3.0.0",
-    "purescript-psci-support": "^3.0.0",
-    "purescript-spec": "^0.14.0"
-  },
-  "resolutions": {
-    "purescript-datetime": "interval"
+    "purescript-aff": "^5.0.0",
+    "purescript-console": "^4.1.0",
+    "purescript-psci-support": "^4.0.0",
+    "purescript-spec": "^3.0.0"
   }
 }

package.json

@@ -6,9 +6,9 @@
     "test": "pulp test"
   },
   "devDependencies": {
-    "pulp": "^11.0.0",
-    "purescript": "^0.11.0",
-    "purescript-psa": "^0.5.0",
-    "rimraf": "^2.6.1"
+    "pulp": "^12.3.0",
+    "purescript": "^0.12.0",
+    "purescript-psa": "^0.6.0",
+    "rimraf": "^2.6.2"
   }
 }

src/Data/Formatter/DateTime.purs

@@ -19,7 +19,7 @@ import Control.Alternative (class Alternative)
 import Control.Apply (applySecond, lift2)
 import Control.Lazy as Z
 import Control.Monad.Reader.Trans (ReaderT, runReaderT, ask)
-import Control.Monad.State (State, modify, put, runState)
+import Control.Monad.State (State, modify_, put, runState)
 import Control.Monad.Trans.Class (lift)
 import Data.Array as Array
 import Data.Date as D
@@ -39,6 +39,7 @@ import Data.Maybe (Maybe(..), maybe, fromMaybe)
 import Data.Newtype (unwrap)
 import Data.Ord (abs)
 import Data.String as Str
+import Data.String.CodeUnits as CU
 import Data.Time as T
 import Data.Time.Duration as Dur
 import Data.Tuple (Tuple(..))
@@ -113,10 +114,10 @@ parseFormatString = runP formatParser
 
 placeholderContent ∷ P.Parser String String
 placeholderContent =
-  Str.toCharArray "YMDEHhamsS"
+  CU.toCharArray "YMDEHhamsS"
   # PS.noneOf
   # Array.some
-  <#> Str.fromCharArray
+  <#> CU.fromCharArray
 
 formatterCommandParser ∷ P.Parser String FormatterCommand
 formatterCommandParser = (PC.try <<< PS.string) `oneOfAs`
@@ -393,7 +394,7 @@ unformatCommandParser = case _ of
   modifyWithParser ∷ ∀ s' s x. (s → Maybe x → s) → P.ParserT s' (State s) x → P.ParserT s' (State s) Unit
   modifyWithParser f p = do
     v ← p
-    lift $ modify (flip f (Just v))
+    lift $ modify_ (flip f (Just v))
 
 unformatParser ∷ ∀ m. Monad m ⇒ Formatter → P.ParserT String m DT.DateTime
 unformatParser f = do

src/Data/Formatter/Internal.purs

@@ -3,7 +3,6 @@ module Data.Formatter.Internal where
 import Prelude
 
 import Data.Foldable (class Foldable, foldl)
-import Data.Monoid (class Monoid, mempty)
 
 foldDigits ∷ ∀ f. Foldable f ⇒ f Int → Int
 foldDigits = foldl (\acc d → acc * 10 + d) zero

src/Data/Formatter/Interval.purs

@@ -18,7 +18,6 @@ import Data.Interval as I
 import Data.Interval.Duration.Iso (IsoDuration, unIsoDuration)
 import Data.Map (lookup)
 import Data.Maybe (maybe)
-import Data.Monoid (mempty)
 import Data.Tuple (Tuple(..))
 
 formatRecurringInterval ∷ I.RecurringInterval IsoDuration DateTime → String

src/Data/Formatter/Number.purs

@@ -22,6 +22,7 @@ import Data.Traversable (for)
 import Data.Either (Either, either)
 import Data.Int as Int
 import Data.String as Str
+import Data.String.CodeUnits as CU
 
 import Data.Formatter.Parser.Utils (runP)
 import Data.Formatter.Internal (foldDigits, repeat)
@@ -123,17 +124,17 @@ format (Formatter f) num =
          roundedWithZeros =
            let roundedString = show rounded
                roundedLength = Str.length roundedString
-               zeros = repeat "0" (f.after - roundedLength)
-           in zeros <> roundedString
+               zeros' = repeat "0" (f.after - roundedLength)
+           in zeros' <> roundedString
          shownNumber =
            if f.comma
              then
-             addCommas [] zero $ Arr.reverse $ Str.toCharArray (repeat "0" zeros <> show integer)
+             addCommas [] zero $ Arr.reverse $ CU.toCharArray (repeat "0" zeros <> show integer)
              else repeat "0" zeros <> show integer
 
          addCommas ∷ Array Char → Int → Array Char → String
          addCommas acc counter input = case Arr.uncons input of
-           Nothing → Str.fromCharArray acc
+           Nothing → CU.fromCharArray acc
            Just {head, tail} | counter < 3 →
              addCommas (Arr.cons head acc) (counter + one) tail
            _ →
@@ -238,5 +239,5 @@ unformatNumber pattern str =
 -- good way to extract number back to show.
 formatOrShowNumber ∷ String → Number → String
 formatOrShowNumber patter number =
-  either (const $ show number) id
+  either (const $ show number) identity
   $ formatNumber patter number

src/Data/Formatter/Parser/Interval.purs

@@ -17,7 +17,6 @@ import Data.Formatter.Parser.Number (parseNumber, parseMaybeInteger)
 import Data.Interval as I
 import Data.Interval.Duration.Iso (IsoDuration, mkIsoDuration, prettyError)
 import Data.Maybe (Maybe)
-import Data.Monoid (class Monoid, mempty)
 import Data.Traversable (sequence)
 import Data.Tuple (Tuple(..), snd)
 import Partial.Unsafe (unsafePartial)

test/src/DateTime.purs

@@ -12,7 +12,7 @@ import Test.Spec (describe, Spec, it)
 import Test.Spec.Assertions (shouldEqual)
 import Test.Utils (forAll, makeDateTime)
 
-datetimeTest ∷ ∀ e. Spec e Unit
+datetimeTest ∷ Spec Unit
 datetimeTest = describe "Data.Formatter.DateTime" do
   forAll (\a → a.format <> " | " <> a.dateStr)
     "formatDateTime/unformatDateTime should format/unformat dateTime"

test/src/Interval.purs

@@ -2,7 +2,7 @@ module Test.Interval (intervalTest) where
 
 import Prelude
 
-import Control.Monad.Aff (Aff)
+import Effect.Aff (Aff)
 import Data.DateTime (DateTime)
 import Data.Either (Either(..), fromRight)
 import Data.Foldable (class Foldable, fold)
@@ -17,10 +17,10 @@ import Test.Spec (describe, Spec)
 import Test.Spec.Assertions (shouldEqual)
 import Test.Utils (forAll, makeDateTime)
 
-prop ∷ ∀ e e' f. Foldable f ⇒ String → f {str ∷ String | e'} → ({str ∷ String | e'} → Aff e Unit) → Spec e Unit
+prop ∷ ∀ e f. Foldable f ⇒ String → f {str ∷ String | e} → ({str ∷ String | e} → Aff Unit) → Spec Unit
 prop = forAll (show <<< _.str)
 
-intervalTest ∷ ∀ e. Spec e Unit
+intervalTest ∷ Spec Unit
 intervalTest = describe "Data.Formatter.Interval" do
   prop "shouldn't unformat invalid Interval" invalidIntervals \({str, err}) → do
     (unformatInterval str) `shouldEqual` (Left $ err)

test/src/Main.purs

@@ -6,10 +6,10 @@ import Test.Interval (intervalTest)
 import Test.DateTime (datetimeTest)
 import Test.Number (numberTest)
 import Test.Spec.Reporter.Console (consoleReporter)
-import Control.Monad.Eff (Eff)
-import Test.Spec.Runner (RunnerEffects, run)
+import Effect (Effect)
+import Test.Spec.Runner (run)
 
-main ∷ Eff (RunnerEffects ()) Unit
+main ∷ Effect Unit
 main = run [consoleReporter] do
   intervalTest
   datetimeTest

test/src/Number.purs

@@ -9,7 +9,7 @@ import Test.Spec (describe, Spec)
 import Test.Spec.Assertions (shouldEqual)
 import Test.Utils (forAll)
 
-numberTest ∷ ∀ e. Spec e Unit
+numberTest ∷ Spec Unit
 numberTest = describe "Data.Formatter.Number" do
   forAll _.str
     "should print formatter"

test/src/Utils.purs

@@ -4,7 +4,7 @@ import Prelude
 
 
 import Test.Spec (describe, it, Spec)
-import Control.Monad.Aff (Aff)
+import Effect.Aff (Aff)
 
 import Data.Foldable (class Foldable, for_)
 import Data.Enum (toEnum)
@@ -14,7 +14,7 @@ import Data.Date (canonicalDate)
 import Data.Time (Time(..))
 
 
-forAll ∷ ∀ e a f. Foldable f ⇒ (a → String) → String → f a → (a → Aff e Unit) → Spec e Unit
+forAll ∷ ∀ a f. Foldable f ⇒ (a → String) → String → f a → (a → Aff Unit) → Spec Unit
 forAll itTitle title arb f = describe title do
   for_ arb \a → it (itTitle a) (f a)