Run stylish-haskell

reflex-frp · Jul 14, 2018 · bd3f014 · bd3f014
1 parent d9a8872
commit bd3f014
Show file tree

Hide file tree

Showing 29 changed files with 88 additions and 73 deletions.
diff --git a/.stylish-haskell.yaml b/.stylish-haskell.yaml
@@ -149,6 +149,5 @@ columns: 110
 # needs to be aware of these, so it can parse the file correctly.
 #
 # No language extensions are enabled by default.
-# language_extensions:
-  # - TemplateHaskell
-  # - QuasiQuotes
+language_extensions:
+  - TemplateHaskell
diff --git a/src/Data/FastMutableIntMap.hs b/src/Data/FastMutableIntMap.hs
@@ -24,9 +24,9 @@ module Data.FastMutableIntMap
 
 import Control.Monad.IO.Class
 import Data.Foldable (traverse_)
-import Data.IORef
 import Data.IntMap.Strict (IntMap)
 import qualified Data.IntMap.Strict as IntMap
+import Data.IORef
 import Data.Maybe
 import Prelude hiding (lookup)
 import Reflex.Patch.Class

diff --git a/src/Data/FastWeakBag.hs b/src/Data/FastWeakBag.hs
@@ -31,7 +31,7 @@ import Control.Monad.IO.Class
 
 #ifdef GHCJS_FAST_WEAK
 import GHCJS.Types
-import Reflex.FastWeak (unsafeFromRawJSVal, unsafeToRawJSVal, js_isNull)
+import Reflex.FastWeak (js_isNull, unsafeFromRawJSVal, unsafeToRawJSVal)
 #else
 import Control.Exception
 import Data.Foldable (forM_, mapM_)

diff --git a/src/Data/Functor/Misc.hs b/src/Data/Functor/Misc.hs
@@ -245,12 +245,8 @@ dsumToEither = \case
 -- | We can't use @Compose Maybe@ instead of 'ComposeMaybe', because that would
 -- make the 'f' parameter have a nominal type role.  We need f to be
 -- representational so that we can use safe 'coerce'.
-#if MIN_VERSION_transformers(5,2,0)
 newtype ComposeMaybe f a =
-#else
-newtype ComposeMaybe (f :: * -> *) (a :: *) =
-#endif
-   ComposeMaybe { getComposeMaybe :: Maybe (f a) } deriving (Show, Eq, Ord)
+  ComposeMaybe { getComposeMaybe :: Maybe (f a) } deriving (Show, Eq, Ord)
 
 deriving instance Functor f => Functor (ComposeMaybe f)
 

