Debug.Hoed.Observe

Documentation

type UID = Int

data Event

Constructors

Event

Fields

• eventParent :: !Parent
• change :: !Change

Instances

Eq Event

Methods

(==) :: Event -> Event -> Bool

(/=) :: Event -> Event -> Bool

Show Event

Methods

showsPrec :: Int -> Event -> ShowS

show :: Event -> String

showList :: [Event] -> ShowS

Generic Event

Associated Types

type Rep Event :: * -> *

Methods

from :: Event -> Rep Event x

to :: Rep Event x -> Event

Unbox Event

Vector Vector Event

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Event -> m (Vector Event)

basicUnsafeThaw :: PrimMonad m => Vector Event -> m (Mutable Vector (PrimState m) Event)

basicLength :: Vector Event -> Int

basicUnsafeSlice :: Int -> Int -> Vector Event -> Vector Event

basicUnsafeIndexM :: Monad m => Vector Event -> Int -> m Event

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Event -> Vector Event -> m ()

elemseq :: Vector Event -> Event -> b -> b

MVector MVector Event

Methods

basicLength :: MVector s Event -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Event -> MVector s Event

basicOverlaps :: MVector s Event -> MVector s Event -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Event)

basicInitialize :: PrimMonad m => MVector (PrimState m) Event -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Event -> m (MVector (PrimState m) Event)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Event -> Int -> m Event

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Event -> Int -> Event -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Event -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Event -> Event -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Event -> MVector (PrimState m) Event -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Event -> MVector (PrimState m) Event -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Event -> Int -> m (MVector (PrimState m) Event)

type Rep Event

type Rep Event = D1 * (MetaData "Event" "Debug.Hoed.Observe" "Hoed-0.5.1-6GkquCGsp1cHNYyj6cETAl" False) (C1 * (MetaCons "Event" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "eventParent") SourceUnpack SourceStrict DecidedStrict) (Rec0 * Parent)) (S1 * (MetaSel (Just Symbol "change") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Change))))

data Vector Event

data Vector Event = V_Event (Vector (Parent, Change))

data MVector s Event

data MVector s Event = MV_Event (MVector s (Parent, Change))

data EventWithId

Constructors

EventWithId

Fields

• eventUID :: !UID
• event :: !Event

Instances

Show EventWithId

Methods

showsPrec :: Int -> EventWithId -> ShowS

show :: EventWithId -> String

showList :: [EventWithId] -> ShowS

data Change

Constructors

Observe !Text

Cons !Word8 !Text

ConsChar !Char

Enter

Fun

Instances

Eq Change

Methods

(==) :: Change -> Change -> Bool

(/=) :: Change -> Change -> Bool

Show Change

Methods

showsPrec :: Int -> Change -> ShowS

show :: Change -> String

showList :: [Change] -> ShowS

Generic Change

Associated Types

type Rep Change :: * -> *

Methods

from :: Change -> Rep Change x

to :: Rep Change x -> Change

Unbox Change

Vector Vector Change

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Change -> m (Vector Change)

basicUnsafeThaw :: PrimMonad m => Vector Change -> m (Mutable Vector (PrimState m) Change)

basicLength :: Vector Change -> Int

basicUnsafeSlice :: Int -> Int -> Vector Change -> Vector Change

basicUnsafeIndexM :: Monad m => Vector Change -> Int -> m Change

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Change -> Vector Change -> m ()

elemseq :: Vector Change -> Change -> b -> b

MVector MVector Change

Methods

basicLength :: MVector s Change -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Change -> MVector s Change

basicOverlaps :: MVector s Change -> MVector s Change -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Change)

basicInitialize :: PrimMonad m => MVector (PrimState m) Change -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Change -> m (MVector (PrimState m) Change)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Change -> Int -> m Change

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Change -> Int -> Change -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Change -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Change -> Change -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Change -> MVector (PrimState m) Change -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Change -> MVector (PrimState m) Change -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Change -> Int -> m (MVector (PrimState m) Change)

type Rep Change

type Rep Change = D1 * (MetaData "Change" "Debug.Hoed.Observe" "Hoed-0.5.1-6GkquCGsp1cHNYyj6cETAl" False) ((:+:) * ((:+:) * (C1 * (MetaCons "Observe" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Text))) (C1 * (MetaCons "Cons" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Word8)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Text))))) ((:+:) * (C1 * (MetaCons "ConsChar" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * Char))) ((:+:) * (C1 * (MetaCons "Enter" PrefixI False) (U1 *)) (C1 * (MetaCons "Fun" PrefixI False) (U1 *)))))

