Hello,

This may be silly. I would like to understand whether this is a viable design pattern in Julia. I want to define a new type `GraphPoint <: AbstractArray`

that joins together a point and a function value at that point (like a cache, to avoid re-evaluating a function if you will). I would do it pretty much like this:

```
immutable GraphPoint <: AbstractArray
x::AbstractArray
fx::Real
end
```

The idea is to have a function that uses this information to avoid computations, as in

```
function myFun(point::GraphPoint)
return x.fx
end
function myFun(x::AbstractArray)
# compute something with x
return something
end
```

`GraphPoint`

objects are created somewhere. It’s not relevant by whom or when. The point is, I would like to naturally extend all *other* functions defined on `AbstractArray`

to my new type `GraphPoint`

, by simply redirecting them to the `x`

field of the structure. Say, I would like to do matrix-vector products with `A::AbstractMatrix`

and an object `point::GraphPoint`

by doing `A*point.x`

.

Is there a way to naturally extend *all* functions defined on `AbstractArrat`

to my new type `GraphPoint`

in this sense?

Thank you.