diff --git a/src/Data/Map/Misc.hs b/src/Data/Map/Misc.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE LambdaCase #-}
-module Data.Map.Misc 
+module Data.Map.Misc
   (
   -- * Working with Maps
     diffMapNoEq

diff --git a/src/Reflex.hs b/src/Reflex.hs
@@ -7,9 +7,9 @@ module Reflex
 
 import Reflex.Class as X
 import Reflex.Collection as X
+import Reflex.Dynamic as X
 import Reflex.EventWriter.Base as X
 import Reflex.EventWriter.Class as X
-import Reflex.Dynamic as X
 #ifdef USE_TEMPLATE_HASKELL
 import Reflex.Dynamic.TH as X
 #endif

diff --git a/src/Reflex/Adjustable/Class.hs b/src/Reflex/Adjustable/Class.hs
@@ -1,9 +1,9 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FunctionalDependencies #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 #ifdef USE_REFLEX_OPTIMIZER
@@ -21,11 +21,11 @@ module Reflex.Adjustable.Class
 import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
 import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
 import Data.Align
-import Data.Map (Map)
-import qualified Data.Map as Map
 import Data.Dependent.Map (DMap, GCompare (..))
 import Data.Functor.Constant
 import Data.Functor.Misc
+import Data.Map (Map)
+import qualified Data.Map as Map
 import Data.Map.Misc
 import Data.These
 

diff --git a/src/Reflex/Class.hs b/src/Reflex/Class.hs
@@ -1,6 +1,6 @@
 {-# LANGUAGE BangPatterns #-}
-{-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
@@ -150,17 +150,18 @@ import Control.Applicative
 import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
 import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
 import Control.Monad.State.Strict hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
-import Control.Monad.Trans.Cont (ContT ())
-import Control.Monad.Trans.Except (ExceptT ())
-import Control.Monad.Trans.RWS (RWST ())
-import Control.Monad.Trans.Writer (WriterT ())
+import Control.Monad.Trans.Cont (ContT)
+import Control.Monad.Trans.Except (ExceptT)
+import Control.Monad.Trans.RWS (RWST)
+import Control.Monad.Trans.Writer (WriterT)
 import Data.Align
 import Data.Bifunctor
 import Data.Coerce
 import Data.Default
 import Data.Dependent.Map (DMap, DSum (..), GCompare (..))
 import qualified Data.Dependent.Map as DMap
 import Data.Either
+import Data.FastMutableIntMap (PatchIntMap)
 import Data.Foldable
 import Data.Functor.Bind hiding (join)
 import qualified Data.Functor.Bind as Bind
@@ -180,7 +181,6 @@ import Data.Traversable
 import Data.Type.Coercion
 import Reflex.FunctorMaybe
 import Reflex.Patch
-import Data.FastMutableIntMap (PatchIntMap)
 
 -- Note: must come last to silence warnings due to AMP on GHC < 7.10
 import Prelude hiding (foldl, mapM, mapM_, sequence, sequence_)

diff --git a/src/Reflex/Collection.hs b/src/Reflex/Collection.hs
@@ -1,10 +1,10 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE RecursiveDo #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 #ifdef USE_REFLEX_OPTIMIZER
@@ -27,9 +27,9 @@ module Reflex.Collection
 
 import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
 import Data.Align
+import Data.Functor.Misc
 import Data.Map (Map)
 import qualified Data.Map as Map
-import Data.Functor.Misc
 import Data.Map.Misc
 import Data.These
 

diff --git a/src/Reflex/EventWriter/Class.hs b/src/Reflex/EventWriter/Class.hs
@@ -2,6 +2,7 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE UndecidableInstances #-}
 #ifdef USE_REFLEX_OPTIMIZER
 {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-}

diff --git a/src/Reflex/FastWeak.hs b/src/Reflex/FastWeak.hs
@@ -133,11 +133,14 @@ emptyFastWeak = unsafeCoerce w
   where w :: FastWeak Any
 #ifdef GHCJS_FAST_WEAK
         w = js_emptyWeak
-foreign import javascript unsafe "$r = new h$FastWeak(null);" js_emptyWeak :: FastWeak Any
 #else
         w = unsafePerformIO $ do
           w' <- mkWeakPtr undefined Nothing
           finalize w'
           return w'
 #endif
 {-# NOINLINE emptyFastWeak #-}
+
+#ifdef GHCJS_FAST_WEAK
+foreign import javascript unsafe "$r = new h$FastWeak(null);" js_emptyWeak :: FastWeak Any
+#endif
diff --git a/src/Reflex/Host/Class.hs b/src/Reflex/Host/Class.hs
@@ -36,13 +36,13 @@ import Control.Monad.Fix
 import Control.Monad.Identity
 import Control.Monad.Ref
 import Control.Monad.Trans
-import Control.Monad.Trans.Cont (ContT ())
-import Control.Monad.Trans.Except (ExceptT ())
-import Control.Monad.Trans.Reader (ReaderT ())
-import Control.Monad.Trans.RWS (RWST ())
-import Control.Monad.Trans.State (StateT ())
+import Control.Monad.Trans.Cont (ContT)
+import Control.Monad.Trans.Except (ExceptT)
+import Control.Monad.Trans.Reader (ReaderT)
+import Control.Monad.Trans.RWS (RWST)
+import Control.Monad.Trans.State (StateT)
 import qualified Control.Monad.Trans.State.Strict as Strict
-import Control.Monad.Trans.Writer (WriterT ())
+import Control.Monad.Trans.Writer (WriterT)
 import Data.Dependent.Sum (DSum (..))
 import Data.GADT.Compare
 import Data.Monoid

diff --git a/src/Reflex/NotReady/Class.hs b/src/Reflex/NotReady/Class.hs
@@ -1,9 +1,10 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE DefaultSignatures #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE UndecidableInstances #-}
 #ifdef USE_REFLEX_OPTIMIZER
 {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-}
@@ -12,17 +13,17 @@ module Reflex.NotReady.Class
   ( NotReady(..)
   ) where
 
-import Control.Monad.Trans
 import Control.Monad.Reader (ReaderT)
+import Control.Monad.Trans
 
 import Reflex.Class
+import Reflex.DynamicWriter.Base (DynamicWriterT)
+import Reflex.EventWriter.Base (EventWriterT)
 import Reflex.Host.Class
+import Reflex.PerformEvent.Base (PerformEventT (..))
 import Reflex.PostBuild.Base (PostBuildT)
-import Reflex.EventWriter.Base (EventWriterT)
-import Reflex.DynamicWriter.Base (DynamicWriterT)
 import Reflex.Query.Base (QueryT)
 import Reflex.Requester.Base (RequesterT)
-import Reflex.PerformEvent.Base (PerformEventT(..))
 import Reflex.TriggerEvent.Base (TriggerEventT)
 
 class Monad m => NotReady t m | m -> t where

diff --git a/src/Reflex/Patch.hs b/src/Reflex/Patch.hs
@@ -8,10 +8,15 @@ module Reflex.Patch
 
 import Reflex.Patch.Class as X
 import Reflex.Patch.DMap as X hiding (getDeletions)
-import Reflex.Patch.DMapWithMove as X (PatchDMapWithMove, const2PatchDMapWithMoveWith, patchDMapWithMoveToPatchMapWithMoveWith, mapPatchDMapWithMove, weakenPatchDMapWithMoveWith, traversePatchDMapWithMoveWithKey, unsafePatchDMapWithMove, unPatchDMapWithMove)
-import Reflex.Patch.Map as X
-import Reflex.Patch.MapWithMove as X (PatchMapWithMove, patchMapWithMoveNewElementsMap, patchMapWithMoveNewElements, unsafePatchMapWithMove, unPatchMapWithMove)
+import Reflex.Patch.DMapWithMove as X (PatchDMapWithMove, const2PatchDMapWithMoveWith, mapPatchDMapWithMove,
+                                       patchDMapWithMoveToPatchMapWithMoveWith,
+                                       traversePatchDMapWithMoveWithKey, unPatchDMapWithMove,
+                                       unsafePatchDMapWithMove, weakenPatchDMapWithMoveWith)
 import Reflex.Patch.IntMap as X hiding (getDeletions)
+import Reflex.Patch.Map as X
+import Reflex.Patch.MapWithMove as X (PatchMapWithMove, patchMapWithMoveNewElements,
+                                      patchMapWithMoveNewElementsMap, unPatchMapWithMove,
+                                      unsafePatchMapWithMove)
 
 import Data.Semigroup (Semigroup (..), (<>))
 

diff --git a/src/Reflex/Patch/DMap.hs b/src/Reflex/Patch/DMap.hs
@@ -14,8 +14,8 @@ import Reflex.Patch.Map
 import Data.Dependent.Map (DMap, DSum (..), GCompare (..))
 import qualified Data.Dependent.Map as DMap
 import Data.Functor.Constant
-import qualified Data.IntMap as IntMap
 import Data.Functor.Misc
+import qualified Data.IntMap as IntMap
 import qualified Data.Map as Map
 import Data.Semigroup (Semigroup (..))
 import Data.Some (Some)

diff --git a/src/Reflex/Patch/IntMap.hs b/src/Reflex/Patch/IntMap.hs
@@ -1,16 +1,16 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveFunctor #-}
 {-# LANGUAGE DeriveFoldable #-}
+{-# LANGUAGE DeriveFunctor #-}
 {-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE TypeFamilies #-}
 module Reflex.Patch.IntMap where
 
-import Prelude hiding (lookup)
 import Data.IntMap.Strict (IntMap)
 import qualified Data.IntMap.Strict as IntMap
 import Data.Maybe
 import Data.Semigroup
+import Prelude hiding (lookup)
 import Reflex.Patch.Class
 
 newtype PatchIntMap a = PatchIntMap (IntMap (Maybe a)) deriving (Functor, Foldable, Traversable, Monoid)

diff --git a/src/Reflex/Patch/Map.hs b/src/Reflex/Patch/Map.hs
@@ -7,10 +7,10 @@ module Reflex.Patch.Map where
 
 import Reflex.Patch.Class
 
-import Data.Semigroup
 import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Maybe
+import Data.Semigroup
 
 -- | A set of changes to a 'Map'.  Any element may be inserted/updated or
 -- deleted.  Insertions are represented as values wrapped in 'Just', while

diff --git a/src/Reflex/Profiled.hs b/src/Reflex/Profiled.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE InstanceSigs #-}
@@ -18,9 +19,9 @@ import Control.Monad.Ref
 import Control.Monad.State.Strict (StateT, execStateT, modify)
 import Data.Coerce
 import Data.Dependent.Map (DMap, GCompare)
-import Data.List
 import Data.FastMutableIntMap
 import Data.IORef
+import Data.List
 import Data.Map (Map)
 import qualified Data.Map.Strict as Map
 import Data.Monoid ((<>))
@@ -32,8 +33,8 @@ import GHC.Foreign
 import GHC.IO.Encoding
 import GHC.Stack
 import Reflex.Class
-import Reflex.PerformEvent.Class
 import Reflex.Host.Class
+import Reflex.PerformEvent.Class
 
 import System.IO.Unsafe
 import Unsafe.Coerce

diff --git a/src/Reflex/Query/Base.hs b/src/Reflex/Query/Base.hs
@@ -37,15 +37,15 @@ import qualified Data.Some as Some
 import Data.These
 
 import Reflex.Class
-import Reflex.EventWriter.Class
 import Reflex.EventWriter.Base
+import Reflex.EventWriter.Class
 import Reflex.Host.Class
+import qualified Reflex.Patch.MapWithMove as MapWithMove
 import Reflex.PerformEvent.Class
 import Reflex.PostBuild.Class
 import Reflex.Query.Class
 import Reflex.Requester.Class
 import Reflex.TriggerEvent.Class
-import qualified Reflex.Patch.MapWithMove as MapWithMove
 
 newtype QueryT t q m a = QueryT { unQueryT :: StateT [Behavior t q] (EventWriterT t q (ReaderT (Dynamic t (QueryResult q)) m)) a }
   deriving (Functor, Applicative, Monad, MonadException, MonadFix, MonadIO, MonadHold t, MonadSample t, MonadAtomicRef)

diff --git a/src/Reflex/Requester/Base.hs b/src/Reflex/Requester/Base.hs
@@ -49,19 +49,19 @@ import Data.Bits
 import Data.Coerce
 import Data.Dependent.Map (DMap, DSum (..))
 import qualified Data.Dependent.Map as DMap
-import qualified Data.Some as Some
 import Data.Functor.Compose
 import Data.Functor.Misc
 import Data.IntMap.Strict (IntMap)
 import qualified Data.IntMap.Strict as IntMap
 import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Monoid ((<>))
-import Data.Unique.Tag
+import Data.Proxy
 import qualified Data.Semigroup as S
 import Data.Some (Some)
+import qualified Data.Some as Some
 import Data.Type.Equality
-import Data.Proxy
+import Data.Unique.Tag
 
 import GHC.Exts (Any)
 import Unsafe.Coerce