Introduce purs-tidy formatter (#27)

* Add purs-tidy formatter

* Run purs-tidy

Author: thomashoneyman

.github/workflows/ci.yml

@@ -15,6 +15,8 @@ jobs:
 
       - name: Set up PureScript toolchain
         uses: purescript-contrib/setup-purescript@main
+        with:
+          purs-tidy: "latest"
 
       - name: Cache PureScript dependencies
         uses: actions/cache@v2
@@ -25,9 +27,9 @@ jobs:
             output
 
       - name: Set up Node toolchain
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v2
         with:
-          node-version: "12.x"
+          node-version: "14.x"
 
       - name: Cache NPM dependencies
         uses: actions/cache@v2
@@ -49,3 +51,6 @@ jobs:
 
       - name: Run tests
         run: npm run test
+
+      - name: Check formatting
+        run: purs-tidy check src test

.gitignore

@@ -2,6 +2,7 @@
 !.gitignore
 !.github
 !.editorconfig
+!.tidyrc.json
 !.eslintrc.json
 
 output

.tidyrc.json

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

CHANGELOG.md

@@ -11,6 +11,7 @@ New features:
 Bugfixes:
 
 Other improvements:
+- Added `purs-tidy` formatter (#27 by @thomashoneyman)
 
 ## [v4.0.0](https://github.com/purescript-contrib/purescript-avar/releases/tag/v4.0.0) - 2021-02-26
 

src/Effect/AVar.purs

@@ -24,9 +24,9 @@ import Data.Maybe (Maybe(..))
 import Effect (Effect)
 import Effect.Exception (Error)
 
-type AVarCallback a = (Either Error a → Effect Unit)
+type AVarCallback a = (Either Error a -> Effect Unit)
 
-foreign import data AVar ∷ Type → Type
+foreign import data AVar :: Type -> Type
 
 type role AVar representational
 
@@ -36,92 +36,92 @@ data AVarStatus a
   | Empty
 
 -- | Creates a new empty AVar.
-foreign import empty ∷ ∀ a. Effect (AVar a)
+foreign import empty :: forall a. Effect (AVar a)
 
 -- | Creates a fresh AVar with an initial value.
-new ∷ ∀ a. a → Effect (AVar a)
+new :: forall a. a -> Effect (AVar a)
 new = _newVar
 
 -- | Kills the AVar with an exception. All pending and future actions will
 -- | resolve immediately with the provided exception.
-kill ∷ ∀ a. Error → AVar a → Effect Unit
+kill :: forall a. Error -> AVar a -> Effect Unit
 kill err avar = Fn.runFn3 _killVar ffiUtil err avar
 
 -- | Sets the value of the AVar. If the AVar is already filled, it will be
 -- | queued until the value is emptied. Multiple puts will resolve in order as
 -- | the AVar becomes available. Returns an effect which will remove the
 -- | callback from the pending queue.
-put ∷ ∀ a. a → AVar a → AVarCallback Unit → Effect (Effect Unit)
+put :: forall a. a -> AVar a -> AVarCallback Unit -> Effect (Effect Unit)
 put value avar cb = Fn.runFn4 _putVar ffiUtil value avar cb
 
 -- | Attempts to synchronously fill an AVar. If the AVar is already filled,
 -- | this will do nothing. Returns true or false depending on if it succeeded.
-tryPut ∷ ∀ a. a → AVar a → Effect Boolean
+tryPut :: forall a. a -> AVar a -> Effect Boolean
 tryPut value avar = Fn.runFn3 _tryPutVar ffiUtil value avar
 
 -- | Takes the AVar value, leaving it empty. If the AVar is already empty,
 -- | the callback will be queued until the AVar is filled. Multiple takes will
 -- | resolve in order as the AVar fills. Returns an effect which will remove
 -- | the callback from the pending queue.
-take ∷ ∀ a. AVar a → AVarCallback a → Effect (Effect Unit)
+take :: forall a. AVar a -> AVarCallback a -> Effect (Effect Unit)
 take avar cb = Fn.runFn3 _takeVar ffiUtil avar cb
 
 -- | Attempts to synchronously take an AVar value, leaving it empty. If the
 -- | AVar is empty, this will return `Nothing`.
-tryTake ∷ ∀ a. AVar a → Effect (Maybe a)
+tryTake :: forall a. AVar a -> Effect (Maybe a)
 tryTake avar = Fn.runFn2 _tryTakeVar ffiUtil avar
 
 -- | Reads the AVar value. Unlike `take`, this will not leave the AVar empty.
 -- | If the AVar is empty, this will queue until it is filled. Multiple reads
 -- | will resolve at the same time, as soon as possible.
-read ∷ ∀ a. AVar a → AVarCallback a → Effect (Effect Unit)
+read :: forall a. AVar a -> AVarCallback a -> Effect (Effect Unit)
 read avar cb = Fn.runFn3 _readVar ffiUtil avar cb
 
 -- | Attempts to synchronously read an AVar. If the AVar is empty, this will
 -- | return `Nothing`.
-tryRead ∷ ∀ a. AVar a → Effect (Maybe a)
+tryRead :: forall a. AVar a -> Effect (Maybe a)
 tryRead avar = Fn.runFn2 _tryReadVar ffiUtil avar
 
 -- | Synchronously checks the status of an AVar.
-status ∷ ∀ a. AVar a → Effect (AVarStatus a)
+status :: forall a. AVar a -> Effect (AVarStatus a)
 status avar = Fn.runFn2 _status ffiUtil avar
 
-isEmpty ∷ ∀ a. AVarStatus a → Boolean
+isEmpty :: forall a. AVarStatus a -> Boolean
 isEmpty = case _ of
-  Empty → true
-  _ → false
+  Empty -> true
+  _ -> false
 
-isFilled ∷ ∀ a. AVarStatus a → Boolean
+isFilled :: forall a. AVarStatus a -> Boolean
 isFilled = case _ of
-  Filled _ → true
-  _ → false
+  Filled _ -> true
+  _ -> false
 
-isKilled ∷ ∀ a. AVarStatus a → Boolean
+isKilled :: forall a. AVarStatus a -> Boolean
 isKilled = case _ of
-  Killed _ → true
-  _ → false
-
-foreign import _newVar ∷ ∀ a. a → Effect (AVar a)
-foreign import _killVar ∷ ∀ a. Fn.Fn3 FFIUtil Error (AVar a) (Effect Unit)
-foreign import _putVar ∷ ∀ a. Fn.Fn4 FFIUtil a (AVar a) (AVarCallback Unit) (Effect (Effect Unit))
-foreign import _tryPutVar ∷ ∀ a. Fn.Fn3 FFIUtil a (AVar a) (Effect Boolean)
-foreign import _takeVar ∷ ∀ a. Fn.Fn3 FFIUtil (AVar a) (AVarCallback a) (Effect (Effect Unit))
-foreign import _tryTakeVar ∷ ∀ a. Fn.Fn2 FFIUtil (AVar a) (Effect (Maybe a))
-foreign import _readVar ∷ ∀ a. Fn.Fn3 FFIUtil (AVar a) (AVarCallback a) (Effect (Effect Unit))
-foreign import _tryReadVar ∷ ∀ a. Fn.Fn2 FFIUtil (AVar a) (Effect (Maybe a))
-foreign import _status ∷ ∀ a. Fn.Fn2 FFIUtil (AVar a) (Effect (AVarStatus a))
+  Killed _ -> true
+  _ -> false
+
+foreign import _newVar :: forall a. a -> Effect (AVar a)
+foreign import _killVar :: forall a. Fn.Fn3 FFIUtil Error (AVar a) (Effect Unit)
+foreign import _putVar :: forall a. Fn.Fn4 FFIUtil a (AVar a) (AVarCallback Unit) (Effect (Effect Unit))
+foreign import _tryPutVar :: forall a. Fn.Fn3 FFIUtil a (AVar a) (Effect Boolean)
+foreign import _takeVar :: forall a. Fn.Fn3 FFIUtil (AVar a) (AVarCallback a) (Effect (Effect Unit))
+foreign import _tryTakeVar :: forall a. Fn.Fn2 FFIUtil (AVar a) (Effect (Maybe a))
+foreign import _readVar :: forall a. Fn.Fn3 FFIUtil (AVar a) (AVarCallback a) (Effect (Effect Unit))
+foreign import _tryReadVar :: forall a. Fn.Fn2 FFIUtil (AVar a) (Effect (Maybe a))
+foreign import _status :: forall a. Fn.Fn2 FFIUtil (AVar a) (Effect (AVarStatus a))
 
 type FFIUtil =
-  { left ∷ ∀ a b. a → Either a b
-  , right ∷ ∀ a b. b → Either a b
-  , nothing ∷ ∀ a. Maybe a
-  , just ∷ ∀ a. a → Maybe a
-  , killed ∷ ∀ a. Error → AVarStatus a
-  , filled ∷ ∀ a. a → AVarStatus a
-  , empty ∷ ∀ a. AVarStatus a
+  { left :: forall a b. a -> Either a b
+  , right :: forall a b. b -> Either a b
+  , nothing :: forall a. Maybe a
+  , just :: forall a. a -> Maybe a
+  , killed :: forall a. Error -> AVarStatus a
+  , filled :: forall a. a -> AVarStatus a
+  , empty :: forall a. AVarStatus a
   }
 
-ffiUtil ∷ FFIUtil
+ffiUtil :: FFIUtil
 ffiUtil =
   { left: Left
   , right: Right

src/Effect/Aff/AVar.purs

@@ -21,57 +21,57 @@ import Effect.Class (liftEffect)
 import Effect.Exception (Error)
 
 -- | Creates a fresh AVar with an initial value.
-new ∷ ∀ a. a → Aff (AVar a)
+new :: forall a. a -> Aff (AVar a)
 new = liftEffect <<< AVar.new
 
 -- | Creates a fresh AVar.
-empty ∷ ∀ a. Aff (AVar a)
+empty :: forall a. Aff (AVar a)
 empty = liftEffect AVar.empty
 
 -- | Synchronously checks the status of an AVar.
-status ∷ ∀ a. AVar a → Aff (AVar.AVarStatus a)
+status :: forall a. AVar a -> Aff (AVar.AVarStatus a)
 status = liftEffect <<< AVar.status
 
 -- | Takes the AVar value, leaving it empty. If the AVar is already empty,
 -- | the callback will be queued until the AVar is filled. Multiple takes will
 -- | resolve in order as the AVar fills.
-take ∷ ∀ a. AVar a → Aff a
-take avar = makeAff \k → do
-  c ← AVar.take avar k
+take :: forall a. AVar a -> Aff a
+take avar = makeAff \k -> do
+  c <- AVar.take avar k
   pure (effectCanceler c)
 
 -- | Attempts to synchronously take an AVar value, leaving it empty. If the
 -- | AVar is empty, this will return `Nothing`.
-tryTake ∷ ∀ a. AVar a → Aff (Maybe a)
+tryTake :: forall a. AVar a -> Aff (Maybe a)
 tryTake = liftEffect <<< AVar.tryTake
 
 -- | Sets the value of the AVar. If the AVar is already filled, it will be
 -- | queued until the value is emptied. Multiple puts will resolve in order as
 -- | the AVar becomes available.
-put ∷ ∀ a. a → AVar a → Aff Unit
-put value avar = makeAff \k → do
-  c ← AVar.put value avar k
+put :: forall a. a -> AVar a -> Aff Unit
+put value avar = makeAff \k -> do
+  c <- AVar.put value avar k
   pure (effectCanceler c)
 
 -- | Attempts to synchronously fill an AVar. If the AVar is already filled,
 -- | this will do nothing. Returns true or false depending on if it succeeded.
-tryPut ∷ ∀ a. a → AVar a → Aff Boolean
+tryPut :: forall a. a -> AVar a -> Aff Boolean
 tryPut value = liftEffect <<< AVar.tryPut value
 
 -- | Reads the AVar value. Unlike `take`, this will not leave the AVar empty.
 -- | If the AVar is empty, this will queue until it is filled. Multiple reads
 -- | will resolve at the same time, as soon as possible.
-read ∷ ∀ a. AVar a → Aff a
-read avar = makeAff \k → do
-  c ← AVar.read avar k
+read :: forall a. AVar a -> Aff a
+read avar = makeAff \k -> do
+  c <- AVar.read avar k
   pure (effectCanceler c)
 
 -- | Attempts to synchronously read an AVar. If the AVar is empty, this will
 -- | return `Nothing`.
-tryRead ∷ ∀ a. AVar a → Aff (Maybe a)
+tryRead :: forall a. AVar a -> Aff (Maybe a)
 tryRead = liftEffect <<< AVar.tryRead
 
 -- | Kills the AVar with an exception. All pending and future actions will
 -- | resolve immediately with the provided exception.
-kill ∷ ∀ a. Error → AVar a → Aff Unit
+kill :: forall a. Error -> AVar a -> Aff Unit
 kill error = liftEffect <<< AVar.kill error