data Vector Change

data Vector Change = V_Change (Vector (Word8, Word8, Int))

data MVector s Change

data MVector s Change = MV_Change (MVector s (Word8, Word8, Int))

type ParentPosition = Word8

data Parent

Constructors

Parent

Fields

• parentUID :: !UID
• parentPosition :: !ParentPosition

Instances

Eq Parent

Methods

(==) :: Parent -> Parent -> Bool

(/=) :: Parent -> Parent -> Bool

Show Parent

Methods

showsPrec :: Int -> Parent -> ShowS

show :: Parent -> String

showList :: [Parent] -> ShowS

Generic Parent

Associated Types

type Rep Parent :: * -> *

Methods

from :: Parent -> Rep Parent x

to :: Rep Parent x -> Parent

Unbox Parent

Vector Vector Parent

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Parent -> m (Vector Parent)

basicUnsafeThaw :: PrimMonad m => Vector Parent -> m (Mutable Vector (PrimState m) Parent)

basicLength :: Vector Parent -> Int

basicUnsafeSlice :: Int -> Int -> Vector Parent -> Vector Parent

basicUnsafeIndexM :: Monad m => Vector Parent -> Int -> m Parent

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Parent -> Vector Parent -> m ()

elemseq :: Vector Parent -> Parent -> b -> b

MVector MVector Parent

Methods

basicLength :: MVector s Parent -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Parent -> MVector s Parent

basicOverlaps :: MVector s Parent -> MVector s Parent -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Parent)

basicInitialize :: PrimMonad m => MVector (PrimState m) Parent -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Parent -> m (MVector (PrimState m) Parent)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Parent -> Int -> m Parent

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Parent -> Int -> Parent -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Parent -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Parent -> Parent -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Parent -> MVector (PrimState m) Parent -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Parent -> MVector (PrimState m) Parent -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Parent -> Int -> m (MVector (PrimState m) Parent)

type Rep Parent

type Rep Parent = D1 * (MetaData "Parent" "Debug.Hoed.Observe" "Hoed-0.5.1-6GkquCGsp1cHNYyj6cETAl" False) (C1 * (MetaCons "Parent" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "parentUID") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * UID)) (S1 * (MetaSel (Just Symbol "parentPosition") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 * ParentPosition))))

data Vector Parent

data Vector Parent = V_Parent (Vector (UID, ParentPosition))

data MVector s Parent

data MVector s Parent = MV_Parent (MVector s (UID, ParentPosition))

root :: Parent

isRootEvent :: Event -> Bool

type Trace = Vector Event

endEventStream :: IO Trace

sendEvent :: Int -> Parent -> Change -> IO ()

lookupOrAddString :: Text -> IO Int

events :: Rope IO MVector Event

strings :: MVar (Pair Int (HashMap Text Int))

stringsLookupTable :: IORef (Vector Text)

lookupString :: Int -> Text

initUniq :: IO ()

getUniq :: IO UID

peepUniq :: IO UID

uniq :: IORef UID

class Observable a where

A type class for observable values.

• For Generic datatypes it can be derived automatically.
• For opaque datatypes, use observeOpaque or rely on the catch-all ? instance.
• Custom implementations can exclude one or more fields from the observation:

 instance (Observable a, Observable b) => Observable (excluded, a,b) where
        observe (excluded,a,b) = send "(,,)" (return (,,) excluded << a << b)

Methods

observer :: a -> Parent -> a

observer :: (Generic a, GObservable (Rep a)) => a -> Parent -> a

constrain :: a -> a -> a

constrain :: (Generic a, GConstrain (Rep a)) => a -> a -> a

Instances

Observable Bool

Methods

observer :: Bool -> Parent -> Bool

constrain :: Bool -> Bool -> Bool

Observable Char

Methods

observer :: Char -> Parent -> Char

constrain :: Char -> Char -> Char

Observable Double

Methods

observer :: Double -> Parent -> Double

constrain :: Double -> Double -> Double

Observable Float

Methods

observer :: Float -> Parent -> Float

constrain :: Float -> Float -> Float

Observable Int

Methods

observer :: Int -> Parent -> Int

constrain :: Int -> Int -> Int

Observable Integer

Methods

observer :: Integer -> Parent -> Integer

constrain :: Integer -> Integer -> Integer

Observable ()

Methods

observer :: () -> Parent -> ()

constrain :: () -> () -> ()

Observable Dynamic

Methods

