Use stylish-haskell

.stylish-haskell.yaml

@@ -0,0 +1,154 @@
+# stylish-haskell configuration file
+# ==================================
+
+# The stylish-haskell tool is mainly configured by specifying steps. These steps
+# are a list, so they have an order, and one specific step may appear more than
+# once (if needed). Each file is processed by these steps in the given order.
+steps:
+  # Convert some ASCII sequences to their Unicode equivalents. This is disabled
+  # by default.
+  # - unicode_syntax:
+  #     # In order to make this work, we also need to insert the UnicodeSyntax
+  #     # language pragma. If this flag is set to true, we insert it when it's
+  #     # not already present. You may want to disable it if you configure
+  #     # language extensions using some other method than pragmas. Default:
+  #     # true.
+  #     add_language_pragma: true
+
+  # Import cleanup
+  - imports:
+      # There are different ways we can align names and lists.
+      #
+      # - global: Align the import names and import list throughout the entire
+      #   file.
+      #
+      # - file: Like global, but don't add padding when there are no qualified
+      #   imports in the file.
+      #
+      # - group: Only align the imports per group (a group is formed by adjacent
+      #   import lines).
+      #
+      # - none: Do not perform any alignment.
+      #
+      # Default: global.
+      align: none
+
+      # Folowing options affect only import list alignment.
+      #
+      # List align has following options:
+      #
+      # - after_alias: Import list is aligned with end of import including
+      #   'as' and 'hiding' keywords.
+      #
+      #   > import qualified Data.List      as List (concat, foldl, foldr, head,
+      #   >                                          init, last, length)
+      #
+      # - with_alias: Import list is aligned with start of alias or hiding.
+      #
+      #   > import qualified Data.List      as List (concat, foldl, foldr, head,
+      #   >                                 init, last, length)
+      #
+      # - new_line: Import list starts always on new line.
+      #
+      #   > import qualified Data.List      as List
+      #   >     (concat, foldl, foldr, head, init, last, length)
+      #
+      # Default: after alias
+      list_align: after_alias
+
+      # Long list align style takes effect when import is too long. This is
+      # determined by 'columns' setting.
+      #
+      # - inline: This option will put as much specs on same line as possible.
+      #
+      # - new_line: Import list will start on new line.
+      #
+      # - new_line_multiline: Import list will start on new line when it's
+      #   short enough to fit to single line. Otherwise it'll be multiline.
+      #
+      # - multiline: One line per import list entry.
+      #   Type with contructor list acts like single import.
+      #
+      #   > import qualified Data.Map as M
+      #   >     ( empty
+      #   >     , singleton
+      #   >     , ...
+      #   >     , delete
+      #   >     )
+      #
+      # Default: inline
+      long_list_align: inline
+
+      # List padding determines indentation of import list on lines after import.
+      # This option affects 'list_align' and 'long_list_align'.
+      list_padding: 2
+
+      # Separate lists option affects formating of import list for type
+      # or class. The only difference is single space between type and list
+      # of constructors, selectors and class functions.
+      #
+      # - true: There is single space between Foldable type and list of it's
+      #   functions.
+      #
+      #   > import Data.Foldable (Foldable (fold, foldl, foldMap))
+      #
+      # - false: There is no space between Foldable type and list of it's
+      #   functions.
+      #
+      #   > import Data.Foldable (Foldable(fold, foldl, foldMap))
+      #
+      # Default: true
+      separate_lists: true
+
+  # Language pragmas
+  - language_pragmas:
+      # We can generate different styles of language pragma lists.
+      #
+      # - vertical: Vertical-spaced language pragmas, one per line.
+      #
+      # - compact: A more compact style.
+      #
+      # - compact_line: Similar to compact, but wrap each line with
+      #   `{-#LANGUAGE #-}'.
+      #
+      # Default: vertical.
+      style: vertical
+
+      # Align affects alignment of closing pragma brackets.
+      #
+      # - true: Brackets are aligned in same collumn.
+      #
+      # - false: Brackets are not aligned together. There is only one space
+      #   between actual import and closing bracket.
+      #
+      # Default: true
+      align: false
+
+      # stylish-haskell can detect redundancy of some language pragmas. If this
+      # is set to true, it will remove those redundant pragmas. Default: true.
+      remove_redundant: true
+
+  # Align the types in record declarations
+  # - records: {}
+
+  # Replace tabs by spaces. This is disabled by default.
+  # - tabs:
+  #     # Number of spaces to use for each tab. Default: 8, as specified by the
+  #     # Haskell report.
+  #     spaces: 8
+
+  # Remove trailing whitespace
+  - trailing_whitespace: {}
+
+# A common setting is the number of columns (parts of) code will be wrapped
+# to. Different steps take this into account. Default: 80.
+columns: 110
+
+# Sometimes, language extensions are specified in a cabal file or from the
+# command line instead of using language pragmas in the file. stylish-haskell
+# needs to be aware of these, so it can parse the file correctly.
+#
+# No language extensions are enabled by default.
+# language_extensions:
+  # - TemplateHaskell
+  # - QuasiQuotes

src-ghc/Reflex/Dom/Internal/Foreign.hs

