Merge pull request #292 from reflex-frp/release/0.6

Release/0.6

Author: ali-abrar

ChangeLog.md

@@ -0,0 +1,12 @@
+# Revision history for reflex
+
+## 0.6.0.0 -- 2019-03-20
+
+* Deprecate FunctorMaybe in favor of Data.Witherable.Filterable. We still export fmapMaybe, ffilter, etc., but they all rely on Filterable now.
+* Rename MonadDynamicWriter to DynamicWriter and add a deprecation for the old name.
+* Remove many deprecated functions.
+* Add a Num instance for Dynamic.
+* Add matchRequestsWithResponses to make it easier to use Requester with protocols that don't do this matching for you.
+* Add withRequesterT to map functions over the request and response of a RequesterT.
+* Suppress nil patches in QueryT as an optimization. The Query type must now have an Eq instance.
+* Add throttleBatchWithLag to Reflex.Time. See that module for details.

Quickref.md

@@ -57,15 +57,15 @@ Since MonadHold depends on MonadSample, any [S] function also runs in [H] contex
 [ ]   mergeWith  :: (a -> a -> a) -> [Event a] -> Event a
 [ ]   leftmost   :: [Event a] -> Event a
 [ ]   mergeList  :: [Event a] -> Event (NonEmpty a)
-[ ]   merge      :: GCompare k => DMap (WrapArg Event k) -> Event (DMap k)
+[ ]   merge      :: GCompare k => DMap k Event -> Event (DMap k Identity)
 [ ]   mergeMap   :: Ord k => Map k (Event a) -> Event (Map k a)
 
 -- Efficient one-to-many fanout
-[ ]   fanMap    ::      Ord k => Event (Map k a) -> EventSelector (Const2 k a)
-[ ]   fan       :: GCompare k => Event  (DMap k) -> EventSelector k
-[ ]   select    ::                                  EventSelector k -> k a -> Event a
-[ ]   fanEither ::            Event (Either a b) -> (Event a, Event b)
-[ ]   fanThese  ::            Event (These a b)  -> (Event a, Event b)
+[ ]   fanMap    :: Ord k      => Event (Map k a)         -> EventSelector (Const2 k a)
+[ ]   fan       :: GCompare k => Event (DMap k Identity) -> EventSelector k
+[ ]   select    ::                                          EventSelector k -> k a -> Event a
+[ ]   fanEither :: Event (Either a b) -> (Event a, Event b)
+[ ]   fanThese  :: Event (These a b)  -> (Event a, Event b)
 
 -- Event to Event via function that can sample current values
 [ ]   push       :: (a -> m (Maybe b)) -> Event a -> Event b
@@ -166,7 +166,7 @@ For Events, the returned Event fires whenever the latest Event supplied by the w
 -- Flatten Behavior-of-Event to Event.  Old Event is used during switchover.
 [ ]   switch            ::                  Behavior (Event a)  ->    Event a
 
--- Flatten Dyanmic-of-Event to Event.  New Event is used immediately.
+-- Flatten Dynamic-of-Event to Event.  New Event is used immediately.
 [ ]   switchDyn         ::                   Dynamic (Event a)  ->    Event a
 
 -- Flatten Event-of-Event to Event that fires when both wrapper AND new Event fire.

README.md

@@ -1,19 +1,24 @@
-## Reflex
+## [Reflex](https://reflex-frp.org/)
 ### Practical Functional Reactive Programming
 
