I was trying to use the `Data.Constraint`

package to do some constraint programming but I am hitting a wall. Is there an implementation for `compHasLens`

in the following example?

```
import qualified Control.Category as C
import Data.Constraint
-- | A very simple lens to handle the infinite type problem.
data a :>: b =
Lens'
{ getL :: a -> b,modL :: (b -> b) -> a -> a }
instance C.Category (:>:) where
a . b = Lens' { getL = getL a . getL b,modL = modL b . modL a }
id = Lens' { getL = id,modL = id }
class HasLens a b where
defLens :: a :>: b
composeHasLens :: Dict (HasLens a b) -> Dict (HasLens b c) -> Dict (HasLens a c)
composeHasLens Dict Dict = error "Is there an implementation for this?"
```

The semantics might be a bit strange:

```
instance HasLens A B
instance HasLens B C
instance HasLens A C
lAB :: Dict (HasLens A B)
lAB = Dict
lBC :: Dict (HasLens B C)
lBC = Dict
-- | The one from the instance
lens :: A :>: C
lens = defLens
-- | The composition.
lens' :: A :>: C
lens' = case composeHasLens lAB lBC of
Dict -> defLens
```

But if I understand correctly GHC accepts constraints as arguments it seems like it should possible in principle at least?