on develop help sign in
Use stylish-haskell
commit43634f37dbc5da33823549ef847cee5f2822b783 authorRyan Trinkle <ryan.trinkle@gmail.com> dateSun 17 Jul 2016, 19:43 (10 years ago) parente596bab
20 files changed+503−164
.stylish-haskell.yaml+154 bench/Main.hs+9−9 bench/RunAll.hs+30−16 src/Data/Functor/Misc.hs+17−8 src/Data/WeakBag.hs+2−2 src/Reflex/Class.hs+39−20 src/Reflex/Dynamic.hs+29−8 src/Reflex/Dynamic/Nub.hs+3−1 src/Reflex/Dynamic/TH.hs+12−7 src/Reflex/Host/Class.hs+28−15 src/Reflex/Spider/Internal.hs+50−29 test/Reflex/Bench/Focused.hs+18−8 test/Reflex/Plan/Pure.hs+8−2 test/Reflex/Plan/Reflex.hs+18−7 test/Reflex/Pure.hs+11−6 test/Reflex/Test.hs+7−1 test/Reflex/Test/CrossImpl.hs+34−14 test/Reflex/Test/Micro.hs+9−3 test/Reflex/Test/RunAll.hs+11−5 test/Reflex/TestPlan.hs+14−3
.stylish-haskell.yamlnew file+154
@@ -0,0 +1,154 @@
1+# stylish-haskell configuration file
2+# ==================================
3+
4+# The stylish-haskell tool is mainly configured by specifying steps. These steps
5+# are a list, so they have an order, and one specific step may appear more than
6+# once (if needed). Each file is processed by these steps in the given order.
7+steps:
8+ # Convert some ASCII sequences to their Unicode equivalents. This is disabled
9+ # by default.
10+ # - unicode_syntax:
11+ # # In order to make this work, we also need to insert the UnicodeSyntax
12+ # # language pragma. If this flag is set to true, we insert it when it's
13+ # # not already present. You may want to disable it if you configure
14+ # # language extensions using some other method than pragmas. Default:
15+ # # true.
16+ # add_language_pragma: true
17+
18+ # Import cleanup
19+ - imports:
20+ # There are different ways we can align names and lists.
21+ #
22+ # - global: Align the import names and import list throughout the entire
23+ # file.
24+ #
25+ # - file: Like global, but don't add padding when there are no qualified
26+ # imports in the file.
27+ #
28+ # - group: Only align the imports per group (a group is formed by adjacent
29+ # import lines).
30+ #
31+ # - none: Do not perform any alignment.
32+ #
33+ # Default: global.
34+ align: none
35+
36+ # Folowing options affect only import list alignment.
37+ #
38+ # List align has following options:
39+ #
40+ # - after_alias: Import list is aligned with end of import including
41+ # 'as' and 'hiding' keywords.
42+ #
43+ # > import qualified Data.List as List (concat, foldl, foldr, head,
44+ # > init, last, length)
45+ #
46+ # - with_alias: Import list is aligned with start of alias or hiding.
47+ #
48+ # > import qualified Data.List as List (concat, foldl, foldr, head,
49+ # > init, last, length)
50+ #
51+ # - new_line: Import list starts always on new line.
52+ #
53+ # > import qualified Data.List as List
54+ # > (concat, foldl, foldr, head, init, last, length)
55+ #
56+ # Default: after alias
57+ list_align: after_alias
58+
59+ # Long list align style takes effect when import is too long. This is
60+ # determined by 'columns' setting.
61+ #
62+ # - inline: This option will put as much specs on same line as possible.
63+ #
64+ # - new_line: Import list will start on new line.
65+ #
66+ # - new_line_multiline: Import list will start on new line when it's
67+ # short enough to fit to single line. Otherwise it'll be multiline.
68+ #
69+ # - multiline: One line per import list entry.
70+ # Type with contructor list acts like single import.
71+ #
72+ # > import qualified Data.Map as M
73+ # > ( empty
74+ # > , singleton
75+ # > , ...
76+ # > , delete
77+ # > )
78+ #
79+ # Default: inline
80+ long_list_align: inline
81+
82+ # List padding determines indentation of import list on lines after import.
83+ # This option affects 'list_align' and 'long_list_align'.
84+ list_padding: 2
85+
86+ # Separate lists option affects formating of import list for type
87+ # or class. The only difference is single space between type and list
88+ # of constructors, selectors and class functions.
89+ #
90+ # - true: There is single space between Foldable type and list of it's
91+ # functions.
92+ #
93+ # > import Data.Foldable (Foldable (fold, foldl, foldMap))
94+ #
95+ # - false: There is no space between Foldable type and list of it's
96+ # functions.
97+ #
98+ # > import Data.Foldable (Foldable(fold, foldl, foldMap))
99+ #
100+ # Default: true
101+ separate_lists: true
102+
103+ # Language pragmas
104+ - language_pragmas:
105+ # We can generate different styles of language pragma lists.
106+ #
107+ # - vertical: Vertical-spaced language pragmas, one per line.
108+ #
109+ # - compact: A more compact style.
110+ #
111+ # - compact_line: Similar to compact, but wrap each line with
112+ # `{-#LANGUAGE #-}'.
113+ #
114+ # Default: vertical.
115+ style: vertical
116+
117+ # Align affects alignment of closing pragma brackets.
118+ #
119+ # - true: Brackets are aligned in same collumn.
120+ #
121+ # - false: Brackets are not aligned together. There is only one space
122+ # between actual import and closing bracket.
123+ #
124+ # Default: true
125+ align: false
126+
127+ # stylish-haskell can detect redundancy of some language pragmas. If this
128+ # is set to true, it will remove those redundant pragmas. Default: true.
129+ remove_redundant: true
130+
131+ # Align the types in record declarations
132+ # - records: {}
133+
134+ # Replace tabs by spaces. This is disabled by default.
135+ # - tabs:
136+ # # Number of spaces to use for each tab. Default: 8, as specified by the
137+ # # Haskell report.
138+ # spaces: 8
139+
140+ # Remove trailing whitespace
141+ - trailing_whitespace: {}
142+
143+# A common setting is the number of columns (parts of) code will be wrapped
144+# to. Different steps take this into account. Default: 80.
145+columns: 110
146+
147+# Sometimes, language extensions are specified in a cabal file or from the
148+# command line instead of using language pragmas in the file. stylish-haskell
149+# needs to be aware of these, so it can parse the file correctly.
150+#
151+# No language extensions are enabled by default.
152+# language_extensions:
153+ # - TemplateHaskell
154+ # - QuasiQuotes
bench/Main.hs+9−9
@@ -1,7 +1,7 @@
1−{-# LANGUAGE CPP #-}
21{-# LANGUAGE BangPatterns #-}
3−{-# LANGUAGE TupleSections #-}
2+{-# LANGUAGE CPP #-}
43{-# LANGUAGE ScopedTypeVariables #-}
4+{-# LANGUAGE TupleSections #-}
55{-# LANGUAGE TypeFamilies #-}
66
77-- The instance for NFData (TVar a) is an orphan, but necessary here
@@ -9,19 +9,19 @@
99
1010module Main where
1111
12−import Data.Functor.Misc
13−import Control.Monad.IO.Class
14−import Control.Monad.Identity
15−import Data.Dependent.Sum
1612import Control.Concurrent.STM
17−import Data.IORef
1813import Control.DeepSeq
1914import Control.Exception (evaluate)
20−import Reflex
21−import Reflex.Host.Class
15+import Control.Monad.Identity
16+import Control.Monad.IO.Class
2217import Criterion.Main
2318import Data.Dependent.Map (DMap)
2419import qualified Data.Dependent.Map as DMap
20+import Data.Dependent.Sum
21+import Data.Functor.Misc
22+import Data.IORef
23+import Reflex
24+import Reflex.Host.Class
2525
2626main :: IO ()
2727main = defaultMain
bench/RunAll.hs+30−16
@@ -1,4 +1,18 @@
1−{-# LANGUAGE ConstraintKinds, TypeSynonymInstances, BangPatterns, ScopedTypeVariables, TupleSections, GADTs, RankNTypes, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, GeneralizedNewtypeDeriving, ForeignFunctionInterface, ViewPatterns, TemplateHaskell, PatternSynonyms #-}
1+{-# LANGUAGE BangPatterns #-}
2+{-# LANGUAGE ConstraintKinds #-}
3+{-# LANGUAGE FlexibleContexts #-}
4+{-# LANGUAGE FlexibleInstances #-}
5+{-# LANGUAGE ForeignFunctionInterface #-}
6+{-# LANGUAGE GADTs #-}
7+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
8+{-# LANGUAGE MultiParamTypeClasses #-}
9+{-# LANGUAGE PatternSynonyms #-}
10+{-# LANGUAGE RankNTypes #-}
11+{-# LANGUAGE ScopedTypeVariables #-}
12+{-# LANGUAGE TemplateHaskell #-}
13+{-# LANGUAGE TupleSections #-}
14+{-# LANGUAGE TypeSynonymInstances #-}
15+{-# LANGUAGE ViewPatterns #-}
216{-# OPTIONS_GHC -fno-warn-orphans #-}
317
418module Main where
@@ -9,37 +23,37 @@ import Criterion.Types
923import Reflex
1024import Reflex.Host.Class
1125
12−import Reflex.TestPlan
1326import Reflex.Plan.Reflex
27+import Reflex.TestPlan
1428
15−import Reflex.Spider.Internal (SpiderEventHandle)
1629import qualified Reflex.Bench.Focused as Focused
30+import Reflex.Spider.Internal (SpiderEventHandle)
1731
1832import Control.Applicative
1933import Control.DeepSeq (NFData (..))
2034
35+import Prelude
2136import System.IO
2237import System.Mem
23−import Prelude
2438
25−import Data.IORef
26−import System.Mem.Weak
27−import Data.Function
28−import Control.Concurrent
29−import Data.Time.Clock
30−import GHC.Stats
31−import Data.Monoid
3239import Control.Arrow
40+import Control.Concurrent
41+import Control.Concurrent.STM
42+import Control.Exception
3343import Control.Monad
44+import Control.Monad.Trans
3445import Data.Bool
35−import Control.Concurrent.STM
46+import Data.Function
3647import Data.Int
37−import Control.Exception
38−import Text.Read
39−import System.Environment
48+import Data.IORef
49+import Data.Monoid
50+import Data.Time.Clock
4051import Debug.Trace.LocationTH
41−import Control.Monad.Trans
52+import GHC.Stats
53+import System.Environment
54+import System.Mem.Weak
4255import System.Process
56+import Text.Read
4357
4458import Unsafe.Coerce
4559
src/Data/Functor/Misc.hs+17−8
@@ -1,16 +1,25 @@
1−{-# LANGUAGE KindSignatures, GADTs, DeriveDataTypeable, RankNTypes, ScopedTypeVariables, PolyKinds, FlexibleInstances, MultiParamTypeClasses, FlexibleContexts, StandaloneDeriving #-}
1+{-# LANGUAGE DeriveDataTypeable #-}
2+{-# LANGUAGE FlexibleContexts #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE GADTs #-}
5+{-# LANGUAGE KindSignatures #-}
6+{-# LANGUAGE MultiParamTypeClasses #-}
7+{-# LANGUAGE PolyKinds #-}
8+{-# LANGUAGE RankNTypes #-}
9+{-# LANGUAGE ScopedTypeVariables #-}
10+{-# LANGUAGE StandaloneDeriving #-}
211module Data.Functor.Misc where
312
13+import Control.Monad.Identity
14+import Data.Dependent.Map (DMap)
15+import qualified Data.Dependent.Map as DMap
16+import Data.Dependent.Sum
417import Data.GADT.Compare
18+import Data.GADT.Show
519import Data.Map (Map)
620import qualified Data.Map as Map
7−import Data.GADT.Show
8−import Data.Dependent.Sum
9−import Data.Dependent.Map (DMap)
10−import qualified Data.Dependent.Map as DMap
11−import Data.Typeable hiding (Refl)
1221import Data.These
13−import Control.Monad.Identity
22+import Data.Typeable hiding (Refl)
1423
1524data WrapArg :: (k -> *) -> (k -> *) -> * -> * where
1625 WrapArg :: f a -> WrapArg g f (g a)
@@ -70,7 +79,7 @@ wrapDMap f = DMap.mapWithKey $ \_ -> f . runIdentity
7079rewrapDMap :: (forall (a :: *). f a -> g a) -> DMap k f -> DMap k g
7180rewrapDMap f = DMap.mapWithKey $ \_ -> f
7281
73−unwrapDMap :: (forall a. f a -> a) -> DMap k f -> DMap k Identity
82+unwrapDMap :: (forall a. f a -> a) -> DMap k f -> DMap k Identity
7483unwrapDMap f = DMap.mapWithKey $ \_ -> Identity . f
7584
7685unwrapDMapMaybe :: (forall a. f a -> Maybe a) -> DMap k f -> DMap k Identity
src/Data/WeakBag.hs+2−2
@@ -6,10 +6,10 @@ import Control.Exception
66import Control.Monad hiding (forM_, mapM_)
77import Control.Monad.IO.Class
88import Data.Foldable (forM_, mapM_)
9−import Data.IORef
10−import System.Mem.Weak
119import Data.IntMap.Strict (IntMap)
1210import qualified Data.IntMap.Strict as IntMap
11+import Data.IORef
12+import System.Mem.Weak
1313
1414data WeakBag a = WeakBag
1515 { _weakBag_nextId :: {-# UNPACK #-} !(TVar Int) --TODO: what if this wraps around?
src/Reflex/Class.hs+39−20
@@ -1,34 +1,53 @@
1−{-# LANGUAGE TypeFamilies, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, RankNTypes, GADTs, ScopedTypeVariables, FunctionalDependencies, RecursiveDo, UndecidableInstances, GeneralizedNewtypeDeriving, StandaloneDeriving, EmptyDataDecls, NoMonomorphismRestriction, TypeOperators, DeriveDataTypeable, PackageImports, TemplateHaskell, LambdaCase, CPP #-}
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE DeriveDataTypeable #-}
3+{-# LANGUAGE EmptyDataDecls #-}
4+{-# LANGUAGE FlexibleContexts #-}
5+{-# LANGUAGE FlexibleInstances #-}
6+{-# LANGUAGE FunctionalDependencies #-}
7+{-# LANGUAGE GADTs #-}
8+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
9+{-# LANGUAGE LambdaCase #-}
10+{-# LANGUAGE MultiParamTypeClasses #-}
11+{-# LANGUAGE NoMonomorphismRestriction #-}
12+{-# LANGUAGE PackageImports #-}
13+{-# LANGUAGE RankNTypes #-}
14+{-# LANGUAGE RecursiveDo #-}
15+{-# LANGUAGE ScopedTypeVariables #-}
16+{-# LANGUAGE StandaloneDeriving #-}
17+{-# LANGUAGE TemplateHaskell #-}
18+{-# LANGUAGE TypeFamilies #-}
19+{-# LANGUAGE TypeOperators #-}
20+{-# LANGUAGE UndecidableInstances #-}
221module Reflex.Class where
322
423import Control.Applicative
5−import Control.Monad.Identity hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
6−import Control.Monad.State.Strict hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
7−import Control.Monad.Reader hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
8−import Control.Monad.Trans.Writer (WriterT())
9−import Control.Monad.Trans.Except (ExceptT())
10−import Control.Monad.Trans.Cont (ContT())
11−import Control.Monad.Trans.RWS (RWST())
12−import Data.List.NonEmpty (NonEmpty (..))
13−import Data.These
24+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
25+import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
26+import Control.Monad.State.Strict hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
27+import Control.Monad.Trans.Cont (ContT ())
28+import Control.Monad.Trans.Except (ExceptT ())
29+import Control.Monad.Trans.RWS (RWST ())
30+import Control.Monad.Trans.Writer (WriterT ())
1431import Data.Align
15−import Data.GADT.Compare (GEq (..), (:~:) (..))
16−import Data.GADT.Show (GShow (..))
17−import Data.Dependent.Sum (ShowTag (..))
18−import Data.Map (Map)
32+import Data.Bifunctor
1933import Data.Dependent.Map (DMap, DSum (..), GCompare (..), GOrdering (..))
2034import qualified Data.Dependent.Map as DMap
21−import Data.Functor.Misc
22−import Data.Semigroup (Semigroup, (<>), sconcat, stimes, stimesIdempotentMonoid)
23−import Data.Traversable
35+import Data.Dependent.Sum (ShowTag (..))
36+import Data.Foldable
2437import Data.Functor.Compose
2538import Data.Functor.Constant
26−import Data.Foldable
39+import Data.Functor.Misc
40+import Data.GADT.Compare ((:~:) (..), GEq (..))
41+import Data.GADT.Show (GShow (..))
42+import Data.List.NonEmpty (NonEmpty (..))
43+import Data.Map (Map)
2744import Data.Maybe
28−import Data.Bifunctor
45+import Data.Semigroup (Semigroup, sconcat, stimes, stimesIdempotentMonoid, (<>))
46+import Data.These
47+import Data.Traversable
2948
3049-- Note: must come last to silence warnings due to AMP on GHC < 7.10
31−import Prelude hiding (mapM, mapM_, sequence, sequence_, foldl)
50+import Prelude hiding (foldl, mapM, mapM_, sequence, sequence_)
3251
3352import Debug.Trace (trace)
3453
src/Reflex/Dynamic.hs+29−8
@@ -1,4 +1,25 @@
1−{-# LANGUAGE CPP, TypeFamilies, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, RankNTypes, GADTs, ScopedTypeVariables, FunctionalDependencies, RecursiveDo, UndecidableInstances, GeneralizedNewtypeDeriving, StandaloneDeriving, EmptyDataDecls, NoMonomorphismRestriction, TypeOperators, DeriveDataTypeable, PackageImports, TemplateHaskell, LambdaCase, DataKinds, PolyKinds #-}
1+{-# LANGUAGE CPP #-}
2+{-# LANGUAGE DataKinds #-}
3+{-# LANGUAGE DeriveDataTypeable #-}
4+{-# LANGUAGE EmptyDataDecls #-}
5+{-# LANGUAGE FlexibleContexts #-}
6+{-# LANGUAGE FlexibleInstances #-}
7+{-# LANGUAGE FunctionalDependencies #-}
8+{-# LANGUAGE GADTs #-}
9+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
10+{-# LANGUAGE LambdaCase #-}
11+{-# LANGUAGE MultiParamTypeClasses #-}
12+{-# LANGUAGE NoMonomorphismRestriction #-}
13+{-# LANGUAGE PackageImports #-}
14+{-# LANGUAGE PolyKinds #-}
15+{-# LANGUAGE RankNTypes #-}
16+{-# LANGUAGE RecursiveDo #-}
17+{-# LANGUAGE ScopedTypeVariables #-}
18+{-# LANGUAGE StandaloneDeriving #-}
19+{-# LANGUAGE TemplateHaskell #-}
20+{-# LANGUAGE TypeFamilies #-}
21+{-# LANGUAGE TypeOperators #-}
22+{-# LANGUAGE UndecidableInstances #-}
223module Reflex.Dynamic ( Dynamic -- Abstract so we can preserve the law that the current value is always equal to the most recent update
324 , current
425 , updated
@@ -42,20 +63,20 @@ module Reflex.Dynamic ( Dynamic -- Abstract so we can preserve the law that the
4263
4364import Prelude hiding (mapM, mapM_)
4465
45−import Reflex.Class
4666import Data.Functor.Misc
67+import Reflex.Class
4768
48−import Control.Monad hiding (mapM, mapM_, forM, forM_)
69+import Control.Monad hiding (forM, forM_, mapM, mapM_)
4970import Control.Monad.Fix
50−import Control.Monad.Identity hiding (mapM, mapM_, forM, forM_)
51−import Data.These
71+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_)
5272import Data.Align
53−import Data.Map (Map)
5473import Data.Dependent.Map (DMap)
5574import qualified Data.Dependent.Map as DMap
5675import Data.Dependent.Sum (DSum (..))
57−import Data.GADT.Compare (GCompare (..), GEq (..), (:~:) (..), GOrdering (..))
76+import Data.GADT.Compare ((:~:) (..), GCompare (..), GEq (..), GOrdering (..))
77+import Data.Map (Map)
5878import Data.Monoid
79+import Data.These
5980
6081import Debug.Trace
6182
@@ -291,7 +312,7 @@ data Demux t k = Demux { demuxValue :: Behavior t k
291312-- | Demultiplex an input value to a 'Demux' with many outputs. At any given time, whichever output is indicated by the given 'Dynamic' will be 'True'.
292313demux :: (Reflex t, Ord k) => Dynamic t k -> Demux t k
293314demux k = Demux (current k)
294− (fan $ attachWith (\k0 k1 -> if k0 == k1
315+ (fan $ attachWith (\k0 k1 -> if k0 == k1
295316 then DMap.empty
296317 else DMap.fromList [Const2 k0 :=> Identity False,
297318 Const2 k1 :=> Identity True])
src/Reflex/Dynamic/Nub.hs+3−1
@@ -1,4 +1,6 @@
1−{-# LANGUAGE MagicHash, FlexibleInstances, MultiParamTypeClasses #-}
1+{-# LANGUAGE FlexibleInstances #-}
2+{-# LANGUAGE MagicHash #-}
3+{-# LANGUAGE MultiParamTypeClasses #-}
24module Reflex.Dynamic.Nub
35 ( NubDynamic
46 , nubDynamic
src/Reflex/Dynamic/TH.hs+12−7
@@ -1,17 +1,22 @@
1−{-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeOperators, GADTs, EmptyDataDecls, PatternGuards #-}
1+{-# LANGUAGE EmptyDataDecls #-}
2+{-# LANGUAGE GADTs #-}
3+{-# LANGUAGE PatternGuards #-}
4+{-# LANGUAGE ScopedTypeVariables #-}
5+{-# LANGUAGE TemplateHaskell #-}
6+{-# LANGUAGE TypeOperators #-}
27module Reflex.Dynamic.TH (qDyn, unqDyn, mkDyn) where
38
49import Reflex.Dynamic
510
6−import Language.Haskell.TH
7−import qualified Language.Haskell.TH.Syntax as TH
8−import Language.Haskell.TH.Quote
9−import Data.Data
1011import Control.Monad.State
12+import Data.Data
13+import Data.Generics
14+import Data.Monoid
1115import qualified Language.Haskell.Exts as Hs
1216import qualified Language.Haskell.Meta.Syntax.Translate as Hs
13−import Data.Monoid
14−import Data.Generics
17+import Language.Haskell.TH
18+import Language.Haskell.TH.Quote
19+import qualified Language.Haskell.TH.Syntax as TH
1520
1621-- | Quote a Dynamic expression. Within the quoted expression, you can use '$(unqDyn [| x |])' to refer to any expression 'x' of type 'Dynamic t a'; the unquoted result will be of type 'a'
1722qDyn :: Q Exp -> Q Exp
src/Reflex/Host/Class.hs+28−15
@@ -1,4 +1,17 @@
1−{-# LANGUAGE ExistentialQuantification, GADTs, ScopedTypeVariables, TypeFamilies, FlexibleInstances, MultiParamTypeClasses, GeneralizedNewtypeDeriving, RankNTypes, BangPatterns, UndecidableInstances, EmptyDataDecls, RecursiveDo, RoleAnnotations, FunctionalDependencies, FlexibleContexts #-}
1+{-# LANGUAGE EmptyDataDecls #-}
2+{-# LANGUAGE ExistentialQuantification #-}
3+{-# LANGUAGE FlexibleContexts #-}
4+{-# LANGUAGE FlexibleInstances #-}
5+{-# LANGUAGE FunctionalDependencies #-}
6+{-# LANGUAGE GADTs #-}
7+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
8+{-# LANGUAGE MultiParamTypeClasses #-}
9+{-# LANGUAGE RankNTypes #-}
10+{-# LANGUAGE RecursiveDo #-}
11+{-# LANGUAGE RoleAnnotations #-}
12+{-# LANGUAGE ScopedTypeVariables #-}
13+{-# LANGUAGE TypeFamilies #-}
14+{-# LANGUAGE UndecidableInstances #-}
215module Reflex.Host.Class where
316
417import Reflex.Class
@@ -7,21 +20,21 @@ import Control.Applicative
720import Control.Monad
821import Control.Monad.Fix
922import Control.Monad.Identity
23+import Control.Monad.Ref
1024import Control.Monad.Trans
11−import Control.Monad.Trans.Reader (ReaderT())
12−import Control.Monad.Trans.Writer (WriterT())
13−import Control.Monad.Trans.Cont (ContT())
14−import Control.Monad.Trans.Except (ExceptT())
15−import Control.Monad.Trans.RWS (RWST())
16−import Control.Monad.Trans.State (StateT())
25+import Control.Monad.Trans.Cont (ContT ())
26+import Control.Monad.Trans.Except (ExceptT ())
27+import Control.Monad.Trans.Reader (ReaderT ())
28+import Control.Monad.Trans.RWS (RWST ())
29+import Control.Monad.Trans.State (StateT ())
1730import qualified Control.Monad.Trans.State.Strict as Strict
31+import Control.Monad.Trans.Writer (WriterT ())
1832import Data.Dependent.Sum (DSum (..))
19−import Data.Monoid
2033import Data.GADT.Compare
21−import Control.Monad.Ref
34+import Data.Monoid
2235
2336-- Note: this import must come last to silence warnings from AMP
24−import Prelude hiding (mapM, mapM_, sequence, sequence_, foldl)
37+import Prelude hiding (foldl, mapM, mapM_, sequence, sequence_)
2538
2639-- | Framework implementation support class for the reflex implementation represented by @t@.
2740class (Reflex t, MonadReflexCreateTrigger t (HostFrame t), MonadSample t (HostFrame t), MonadHold t (HostFrame t), MonadFix (HostFrame t), MonadSubscribeEvent t (HostFrame t)) => ReflexHost t where
@@ -174,8 +187,8 @@ instance MonadReflexHost t m => MonadReflexHost t (StateT s m) where
174187 type ReadPhase (StateT s m) = ReadPhase m
175188 fireEventsAndRead dm a = lift $ fireEventsAndRead dm a
176189 runHostFrame = lift . runHostFrame
177−
178−
190+
191+
179192instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (Strict.StateT s m) where
180193 newEventWithTrigger = lift . newEventWithTrigger
181194 newFanEventWithTrigger initializer = lift $ newFanEventWithTrigger initializer
@@ -186,9 +199,9 @@ instance MonadSubscribeEvent t m => MonadSubscribeEvent t (Strict.StateT r m) wh
186199instance MonadReflexHost t m => MonadReflexHost t (Strict.StateT s m) where
187200 type ReadPhase (Strict.StateT s m) = ReadPhase m
188201 fireEventsAndRead dm a = lift $ fireEventsAndRead dm a
189− runHostFrame = lift . runHostFrame
190−
191−
202+ runHostFrame = lift . runHostFrame
203+
204+
192205
193206instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (ContT r m) where
194207 newEventWithTrigger = lift . newEventWithTrigger
src/Reflex/Spider/Internal.hs+50−29
@@ -1,54 +1,75 @@
1−{-# LANGUAGE CPP, ExistentialQuantification, GADTs, ScopedTypeVariables, TypeFamilies, FlexibleInstances, MultiParamTypeClasses, GeneralizedNewtypeDeriving, RankNTypes, BangPatterns, UndecidableInstances, EmptyDataDecls, RecursiveDo, RoleAnnotations, LambdaCase, TypeOperators, FlexibleContexts, ConstraintKinds, MagicHash, UnboxedTuples, FunctionalDependencies, MultiWayIf #-}
1+{-# LANGUAGE BangPatterns #-}
2+{-# LANGUAGE CPP #-}
3+{-# LANGUAGE ConstraintKinds #-}
4+{-# LANGUAGE EmptyDataDecls #-}
5+{-# LANGUAGE ExistentialQuantification #-}
6+{-# LANGUAGE FlexibleContexts #-}
7+{-# LANGUAGE FlexibleInstances #-}
8+{-# LANGUAGE FunctionalDependencies #-}
9+{-# LANGUAGE GADTs #-}
10+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
11+{-# LANGUAGE LambdaCase #-}
12+{-# LANGUAGE MagicHash #-}
13+{-# LANGUAGE MultiParamTypeClasses #-}
14+{-# LANGUAGE MultiWayIf #-}
15+{-# LANGUAGE RankNTypes #-}
16+{-# LANGUAGE RecursiveDo #-}
17+{-# LANGUAGE RoleAnnotations #-}
18+{-# LANGUAGE ScopedTypeVariables #-}
19+{-# LANGUAGE TypeFamilies #-}
20+{-# LANGUAGE TypeOperators #-}
21+{-# LANGUAGE UnboxedTuples #-}
22+{-# LANGUAGE UndecidableInstances #-}
223module Reflex.Spider.Internal (Spider, SpiderEnv (..), Global, SpiderHost, runSpiderHost, SpiderEventHandle (..), showSubscriberType, showEventType, ComputeM (..), MergeSubscribedParent (..), HasSpiderEnv (..), newSpiderEnv, SpiderPullM (..), SpiderPushM (..), ReadPhase (..)) where
324
4−import qualified Reflex.Class as R
5−import qualified Reflex.Host.Class as R
625import Data.WeakBag (WeakBag, WeakBagTicket)
726import qualified Data.WeakBag as WeakBag
27+import qualified Reflex.Class as R
28+import qualified Reflex.Host.Class as R
829
9−import Data.List
10−import Data.IORef
11−import System.Mem.Weak
12−import Data.Foldable
13−import Data.Traversable
14−import Control.Monad hiding (mapM, mapM_, forM_, forM, sequence)
15−import Control.Monad.Identity hiding (mapM, mapM_, forM_, forM, sequence)
16−import Control.Monad.Reader hiding (mapM, mapM_, forM_, forM, sequence)
17−import Control.Monad.State hiding (mapM, mapM_, forM_, forM, sequence)
18−import Control.Applicative -- Unconditionally import, because otherwise it breaks on GHC 7.10.1RC2
19−import Data.Some (Some)
20−import qualified Data.Some as Some
30+import Control.Applicative
31+import Control.Concurrent
32+import Control.Exception
33+import Control.Monad hiding (forM, forM_, mapM, mapM_, sequence)
34+import Control.Monad.Exception
35+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence)
36+import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence)
37+import Control.Monad.Ref
38+import Control.Monad.State hiding (forM, forM_, mapM, mapM_, sequence)
39+import Data.Align
2140import Data.Dependent.Map (DMap, DSum (..))
2241import qualified Data.Dependent.Map as DMap
42+import Data.Foldable
43+import Data.Function
44+import Data.Functor.Compose
2345import Data.GADT.Compare
24−import Data.Maybe
2546import Data.IntMap.Strict (IntMap)
2647import qualified Data.IntMap.Strict as IntMap
27−import Control.Monad.Ref
28−import Control.Monad.Exception
48+import Data.IORef
49+import Data.List
50+import Data.Maybe
2951import Data.Monoid ((<>))
30−import Data.Functor.Compose
31−import Control.Exception
32−import Control.Concurrent
33−import Data.Function
52+import Data.Some (Some)
53+import qualified Data.Some as Some
3454import Data.These
35−import Data.Align
55+import Data.Traversable
56+import System.Mem.Weak
3657
37−import GHC.IORef (IORef (..))
3858import GHC.Base (IO (..))
59+import GHC.IORef (IORef (..))
3960import GHC.Stack
4061
62+import Control.Monad.Primitive
63+import Data.Coerce
4164import System.IO.Unsafe
4265import Unsafe.Coerce
43−import Data.Coerce
44−import Control.Monad.Primitive
4566
46−import qualified Data.List.NonEmpty as NonEmpty
4767import Data.List.NonEmpty (NonEmpty (..), nonEmpty)
48−import Data.Tree (Tree (..), Forest, drawForest)
68+import qualified Data.List.NonEmpty as NonEmpty
69+import Data.Tree (Forest, Tree (..), drawForest)
4970
5071-- Note: must come last to silence warnings due to AMP on GHC < 7.10
51−import Prelude hiding (mapM, mapM_, any, sequence, concat)
72+import Prelude hiding (any, concat, mapM, mapM_, sequence)
5273
5374type SubscriberList a = WeakBag (Subscriber a)
5475type SubscriberListTicket a = WeakBagTicket (Subscriber a)
test/Reflex/Bench/Focused.hs+18−8
@@ -1,34 +1,44 @@
1−{-# LANGUAGE RecursiveDo, ConstraintKinds, TypeSynonymInstances, BangPatterns, ScopedTypeVariables, TupleSections, GADTs, RankNTypes, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}
1+{-# LANGUAGE ConstraintKinds #-}
2+{-# LANGUAGE FlexibleContexts #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE GADTs #-}
5+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
6+{-# LANGUAGE MultiParamTypeClasses #-}
7+{-# LANGUAGE RankNTypes #-}
8+{-# LANGUAGE RecursiveDo #-}
9+{-# LANGUAGE ScopedTypeVariables #-}
10+{-# LANGUAGE TupleSections #-}
11+{-# LANGUAGE TypeSynonymInstances #-}
212
313module Reflex.Bench.Focused where
414
515import Reflex
616import Reflex.TestPlan
717
8−import Control.Monad.Fix
18+import Control.Applicative
919import Control.Monad
20+import Control.Monad.Fix
1021import Control.Monad.Identity
11−import Control.Applicative
1222--import Data.Foldable
1323import Data.Traversable (for)
1424
15−import Data.Maybe
25+import qualified Data.Dependent.Map as DMap
1626import Data.Map (Map)
1727import qualified Data.Map as Map
18−import qualified Data.Dependent.Map as DMap
28+import Data.Maybe
1929
2030import Data.Functor.Misc
2131
22−import Data.Tuple
2332import Data.List
2433import Data.List.Split
34+import Data.Tuple
2535
26−import Data.Word
2736import Data.Monoid
37+import Data.Word
2838
2939import Control.DeepSeq
3040
31−import Prelude hiding (sum, concat)
41+import Prelude hiding (concat, sum)
3242
3343
3444mergeTree :: Num a => (Monoid (f [a]), Functor f) => Int -> [f a] -> f a
test/Reflex/Plan/Pure.hs+8−2
@@ -1,4 +1,10 @@
1−{-# LANGUAGE GADTs, RankNTypes, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, GeneralizedNewtypeDeriving, ScopedTypeVariables #-}
1+{-# LANGUAGE FlexibleContexts #-}
2+{-# LANGUAGE FlexibleInstances #-}
3+{-# LANGUAGE GADTs #-}
4+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
5+{-# LANGUAGE MultiParamTypeClasses #-}
6+{-# LANGUAGE RankNTypes #-}
7+{-# LANGUAGE ScopedTypeVariables #-}
28
39module Reflex.Plan.Pure where
410
@@ -14,9 +20,9 @@ import qualified Data.IntMap as IntMap
1420import Data.IntSet (IntSet)
1521import qualified Data.IntSet as IntSet
1622
17−import Data.Monoid
1823import Data.Bifunctor
1924import Data.Maybe
25+import Data.Monoid
2026import Prelude
2127
2228
test/Reflex/Plan/Reflex.hs+18−7
@@ -1,4 +1,15 @@
1−{-# LANGUAGE FunctionalDependencies, BangPatterns, UndecidableInstances, ConstraintKinds, GADTs, ScopedTypeVariables, FlexibleInstances, MultiParamTypeClasses, GeneralizedNewtypeDeriving, RankNTypes, RecursiveDo, FlexibleContexts, StandaloneDeriving #-}
1+{-# LANGUAGE ConstraintKinds #-}
2+{-# LANGUAGE FlexibleContexts #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE FunctionalDependencies #-}
5+{-# LANGUAGE GADTs #-}
6+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
7+{-# LANGUAGE MultiParamTypeClasses #-}
8+{-# LANGUAGE RankNTypes #-}
9+{-# LANGUAGE RecursiveDo #-}
10+{-# LANGUAGE ScopedTypeVariables #-}
11+{-# LANGUAGE StandaloneDeriving #-}
12+{-# LANGUAGE UndecidableInstances #-}
213module Reflex.Plan.Reflex
314 ( TestPlan(..)
415 , runPlan
@@ -28,18 +39,18 @@ import Control.Monad
2839import Control.Monad.Identity
2940import Control.Monad.State.Strict
3041
42+import Control.Monad.Ref
3143import Data.Dependent.Sum (DSum (..))
32−import Data.Monoid
33−import Data.Traversable (traverse, sequenceA)
34−import Data.Maybe
3544import qualified Data.IntMap.Strict as IntMap
36−import Control.Monad.Ref
45+import Data.Maybe
46+import Data.Monoid
47+import Data.Traversable (sequenceA, traverse)
3748
49+import Control.DeepSeq
50+import Control.Exception
3851import Data.IntMap.Strict (IntMap)
3952import Data.IORef
4053import System.Mem
41−import Control.Exception
42−import Control.DeepSeq
4354
4455-- Note: this import must come last to silence warnings from AMP
4556import Prelude
test/Reflex/Pure.hs+11−6
@@ -4,7 +4,12 @@ of Reflex should produce the same results as this implementation, although perfo
44and laziness/strictness may differ.
55-}
66
7−{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, EmptyDataDecls, InstanceSigs, FlexibleInstances, ScopedTypeVariables #-}
7+{-# LANGUAGE EmptyDataDecls #-}
8+{-# LANGUAGE FlexibleInstances #-}
9+{-# LANGUAGE InstanceSigs #-}
10+{-# LANGUAGE MultiParamTypeClasses #-}
11+{-# LANGUAGE ScopedTypeVariables #-}
12+{-# LANGUAGE TypeFamilies #-}
813
914-- There are two expected orphan instances in this module:
1015-- * MonadSample (Pure t) ((->) t)
@@ -13,14 +18,14 @@ and laziness/strictness may differ.
1318
1419module Reflex.Pure where
1520
16−import Reflex.Class
17−import Data.Functor.Misc
18−import Data.Functor.Identity
19−import Data.MemoTrie
21+import Control.Monad
2022import Data.Dependent.Map (DMap, GCompare)
2123import qualified Data.Dependent.Map as DMap
22−import Control.Monad
24+import Data.Functor.Identity
25+import Data.Functor.Misc
26+import Data.MemoTrie
2327import Data.Monoid
28+import Reflex.Class
2429
2530data Pure t
2631
test/Reflex/Test.hs+7−1
@@ -1,4 +1,10 @@
1−{-# LANGUAGE ConstraintKinds, GADTs, RankNTypes, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}
1+{-# LANGUAGE ConstraintKinds #-}
2+{-# LANGUAGE FlexibleContexts #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE GADTs #-}
5+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
6+{-# LANGUAGE MultiParamTypeClasses #-}
7+{-# LANGUAGE RankNTypes #-}
28
39module Reflex.Test
410 ( testAgreement
test/Reflex/Test/CrossImpl.hs+34−14
@@ -1,27 +1,47 @@
1−{-# LANGUAGE TypeFamilies, FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, RankNTypes, GADTs, ScopedTypeVariables, FunctionalDependencies, RecursiveDo, UndecidableInstances, GeneralizedNewtypeDeriving, StandaloneDeriving, EmptyDataDecls, NoMonomorphismRestriction, TypeOperators, DeriveDataTypeable, PackageImports, TemplateHaskell, LambdaCase, BangPatterns, ConstraintKinds #-}
1+{-# LANGUAGE ConstraintKinds #-}
2+{-# LANGUAGE DeriveDataTypeable #-}
3+{-# LANGUAGE EmptyDataDecls #-}
4+{-# LANGUAGE ExistentialQuantification #-}
5+{-# LANGUAGE FlexibleContexts #-}
6+{-# LANGUAGE FlexibleInstances #-}
7+{-# LANGUAGE FunctionalDependencies #-}
8+{-# LANGUAGE GADTs #-}
9+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
10+{-# LANGUAGE LambdaCase #-}
11+{-# LANGUAGE MultiParamTypeClasses #-}
12+{-# LANGUAGE NoMonomorphismRestriction #-}
13+{-# LANGUAGE PackageImports #-}
14+{-# LANGUAGE RankNTypes #-}
15+{-# LANGUAGE RecursiveDo #-}
16+{-# LANGUAGE ScopedTypeVariables #-}
17+{-# LANGUAGE StandaloneDeriving #-}
18+{-# LANGUAGE TemplateHaskell #-}
19+{-# LANGUAGE TypeFamilies #-}
20+{-# LANGUAGE TypeOperators #-}
21+{-# LANGUAGE UndecidableInstances #-}
222module Reflex.Test.CrossImpl (test) where
323
4−import Prelude hiding (mapM, mapM_, sequence, sequence_, foldl, and)
24+import Prelude hiding (and, foldl, mapM, mapM_, sequence, sequence_)
525
26+import Control.Monad.Ref
627import Reflex.Class
7−import Reflex.Host.Class
828import Reflex.Dynamic
9−import qualified Reflex.Spider.Internal as S
29+import Reflex.Host.Class
1030import qualified Reflex.Pure as P
11−import Control.Monad.Ref
31+import qualified Reflex.Spider.Internal as S
1232
13−import Control.Monad.Identity hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
14−import qualified Data.Set as Set
33+import Control.Arrow (second, (&&&))
34+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
35+import Control.Monad.State.Strict hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
36+import Control.Monad.Writer hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
37+import Data.Dependent.Map (DSum (..))
38+import Data.Foldable
1539import Data.Map.Strict (Map)
1640import qualified Data.Map.Strict as Map
17−import Control.Arrow (second, (&&&))
41+import qualified Data.Set as Set
1842import Data.Traversable
19−import Data.Foldable
20−import Control.Monad.State.Strict hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
21−import Control.Monad.Writer hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
22−import Data.Dependent.Map (DSum (..))
23−import System.Mem
2443import System.Exit
44+import System.Mem
2545
2646import System.IO.Unsafe
2747
@@ -81,7 +101,7 @@ testSpider builder (bMap, eMap) = unsafePerformIO $ S.runSpiderHost $ do
81101 fireEventsAndRead firing $ sequence =<< readEvent e'Handle
82102 liftIO performGC
83103 return (t, (bOutput, eOutput))
84− return (Map.fromList $ map (second fst) outputs, Map.mapMaybe id $ Map.fromList $ map (second snd) outputs)
104+ return (Map.fromList $ map (second fst) outputs, Map.mapMaybe id $ Map.fromList $ map (second snd) outputs)
85105
86106tracePerf :: Show a => a -> b -> b
87107tracePerf = flip const
test/Reflex/Test/Micro.hs+9−3
@@ -1,15 +1,21 @@
1−{-# LANGUAGE ConstraintKinds, GADTs, RankNTypes, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}
1+{-# LANGUAGE ConstraintKinds #-}
2+{-# LANGUAGE FlexibleContexts #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE GADTs #-}
5+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
6+{-# LANGUAGE MultiParamTypeClasses #-}
7+{-# LANGUAGE RankNTypes #-}
28
39module Reflex.Test.Micro (testCases) where
410
511import Reflex
612import Reflex.TestPlan
713
8−import Control.Monad
914import Control.Applicative
15+import Control.Monad
1016import Data.Char
11−import Data.Monoid
1217import Data.Functor.Misc
18+import Data.Monoid
1319
1420import Data.Foldable
1521
test/Reflex/Test/RunAll.hs+11−5
@@ -1,17 +1,23 @@
1−{-# LANGUAGE ConstraintKinds, GADTs, RankNTypes, FlexibleInstances, FlexibleContexts, MultiParamTypeClasses, GeneralizedNewtypeDeriving #-}
1+{-# LANGUAGE ConstraintKinds #-}
2+{-# LANGUAGE FlexibleContexts #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE GADTs #-}
5+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
6+{-# LANGUAGE MultiParamTypeClasses #-}
7+{-# LANGUAGE RankNTypes #-}
28
39module Main (main) where
410
511import Reflex.Test
612
7−import qualified Reflex.Bench.Focused as Focused
8−import qualified Reflex.Test.Micro as Micro
9−import Data.Functor
1013import Data.Bifunctor
14+import Data.Functor
1115import Data.List
16+import qualified Reflex.Bench.Focused as Focused
17+import qualified Reflex.Test.Micro as Micro
1218
13−import System.Exit
1419import System.Environment
20+import System.Exit
1521
1622import Prelude
1723
test/Reflex/TestPlan.hs+14−3
@@ -1,4 +1,15 @@
1−{-# LANGUAGE FunctionalDependencies, BangPatterns, UndecidableInstances, ConstraintKinds, GADTs, ScopedTypeVariables, FlexibleInstances, MultiParamTypeClasses, GeneralizedNewtypeDeriving, RankNTypes, RecursiveDo, FlexibleContexts, StandaloneDeriving #-}
1+{-# LANGUAGE ConstraintKinds #-}
2+{-# LANGUAGE FlexibleContexts #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE FunctionalDependencies #-}
5+{-# LANGUAGE GADTs #-}
6+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
7+{-# LANGUAGE MultiParamTypeClasses #-}
8+{-# LANGUAGE RankNTypes #-}
9+{-# LANGUAGE RecursiveDo #-}
10+{-# LANGUAGE ScopedTypeVariables #-}
11+{-# LANGUAGE StandaloneDeriving #-}
12+{-# LANGUAGE UndecidableInstances #-}
213module Reflex.TestPlan
314 ( TestPlan(..)
415
@@ -10,10 +21,10 @@ module Reflex.TestPlan
1021
1122 ) where
1223
13−import Reflex.Class
24+import Control.DeepSeq
1425import Control.Monad.Fix
1526import Data.Word
16−import Control.DeepSeq
27+import Reflex.Class
1728
1829
1930import Prelude