-Reflex is an fully-deterministic, higher-order Functional Reactive Programming (FRP) interface and an engine that efficiently implements that interface.
+Reflex is a fully-deterministic, higher-order Functional Reactive Programming (FRP) interface and an engine that efficiently implements that interface.
 
 [Reflex-DOM](https://github.com/reflex-frp/reflex-dom) is a framework built on Reflex that facilitates the development of web pages, including highly-interactive single-page apps.
 
-Comprehensive documentation is still a work in progress, but a tutorial for Reflex and Reflex-DOM is available at https://github.com/reflex-frp/reflex-platform and an introductory talk given at the New York Haskell Meetup is available here: [Part 1](https://www.youtube.com/watch?v=mYvkcskJbc4) / [Part 2](https://www.youtube.com/watch?v=3qfc9XFVo2c).
-
 A summary of Reflex functions is available in the [quick reference](Quickref.md).
 
-### Additional resources
+**Visit https://reflex-frp.org/ for more information, tutorials, documentation and [examples](https://examples.reflex-frp.org/).**
+
+### Resources
 [Get started with Reflex](https://github.com/reflex-frp/reflex-platform)
 
 [/r/reflexfrp](https://www.reddit.com/r/reflexfrp)
 
 [hackage](https://hackage.haskell.org/package/reflex)
 
 [irc.freenode.net #reflex-frp](http://webchat.freenode.net?channels=%23reflex-frp&uio=d4)
+
+### Hacking
+
+Use the `./scripts/hack-on reflex` script in [Reflex Platform](https://github.com/reflex-frp/reflex-platform) to checkout the source code of `reflex` locally in `reflex-platform/reflex` directory.
+Then do modifications to the source in place, and use the `./try-reflex` or `./scripts/work-on` scripts to create the shell to test your changes.

default.nix

@@ -6,12 +6,12 @@
 , template-haskell , these, time, transformers
 , transformers-compat, unbounded-delays, prim-uniq
 , data-default, filepath, directory, filemanip, ghcjs-base
-, monoidal-containers
+, monoidal-containers, witherable
 , useTemplateHaskell ? true
 }:
 mkDerivation {
   pname = "reflex";
-  version = "0.5";
+  version = "0.5.0.1";
   src = builtins.filterSource (path: type: !(builtins.elem (baseNameOf path) [ ".git" "dist" ])) ./.;
   libraryHaskellDepends = [
     base bifunctors containers dependent-map dependent-sum
@@ -21,7 +21,7 @@ mkDerivation {
     transformers-compat prim-uniq
     base bifunctors containers deepseq dependent-map dependent-sum
     mtl ref-tf split transformers data-default
-    random time unbounded-delays monoidal-containers
+    random time unbounded-delays monoidal-containers witherable
   ] ++ (if ghc.isGhcjs or false then [
     ghcjs-base
   ] else []) ++ (if !useTemplateHaskell then [] else [

reflex.cabal

@@ -1,5 +1,5 @@
 Name: reflex
-Version: 0.5
+Version: 0.6
 Synopsis: Higher-order Functional Reactive Programming
 Description: Reflex is a high-performance, deterministic, higher-order Functional Reactive Programming system
 License: BSD3
@@ -15,6 +15,7 @@ bug-reports: https://github.com/reflex-frp/reflex/issues
 extra-source-files:
   README.md
   Quickref.md
+  ChangeLog.md
 
 flag use-reflex-optimizer
   description: Use the GHC plugin Reflex.Optimizer on some of the modules in the package.  This is still experimental.
@@ -60,11 +61,12 @@ library
     semigroups >= 0.16 && < 0.19,
     stm >= 2.4 && < 2.6,
     syb >= 0.5 && < 0.8,
-    these >= 0.4 && < 0.7.6,
+    these >= 0.4 && < 0.7.7,
     time >= 1.4 && < 1.9,
     transformers >= 0.2,
     transformers-compat >= 0.3,
-    unbounded-delays >= 0.1.0.0 && < 0.2
+    unbounded-delays >= 0.1.0.0 && < 0.2,
+    witherable >= 0.2 && < 0.4
 
   exposed-modules:
     Data.AppendMap,
@@ -233,14 +235,16 @@ test-suite RequesterT
   main-is: RequesterT.hs
   hs-source-dirs: test
   build-depends: base
+               , containers
+               , deepseq >= 1.3 && < 1.5
                , dependent-sum
                , dependent-map
                , lens
+               , mtl
                , these
                , transformers
                , reflex
                , ref-tf
-  buildable: False
   other-modules:
     Reflex.TestPlan
     Reflex.Plan.Pure

src/Data/AppendMap.hs

@@ -1,15 +1,10 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE DeriveFunctor #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE RoleAnnotations #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 -- | 'Data.Map' with a better 'Monoid' instance
@@ -31,9 +26,9 @@ import qualified Data.Map.Internal.Debug as Map (showTree, showTreeWith)
 #else
 import qualified Data.Map as Map (showTree, showTreeWith)
 #endif
-import Data.Map.Monoidal
-import Reflex.Class (FunctorMaybe (..))
-import Reflex.Patch (Additive, Group (..))
+import Data.Witherable (Filterable(..))
+import Data.Map.Monoidal (MonoidalMap(..), delete, null, empty)
+import qualified Data.Map.Monoidal as M
 
 {-# DEPRECATED AppendMap "Use 'MonoidalMap' instead" #-}
 type AppendMap = MonoidalMap
@@ -45,8 +40,8 @@ _unAppendMap = getMonoidalMap
 pattern AppendMap :: Map k v -> MonoidalMap k v
 pattern AppendMap m = MonoidalMap m
 
-instance FunctorMaybe (MonoidalMap k) where
-  fmapMaybe = mapMaybe
+instance Filterable (MonoidalMap k) where
+  mapMaybe = M.mapMaybe
 
 -- | Deletes a key, returning 'Nothing' if the result is empty.
 nonEmptyDelete :: Ord k => k -> MonoidalMap k a -> Maybe (MonoidalMap k a)
@@ -60,17 +55,12 @@ mapMaybeNoNull :: (a -> Maybe b)
                -> MonoidalMap token a
                -> Maybe (MonoidalMap token b)
 mapMaybeNoNull f as =
-  let bs = fmapMaybe f as
+  let bs = mapMaybe f as
   in if null bs
        then Nothing
        else Just bs
 
 -- TODO: Move instances to `Reflex.Patch`
-instance (Ord k, Group q) => Group (MonoidalMap k q) where
-  negateG = map negateG
-
-instance (Ord k, Additive q) => Additive (MonoidalMap k q)
-
 showTree :: forall k a. (Show k, Show a) => MonoidalMap k a -> String
 showTree = coerce (Map.showTree :: Map k a -> String)
 

src/Data/Functor/Misc.hs

@@ -38,17 +38,10 @@ module Data.Functor.Misc
   , dmapToThese
   , eitherToDSum
   , dsumToEither
-    -- * Deprecated functions
-  , sequenceDmap
-  , wrapDMap
-  , rewrapDMap
-  , unwrapDMap
-  , unwrapDMapMaybe
-  , extractFunctorDMap
   , ComposeMaybe (..)
   ) where
 
-import Control.Applicative (Applicative, (<$>))
+import Control.Applicative ((<$>))
 import Control.Monad.Identity
 import Data.Dependent.Map (DMap)
 import qualified Data.Dependent.Map as DMap
@@ -249,39 +242,3 @@ newtype ComposeMaybe f a =
   ComposeMaybe { getComposeMaybe :: Maybe (f a) } deriving (Show, Eq, Ord)
 
 deriving instance Functor f => Functor (ComposeMaybe f)
-
---------------------------------------------------------------------------------
--- Deprecated functions
---------------------------------------------------------------------------------
-
-{-# INLINE sequenceDmap #-}
-{-# DEPRECATED sequenceDmap "Use 'Data.Dependent.Map.traverseWithKey (\\_ -> fmap Identity)' instead" #-}
--- | Run the actions contained in the 'DMap'
-sequenceDmap :: Applicative t => DMap f t -> t (DMap f Identity)
-sequenceDmap = DMap.traverseWithKey $ \_ t -> Identity <$> t
-
-{-# DEPRECATED wrapDMap "Use 'Data.Dependent.Map.map (f . runIdentity)' instead" #-}
--- | Replace the 'Identity' functor for a 'DMap''s values with a different functor
-wrapDMap :: (forall a. a -> f a) -> DMap k Identity -> DMap k f
-wrapDMap f = DMap.map $ f . runIdentity
-
-{-# DEPRECATED rewrapDMap "Use 'Data.Dependent.Map.map' instead" #-}
--- | Replace one functor for a 'DMap''s values with a different functor
-rewrapDMap :: (forall (a :: *). f a -> g a) -> DMap k f -> DMap k g
-rewrapDMap = DMap.map
-
-{-# DEPRECATED unwrapDMap "Use 'Data.Dependent.Map.map (Identity . f)' instead" #-}
--- | Replace one functor for a 'DMap''s values with the 'Identity' functor
-unwrapDMap :: (forall a. f a -> a) -> DMap k f -> DMap k Identity
-unwrapDMap f = DMap.map $ Identity . f
-
-{-# DEPRECATED unwrapDMapMaybe "Use 'Data.Dependent.Map.mapMaybeWithKey (\\_ a -> fmap Identity $ f a)' instead" #-}
--- | Like 'unwrapDMap', but possibly delete some values from the DMap
-unwrapDMapMaybe :: GCompare k => (forall a. f a -> Maybe a) -> DMap k f -> DMap k Identity
-unwrapDMapMaybe f = DMap.mapMaybeWithKey $ \_ a -> Identity <$> f a
-
-{-# DEPRECATED extractFunctorDMap "Use 'mapKeyValuePairsMonotonic (\\(Const2 k :=> Identity v) -> Const2 k :=> v)' instead" #-}
--- | Eliminate the 'Identity' functor in a 'DMap' and replace it with the
--- underlying functor
-extractFunctorDMap :: DMap (Const2 k (f v)) Identity -> DMap (Const2 k v) f
-extractFunctorDMap = mapKeyValuePairsMonotonic $ \(Const2 k :=> Identity v) -> Const2 k :=> v

src/Reflex.hs

@@ -19,6 +19,7 @@ import Reflex.Dynamic.TH as X
 import Reflex.Dynamic.Uniq as X
 import Reflex.DynamicWriter.Base as X
 import Reflex.DynamicWriter.Class as X
+import Reflex.NotReady.Class as X
 import Reflex.PerformEvent.Base as X
 import Reflex.PerformEvent.Class as X
 import Reflex.PostBuild.Base as X