module Reactive.Threepenny.Types where

import Control.Monad.Trans.RWS.Lazy
import Data.Functor.Identity ()

import           Data.Hashable
import qualified Data.Vault.Strict   as Vault.Strict
import           Data.Unique.Really

{-----------------------------------------------------------------------------
    Pulse and Latch
------------------------------------------------------------------------------}
type Values = Vault.Strict.Vault

type Handler  = EvalP (IO ())
data Priority = DoLatch | DoIO deriving (Priority -> Priority -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Priority -> Priority -> Bool
$c/= :: Priority -> Priority -> Bool
== :: Priority -> Priority -> Bool
$c== :: Priority -> Priority -> Bool
Eq,Int -> Priority -> ShowS
[Priority] -> ShowS
Priority -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Priority] -> ShowS
$cshowList :: [Priority] -> ShowS
show :: Priority -> String
$cshow :: Priority -> String
showsPrec :: Int -> Priority -> ShowS
$cshowsPrec :: Int -> Priority -> ShowS
Show,Eq Priority
Priority -> Priority -> Bool
Priority -> Priority -> Ordering
Priority -> Priority -> Priority
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Priority -> Priority -> Priority
$cmin :: Priority -> Priority -> Priority
max :: Priority -> Priority -> Priority
$cmax :: Priority -> Priority -> Priority
>= :: Priority -> Priority -> Bool
$c>= :: Priority -> Priority -> Bool
> :: Priority -> Priority -> Bool
$c> :: Priority -> Priority -> Bool
<= :: Priority -> Priority -> Bool
$c<= :: Priority -> Priority -> Bool
< :: Priority -> Priority -> Bool
$c< :: Priority -> Priority -> Bool
compare :: Priority -> Priority -> Ordering
$ccompare :: Priority -> Priority -> Ordering
Ord,Int -> Priority
Priority -> Int
Priority -> [Priority]
Priority -> Priority
Priority -> Priority -> [Priority]
Priority -> Priority -> Priority -> [Priority]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Priority -> Priority -> Priority -> [Priority]
$cenumFromThenTo :: Priority -> Priority -> Priority -> [Priority]
enumFromTo :: Priority -> Priority -> [Priority]
$cenumFromTo :: Priority -> Priority -> [Priority]
enumFromThen :: Priority -> Priority -> [Priority]
$cenumFromThen :: Priority -> Priority -> [Priority]
enumFrom :: Priority -> [Priority]
$cenumFrom :: Priority -> [Priority]
fromEnum :: Priority -> Int
$cfromEnum :: Priority -> Int
toEnum :: Int -> Priority
$ctoEnum :: Int -> Priority
pred :: Priority -> Priority
$cpred :: Priority -> Priority
succ :: Priority -> Priority
$csucc :: Priority -> Priority
Enum)

data Pulse a = Pulse
    { forall a. Pulse a -> ((Unique, Priority), Handler) -> Build (IO ())
addHandlerP :: ((Unique, Priority), Handler) -> Build (IO ())
    , forall a. Pulse a -> EvalP (Maybe a)
evalP       :: EvalP (Maybe a)
    }

instance Hashable Priority where
    hashWithSalt :: Int -> Priority -> Int
hashWithSalt = forall b a. Hashable b => (a -> b) -> Int -> a -> Int
hashUsing forall a. Enum a => a -> Int
fromEnum
    hash :: Priority -> Int
hash         = forall a. Enum a => a -> Int
fromEnum

data Latch a = Latch { forall a. Latch a -> EvalL a
readL :: EvalL a }

{-----------------------------------------------------------------------------
    Monads
------------------------------------------------------------------------------}
-- | The 'EvalP' monad is used to evaluate pulses.
type EvalP = RWST () () Values BuildIO
    -- state: current pulse values

-- | The 'EvalL' monad is used to evaluate latches.
type EvalL = IO

-- | The 'Build' monad is used to add pulses and latches to the graph.
type Build   = IO
type BuildIO = Build