git.iko.soy/patch
on develop help sign in
Use stylish-haskell
43634f3Ryan Trinkle
.stylish-haskell.yamlnew file+154
compare with develop
unifiedsplit
@@ -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 #-}
2{-# LANGUAGE BangPatterns #-}
1{-# LANGUAGE BangPatterns #-}
3−{-# LANGUAGE TupleSections #-}
2+{-# LANGUAGE CPP #-}
4{-# LANGUAGE ScopedTypeVariables #-}
3{-# LANGUAGE ScopedTypeVariables #-}
4+{-# LANGUAGE TupleSections #-}
5{-# LANGUAGE TypeFamilies #-}
5{-# LANGUAGE TypeFamilies #-}
6
6
7-- The instance for NFData (TVar a) is an orphan, but necessary here
7-- The instance for NFData (TVar a) is an orphan, but necessary here
@@ -9,19 +9,19 @@
9
9
10module Main where
10module Main where
11
11
12−import Data.Functor.Misc
13−import Control.Monad.IO.Class
14−import Control.Monad.Identity
15−import Data.Dependent.Sum
16import Control.Concurrent.STM
12import Control.Concurrent.STM
17−import Data.IORef
18import Control.DeepSeq
13import Control.DeepSeq
19import Control.Exception (evaluate)
14import Control.Exception (evaluate)
20−import Reflex
15+import Control.Monad.Identity
21−import Reflex.Host.Class
16+import Control.Monad.IO.Class
22import Criterion.Main
17import Criterion.Main
23import Data.Dependent.Map (DMap)
18import Data.Dependent.Map (DMap)
24import qualified Data.Dependent.Map as DMap
19import 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
25
25
26main :: IO ()
26main :: IO ()
27main = defaultMain
27main = 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 #-}
2{-# OPTIONS_GHC -fno-warn-orphans #-}
16{-# OPTIONS_GHC -fno-warn-orphans #-}
3
17
4module Main where
18module Main where
@@ -9,37 +23,37 @@ import Criterion.Types
9import Reflex
23import Reflex
10import Reflex.Host.Class
24import Reflex.Host.Class
11
25
12−import Reflex.TestPlan
13import Reflex.Plan.Reflex
26import Reflex.Plan.Reflex
27+import Reflex.TestPlan
14
28
15−import Reflex.Spider.Internal (SpiderEventHandle)
16import qualified Reflex.Bench.Focused as Focused
29import qualified Reflex.Bench.Focused as Focused
30+import Reflex.Spider.Internal (SpiderEventHandle)
17
31
18import Control.Applicative
32import Control.Applicative
19import Control.DeepSeq (NFData (..))
33import Control.DeepSeq (NFData (..))
20
34
35+import Prelude
21import System.IO
36import System.IO
22import System.Mem
37import System.Mem
23−import Prelude
24
38
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
32import Control.Arrow
39import Control.Arrow
40+import Control.Concurrent
41+import Control.Concurrent.STM
42+import Control.Exception
33import Control.Monad
43import Control.Monad
44+import Control.Monad.Trans
34import Data.Bool
45import Data.Bool
35−import Control.Concurrent.STM
46+import Data.Function
36import Data.Int
47import Data.Int
37−import Control.Exception
48+import Data.IORef
38−import Text.Read
49+import Data.Monoid
39−import System.Environment
50+import Data.Time.Clock
40import Debug.Trace.LocationTH
51import Debug.Trace.LocationTH
41−import Control.Monad.Trans
52+import GHC.Stats
53+import System.Environment
54+import System.Mem.Weak
42import System.Process
55import System.Process
56+import Text.Read
43
57
44import Unsafe.Coerce
58import Unsafe.Coerce
45
59
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 #-}
2module Data.Functor.Misc where
11module Data.Functor.Misc where
3
12
13+import Control.Monad.Identity
14+import Data.Dependent.Map (DMap)
15+import qualified Data.Dependent.Map as DMap
16+import Data.Dependent.Sum
4import Data.GADT.Compare
17import Data.GADT.Compare
18+import Data.GADT.Show
5import Data.Map (Map)
19import Data.Map (Map)
6import qualified Data.Map as Map
20import 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)
12import Data.These
21import Data.These
13−import Control.Monad.Identity
22+import Data.Typeable hiding (Refl)
14
23
15data WrapArg :: (k -> *) -> (k -> *) -> * -> * where
24data WrapArg :: (k -> *) -> (k -> *) -> * -> * where
16 WrapArg :: f a -> WrapArg g f (g a)
25 WrapArg :: f a -> WrapArg g f (g a)
@@ -70,7 +79,7 @@ wrapDMap f = DMap.mapWithKey $ \_ -> f . runIdentity
70rewrapDMap :: (forall (a :: *). f a -> g a) -> DMap k f -> DMap k g
79rewrapDMap :: (forall (a :: *). f a -> g a) -> DMap k f -> DMap k g
71rewrapDMap f = DMap.mapWithKey $ \_ -> f
80rewrapDMap f = DMap.mapWithKey $ \_ -> f
72
81
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
74unwrapDMap f = DMap.mapWithKey $ \_ -> Identity . f
83unwrapDMap f = DMap.mapWithKey $ \_ -> Identity . f
75
84
76unwrapDMapMaybe :: (forall a. f a -> Maybe a) -> DMap k f -> DMap k Identity
85unwrapDMapMaybe :: (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
6import Control.Monad hiding (forM_, mapM_)
6import Control.Monad hiding (forM_, mapM_)
7import Control.Monad.IO.Class
7import Control.Monad.IO.Class
8import Data.Foldable (forM_, mapM_)
8import Data.Foldable (forM_, mapM_)
9−import Data.IORef
10−import System.Mem.Weak
11import Data.IntMap.Strict (IntMap)
9import Data.IntMap.Strict (IntMap)
12import qualified Data.IntMap.Strict as IntMap
10import qualified Data.IntMap.Strict as IntMap
11+import Data.IORef
12+import System.Mem.Weak
13
13
14data WeakBag a = WeakBag
14data WeakBag a = WeakBag
15 { _weakBag_nextId :: {-# UNPACK #-} !(TVar Int) --TODO: what if this wraps around?
15 { _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 #-}
2module Reflex.Class where
21module Reflex.Class where
3
22
4import Control.Applicative
23import Control.Applicative
5−import Control.Monad.Identity hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
24+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
25+import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
6−import Control.Monad.State.Strict hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
26+import Control.Monad.State.Strict hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
7−import Control.Monad.Reader hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
8−import Control.Monad.Trans.Writer (WriterT())
27+import Control.Monad.Trans.Cont (ContT ())
9−import Control.Monad.Trans.Except (ExceptT())
28+import Control.Monad.Trans.Except (ExceptT ())
10−import Control.Monad.Trans.Cont (ContT())
11−import Control.Monad.Trans.RWS (RWST())
29+import Control.Monad.Trans.RWS (RWST ())
12−import Data.List.NonEmpty (NonEmpty (..))
30+import Control.Monad.Trans.Writer (WriterT ())
13−import Data.These
14import Data.Align
31import Data.Align
15−import Data.GADT.Compare (GEq (..), (:~:) (..))
32+import Data.Bifunctor
16−import Data.GADT.Show (GShow (..))
17−import Data.Dependent.Sum (ShowTag (..))
18−import Data.Map (Map)
19import Data.Dependent.Map (DMap, DSum (..), GCompare (..), GOrdering (..))
33import Data.Dependent.Map (DMap, DSum (..), GCompare (..), GOrdering (..))
20import qualified Data.Dependent.Map as DMap
34import qualified Data.Dependent.Map as DMap
21−import Data.Functor.Misc
35+import Data.Dependent.Sum (ShowTag (..))
22−import Data.Semigroup (Semigroup, (<>), sconcat, stimes, stimesIdempotentMonoid)
23−import Data.Traversable
36+import Data.Foldable
24import Data.Functor.Compose
37import Data.Functor.Compose
25import Data.Functor.Constant
38import 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)
27import Data.Maybe
44import Data.Maybe
28−import Data.Bifunctor
45+import Data.Semigroup (Semigroup, sconcat, stimes, stimesIdempotentMonoid, (<>))
46+import Data.These
47+import Data.Traversable
29
48
30-- Note: must come last to silence warnings due to AMP on GHC < 7.10
49-- 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_)
32
51
33import Debug.Trace (trace)
52import Debug.Trace (trace)
34
53
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 #-}
2module Reflex.Dynamic ( Dynamic -- Abstract so we can preserve the law that the current value is always equal to the most recent update
23module Reflex.Dynamic ( Dynamic -- Abstract so we can preserve the law that the current value is always equal to the most recent update
3 , current
24 , current
4 , updated
25 , updated
@@ -42,20 +63,20 @@ module Reflex.Dynamic ( Dynamic -- Abstract so we can preserve the law that the
42
63
43import Prelude hiding (mapM, mapM_)
64import Prelude hiding (mapM, mapM_)
44
65
45−import Reflex.Class
46import Data.Functor.Misc
66import Data.Functor.Misc
67+import Reflex.Class
47
68
48−import Control.Monad hiding (mapM, mapM_, forM, forM_)
69+import Control.Monad hiding (forM, forM_, mapM, mapM_)
49import Control.Monad.Fix
70import Control.Monad.Fix
50−import Control.Monad.Identity hiding (mapM, mapM_, forM, forM_)
71+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_)
51−import Data.These
52import Data.Align
72import Data.Align
53−import Data.Map (Map)
54import Data.Dependent.Map (DMap)
73import Data.Dependent.Map (DMap)
55import qualified Data.Dependent.Map as DMap
74import qualified Data.Dependent.Map as DMap
56import Data.Dependent.Sum (DSum (..))
75import 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)
58import Data.Monoid
78import Data.Monoid
79+import Data.These
59
80
60import Debug.Trace
81import Debug.Trace
61
82
@@ -291,7 +312,7 @@ data Demux t k = Demux { demuxValue :: Behavior t k
291-- | 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'.
312-- | 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'.
292demux :: (Reflex t, Ord k) => Dynamic t k -> Demux t k
313demux :: (Reflex t, Ord k) => Dynamic t k -> Demux t k
293demux k = Demux (current k)
314demux k = Demux (current k)
294− (fan $ attachWith (\k0 k1 -> if k0 == k1
315+ (fan $ attachWith (\k0 k1 -> if k0 == k1
295 then DMap.empty
316 then DMap.empty
296 else DMap.fromList [Const2 k0 :=> Identity False,
317 else DMap.fromList [Const2 k0 :=> Identity False,
297 Const2 k1 :=> Identity True])
318 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 #-}
2module Reflex.Dynamic.Nub
4module Reflex.Dynamic.Nub
3 ( NubDynamic
5 ( NubDynamic
4 , nubDynamic
6 , 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 #-}
2module Reflex.Dynamic.TH (qDyn, unqDyn, mkDyn) where
7module Reflex.Dynamic.TH (qDyn, unqDyn, mkDyn) where
3
8
4import Reflex.Dynamic
9import Reflex.Dynamic
5
10
6−import Language.Haskell.TH
7−import qualified Language.Haskell.TH.Syntax as TH
8−import Language.Haskell.TH.Quote
9−import Data.Data
10import Control.Monad.State
11import Control.Monad.State
12+import Data.Data
13+import Data.Generics
14+import Data.Monoid
11import qualified Language.Haskell.Exts as Hs
15import qualified Language.Haskell.Exts as Hs
12import qualified Language.Haskell.Meta.Syntax.Translate as Hs
16import qualified Language.Haskell.Meta.Syntax.Translate as Hs
13−import Data.Monoid
17+import Language.Haskell.TH
14−import Data.Generics
18+import Language.Haskell.TH.Quote
19+import qualified Language.Haskell.TH.Syntax as TH
15
20
16-- | 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'
21-- | 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'
17qDyn :: Q Exp -> Q Exp
22qDyn :: 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 #-}
2module Reflex.Host.Class where
15module Reflex.Host.Class where
3
16
4import Reflex.Class
17import Reflex.Class
@@ -7,21 +20,21 @@ import Control.Applicative
7import Control.Monad
20import Control.Monad
8import Control.Monad.Fix
21import Control.Monad.Fix
9import Control.Monad.Identity
22import Control.Monad.Identity
23+import Control.Monad.Ref
10import Control.Monad.Trans
24import Control.Monad.Trans
11−import Control.Monad.Trans.Reader (ReaderT())
25+import Control.Monad.Trans.Cont (ContT ())
12−import Control.Monad.Trans.Writer (WriterT())
13−import Control.Monad.Trans.Cont (ContT())
14−import Control.Monad.Trans.Except (ExceptT())
26+import Control.Monad.Trans.Except (ExceptT ())
27+import Control.Monad.Trans.Reader (ReaderT ())
15−import Control.Monad.Trans.RWS (RWST())
28+import Control.Monad.Trans.RWS (RWST ())
16−import Control.Monad.Trans.State (StateT())
29+import Control.Monad.Trans.State (StateT ())
17import qualified Control.Monad.Trans.State.Strict as Strict
30import qualified Control.Monad.Trans.State.Strict as Strict
31+import Control.Monad.Trans.Writer (WriterT ())
18import Data.Dependent.Sum (DSum (..))
32import Data.Dependent.Sum (DSum (..))
19−import Data.Monoid
20import Data.GADT.Compare
33import Data.GADT.Compare
21−import Control.Monad.Ref
34+import Data.Monoid
22
35
23-- Note: this import must come last to silence warnings from AMP
36-- 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_)
25
38
26-- | Framework implementation support class for the reflex implementation represented by @t@.
39-- | Framework implementation support class for the reflex implementation represented by @t@.
27class (Reflex t, MonadReflexCreateTrigger t (HostFrame t), MonadSample t (HostFrame t), MonadHold t (HostFrame t), MonadFix (HostFrame t), MonadSubscribeEvent t (HostFrame t)) => ReflexHost t where
40class (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
174 type ReadPhase (StateT s m) = ReadPhase m
187 type ReadPhase (StateT s m) = ReadPhase m
175 fireEventsAndRead dm a = lift $ fireEventsAndRead dm a
188 fireEventsAndRead dm a = lift $ fireEventsAndRead dm a
176 runHostFrame = lift . runHostFrame
189 runHostFrame = lift . runHostFrame
177−
190+
178−
191+
179instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (Strict.StateT s m) where
192instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (Strict.StateT s m) where
180 newEventWithTrigger = lift . newEventWithTrigger
193 newEventWithTrigger = lift . newEventWithTrigger
181 newFanEventWithTrigger initializer = lift $ newFanEventWithTrigger initializer
194 newFanEventWithTrigger initializer = lift $ newFanEventWithTrigger initializer
@@ -186,9 +199,9 @@ instance MonadSubscribeEvent t m => MonadSubscribeEvent t (Strict.StateT r m) wh
186instance MonadReflexHost t m => MonadReflexHost t (Strict.StateT s m) where
199instance MonadReflexHost t m => MonadReflexHost t (Strict.StateT s m) where
187 type ReadPhase (Strict.StateT s m) = ReadPhase m
200 type ReadPhase (Strict.StateT s m) = ReadPhase m
188 fireEventsAndRead dm a = lift $ fireEventsAndRead dm a
201 fireEventsAndRead dm a = lift $ fireEventsAndRead dm a
189− runHostFrame = lift . runHostFrame
202+ runHostFrame = lift . runHostFrame
190−
203+
191−
204+
192
205
193instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (ContT r m) where
206instance MonadReflexCreateTrigger t m => MonadReflexCreateTrigger t (ContT r m) where
194 newEventWithTrigger = lift . newEventWithTrigger
207 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 #-}
2module Reflex.Spider.Internal (Spider, SpiderEnv (..), Global, SpiderHost, runSpiderHost, SpiderEventHandle (..), showSubscriberType, showEventType, ComputeM (..), MergeSubscribedParent (..), HasSpiderEnv (..), newSpiderEnv, SpiderPullM (..), SpiderPushM (..), ReadPhase (..)) where
23module Reflex.Spider.Internal (Spider, SpiderEnv (..), Global, SpiderHost, runSpiderHost, SpiderEventHandle (..), showSubscriberType, showEventType, ComputeM (..), MergeSubscribedParent (..), HasSpiderEnv (..), newSpiderEnv, SpiderPullM (..), SpiderPushM (..), ReadPhase (..)) where
3
24
4−import qualified Reflex.Class as R
5−import qualified Reflex.Host.Class as R
6import Data.WeakBag (WeakBag, WeakBagTicket)
25import Data.WeakBag (WeakBag, WeakBagTicket)
7import qualified Data.WeakBag as WeakBag
26import qualified Data.WeakBag as WeakBag
27+import qualified Reflex.Class as R
28+import qualified Reflex.Host.Class as R
8
29
9−import Data.List
30+import Control.Applicative
10−import Data.IORef
31+import Control.Concurrent
11−import System.Mem.Weak
32+import Control.Exception
12−import Data.Foldable
13−import Data.Traversable
14−import Control.Monad hiding (mapM, mapM_, forM_, forM, sequence)
33+import Control.Monad hiding (forM, forM_, mapM, mapM_, sequence)
15−import Control.Monad.Identity hiding (mapM, mapM_, forM_, forM, sequence)
34+import Control.Monad.Exception
35+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence)
16−import Control.Monad.Reader hiding (mapM, mapM_, forM_, forM, sequence)
36+import Control.Monad.Reader hiding (forM, forM_, mapM, mapM_, sequence)
17−import Control.Monad.State hiding (mapM, mapM_, forM_, forM, sequence)
37+import Control.Monad.Ref
18−import Control.Applicative -- Unconditionally import, because otherwise it breaks on GHC 7.10.1RC2
38+import Control.Monad.State hiding (forM, forM_, mapM, mapM_, sequence)
19−import Data.Some (Some)
20−import qualified Data.Some as Some
39+import Data.Align
21import Data.Dependent.Map (DMap, DSum (..))
40import Data.Dependent.Map (DMap, DSum (..))
22import qualified Data.Dependent.Map as DMap
41import qualified Data.Dependent.Map as DMap
42+import Data.Foldable
43+import Data.Function
44+import Data.Functor.Compose
23import Data.GADT.Compare
45import Data.GADT.Compare
24−import Data.Maybe
25import Data.IntMap.Strict (IntMap)
46import Data.IntMap.Strict (IntMap)
26import qualified Data.IntMap.Strict as IntMap
47import qualified Data.IntMap.Strict as IntMap
27−import Control.Monad.Ref
48+import Data.IORef
28−import Control.Monad.Exception
49+import Data.List
50+import Data.Maybe
29import Data.Monoid ((<>))
51import Data.Monoid ((<>))
30−import Data.Functor.Compose
52+import Data.Some (Some)
31−import Control.Exception
53+import qualified Data.Some as Some
32−import Control.Concurrent
33−import Data.Function
34import Data.These
54import Data.These
35−import Data.Align
55+import Data.Traversable
56+import System.Mem.Weak
36
57
37−import GHC.IORef (IORef (..))
38import GHC.Base (IO (..))
58import GHC.Base (IO (..))
59+import GHC.IORef (IORef (..))
39import GHC.Stack
60import GHC.Stack
40
61
62+import Control.Monad.Primitive
63+import Data.Coerce
41import System.IO.Unsafe
64import System.IO.Unsafe
42import Unsafe.Coerce
65import Unsafe.Coerce
43−import Data.Coerce
44−import Control.Monad.Primitive
45
66
46−import qualified Data.List.NonEmpty as NonEmpty
47import Data.List.NonEmpty (NonEmpty (..), nonEmpty)
67import Data.List.NonEmpty (NonEmpty (..), nonEmpty)
68+import qualified Data.List.NonEmpty as NonEmpty
48−import Data.Tree (Tree (..), Forest, drawForest)
69+import Data.Tree (Forest, Tree (..), drawForest)
49
70
50-- Note: must come last to silence warnings due to AMP on GHC < 7.10
71-- 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)
52
73
53type SubscriberList a = WeakBag (Subscriber a)
74type SubscriberList a = WeakBag (Subscriber a)
54type SubscriberListTicket a = WeakBagTicket (Subscriber a)
75type 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 #-}
2
12
3module Reflex.Bench.Focused where
13module Reflex.Bench.Focused where
4
14
5import Reflex
15import Reflex
6import Reflex.TestPlan
16import Reflex.TestPlan
7
17
8−import Control.Monad.Fix
18+import Control.Applicative
9import Control.Monad
19import Control.Monad
20+import Control.Monad.Fix
10import Control.Monad.Identity
21import Control.Monad.Identity
11−import Control.Applicative
12--import Data.Foldable
22--import Data.Foldable
13import Data.Traversable (for)
23import Data.Traversable (for)
14
24
15−import Data.Maybe
25+import qualified Data.Dependent.Map as DMap
16import Data.Map (Map)
26import Data.Map (Map)
17import qualified Data.Map as Map
27import qualified Data.Map as Map
18−import qualified Data.Dependent.Map as DMap
28+import Data.Maybe
19
29
20import Data.Functor.Misc
30import Data.Functor.Misc
21
31
22−import Data.Tuple
23import Data.List
32import Data.List
24import Data.List.Split
33import Data.List.Split
34+import Data.Tuple
25
35
26−import Data.Word
27import Data.Monoid
36import Data.Monoid
37+import Data.Word
28
38
29import Control.DeepSeq
39import Control.DeepSeq
30
40
31−import Prelude hiding (sum, concat)
41+import Prelude hiding (concat, sum)
32
42
33
43
34mergeTree :: Num a => (Monoid (f [a]), Functor f) => Int -> [f a] -> f a
44mergeTree :: 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 #-}
2
8
3module Reflex.Plan.Pure where
9module Reflex.Plan.Pure where
4
10
@@ -14,9 +20,9 @@ import qualified Data.IntMap as IntMap
14import Data.IntSet (IntSet)
20import Data.IntSet (IntSet)
15import qualified Data.IntSet as IntSet
21import qualified Data.IntSet as IntSet
16
22
17−import Data.Monoid
18import Data.Bifunctor
23import Data.Bifunctor
19import Data.Maybe
24import Data.Maybe
25+import Data.Monoid
20import Prelude
26import Prelude
21
27
22
28
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 #-}
2module Reflex.Plan.Reflex
13module Reflex.Plan.Reflex
3 ( TestPlan(..)
14 ( TestPlan(..)
4 , runPlan
15 , runPlan
@@ -28,18 +39,18 @@ import Control.Monad
28import Control.Monad.Identity
39import Control.Monad.Identity
29import Control.Monad.State.Strict
40import Control.Monad.State.Strict
30
41
42+import Control.Monad.Ref
31import Data.Dependent.Sum (DSum (..))
43import Data.Dependent.Sum (DSum (..))
32−import Data.Monoid
33−import Data.Traversable (traverse, sequenceA)
34−import Data.Maybe
35import qualified Data.IntMap.Strict as IntMap
44import 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)
37
48
49+import Control.DeepSeq
50+import Control.Exception
38import Data.IntMap.Strict (IntMap)
51import Data.IntMap.Strict (IntMap)
39import Data.IORef
52import Data.IORef
40import System.Mem
53import System.Mem
41−import Control.Exception
42−import Control.DeepSeq
43
54
44-- Note: this import must come last to silence warnings from AMP
55-- Note: this import must come last to silence warnings from AMP
45import Prelude
56import Prelude
test/Reflex/Pure.hs+11−6
@@ -4,7 +4,12 @@ of Reflex should produce the same results as this implementation, although perfo
4and laziness/strictness may differ.
4and laziness/strictness may differ.
5-}
5-}
6
6
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 #-}
8
13
9-- There are two expected orphan instances in this module:
14-- There are two expected orphan instances in this module:
10-- * MonadSample (Pure t) ((->) t)
15-- * MonadSample (Pure t) ((->) t)
@@ -13,14 +18,14 @@ and laziness/strictness may differ.
13
18
14module Reflex.Pure where
19module Reflex.Pure where
15
20
16−import Reflex.Class
21+import Control.Monad
17−import Data.Functor.Misc
18−import Data.Functor.Identity
19−import Data.MemoTrie
20import Data.Dependent.Map (DMap, GCompare)
22import Data.Dependent.Map (DMap, GCompare)
21import qualified Data.Dependent.Map as DMap
23import qualified Data.Dependent.Map as DMap
22−import Control.Monad
24+import Data.Functor.Identity
25+import Data.Functor.Misc
26+import Data.MemoTrie
23import Data.Monoid
27import Data.Monoid
28+import Reflex.Class
24
29
25data Pure t
30data Pure t
26
31
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 #-}
2
8
3module Reflex.Test
9module Reflex.Test
4 ( testAgreement
10 ( 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 #-}
2module Reflex.Test.CrossImpl (test) where
22module Reflex.Test.CrossImpl (test) where
3
23
4−import Prelude hiding (mapM, mapM_, sequence, sequence_, foldl, and)
24+import Prelude hiding (and, foldl, mapM, mapM_, sequence, sequence_)
5
25
26+import Control.Monad.Ref
6import Reflex.Class
27import Reflex.Class
7−import Reflex.Host.Class
8import Reflex.Dynamic
28import Reflex.Dynamic
9−import qualified Reflex.Spider.Internal as S
29+import Reflex.Host.Class
10import qualified Reflex.Pure as P
30import qualified Reflex.Pure as P
11−import Control.Monad.Ref
31+import qualified Reflex.Spider.Internal as S
12
32
33+import Control.Arrow (second, (&&&))
13−import Control.Monad.Identity hiding (mapM, mapM_, forM, forM_, sequence, sequence_)
34+import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_, sequence, sequence_)
14−import qualified Data.Set as Set
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
15import Data.Map.Strict (Map)
39import Data.Map.Strict (Map)
16import qualified Data.Map.Strict as Map
40import qualified Data.Map.Strict as Map
17−import Control.Arrow (second, (&&&))
41+import qualified Data.Set as Set
18import Data.Traversable
42import 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
24import System.Exit
43import System.Exit
44+import System.Mem
25
45
26import System.IO.Unsafe
46import System.IO.Unsafe
27
47
@@ -81,7 +101,7 @@ testSpider builder (bMap, eMap) = unsafePerformIO $ S.runSpiderHost $ do
81 fireEventsAndRead firing $ sequence =<< readEvent e'Handle
101 fireEventsAndRead firing $ sequence =<< readEvent e'Handle
82 liftIO performGC
102 liftIO performGC
83 return (t, (bOutput, eOutput))
103 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)
85
105
86tracePerf :: Show a => a -> b -> b
106tracePerf :: Show a => a -> b -> b
87tracePerf = flip const
107tracePerf = 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 #-}
2
8
3module Reflex.Test.Micro (testCases) where
9module Reflex.Test.Micro (testCases) where
4
10
5import Reflex
11import Reflex
6import Reflex.TestPlan
12import Reflex.TestPlan
7
13
8−import Control.Monad
9import Control.Applicative
14import Control.Applicative
15+import Control.Monad
10import Data.Char
16import Data.Char
11−import Data.Monoid
12import Data.Functor.Misc
17import Data.Functor.Misc
18+import Data.Monoid
13
19
14import Data.Foldable
20import Data.Foldable
15
21
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 #-}
2
8
3module Main (main) where
9module Main (main) where
4
10
5import Reflex.Test
11import Reflex.Test
6
12
7−import qualified Reflex.Bench.Focused as Focused
8−import qualified Reflex.Test.Micro as Micro
9−import Data.Functor
10import Data.Bifunctor
13import Data.Bifunctor
14+import Data.Functor
11import Data.List
15import Data.List
16+import qualified Reflex.Bench.Focused as Focused
17+import qualified Reflex.Test.Micro as Micro
12
18
13−import System.Exit
14import System.Environment
19import System.Environment
20+import System.Exit
15
21
16import Prelude
22import Prelude
17
23
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 #-}
2module Reflex.TestPlan
13module Reflex.TestPlan
3 ( TestPlan(..)
14 ( TestPlan(..)
4
15
@@ -10,10 +21,10 @@ module Reflex.TestPlan
10
21
11 ) where
22 ) where
12
23
13−import Reflex.Class
24+import Control.DeepSeq
14import Control.Monad.Fix
25import Control.Monad.Fix
15import Data.Word
26import Data.Word
16−import Control.DeepSeq
27+import Reflex.Class
17
28
18
29
19import Prelude
30import Prelude