Hoed-0.5.1: Lightweight algorithmic debugging.

Safe HaskellNone
LanguageHaskell2010

Debug.Hoed.Observe

Synopsis

Documentation

type UID = Int #

data Event #

Constructors

Event 

Fields

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 # 
MVector MVector Event # 
type Rep Event # 
type Rep Event = D1 * (MetaData "Event" "Debug.Hoed.Observe" "Hoed-0.5.1-HXLXOUi9BI77FVyFM1g2uA" 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 MVector s Event # 

data EventWithId #

Constructors

EventWithId 

Fields

data Change #

Constructors

Observe !Text 
Cons !Word8 !Text 
ConsChar !Char 
Enter 
Fun 

Instances

Eq Change # 

Methods

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

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

Show Change # 
Generic Change # 

Associated Types

type Rep Change :: * -> * #

Methods

from :: Change -> Rep Change x #

to :: Rep Change x -> Change #

Unbox Change # 
Vector Vector Change # 
MVector MVector Change # 
type Rep Change # 
data Vector Change # 
data MVector s Change # 

data Parent #

Constructors

Parent 

Instances

Eq Parent # 

Methods

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

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

Show Parent # 
Generic Parent # 

Associated Types

type Rep Parent :: * -> * #

Methods

from :: Parent -> Rep Parent x #

to :: Rep Parent x -> Parent #

Unbox Parent # 
Vector Vector Parent # 
MVector MVector Parent # 
type Rep Parent # 
type Rep Parent = D1 * (MetaData "Parent" "Debug.Hoed.Observe" "Hoed-0.5.1-HXLXOUi9BI77FVyFM1g2uA" 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 MVector s Parent # 

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

initUniq :: IO () #

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 # 
Observable Float # 
Observable Int # 

Methods

observer :: Int -> Parent -> Int #

constrain :: Int -> Int -> Int #

Observable Integer # 
Observable () # 

Methods

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

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

Observable Dynamic # 
Observable 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

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 #

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