Sync with latest formatting

Author: thomashoneyman

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
 
       - uses: actions/setup-node@v1
         with:
-          node-version: "12"
+          node-version: "16"
 
       - name: Install dependencies
         run: |

.gitignore

@@ -1,6 +1,7 @@
 /.*
 !/.gitignore
 !/.github
+!/.tidyrc.json
 /bower_components/
 /node_modules/
 /output/

.tidyrc.json

@@ -0,0 +1,10 @@
+{
+  "importSort": "ide",
+  "importWrap": "source",
+  "indent": 2,
+  "operatorsFile": null,
+  "ribbon": 1,
+  "typeArrowPlacement": "first",
+  "unicode": "always",
+  "width": null
+}

package.json

@@ -9,6 +9,7 @@
     "pulp": "^16.0.0",
     "purescript": "^0.15.0",
     "purescript-psa": "^0.8.2",
+    "purs-tidy": "^0.9.2",
     "rimraf": "^3.0.0"
   }
 }

src/Data/Codec/Argonaut.purs

@@ -31,18 +31,18 @@ module Data.Codec.Argonaut
 import Prelude
 
 import Control.Monad.Reader (ReaderT(..), runReaderT)
-import Control.Monad.Writer (Writer, writer, mapWriter)
+import Control.Monad.Writer (Writer, mapWriter, writer)
 import Data.Argonaut.Core as J
 import Data.Array as A
 import Data.Bifunctor as BF
 import Data.Codec (BasicCodec, Codec, GCodec(..), basicCodec, bihoistGCodec, decode, encode)
-import Data.Codec (decode, encode, (~), (<~<), (>~>)) as Exports
+import Data.Codec (decode, encode, (<~<), (>~>), (~)) as Exports
 import Data.Either (Either(..), note)
 import Data.Generic.Rep (class Generic)
 import Data.Int as I
 import Data.List ((:))
 import Data.List as L
-import Data.Maybe (Maybe(..), maybe, fromJust)
+import Data.Maybe (Maybe(..), fromJust, maybe)
 import Data.Profunctor.Star (Star(..))
 import Data.String as S
 import Data.String.CodeUnits as SCU
@@ -73,25 +73,25 @@ derive instance genericJsonDecodeError ∷ Generic JsonDecodeError _
 
 instance showJsonDecodeError ∷ Show JsonDecodeError where
   show = case _ of
-    TypeMismatch s -> "(TypeMismatch " <> show s <> ")"
-    UnexpectedValue j -> "(UnexpectedValue " <> J.stringify j <> ")"
-    AtIndex i e -> "(AtIndex " <> show i <> " " <> show e <> ")"
-    AtKey k e -> "(AtKey " <> show k <> " " <> show e <> ")"
-    Named s e -> "(Named " <> show s <> " " <> show e <> ")"
-    MissingValue -> "MissingValue"
+    TypeMismatch s → "(TypeMismatch " <> show s <> ")"
+    UnexpectedValue j → "(UnexpectedValue " <> J.stringify j <> ")"
+    AtIndex i e → "(AtIndex " <> show i <> " " <> show e <> ")"
+    AtKey k e → "(AtKey " <> show k <> " " <> show e <> ")"
+    Named s e → "(Named " <> show s <> " " <> show e <> ")"
+    MissingValue → "MissingValue"
 
 -- | Prints a `JsonDecodeError` as a somewhat readable error message.
 printJsonDecodeError ∷ JsonDecodeError → String
 printJsonDecodeError err =
   "An error occurred while decoding a JSON value:\n" <> go err
   where
-    go = case _ of
-      TypeMismatch ty → "  Expected value of type '" <> ty <> "'."
-      UnexpectedValue val → "  Unexpected value " <> J.stringify val <> "."
-      AtIndex ix inner → "  At array index " <> show ix <> ":\n" <> go inner
-      AtKey key inner → "  At object key " <> key <> ":\n" <> go inner
-      Named name inner → "  Under '" <> name <> "':\n" <> go inner
-      MissingValue → "  No value was found."
+  go = case _ of
+    TypeMismatch ty → "  Expected value of type '" <> ty <> "'."
+    UnexpectedValue val → "  Unexpected value " <> J.stringify val <> "."
+    AtIndex ix inner → "  At array index " <> show ix <> ":\n" <> go inner
+    AtKey key inner → "  At object key " <> key <> ":\n" <> go inner
+    Named name inner → "  Under '" <> name <> "':\n" <> go inner
+    MissingValue → "  No value was found."
 
 -- | The "identity codec" for `Json` values.
 json ∷ JsonCodec J.Json
