reflex-0.10.0.0: test/QueryT.hs
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
import Control.Lens
import Control.Monad.Fix
import Data.Align
import Data.Functor.Misc
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Map.Monoidal (MonoidalMap)
import Data.Semigroup
import Data.Semigroup.Commutative
import Data.These
import qualified Data.AppendMap as AMap
#if defined(MIN_VERSION_these_lens) || (MIN_VERSION_these(0,8,0) && !MIN_VERSION_these(0,9,0))
import Data.These.Lens
#endif
import Data.Patch.MapWithMove
import Reflex
import Test.Run
newtype MyQuery = MyQuery SelectedCount
deriving (Commutative, Eq, Group, Monoid, Ord, Read, Semigroup, Show)
instance Query MyQuery where
type QueryResult MyQuery = ()
crop _ _ = ()
instance (Ord k, Query a, Eq (QueryResult a), Align (MonoidalMap k)) => Query (Selector k a) where
type QueryResult (Selector k a) = Selector k (QueryResult a)
crop (Selector q) (Selector r) = Selector $ AMap.intersectionWith (flip crop) r q
newtype Selector k a = Selector {unSelector :: MonoidalMap k a}
deriving (Eq, Functor, Ord, Read, Show)
#if !(MIN_VERSION_monoidal_containers(0,4,1))
deriving instance Ord k => Align (MonoidalMap k)
#endif
instance (Ord k, Eq a, Monoid a, Align (MonoidalMap k)) => Semigroup (Selector k a) where
(Selector a) <> (Selector b) = Selector $ fmapMaybe id $ f a b
where
f = alignWith $ \case
This x -> Just x
That y -> Just y
These x y ->
let z = x `mappend` y
in if z == mempty then Nothing else Just z
instance (Ord k, Eq a, Monoid a, Align (MonoidalMap k)) => Monoid (Selector k a) where
mempty = Selector AMap.empty
mappend = (<>)
instance (Eq a, Ord k, Group a, Align (MonoidalMap k)) => Group (Selector k a) where
negateG = fmap negateG
instance (Eq a, Ord k, Group a, Align (MonoidalMap k)) => Commutative (Selector k a)
main :: IO ()
main = do
[0, 1, 1, 0] <-
fmap (map fst . concat)
$ runApp (testQueryT testRunWithReplace) ()
$ map (Just . That) [That (), This (), That ()]
[0, 1, 1, 0] <-
fmap (map fst . concat)
$ runApp (testQueryT testSequenceDMapWithAdjust) ()
$ map (Just . That) [That (), This (), That ()]
[0, 1, 1, 0] <-
fmap (map fst . concat)
$ runApp (testQueryT testSequenceDMapWithAdjustWithMove) ()
$ map (Just . That) [That (), This (), That ()]
return ()
testQueryT
:: (Reflex t, MonadFix m)
=> (Event t () -> Event t () -> QueryT t (Selector Int MyQuery) m ())
-> AppIn t () (These () ())
-> m (AppOut t Int Int)
testQueryT w (AppIn _ pulse) = do
let replace = fmapMaybe (^? here) pulse
increment = fmapMaybe (^? there) pulse
(_, q) <- runQueryT (w replace increment) $ pure mempty
let qDyn =
ffor (incrementalToDynamic q) $ \(Selector s) -> case AMap.keys s of
k : _ -> k
[] -> error "testQueryT"
return $
AppOut
{ _appOut_behavior = current qDyn
, _appOut_event = updated qDyn
}
testRunWithReplace
:: ( Reflex t
, Adjustable t m
, MonadHold t m
, MonadFix m
, MonadQuery t (Selector Int MyQuery) m
)
=> Event t ()
-> Event t ()
-> m ()
testRunWithReplace replace increment = do
let w = do
n <- count increment
queryDyn $ zipDynWith (\x y -> Selector (AMap.singleton (x :: Int) y)) n $ pure $ MyQuery $ SelectedCount 1
_ <- runWithReplace w $ w <$ replace
return ()
testSequenceDMapWithAdjust
:: ( Reflex t
, Adjustable t m
, MonadHold t m
, MonadFix m
, MonadQuery t (Selector Int MyQuery) m
)
=> Event t ()
-> Event t ()
-> m ()
testSequenceDMapWithAdjust replace increment = do
_ <- listHoldWithKey (Map.singleton () ()) (Map.singleton () (Just ()) <$ replace) $ \_ _ -> do
n <- count increment
queryDyn $ zipDynWith (\x y -> Selector (AMap.singleton (x :: Int) y)) n $ pure $ MyQuery $ SelectedCount 1
return ()
testSequenceDMapWithAdjustWithMove
:: ( Reflex t
, Adjustable t m
, MonadHold t m
, MonadFix m
, MonadQuery t (Selector Int MyQuery) m
)
=> Event t ()
-> Event t ()
-> m ()
testSequenceDMapWithAdjustWithMove replace increment = do
_ <- listHoldWithKeyWithMove (Map.singleton () ()) (Map.singleton () (Just ()) <$ replace) $ \_ _ -> do
n <- count increment
queryDyn $ zipDynWith (\x y -> Selector (AMap.singleton (x :: Int) y)) n $ pure $ MyQuery $ SelectedCount 1
return ()
-- scam it out to test traverseDMapWithAdjustWithMove
listHoldWithKeyWithMove :: forall t m k v a. (Ord k, MonadHold t m, Adjustable t m) => Map k v -> Event t (Map k (Maybe v)) -> (k -> v -> m a) -> m (Dynamic t (Map k a))
listHoldWithKeyWithMove m0 m' f = do
(n0, n') <- mapMapWithAdjustWithMove f m0 $ ffor m' $ PatchMapWithMove . Map.map (\v -> NodeInfo (maybe From_Delete From_Insert v) Nothing)
incrementalToDynamic <$> holdIncremental n0 n'
-- -}