We need the Template Haskell extension to splice in the generated
Observable instances. We need the Rank2Types extionsion to be able
to specify parametrized types such as 'Tree a' with forall a.

> {-# LANGUAGE TemplateHaskell, Rank2Types #-}

We need the Derive Generic extention to derive the Generic representation
used for the non spliced in observe (see the Cache data type).

> {-# LANGUAGE DeriveGeneric #-}

> import Debug.Hoed.Pure

We use the Stern–Brocot tree as example. The Stern-Brocot tree is a
binary tree containing all rational numbers. The tree is infinit and
is therefore a nice example to demonstrate how laziness is handled.

To store the tree we use the following datatype, note that because
our definition is endless we do not actually use Leaf.

> data Tree a = Node a (Tree a) (Tree a) deriving Generic

The values in the tree will be fractional numbers:

> data Frac = Frac Int Int deriving (Show,Generic)

We use cache to store what the last seen up and to the left, and up and
to the right values are.

> data Cache = Cache { v :: Frac
>                    , l :: Frac
>                    , r :: Frac
>                    } deriving Generic

Make Cache and Frac Observable for gdmobserve.

> instance Observable Cache
> instance Observable Frac

The mediant is used to find which new number to insert between 2 exisiting
numbers.

> mediant :: Frac -> Frac -> Frac
> mediant (Frac p1 q1) (Frac p2 q2) = Frac (p1+p2) (q1+q2)

Definition of the sternbrocot tree:

> sternbrocot :: Tree Frac
> sternbrocot = sternbrocot' mediant
>
> sternbrocot' :: (Frac -> Frac -> Frac) -> Tree Frac
> sternbrocot' m = w_sternbrocot m Cache{v=(Frac 1 1), l=(Frac 0 1), r=(Frac 1 0)}
>
> w_sternbrocot :: (Frac -> Frac -> Frac) -> Cache -> Tree Frac
> w_sternbrocot m cache
>  = let Cache{v=v, l=l, r=r} = cache -- observe "cache" cache
>    in  Node v (w_sternbrocot m Cache{v=m v l, l=l, r=v})
>               (w_sternbrocot m Cache{v=m v r, l=v, r=r})

The Stern-Brocot tree is sorted: all values in the left subtree are
smaller than the value of the current node and all values in the right subtree
are greater than the value in the current node.
This can be used to approximate a Float value by doing a binary search where
each next rational number is a better aproximation of the Float.

> toFrac :: Float -> Tree Frac -> Frac
> toFrac val (Node frac@(Frac p q) left right)
>  = case compare ((fromIntegral p) / (fromIntegral q)) val of
>       LT -> toFrac val right 
>       GT -> toFrac val left
>       EQ -> frac

We use template-haskell to observe Tree and the values stored in Tree.

> $(observedTypes "sternbrocot1" [ [t| forall a . Observable a => Tree a |]
>                                , [t| Frac |]
>                                ]
>  )
>
> frac1 = toFrac 0.6 ($(observeTempl "sternbrocot1") sternbrocot)

Or to only observe which part of the tree is walked while ignoring
the values stored in the tree.

> $(observedTypes "sternbrocot2" [ [t| forall a . Tree a |]])
>
> frac2 = toFrac 0.6 ($(observeTempl "sternbrocot2") sternbrocot)

> instance (Observable a) => Observable (Tree a)
>
> frac3 = toFrac 0.6 (observe "sternbrocot3" sternbrocot)

Example main function:

> main = runO $ do -- print frac1
>                  -- print frac2
>                  print frac3