@@ -1,12 +1,21 @@
-{-# LANGUAGE CPP, ForeignFunctionInterface, ScopedTypeVariables, LambdaCase, OverloadedStrings #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 module Reflex.Dom.Internal.Foreign where
 
 import Control.Concurrent
 import Control.Exception (bracket)
 import Control.Lens hiding (set)
 import Control.Monad
-import Control.Monad.State.Strict hiding (mapM, mapM_, forM, forM_, sequence, sequence_, get)
+import Control.Monad.State.Strict hiding (forM, forM_, get, mapM, mapM_, sequence, sequence_)
 import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
+import Data.Maybe
+import Data.Monoid
+import Data.Text (Text)
+import qualified Data.Text as T
 import Foreign.Marshal hiding (void)
 import Foreign.Ptr
 import GHCJS.DOM hiding (runWebGUI)
@@ -18,18 +27,13 @@ import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.WebFrame
-import Graphics.UI.Gtk.WebKit.Types hiding (Event, Widget, Text)
+import Graphics.UI.Gtk.WebKit.Types hiding (Event, Text, Widget)
 import Graphics.UI.Gtk.WebKit.WebFrame
 import Graphics.UI.Gtk.WebKit.WebInspector
 import Graphics.UI.Gtk.WebKit.WebSettings
 import Graphics.UI.Gtk.WebKit.WebView
 import System.Directory
 import System.Glib.FFI hiding (void)
-import qualified Data.ByteString as BS
-import Data.Monoid
-import Data.Maybe
-import Data.Text (Text)
-import qualified Data.Text as T
 
 #ifndef mingw32_HOST_OS
 import System.Posix.Signals

src-ghc/Reflex/Dom/WebSocket/Foreign.hs

@@ -1,12 +1,28 @@
-{-# LANGUAGE JavaScriptFFI, CPP, NoMonomorphismRestriction, RankNTypes, GADTs, ScopedTypeVariables, FlexibleInstances, MultiParamTypeClasses, TypeFamilies, FlexibleContexts, ConstraintKinds, UndecidableInstances, PolyKinds, AllowAmbiguousTypes #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE JavaScriptFFI #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 module Reflex.Dom.WebSocket.Foreign where
 
-import Prelude hiding (div, span, mapM, mapM_, concat, concatMap, all, sequence)
+import Prelude hiding (all, concat, concatMap, div, mapM, mapM_, sequence, span)
 
 import Control.Exception
 import Control.Monad.State
 import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
+import Data.Text (Text)
+import qualified Data.Text as T
 import Data.Text.Encoding
 import Foreign.Marshal hiding (void)
 import Foreign.Ptr
@@ -16,9 +32,6 @@ import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef
 import Graphics.UI.Gtk.WebKit.WebView
-import qualified Data.ByteString as BS
-import Data.Text (Text)
-import qualified Data.Text as T
 
 import Reflex.Dom.Internal.Foreign
 

src-ghc/Reflex/Dom/Xhr/Foreign.hs

@@ -1,23 +1,25 @@
-{-# LANGUAGE TypeSynonymInstances, FlexibleInstances, QuasiQuotes, OverloadedStrings #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE TypeSynonymInstances #-}
 module Reflex.Dom.Xhr.Foreign ( module Reflex.Dom.Xhr.Foreign
                               , XhrResponseType
                               ) where
 
+import Control.Concurrent.MVar
+import Control.Exception.Base
 import Control.Monad
-import qualified Data.Text as T
 import Data.Text (Text)
-import System.Glib.FFI
-import Graphics.UI.Gtk.WebKit.WebView
+import qualified Data.Text as T
+import GHCJS.DOM.File
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSBase
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef
-import GHCJS.DOM.File
-import Reflex.Dom.Xhr.ResponseType
-import Reflex.Dom.Xhr.Exception
-import Control.Concurrent.MVar
-import Control.Exception.Base
 import Graphics.UI.Gtk.WebKit.Types hiding (Text)
+import Reflex.Dom.Xhr.Exception
+import Reflex.Dom.Xhr.ResponseType
+import System.Glib.FFI
 
 import Reflex.Dom.Internal.Foreign
 

src-ghcjs/Reflex/Dom/Internal/Foreign.hs

@@ -1,18 +1,19 @@
-{-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
 module Reflex.Dom.Internal.Foreign ( module Reflex.Dom.Internal.Foreign
                                    , runWebGUI
                                    ) where
 
 import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
 import Foreign
 import Foreign.C
+import qualified GHCJS.Buffer as JS
 import GHCJS.DOM
 import GHCJS.DOM.Types
+import qualified GHCJS.Marshal.Pure as JS
 import GHCJS.Types
 import JavaScript.TypedArray.ArrayBuffer as JS
-import qualified Data.ByteString as BS
-import qualified GHCJS.Buffer as JS
-import qualified GHCJS.Marshal.Pure as JS
 
 quitWebView :: WebView -> IO ()
 quitWebView = error "quitWebView: unimplemented in GHCJS"

src-ghcjs/Reflex/Dom/WebSocket/Foreign.hs

@@ -1,25 +1,27 @@
-{-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI, CPP #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE JavaScriptFFI #-}
 
 module Reflex.Dom.WebSocket.Foreign where
 
-import Prelude hiding (div, span, mapM, mapM_, concat, concatMap, all, sequence)
+import Prelude hiding (all, concat, concatMap, div, mapM, mapM_, sequence, span)
 
-import Data.ByteString (ByteString)
-import qualified Data.ByteString as BS
-import GHCJS.Types
-import GHCJS.DOM.WebSocket (message, open, closeEvent)
-import qualified GHCJS.DOM.WebSocket as GD
-import GHCJS.DOM.MessageEvent
-import GHCJS.DOM.EventM (on)
-import GHCJS.DOM.Types hiding (Text)
 import Control.Monad.IO.Class
 import Control.Monad.Reader
-import GHCJS.Buffer
-import JavaScript.TypedArray.ArrayBuffer as JS
-import GHCJS.Marshal.Pure
-import GHCJS.Foreign.Internal
-import Data.Text.Encoding
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as BS
 import Data.Text (Text)
+import Data.Text.Encoding
+import GHCJS.Buffer
+import GHCJS.DOM.EventM (on)
+import GHCJS.DOM.MessageEvent
+import GHCJS.DOM.Types hiding (Text)
+import GHCJS.DOM.WebSocket (closeEvent, message, open)
+import qualified GHCJS.DOM.WebSocket as GD
+import GHCJS.Foreign.Internal
+import GHCJS.Marshal.Pure
+import GHCJS.Types
+import JavaScript.TypedArray.ArrayBuffer as JS
 
 data JSWebSocket = JSWebSocket { unWebSocket :: WebSocket }
 

src-ghcjs/Reflex/Dom/Xhr/Foreign.hs

@@ -1,4 +1,7 @@
-{-# LANGUAGE FlexibleInstances, TypeSynonymInstances, JavaScriptFFI, OverloadedStrings #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE JavaScriptFFI #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeSynonymInstances #-}
 
 module Reflex.Dom.Xhr.Foreign (
     XMLHttpRequest
@@ -6,20 +9,20 @@ module Reflex.Dom.Xhr.Foreign (
   , module Reflex.Dom.Xhr.Foreign
 ) where
 
-import Prelude hiding (error)
+import Control.Exception (catch, throwIO)
+import Data.Maybe (fromMaybe)
 import Data.Text (Text)
-import GHCJS.DOM.Types hiding (Text)
 import GHCJS.DOM
 import GHCJS.DOM.Enums
-import GHCJS.DOM.XMLHttpRequest
-import Data.Maybe (fromMaybe)
-import GHCJS.DOM.EventTarget (dispatchEvent)
 import GHCJS.DOM.EventM (EventM, on)
+import GHCJS.DOM.EventTarget (dispatchEvent)
+import GHCJS.DOM.Types hiding (Text)
+import GHCJS.DOM.XMLHttpRequest
+import GHCJS.Types
+import Prelude hiding (error)
 import Reflex.Dom.Internal.Foreign
 import Reflex.Dom.Xhr.Exception
 import Reflex.Dom.Xhr.ResponseType
-import Control.Exception (catch, throwIO)
-import GHCJS.Types
 
 prepareWebView :: WebView -> IO ()
 prepareWebView _ = return ()

src/Foreign/JavaScript/TH.hs

@@ -1,4 +1,18 @@
-{-# LANGUAGE ForeignFunctionInterface, CPP, TemplateHaskell, TypeFamilies, TypeSynonymInstances, FlexibleInstances, MultiParamTypeClasses, StandaloneDeriving, GeneralizedNewtypeDeriving, ExistentialQuantification, FunctionalDependencies, EmptyDataDecls, FlexibleContexts, RankNTypes, UndecidableInstances #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE UndecidableInstances #-}
 #ifdef __GHCJS__
 {-# LANGUAGE JavaScriptFFI #-}
 #endif
@@ -7,58 +21,58 @@ module Foreign.JavaScript.TH ( module Foreign.JavaScript.TH
                              ) where
 
 import Reflex.Class
-import Reflex.Host.Class
-import Reflex.Dom.PerformEvent.Class
 import Reflex.Dom.Deletable.Class
+import Reflex.Dom.PerformEvent.Class
+import Reflex.Host.Class
 
 import Language.Haskell.TH
 
 #ifdef __GHCJS__
-import qualified GHCJS.Marshal as JS
-import qualified GHCJS.Marshal.Pure as JS
-import qualified GHCJS.Foreign as JS
-import qualified GHCJS.Foreign.Callback as JS
-import qualified GHCJS.Types as JS
 import qualified GHCJS.Buffer as JS
 import GHCJS.DOM
-import GHCJS.DOM.Types hiding (fromJSString, Text)
+import GHCJS.DOM.Types hiding (Text, fromJSString)
 import qualified GHCJS.DOM.Types as JS
+import qualified GHCJS.Foreign as JS
+import qualified GHCJS.Foreign.Callback as JS
+import qualified GHCJS.Foreign.Callback.Internal (Callback (..))
+import qualified GHCJS.Marshal as JS
+import qualified GHCJS.Marshal.Pure as JS
+import qualified GHCJS.Types as JS
 import qualified JavaScript.Array as JS
+import qualified JavaScript.Array.Internal (SomeJSArray (..))
 import qualified JavaScript.Object as JS
 import qualified JavaScript.Object.Internal (Object (..))
-import qualified GHCJS.Foreign.Callback.Internal (Callback (..))
-import qualified JavaScript.Array.Internal (SomeJSArray (..))
 import qualified JavaScript.TypedArray.ArrayBuffer as JSArrayBuffer
 
-import Data.Word
-import Foreign.Ptr
-import Foreign.C.Types
 import Data.Hashable
+import Data.Word
+import Foreign.C.Types
+import Foreign.Ptr
 import Text.Encoding.Z
 #else
-import System.Glib.FFI
-import Graphics.UI.Gtk.WebKit.WebView
+import Foreign.Marshal
+import Graphics.UI.Gtk.WebKit.DOM.Node
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSBase
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSObjectRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSStringRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.JSValueRef
 import Graphics.UI.Gtk.WebKit.JavaScriptCore.WebFrame
-import Graphics.UI.Gtk.WebKit.DOM.Node
-import Foreign.Marshal
+import Graphics.UI.Gtk.WebKit.WebView
+import System.Glib.FFI
 #endif
 
+import Control.Concurrent
 import Control.Monad
-import Control.Monad.Ref
+import Control.Monad.Exception
 import Control.Monad.Fix
 import Control.Monad.IO.Class
-import Control.Monad.Exception
 import Control.Monad.Reader
+import Control.Monad.Ref
 import Control.Monad.State
-import Control.Monad.Trans.Control
 import qualified Control.Monad.State.Strict as Strict
+import Control.Monad.Trans.Control
 import Data.ByteString (ByteString)
 import qualified Data.ByteString as BS
-import Control.Concurrent
 import Data.Coerce
 import Data.Monoid
 import Data.Text (Text)

src/Reflex/Dom/Builder/Class.hs

@@ -1,4 +1,19 @@
-{-# LANGUAGE OverloadedStrings, TemplateHaskell, MultiParamTypeClasses, FunctionalDependencies, TypeFamilies, DeriveFunctor, FlexibleInstances, DataKinds, LambdaCase, PolyKinds, RankNTypes, ScopedTypeVariables, FlexibleContexts, UndecidableInstances, ConstraintKinds, DefaultSignatures #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE DeriveFunctor #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.Builder.Class
        ( module Reflex.Dom.Builder.Class
        , module Reflex.Dom.Builder.Class.Events
@@ -9,20 +24,20 @@ import Reflex
 import Reflex.Dom.Builder.Class.Events
 import Reflex.Dom.Deletable.Class
 
+import qualified Control.Category
 import Control.Lens hiding (element)
 import Control.Monad.Reader
 import Control.Monad.Trans.Control
 import Data.Default
-import Data.Functor.Misc
-import Data.Map (Map)
-import Data.Text (Text)
 import Data.Dependent.Map (DMap)
 import qualified Data.Dependent.Map as DMap
-import Data.Semigroup
+import Data.Functor.Misc
+import Data.Map (Map)
 import Data.Proxy
-import GHC.Exts (Constraint)
+import Data.Semigroup
+import Data.Text (Text)
 import Data.Type.Coercion
-import qualified Control.Category
+import GHC.Exts (Constraint)
 
 data Pair1 (f :: k -> *) (g :: k -> *) (a :: k) = Pair1 (f a) (g a)
 

src/Reflex/Dom/Builder/Class/Events.hs

@@ -1,4 +1,9 @@
-{-# LANGUAGE TemplateHaskell, DataKinds, GADTs, KindSignatures, TypeFamilies, PolyKinds #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeFamilies #-}
 module Reflex.Dom.Builder.Class.Events where
 
 import Data.GADT.Compare.TH

src/Reflex/Dom/Builder/Immediate.hs

@@ -1,42 +1,58 @@
-{-# LANGUAGE OverloadedStrings, MultiParamTypeClasses, FlexibleInstances, GeneralizedNewtypeDeriving, UndecidableInstances, DataKinds, TypeFamilies, RankNTypes, ConstraintKinds, TypeOperators, FlexibleContexts, LambdaCase, ScopedTypeVariables, PolyKinds, EmptyDataDecls #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.Builder.Immediate where
 
+import Foreign.JavaScript.TH
 import Reflex
-import Reflex.Host.Class
 import Reflex.Dom.Builder.Class
 import Reflex.Dom.PerformEvent.Class
 import Reflex.Dom.PostBuild.Class
-import Foreign.JavaScript.TH
+import Reflex.Host.Class
 
-import GHCJS.DOM.Document (Document, createTextNode, createElement, createElementNS, createDocumentFragment)
-import GHCJS.DOM.Element (setAttribute, setAttributeNS, removeAttribute, removeAttributeNS, getScrollTop)
-import qualified GHCJS.DOM.HTMLInputElement as Input
-import qualified GHCJS.DOM.HTMLTextAreaElement as TextArea
-import qualified GHCJS.DOM.Element as Element
-import qualified GHCJS.DOM.Window as Window
-import GHCJS.DOM.EventM (on, event, EventM)
-import qualified GHCJS.DOM.Event as Event
-import GHCJS.DOM.MouseEvent
-import GHCJS.DOM.Node (appendChild, getParentNode, getPreviousSibling, removeChild, toNode, getOwnerDocument, insertBefore)
-import GHCJS.DOM.Types (Node, IsNode, ToDOMString, FocusEvent, KeyboardEvent, WheelEvent, TouchEvent, IsElement, IsEvent, castToHTMLInputElement, castToHTMLTextAreaElement)
-import qualified GHCJS.DOM.Types as DOM
-import qualified GHCJS.DOM.EventM as DOM
-import GHCJS.DOM.UIEvent
-import Control.Monad.Reader
-import Control.Monad.Trans.Control
-import Control.Lens hiding (element)
 import Control.Concurrent.Chan
-import Data.Dependent.Sum
-import Data.Functor.Misc
-import Data.Bitraversable
-import Data.Text (Text)
-import Data.Maybe
-import Data.IORef
-import Control.Monad.Ref
+import Control.Lens hiding (element)
 import Control.Monad.Exception
+import Control.Monad.Reader
+import Control.Monad.Ref
+import Control.Monad.Trans.Control
+import Data.Bitraversable
+import Data.Default
 import Data.Dependent.Map (DMap)
 import qualified Data.Dependent.Map as DMap
-import Data.Default
+import Data.Dependent.Sum
+import Data.Functor.Misc
+import Data.IORef
+import Data.Maybe
+import Data.Text (Text)
+import GHCJS.DOM.Document (Document, createDocumentFragment, createElement, createElementNS, createTextNode)
+import GHCJS.DOM.Element (getScrollTop, removeAttribute, removeAttributeNS, setAttribute, setAttributeNS)
+import qualified GHCJS.DOM.Element as Element
+import qualified GHCJS.DOM.Event as Event
+import GHCJS.DOM.EventM (EventM, event, on)
+import qualified GHCJS.DOM.EventM as DOM
+import qualified GHCJS.DOM.HTMLInputElement as Input
+import qualified GHCJS.DOM.HTMLTextAreaElement as TextArea
+import GHCJS.DOM.MouseEvent
+import GHCJS.DOM.Node (appendChild, getOwnerDocument, getParentNode, getPreviousSibling, insertBefore,
+                       removeChild, toNode)
+import GHCJS.DOM.Types (FocusEvent, IsElement, IsEvent, IsNode, KeyboardEvent, Node, ToDOMString, TouchEvent,
+                        WheelEvent, castToHTMLInputElement, castToHTMLTextAreaElement)
+import qualified GHCJS.DOM.Types as DOM
+import GHCJS.DOM.UIEvent
+import qualified GHCJS.DOM.Window as Window
 
 import Debug.Trace hiding (traceEvent)
 
@@ -648,7 +664,7 @@ windowOnEventName en e = case en of
   Touchcancel -> on e Window.touchCancel
 
 {-# INLINABLE wrapDomEvent #-}
-wrapDomEvent :: (MonadIO m, TriggerEvent t m) => e -> (e -> EventM e event () -> IO (IO ())) -> EventM e event a -> m (Event t a)
+wrapDomEvent :: TriggerEvent t m => e -> (e -> EventM e event () -> IO (IO ())) -> EventM e event a -> m (Event t a)
 wrapDomEvent el elementOnevent getValue = wrapDomEventMaybe el elementOnevent $ fmap Just getValue
 
 {-# INLINABLE subscribeDomEvent #-}
@@ -665,7 +681,7 @@ subscribeDomEvent elementOnevent getValue eventChan et = elementOnevent $ do
     writeChan eventChan [TriggerRef etr :=> TriggerInvocation v (return ())]
 
 {-# INLINABLE wrapDomEventMaybe #-}
-wrapDomEventMaybe :: (MonadIO m, TriggerEvent t m)
+wrapDomEventMaybe :: TriggerEvent t m
                   => e
                   -> (e -> EventM e event () -> IO (IO ()))
                   -> EventM e event (Maybe a)

src/Reflex/Dom/Builder/Static.hs

@@ -1,28 +1,42 @@
-{-# LANGUAGE OverloadedStrings, MultiParamTypeClasses, FlexibleInstances, GeneralizedNewtypeDeriving, UndecidableInstances, DataKinds, TypeFamilies, RankNTypes, ConstraintKinds, TypeOperators, FlexibleContexts, LambdaCase, ScopedTypeVariables, PolyKinds, EmptyDataDecls #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.Builder.Static where
 
+import Control.Monad.Identity
+import Control.Monad.Ref
+import Data.Dependent.Sum (DSum (..))
 import Reflex
-import Reflex.Host.Class
 import Reflex.Dom.Builder.Class
 import Reflex.Dom.PerformEvent.Base
 import Reflex.Dom.PerformEvent.Class
 import Reflex.Dom.PostBuild.Class
 import Reflex.Dom.Widget.Basic (applyMap)
-import Control.Monad.Ref
-import Control.Monad.Identity
-import Data.Dependent.Sum (DSum (..))
+import Reflex.Host.Class
 
-import Data.Monoid
-import qualified Data.Map as Map
+import Blaze.ByteString.Builder.Html.Utf8
 import Control.Lens hiding (element)
-import qualified Data.ByteString.Lazy as BL
-import Data.ByteString (ByteString)
+import Control.Monad.Exception
 import Control.Monad.State.Strict
 import Control.Monad.Trans.Control
+import Data.ByteString (ByteString)
 import Data.ByteString.Builder (toLazyByteString)
-import Blaze.ByteString.Builder.Html.Utf8
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.Map as Map
+import Data.Monoid
 import Data.Text.Encoding
-import Control.Monad.Exception
 
 
 newtype StaticDomBuilderT t m a = StaticDomBuilderT

src/Reflex/Dom/Deletable/Class.hs

@@ -1,4 +1,7 @@
-{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.Deletable.Class where
 
 import Reflex

src/Reflex/Dom/DynamicWriter.hs

@@ -1,27 +1,37 @@
-{-# LANGUAGE CPP, FlexibleInstances, MultiParamTypeClasses, TypeFamilies, GeneralizedNewtypeDeriving, UndecidableInstances, FunctionalDependencies, RecursiveDo, ScopedTypeVariables, LambdaCase, GADTs #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.DynamicWriter where
 
 import Reflex
-import Reflex.Host.Class
-import Reflex.Dom.Class
 import Reflex.Dom.Builder.Class
+import Reflex.Dom.Class
 import Reflex.Dom.PerformEvent.Class
 import Reflex.Dom.PostBuild.Class
+import Reflex.Host.Class
 
 import Control.Lens hiding (element)
+import Control.Monad.Exception
 import Control.Monad.IO.Class
-import Control.Monad.State.Strict
 import Control.Monad.Reader
 import Control.Monad.Ref
-import Control.Monad.Exception
-import Data.Map (Map)
-import qualified Data.Map as Map
+import Control.Monad.State.Strict
 import Data.Dependent.Map (DMap)
-import Data.List.NonEmpty (NonEmpty, nonEmpty)
+import Data.Foldable
 import Data.Functor.Compose
 import Data.Functor.Misc
+import Data.List.NonEmpty (NonEmpty, nonEmpty)
+import Data.Map (Map)
+import qualified Data.Map as Map
 import Data.Semigroup
-import Data.Foldable
 import Data.Traversable
 
 instance MonadTrans (DynamicWriterT t w) where

src/Reflex/Dom/Internal.hs

@@ -1,7 +1,20 @@
-{-# LANGUAGE TypeFamilies, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, RankNTypes, GADTs, ScopedTypeVariables, RecursiveDo, UndecidableInstances, NoMonomorphismRestriction, TypeOperators, LambdaCase, ConstraintKinds, CPP #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.Internal where
 
-import Prelude hiding (mapM, mapM_, concat, sequence, sequence_)
+import Prelude hiding (concat, mapM, mapM_, sequence, sequence_)
 
 import Reflex.Dom.Builder.Immediate
 import Reflex.Dom.Class
@@ -9,26 +22,25 @@ import Reflex.Dom.Internal.Foreign
 import Reflex.Dom.PerformEvent.Base
 import Reflex.Dom.PostBuild.Class
 import Reflex.Host.Class
-import Reflex.Spider (Spider, SpiderHost, runSpiderHost, Global)
+import Reflex.Spider (Global, Spider, SpiderHost, runSpiderHost)
 
-import GHCJS.DOM hiding (runWebGUI)
-import qualified GHCJS.DOM.Types as DOM
-import GHCJS.DOM.Node
-import GHCJS.DOM.Element
-import GHCJS.DOM.Document
-import Control.Lens
-import Control.Monad.Reader hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
-import Control.Monad.Ref
 import Control.Concurrent
+import Control.Lens
+import Control.Monad
+import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
+import Control.Monad.Ref
 import Data.ByteString (ByteString)
 import Data.Dependent.Sum (DSum (..))
-import Data.Foldable
+import Data.IORef
+import Data.Maybe
+import Data.Monoid ((<>))
 import qualified Data.Text as T
 import Data.Text.Encoding
-import Data.Monoid ((<>))
-import Data.IORef
-import Control.Monad
-import Data.Maybe
+import GHCJS.DOM hiding (runWebGUI)
+import GHCJS.DOM.Document
+import GHCJS.DOM.Element
+import GHCJS.DOM.Node
+import qualified GHCJS.DOM.Types as DOM
 
 {-# INLINABLE mainWidget #-}
 mainWidget :: (forall x. Widget x ()) -> IO ()

src/Reflex/Dom/Location.hs

@@ -1,8 +1,8 @@
 module Reflex.Dom.Location (getLocationHost, getLocationProtocol) where
 
+import Data.Text (Text)
 import Reflex.Dom.Class
 import qualified Reflex.Dom.Internal.Foreign as F
-import Data.Text (Text)
 
 import Control.Monad.IO.Class
 

src/Reflex/Dom/Old.hs

@@ -1,4 +1,6 @@
-{-# LANGUAGE ConstraintKinds, TypeFamilies, FlexibleContexts #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeFamilies #-}
 module Reflex.Dom.Old where
 
 import Control.Monad.Exception

src/Reflex/Dom/PerformEvent/Base.hs

@@ -1,27 +1,37 @@
-{-# LANGUAGE MultiParamTypeClasses, GeneralizedNewtypeDeriving, FlexibleInstances, TypeFamilies, TypeOperators, RankNTypes, ScopedTypeVariables, StandaloneDeriving, FlexibleContexts, RecursiveDo, UndecidableInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.PerformEvent.Base where
 
-import Reflex
-import Reflex.Host.Class
-import Reflex.Dom.PerformEvent.Class
-import Reflex.Dom.Deletable.Class
 import Foreign.JavaScript.TH
+import Reflex
+import Reflex.Dom.Deletable.Class
+import Reflex.Dom.PerformEvent.Class
+import Reflex.Host.Class
 
+import Control.Lens
+import Control.Monad.Exception
 import Control.Monad.Identity
 import Control.Monad.Ref
 import Control.Monad.State.Strict
-import Control.Monad.Exception
-import Data.Dependent.Sum
-import Data.Maybe
-import Data.Functor.Misc
+import Data.Align
 import Data.Dependent.Map (DMap)
 import qualified Data.Dependent.Map as DMap
-import Data.Word
+import Data.Dependent.Sum
 import Data.Functor.Compose
+import Data.Functor.Misc
+import Data.Maybe
 import Data.Semigroup
 import Data.These
-import Data.Align
-import Control.Lens
+import Data.Word
 
 newtype EventTriggerRef t m a = EventTriggerRef { unEventTriggerRef :: Ref m (Maybe (EventTrigger t a)) }
 

src/Reflex/Dom/PerformEvent/Class.hs

@@ -1,4 +1,12 @@
-{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, TypeFamilies, TypeOperators, RankNTypes, ScopedTypeVariables, FlexibleContexts, UndecidableInstances #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.PerformEvent.Class where
 
 import Reflex

src/Reflex/Dom/PostBuild/Class.hs

@@ -1,17 +1,27 @@
-{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, GeneralizedNewtypeDeriving, TypeFamilies, UndecidableInstances, RecursiveDo, ScopedTypeVariables, DataKinds, TypeOperators, PolyKinds, FunctionalDependencies #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Reflex.Dom.PostBuild.Class where
 
+import Foreign.JavaScript.TH
 import Reflex
-import Reflex.Host.Class
 import Reflex.Dom.Builder.Class
 import Reflex.Dom.PerformEvent.Class
-import Foreign.JavaScript.TH
+import Reflex.Host.Class
 
 import Control.Lens hiding (element)
-import Control.Monad.Reader
-import Control.Monad.Trans.Control
-import Control.Monad.Ref
 import Control.Monad.Exception
+import Control.Monad.Reader
+import Control.Monad.Ref
+import Control.Monad.Trans.Control
 
 class (Reflex t, Monad m) => PostBuild t m | m -> t where
   getPostBuild :: m (Event t ())

src/Reflex/Dom/WebSocket.hs

@@ -1,26 +1,46 @@
-{-# LANGUAGE ForeignFunctionInterface, JavaScriptFFI, CPP, TemplateHaskell, NoMonomorphismRestriction, EmptyDataDecls, RankNTypes, GADTs, RecursiveDo, ScopedTypeVariables, FlexibleInstances, MultiParamTypeClasses, TypeFamilies, FlexibleContexts, DeriveDataTypeable, GeneralizedNewtypeDeriving, StandaloneDeriving, ConstraintKinds, UndecidableInstances, PolyKinds, AllowAmbiguousTypes #-}
+{-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE EmptyDataDecls #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE JavaScriptFFI #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
+{-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 module Reflex.Dom.WebSocket where
 
-import Prelude hiding (div, span, mapM, mapM_, concat, concatMap, all, sequence)
+import Prelude hiding (all, concat, concatMap, div, mapM, mapM_, sequence, span)
 
 import Reflex
+import Reflex.Dom.Class
 import Reflex.Dom.PerformEvent.Class
 import Reflex.Dom.PostBuild.Class
-import Reflex.Dom.Class
 import Reflex.Dom.WebSocket.Foreign
 
 import Control.Concurrent
 import Control.Concurrent.STM
-import Control.Exception (catch, SomeException)
+import Control.Exception (SomeException, catch)
 import Control.Lens
 import Control.Monad hiding (forM, forM_, mapM, mapM_, sequence)
 import Control.Monad.IO.Class
 import Control.Monad.State
-import Data.Maybe (isJust)
 import Data.ByteString (ByteString)
 import Data.Default
 import Data.IORef
+import Data.Maybe (isJust)
 import Data.Text
 
 data WebSocketConfig t

src/Reflex/Dom/Widget/Basic.hs

@@ -1,31 +1,42 @@
-{-# LANGUAGE OverloadedStrings, ScopedTypeVariables, LambdaCase, ConstraintKinds, TypeFamilies, FlexibleContexts, MultiParamTypeClasses, FlexibleInstances, RecursiveDo, GADTs, DataKinds, RankNTypes #-}
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE RecursiveDo #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeFamilies #-}
 module Reflex.Dom.Widget.Basic where
 
+import Reflex.Dom.Builder.Class
 import Reflex.Dom.Class
 import Reflex.Dom.Internal.Foreign ()
 import Reflex.Dom.PostBuild.Class
-import Reflex.Dom.Builder.Class
 
-import Prelude hiding (mapM, mapM_, sequence, sequence_)
-import Reflex
+import Control.Arrow
+import Control.Lens hiding (children, element)
+import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
+import Data.Align
+import Data.Default
+import Data.Either
+import Data.Foldable
 import Data.Functor.Misc
 import Data.Map (Map)
 import qualified Data.Map as Map
+import Data.Maybe
+import Data.Semigroup
 import Data.Set (Set)
 import qualified Data.Set as Set
-import Data.Foldable
-import Data.Traversable
-import Control.Arrow
-import Control.Monad.Reader hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
-import Control.Lens hiding (element, children)
-import Data.These
-import Data.Align
-import Data.Maybe
-import Data.Default
-import Data.Either
-import Data.Semigroup
 import Data.Text (Text)
 import qualified Data.Text as T
+import Data.These
+import Data.Traversable
+import Prelude hiding (mapM, mapM_, sequence, sequence_)
+import Reflex
 
 widgetHoldInternal :: DomBuilder t m => m a -> Event t (m b) -> m (a, Event t b)
 widgetHoldInternal child0 child' = do

src/Reflex/Dom/Widget/Resize.hs

@@ -23,16 +23,16 @@ import qualified Data.Map as Map
 
 -- | A widget that wraps the given widget in a div and fires an event when resized.
 --   Adapted from github.com/marcj/css-element-queries
-resizeDetector :: (DomBuilder t m, PostBuild t m, TriggerEvent t m, PerformEvent t m, MonadHold t m, DomBuilderSpace m ~ GhcjsDomSpace, MonadIO (Performable m), MonadIO m, MonadFix m) => m a -> m (Event t (), a)
+resizeDetector :: (DomBuilder t m, PostBuild t m, TriggerEvent t m, PerformEvent t m, MonadHold t m, DomBuilderSpace m ~ GhcjsDomSpace, MonadIO (Performable m), MonadFix m) => m a -> m (Event t (), a)
 resizeDetector = resizeDetectorWithStyle ""
 
-resizeDetectorWithStyle :: (DomBuilder t m, PostBuild t m, TriggerEvent t m, PerformEvent t m, MonadHold t m, DomBuilderSpace m ~ GhcjsDomSpace, MonadIO (Performable m), MonadIO m, MonadFix m)
+resizeDetectorWithStyle :: (DomBuilder t m, PostBuild t m, TriggerEvent t m, PerformEvent t m, MonadHold t m, DomBuilderSpace m ~ GhcjsDomSpace, MonadIO (Performable m), MonadFix m)
   => Text -- ^ A css style string. Warning: It should not contain the "position" style attribute.
   -> m a -- ^ The embedded widget
   -> m (Event t (), a) -- ^ An 'Event' that fires on resize, and the result of the embedded widget
 resizeDetectorWithStyle styleString = resizeDetectorWithAttrs ("style" =: styleString)
 
-resizeDetectorWithAttrs :: (DomBuilder t m, PostBuild t m, TriggerEvent t m, PerformEvent t m, MonadHold t m, DomBuilderSpace m ~ GhcjsDomSpace, MonadIO (Performable m), MonadIO m, MonadFix m)
+resizeDetectorWithAttrs :: (DomBuilder t m, PostBuild t m, TriggerEvent t m, PerformEvent t m, MonadHold t m, DomBuilderSpace m ~ GhcjsDomSpace, MonadIO (Performable m), MonadFix m)
   => Map Text Text -- ^ A map of attributes. Warning: It should not modify the "position" style attribute.
   -> m a -- ^ The embedded widget
   -> m (Event t (), a) -- ^ An 'Event' that fires on resize, and the result of the embedded widget

src/Reflex/Dom/Xhr/Exception.hs

@@ -2,8 +2,8 @@
 
 module Reflex.Dom.Xhr.Exception where
 
+import Control.Exception (Exception (..))
 import Data.Typeable
-import Control.Exception (Exception(..))
 
 data XhrException = XhrException_Error
                   | XhrException_Aborted

src/Reflex/Dom/Xhr/ResponseType.hs

@@ -2,10 +2,10 @@
 
 module Reflex.Dom.Xhr.ResponseType where
 
-import Data.Typeable
-import Data.Text (Text)
-import GHCJS.DOM.Blob (Blob)
 import Data.ByteString (ByteString)
+import Data.Text (Text)
+import Data.Typeable
+import GHCJS.DOM.Blob (Blob)
 
 data XhrResponseType = XhrResponseType_Default
                      | XhrResponseType_ArrayBuffer

test/BrokenHaltSpec.hs

@@ -2,13 +2,13 @@
 
 module HaltSpec where
 
-import           Control.Monad.IO.Class
-import           Data.Foldable
-import           GHCJS.DOM
+import Control.Monad.IO.Class
+import Data.Foldable
+import GHCJS.DOM
 import qualified Graphics.UI.Gtk as Gtk
-import           Reflex.Dom
-import           Reflex.Spider.Internal (SpiderHostFrame)
-import           Test.Hspec
+import Reflex.Dom
+import Reflex.Spider.Internal (SpiderHostFrame)
+import Test.Hspec
 
 spec :: Spec
 spec = do

test/HaltSpec.hs

@@ -1,11 +1,11 @@
 {-# LANGUAGE FlexibleContexts #-}
 
-import           Control.Monad.IO.Class
-import           Data.Foldable
-import           GHCJS.DOM
+import Control.Monad.IO.Class
+import Data.Foldable
+import GHCJS.DOM
 import qualified Graphics.UI.Gtk as Gtk
-import           Reflex.Dom
-import           Reflex.Spider.Internal (SpiderHostFrame)
+import Reflex.Dom
+import Reflex.Spider.Internal (SpiderHostFrame)
 
 main = do
   getFirstEventAndHalt return