[julia-users] Question about circular-references / self-referencing in types, in terms of performance

[Christopher Alexander]

Hello all, 

I have a question about the usage of circular references in types.  In a 
project I am working on, I am running into several situations where this 
type of design appears to be the best issue.  For example, let's say I have 
this (this is a massive simplification but illustrates my point):

```
abstract TermStructure

type Bond
rate::Float64
ts::TermStructure
mat_date::Date
end

function Bond(rate::Float64, mat_date::Date)
   ts = NullTermStructure()
   return Bond(rate, ts, mat_date)
end

type NullTermStructure <: TermStructure end

type PiecewiseYieldCurve <: TermStructure
settlement::Date
bonds::Vector{Bond}
end

function PiecewiseYieldCurve(settlement::Date, sched::Schedule, 
rate::Float64)
  bonds = Vector{Bond}(length(sched))
  for (i, d) in enumerate(sched)
     new_bond = Bond(rate, d)
     bonds[i] = new_bond
  end
  
  pyc = PiecewiseYieldCurve(settlement, bonds)
  for b in bonds
    b.ts = pyc
  end
  
  return pyc
end
```

Firstly, I guess, is this the best implementation?  There are situations 
where I need the bonds of the PiecewiseYieldCurve to be aware of the 
TermStructure to which they are connected.  Secondly, do I take a 
performance hit from this?  The PiecewiseYieldCurve instance will have 
parts of it updated as I run some of my pricer methods (not shown).

Thanks!

Chris