Run purs-tidy

Author: thomashoneyman

src/Data/Float32.purs

@@ -1,12 +1,26 @@
 module Data.Float32
-  ( Float32, fromNumber, fromNumber', toNumber
+  ( Float32
+  , fromNumber
+  , fromNumber'
+  , toNumber
   ) where
 
 import Prelude
-  ( class Eq, class Ord, class Show, class Semiring, class Ring, class Bounded, class EuclideanRing
-  , class CommutativeRing, class DivisionRing
-  , top, bottom, (==), (||))
-import Data.Maybe (Maybe (..))
+  ( class Eq
+  , class Ord
+  , class Show
+  , class Semiring
+  , class Ring
+  , class Bounded
+  , class EuclideanRing
+  , class CommutativeRing
+  , class DivisionRing
+  , top
+  , bottom
+  , (==)
+  , (||)
+  )
+import Data.Maybe (Maybe(..))
 
 -- | [32-bit single-precision floating-point](https://en.wikipedia.org/wiki/Single-precision_floating-point_format)
 -- | number.
@@ -24,17 +38,17 @@ instance boundedFloat32 :: Bounded Float32 where
   top = float32Top
   bottom = float32Bottom
 
-
 foreign import float32Top :: Float32
 foreign import float32Bottom :: Float32
 
-
 -- | Uses `Math.fround()` to convert to a `Float32`.
 -- | Returns `Nothing` when outside the range.
 fromNumber :: Number -> Maybe Float32
 fromNumber x =
-  let r = fromNumberImpl x
-  in  if r == top || r == bottom then Nothing else Just (Float32 r)
+  let
+    r = fromNumberImpl x
+  in
+    if r == top || r == bottom then Nothing else Just (Float32 r)
 
 -- | Uses `Math.fround()` to convert to a `Float32`.
 -- | Returns *0.0* when outside the range.
@@ -43,7 +57,6 @@ fromNumber' x = case fromNumber x of
   Nothing -> Float32 0.0
   Just y -> y
 
-
 foreign import fromNumberImpl :: Number -> Number
 
 toNumber :: Float32 -> Number

src/Data/Float32/Gen.purs

@@ -4,6 +4,5 @@ import Prelude ((<$>))
 import Data.Float32 (Float32, fromNumber', toNumber)
 import Control.Monad.Gen.Class (class MonadGen, chooseFloat)
 
-
 chooseFloat32 :: forall m. MonadGen m => Float32 -> Float32 -> m Float32
 chooseFloat32 a b = fromNumber' <$> chooseFloat (toNumber a) (toNumber b)

test/Main.purs

@@ -10,6 +10,7 @@ import Test.QuickCheck.Laws.Data (checkBounded, checkCommutativeRing, checkEq, c
 import Type.Proxy (Proxy(..))
 
 newtype Float32' = Float32' Float32
+
 derive newtype instance eqFloat32' :: Eq Float32'
 derive newtype instance ordFloat32' :: Ord Float32'
 derive newtype instance boundedFloat32' :: Bounded Float32'
@@ -21,26 +22,17 @@ derive newtype instance euclideanRingFloat32' :: EuclideanRing Float32'
 instance arbitraryFloat32' :: Arbitrary Float32' where
   arbitrary = Float32' <$> chooseFloat32 bottom top
 
-
 main :: Effect Unit
 main = do
-  let p :: Proxy Float32'
-      p = Proxy
+  let
+    p :: Proxy Float32'
+    p = Proxy
   checkBounded p
   checkEq p
   checkOrd p
   checkSemiring p
   checkRing p
   checkCommutativeRing p
-  -- checkDivisionRing p -- isn't a division ring because 32bit float isn't perfectly precise
-  -- checkEuclideanRing p -- likewise for euclidean ring
-
-
-
-
-
-
-
-
-
+-- checkDivisionRing p -- isn't a division ring because 32bit float isn't perfectly precise
+-- checkEuclideanRing p -- likewise for euclidean ring