# Function decoration pattern

## Motivation

You want to add extra properties to a function type, but you don't want the users to have to tediously project out the decorated type when they don't care about the decorations.

This can be generalized to arbitrary values instead of just functions.

## Approach

Use type classes to drive the projection by the how the value is used.

```
{-# LANGUAGE MultiParamTypeClasses, Rank2Types, FlexibleContexts, FlexibleInstances #-}
-- This implementation is somewhat general, but it is not intended
-- that all examples can be cast in exactly this way.
data Decorate d a b = Decorated (a -> b) (d a b)
class Decorated d a b dec where
decorated :: (a -> b) -> d a b -> dec a b
-- The above is a Scott-encoding of the below which is equivalent.
-- The Scott-encoded version is often more convenient and efficient.`
-- decorated :: Decorate d a b -> dec a b
instance Decorated d a b (Decorate d) where
decorated = Decorated
instance Decorated d a b (->) where
decorated f _ = f
type IsDecorated d a b = forall dec. Decorated d a b dec => dec a b
-- Not a very realistic example.
type UnitTested = Decorate (,)
type IsUnitTested a b = IsDecorated (,) a b
makeTested :: (a -> b) -> a -> b -> IsUnitTested a b
makeTested f a b = decorated f (a, b)
test :: Eq b => UnitTested a b -> Bool
test (Decorated f (a, b)) = f a == b
testedSquare :: Num a => IsUnitTested a a
testedSquare = makeTested (\x -> x * x) 3 9
main = do
print (map testedSquare [1,2,3])
putStrLn (if test testedSquare then "Passed" else "Failed")
```

## Examples

The archetypical example is the type of isomorphisms e.g. as used in the lens library.

An isomorphism is a function equipped with an inverse. Traditionally, this would be represented by a data type such as

```
data Iso a b = Iso { _to :: a -> b, _from :: b -> a }
```

This would require explicitly projecting out the forward function using `_to`

, which makes the code noisy and tedious to write. This can be eliminated by writing:

```
class Isomorphic a b iso where
iso :: (a -> b) -> (b -> a) -> iso a b
instance Isomorphic a b Iso where
iso = Iso
instance Isomorphic a b (->) where
iso to _ = to
type IsIsomorphic a b = forall iso. Isomorphic a b iso => iso a b
```

Now if we produce values of type `IsIsomorphic a b`

rather than `Iso a b`

we can just treat them like functions. Note that this should be pursued aggresively. For example, traditionally we'd have two functions `from :: Iso a b -> b -> a`

and `op :: Iso a b -> Iso b a`

but by using `from :: Iso a b -> IsIsomorphic b a`

we get both at once. This can be enforced by making `Iso`

abstract.

Another example would be allowing arrays to used as functions but still being able to get at the bounds when you needed them.

## Notes

This is closely related to the Yoneda lemma and representability. Essentially we are identifying the value `x`

with `($ x)`

. The instances of the type classes just choose how we want to observe the `x`

via `($ x) observation`

. `makeTested`

makes this pretty explicit especially if the direct (rather than Scott-encoded) representation is used.

This can be viewed as a special case of the finally, tagless encoding.