From ce4244d48a89dea4ff7f50a69e3e518d8e39a5a3 Mon Sep 17 00:00:00 2001 From: ymeister <47071325+ymeister@users.noreply.github.com> Date: Wed, 7 Aug 2024 07:48:03 +0400 Subject: [PATCH] Update bounds with 'cabal-bounds' & clean warnings --- .github/workflows/haskell.yml | 2 +- .gitignore | 1 + reflex.cabal | 948 +++++++++++++------------- src/Control/Monad/ReaderIO.hs | 10 +- src/Data/AppendMap.hs | 3 +- src/Data/FastMutableIntMap.hs | 3 +- src/Data/FastWeakBag.hs | 1 + src/Data/Map/Misc.hs | 1 + src/Data/WeakBag.hs | 1 + src/Reflex.hs | 1 + src/Reflex/Adjustable/Class.hs | 1 + src/Reflex/BehaviorWriter/Base.hs | 7 +- src/Reflex/BehaviorWriter/Class.hs | 1 + src/Reflex/Class.hs | 9 +- src/Reflex/Collection.hs | 6 +- src/Reflex/Dynamic.hs | 18 +- src/Reflex/Dynamic/TH.hs | 10 +- src/Reflex/Dynamic/Uniq.hs | 9 +- src/Reflex/DynamicWriter/Base.hs | 11 +- src/Reflex/DynamicWriter/Class.hs | 1 + src/Reflex/EventWriter/Base.hs | 1 + src/Reflex/EventWriter/Class.hs | 4 + src/Reflex/FunctorMaybe.hs | 2 +- src/Reflex/Host/Class.hs | 2 + src/Reflex/Host/Headless.hs | 1 + src/Reflex/Network.hs | 1 + src/Reflex/NotReady/Class.hs | 2 + src/Reflex/PerformEvent/Base.hs | 28 +- src/Reflex/PerformEvent/Class.hs | 7 +- src/Reflex/PostBuild/Base.hs | 23 +- src/Reflex/PostBuild/Class.hs | 1 + src/Reflex/Profiled.hs | 11 +- src/Reflex/Pure.hs | 6 +- src/Reflex/Query/Base.hs | 8 +- src/Reflex/Query/Class.hs | 8 +- src/Reflex/Requester/Base/Internal.hs | 29 +- src/Reflex/Requester/Class.hs | 2 + src/Reflex/Spider.hs | 23 +- src/Reflex/Spider/Internal.hs | 68 +- src/Reflex/Time.hs | 18 +- src/Reflex/TriggerEvent/Base.hs | 11 +- src/Reflex/TriggerEvent/Class.hs | 1 + src/Reflex/Workflow.hs | 9 +- test/DebugCycles.hs | 2 +- 44 files changed, 706 insertions(+), 606 deletions(-) diff --git a/.github/workflows/haskell.yml b/.github/workflows/haskell.yml index dc3c98e9..940cb020 100644 --- a/.github/workflows/haskell.yml +++ b/.github/workflows/haskell.yml @@ -6,7 +6,7 @@ jobs: build: strategy: matrix: - ghc: ['8.4.4', '8.6.5', '8.8.4', '8.10.7', '9.0.2', '9.2.5', '9.4.5', '9.6.1'] + ghc: ['8.4.4', '8.6.5', '8.8.4', '8.10.7', '9.0.2', '9.2.5', '9.4.5', '9.6.1', '9.8.2', '9.10.1'] os: ['ubuntu-latest', 'macos-latest'] runs-on: ${{ matrix.os }} diff --git a/.gitignore b/.gitignore index 0cab7d45..29495b2e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ dist cabal.sandbox.config +cabal.project.local .cabal-sandbox/ dist-* cabal-dev diff --git a/reflex.cabal b/reflex.cabal index ef0b397c..3fd84ee0 100644 --- a/reflex.cabal +++ b/reflex.cabal @@ -1,510 +1,532 @@ -Name: reflex -Version: 0.9.3.0 -Synopsis: Higher-order Functional Reactive Programming -Description: - Interactive programs without callbacks or side-effects. - Functional Reactive Programming (FRP) uses composable events and time-varying - values to describe interactive systems as pure functions. - Just like other pure functional code, functional reactive code is easier - to get right on the first try, maintain, and reuse. - . - Reflex is a fully-deterministic, higher-order Functional Reactive Programming - interface and an engine that efficiently implements that interface. - . - -License: BSD3 -License-file: LICENSE -Author: Ryan Trinkle -Maintainer: ryan.trinkle@gmail.com -Stability: Experimental -Category: FRP -Build-type: Simple -Cabal-version: 1.22 -homepage: https://reflex-frp.org -bug-reports: https://github.com/reflex-frp/reflex/issues +cabal-version: 1.22 +name: reflex +version: 0.9.3.0 +license: BSD3 +license-file: LICENSE +maintainer: ryan.trinkle@gmail.com +author: Ryan Trinkle +stability: Experimental +tested-with: + ghc ==8.4.4 || ==8.6.5 || ==8.8.1 || ==8.10.7 || ==9.0.1 || ==9.2.5 || ==9.4.5 || ==9.6.1 || ==9.8.2 || ==9.10.1 + ghcjs ==8.6 || ==8.10 + +homepage: https://reflex-frp.org +bug-reports: https://github.com/reflex-frp/reflex/issues +synopsis: Higher-order Functional Reactive Programming +description: + Interactive programs without callbacks or side-effects. + Functional Reactive Programming (FRP) uses composable events and time-varying + values to describe interactive systems as pure functions. + Just like other pure functional code, functional reactive code is easier + to get right on the first try, maintain, and reuse. + . + Reflex is a fully-deterministic, higher-order Functional Reactive Programming + interface and an engine that efficiently implements that interface. + . + + +category: FRP +build-type: Simple extra-source-files: - README.md - Quickref.md - ChangeLog.md + README.md + Quickref.md + ChangeLog.md -tested-with: - GHC ==8.4.4 || ==8.6.5 || ==8.8.1 || ==8.10.7 || ==9.0.1 || ==9.2.5 || ==9.4.5 || ==9.6.1, - GHCJS ==8.6 || ==8.10 +source-repository head + type: git + location: https://github.com/reflex-frp/reflex flag use-reflex-optimizer - description: Use the GHC plugin Reflex.Optimizer on some of the modules in the package. This is still experimental. - default: False - manual: True + description: + Use the GHC plugin Reflex.Optimizer on some of the modules in the package. This is still experimental. + + default: False + manual: True flag use-template-haskell - description: Use template haskell to generate lenses - default: True - manual: True + description: Use template haskell to generate lenses + manual: True flag debug-trace-events - description: Add instrumentation that outputs the stack trace of the definition of an event whenever it is subscribed to. Warning: It is very slow! - default: False - manual: True + description: + Add instrumentation that outputs the stack trace of the definition of an event whenever it is subscribed to. Warning: It is very slow! + + default: False + manual: True flag fast-weak - description: Use the primitive implementation of FastWeak in GHCJS; note that this requires GHCJS to be built with FastWeak and FastWeakBag present in the RTS, which is not the default - default: False - manual: True + description: + Use the primitive implementation of FastWeak in GHCJS; note that this requires GHCJS to be built with FastWeak and FastWeakBag present in the RTS, which is not the default + + default: False + manual: True flag debug-propagation - description: Enable debugging of spider internals - default: False - manual: True + description: Enable debugging of spider internals + default: False + manual: True flag debug-cycles - description: Enable debugging of event cycles - default: False - manual: True + description: Enable debugging of event cycles + default: False + manual: True flag split-these - description: Use split these/semialign packages - manual: False - default: True + description: Use split these/semialign packages library - default-language: Haskell2010 - hs-source-dirs: src - build-depends: - MemoTrie == 0.6.*, - base >= 4.11 && <= 4.21, - bifunctors >= 5.2 && < 5.7, - comonad >= 5.0.4 && < 5.1, - commutative-semigroups >= 0.1 && <= 0.2.0.1, - constraints >= 0.10 && <= 0.14.2, - constraints-extras >= 0.3 && < 0.5, - containers >= 0.6 && <= 0.7, - data-default >= 0.5 && < 0.8, - dependent-map >= 0.3 && < 0.5, - exceptions >= 0.10 && < 0.11, - exception-transformers >= 0.4 && < 0.5, - lens >= 4.7 && <= 5.3.2, - mmorph >= 1.0 && < 1.3, - monad-control >= 1.0.1 && < 1.1, - mtl >= 2.1 && < 2.4, - patch >= 0.0.7 && < 0.1, - prim-uniq >= 0.1.0.1 && < 0.3, - primitive >= 0.5 && <= 0.9.1.0, - profunctors >= 5.3 && < 5.7, - random >= 1.1 && < 1.3, - ref-tf >= 0.4 && < 0.6, - reflection == 2.1.*, - semigroupoids >= 4.0 && < 7, - stm >= 2.4 && < 2.6, - syb >= 0.5 && < 0.8, - time >= 1.4 && < 1.13, - transformers >= 0.5 && < 0.7, - unbounded-delays >= 0.1.0.0 && < 0.2, - witherable >= 0.4 && < 0.5 - - if flag(split-these) - build-depends: these >= 1 && <1.3, - semialign >=1 && <1.4, - monoidal-containers >= 0.6.2.0 && < 0.7 - else - build-depends: these >= 0.4 && <0.9, - monoidal-containers == 0.4.0.0 - - exposed-modules: - Control.Monad.ReaderIO - Data.AppendMap, - Data.FastMutableIntMap, - Data.FastWeakBag, - Data.Map.Misc, - Data.WeakBag, - Reflex, - Reflex.Class, - Reflex.Adjustable.Class, - Reflex.BehaviorWriter.Base, - Reflex.BehaviorWriter.Class, - Reflex.Collection, - Reflex.Dynamic, - Reflex.Dynamic.Uniq, - Reflex.DynamicWriter, - Reflex.DynamicWriter.Base, - Reflex.DynamicWriter.Class, - Reflex.EventWriter, - Reflex.EventWriter.Base, - Reflex.EventWriter.Class, - Reflex.FastWeak, - Reflex.FunctorMaybe, - Reflex.Host.Class, - Reflex.Host.Headless, - Reflex.Network, - Reflex.NotReady.Class, - Reflex.PerformEvent.Base, - Reflex.PerformEvent.Class, - Reflex.PostBuild.Base, - Reflex.PostBuild.Class, - Reflex.Profiled, - Reflex.Pure, - Reflex.Query.Base, - Reflex.Query.Class, - Reflex.Requester.Base, - Reflex.Requester.Base.Internal, - Reflex.Requester.Class, - Reflex.Spider, - Reflex.Spider.Internal, - Reflex.Time, - Reflex.TriggerEvent.Base, - Reflex.TriggerEvent.Class, - Reflex.Widget.Basic, - Reflex.Workflow - - reexported-modules: - patch:Data.Functor.Misc, - patch:Data.Patch as Reflex.Patch, - patch:Data.Patch.Class as Reflex.Patch.Class, - patch:Data.Patch.DMap as Reflex.Patch.DMap, - patch:Data.Patch.DMapWithMove as Reflex.Patch.DMapWithMove, - patch:Data.Patch.IntMap as Reflex.Patch.IntMap, - patch:Data.Patch.Map as Reflex.Patch.Map, - patch:Data.Patch.MapWithMove as Reflex.Patch.MapWithMove - - ghc-options: -Wall -fwarn-redundant-constraints -fwarn-tabs -funbox-strict-fields -O2 -fspecialise-aggressively - - if flag(debug-trace-events) - cpp-options: -DDEBUG_TRACE_EVENTS - build-depends: - bytestring >= 0.10.8 && < 0.11 - - if flag(use-reflex-optimizer) - cpp-options: -DUSE_REFLEX_OPTIMIZER - build-depends: ghc - exposed-modules: Reflex.Optimizer - - if flag(debug-propagation) - cpp-options: -DDEBUG -DDEBUG_TRACE_PROPAGATION -DDEBUG_TRACE_INVALIDATION - - if flag(debug-cycles) - cpp-options: -DDEBUG_CYCLES - - if flag(use-template-haskell) - cpp-options: -DUSE_TEMPLATE_HASKELL - build-depends: - dependent-sum >= 0.6 && < 0.8, - haskell-src-exts >= 1.16 && < 1.24, - haskell-src-meta >= 0.6 && < 0.9, - template-haskell >= 2.9 && <= 2.22.0.0 exposed-modules: - Reflex.Dynamic.TH - other-extensions: TemplateHaskell - else - build-depends: - dependent-sum >= 0.6 && < 0.8 - - if flag(fast-weak) && impl(ghcjs) - cpp-options: -DGHCJS_FAST_WEAK + Control.Monad.ReaderIO + Data.AppendMap + Data.FastMutableIntMap + Data.FastWeakBag + Data.Map.Misc + Data.WeakBag + Reflex + Reflex.Class + Reflex.Adjustable.Class + Reflex.BehaviorWriter.Base + Reflex.BehaviorWriter.Class + Reflex.Collection + Reflex.Dynamic + Reflex.Dynamic.Uniq + Reflex.DynamicWriter + Reflex.DynamicWriter.Base + Reflex.DynamicWriter.Class + Reflex.EventWriter + Reflex.EventWriter.Base + Reflex.EventWriter.Class + Reflex.FastWeak + Reflex.FunctorMaybe + Reflex.Host.Class + Reflex.Host.Headless + Reflex.Network + Reflex.NotReady.Class + Reflex.PerformEvent.Base + Reflex.PerformEvent.Class + Reflex.PostBuild.Base + Reflex.PostBuild.Class + Reflex.Profiled + Reflex.Pure + Reflex.Query.Base + Reflex.Query.Class + Reflex.Requester.Base + Reflex.Requester.Base.Internal + Reflex.Requester.Class + Reflex.Spider + Reflex.Spider.Internal + Reflex.Time + Reflex.TriggerEvent.Base + Reflex.TriggerEvent.Class + Reflex.Widget.Basic + Reflex.Workflow + + reexported-modules: + patch:Data.Functor.Misc, + patch:Data.Patch as Reflex.Patch, + patch:Data.Patch.Class as Reflex.Patch.Class, + patch:Data.Patch.DMap as Reflex.Patch.DMap, + patch:Data.Patch.DMapWithMove as Reflex.Patch.DMapWithMove, + patch:Data.Patch.IntMap as Reflex.Patch.IntMap, + patch:Data.Patch.Map as Reflex.Patch.Map, + patch:Data.Patch.MapWithMove as Reflex.Patch.MapWithMove + + hs-source-dirs: src + default-language: Haskell2010 + ghc-options: + -Wall -fwarn-redundant-constraints -fwarn-tabs + -funbox-strict-fields -O2 -fspecialise-aggressively - if impl(ghcjs) build-depends: - ghcjs-base == 0.2.* + MemoTrie >=0.6 && <0.7, + base >=4.11 && <4.21, + bifunctors >=5.2 && <5.7, + comonad >=5.0.4 && <5.1, + commutative-semigroups >=0.1 && <0.3, + constraints >=0.10 && <0.15, + constraints-extras >=0.3 && <0.5, + containers >=0.6 && <0.8, + data-default >=0.5 && <0.8, + dependent-map >=0.3 && <0.5, + exceptions >=0.10 && <0.11, + exception-transformers >=0.4 && <0.5, + lens >=4.7 && <5.4, + mmorph >=1.0 && <1.3, + monad-control >=1.0.1 && <1.1, + mtl >=2.1 && <2.4, + patch >=0.0.7 && <0.1, + prim-uniq >=0.1.0.1 && <0.3, + primitive >=0.5 && <0.10, + profunctors >=5.3 && <5.7, + random >=1.1 && <1.3, + ref-tf >=0.4 && <0.6, + reflection >=2.1 && <2.2, + semigroupoids >=4.0 && <7, + stm >=2.4 && <2.6, + syb >=0.5 && <0.8, + time >=1.4 && <1.13, + transformers >=0.5 && <0.7, + unbounded-delays >=0.1.0.0 && <0.2, + witherable >=0.4 && <0.6 + + if flag(split-these) + build-depends: + these >=1 && <1.3, + semialign >=1 && <1.4, + monoidal-containers >=0.6.2.0 && <0.7 + + else + build-depends: + these >=0.4 && <0.9, + monoidal-containers ==0.4.0.0 + + if flag(debug-trace-events) + cpp-options: -DDEBUG_TRACE_EVENTS + build-depends: bytestring >=0.10.8 && <0.11 + + if flag(use-reflex-optimizer) + exposed-modules: Reflex.Optimizer + cpp-options: -DUSE_REFLEX_OPTIMIZER + build-depends: ghc + + if flag(debug-propagation) + cpp-options: + -DDEBUG -DDEBUG_TRACE_PROPAGATION -DDEBUG_TRACE_INVALIDATION + + if flag(debug-cycles) + cpp-options: -DDEBUG_CYCLES + + if flag(use-template-haskell) + exposed-modules: Reflex.Dynamic.TH + cpp-options: -DUSE_TEMPLATE_HASKELL + other-extensions: TemplateHaskell + build-depends: + dependent-sum >=0.6 && <0.8, + haskell-src-exts >=1.16 && <1.24, + haskell-src-meta >=0.6 && <0.9, + template-haskell >=2.9 && <=2.22.0.0 + + else + build-depends: dependent-sum >=0.6 && <0.8 + + if (flag(fast-weak) && impl(ghcjs >=0)) + cpp-options: -DGHCJS_FAST_WEAK + + if impl(ghcjs >=0) + build-depends: ghcjs-base >=0.2 && <0.3 test-suite semantics - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: semantics.hs - hs-source-dirs: test - ghc-options: -O2 -Wall -rtsopts - build-depends: - base, - bifunctors, - containers, - deepseq, - dependent-map, - dependent-sum, - mtl, - ref-tf, - reflex, - split, - transformers - other-modules: - Reflex.Bench.Focused - Reflex.Plan.Pure - Reflex.Plan.Reflex - Reflex.Test - Reflex.Test.Micro - Reflex.TestPlan + type: exitcode-stdio-1.0 + main-is: semantics.hs + hs-source-dirs: test + other-modules: + Reflex.Bench.Focused + Reflex.Plan.Pure + Reflex.Plan.Reflex + Reflex.Test + Reflex.Test.Micro + Reflex.TestPlan + + default-language: Haskell2010 + ghc-options: -O2 -Wall -rtsopts + build-depends: + base, + bifunctors <5.7, + containers, + deepseq, + dependent-map <0.5, + dependent-sum <0.8, + mtl, + ref-tf <0.6, + reflex, + split <0.3, + transformers test-suite CrossImpl - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: Reflex/Test/CrossImpl.hs - hs-source-dirs: test - ghc-options: -O2 -Wall -rtsopts - build-depends: - base, - containers, - dependent-map, - dependent-sum, - deepseq, - mtl, - transformers, - ref-tf, - reflex - other-modules: - Reflex.Test - Reflex.TestPlan - Reflex.Plan.Reflex - Reflex.Plan.Pure + type: exitcode-stdio-1.0 + main-is: Reflex/Test/CrossImpl.hs + hs-source-dirs: test + other-modules: + Reflex.Test + Reflex.TestPlan + Reflex.Plan.Reflex + Reflex.Plan.Pure + + default-language: Haskell2010 + ghc-options: -O2 -Wall -rtsopts + build-depends: + base, + containers, + dependent-map <0.5, + dependent-sum <0.8, + deepseq, + mtl, + transformers, + ref-tf <0.6, + reflex test-suite hlint - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: hlint.hs - hs-source-dirs: test - build-depends: base - , directory - , filepath - , filemanip - if impl(ghc >= 9.6) - buildable: False - if impl(ghc < 9.2) - build-depends: hlint (< 2.1 || >= 2.2.2) && < 3.5 - else - build-depends: hlint >= 3.5 && < 3.6 - if impl(ghcjs) || arch(javascript) - buildable: False + type: exitcode-stdio-1.0 + main-is: hlint.hs + hs-source-dirs: test + default-language: Haskell2010 + build-depends: + base, + directory, + filepath, + filemanip -test-suite EventWriterT - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: EventWriterT.hs - hs-source-dirs: test - build-depends: base - , containers - , deepseq - , dependent-map - , dependent-sum - , lens - , mtl - , these - , transformers - , reflex - , ref-tf - - if flag(split-these) - build-depends: these-lens - - other-modules: - Test.Run + if impl(ghc >=9.6) + buildable: False + if impl(ghc <9.2) + build-depends: hlint (<2.1 || >=2.2.2) && <3.5 -test-suite DebugCycles - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: DebugCycles.hs - hs-source-dirs: test - ghc-options: -threaded - build-depends: base - , containers - , deepseq - , dependent-map - , dependent-sum - , hspec - , lens - , mtl - , these - , transformers - , reflex - , ref-tf - , witherable - , proctest - - - if flag(split-these) - build-depends: these-lens, semialign - - other-modules: - Test.Run + else + build-depends: hlint >=3.5 && <3.6 + if (impl(ghcjs >=0) || arch(javascript)) + buildable: False + +test-suite EventWriterT + type: exitcode-stdio-1.0 + main-is: EventWriterT.hs + hs-source-dirs: test + other-modules: Test.Run + default-language: Haskell2010 + build-depends: + base, + containers, + deepseq, + dependent-map <0.5, + dependent-sum <0.8, + lens <5.4, + mtl, + these <1.3, + transformers, + reflex, + ref-tf <0.6 + + if flag(split-these) + build-depends: these-lens <1.1 + +test-suite DebugCycles + type: exitcode-stdio-1.0 + main-is: DebugCycles.hs + hs-source-dirs: test + other-modules: Test.Run + default-language: Haskell2010 + ghc-options: -threaded + build-depends: + base, + containers, + deepseq, + dependent-map <0.5, + dependent-sum <0.8, + hspec <2.12, + lens <5.4, + mtl, + these <1.3, + transformers, + reflex, + ref-tf <0.6, + witherable <0.6, + proctest <0.2 + + if flag(split-these) + build-depends: + these-lens <1.1, + semialign <1.4 test-suite RequesterT - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: RequesterT.hs - hs-source-dirs: test - build-depends: base - , constraints - , constraints-extras - , containers - , deepseq - , dependent-map - , dependent-sum - , lens - , mtl - , ref-tf - , reflex - , text - , these - , transformers - - if flag(split-these) - build-depends: these-lens - - other-modules: - Reflex.TestPlan - Reflex.Plan.Pure - Test.Run + type: exitcode-stdio-1.0 + main-is: RequesterT.hs + hs-source-dirs: test + other-modules: + Reflex.TestPlan + Reflex.Plan.Pure + Test.Run + + default-language: Haskell2010 + build-depends: + base, + constraints <0.15, + constraints-extras <0.5, + containers, + deepseq, + dependent-map <0.5, + dependent-sum <0.8, + lens <5.4, + mtl, + ref-tf <0.6, + reflex, + text, + these <1.3, + transformers + + if flag(split-these) + build-depends: these-lens <1.1 test-suite Headless - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: Headless.hs - hs-source-dirs: test - build-depends: base - , reflex + type: exitcode-stdio-1.0 + main-is: Headless.hs + hs-source-dirs: test + default-language: Haskell2010 + build-depends: + base, + reflex test-suite Adjustable - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: Adjustable.hs - hs-source-dirs: test - build-depends: base - , containers - , dependent-sum - , reflex - , ref-tf - , these - - other-modules: - Test.Run + type: exitcode-stdio-1.0 + main-is: Adjustable.hs + hs-source-dirs: test + other-modules: Test.Run + default-language: Haskell2010 + build-depends: + base, + containers, + dependent-sum <0.8, + reflex, + ref-tf <0.6, + these <1.3 test-suite QueryT - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: QueryT.hs - hs-source-dirs: test - build-depends: base - , commutative-semigroups - , containers - , dependent-map - , dependent-sum - , deepseq - , lens - , monoidal-containers - , mtl - , patch - , ref-tf - , reflex - , these - , transformers - - if flag(split-these) - build-depends: semialign, these-lens - - other-modules: - Test.Run - Reflex.TestPlan - Reflex.Plan.Reflex - Reflex.Plan.Pure + type: exitcode-stdio-1.0 + main-is: QueryT.hs + hs-source-dirs: test + other-modules: + Test.Run + Reflex.TestPlan + Reflex.Plan.Reflex + Reflex.Plan.Pure + + default-language: Haskell2010 + build-depends: + base, + commutative-semigroups <0.3, + containers, + dependent-map <0.5, + dependent-sum <0.8, + deepseq, + lens <5.4, + monoidal-containers <0.7, + mtl, + patch <0.1, + ref-tf <0.6, + reflex, + these <1.3, + transformers + + if flag(split-these) + build-depends: + semialign <1.4, + these-lens <1.1 test-suite GC-Semantics - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: GC.hs - hs-source-dirs: test - build-depends: base - , containers - , dependent-sum - , dependent-map - , deepseq - , mtl - , patch - , these - , transformers - , reflex - , ref-tf - - if flag(split-these) - build-depends: semialign - - other-modules: - Reflex.Plan.Pure - Reflex.Plan.Reflex - Reflex.TestPlan - Test.Run + type: exitcode-stdio-1.0 + main-is: GC.hs + hs-source-dirs: test + other-modules: + Reflex.Plan.Pure + Reflex.Plan.Reflex + Reflex.TestPlan + Test.Run + + default-language: Haskell2010 + build-depends: + base, + containers, + dependent-sum <0.8, + dependent-map <0.5, + deepseq, + mtl, + patch <0.1, + these <1.3, + transformers, + reflex, + ref-tf <0.6 + + if flag(split-these) + build-depends: semialign <1.4 test-suite rootCleanup - default-language: Haskell2010 - type: exitcode-stdio-1.0 - main-is: rootCleanup.hs - hs-source-dirs: test - build-depends: base - , containers - , deepseq - , dependent-sum - , mtl - , reflex - , ref-tf - , these - other-modules: - Reflex.Plan.Pure - Reflex.TestPlan - Test.Run + type: exitcode-stdio-1.0 + main-is: rootCleanup.hs + hs-source-dirs: test + other-modules: + Reflex.Plan.Pure + Reflex.TestPlan + Test.Run + + default-language: Haskell2010 + build-depends: + base, + containers, + deepseq, + dependent-sum <0.8, + mtl, + reflex, + ref-tf <0.6, + these <1.3 benchmark spider-bench - default-language: Haskell2010 - type: exitcode-stdio-1.0 - hs-source-dirs: bench test - main-is: Main.hs - ghc-options: -Wall -O2 -rtsopts - build-depends: - base, - containers, - criterion, - deepseq, - dependent-map, - dependent-sum, - ref-tf, - mtl, - primitive, - reflex, - split, - stm, - transformers - other-modules: - Reflex.TestPlan - Reflex.Plan.Reflex - Reflex.Bench.Focused - if arch(javascript) - buildable: False + type: exitcode-stdio-1.0 + main-is: Main.hs + hs-source-dirs: bench test + other-modules: + Reflex.TestPlan + Reflex.Plan.Reflex + Reflex.Bench.Focused + + default-language: Haskell2010 + ghc-options: -Wall -O2 -rtsopts + build-depends: + base, + containers, + criterion <1.7, + deepseq, + dependent-map <0.5, + dependent-sum <0.8, + ref-tf <0.6, + mtl, + primitive <0.10, + reflex, + split <0.3, + stm, + transformers + + if arch(javascript) + buildable: False benchmark saulzar-bench - default-language: Haskell2010 - type: exitcode-stdio-1.0 - hs-source-dirs: bench test - c-sources: bench-cbits/checkCapability.c - main-is: RunAll.hs - ghc-options: -Wall -O2 -rtsopts -threaded - build-depends: - base, - containers, - criterion, - deepseq, - dependent-map, - dependent-sum, - loch-th, - mtl, - primitive, - process, - ref-tf, - reflex, - split, - stm, - time, - transformers - other-modules: - Reflex.TestPlan - Reflex.Plan.Reflex - Reflex.Bench.Focused - if arch(javascript) - buildable: False - -source-repository head - type: git - location: https://github.com/reflex-frp/reflex + type: exitcode-stdio-1.0 + main-is: RunAll.hs + c-sources: bench-cbits/checkCapability.c + hs-source-dirs: bench test + other-modules: + Reflex.TestPlan + Reflex.Plan.Reflex + Reflex.Bench.Focused + + default-language: Haskell2010 + ghc-options: -Wall -O2 -rtsopts -threaded + build-depends: + base, + containers, + criterion <1.7, + deepseq, + dependent-map <0.5, + dependent-sum <0.8, + loch-th <0.3, + mtl, + primitive <0.10, + process, + ref-tf <0.6, + reflex, + split <0.3, + stm, + time, + transformers + + if arch(javascript) + buildable: False diff --git a/src/Control/Monad/ReaderIO.hs b/src/Control/Monad/ReaderIO.hs index ad235fe7..33d58ff5 100644 --- a/src/Control/Monad/ReaderIO.hs +++ b/src/Control/Monad/ReaderIO.hs @@ -2,16 +2,12 @@ {-# language MultiParamTypeClasses #-} {-# language FlexibleInstances #-} {-# language CPP #-} + module Control.Monad.ReaderIO - ( - ReaderIO (..) - ) - where + ( ReaderIO (..) + ) where import Control.Monad.Fix -#if MIN_VERSION_base(4,10,0) -import Control.Applicative -#endif import Control.Monad import Control.Monad.Reader.Class import Control.Monad.IO.Class diff --git a/src/Data/AppendMap.hs b/src/Data/AppendMap.hs index 4bfd8e0c..5bbd379a 100644 --- a/src/Data/AppendMap.hs +++ b/src/Data/AppendMap.hs @@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# OPTIONS_GHC -fno-warn-orphans #-} + -- | -- Module: -- Data.AppendMap @@ -30,9 +31,7 @@ import qualified Data.Map.Internal.Debug as Map (showTree, showTreeWith) #else import qualified Data.Map as Map (showTree, showTreeWith) #endif -import qualified Data.Witherable as W import Data.Map.Monoidal -import qualified Data.Map.Monoidal as MonoidalMap {-# DEPRECATED AppendMap "Use 'MonoidalMap' instead" #-} diff --git a/src/Data/FastMutableIntMap.hs b/src/Data/FastMutableIntMap.hs index d46c6a24..640a7b61 100644 --- a/src/Data/FastMutableIntMap.hs +++ b/src/Data/FastMutableIntMap.hs @@ -1,4 +1,5 @@ {-# LANGUAGE TypeFamilies #-} + -- | -- Module: -- Data.FastMutableIntMap @@ -94,4 +95,4 @@ applyPatch (FastMutableIntMap r) p@(PatchIntMap m) = do return $ IntMap.intersection v m toList :: FastMutableIntMap a -> IO [(Int, a)] -toList (FastMutableIntMap r) = IntMap.toList <$> readIORef r \ No newline at end of file +toList (FastMutableIntMap r) = IntMap.toList <$> readIORef r diff --git a/src/Data/FastWeakBag.hs b/src/Data/FastWeakBag.hs index 2fe8068b..ae97a6a8 100644 --- a/src/Data/FastWeakBag.hs +++ b/src/Data/FastWeakBag.hs @@ -7,6 +7,7 @@ {-# LANGUAGE ForeignFunctionInterface #-} {-# LANGUAGE JavaScriptFFI #-} #endif + -- | This module defines the 'FastWeakBag' type, which represents a mutable -- collection of items that does not cause the items to be retained in memory. -- This is useful for situations where a value needs to be inspected or modified diff --git a/src/Data/Map/Misc.hs b/src/Data/Map/Misc.hs index a41010da..afdfc282 100644 --- a/src/Data/Map/Misc.hs +++ b/src/Data/Map/Misc.hs @@ -1,4 +1,5 @@ {-# LANGUAGE LambdaCase #-} + -- | Additional functions for manipulating 'Map's. module Data.Map.Misc ( diff --git a/src/Data/WeakBag.hs b/src/Data/WeakBag.hs index cbd01ef1..fd70ec2a 100644 --- a/src/Data/WeakBag.hs +++ b/src/Data/WeakBag.hs @@ -4,6 +4,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | This module defines the 'WeakBag' type, which represents a mutable -- collection of items that does not cause the items to be retained in memory. -- This is useful for situations where a value needs to be inspected or modified diff --git a/src/Reflex.hs b/src/Reflex.hs index 1529280b..8e177825 100644 --- a/src/Reflex.hs +++ b/src/Reflex.hs @@ -1,4 +1,5 @@ {-# LANGUAGE CPP #-} + -- | This module exports all of the commonly-used functionality of Reflex; if -- you are just getting started with Reflex, this is probably what you want. module Reflex diff --git a/src/Reflex/Adjustable/Class.hs b/src/Reflex/Adjustable/Class.hs index c58e3f28..4d428e04 100644 --- a/src/Reflex/Adjustable/Class.hs +++ b/src/Reflex/Adjustable/Class.hs @@ -10,6 +10,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | -- Module: -- Reflex.Adjustable.Class diff --git a/src/Reflex/BehaviorWriter/Base.hs b/src/Reflex/BehaviorWriter/Base.hs index 520d8602..802c7b22 100644 --- a/src/Reflex/BehaviorWriter/Base.hs +++ b/src/Reflex/BehaviorWriter/Base.hs @@ -10,11 +10,13 @@ Description: Implementation of BehaviorWriter {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE StandaloneDeriving #-} #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.BehaviorWriter.Base ( BehaviorWriterT (..) , runBehaviorWriterT @@ -25,7 +27,6 @@ import Control.Monad import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception import Control.Monad.Fix -import Control.Monad.Identity import Control.Monad.IO.Class import Control.Monad.Morph import Control.Monad.Reader @@ -40,6 +41,10 @@ import Data.Map (Map) import qualified Data.Map as Map import Data.Some (Some) +#if !MIN_VERSION_base(4,18,0) +import Control.Monad.Identity +#endif + import Reflex.Class import Reflex.Adjustable.Class import Reflex.BehaviorWriter.Class diff --git a/src/Reflex/BehaviorWriter/Class.hs b/src/Reflex/BehaviorWriter/Class.hs index bff3a4b4..dfc08e2b 100644 --- a/src/Reflex/BehaviorWriter/Class.hs +++ b/src/Reflex/BehaviorWriter/Class.hs @@ -10,6 +10,7 @@ Description: This module defines the 'BehaviorWriter' class #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.BehaviorWriter.Class ( MonadBehaviorWriter , BehaviorWriter(..) diff --git a/src/Reflex/Class.hs b/src/Reflex/Class.hs index 128ac493..a9cc29f8 100644 --- a/src/Reflex/Class.hs +++ b/src/Reflex/Class.hs @@ -204,7 +204,6 @@ import qualified Data.Dependent.Map as DMap import Data.Functor.Compose import Data.Functor.Product import Data.GADT.Compare (GEq (..), GCompare (..)) -import Data.FastMutableIntMap (PatchIntMap) import Data.Foldable import Data.Functor.Bind import Data.Functor.Misc @@ -220,12 +219,12 @@ import Data.String import Data.These import Data.Type.Coercion import Data.Type.Equality ((:~:) (..)) -import Data.Witherable (Filterable(..)) -import qualified Data.Witherable as W import Reflex.FunctorMaybe (FunctorMaybe) import qualified Reflex.FunctorMaybe import Data.Patch import qualified Data.Patch.MapWithMove as PatchMapWithMove +import Witherable (Filterable(..)) +import qualified Witherable as W import Debug.Trace (trace) @@ -679,15 +678,12 @@ instance (Reflex t, IsString a) => IsString (Behavior t a) where instance Reflex t => Monad (Behavior t) where a >>= f = pull $ sample a >>= sample . f - -- Note: it is tempting to write (_ >> b = b); however, this would result in (fail x >> return y) succeeding (returning y), which violates the law that (a >> b = a >>= \_ -> b), since the implementation of (>>=) above actually will fail. Since we can't examine 'Behavior's other than by using sample, I don't think it's possible to write (>>) to be more efficient than the (>>=) above. - return = constant #if !MIN_VERSION_base(4,13,0) fail = error "Monad (Behavior t) does not support fail" #endif instance (Reflex t, Monoid a) => Monoid (Behavior t a) where mempty = constant mempty - mappend a b = pull $ liftM2 mappend (sample a) (sample b) mconcat = pull . fmap mconcat . mapM sample instance (Reflex t, Num a) => Num (Behavior t a) where @@ -1159,7 +1155,6 @@ instance (Reflex t, Semigroup a) => Semigroup (Dynamic t a) where instance (Reflex t, Monoid a) => Monoid (Dynamic t a) where mconcat = distributeListOverDynWith mconcat mempty = constDyn mempty - mappend = zipDynWith mappend -- | This function converts a 'DMap' whose elements are 'Dynamic's into a -- 'Dynamic' 'DMap'. Its implementation is more efficient than doing the same diff --git a/src/Reflex/Collection.hs b/src/Reflex/Collection.hs index 770ea4b6..37c02446 100644 --- a/src/Reflex/Collection.hs +++ b/src/Reflex/Collection.hs @@ -10,6 +10,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | -- Module: -- Reflex.Collection @@ -36,7 +37,6 @@ import Data.Zip (Zip (..)) import Control.Monad import Control.Monad.Fix -import Control.Monad.Identity import Data.Align import Data.Functor.Misc import Data.Map (Map) @@ -44,6 +44,10 @@ import qualified Data.Map as Map import Data.Map.Misc import Data.These +#if !MIN_VERSION_base(4,18,0) +import Control.Monad.Identity +#endif + import Reflex.Class import Reflex.Adjustable.Class import Reflex.Dynamic diff --git a/src/Reflex/Dynamic.hs b/src/Reflex/Dynamic.hs index 4df27298..74c93ba0 100644 --- a/src/Reflex/Dynamic.hs +++ b/src/Reflex/Dynamic.hs @@ -17,6 +17,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | -- Module: -- Reflex.Dynamic @@ -78,29 +79,30 @@ module Reflex.Dynamic , unsafeDynamic ) where -import Data.Functor.Compose -import Data.Functor.Misc -import Reflex.Class - -import Control.Monad import Control.Monad.Fix import Control.Monad.Identity import Data.Align import Data.Dependent.Map (DMap) import qualified Data.Dependent.Map as DMap import Data.Dependent.Sum (DSum (..)) +import Data.Functor.Compose +import Data.Functor.Misc import Data.GADT.Compare (GCompare (..), GEq (..), GOrdering (..)) import Data.IntMap (IntMap) -import qualified Data.IntMap as IntMap import Data.Kind (Type) import Data.Map (Map) import Data.Maybe -import Data.Monoid ((<>)) import Data.These import Data.Type.Equality ((:~:) (..)) - import Debug.Trace hiding (traceEventWith) +#if !MIN_VERSION_base(4,18,0) +import Control.Monad +import Data.Monoid ((<>)) +#endif + +import Reflex.Class + -- | Map a sampling function over a 'Dynamic'. mapDynM :: forall t m a b. (Reflex t, MonadHold t m) => (forall m'. MonadSample t m' => a -> m' b) -> Dynamic t a -> m (Dynamic t b) mapDynM f d = buildDynamic (f =<< sample (current d)) $ pushAlways f (updated d) diff --git a/src/Reflex/Dynamic/TH.hs b/src/Reflex/Dynamic/TH.hs index b7759bef..d40dd11e 100644 --- a/src/Reflex/Dynamic/TH.hs +++ b/src/Reflex/Dynamic/TH.hs @@ -8,6 +8,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | Template Haskell helper functions for building complex 'Dynamic' values. module Reflex.Dynamic.TH ( qDynPure @@ -15,18 +16,21 @@ module Reflex.Dynamic.TH , mkDynPure ) where -import Reflex.Dynamic - import Control.Monad.State import Data.Data import Data.Generics -import Data.Monoid ((<>)) import qualified Language.Haskell.Exts as Hs import qualified Language.Haskell.Meta.Syntax.Translate as Hs import Language.Haskell.TH import Language.Haskell.TH.Quote import qualified Language.Haskell.TH.Syntax as TH +#if !MIN_VERSION_base(4,18,0) +import Data.Monoid ((<>)) +#endif + +import Reflex.Dynamic + -- | 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@ diff --git a/src/Reflex/Dynamic/Uniq.hs b/src/Reflex/Dynamic/Uniq.hs index e118af9d..8c2e6ba0 100644 --- a/src/Reflex/Dynamic/Uniq.hs +++ b/src/Reflex/Dynamic/Uniq.hs @@ -5,6 +5,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | This module provides a variation of 'Dynamic' values that uses cheap -- pointer equality checks to reduce the amount of signal propagation needed. module Reflex.Dynamic.Uniq @@ -14,8 +15,12 @@ module Reflex.Dynamic.Uniq , alreadyUniqDynamic ) where -import Control.Applicative (Applicative (..)) import GHC.Exts + +#if !MIN_VERSION_base(4,18,0) +import Control.Monad.Applicative (Applicative(..)) +#endif + import Reflex.Class -- | A 'Dynamic' whose 'updated' 'Event' will never fire with the same value as @@ -101,5 +106,3 @@ instance Reflex t => Applicative (UniqDynamic t) where instance Reflex t => Monad (UniqDynamic t) where UniqDynamic x >>= f = uniqDynamic $ x >>= unUniqDynamic . f - _ >> b = b - return = pure diff --git a/src/Reflex/DynamicWriter/Base.hs b/src/Reflex/DynamicWriter/Base.hs index 912aea3d..6742e22a 100644 --- a/src/Reflex/DynamicWriter/Base.hs +++ b/src/Reflex/DynamicWriter/Base.hs @@ -8,11 +8,13 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TupleSections #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE StandaloneDeriving #-} #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.DynamicWriter.Base ( DynamicWriterT (..) , runDynamicWriterT @@ -23,7 +25,6 @@ import Control.Monad import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception import Control.Monad.Fix -import Control.Monad.Identity import Control.Monad.IO.Class import Control.Monad.Morph import Control.Monad.Primitive @@ -39,10 +40,14 @@ import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap import Data.Map (Map) import qualified Data.Map as Map -import Data.Semigroup (Semigroup(..)) import Data.Some (Some) import Data.These +#if !MIN_VERSION_base(4,18,0) +import Control.Monad.Identity +import Data.Semigroup (Semigroup(..)) +#endif + import Reflex.Adjustable.Class import Reflex.Class import Reflex.DynamicWriter.Class @@ -225,7 +230,7 @@ traverseIntMapWithKeyWithAdjustImpl base mergeMyDynIncremental f (dm0 :: IntMap return (liftedResult0, liftedResult') -- | Map a function over the output of a 'DynamicWriterT'. -withDynamicWriterT :: (Monoid w, Monoid w', Reflex t, MonadHold t m, MonadFix m) +withDynamicWriterT :: (Monoid w, Monoid w', Reflex t, MonadFix m) => (w -> w') -> DynamicWriterT t w m a -> DynamicWriterT t w' m a diff --git a/src/Reflex/DynamicWriter/Class.hs b/src/Reflex/DynamicWriter/Class.hs index 1df9cf61..2df070d8 100644 --- a/src/Reflex/DynamicWriter/Class.hs +++ b/src/Reflex/DynamicWriter/Class.hs @@ -7,6 +7,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.DynamicWriter.Class ( MonadDynamicWriter , DynamicWriter(..) diff --git a/src/Reflex/EventWriter/Base.hs b/src/Reflex/EventWriter/Base.hs index 0612d66a..ed00ba38 100644 --- a/src/Reflex/EventWriter/Base.hs +++ b/src/Reflex/EventWriter/Base.hs @@ -13,6 +13,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.EventWriter.Base ( EventWriterT (..) , runEventWriterT diff --git a/src/Reflex/EventWriter/Class.hs b/src/Reflex/EventWriter/Class.hs index 41aadd35..74774b2b 100644 --- a/src/Reflex/EventWriter/Class.hs +++ b/src/Reflex/EventWriter/Class.hs @@ -6,12 +6,16 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.EventWriter.Class ( EventWriter (..) ) where import Control.Monad.Reader (ReaderT, lift) + +#if !MIN_VERSION_base(4,18,0) import Data.Semigroup (Semigroup) +#endif import Reflex.Class (Event) diff --git a/src/Reflex/FunctorMaybe.hs b/src/Reflex/FunctorMaybe.hs index 84656db5..8368562a 100644 --- a/src/Reflex/FunctorMaybe.hs +++ b/src/Reflex/FunctorMaybe.hs @@ -19,7 +19,7 @@ import Data.Map (Map) #if !MIN_VERSION_base(4,16,0) import Data.Semigroup (Option(..)) #endif -import Data.Witherable +import Witherable --TODO: See if there's a better class in the standard libraries already diff --git a/src/Reflex/Host/Class.hs b/src/Reflex/Host/Class.hs index 4f5a5b72..73044bb1 100644 --- a/src/Reflex/Host/Class.hs +++ b/src/Reflex/Host/Class.hs @@ -8,10 +8,12 @@ {-# LANGUAGE RoleAnnotations #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | This module provides the interface for hosting 'Reflex' engines. This -- should only be necessary if you're writing a binding or some other library -- that provides a core event loop. diff --git a/src/Reflex/Host/Headless.hs b/src/Reflex/Host/Headless.hs index 13f66489..16d1893d 100644 --- a/src/Reflex/Host/Headless.hs +++ b/src/Reflex/Host/Headless.hs @@ -3,6 +3,7 @@ {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} module Reflex.Host.Headless where diff --git a/src/Reflex/Network.hs b/src/Reflex/Network.hs index 8f914a82..d04b2950 100644 --- a/src/Reflex/Network.hs +++ b/src/Reflex/Network.hs @@ -3,6 +3,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + -- | -- Module: -- Reflex.Network diff --git a/src/Reflex/NotReady/Class.hs b/src/Reflex/NotReady/Class.hs index 7d1232bd..5bb91a9e 100644 --- a/src/Reflex/NotReady/Class.hs +++ b/src/Reflex/NotReady/Class.hs @@ -4,10 +4,12 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.NotReady.Class ( NotReady(..) ) where diff --git a/src/Reflex/PerformEvent/Base.hs b/src/Reflex/PerformEvent/Base.hs index 9fae30ae..d961ead8 100644 --- a/src/Reflex/PerformEvent/Base.hs +++ b/src/Reflex/PerformEvent/Base.hs @@ -18,24 +18,17 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.PerformEvent.Base ( PerformEventT (..) , FireCommand (..) , hostPerformEventT ) where -import Reflex.Class -import Reflex.Adjustable.Class -import Reflex.Host.Class -import Reflex.PerformEvent.Class -import Reflex.Requester.Base -import Reflex.Requester.Class - import Control.Lens import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception import Control.Monad.Fix -import Control.Monad.Identity import Control.Monad.Primitive import Control.Monad.Reader import Control.Monad.Ref @@ -47,6 +40,17 @@ import Data.IntMap.Strict (IntMap) import qualified Data.IntMap.Strict as IntMap import qualified Data.Semigroup as S +#if !MIN_VERSION_base(4,18,0) +import Control.Monad.Identity +#endif + +import Reflex.Class +import Reflex.Adjustable.Class +import Reflex.Host.Class +import Reflex.PerformEvent.Class +import Reflex.Requester.Base +import Reflex.Requester.Class + -- | A function that fires events for the given 'EventTrigger's and then runs -- any followup actions provided via 'PerformEvent'. The given 'ReadPhase' -- action will be run once for the initial trigger execution as well as once for @@ -91,7 +95,7 @@ instance (ReflexHost t, PrimMonad (HostFrame t)) => Adjustable t (PerformEventT traverseDMapWithKeyWithAdjust f outerDm0 outerDm' = PerformEventT $ traverseDMapWithKeyWithAdjustRequesterTWith (defaultAdjustBase traversePatchDMapWithKey) mapPatchDMap weakenPatchDMapWith patchMapNewElementsMap mergeMapIncremental (\k v -> unPerformEventT $ f k v) (coerce outerDm0) (coerceEvent outerDm') traverseDMapWithKeyWithAdjustWithMove f outerDm0 outerDm' = PerformEventT $ traverseDMapWithKeyWithAdjustRequesterTWith (defaultAdjustBase traversePatchDMapWithMoveWithKey) mapPatchDMapWithMove weakenPatchDMapWithMoveWith patchMapWithMoveNewElementsMap mergeMapIncrementalWithMove (\k v -> unPerformEventT $ f k v) (coerce outerDm0) (coerceEvent outerDm') -defaultAdjustBase :: forall t v v2 k' p. (Monad (HostFrame t), PrimMonad (HostFrame t), Reflex t) +defaultAdjustBase :: forall t v v2 k' p. (Monad (HostFrame t), Reflex t) => ((forall a. k' a -> v a -> HostFrame t (v2 a)) -> p k' v -> HostFrame t (p k' v2)) -> (forall a. k' a -> v a -> HostFrame t (v2 a)) -> DMap k' v @@ -102,7 +106,7 @@ defaultAdjustBase traversePatchWithKey f' dm0 dm' = do result' <- requestingIdentity $ ffor dm' $ traversePatchWithKey f' return (result0, result') -defaultAdjustIntBase :: forall t v v2 p. (Monad (HostFrame t), PrimMonad (HostFrame t), Reflex t) +defaultAdjustIntBase :: forall t v v2 p. (Monad (HostFrame t), Reflex t) => ((IntMap.Key -> v -> HostFrame t v2) -> p v -> HostFrame t (p v2)) -> (IntMap.Key -> v -> HostFrame t v2) -> IntMap v @@ -124,9 +128,7 @@ instance ReflexHost t => MonadReflexCreateTrigger t (PerformEventT t m) where -- at the appropriate time. {-# INLINABLE hostPerformEventT #-} hostPerformEventT :: forall t m a. - ( Monad m - , MonadSubscribeEvent t m - , MonadReflexHost t m + ( MonadReflexHost t m , MonadRef m , Ref m ~ Ref IO ) diff --git a/src/Reflex/PerformEvent/Class.hs b/src/Reflex/PerformEvent/Class.hs index 1b72fdde..137e5812 100644 --- a/src/Reflex/PerformEvent/Class.hs +++ b/src/Reflex/PerformEvent/Class.hs @@ -12,18 +12,21 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.PerformEvent.Class ( PerformEvent (..) , performEventAsync ) where import Control.Monad -import Control.Monad.Fix import Control.Monad.Reader import Control.Monad.Trans.Maybe (MaybeT (..)) - import Data.Kind (Type) +#if !MIN_VERSION_base(4,18,0) +import Control.Monad.Fix +#endif + import Reflex.Class import Reflex.TriggerEvent.Class diff --git a/src/Reflex/PostBuild/Base.hs b/src/Reflex/PostBuild/Base.hs index b866c2e3..2fa326ca 100644 --- a/src/Reflex/PostBuild/Base.hs +++ b/src/Reflex/PostBuild/Base.hs @@ -13,6 +13,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.PostBuild.Base ( PostBuildT (..) , runPostBuildT @@ -21,18 +22,9 @@ module Reflex.PostBuild.Base , mapDMapWithAdjustImpl ) where -import Reflex.Class -import Reflex.Adjustable.Class -import Reflex.Host.Class -import Reflex.PerformEvent.Class -import Reflex.PostBuild.Class -import Reflex.TriggerEvent.Class - -import Control.Applicative (liftA2) import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception import Control.Monad.Fix -import Control.Monad.Identity import Control.Monad.Primitive import Control.Monad.Reader import Control.Monad.Ref @@ -44,6 +36,18 @@ import Data.IntMap.Strict (IntMap) import qualified Data.IntMap.Strict as IntMap import qualified Data.Semigroup as S +#if !MIN_VERSION_base(4,18,0) +import Control.Applicative (liftA2) +import Control.Monad.Identity +#endif + +import Reflex.Class +import Reflex.Adjustable.Class +import Reflex.Host.Class +import Reflex.PerformEvent.Class +import Reflex.PostBuild.Class +import Reflex.TriggerEvent.Class + -- | Provides a basic implementation of 'PostBuild'. newtype PostBuildT t m a = PostBuildT { unPostBuildT :: ReaderT (Event t ()) m a } deriving @@ -70,7 +74,6 @@ runPostBuildT (PostBuildT a) = runReaderT a -- TODO: Monoid and Semigroup can likely be derived once ReaderT has them. instance (Monoid a, Applicative m) => Monoid (PostBuildT t m a) where mempty = pure mempty - mappend = liftA2 mappend instance (S.Semigroup a, Applicative m) => S.Semigroup (PostBuildT t m a) where (<>) = liftA2 (S.<>) diff --git a/src/Reflex/PostBuild/Class.hs b/src/Reflex/PostBuild/Class.hs index dac1516b..d7cc9bfb 100644 --- a/src/Reflex/PostBuild/Class.hs +++ b/src/Reflex/PostBuild/Class.hs @@ -10,6 +10,7 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.PostBuild.Class ( PostBuild (..) ) where diff --git a/src/Reflex/Profiled.hs b/src/Reflex/Profiled.hs index f579df1b..cba968f5 100644 --- a/src/Reflex/Profiled.hs +++ b/src/Reflex/Profiled.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE CPP #-} {-# LANGUAGE EmptyDataDecls #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} @@ -11,6 +12,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE RankNTypes #-} + -- | -- Module: -- Reflex.Profiled @@ -36,7 +38,6 @@ import Data.List import Data.Kind (Type) import Data.Map (Map) import qualified Data.Map.Strict as Map -import Data.Monoid ((<>)) import Data.Ord import Data.Profunctor.Unsafe ((#.)) import qualified Data.Semigroup as S @@ -45,6 +46,12 @@ import Foreign.Ptr import GHC.Foreign import GHC.IO.Encoding import GHC.Stack +import System.IO.Unsafe + +#if !MIN_VERSION_base(4,18,0) +import Data.Monoid ((<>)) +#endif + import Reflex.Adjustable.Class import Reflex.BehaviorWriter.Class import Reflex.Class @@ -58,8 +65,6 @@ import Reflex.Query.Class import Reflex.Requester.Class import Reflex.TriggerEvent.Class -import System.IO.Unsafe - data ProfiledTimeline t {-# NOINLINE profilingData #-} diff --git a/src/Reflex/Pure.hs b/src/Reflex/Pure.hs index a0ada8ba..cd2d668c 100644 --- a/src/Reflex/Pure.hs +++ b/src/Reflex/Pure.hs @@ -5,17 +5,17 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE PolyKinds #-} - #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif - -- There are two expected orphan instances in this module: -- * MonadSample (Pure t) ((->) t) -- * MonadHold (Pure t) ((->) t) {-# OPTIONS_GHC -fno-warn-orphans #-} + -- | -- Module: Reflex.Pure -- Description: @@ -213,5 +213,5 @@ instance (Enum t, HasTrie t, Ord t) => MonadHold (Pure t) ((->) t) where headE = slowHeadE now t = Event $ guard . (t ==) - + diff --git a/src/Reflex/Query/Base.hs b/src/Reflex/Query/Base.hs index d4135e47..7f062809 100644 --- a/src/Reflex/Query/Base.hs +++ b/src/Reflex/Query/Base.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE CPP #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE InstanceSigs #-} @@ -19,7 +20,6 @@ module Reflex.Query.Base , mapQueryT ) where -import Control.Applicative (liftA2) import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception import Control.Monad.Fix @@ -41,12 +41,16 @@ import qualified Data.IntMap as IntMap import Data.Kind (Type) import Data.Map (Map) import qualified Data.Map as Map -import Data.Monoid ((<>)) import qualified Data.Semigroup as S import Data.Semigroup.Commutative import Data.Some (Some(Some)) import Data.These +#if !MIN_VERSION_base(4,18,0) +import Control.Applicative (liftA2) +import Data.Monoid ((<>)) +#endif + import Reflex.Class import Reflex.Adjustable.Class import Reflex.DynamicWriter.Class diff --git a/src/Reflex/Query/Class.hs b/src/Reflex/Query/Class.hs index dc6a6888..8b7b3aec 100644 --- a/src/Reflex/Query/Class.hs +++ b/src/Reflex/Query/Class.hs @@ -6,6 +6,7 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} + -- | -- Module: -- Reflex.Query.Class @@ -27,7 +28,6 @@ module Reflex.Query.Class , mapQueryResult ) where -import Control.Applicative import Control.Category (Category) import qualified Control.Category as Cat import Control.Monad.Reader @@ -37,12 +37,16 @@ import Data.Ix import Data.Kind (Type) import Data.Map.Monoidal (MonoidalMap) import qualified Data.Map.Monoidal as MonoidalMap -import Data.Semigroup (Semigroup(..)) import Data.Semigroup.Commutative import Data.Void import Data.Monoid hiding ((<>)) import Foreign.Storable +#if !MIN_VERSION_base(4,18,0) +import Control.Applicative +import Data.Semigroup (Semigroup(..)) +#endif + import Reflex.Class -- | A 'Query' can be thought of as a declaration of interest in some set of data. diff --git a/src/Reflex/Requester/Base/Internal.hs b/src/Reflex/Requester/Base/Internal.hs index 12d7a8f9..c8bf7cc3 100644 --- a/src/Reflex/Requester/Base/Internal.hs +++ b/src/Reflex/Requester/Base/Internal.hs @@ -19,19 +19,9 @@ #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif -module Reflex.Requester.Base.Internal where -import Reflex.Class -import Reflex.Adjustable.Class -import Reflex.Dynamic -import Reflex.EventWriter.Class -import Reflex.Host.Class -import Reflex.PerformEvent.Class -import Reflex.PostBuild.Class -import Reflex.Requester.Class -import Reflex.TriggerEvent.Class +module Reflex.Requester.Base.Internal where -import Control.Applicative (liftA2) import Control.Monad import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception @@ -55,7 +45,6 @@ import qualified Data.IntMap.Strict as IntMap import Data.Kind (Type) import Data.Map (Map) import qualified Data.Map as Map -import Data.Monoid ((<>)) import Data.Proxy import qualified Data.Semigroup as S import Data.Some (Some(Some)) @@ -65,6 +54,21 @@ import Data.Unique.Tag import GHC.Exts (Any) import Unsafe.Coerce +#if !MIN_VERSION_base(4,18,0) +import Control.Applicative (liftA2) +import Data.Monoid ((<>)) +#endif + +import Reflex.Class +import Reflex.Adjustable.Class +import Reflex.Dynamic +import Reflex.EventWriter.Class +import Reflex.Host.Class +import Reflex.PerformEvent.Class +import Reflex.PostBuild.Class +import Reflex.Requester.Class +import Reflex.TriggerEvent.Class + --TODO: Make this module type-safe newtype TagMap (f :: Type -> Type) = TagMap (IntMap Any) @@ -298,7 +302,6 @@ instance PrimMonad m => PrimMonad (RequesterT t request response m) where -- TODO: Monoid and Semigroup can likely be derived once StateT has them. instance (Monoid a, Monad m) => Monoid (RequesterT t request response m a) where mempty = pure mempty - mappend = liftA2 mappend instance (S.Semigroup a, Monad m) => S.Semigroup (RequesterT t request response m a) where (<>) = liftA2 (S.<>) diff --git a/src/Reflex/Requester/Class.hs b/src/Reflex/Requester/Class.hs index f9e50757..b0fab7ba 100644 --- a/src/Reflex/Requester/Class.hs +++ b/src/Reflex/Requester/Class.hs @@ -8,10 +8,12 @@ {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE RecursiveDo #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-} #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif + module Reflex.Requester.Class ( Requester (..) , withRequesting diff --git a/src/Reflex/Spider.hs b/src/Reflex/Spider.hs index 6dc64761..1236e3d6 100644 --- a/src/Reflex/Spider.hs +++ b/src/Reflex/Spider.hs @@ -1,20 +1,21 @@ {-# LANGUAGE CPP #-} + -- | -- Module: -- Reflex.Spider -- Description: -- This module exports all of the user-facing functionality of the 'Spider' 'Reflex' engine module Reflex.Spider - ( Spider - , SpiderTimeline - , Global - , SpiderHost - , runSpiderHost - , runSpiderHostForTimeline - , newSpiderTimeline - , withSpiderTimeline - -- * Deprecated - , SpiderEnv - ) where + ( Spider + , SpiderTimeline + , Global + , SpiderHost + , runSpiderHost + , runSpiderHostForTimeline + , newSpiderTimeline + , withSpiderTimeline + -- * Deprecated + , SpiderEnv + ) where import Reflex.Spider.Internal diff --git a/src/Reflex/Spider/Internal.hs b/src/Reflex/Spider/Internal.hs index bd833ed2..c7f66db9 100644 --- a/src/Reflex/Spider/Internal.hs +++ b/src/Reflex/Spider/Internal.hs @@ -20,38 +20,35 @@ {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE InstanceSigs #-} {-# LANGUAGE MultiWayIf #-} - #ifdef USE_REFLEX_OPTIMIZER {-# OPTIONS_GHC -fplugin=Reflex.Optimizer #-} #endif {-# OPTIONS_GHC -Wunused-binds #-} + -- | This module is the implementation of the 'Spider' 'Reflex' engine. It uses -- a graph traversal algorithm to propagate 'Event's and 'Behavior's. -module Reflex.Spider.Internal (module Reflex.Spider.Internal) where +module Reflex.Spider.Internal + ( module Reflex.Spider.Internal + ) where -#if MIN_VERSION_base(4,10,0) -import Control.Applicative (liftA2) -#endif import Control.Concurrent import Control.Exception import Control.Monad hiding (forM, forM_, mapM, mapM_) import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception import Control.Monad.Fix -import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_) import Control.Monad.Primitive import Control.Monad.Reader.Class import Control.Monad.IO.Class import Control.Monad.ReaderIO import Control.Monad.Ref -import Control.Monad.Fail (MonadFail) import qualified Control.Monad.Fail as MonadFail import Data.Align import Data.Coerce import Data.Dependent.Map (DMap) import qualified Data.Dependent.Map as DMap import Data.Dependent.Sum (DSum (..)) -import Data.FastMutableIntMap (FastMutableIntMap, PatchIntMap (..)) +import Data.FastMutableIntMap (FastMutableIntMap) import qualified Data.FastMutableIntMap as FastMutableIntMap import Data.Foldable hiding (concat, elem, sequence_) import Data.Functor.Constant @@ -63,12 +60,10 @@ import qualified Data.IntMap.Strict as IntMap import Data.IORef import Data.Kind (Type) import Data.Maybe hiding (mapMaybe) -import Data.Monoid (mempty, (<>)) import Data.Proxy import Data.These import Data.Traversable import Data.Type.Equality ((:~:)(Refl)) -import Data.Witherable (Filterable, mapMaybe) import GHC.Exts hiding (toList) import GHC.IORef (IORef (..)) import GHC.Stack @@ -76,6 +71,18 @@ import Reflex.FastWeak import System.IO.Unsafe import System.Mem.Weak import Unsafe.Coerce +import Witherable (Filterable, mapMaybe) + +#if !MIN_VERSION_base(4,18,0) +import Control.Applicative (liftA2) +import Control.Monad.Identity hiding (forM, forM_, mapM, mapM_) +import Control.Monad.Fail (MonadFail) +import Data.FastMutableIntMap (PatchIntMap (..)) +import Data.List (isPrefixOf) +import Data.Monoid (mempty, (<>)) +#else +import Control.Monad.Identity +#endif #ifdef MIN_VERSION_semialign #if MIN_VERSION_these(0,8,0) @@ -93,7 +100,6 @@ import Control.Monad.State hiding (forM, forM_, mapM, mapM_, sequence) import Data.List.NonEmpty (NonEmpty (..), nonEmpty) import qualified Data.List.NonEmpty as NonEmpty import Data.Tree (Forest, Tree (..), drawForest) -import Data.List (isPrefixOf) import Data.FastWeakBag (FastWeakBag, FastWeakBagTicket) import qualified Data.FastWeakBag as FastWeakBag @@ -253,7 +259,7 @@ subscribeAndRead = unEvent -- caching; if the computation function is very cheap, this is (much) more -- efficient than 'push' {-# INLINE [1] pushCheap #-} -pushCheap :: HasSpiderTimeline x => (a -> ComputeM x (Maybe b)) -> Event x a -> Event x b +pushCheap :: (a -> ComputeM x (Maybe b)) -> Event x a -> Event x b pushCheap !f e = Event $ \sub -> do (subscription, occ) <- subscribeAndRead e $ debugSubscriber' "push" $ sub { subscriberPropagate = \a -> do @@ -274,7 +280,7 @@ terminalSubscriber p = Subscriber -- | Subscribe to an Event only for the duration of one occurrence {-# INLINE subscribeAndReadHead #-} -subscribeAndReadHead :: HasSpiderTimeline x => Event x a -> Subscriber x a -> EventM x (EventSubscription x, Maybe a) +subscribeAndReadHead :: Event x a -> Subscriber x a -> EventM x (EventSubscription x, Maybe a) subscribeAndReadHead e sub = do subscriptionRef <- liftIO $ newIORef $ error "subscribeAndReadHead: not initialized" (subscription, occ) <- subscribeAndRead e $ debugSubscriber' "head" $ sub @@ -288,7 +294,7 @@ subscribeAndReadHead e sub = do return (subscription, occ) --TODO: Make this lazy in its input event -headE :: (MonadIO m, Defer (SomeMergeInit x) m, HasSpiderTimeline x) => Event x a -> m (Event x a) +headE :: Defer (SomeMergeInit x) m => Event x a -> m (Event x a) headE originalE = do parent <- liftIO $ newIORef $ Just originalE defer $ SomeMergeInit $ do --TODO: Rename SomeMergeInit appropriately @@ -309,12 +315,10 @@ data CacheSubscribed x a #endif } -nowSpiderEventM :: (HasSpiderTimeline x) => EventM x (R.Event (SpiderTimeline x) ()) -nowSpiderEventM = - SpiderEvent <$> now +nowSpiderEventM :: HasSpiderTimeline x => EventM x (R.Event (SpiderTimeline x) ()) +nowSpiderEventM = SpiderEvent <$> now -now :: (MonadIO m, Defer (Some Clear) m, HasSpiderTimeline x - ) => m (Event x ()) +now :: Defer (Some Clear) m => m (Event x ()) now = do nowOrNot <- liftIO $ newIORef $ Just () scheduleClear nowOrNot @@ -553,14 +557,14 @@ recalculateSubscriberHeight :: Height -> Subscriber x a -> IO () recalculateSubscriberHeight = flip subscriberRecalculateHeight -- | Propagate everything at the current height -propagate :: forall x a. HasSpiderTimeline x => a -> WeakBag (Subscriber x a) -> EventM x () +propagate :: a -> WeakBag (Subscriber x a) -> EventM x () propagate a subscribers = withIncreasedDepth (Proxy::Proxy x) $ -- Note: in the following traversal, we do not visit nodes that are added to the list during our traversal; they are new events, which will necessarily have full information already, so there is no need to traverse them --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work WeakBag.traverse_ subscribers $ \s -> subscriberPropagate s a -- | Propagate everything at the current height -propagateFast :: forall x a. HasSpiderTimeline x => a -> FastWeakBag (Subscriber x a) -> EventM x () +propagateFast :: a -> FastWeakBag (Subscriber x a) -> EventM x () propagateFast a subscribers = withIncreasedDepth (Proxy::Proxy x) $ -- Note: in the following traversal, we do not visit nodes that are added to the list during our traversal; they are new events, which will necessarily have full information already, so there is no need to traverse them --TODO: Should we check if nodes already have their values before propagating? Maybe we're re-doing work @@ -993,9 +997,9 @@ instance Monad (BehaviorM x) where {-# INLINE (>>=) #-} BehaviorM x >>= f = BehaviorM $ x >>= unBehaviorM . f {-# INLINE (>>) #-} - BehaviorM x >> BehaviorM y = BehaviorM $ x >> y + (>>) = (*>) {-# INLINE return #-} - return x = BehaviorM $ return x + return = pure #if !MIN_VERSION_base(4,13,0) {-# INLINE fail #-} fail s = BehaviorM $ fail s @@ -1096,7 +1100,7 @@ heightBagRemove (Height h) b@(HeightBag s c) = heightBagVerify $ case IntMap.loo _ -> IntMap.insert h (pred old) c heightBagRemoveMaybe :: Height -> HeightBag -> Maybe HeightBag -heightBagRemoveMaybe (Height h) b@(HeightBag s c) = heightBagVerify . removed <$> IntMap.lookup h c where +heightBagRemoveMaybe (Height h) (HeightBag s c) = heightBagVerify . removed <$> IntMap.lookup h c where removed old = HeightBag (pred s) $ case old of 0 -> IntMap.delete h c _ -> IntMap.insert h (pred old) c @@ -1473,7 +1477,7 @@ filterStack :: String -> [String] -> [String] #ifdef DEBUG_HIDE_INTERNALS filterStack prefix = filter (not . (prefix `isPrefixOf`)) #else -filterStack prefix = id +filterStack _ = id #endif #ifdef DEBUG_CYCLES @@ -2055,7 +2059,7 @@ scheduleMergeSelf m height = scheduleMerge' height (_merge_heightRef m) $ do --TODO: Assert that m is not empty subscriberPropagate (_merge_sub m) vals -checkCycle :: HasSpiderTimeline x => EventSubscribed x -> EventM x () +checkCycle :: EventSubscribed x -> EventM x () checkCycle subscribed = liftIO $ do height <- readIORef (eventSubscribedHeightRef subscribed) @@ -2109,7 +2113,7 @@ updateMerge subscribed m updateFunc p = SomeMergeUpdate updateMe (invalidateMerg {-# INLINE mergeGCheap' #-} mergeGCheap' :: forall k v x p s q. (HasSpiderTimeline x, GCompare k, PatchTarget p ~ DMap k q) => MergeGetSubscription x s -> MergeInitFunc k v q x s -> MergeUpdateFunc k v x p s -> MergeDestroyFunc k s -> DynamicS x p -> Event x (DMap k v) -mergeGCheap' getParent getInitialSubscribers updateFunc destroy d = Event $ \sub -> do +mergeGCheap' _ getInitialSubscribers updateFunc destroy d = Event $ \sub -> do initialParents <- readBehaviorUntracked $ dynamicCurrent d accumRef <- liftIO $ newIORef $ error "merge: accumRef not yet initialized" heightRef <- liftIO $ newIORef $ error "merge: heightRef not yet initialized" @@ -2614,7 +2618,7 @@ instance HasSpiderTimeline x => Reflex.Class.MonadHold (SpiderTimeline x) (Spide headE e = runFrame . runSpiderHostFrame $ Reflex.Class.headE e {-# INLINABLE now #-} now = runFrame . runSpiderHostFrame $ Reflex.Class.now - + instance HasSpiderTimeline x => Reflex.Class.MonadSample (SpiderTimeline x) (SpiderHostFrame x) where sample = SpiderHostFrame . readBehaviorUntracked . unSpiderBehavior --TODO: This can cause problems with laziness, so we should get rid of it if we can @@ -2843,9 +2847,9 @@ instance Monad (SpiderHost x) where {-# INLINABLE (>>=) #-} SpiderHost x >>= f = SpiderHost $ x >>= unSpiderHost . f {-# INLINABLE (>>) #-} - SpiderHost x >> SpiderHost y = SpiderHost $ x >> y + (>>) = (*>) {-# INLINABLE return #-} - return x = SpiderHost $ return x + return = pure #if !MIN_VERSION_base(4,13,0) {-# INLINABLE fail #-} fail = MonadFail.fail @@ -2872,9 +2876,9 @@ instance Monad (SpiderHostFrame x) where {-# INLINABLE (>>=) #-} SpiderHostFrame x >>= f = SpiderHostFrame $ x >>= runSpiderHostFrame . f {-# INLINABLE (>>) #-} - SpiderHostFrame x >> SpiderHostFrame y = SpiderHostFrame $ x >> y + (>>) = (*>) {-# INLINABLE return #-} - return x = SpiderHostFrame $ return x + return = pure #if !MIN_VERSION_base(4,13,0) {-# INLINABLE fail #-} fail s = SpiderHostFrame $ fail s diff --git a/src/Reflex/Time.hs b/src/Reflex/Time.hs index 4ae42f26..bed11200 100644 --- a/src/Reflex/Time.hs +++ b/src/Reflex/Time.hs @@ -11,6 +11,7 @@ #ifdef USE_TEMPLATE_HASKELL {-# LANGUAGE TemplateHaskell #-} #endif + -- | -- Module: -- Reflex.Time @@ -18,12 +19,6 @@ -- Clocks, timers, and other time-related functions. module Reflex.Time where -import Reflex.Class -import Reflex.Dynamic -import Reflex.PerformEvent.Class -import Reflex.PostBuild.Class -import Reflex.TriggerEvent.Class - import Control.Concurrent import qualified Control.Concurrent.Thread.Delay as Concurrent import Control.Lens hiding ((|>)) @@ -33,7 +28,6 @@ import Control.Monad.IO.Class import Data.Align import Data.Data (Data) import Data.Fixed -import Data.Semigroup (Semigroup(..)) import Data.Sequence (Seq, (|>)) import qualified Data.Sequence as Seq import Data.These @@ -42,6 +36,16 @@ import Data.Typeable import GHC.Generics (Generic) import System.Random +#if !MIN_VERSION_base(4,18,0) +import Data.Semigroup (Semigroup(..)) +#endif + +import Reflex.Class +import Reflex.Dynamic +import Reflex.PerformEvent.Class +import Reflex.PostBuild.Class +import Reflex.TriggerEvent.Class + -- | Metadata associated with a timer "tick" data TickInfo = TickInfo { _tickInfo_lastUTC :: UTCTime diff --git a/src/Reflex/TriggerEvent/Base.hs b/src/Reflex/TriggerEvent/Base.hs index 2e409447..7d4de55c 100644 --- a/src/Reflex/TriggerEvent/Base.hs +++ b/src/Reflex/TriggerEvent/Base.hs @@ -1,10 +1,13 @@ -- | This module defines 'TriggerEventT', the standard implementation of -- 'TriggerEvent'. +{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE TypeOperators #-} + module Reflex.TriggerEvent.Base ( TriggerEventT (..) , runTriggerEventT @@ -13,7 +16,6 @@ module Reflex.TriggerEvent.Base , EventTriggerRef (..) ) where -import Control.Applicative (liftA2) import Control.Concurrent import Control.Monad.Catch (MonadMask, MonadThrow, MonadCatch) import Control.Monad.Exception @@ -24,8 +26,13 @@ import Control.Monad.Ref import Data.Coerce import Data.Dependent.Sum import Data.IORef -import Data.Monoid ((<>)) import qualified Data.Semigroup as S + +#if !MIN_VERSION_base(4,18,0) +import Control.Applicative (liftA2) +import Data.Monoid ((<>)) +#endif + import Reflex.Class import Reflex.Adjustable.Class import Reflex.Host.Class diff --git a/src/Reflex/TriggerEvent/Class.hs b/src/Reflex/TriggerEvent/Class.hs index f747db12..0589a1fe 100644 --- a/src/Reflex/TriggerEvent/Class.hs +++ b/src/Reflex/TriggerEvent/Class.hs @@ -3,6 +3,7 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE UndecidableInstances #-} + module Reflex.TriggerEvent.Class ( TriggerEvent (..) ) where diff --git a/src/Reflex/Workflow.hs b/src/Reflex/Workflow.hs index 71317a1e..0efc4eea 100644 --- a/src/Reflex/Workflow.hs +++ b/src/Reflex/Workflow.hs @@ -1,5 +1,6 @@ {-# LANGUAGE RecursiveDo #-} {-# LANGUAGE ScopedTypeVariables #-} + -- | -- Module: -- Reflex.Workflow @@ -7,8 +8,8 @@ -- Provides a convenient way to describe a series of interrelated widgets that -- can send data to, invoke, and replace one another. Useful for modeling user interface -- "workflows." -module Reflex.Workflow ( - Workflow (..) +module Reflex.Workflow + ( Workflow (..) , workflow , workflowView , mapWorkflow @@ -30,13 +31,13 @@ import Reflex.PostBuild.Class newtype Workflow t m a = Workflow { unWorkflow :: m (a, Event t (Workflow t m a)) } -- | Runs a 'Workflow' and returns the 'Dynamic' result of the 'Workflow' (i.e., a 'Dynamic' of the value produced by the current 'Workflow' node, and whose update 'Event' fires whenever one 'Workflow' is replaced by another). -workflow :: forall t m a. (Reflex t, Adjustable t m, MonadFix m, MonadHold t m) => Workflow t m a -> m (Dynamic t a) +workflow :: forall t m a. (Adjustable t m, MonadFix m, MonadHold t m) => Workflow t m a -> m (Dynamic t a) workflow w0 = do rec eResult <- networkHold (unWorkflow w0) $ fmap unWorkflow $ switch $ snd <$> current eResult return $ fmap fst eResult -- | Similar to 'workflow', but outputs an 'Event' that fires at post-build time and whenever the current 'Workflow' is replaced by the next 'Workflow'. -workflowView :: forall t m a. (Reflex t, NotReady t m, Adjustable t m, MonadFix m, MonadHold t m, PostBuild t m) => Workflow t m a -> m (Event t a) +workflowView :: forall t m a. (NotReady t m, Adjustable t m, MonadFix m, MonadHold t m, PostBuild t m) => Workflow t m a -> m (Event t a) workflowView w0 = do rec eResult <- networkView . fmap unWorkflow =<< holdDyn w0 eReplace eReplace <- fmap switch $ hold never $ fmap snd eResult diff --git a/test/DebugCycles.hs b/test/DebugCycles.hs index e0bf3f67..e42d6d25 100644 --- a/test/DebugCycles.hs +++ b/test/DebugCycles.hs @@ -29,7 +29,7 @@ import Reflex.EventWriter.Base import Test.Run import Test.Hspec import Reflex.Spider.Internal (EventLoopException) -import Data.Witherable (Filterable) +import Witherable (Filterable) #if defined(MIN_VERSION_these_lens) || (MIN_VERSION_these(0,8,0) && !MIN_VERSION_these(0,9,0)) import Data.These.Lens