-- | Brick application types
module Dyna.Brick.Types(
  -- * Brick helper types
  Box,
  BoxId(..),
  Win(..),
  Act(..),
  MouseUpEvent(..),
  MouseDownEvent(..),
  -- * Brick application monad
  Run(..),
  evalRun,
  -- * FRP types
  Evt(..),
  Dyn(..),
  -- * Internal types
  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)

----------------------------------------------------------------------------------
-- brick helper types

-- | Synonym to fix the Widget parameter
type Box = Widget BoxId

-- | Box identifier
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)

-- | Actions for Brick rendering engine
data Act
  = Quit -- ^ Quit the app

-- | Window of the application
data Win = Win
  { Win -> Dyn [Box]
win'widgets :: Dyn [Box]   -- ^ window view
  , Win -> Evt Act
win'acts    :: Evt Act     -- ^ brick app actions
  }

-- | Mouse down events only
data MouseDownEvent = MouseDownEvent BoxId Button [Modifier] Location

-- | Mouse up events only
data MouseUpEvent = MouseUpEvent BoxId (Maybe Button) Location

----------------------------------------------------------------------------------
-- Brick application monad

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

----------------------------------------------------------------------------------
-- FRP types

-- | Event stream
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


-- | Dynamic value that continuously changes over time
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
(>=*)

----------------------------------------------------------------------------------
-- internal types

-- | Environment for execution of Brick and routing events to sensor streams
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
  }

-- | Init new environment
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

-- | Internal events to interact with brock application
data InternalEvent
  = UpdateWidgets [Box]
     -- ^ update the view
  | BrickAct Act
      -- ^ send command to brick