observer :: Dynamic -> Parent -> Dynamic

constrain :: Dynamic -> Dynamic -> Dynamic

Observable SomeException

Methods

observer :: SomeException -> Parent -> SomeException

constrain :: SomeException -> SomeException -> SomeException

Observable a => Observable [a]

Methods

observer :: [a] -> Parent -> [a]

constrain :: [a] -> [a] -> [a]

Observable a => Observable (Maybe a)

Methods

observer :: Maybe a -> Parent -> Maybe a

constrain :: Maybe a -> Maybe a -> Maybe a

Observable a => Observable (IO a)

Methods

observer :: IO a -> Parent -> IO a

constrain :: IO a -> IO a -> IO a

(Observable a, Observable b) => Observable (a -> b)

Methods

observer :: (a -> b) -> Parent -> a -> b

constrain :: (a -> b) -> (a -> b) -> a -> b

(Observable a, Observable b) => Observable (Either a b)

Methods

observer :: Either a b -> Parent -> Either a b

constrain :: Either a b -> Either a b -> Either a b

(Observable a, Observable b) => Observable (a, b)

Methods

observer :: (a, b) -> Parent -> (a, b)

constrain :: (a, b) -> (a, b) -> (a, b)

(Ix a, Observable a, Observable b) => Observable (Array a b)

Methods

observer :: Array a b -> Parent -> Array a b

constrain :: Array a b -> Array a b -> Array a b

(Observable a, Observable b, Observable c) => Observable (a, b, c)

Methods

observer :: (a, b, c) -> Parent -> (a, b, c)

constrain :: (a, b, c) -> (a, b, c) -> (a, b, c)

(Observable a, Observable b, Observable c, Observable d) => Observable (a, b, c, d)

Methods

observer :: (a, b, c, d) -> Parent -> (a, b, c, d)

constrain :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

(Observable a, Observable b, Observable c, Observable d, Observable e) => Observable (a, b, c, d, e)

Methods

observer :: (a, b, c, d, e) -> Parent -> (a, b, c, d, e)

constrain :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

class GObservable f where

Minimal complete definition

gdmobserver, gdmObserveArgs, gdmShallowShow

Methods

gdmobserver :: f a -> Parent -> f a

gdmObserveArgs :: f a -> ObserverM (f a)

gdmShallowShow :: f a -> Text

Instances

GObservable (U1 *)

Methods

gdmobserver :: U1 * a -> Parent -> U1 * a

gdmObserveArgs :: U1 * a -> ObserverM (U1 * a)

gdmShallowShow :: U1 * a -> Text

Observable a => GObservable (K1 * i a)

Methods

gdmobserver :: K1 * i a a -> Parent -> K1 * i a a

gdmObserveArgs :: K1 * i a a -> ObserverM (K1 * i a a)

gdmShallowShow :: K1 * i a a -> Text

(GObservable a, GObservable b) => GObservable ((:+:) * a b)

Methods

gdmobserver :: (* :+: a) b a -> Parent -> (* :+: a) b a

gdmObserveArgs :: (* :+: a) b a -> ObserverM ((* :+: a) b a)

gdmShallowShow :: (* :+: a) b a -> Text

(GObservable a, GObservable b) => GObservable ((:*:) * a b)

Methods

gdmobserver :: (* :*: a) b a -> Parent -> (* :*: a) b a

gdmObserveArgs :: (* :*: a) b a -> ObserverM ((* :*: a) b a)

gdmShallowShow :: (* :*: a) b a -> Text

(FieldLimit (S (S (S (S (S (S Z)))))) a, GObservable a) => GObservable (M1 * D d a)

Methods

gdmobserver :: M1 * D d a a -> Parent -> M1 * D d a a

gdmObserveArgs :: M1 * D d a a -> ObserverM (M1 * D d a a)

gdmShallowShow :: M1 * D d a a -> Text

(GObservable a, Constructor Meta c) => GObservable (M1 * C c a)

Methods

gdmobserver :: M1 * C c a a -> Parent -> M1 * C c a a

gdmObserveArgs :: M1 * C c a a -> ObserverM (M1 * C c a a)

gdmShallowShow :: M1 * C c a a -> Text

(GObservable a, Selector Meta s) => GObservable (M1 * S s a)

Methods

gdmobserver :: M1 * S s a a -> Parent -> M1 * S s a a

gdmObserveArgs :: M1 * S s a a -> ObserverM (M1 * S s a a)

gdmShallowShow :: M1 * S s a a -> Text

constrainBase :: (Show a, Eq a) => a -> a -> a