@@ -163,7 +163,8 @@ type JIndexedCodec a =
     (Either JsonDecodeError)
     (Array J.Json)
     (L.List J.Json)
-    a a
+    a
+    a
 
 -- | A codec for types that are encoded as an array with a specific layout.
 -- |
@@ -204,7 +205,8 @@ type JPropCodec a =
     (Either JsonDecodeError)
     (FO.Object J.Json)
     (L.List (Tuple String J.Json))
-    a a
+    a
+    a
 
 -- | A codec for objects that are encoded with specific properties.
 -- |
@@ -225,6 +227,7 @@ prop key codec = GCodec dec enc
     BF.lmap (AtKey key) case FO.lookup key obj of
       Just val → decode codec val
       Nothing → Left MissingValue
+
   enc ∷ Star (Writer (L.List (Tuple String J.Json))) a a
   enc = Star \val → writer $ Tuple val (pure (Tuple key (encode codec val)))
 
@@ -265,29 +268,33 @@ recordProp
 recordProp p codecA codecR =
   let key = reflectSymbol p in GCodec (dec' key) (enc' key)
   where
-    dec' ∷ String → ReaderT (FO.Object J.Json) (Either JsonDecodeError) (Record r')
-    dec' key = ReaderT \obj → do
-      r ← decode codecR obj
-      a ← BF.lmap (AtKey key) case FO.lookup key obj of
-        Just val → decode codecA val
-        Nothing → Left MissingValue
-      pure $ unsafeSet key a r
-    enc' ∷ String → Star (Writer (L.List (Tuple String J.Json))) (Record r') (Record r')
-    enc' key = Star \val →
-      writer $ Tuple val
-        $ Tuple key (encode codecA (unsafeGet key val))
-        : encode codecR (unsafeForget val)
-    unsafeForget ∷ Record r' → Record r
-    unsafeForget = unsafeCoerce
-    unsafeSet ∷ String → a → Record r → Record r'
-    unsafeSet key a = unsafeCoerce <<< FO.insert key a <<< unsafeCoerce
-    unsafeGet ∷ String → Record r' → a
-    unsafeGet s = unsafePartial fromJust <<< FO.lookup s <<< unsafeCoerce
-    
+  dec' ∷ String → ReaderT (FO.Object J.Json) (Either JsonDecodeError) (Record r')
+  dec' key = ReaderT \obj → do
+    r ← decode codecR obj
+    a ← BF.lmap (AtKey key) case FO.lookup key obj of
+      Just val → decode codecA val
+      Nothing → Left MissingValue
+    pure $ unsafeSet key a r
+
+  enc' ∷ String → Star (Writer (L.List (Tuple String J.Json))) (Record r') (Record r')
+  enc' key = Star \val →
+    writer $ Tuple val
+      $ Tuple key (encode codecA (unsafeGet key val))
+          : encode codecR (unsafeForget val)
+
+  unsafeForget ∷ Record r' → Record r
+  unsafeForget = unsafeCoerce
+
+  unsafeSet ∷ String → a → Record r → Record r'
+  unsafeSet key a = unsafeCoerce <<< FO.insert key a <<< unsafeCoerce
+
+  unsafeGet ∷ String → Record r' → a
+  unsafeGet s = unsafePartial fromJust <<< FO.lookup s <<< unsafeCoerce
+
 -- | Used with `record` to define an optional field.
 -- |
 -- | This will only decode the property as `Nothing` if the field does not exist
--- | in the object - having a values such as `null` assigned will need handling 
+-- | in the object - having a values such as `null` assigned will need handling
 -- | separately.
 -- |
 -- | The property will be omitted when encoding and the value is `Nothing`.
@@ -302,29 +309,33 @@ recordPropOptional
 recordPropOptional p codecA codecR =
   let key = reflectSymbol p in GCodec (dec' key) (enc' key)
   where
-    dec' ∷ String → ReaderT (FO.Object J.Json) (Either JsonDecodeError) (Record r')
-    dec' key = ReaderT \obj → do
-      r ← decode codecR obj
-      a ← BF.lmap (AtKey key) case FO.lookup key obj of
-        Just val → Just <$> decode codecA val
-        _ → Right Nothing
-      pure $ unsafeSet key a r
-    enc' ∷ String → Star (Writer (L.List (Tuple String J.Json))) (Record r') (Record r')
-    enc' key = Star \val → do
-      let w = encode codecR (unsafeForget val)
-      writer $ Tuple val case unsafeGet key val of
-        Just a → Tuple key (encode codecA a) : w
-        Nothing → w
-    unsafeForget ∷ Record r' → Record r
-    unsafeForget = unsafeCoerce
-    unsafeSet ∷ String → Maybe a → Record r → Record r'
-    unsafeSet key a = unsafeCoerce <<< FO.insert key a <<< unsafeCoerce
-    unsafeGet ∷ String → Record r' → Maybe a
-    unsafeGet s = unsafePartial fromJust <<< FO.lookup s <<< unsafeCoerce
+  dec' ∷ String → ReaderT (FO.Object J.Json) (Either JsonDecodeError) (Record r')
+  dec' key = ReaderT \obj → do
+    r ← decode codecR obj
+    a ← BF.lmap (AtKey key) case FO.lookup key obj of
+      Just val → Just <$> decode codecA val
+      _ → Right Nothing
+    pure $ unsafeSet key a r
+
+  enc' ∷ String → Star (Writer (L.List (Tuple String J.Json))) (Record r') (Record r')
+  enc' key = Star \val → do
+    let w = encode codecR (unsafeForget val)
+    writer $ Tuple val case unsafeGet key val of
+      Just a → Tuple key (encode codecA a) : w
+      Nothing → w
+
+  unsafeForget ∷ Record r' → Record r
+  unsafeForget = unsafeCoerce
+
+  unsafeSet ∷ String → Maybe a → Record r → Record r'
+  unsafeSet key a = unsafeCoerce <<< FO.insert key a <<< unsafeCoerce
+
+  unsafeGet ∷ String → Record r' → Maybe a
+  unsafeGet s = unsafePartial fromJust <<< FO.lookup s <<< unsafeCoerce
 
 jsonPrimCodec
   ∷ ∀ a
-   . String
+  . String
   → (J.Json → Maybe a)
   → (a → J.Json)
   → JsonCodec a

src/Data/Codec/Argonaut/Common.purs

@@ -14,8 +14,8 @@ import Data.List as L
 import Data.Map as M
 import Data.Maybe (Maybe(..))
 import Data.Profunctor (dimap)
-import Foreign.Object as FO
 import Data.Tuple (Tuple(..), fst, snd)
+import Foreign.Object as FO
 
 -- | A codec for `Maybe` values.
 -- |

src/Data/Codec/Argonaut/Compat.purs

@@ -15,9 +15,9 @@ import Data.Codec.Argonaut.Common (either, list, map, tuple) as Common
 import Data.Either (Either)
 import Data.Functor as F
 import Data.Maybe (Maybe(..))
-import Foreign.Object as FO
 import Data.Traversable (traverse)
 import Data.Tuple (Tuple(..))
+import Foreign.Object as FO
 
 -- | A codec for `Maybe` values.
 -- |
@@ -32,6 +32,7 @@ maybe codec = basicCodec dec enc
   dec j
     | J.isNull j = pure Nothing
     | otherwise = BF.bimap (Named "Maybe") Just ((decode codec j))
+
   enc ∷ Maybe a → J.Json
   enc = case _ of
     Nothing → J.jsonNull
@@ -53,6 +54,7 @@ foreignObject codec =
   where
   fromArray ∷ ∀ v. Array (Tuple String v) → FO.Object v
   fromArray = FO.fromFoldable
+
   decodeItem ∷ Tuple String J.Json → Either JsonDecodeError (Tuple String a)
   decodeItem (Tuple key value) =
     BF.bimap (AtKey key) (Tuple key) (decode codec value)

src/Data/Codec/Argonaut/Generic.purs

@@ -36,15 +36,15 @@ instance nullarySumCodecSum ∷ (NullarySumCodec a, NullarySumCodec b) ⇒ Nulla
   nullarySumEncode = case _ of
     Inl a → nullarySumEncode a
     Inr b → nullarySumEncode b
-  nullarySumDecode name j
-    = Inl <$> nullarySumDecode name j
+  nullarySumDecode name j = Inl <$> nullarySumDecode name j
     <|> Inr <$> nullarySumDecode name j
 
 instance nullarySumCodecCtor ∷ IsSymbol name ⇒ NullarySumCodec (Constructor name NoArguments) where
   nullarySumEncode _ =
     J.fromString $ reflectSymbol (Proxy ∷ Proxy name)
   nullarySumDecode name j = do
     tag ← note (CA.Named name (CA.TypeMismatch "String")) (J.toString j)
-    if tag /= reflectSymbol (Proxy ∷ Proxy name)
-      then Left (CA.Named name (CA.UnexpectedValue j))
-      else Right (Constructor NoArguments)
+    if tag /= reflectSymbol (Proxy ∷ Proxy name) then 
+      Left (CA.Named name (CA.UnexpectedValue j))
+    else
+      Right (Constructor NoArguments)

src/Data/Codec/Argonaut/Migration.purs

@@ -59,10 +59,10 @@ import Prelude
 import Data.Argonaut.Core as J
 import Data.Codec (basicCodec)
 import Data.Codec.Argonaut (JsonCodec)
-import Data.Maybe (Maybe(..), maybe, fromMaybe)
+import Data.Maybe (Maybe(..), fromMaybe, maybe)
+import Data.Tuple (Tuple(..), uncurry)
 import Foreign.Object as FO
 import Foreign.Object.ST as FOST
-import Data.Tuple (Tuple(..), uncurry)
 
 -- | When dealing with a JSON object that may be missing a field, this codec
 -- | can be used to alter the JSON before parsing to ensure a default value is
@@ -89,6 +89,7 @@ renameField oldName newName = basicCodec (pure <<< dec) identity
   where
   dec ∷ J.Json → J.Json
   dec j = J.caseJsonObject j (J.fromObject <<< rename) j
+
   rename ∷ FO.Object J.Json → FO.Object J.Json
   rename obj = maybe obj (uncurry (FO.insert newName)) (FO.pop oldName obj)
 
@@ -117,6 +118,7 @@ nestForTagged = basicCodec (pure <<< dec) identity
   where
   dec ∷ J.Json → J.Json
   dec j = J.caseJsonObject j (J.fromObject <<< rewrite) j
+
   rewrite ∷ FO.Object J.Json → FO.Object J.Json
   rewrite obj =
     case FO.pop "tag" obj of
@@ -127,6 +129,7 @@ nestForTagged = basicCodec (pure <<< dec) identity
         result ← FOST.new
         _ ← FOST.poke "tag" tagValue result
         FOST.poke "value" (mkValue obj') result
+
   mkValue ∷ FO.Object J.Json → J.Json
   mkValue obj = case FO.pop "value" obj of
     Just (Tuple valueValue obj') | FO.isEmpty obj' → valueValue
@@ -137,5 +140,6 @@ alterField field f = basicCodec (pure <<< dec) identity
   where
   dec ∷ J.Json → J.Json
   dec j = J.caseJsonObject j (J.fromObject <<< setDefault) j
+
   setDefault ∷ FO.Object J.Json → FO.Object J.Json
   setDefault = FO.alter f field

src/Data/Codec/Argonaut/Record.purs

@@ -41,7 +41,7 @@ record = rowListCodec (Proxy ∷ Proxy rl)
 -- | The class used to enable the building of `Record` codecs by providing a
 -- | record of codecs.
 class RowListCodec (rl ∷ RL.RowList Type) (ri ∷ Row Type) (ro ∷ Row Type) | rl → ri ro where
-  rowListCodec ∷ forall proxy. proxy rl → Record ri → CA.JPropCodec (Record ro)
+  rowListCodec ∷ ∀ proxy. proxy rl → Record ri → CA.JPropCodec (Record ro)
 
 instance rowListCodecNil ∷ RowListCodec RL.Nil () () where
   rowListCodec _ _ = CA.record
@@ -52,7 +52,8 @@ instance rowListCodecCons ∷
   , R.Cons sym a ro' ro
   , IsSymbol sym
   , TE.TypeEquals co (CA.JsonCodec a)
-  ) ⇒ RowListCodec (RL.Cons sym co rs) ri ro where
+  ) ⇒
+  RowListCodec (RL.Cons sym co rs) ri ro where
   rowListCodec _ codecs =
     CA.recordProp (Proxy ∷ Proxy sym) codec tail
     where