module Dyna.Brick.Types(
Box,
BoxId(..),
Win(..),
Act(..),
MouseUpEvent(..),
MouseDownEvent(..),
Run(..),
evalRun,
Evt(..),
Dyn(..),
Env(..),
newEnv,
InternalEvent(..),
) where
import Prelude hiding ((<*))
import Control.Applicative (liftA2, liftA3)
import Control.Monad.Reader
import Control.Monad.Base
import Control.Monad.Trans.Control (MonadBaseControl(..))
import Control.Monad.Random.Class
import Control.Concurrent.Chan.Unagi
import Data.Text (Text)
import Data.Boolean
import Data.AdditiveGroup
import Data.AffineSpace
import Data.VectorSpace
import Data.Basis
import Data.Cross
import Data.String
import Temporal.Class
import Data.IORef
import Dyna qualified as D
import Brick
import qualified Graphics.Vty as Vty
import Graphics.Vty (Key(..), Modifier, Button)
type Box = Widget BoxId
newtype BoxId = BoxId { BoxId -> Text
getBoxId :: Text }
deriving (Int -> BoxId -> ShowS
[BoxId] -> ShowS
BoxId -> String
(Int -> BoxId -> ShowS)
-> (BoxId -> String) -> ([BoxId] -> ShowS) -> Show BoxId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BoxId] -> ShowS
$cshowList :: [BoxId] -> ShowS
show :: BoxId -> String
$cshow :: BoxId -> String
showsPrec :: Int -> BoxId -> ShowS
$cshowsPrec :: Int -> BoxId -> ShowS
Show, BoxId -> BoxId -> Bool
(BoxId -> BoxId -> Bool) -> (BoxId -> BoxId -> Bool) -> Eq BoxId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BoxId -> BoxId -> Bool
$c/= :: BoxId -> BoxId -> Bool
== :: BoxId -> BoxId -> Bool
$c== :: BoxId -> BoxId -> Bool
Eq, Eq BoxId
Eq BoxId
-> (BoxId -> BoxId -> Ordering)
-> (BoxId -> BoxId -> Bool)
-> (BoxId -> BoxId -> Bool)
-> (BoxId -> BoxId -> Bool)
-> (BoxId -> BoxId -> Bool)
-> (BoxId -> BoxId -> BoxId)
-> (BoxId -> BoxId -> BoxId)
-> Ord BoxId
BoxId -> BoxId -> Bool
BoxId -> BoxId -> Ordering
BoxId -> BoxId -> BoxId
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 :: BoxId -> BoxId -> BoxId
$cmin :: BoxId -> BoxId -> BoxId
max :: BoxId -> BoxId -> BoxId
$cmax :: BoxId -> BoxId -> BoxId
>= :: BoxId -> BoxId -> Bool
$c>= :: BoxId -> BoxId -> Bool
> :: BoxId -> BoxId -> Bool
$c> :: BoxId -> BoxId -> Bool
<= :: BoxId -> BoxId -> Bool
$c<= :: BoxId -> BoxId -> Bool
< :: BoxId -> BoxId -> Bool
$c< :: BoxId -> BoxId -> Bool
compare :: BoxId -> BoxId -> Ordering
$ccompare :: BoxId -> BoxId -> Ordering
$cp1Ord :: Eq BoxId
Ord, ReadPrec [BoxId]
ReadPrec BoxId
Int -> ReadS BoxId
ReadS [BoxId]
(Int -> ReadS BoxId)
-> ReadS [BoxId]
-> ReadPrec BoxId
-> ReadPrec [BoxId]
-> Read BoxId
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BoxId]
$creadListPrec :: ReadPrec [BoxId]
readPrec :: ReadPrec BoxId
$creadPrec :: ReadPrec BoxId
readList :: ReadS [BoxId]
$creadList :: ReadS [BoxId]
readsPrec :: Int -> ReadS BoxId
$creadsPrec :: Int -> ReadS BoxId
Read)
data Act
= Quit
data Win = Win
{ Win -> Dyn [Box]
win'widgets :: Dyn [Box]
, Win -> Evt Act
win'acts :: Evt Act
}
data MouseDownEvent = MouseDownEvent BoxId Button [Modifier] Location
data MouseUpEvent = MouseUpEvent BoxId (Maybe Button) Location
newtype Run a = Run { Run a -> ReaderT Env IO a
unRun :: ReaderT Env IO a }
deriving ( a -> Run b -> Run a
(a -> b) -> Run a -> Run b
(forall a b. (a -> b) -> Run a -> Run b)
-> (forall a b. a -> Run b -> Run a) -> Functor Run
forall a b. a -> Run b -> Run a
forall a b. (a -> b) -> Run a -> Run b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Run b -> Run a
$c<$ :: forall a b. a -> Run b -> Run a
fmap :: (a -> b) -> Run a -> Run b
$cfmap :: forall a b. (a -> b) -> Run a -> Run b
Functor, Functor Run
a -> Run a
Functor Run
-> (forall a. a -> Run a)
-> (forall a b. Run (a -> b) -> Run a -> Run b)
-> (forall a b c. (a -> b -> c) -> Run a -> Run b -> Run c)
-> (forall a b. Run a -> Run b -> Run b)
-> (forall a b. Run a -> Run b -> Run a)
-> Applicative Run
Run a -> Run b -> Run b
Run a -> Run b -> Run a
Run (a -> b) -> Run a -> Run b
(a -> b -> c) -> Run a -> Run b -> Run c
forall a. a -> Run a
forall a b. Run a -> Run b -> Run a
forall a b. Run a -> Run b -> Run b
forall a b. Run (a -> b) -> Run a -> Run b
forall a b c. (a -> b -> c) -> Run a -> Run b -> Run c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Run a -> Run b -> Run a
$c<* :: forall a b. Run a -> Run b -> Run a
*> :: Run a -> Run b -> Run b
$c*> :: forall a b. Run a -> Run b -> Run b
liftA2 :: (a -> b -> c) -> Run a -> Run b -> Run c
$cliftA2 :: forall a b c. (a -> b -> c) -> Run a -> Run b -> Run c
<*> :: Run (a -> b) -> Run a -> Run b
$c<*> :: forall a b. Run (a -> b) -> Run a -> Run b
pure :: a -> Run a
$cpure :: forall a. a -> Run a
$cp1Applicative :: Functor Run
Applicative, Applicative Run
a -> Run a
Applicative Run
-> (forall a b. Run a -> (a -> Run b) -> Run b)
-> (forall a b. Run a -> Run b -> Run b)
-> (forall a. a -> Run a)
-> Monad Run
Run a -> (a -> Run b) -> Run b
Run a -> Run b -> Run b
forall a. a -> Run a
forall a b. Run a -> Run b -> Run b
forall a b. Run a -> (a -> Run b) -> Run b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Run a
$creturn :: forall a. a -> Run a
>> :: Run a -> Run b -> Run b
$c>> :: forall a b. Run a -> Run b -> Run b
>>= :: Run a -> (a -> Run b) -> Run b
$c>>= :: forall a b. Run a -> (a -> Run b) -> Run b
$cp1Monad :: Applicative Run
Monad, MonadReader Env, Monad Run
Monad Run -> (forall a. IO a -> Run a) -> MonadIO Run
IO a -> Run a
forall a. IO a -> Run a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> Run a
$cliftIO :: forall a. IO a -> Run a
$cp1MonadIO :: Monad Run
MonadIO
, MonadBase IO, Monad Run
Run a
Run [a]
Monad Run
-> (forall a. Random a => (a, a) -> Run a)
-> (forall a. Random a => Run a)
-> (forall a. Random a => (a, a) -> Run [a])
-> (forall a. Random a => Run [a])
-> MonadRandom Run
(a, a) -> Run a
(a, a) -> Run [a]
forall a. Random a => Run a
forall a. Random a => Run [a]
forall a. Random a => (a, a) -> Run a
forall a. Random a => (a, a) -> Run [a]
forall (m :: * -> *).
Monad m
-> (forall a. Random a => (a, a) -> m a)
-> (forall a. Random a => m a)
-> (forall a. Random a => (a, a) -> m [a])
-> (forall a. Random a => m [a])
-> MonadRandom m
getRandoms :: Run [a]
$cgetRandoms :: forall a. Random a => Run [a]
getRandomRs :: (a, a) -> Run [a]
$cgetRandomRs :: forall a. Random a => (a, a) -> Run [a]
getRandom :: Run a
$cgetRandom :: forall a. Random a => Run a
getRandomR :: (a, a) -> Run a
$cgetRandomR :: forall a. Random a => (a, a) -> Run a
$cp1MonadRandom :: Monad Run
MonadRandom)
evalRun :: Run a -> Env -> IO a
evalRun :: Run a -> Env -> IO a
evalRun (Run ReaderT Env IO a
act) Env
env = ReaderT Env IO a -> Env -> IO a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT Env IO a
act Env
env
newtype StMRun a =
StMRun { StMRun a -> StM (ReaderT Env IO) a
unStMRun :: StM (ReaderT Env IO) a }
instance MonadBaseControl IO Run where
type StM Run a = StMRun a
liftBaseWith :: (RunInBase Run IO -> IO a) -> Run a
liftBaseWith RunInBase Run IO -> IO a
f =
ReaderT Env IO a -> Run a
forall a. ReaderT Env IO a -> Run a
Run (ReaderT Env IO a -> Run a) -> ReaderT Env IO a -> Run a
forall a b. (a -> b) -> a -> b
$ (RunInBase (ReaderT Env IO) IO -> IO a) -> ReaderT Env IO a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
(RunInBase m b -> b a) -> m a
liftBaseWith ((RunInBase (ReaderT Env IO) IO -> IO a) -> ReaderT Env IO a)
-> (RunInBase (ReaderT Env IO) IO -> IO a) -> ReaderT Env IO a
forall a b. (a -> b) -> a -> b
$ \RunInBase (ReaderT Env IO) IO
q -> RunInBase Run IO -> IO a
f ((a -> StMRun a) -> IO a -> IO (StMRun a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> StMRun a
forall a. StM (ReaderT Env IO) a -> StMRun a
StMRun (IO a -> IO (StMRun a))
-> (Run a -> IO a) -> Run a -> IO (StMRun a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReaderT Env IO a -> IO a
RunInBase (ReaderT Env IO) IO
q (ReaderT Env IO a -> IO a)
-> (Run a -> ReaderT Env IO a) -> Run a -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Run a -> ReaderT Env IO a
forall a. Run a -> ReaderT Env IO a
unRun)
restoreM :: StM Run a -> Run a
restoreM = ReaderT Env IO a -> Run a
forall a. ReaderT Env IO a -> Run a
Run (ReaderT Env IO a -> Run a)
-> (StMRun a -> ReaderT Env IO a) -> StMRun a -> Run a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> ReaderT Env IO a
forall (b :: * -> *) (m :: * -> *) a.
MonadBaseControl b m =>
StM m a -> m a
restoreM (a -> ReaderT Env IO a)
-> (StMRun a -> a) -> StMRun a -> ReaderT Env IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StMRun a -> a
forall a. StMRun a -> StM (ReaderT Env IO) a
unStMRun
instance D.Frp Run where
type Ref Run = IORef
newtype Evt a = Evt { Evt a -> Evt Run a
unEvt :: D.Evt Run a }
deriving (a -> Evt b -> Evt a
(a -> b) -> Evt a -> Evt b
(forall a b. (a -> b) -> Evt a -> Evt b)
-> (forall a b. a -> Evt b -> Evt a) -> Functor Evt
forall a b. a -> Evt b -> Evt a
forall a b. (a -> b) -> Evt a -> Evt b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Evt b -> Evt a
$c<$ :: forall a b. a -> Evt b -> Evt a
fmap :: (a -> b) -> Evt a -> Evt b
$cfmap :: forall a b. (a -> b) -> Evt a -> Evt b
Functor, b -> Evt a -> Evt a
NonEmpty (Evt a) -> Evt a
Evt a -> Evt a -> Evt a
(Evt a -> Evt a -> Evt a)
-> (NonEmpty (Evt a) -> Evt a)
-> (forall b. Integral b => b -> Evt a -> Evt a)
-> Semigroup (Evt a)
forall b. Integral b => b -> Evt a -> Evt a
forall a. NonEmpty (Evt a) -> Evt a
forall a. Evt a -> Evt a -> Evt a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> Evt a -> Evt a
stimes :: b -> Evt a -> Evt a
$cstimes :: forall a b. Integral b => b -> Evt a -> Evt a
sconcat :: NonEmpty (Evt a) -> Evt a
$csconcat :: forall a. NonEmpty (Evt a) -> Evt a
<> :: Evt a -> Evt a -> Evt a
$c<> :: forall a. Evt a -> Evt a -> Evt a
Semigroup, Semigroup (Evt a)
Evt a
Semigroup (Evt a)
-> Evt a
-> (Evt a -> Evt a -> Evt a)
-> ([Evt a] -> Evt a)
-> Monoid (Evt a)
[Evt a] -> Evt a
Evt a -> Evt a -> Evt a
forall a. Semigroup (Evt a)
forall a. Evt a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [Evt a] -> Evt a
forall a. Evt a -> Evt a -> Evt a
mconcat :: [Evt a] -> Evt a
$cmconcat :: forall a. [Evt a] -> Evt a
mappend :: Evt a -> Evt a -> Evt a
$cmappend :: forall a. Evt a -> Evt a -> Evt a
mempty :: Evt a
$cmempty :: forall a. Evt a
$cp1Monoid :: forall a. Semigroup (Evt a)
Monoid, Functor Evt
a -> Evt a
Functor Evt
-> (forall a. a -> Evt a)
-> (forall a b. Evt (a -> b) -> Evt a -> Evt b)
-> (forall a b c. (a -> b -> c) -> Evt a -> Evt b -> Evt c)
-> (forall a b. Evt a -> Evt b -> Evt b)
-> (forall a b. Evt a -> Evt b -> Evt a)
-> Applicative Evt
Evt a -> Evt b -> Evt b
Evt a -> Evt b -> Evt a
Evt (a -> b) -> Evt a -> Evt b
(a -> b -> c) -> Evt a -> Evt b -> Evt c
forall a. a -> Evt a
forall a b. Evt a -> Evt b -> Evt a
forall a b. Evt a -> Evt b -> Evt b
forall a b. Evt (a -> b) -> Evt a -> Evt b
forall a b c. (a -> b -> c) -> Evt a -> Evt b -> Evt c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Evt a -> Evt b -> Evt a
$c<* :: forall a b. Evt a -> Evt b -> Evt a
*> :: Evt a -> Evt b -> Evt b
$c*> :: forall a b. Evt a -> Evt b -> Evt b
liftA2 :: (a -> b -> c) -> Evt a -> Evt b -> Evt c
$cliftA2 :: forall a b c. (a -> b -> c) -> Evt a -> Evt b -> Evt c
<*> :: Evt (a -> b) -> Evt a -> Evt b
$c<*> :: forall a b. Evt (a -> b) -> Evt a -> Evt b
pure :: a -> Evt a
$cpure :: forall a. a -> Evt a
$cp1Applicative :: Functor Evt
Applicative, Applicative Evt
a -> Evt a
Applicative Evt
-> (forall a b. Evt a -> (a -> Evt b) -> Evt b)
-> (forall a b. Evt a -> Evt b -> Evt b)
-> (forall a. a -> Evt a)
-> Monad Evt
Evt a -> (a -> Evt b) -> Evt b
Evt a -> Evt b -> Evt b
forall a. a -> Evt a
forall a b. Evt a -> Evt b -> Evt b
forall a b. Evt a -> (a -> Evt b) -> Evt b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Evt a
$creturn :: forall a. a -> Evt a
>> :: Evt a -> Evt b -> Evt b
$c>> :: forall a b. Evt a -> Evt b -> Evt b
>>= :: Evt a -> (a -> Evt b) -> Evt b
$c>>= :: forall a b. Evt a -> (a -> Evt b) -> Evt b
$cp1Monad :: Applicative Evt
Monad, [Evt a] -> Evt a
Evt a -> Evt a -> Evt a
([Evt a] -> Evt a) -> (Evt a -> Evt a -> Evt a) -> Melody (Evt a)
forall a. [Evt a] -> Evt a
forall a. Evt a -> Evt a -> Evt a
forall a. ([a] -> a) -> (a -> a -> a) -> Melody a
+:+ :: Evt a -> Evt a -> Evt a
$c+:+ :: forall a. Evt a -> Evt a -> Evt a
mel :: [Evt a] -> Evt a
$cmel :: forall a. [Evt a] -> Evt a
Melody, [Evt a] -> Evt a
Evt a -> Evt a -> Evt a
([Evt a] -> Evt a) -> (Evt a -> Evt a -> Evt a) -> Harmony (Evt a)
forall a. [Evt a] -> Evt a
forall a. Evt a -> Evt a -> Evt a
forall a. ([a] -> a) -> (a -> a -> a) -> Harmony a
=:= :: Evt a -> Evt a -> Evt a
$c=:= :: forall a. Evt a -> Evt a -> Evt a
har :: [Evt a] -> Evt a
$char :: forall a. [Evt a] -> Evt a
Harmony, Harmony (Evt a)
Melody (Evt a)
Melody (Evt a) -> Harmony (Evt a) -> Compose (Evt a)
forall a. Harmony (Evt a)
forall a. Melody (Evt a)
forall a. Melody a -> Harmony a -> Compose a
$cp2Compose :: forall a. Harmony (Evt a)
$cp1Compose :: forall a. Melody (Evt a)
Compose, Evt a -> Evt a
(Evt a -> Evt a) -> Loop (Evt a)
forall a. Evt a -> Evt a
forall a. (a -> a) -> Loop a
loop :: Evt a -> Evt a
$cloop :: forall a. Evt a -> Evt a
Loop)
type instance DurOf (Evt a) = Float
instance Limit (Evt a) where
lim :: DurOf (Evt a) -> Evt a -> Evt a
lim DurOf (Evt a)
t (Evt Evt Run a
evt) = Evt Run a -> Evt a
forall a. Evt Run a -> Evt a
Evt (Evt Run a -> Evt a) -> Evt Run a -> Evt a
forall a b. (a -> b) -> a -> b
$ DurOf (Evt Run a) -> Evt Run a -> Evt Run a
forall a. Limit a => DurOf a -> a -> a
lim (Float -> NominalDiffTime
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
DurOf (Evt a)
t) Evt Run a
evt
newtype Dyn a = Dyn { Dyn a -> Dyn Run a
unDyn :: D.Dyn Run a }
deriving (a -> Dyn b -> Dyn a
(a -> b) -> Dyn a -> Dyn b
(forall a b. (a -> b) -> Dyn a -> Dyn b)
-> (forall a b. a -> Dyn b -> Dyn a) -> Functor Dyn
forall a b. a -> Dyn b -> Dyn a
forall a b. (a -> b) -> Dyn a -> Dyn b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Dyn b -> Dyn a
$c<$ :: forall a b. a -> Dyn b -> Dyn a
fmap :: (a -> b) -> Dyn a -> Dyn b
$cfmap :: forall a b. (a -> b) -> Dyn a -> Dyn b
Functor, Functor Dyn
a -> Dyn a
Functor Dyn
-> (forall a. a -> Dyn a)
-> (forall a b. Dyn (a -> b) -> Dyn a -> Dyn b)
-> (forall a b c. (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c)
-> (forall a b. Dyn a -> Dyn b -> Dyn b)
-> (forall a b. Dyn a -> Dyn b -> Dyn a)
-> Applicative Dyn
Dyn a -> Dyn b -> Dyn b
Dyn a -> Dyn b -> Dyn a
Dyn (a -> b) -> Dyn a -> Dyn b
(a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
forall a. a -> Dyn a
forall a b. Dyn a -> Dyn b -> Dyn a
forall a b. Dyn a -> Dyn b -> Dyn b
forall a b. Dyn (a -> b) -> Dyn a -> Dyn b
forall a b c. (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Dyn a -> Dyn b -> Dyn a
$c<* :: forall a b. Dyn a -> Dyn b -> Dyn a
*> :: Dyn a -> Dyn b -> Dyn b
$c*> :: forall a b. Dyn a -> Dyn b -> Dyn b
liftA2 :: (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
$cliftA2 :: forall a b c. (a -> b -> c) -> Dyn a -> Dyn b -> Dyn c
<*> :: Dyn (a -> b) -> Dyn a -> Dyn b
$c<*> :: forall a b. Dyn (a -> b) -> Dyn a -> Dyn b
pure :: a -> Dyn a
$cpure :: forall a. a -> Dyn a
$cp1Applicative :: Functor Dyn
Applicative, Integer -> Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
(Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Integer -> Dyn a)
-> Num (Dyn a)
forall a. Num a => Integer -> Dyn a
forall a. Num a => Dyn a -> Dyn a
forall a. Num a => Dyn a -> Dyn a -> Dyn a
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Dyn a
$cfromInteger :: forall a. Num a => Integer -> Dyn a
signum :: Dyn a -> Dyn a
$csignum :: forall a. Num a => Dyn a -> Dyn a
abs :: Dyn a -> Dyn a
$cabs :: forall a. Num a => Dyn a -> Dyn a
negate :: Dyn a -> Dyn a
$cnegate :: forall a. Num a => Dyn a -> Dyn a
* :: Dyn a -> Dyn a -> Dyn a
$c* :: forall a. Num a => Dyn a -> Dyn a -> Dyn a
- :: Dyn a -> Dyn a -> Dyn a
$c- :: forall a. Num a => Dyn a -> Dyn a -> Dyn a
+ :: Dyn a -> Dyn a -> Dyn a
$c+ :: forall a. Num a => Dyn a -> Dyn a -> Dyn a
Num, Num (Dyn a)
Num (Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Rational -> Dyn a)
-> Fractional (Dyn a)
Rational -> Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
forall a. Fractional a => Num (Dyn a)
forall a. Fractional a => Rational -> Dyn a
forall a. Fractional a => Dyn a -> Dyn a
forall a. Fractional a => Dyn a -> Dyn a -> Dyn a
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Dyn a
$cfromRational :: forall a. Fractional a => Rational -> Dyn a
recip :: Dyn a -> Dyn a
$crecip :: forall a. Fractional a => Dyn a -> Dyn a
/ :: Dyn a -> Dyn a -> Dyn a
$c/ :: forall a. Fractional a => Dyn a -> Dyn a -> Dyn a
$cp1Fractional :: forall a. Fractional a => Num (Dyn a)
Fractional, b -> Dyn a -> Dyn a
NonEmpty (Dyn a) -> Dyn a
Dyn a -> Dyn a -> Dyn a
(Dyn a -> Dyn a -> Dyn a)
-> (NonEmpty (Dyn a) -> Dyn a)
-> (forall b. Integral b => b -> Dyn a -> Dyn a)
-> Semigroup (Dyn a)
forall b. Integral b => b -> Dyn a -> Dyn a
forall a. Semigroup a => NonEmpty (Dyn a) -> Dyn a
forall a. Semigroup a => Dyn a -> Dyn a -> Dyn a
forall a b. (Semigroup a, Integral b) => b -> Dyn a -> Dyn a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Dyn a -> Dyn a
$cstimes :: forall a b. (Semigroup a, Integral b) => b -> Dyn a -> Dyn a
sconcat :: NonEmpty (Dyn a) -> Dyn a
$csconcat :: forall a. Semigroup a => NonEmpty (Dyn a) -> Dyn a
<> :: Dyn a -> Dyn a -> Dyn a
$c<> :: forall a. Semigroup a => Dyn a -> Dyn a -> Dyn a
Semigroup, Semigroup (Dyn a)
Dyn a
Semigroup (Dyn a)
-> Dyn a
-> (Dyn a -> Dyn a -> Dyn a)
-> ([Dyn a] -> Dyn a)
-> Monoid (Dyn a)
[Dyn a] -> Dyn a
Dyn a -> Dyn a -> Dyn a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. Monoid a => Semigroup (Dyn a)
forall a. Monoid a => Dyn a
forall a. Monoid a => [Dyn a] -> Dyn a
forall a. Monoid a => Dyn a -> Dyn a -> Dyn a
mconcat :: [Dyn a] -> Dyn a
$cmconcat :: forall a. Monoid a => [Dyn a] -> Dyn a
mappend :: Dyn a -> Dyn a -> Dyn a
$cmappend :: forall a. Monoid a => Dyn a -> Dyn a -> Dyn a
mempty :: Dyn a
$cmempty :: forall a. Monoid a => Dyn a
$cp1Monoid :: forall a. Monoid a => Semigroup (Dyn a)
Monoid, String -> Dyn a
(String -> Dyn a) -> IsString (Dyn a)
forall a. IsString a => String -> Dyn a
forall a. (String -> a) -> IsString a
fromString :: String -> Dyn a
$cfromString :: forall a. IsString a => String -> Dyn a
IsString,
Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
Dyn a
-> Dyn a
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> Boolean (Dyn a)
forall b.
b -> b -> (b -> b) -> (b -> b -> b) -> (b -> b -> b) -> Boolean b
forall a. Boolean a => Dyn a
forall a. Boolean a => Dyn a -> Dyn a
forall a. Boolean a => Dyn a -> Dyn a -> Dyn a
||* :: Dyn a -> Dyn a -> Dyn a
$c||* :: forall a. Boolean a => Dyn a -> Dyn a -> Dyn a
&&* :: Dyn a -> Dyn a -> Dyn a
$c&&* :: forall a. Boolean a => Dyn a -> Dyn a -> Dyn a
notB :: Dyn a -> Dyn a
$cnotB :: forall a. Boolean a => Dyn a -> Dyn a
false :: Dyn a
$cfalse :: forall a. Boolean a => Dyn a
true :: Dyn a
$ctrue :: forall a. Boolean a => Dyn a
Boolean, Dyn a
Dyn a -> Dyn a
Dyn a -> Dyn a -> Dyn a
Dyn a
-> (Dyn a -> Dyn a -> Dyn a)
-> (Dyn a -> Dyn a)
-> (Dyn a -> Dyn a -> Dyn a)
-> AdditiveGroup (Dyn a)
forall v.
v -> (v -> v -> v) -> (v -> v) -> (v -> v -> v) -> AdditiveGroup v
forall a. AdditiveGroup a => Dyn a
forall a. AdditiveGroup a => Dyn a -> Dyn a
forall a. AdditiveGroup a => Dyn a -> Dyn a -> Dyn a
^-^ :: Dyn a -> Dyn a -> Dyn a
$c^-^ :: forall a. AdditiveGroup a => Dyn a -> Dyn a -> Dyn a
negateV :: Dyn a -> Dyn a
$cnegateV :: forall a. AdditiveGroup a => Dyn a -> Dyn a
^+^ :: Dyn a -> Dyn a -> Dyn a
$c^+^ :: forall a. AdditiveGroup a => Dyn a -> Dyn a -> Dyn a
zeroV :: Dyn a
$czeroV :: forall a. AdditiveGroup a => Dyn a
AdditiveGroup, AdditiveGroup (Dyn a)
AdditiveGroup (Dyn a)
-> (Scalar (Dyn a) -> Dyn a -> Dyn a) -> VectorSpace (Dyn a)
Scalar (Dyn a) -> Dyn a -> Dyn a
forall v. AdditiveGroup v -> (Scalar v -> v -> v) -> VectorSpace v
forall a. VectorSpace a => AdditiveGroup (Dyn a)
forall a. VectorSpace a => Scalar (Dyn a) -> Dyn a -> Dyn a
*^ :: Scalar (Dyn a) -> Dyn a -> Dyn a
$c*^ :: forall a. VectorSpace a => Scalar (Dyn a) -> Dyn a -> Dyn a
$cp1VectorSpace :: forall a. VectorSpace a => AdditiveGroup (Dyn a)
VectorSpace, Dyn a -> Dyn a
(Dyn a -> Dyn a) -> HasNormal (Dyn a)
forall a. HasNormal a => Dyn a -> Dyn a
forall v. (v -> v) -> HasNormal v
normalVec :: Dyn a -> Dyn a
$cnormalVec :: forall a. HasNormal a => Dyn a -> Dyn a
HasNormal, Dyn a -> Dyn a
(Dyn a -> Dyn a) -> HasCross2 (Dyn a)
forall a. HasCross2 a => Dyn a -> Dyn a
forall v. (v -> v) -> HasCross2 v
cross2 :: Dyn a -> Dyn a
$ccross2 :: forall a. HasCross2 a => Dyn a -> Dyn a
HasCross2, Dyn a -> Dyn a -> Dyn a
(Dyn a -> Dyn a -> Dyn a) -> HasCross3 (Dyn a)
forall a. HasCross3 a => Dyn a -> Dyn a -> Dyn a
forall v. (v -> v -> v) -> HasCross3 v
cross3 :: Dyn a -> Dyn a -> Dyn a
$ccross3 :: forall a. HasCross3 a => Dyn a -> Dyn a -> Dyn a
HasCross3, AdditiveGroup (Diff (Dyn a))
AdditiveGroup (Diff (Dyn a))
-> (Dyn a -> Dyn a -> Diff (Dyn a))
-> (Dyn a -> Diff (Dyn a) -> Dyn a)
-> AffineSpace (Dyn a)
Dyn a -> Diff (Dyn a) -> Dyn a
Dyn a -> Dyn a -> Diff (Dyn a)
forall p.
AdditiveGroup (Diff p)
-> (p -> p -> Diff p) -> (p -> Diff p -> p) -> AffineSpace p
forall a. AffineSpace a => AdditiveGroup (Diff (Dyn a))
forall a. AffineSpace a => Dyn a -> Diff (Dyn a) -> Dyn a
forall a. AffineSpace a => Dyn a -> Dyn a -> Diff (Dyn a)
.+^ :: Dyn a -> Diff (Dyn a) -> Dyn a
$c.+^ :: forall a. AffineSpace a => Dyn a -> Diff (Dyn a) -> Dyn a
.-. :: Dyn a -> Dyn a -> Diff (Dyn a)
$c.-. :: forall a. AffineSpace a => Dyn a -> Dyn a -> Diff (Dyn a)
$cp1AffineSpace :: forall a. AffineSpace a => AdditiveGroup (Diff (Dyn a))
AffineSpace, VectorSpace (Dyn a)
VectorSpace (Dyn a)
-> (Basis (Dyn a) -> Dyn a)
-> (Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))])
-> (Dyn a -> Basis (Dyn a) -> Scalar (Dyn a))
-> HasBasis (Dyn a)
Basis (Dyn a) -> Dyn a
Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
forall v.
VectorSpace v
-> (Basis v -> v)
-> (v -> [(Basis v, Scalar v)])
-> (v -> Basis v -> Scalar v)
-> HasBasis v
forall a. (BasisArity a, HasBasis a) => VectorSpace (Dyn a)
forall a. (BasisArity a, HasBasis a) => Basis (Dyn a) -> Dyn a
forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
decompose' :: Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
$cdecompose' :: forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> Basis (Dyn a) -> Scalar (Dyn a)
decompose :: Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
$cdecompose :: forall a.
(BasisArity a, HasBasis a) =>
Dyn a -> [(Basis (Dyn a), Scalar (Dyn a))]
basisValue :: Basis (Dyn a) -> Dyn a
$cbasisValue :: forall a. (BasisArity a, HasBasis a) => Basis (Dyn a) -> Dyn a
$cp1HasBasis :: forall a. (BasisArity a, HasBasis a) => VectorSpace (Dyn a)
HasBasis)
type instance BooleanOf (Dyn a) = Dyn (BooleanOf a)
instance (IfB a) => IfB (Dyn a) where
ifB :: bool -> Dyn a -> Dyn a -> Dyn a
ifB = (BooleanOf a -> a -> a -> a)
-> Dyn (BooleanOf a) -> Dyn a -> Dyn a -> Dyn a
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 BooleanOf a -> a -> a -> a
forall a bool. (IfB a, bool ~ BooleanOf a) => bool -> a -> a -> a
ifB
instance (EqB a) => EqB (Dyn a) where
==* :: Dyn a -> Dyn a -> bool
(==*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (EqB a, bool ~ BooleanOf a) => a -> a -> bool
(==*)
instance (OrdB a) => OrdB (Dyn a) where
<* :: Dyn a -> Dyn a -> bool
(<*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(<*)
>* :: Dyn a -> Dyn a -> bool
(>*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(>*)
<=* :: Dyn a -> Dyn a -> bool
(<=*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(<=*)
>=* :: Dyn a -> Dyn a -> bool
(>=*) = (a -> a -> BooleanOf a) -> Dyn a -> Dyn a -> Dyn (BooleanOf a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> BooleanOf a
forall a bool. (OrdB a, bool ~ BooleanOf a) => a -> a -> bool
(>=*)
data Env = Env
{ Env -> UChan Event
env'eventChan :: D.UChan Vty.Event
, Env -> UChan MouseDownEvent
env'mouseDownChan :: D.UChan MouseDownEvent
, Env -> UChan MouseUpEvent
env'mouseUpChan :: D.UChan MouseUpEvent
}
newEnv :: IO Env
newEnv :: IO Env
newEnv = UChan Event -> UChan MouseDownEvent -> UChan MouseUpEvent -> Env
Env (UChan Event -> UChan MouseDownEvent -> UChan MouseUpEvent -> Env)
-> IO (UChan Event)
-> IO (UChan MouseDownEvent -> UChan MouseUpEvent -> Env)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (UChan Event)
forall a. IO (InChan a, OutChan a)
newChan IO (UChan MouseDownEvent -> UChan MouseUpEvent -> Env)
-> IO (UChan MouseDownEvent) -> IO (UChan MouseUpEvent -> Env)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IO (UChan MouseDownEvent)
forall a. IO (InChan a, OutChan a)
newChan IO (UChan MouseUpEvent -> Env) -> IO (UChan MouseUpEvent) -> IO Env
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> IO (UChan MouseUpEvent)
forall a. IO (InChan a, OutChan a)
newChan
data InternalEvent
= UpdateWidgets [Box]
| BrickAct Act