Debug.Hood.Observe

The main Hood API

observe :: Observable a => String -> a -> a

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.

newtype Observer

Constructors

O (forall a. Observable a => String -> a -> a)

type Observing a = a -> a

class Observable a where

The Observable class defines how data types are observed. For Generic data types, this can be derived. For example:

  data MyType = MyConstr Int String deriving Generic
  instance Observable MyType

Methods

observer :: a -> Parent -> a

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

observers :: String -> (Observer -> a) -> a

Instances

Observable Bool

Methods

observer :: Bool -> Parent -> Bool

observers :: String -> (Observer -> Bool) -> Bool

Observable Char

Methods

observer :: Char -> Parent -> Char

observers :: String -> (Observer -> Char) -> Char

Observable Double

Methods

observer :: Double -> Parent -> Double

observers :: String -> (Observer -> Double) -> Double

Observable Float

Methods

observer :: Float -> Parent -> Float

observers :: String -> (Observer -> Float) -> Float

Observable Int

Methods

observer :: Int -> Parent -> Int

observers :: String -> (Observer -> Int) -> Int

Observable Integer

Methods

observer :: Integer -> Parent -> Integer

observers :: String -> (Observer -> Integer) -> Integer

Observable ()

Methods

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

observers :: String -> (Observer -> ()) -> ()

Observable Dynamic

Methods

observer :: Dynamic -> Parent -> Dynamic

observers :: String -> (Observer -> Dynamic) -> Dynamic

Observable SomeException

Methods

observer :: SomeException -> Parent -> SomeException

observers :: String -> (Observer -> SomeException) -> SomeException

Observable a => Observable [a]

Methods

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

observers :: String -> (Observer -> [a]) -> [a]

Observable a => Observable (Maybe a)

Methods

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

observers :: String -> (Observer -> Maybe a) -> Maybe a

Observable a => Observable (IO a)

Methods

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

observers :: String -> (Observer -> IO a) -> IO a

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

Methods

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

observers :: String -> (Observer -> a -> b) -> a -> b

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

Methods

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

observers :: String -> (Observer -> Either a b) -> Either a b

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

Methods

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

observers :: String -> (Observer -> (a, b)) -> (a, b)

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

Methods

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

observers :: String -> (Observer -> 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)

observers :: String -> (Observer -> (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)

observers :: String -> (Observer -> (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)

observers :: String -> (Observer -> (a, b, c, d, e)) -> (a, b, c, d, e)

runO :: IO a -> IO ()

The main entry point; run some IO code, and debug inside it.

An example of using this debugger is

runO (print [ observe "+1" (+1) x | x <- observe "xs" [1..3]])

[2,3,4]
 -- +1
  {  1  -> 2
  }
 -- +1
  {  2  -> 3
  }
 -- +1
  {  3  -> 4
  }
 -- xs
  1 : 2 : 3 : []

Which says, the return is [2,3,4], there were 3 calls to +1 (showing arguments and results), and xs, which was the list 1 : 2 : 3 : [].

printO :: Show a => a -> IO ()

print a value, with debugging

putStrO :: String -> IO ()

print a string, with debugging

For advanced users, that want to render their own datatypes.

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

thunk :: Observable a => a -> ObserverM a

send :: String -> ObserverM a -> Parent -> a

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

observeOpaque :: String -> a -> Parent -> a

For users that want to write there own render drivers.

debugO :: IO a -> IO [CDS]

run some code and return the CDS structure (for when you want to write your own debugger).

data CDS

Constructors

CDSNamed String CDSSet

CDSCons Int String [CDSSet]

CDSFun Int CDSSet CDSSet

CDSEntered Int

Instances

Eq CDS

Methods

(==) :: CDS -> CDS -> Bool

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

Ord CDS

Methods

compare :: CDS -> CDS -> Ordering

(<) :: CDS -> CDS -> Bool

(<=) :: CDS -> CDS -> Bool

(>) :: CDS -> CDS -> Bool

(>=) :: CDS -> CDS -> Bool

max :: CDS -> CDS -> CDS

min :: CDS -> CDS -> CDS

Show CDS

Methods

showsPrec :: Int -> CDS -> ShowS

show :: CDS -> String

showList :: [CDS] -> ShowS

type CDSSet = [CDS]