Merge branch 'release/0.6.2.1' of github.com:ryantrinkle/reflex

* 'release/0.6.2.1' of github.com:ryantrinkle/reflex: (30 commits)
  Loosen monoidal-containers version bounds
  Update CONTRIBUTING.md
  Update CONTRIBUTING.md
  Use unsafePerformIO better (#325)
  Generalize fan following DMap (#318)
  Distribute more generally
  Generalize merge
  Drop *Tag classes
  Fix deprecation warnings related to updated Data.Some
  Bump dependent-sum to latest version
  fan: Rewrite haddock
  Replace hackage link with badge
  Use Some for more existential types (which should be efficient now that it is a newtype)
  Bump upper bounds
  Typo
  DRY conditional compilation
  Bump 'these' upper bound
  Typo
  Update changelog for holdDyn fix
  Make holdDyn lazy in its Event again
  ...

Author: ali-abrar

CONTRIBUTING.md

@@ -0,0 +1,62 @@
+# Contribution Guide
+
+Contributions and issue reports are encouraged and appreciated!
+
+- [Opening Issues](#opening-issues)
+- [Submitting Changes](#submitting-changes)
+  - [Guidelines for Commit Messages](#guidelines-for-commit-messages)
+  - [Guidelines for Pull Requests](#guidelines-for-pull-requests)
+  - [Code Quality](#code-quality)
+  - [Documentation](#documentation)
+
+## Opening Issues
+
+Before opening an issue, please check whether your issue has already been reported. Assuming it has not:
+
+* Describe the issue you're encountering or the suggestion you're making
+* Include any relevant steps to reproduce or code samples you can. It's always easier for us to debug if we have something that demonstrates the error.
+* Let us know what version of reflex you were using. If you're using a github checkout, provide the git hash.
+* Describe how you're building reflex (i.e., via reflex-platform, cabal install, stack, obelisk, etc.). If you're using reflex-platform or obelisk, provide the git hash of your checkout.
+
+## Submitting Changes
+
+### Guidelines for Commit Messages
+
+#### Summary Line
+The summary line of your commit message should summarize the changes being made. Commit messages should be written in the imperative mood and should describe what happens when the commit is applied.
+
+One way to think about it is that your commit message should be able to complete the sentence:
+"When applied, this commit will..."
+
+#### Body
+For breaking changes, new features, refactors, or other major changes, the body of the commit message should describe the motivation behind the change in greater detail and may include references to the issue tracker. The body shouldn't repeat code/comments from the diff.
+
+### Guidelines for Pull Requests
+
+Wherever possible, pull requests should add a single feature or fix a single bug. Pull requests should not bundle several unrelated changes.
+
+### Code Quality
+
+#### Warnings
+
+Your pull request should add no new warnings to the project. It should also generally not disable any warnings.
+
+#### Build and Test
+
+Make sure the project builds and that the tests pass! This will generally also be checked by CI before merge, but trying it yourself first means you'll catch problems earlier and your contribution can be merged that much sooner!
+
+### Documentation
+
+#### In the code
+We're always striving to improve documentation. Please include [haddock](https://haskell-haddock.readthedocs.io/en/latest/index.html) documentation for any added code, and update the documentation for any code you modify.
+
+#### In the [Changelog](ChangeLog.md)
+Add an entry to the changelog when your PR:
+* Adds a feature
+* Deprecates something
+* Includes a breaking change
+* Makes any other change that will impact users
+
+#### In the [Readme](README.md)
+The readme is the first place a lot of people look for information about the repository. Update any parts of the readme that are affected by your PR.
+

ChangeLog.md

@@ -1,17 +1,36 @@
 # Revision history for reflex
 
-## 0.6.0.0 -- 2019-03-20
+## Unreleased
 
-* 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.
+* Generalize `fan` to `fanG` to take a `DMap` with non-`Identity`
+  values.
+
+* Generalize merging functions:
+  `merge` to `mergeG`, 
+  `mergeIncremental` to `mergeIncrementalG`, 
+  `distributeDMapOverDynPure` to `distributeDMapOverDynPureG`,
+  `mergeIncrementalWithMove` to `mergeIncrementalWithMoveG`.  
+
+
+## 0.6.2.0
+
+* Fix `holdDyn` so that it is lazy in its event argument  
+  These produce `DMap`s  whose values needn't be `Identity`.
+* Stop using the now-deprecated `*Tag` classes (e.g., `ShowTag`).
+* Fix `holdDyn` so that it is lazy in its event argument.
 
 ## 0.6.1.0
 
-* Re-export all of Data.Map.Monoidal
-* Fix QueryT and RequesterT tests
+* Re-export all of `Data.Map.Monoidal`
+* Fix `QueryT` and `RequesterT` tests
+
+## 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.

README.md

@@ -1,4 +1,7 @@
 ## [Reflex](https://reflex-frp.org/)
+
+[![Hackage](https://img.shields.io/hackage/v/reflex.svg)](http://hackage.haskell.org/package/reflex)
+
 ### Practical Functional Reactive Programming
 
 Reflex is a fully-deterministic, higher-order Functional Reactive Programming (FRP) interface and an engine that efficiently implements that interface.
@@ -14,8 +17,6 @@ A summary of Reflex functions is available in the [quick reference](Quickref.md)
 
 [/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

default.nix

@@ -11,7 +11,7 @@
 }:
 mkDerivation {
   pname = "reflex";
-  version = "0.6.1";
+  version = "0.6.2.1";
   src = builtins.filterSource (path: type: !(builtins.elem (baseNameOf path) [ ".git" "dist" ])) ./.;
   libraryHaskellDepends = [
     base bifunctors containers dependent-map dependent-sum

reflex.cabal

@@ -1,5 +1,5 @@
 Name: reflex
-Version: 0.6.1
+Version: 0.6.2.1
 Synopsis: Higher-order Functional Reactive Programming
 Description: Reflex is a high-performance, deterministic, higher-order Functional Reactive Programming system
 License: BSD3
@@ -44,13 +44,15 @@ library
     base >= 4.9 && < 4.13,
     bifunctors >= 5.2 && < 5.6,
     comonad,
+    constraints-extras >= 0.2,
     containers >= 0.5 && < 0.7,
     data-default >= 0.5 && < 0.8,
-    dependent-map >= 0.2.4 && < 0.3,
+    dependent-map >= 0.3 && < 0.4,
     exception-transformers == 0.4.*,
+    profunctors,
     lens >= 4.7 && < 5,
     monad-control >= 1.0.1 && < 1.1,
-    monoidal-containers == 0.4.*,
+    monoidal-containers >= 0.4 && < 0.6,
     mtl >= 2.1 && < 2.3,
     prim-uniq >= 0.1.0.1 && < 0.2,
     primitive >= 0.5 && < 0.7,
@@ -61,7 +63,7 @@ library
     semigroups >= 0.16 && < 0.19,
     stm >= 2.4 && < 2.6,
     syb >= 0.5 && < 0.8,
-    these >= 0.4 && < 0.7.7,
+    these >= 0.4 && < 0.9,
     time >= 1.4 && < 1.9,
     transformers >= 0.2,
     transformers-compat >= 0.3,
@@ -133,16 +135,16 @@ library
   if flag(use-template-haskell)
     cpp-options: -DUSE_TEMPLATE_HASKELL
     build-depends:
-      dependent-sum >= 0.3 && < 0.5,
-      haskell-src-exts >= 1.16 && < 1.21,
+      dependent-sum >= 0.6 && < 0.7,
+      haskell-src-exts >= 1.16 && < 1.22,
       haskell-src-meta >= 0.6 && < 0.9,
       template-haskell >= 2.9 && < 2.15
     exposed-modules:
       Reflex.Dynamic.TH
     other-extensions: TemplateHaskell
   else
     build-depends:
-      dependent-sum == 0.4.*
+      dependent-sum == 0.6.*
 
   if flag(fast-weak) && impl(ghcjs)
     cpp-options: -DGHCJS_FAST_WEAK

src/Data/AppendMap.hs

@@ -7,10 +7,14 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
--- | 'Data.Map' with a better 'Monoid' instance
---
--- 'Data.Map' has @mappend = union@, which is left-biased.  AppendMap has
--- @mappend = unionWith mappend@ instead.
+-- |
+-- Module:
+--   Data.AppendMap
+-- Description:
+--   Instances and convenience functions for 'Data.Map.Monoidal'. We use
+--   monoidal-containers to take advantage of its better monoid instance.
+--   'Data.Map' has @mappend = union@, which is left-biased.  'MonoidalMap'
+--   has @mappend = unionWith mappend@ instead.
 module Data.AppendMap
   ( module Data.AppendMap
   , module Data.Map.Monoidal
@@ -30,12 +34,15 @@ import qualified Data.Witherable as W
 import Data.Map.Monoidal
 
 {-# DEPRECATED AppendMap "Use 'MonoidalMap' instead" #-}
+-- | AppendMap is a synonym for 'Data.Map.Monoidal.MonoidalMap'
 type AppendMap = MonoidalMap
 
 {-# DEPRECATED _unAppendMap "Use 'getMonoidalMap' instead" #-}
+-- | A synonym for 'getMonoidalMap'
 _unAppendMap :: MonoidalMap k v -> Map k v
 _unAppendMap = getMonoidalMap
 
+-- | Pattern synonym for 'MonoidalMap'
 pattern AppendMap :: Map k v -> MonoidalMap k v
 pattern AppendMap m = MonoidalMap m
 
@@ -50,6 +57,7 @@ nonEmptyDelete k vs =
        then Nothing
        else Just deleted
 
+-- | Like 'mapMaybe' but indicates whether the resulting container is empty
 mapMaybeNoNull :: (a -> Maybe b)
                -> MonoidalMap token a
                -> Maybe (MonoidalMap token b)
@@ -60,9 +68,11 @@ mapMaybeNoNull f as =
        else Just bs
 
 -- TODO: Move instances to `Reflex.Patch`
+-- | Displays a 'MonoidalMap' as a tree. See 'Data.Map.Lazy.showTree' for details.
 showTree :: forall k a. (Show k, Show a) => MonoidalMap k a -> String
 showTree = coerce (Map.showTree :: Map k a -> String)
 
+-- | Displays a 'MonoidalMap' as a tree, using the supplied function to convert nodes to string.
 showTreeWith :: forall k a. (k -> a -> String) -> Bool -> Bool -> MonoidalMap k a -> String
 showTreeWith = coerce (Map.showTreeWith :: (k -> a -> String) -> Bool -> Bool -> Map k a -> String)
 

src/Data/FastMutableIntMap.hs

@@ -1,4 +1,9 @@
 {-# LANGUAGE TypeFamilies #-}
+-- |
+-- Module:
+--   Data.FastMutableIntMap
+-- Description:
+--   A mutable version of 'IntMap'
 module Data.FastMutableIntMap
   ( FastMutableIntMap
   , new
@@ -32,33 +37,43 @@ import Data.IORef
 import Reflex.Patch.Class
 import Reflex.Patch.IntMap
 
+-- | A 'FastMutableIntMap' holds a map of values of type @a@ and allows low-overhead modifications via IO.
+-- Operations on 'FastMutableIntMap' run in IO.
 newtype FastMutableIntMap a = FastMutableIntMap (IORef (IntMap a))
 
+-- | Create a new 'FastMutableIntMap' out of an 'IntMap'
 new :: IntMap a -> IO (FastMutableIntMap a)
 new m = FastMutableIntMap <$> newIORef m
 
+-- | Create a new empty 'FastMutableIntMap'
 newEmpty :: IO (FastMutableIntMap a)
 newEmpty = FastMutableIntMap <$> newIORef IntMap.empty
 
+-- | Insert an element into a 'FastMutableIntMap' at the given key
 insert :: FastMutableIntMap a -> Int -> a -> IO ()
 insert (FastMutableIntMap r) k v = modifyIORef' r $ IntMap.insert k v
 
+-- | Attempt to lookup an element by key in a 'FastMutableIntMap'
 lookup :: FastMutableIntMap a -> Int -> IO (Maybe a)
 lookup (FastMutableIntMap r) k = IntMap.lookup k <$> readIORef r
 
+-- | Runs the provided action over the intersection of a 'FastMutableIntMap' and an 'IntMap'
 forIntersectionWithImmutable_ :: MonadIO m => FastMutableIntMap a -> IntMap b -> (a -> b -> m ()) -> m ()
 forIntersectionWithImmutable_ (FastMutableIntMap r) b f = do
   a <- liftIO $ readIORef r
   traverse_ (uncurry f) $ IntMap.intersectionWith (,) a b
 
+-- | Runs the provided action over the values of a 'FastMutableIntMap'
 for_ :: MonadIO m => FastMutableIntMap a -> (a -> m ()) -> m ()
 for_ (FastMutableIntMap r) f = do
   a <- liftIO $ readIORef r
   traverse_ f a
 
+-- | Checks whether a 'FastMutableIntMap' is empty
 isEmpty :: FastMutableIntMap a -> IO Bool
 isEmpty (FastMutableIntMap r) = IntMap.null <$> readIORef r
 
+-- | Retrieves the size of a 'FastMutableIntMap'
 size :: FastMutableIntMap a -> IO Int
 size (FastMutableIntMap r) = IntMap.size <$> readIORef r
 
@@ -69,6 +84,8 @@ getFrozenAndClear (FastMutableIntMap r) = do
   writeIORef r IntMap.empty
   return result
 
+-- | Updates the value of a 'FastMutableIntMap' with the given patch (see 'Reflex.Patch.IntMap'),
+-- and returns an 'IntMap' with the modified keys and values.
 applyPatch :: FastMutableIntMap a -> PatchIntMap a -> IO (IntMap a)
 applyPatch (FastMutableIntMap r) p@(PatchIntMap m) = do
   v <- readIORef r

src/Data/FastWeakBag.hs

@@ -50,7 +50,7 @@ newtype FastWeakBag a = FastWeakBag JSVal
 #else
 data FastWeakBag a = FastWeakBag
   { _weakBag_nextId :: {-# UNPACK #-} !(IORef Int) --TODO: what if this wraps around?
-  , _weakBag_children :: {-# UNPACK #-} !(IORef (IntMap (Weak a)))
+  , _weakBag_children :: {-# UNPACK #-} !(IORef (IntMap (Weak a))) -- ^ Map of items contained by the 'FastWeakBag'
   }
 #endif
 

src/Data/Functor/Misc.hs

@@ -52,8 +52,7 @@ import Data.IntMap (IntMap)
 import qualified Data.IntMap as IntMap
 import Data.Map (Map)
 import qualified Data.Map as Map
-import Data.Some (Some)
-import qualified Data.Some as Some
+import Data.Some (Some(Some))
 import Data.These
 import Data.Typeable hiding (Refl)
 
@@ -79,9 +78,6 @@ deriving instance Read k => Read (Const2 k v v)
 instance Show k => GShow (Const2 k v) where
   gshowsPrec n x@(Const2 _) = showsPrec n x
 
-instance (Show k, Show (f v)) => ShowTag (Const2 k v) f where
-  showTaggedPrec (Const2 _) = showsPrec
-
 instance Eq k => GEq (Const2 k v) where
   geq (Const2 a) (Const2 b) =
     if a == b
@@ -124,7 +120,7 @@ intMapWithFunctorToDMap = DMap.fromDistinctAscList . map (\(k, v) -> Const2 k :=
 -- | Convert a 'DMap' to a regular 'Map' by forgetting the types associated with
 -- the keys, using a function to remove the wrapping 'Functor'
 weakenDMapWith :: (forall a. v a -> v') -> DMap k v -> Map (Some k) v'
-weakenDMapWith f = Map.fromDistinctAscList . map (\(k :=> v) -> (Some.This k, f v)) . DMap.toAscList
+weakenDMapWith f = Map.fromDistinctAscList . map (\(k :=> v) -> (Some k, f v)) . DMap.toAscList
 
 --------------------------------------------------------------------------------
 -- WrapArg
@@ -214,11 +210,6 @@ instance GShow (EitherTag l r) where
     LeftTag -> showString "LeftTag"
     RightTag -> showString "RightTag"
 
-instance (Show l, Show r) => ShowTag (EitherTag l r) Identity where
-  showTaggedPrec t n (Identity a) = case t of
-    LeftTag -> showsPrec n a
-    RightTag -> showsPrec n a
-
 -- | Convert 'Either' to a 'DSum'. Inverse of 'dsumToEither'.
 eitherToDSum :: Either a b -> DSum (EitherTag a b) Identity
 eitherToDSum = \case