class GConstrain f where

Minimal complete definition

gconstrain

Methods

gconstrain :: f a -> f a -> f a

Instances

GConstrain (U1 *)

Methods

gconstrain :: U1 * a -> U1 * a -> U1 * a

Observable a => GConstrain (K1 * i a)

Methods

gconstrain :: K1 * i a a -> K1 * i a a -> K1 * i a a

(GConstrain a, GConstrain b) => GConstrain ((:+:) * a b)

Methods

gconstrain :: (* :+: a) b a -> (* :+: a) b a -> (* :+: a) b a

(GConstrain a, GConstrain b) => GConstrain ((:*:) * a b)

Methods

gconstrain :: (* :*: a) b a -> (* :*: a) b a -> (* :*: a) b a

GConstrain a => GConstrain (M1 * D d a)

Methods

gconstrain :: M1 * D d a a -> M1 * D d a a -> M1 * D d a a

(GConstrain a, Constructor Meta c) => GConstrain (M1 * C c a)

Methods

gconstrain :: M1 * C c a a -> M1 * C c a a -> M1 * C c a a

(GConstrain a, Selector Meta s) => GConstrain (M1 * S s a)

Methods

gconstrain :: M1 * S s a a -> M1 * S s a a -> M1 * S s a a

gdmFunObserver :: (Observable a, Observable b) => Parent -> (a -> b) -> a -> b

observeBase :: Show a => a -> Parent -> a

observeOpaque :: Text -> a -> Parent -> a

newtype ObserverM a

Constructors

ObserverM

Fields

• runMO :: Int -> Word8 -> (a, Word8)

Instances

Monad ObserverM

Methods

(>>=) :: ObserverM a -> (a -> ObserverM b) -> ObserverM b

(>>) :: ObserverM a -> ObserverM b -> ObserverM b

return :: a -> ObserverM a

fail :: String -> ObserverM a

Functor ObserverM

Methods

fmap :: (a -> b) -> ObserverM a -> ObserverM b

(<$) :: a -> ObserverM b -> ObserverM a

Applicative ObserverM

Methods

pure :: a -> ObserverM a

(<*>) :: ObserverM (a -> b) -> ObserverM a -> ObserverM b

liftA2 :: (a -> b -> c) -> ObserverM a -> ObserverM b -> ObserverM c

(*>) :: ObserverM a -> ObserverM b -> ObserverM b

(<*) :: ObserverM a -> ObserverM b -> ObserverM a

thunk :: (a -> Parent -> a) -> a -> ObserverM a

gthunk :: GObservable f => f a -> ObserverM (f a)

(<<) :: Observable a => ObserverM (a -> b) -> a -> ObserverM b infixl 9

gdMapM :: Monad m => (a -> m a) -> m (a -> b) -> a -> m b

gobserve :: (a -> Parent -> a) -> Text -> a -> (a, Int)

observe observes data structures in flight.

An example of use is map (+1) . observe "intermeduate" . map (+2)

In this example, we observe the value that flows from the producer map (+2) to the consumer map (+1).

observe can also observe functions as well a structural values.

observe :: Observable a => Text -> a -> a

Functions which you suspect of misbehaving are annotated with observe and should have a cost centre set. The name of the function, the label of the cost centre and the label given to observe need to be the same.

Consider the following function:

triple x = x + x

This function is annotated as follows:

triple y = (observe "triple" (\x -> {# SCC "triple" #}  x + x)) y

To produce computation statements like:

triple 3 = 6

To observe a value its type needs to be of class Observable. We provided instances for many types already. If you have defined your own type, and want to observe a function that takes a value of this type as argument or returns a value of this type, an Observable instance can be derived as follows:

  data MyType = MyNumber Int | MyName String deriving Generic

  instance Observable MyType

observer_ :: (a -> Parent -> a) -> a -> Parent -> a

gdmobserver_ :: GObservable f => f a -> Parent -> f a

unsafeWithUniq :: (Int -> IO a) -> a

generateContext :: (a -> Parent -> a) -> Text -> a -> (a, Int)

send :: Text -> ObserverM a -> Parent -> a

sendEnterPacket :: (a -> Parent -> a) -> a -> Parent -> a

gsendEnterPacket :: GObservable f => f a -> Parent -> f a

evaluate :: a -> IO a

sendObserveFnPacket :: ObserverM a -> Parent -> a

ourCatchAllIO :: IO a -> (SomeException -> IO a) -> IO a

handleExc :: Parent -> SomeException -> IO a