-----------------------------------------------------------------------------
{-# LANGUAGE CPP                        #-}
{-# LANGUAGE FlexibleInstances          #-}
-----------------------------------------------------------------------------
{-# OPTIONS_GHC -fno-warn-orphans       #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Miso.Effect
-- Copyright   :  (C) 2016-2025 David M. Johnson
-- License     :  BSD3-style (see the file LICENSE)
-- Maintainer  :  David M. Johnson <code@dmj.io>
-- Stability   :  experimental
-- Portability :  non-portable
--
-- This module defines t'Effect', t'Sub' and t'Sink' types, which are used to define
-- 'Miso.Types.update' function and 'Miso.Types.subs' field of the t'Miso.Types.Component'.
--
----------------------------------------------------------------------------
module Miso.Effect
  ( -- ** Effect
    -- *** Types
    Effect
  , Sub
  , Sink
  , DOMRef
  , ComponentInfo (..)
  , ComponentId
  , mkComponentInfo
  -- ** I/O
  , Schedule (..)
  , Synchronicity (..)
    -- *** Combinators
  , (<#)
  , (#>)
  , batch
  , batch_
  , io
  , io_
  , sync
  , sync_
  , for
  , issue
  , withSink
  , mapSub
  , noop
  , beforeAll
  , afterAll
  , modifyAllIO
  -- *** Lens
  , componentDOMRef
  , componentParentId
  , componentId
  -- *** Internal
  , runEffect
  -- *** Deprecated
  , scheduleIO
  , scheduleIO_
  , scheduleIOFor_
  , scheduleSub
  , effectSub
  , batchEff
  , noEff
  ) where
-----------------------------------------------------------------------------
import           Control.Monad (void)
import           Data.Foldable (for_)
import           Control.Monad.RWS ( RWS, put, tell, execRWS, censor)
-----------------------------------------------------------------------------
import           Miso.Lens
import           Miso.DSL.FFI
-----------------------------------------------------------------------------
-- | Smart constructor for t'ComponentInfo'
mkComponentInfo
  :: ComponentId
  -- ^ Component Id
  -> ComponentId
  -- ^ Parent Component Id
  -> DOMRef
  -- ^ DOM Reference
  -> ComponentInfo parent
mkComponentInfo :: forall parent.
ComponentId -> ComponentId -> DOMRef -> ComponentInfo parent
mkComponentInfo = ComponentId -> ComponentId -> DOMRef -> ComponentInfo parent
forall parent.
ComponentId -> ComponentId -> DOMRef -> ComponentInfo parent
ComponentInfo
-----------------------------------------------------------------------------
-- | This is the 'Reader r' in t'Miso.Effect'. Accessible via 'Control.Monad.Reader.ask'. It holds
-- a phantom type for @parent@. This is used as a witness when calling the
-- @parent@ function, and using 'Miso.Property.prop'.
data ComponentInfo parent
  = ComponentInfo
  { forall parent. ComponentInfo parent -> ComponentId
_componentId :: ComponentId
  , forall parent. ComponentInfo parent -> ComponentId
_componentParentId :: ComponentId
  , forall parent. ComponentInfo parent -> DOMRef
_componentDOMRef :: DOMRef
  }
-----------------------------------------------------------------------------
-- | Lens for accessing the t'ComponentId' from t'ComponentInfo'.
--
-- @
--   update = \case
--     SomeAction -> do
--       compId <- view componentId
--       someAction compId
-- @
--
-- @since 1.9.0.0
componentId :: Lens (ComponentInfo parent) ComponentId
componentId :: forall parent. Lens (ComponentInfo parent) ComponentId
componentId = (ComponentInfo parent -> ComponentId)
-> (ComponentInfo parent -> ComponentId -> ComponentInfo parent)
-> Lens (ComponentInfo parent) ComponentId
forall record field.
(record -> field)
-> (record -> field -> record) -> Lens record field
lens ComponentInfo parent -> ComponentId
forall parent. ComponentInfo parent -> ComponentId
_componentId ((ComponentInfo parent -> ComponentId -> ComponentInfo parent)
 -> Lens (ComponentInfo parent) ComponentId)
-> (ComponentInfo parent -> ComponentId -> ComponentInfo parent)
-> Lens (ComponentInfo parent) ComponentId
forall a b. (a -> b) -> a -> b
$ \ComponentInfo parent
r ComponentId
x -> ComponentInfo parent
r { _componentId = x }
-----------------------------------------------------------------------------
-- | Lens for accessing the parents's  t'ComponentId' from t'ComponentInfo'.
--
-- @
--
-- update = \case
--   SomeAction -> do
--     compParentId <- view componentParentId
--     someAction compParentId
-- @
--
-- @since 1.9.0.0
componentParentId :: Lens (ComponentInfo parent) ComponentId
componentParentId :: forall parent. Lens (ComponentInfo parent) ComponentId
componentParentId = (ComponentInfo parent -> ComponentId)
-> (ComponentInfo parent -> ComponentId -> ComponentInfo parent)
-> Lens (ComponentInfo parent) ComponentId
forall record field.
(record -> field)
-> (record -> field -> record) -> Lens record field
lens ComponentInfo parent -> ComponentId
forall parent. ComponentInfo parent -> ComponentId
_componentParentId ((ComponentInfo parent -> ComponentId -> ComponentInfo parent)
 -> Lens (ComponentInfo parent) ComponentId)
-> (ComponentInfo parent -> ComponentId -> ComponentInfo parent)
-> Lens (ComponentInfo parent) ComponentId
forall a b. (a -> b) -> a -> b
$ \ComponentInfo parent
r ComponentId
x -> ComponentInfo parent
r { _componentParentId = x }
-----------------------------------------------------------------------------
-- | Lens for accessing the underlying t'Miso.Types.Component' t'DOMRef'.
--
-- @
--   update = \case
--     SomeAction -> do
--       domRef <- view componentDOMRef
--       someAction domRef
-- @
--
-- @since 1.9.0.0
componentDOMRef :: Lens (ComponentInfo parent) DOMRef
componentDOMRef :: forall parent. Lens (ComponentInfo parent) DOMRef
componentDOMRef = (ComponentInfo parent -> DOMRef)
-> (ComponentInfo parent -> DOMRef -> ComponentInfo parent)
-> Lens (ComponentInfo parent) DOMRef
forall record field.
(record -> field)
-> (record -> field -> record) -> Lens record field
lens ComponentInfo parent -> DOMRef
forall parent. ComponentInfo parent -> DOMRef
_componentDOMRef ((ComponentInfo parent -> DOMRef -> ComponentInfo parent)
 -> Lens (ComponentInfo parent) DOMRef)
-> (ComponentInfo parent -> DOMRef -> ComponentInfo parent)
-> Lens (ComponentInfo parent) DOMRef
forall a b. (a -> b) -> a -> b
$ \ComponentInfo parent
r DOMRef
x -> ComponentInfo parent
r { _componentDOMRef = x }
-----------------------------------------------------------------------------
-- | 'ComponentId' of the current t'Miso.Types.Component'
type ComponentId = Int
-----------------------------------------------------------------------------
-- | Type synonym for constructing event subscriptions.
--
-- The 'Sink' callback is used to dispatch actions which are then fed
-- back into the 'Miso.Types.update' function.
type Sub action = Sink action -> IO ()
-----------------------------------------------------------------------------
-- | Function to asynchronously dispatch actions to the 'Miso.Types.update' function.
type Sink action = action -> IO ()
-----------------------------------------------------------------------------
-- | Smart constructor for an 'Effect' with exactly one action.
infixl 0 <#
(<#) :: model -> IO action -> Effect parent model action
<# :: forall model action parent.
model -> IO action -> Effect parent model action
(<#) model
m IO action
action = model
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put model
m RWST (ComponentInfo parent) [Schedule action] model Identity ()
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall a b.
RWST (ComponentInfo parent) [Schedule action] model Identity a
-> RWST (ComponentInfo parent) [Schedule action] model Identity b
-> RWST (ComponentInfo parent) [Schedule action] model Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Schedule action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [ (Sink action -> IO ()) -> Schedule action
forall action. (Sink action -> IO ()) -> Schedule action
async ((Sink action -> IO ()) -> Schedule action)
-> (Sink action -> IO ()) -> Schedule action
forall a b. (a -> b) -> a -> b
$ \Sink action
f -> Sink action
f Sink action -> IO action -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO action
action ]
-----------------------------------------------------------------------------
async :: (Sink action -> IO ()) -> Schedule action
async :: forall action. (Sink action -> IO ()) -> Schedule action
async = Synchronicity -> (Sink action -> IO ()) -> Schedule action
forall action.
Synchronicity -> (Sink action -> IO ()) -> Schedule action
Schedule Synchronicity
Async
-----------------------------------------------------------------------------
-- | `Effect` smart constructor, flipped
infixr 0 #>
(#>) :: IO action -> model -> Effect parent model action
#> :: forall action model parent.
IO action -> model -> Effect parent model action
(#>) = (model -> IO action -> Effect parent model action)
-> IO action -> model -> Effect parent model action
forall a b c. (a -> b -> c) -> b -> a -> c
flip model -> IO action -> Effect parent model action
forall model action parent.
model -> IO action -> Effect parent model action
(<#)
-----------------------------------------------------------------------------
-- | Smart constructor for an 'Effect' with multiple actions.
--
-- @since 1.9.0.0
batch :: [IO action] -> Effect parent model action
batch :: forall action parent model.
[IO action] -> Effect parent model action
batch [IO action]
actions = [RWST (ComponentInfo parent) [Schedule action] model Identity ()]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_
  [ [Schedule action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [ (Sink action -> IO ()) -> Schedule action
forall action. (Sink action -> IO ()) -> Schedule action
async ((Sink action -> IO ()) -> Schedule action)
-> (Sink action -> IO ()) -> Schedule action
forall a b. (a -> b) -> a -> b
$ \Sink action
f -> Sink action
f Sink action -> IO action -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO action
action ]
  | IO action
action <- [IO action]
actions
  ]
-----------------------------------------------------------------------------
-- | Like @batch@ but actions are discarded
--
-- @since 1.9.0.0
batch_ :: [IO ()] -> Effect parent model action
batch_ :: forall parent model action. [IO ()] -> Effect parent model action
batch_ [IO ()]
actions = [RWST (ComponentInfo parent) [Schedule action] model Identity ()]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_
  [ [Schedule action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [ (Sink action -> IO ()) -> Schedule action
forall action. (Sink action -> IO ()) -> Schedule action
async (IO () -> Sink action -> IO ()
forall a b. a -> b -> a
const IO ()
action) ]
  | IO ()
action <- [IO ()]
actions
  ]
-----------------------------------------------------------------------------
-- | A monad for succinctly expressing model transitions in the @update@ function.
--
-- t'Effect' is a @RWS@, where the @State@ abstracts over manually passing the model
-- around. It's also a @Writer@ @Monad@, where the accumulator is a list of scheduled
-- @IO@ actions. Multiple actions can be scheduled using 'Control.Monad.Writer.Class.tell'
-- from the @mtl@ library and a single action can be scheduled using 'io_'.
--
-- An t'Effect' represents the results of an update action.
--
-- It consists of the updated model and a list of subscriptions. Each t'Sub' is
-- run in a new thread so there is no risk of accidentally blocking the
-- application.
--
-- Tip: use the t'Effect' monad in combination with the stateful
-- <https://hackage.haskell.org/package/lens/docs/Control-Lens-Operators.html lens>
-- operators (all operators ending in "@=@"). The following example assumes
-- the lenses @field1@, @counter@ and @field2@ are in scope and that the
-- @LambdaCase@ language extension is enabled:
--
-- @
-- myComponent = Component
--   { update = \\case
--       MyAction1 -> do
--         field1 .= value1
--         counter += 1
--       MyAction2 -> do
--         field2 %= f
--         io_ $ do
--           putStrLn \"Hello\"
--           putStrLn \"World!\"
--   , ...
--   }
-- @
type Effect parent model action = RWS (ComponentInfo parent) [Schedule action] model ()
-----------------------------------------------------------------------------
-- | Represents a scheduled 'Effect' that is executed either synchronously
-- or asynchronously.
--
-- All t'IO' is by default asynchronous, use the 'sync' function for synchronous
-- execution. Beware 'sync' can block the render thread for a specific
-- t'Miso.Types.Component'.
--
-- N.B. During t'Miso.Types.Component' unmounting, all effects are evaluated
-- synchronously.
--
-- @since 1.9.0.0
data Schedule action = Schedule Synchronicity (Sink action -> IO ())
-----------------------------------------------------------------------------
-- | Type to represent a DOM reference
type DOMRef = JSVal
-----------------------------------------------------------------------------
-- | Internal function used to unwrap an @Effect@
runEffect
    :: Effect parent model action
    -> ComponentInfo parent
    -> model
    -> (model, [Schedule action])
runEffect :: forall parent model action.
Effect parent model action
-> ComponentInfo parent -> model -> (model, [Schedule action])
runEffect = RWS (ComponentInfo parent) [Schedule action] model ()
-> ComponentInfo parent -> model -> (model, [Schedule action])
forall r w s a. RWS r w s a -> r -> s -> (s, w)
execRWS
-----------------------------------------------------------------------------
-- | Turn a 'Sub' that consumes actions of type @a@ into a 'Sub' that consumes
-- actions of type @b@ using the supplied function of type @a -> b@.
mapSub :: (a -> b) -> Sub a -> Sub b
mapSub :: forall a b. (a -> b) -> Sub a -> Sub b
mapSub a -> b
f Sub a
sub = \Sink b
g -> Sub a
sub (Sink b
g Sink b -> (a -> b) -> a -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f)
-----------------------------------------------------------------------------
-- | Schedule a single 'IO' action, executed synchronously. For asynchronous
-- execution, see 'io'.
--
-- Please use this with caution because it will block the render thread.
--
-- @since 1.9.0.0
sync :: IO action -> Effect parent model action
sync :: forall action parent model. IO action -> Effect parent model action
sync IO action
action = [Schedule action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [ Synchronicity -> (Sink action -> IO ()) -> Schedule action
forall action.
Synchronicity -> (Sink action -> IO ()) -> Schedule action
Schedule Synchronicity
Sync ((Sink action -> IO ()) -> Schedule action)
-> (Sink action -> IO ()) -> Schedule action
forall a b. (a -> b) -> a -> b
$ \Sink action
f -> Sink action
f Sink action -> IO action -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< IO action
action ]
-----------------------------------------------------------------------------
-- | Like 'sync', except discards the result.
--
-- @since 1.9.0.0
sync_ :: IO () -> Effect parent model action
sync_ :: forall parent model action. IO () -> Effect parent model action
sync_ IO ()
action = [Schedule action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [ Synchronicity -> (Sink action -> IO ()) -> Schedule action
forall action.
Synchronicity -> (Sink action -> IO ()) -> Schedule action
Schedule Synchronicity
Sync ((Sink action -> IO ()) -> Schedule action)
-> (Sink action -> IO ()) -> Schedule action
forall a b. (a -> b) -> a -> b
$ \Sink action
_ -> IO ()
action ]
-----------------------------------------------------------------------------
-- | Schedule a single 'IO' action for later execution.
--
-- Note that multiple 'IO' action can be scheduled using
-- 'Control.Monad.Writer.Class.tell' from the @mtl@ library.
--
-- @since 1.9.0.0
io :: IO action -> Effect parent model action
io :: forall action parent model. IO action -> Effect parent model action
io IO action
action = (Sink action -> IO ()) -> Effect parent model action
forall action parent model.
(Sink action -> IO ()) -> Effect parent model action
withSink (IO action
action IO action -> Sink action -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=)
-----------------------------------------------------------------------------
-- | Like 'io' but doesn't cause an action to be dispatched to
-- the @update@ function.
--
-- This is handy for scheduling @IO@ computations where you don't care
-- about their results or when they complete.
--
-- Note: The result of @IO a@ is discarded.
--
-- @since 1.9.0.0
io_ :: IO a -> Effect parent model action
io_ :: forall a parent model action. IO a -> Effect parent model action
io_ IO a
action = (Sink action -> IO ()) -> Effect parent model action
forall action parent model.
(Sink action -> IO ()) -> Effect parent model action
withSink (\Sink action
_ -> IO a -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void IO a
action)
-----------------------------------------------------------------------------
-- | Like 'io' but generalized to any instance of 'Foldable'
--
-- This is handy for scheduling @IO@ computations that return a @Maybe@ value
--
-- @since 1.9.0.0
for :: Foldable f => IO (f action) -> Effect parent model action
for :: forall (f :: * -> *) action parent model.
Foldable f =>
IO (f action) -> Effect parent model action
for IO (f action)
actions = (Sink action -> IO ()) -> Effect parent model action
forall action parent model.
(Sink action -> IO ()) -> Effect parent model action
withSink ((Sink action -> IO ()) -> Effect parent model action)
-> (Sink action -> IO ()) -> Effect parent model action
forall a b. (a -> b) -> a -> b
$ \Sink action
sink -> IO (f action)
actions IO (f action) -> (f action -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (f action -> Sink action -> IO ())
-> Sink action -> f action -> IO ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip f action -> Sink action -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ Sink action
sink
-----------------------------------------------------------------------------
-- | Performs the given IO action before all IO actions collected by the given
-- effect.
--
-- Example usage:
--
-- > -- delays connecting a websocket by 100000 microseconds
-- > beforeAll (liftIO $ threadDelay 100000) $ websocketConnectJSON OnConnect OnClose OnOpen OnError
beforeAll :: IO () -> Effect parent model action -> Effect parent model action
beforeAll :: forall parent model action.
IO () -> Effect parent model action -> Effect parent model action
beforeAll = (IO () -> IO ())
-> Effect parent model action -> Effect parent model action
forall parent model action.
(IO () -> IO ())
-> Effect parent model action -> Effect parent model action
modifyAllIO ((IO () -> IO ())
 -> Effect parent model action -> Effect parent model action)
-> (IO () -> IO () -> IO ())
-> IO ()
-> Effect parent model action
-> Effect parent model action
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)
-----------------------------------------------------------------------------
-- | Performs the given IO action after all IO actions collected by the given
-- effect.
--
-- Example usage:
--
-- > -- log that running the a websocket Effect completed
-- > afterAll (consoleLog "Done running websocket effect") $ websocketConnectJSON OnConnect OnClose OnOpen OnError
afterAll :: IO () -> Effect parent model action -> Effect parent model action
afterAll :: forall parent model action.
IO () -> Effect parent model action -> Effect parent model action
afterAll = (IO () -> IO ())
-> Effect parent model action -> Effect parent model action
forall parent model action.
(IO () -> IO ())
-> Effect parent model action -> Effect parent model action
modifyAllIO ((IO () -> IO ())
 -> Effect parent model action -> Effect parent model action)
-> (IO () -> IO () -> IO ())
-> IO ()
-> Effect parent model action
-> Effect parent model action
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
(<*)
-----------------------------------------------------------------------------
-- | Modifies all IO collected by the given Effect.
--
-- All 'IO' expressions collected by 'Effect' can be evaluated either
-- synchronously or asynchronously (the default).
--
-- This function can be used to adjoin additional actions to all 'IO'
-- expressions in an 'Effect'. For examples see 'beforeAll' and 'afterAll'.
modifyAllIO
  :: (IO () -> IO ())
  -> Effect parent model action
  -> Effect parent model action
modifyAllIO :: forall parent model action.
(IO () -> IO ())
-> Effect parent model action -> Effect parent model action
modifyAllIO IO () -> IO ()
f = ([Schedule action] -> [Schedule action])
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *) a. MonadWriter w m => (w -> w) -> m a -> m a
censor (([Schedule action] -> [Schedule action])
 -> RWST (ComponentInfo parent) [Schedule action] model Identity ()
 -> RWST (ComponentInfo parent) [Schedule action] model Identity ())
-> ([Schedule action] -> [Schedule action])
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall a b. (a -> b) -> a -> b
$ \[Schedule action]
actions ->
  [ Synchronicity -> (Sink action -> IO ()) -> Schedule action
forall action.
Synchronicity -> (Sink action -> IO ()) -> Schedule action
Schedule Synchronicity
x (IO () -> IO ()
f (IO () -> IO ()) -> (Sink action -> IO ()) -> Sink action -> IO ()
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sink action -> IO ()
action)
  | Schedule Synchronicity
x Sink action -> IO ()
action <- [Schedule action]
actions
  ]
-----------------------------------------------------------------------------
-- | @withSink@ allows users to access the sink of the t'Miso.Types.Component' or top-level
-- t'Miso.Types.Component' in their application. This is useful for introducing 'IO' into the system.
-- A synonym for 'Control.Monad.Writer.tell', specialized to 'Effect'.
--
-- A use-case is scheduling an 'IO' computation which creates a 3rd-party JS
-- widget which has an associated callback. The callback can then call the sink
-- to turn events into actions.
--
-- > update FetchJSON = withSink $ \sink -> getJSON (sink . ReceivedJSON) (sink . HandleError)
--
-- @since 1.9.0.0
withSink :: (Sink action -> IO ()) -> Effect parent model action
withSink :: forall action parent model.
(Sink action -> IO ()) -> Effect parent model action
withSink Sink action -> IO ()
f = [Schedule action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [ (Sink action -> IO ()) -> Schedule action
forall action. (Sink action -> IO ()) -> Schedule action
async Sink action -> IO ()
f ]
-----------------------------------------------------------------------------
-- | Issue a new @action@ to be processed by 'Miso.Types.update'.
--
-- > data Action = HelloWorld
-- > type Model  = Int
-- >
-- > update :: Action -> Effect Model Action
-- > update = \case
-- >   Click -> issue HelloWorld
--
-- @since 1.9.0.0
issue :: action -> Effect parent model action
issue :: forall action parent model. action -> Effect parent model action
issue action
action = [Schedule action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [ (Sink action -> IO ()) -> Schedule action
forall action. (Sink action -> IO ()) -> Schedule action
async ((Sink action -> IO ()) -> Schedule action)
-> (Sink action -> IO ()) -> Schedule action
forall a b. (a -> b) -> a -> b
$ \Sink action
f -> Sink action
f action
action ]
-----------------------------------------------------------------------------
-- | See 'io'
{-# DEPRECATED scheduleIO "Please use 'io' instead" #-}
scheduleIO :: IO action -> Effect parent model action
scheduleIO :: forall action parent model. IO action -> Effect parent model action
scheduleIO = IO action -> Effect parent model action
forall action parent model. IO action -> Effect parent model action
io
-----------------------------------------------------------------------------
-- | See 'io_'
{-# DEPRECATED scheduleIO_ "Please use 'io_' instead" #-}
scheduleIO_ :: IO () -> Effect parent model action
scheduleIO_ :: forall parent model action. IO () -> Effect parent model action
scheduleIO_ = IO () -> Effect parent model action
forall a parent model action. IO a -> Effect parent model action
io_
-----------------------------------------------------------------------------
-- | See 'for'
{-# DEPRECATED scheduleIOFor_ "Please use 'for' instead" #-}
scheduleIOFor_ :: Foldable f => IO (f action) -> Effect parent model action
scheduleIOFor_ :: forall (f :: * -> *) action parent model.
Foldable f =>
IO (f action) -> Effect parent model action
scheduleIOFor_ = IO (f action) -> Effect parent model action
forall (f :: * -> *) action parent model.
Foldable f =>
IO (f action) -> Effect parent model action
for
-----------------------------------------------------------------------------
-- | See 'withSink'
{-# DEPRECATED scheduleSub "Please use 'withSink' instead" #-}
scheduleSub :: (Sink action -> IO ()) -> Effect parent model action
scheduleSub :: forall action parent model.
(Sink action -> IO ()) -> Effect parent model action
scheduleSub = (Sink action -> IO ()) -> Effect parent model action
forall action parent model.
(Sink action -> IO ()) -> Effect parent model action
withSink
-----------------------------------------------------------------------------
-- | See 'withSink', 'put'
{-# DEPRECATED effectSub "Please use 'put' and 'withSink' instead " #-}
effectSub :: model -> (Sink action -> IO ()) -> Effect parent model action
effectSub :: forall model action parent.
model -> (Sink action -> IO ()) -> Effect parent model action
effectSub model
m Sink action -> IO ()
s = model
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put model
m RWST (ComponentInfo parent) [Schedule action] model Identity ()
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall a b.
RWST (ComponentInfo parent) [Schedule action] model Identity a
-> RWST (ComponentInfo parent) [Schedule action] model Identity b
-> RWST (ComponentInfo parent) [Schedule action] model Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Sink action -> IO ())
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall action parent model.
(Sink action -> IO ()) -> Effect parent model action
withSink Sink action -> IO ()
s
-----------------------------------------------------------------------------
-- | See 'put'
{-# DEPRECATED noEff "Please use 'put' instead " #-}
noEff :: model -> Effect parent model action
noEff :: forall model parent action. model -> Effect parent model action
noEff = model
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put
-----------------------------------------------------------------------------
-- | See 'put', 'batch'
{-# DEPRECATED batchEff "Please use 'put' and 'batch' instead " #-}
batchEff :: model -> [IO action] -> Effect parent model action
batchEff :: forall model action parent.
model -> [IO action] -> Effect parent model action
batchEff model
model [IO action]
actions = do
  model
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put model
model
  [IO action]
-> RWST (ComponentInfo parent) [Schedule action] model Identity ()
forall action parent model.
[IO action] -> Effect parent model action
batch [IO action]
actions
-----------------------------------------------------------------------------
-- | Helper for t'Miso.Types.Component' construction, when you want to ignore the 'Miso.Types.update'
-- function temporarily, or permanently.
--
-- @since 1.9.0.0
noop :: action -> Effect parent model action
noop :: forall action parent model. action -> Effect parent model action
noop = Effect parent model action -> action -> Effect parent model action
forall a b. a -> b -> a
const (() -> Effect parent model action
forall a.
a -> RWST (ComponentInfo parent) [Schedule action] model Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
-----------------------------------------------------------------------------
-- | Data type to indicate if effects should be handled asynchronously
-- or synchronously.
--
data Synchronicity
  = Async
  | Sync
  deriving (ComponentId -> Synchronicity -> ShowS
[Synchronicity] -> ShowS
Synchronicity -> String
(ComponentId -> Synchronicity -> ShowS)
-> (Synchronicity -> String)
-> ([Synchronicity] -> ShowS)
-> Show Synchronicity
forall a.
(ComponentId -> a -> ShowS)
-> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: ComponentId -> Synchronicity -> ShowS
showsPrec :: ComponentId -> Synchronicity -> ShowS
$cshow :: Synchronicity -> String
show :: Synchronicity -> String
$cshowList :: [Synchronicity] -> ShowS
showList :: [Synchronicity] -> ShowS
Show, Synchronicity -> Synchronicity -> Bool
(Synchronicity -> Synchronicity -> Bool)
-> (Synchronicity -> Synchronicity -> Bool) -> Eq Synchronicity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Synchronicity -> Synchronicity -> Bool
== :: Synchronicity -> Synchronicity -> Bool
$c/= :: Synchronicity -> Synchronicity -> Bool
/= :: Synchronicity -> Synchronicity -> Bool
Eq)
-----------------------------------------------------------------------------