Hi,
In Julia, if you are not sure of an arguments type beforehand, you can use
'Any', or if you know it comes under an abstract type, you can use that.
I've been working on a type for BioJulia which allows for representation of
a node of a phylogenetic tree that will allow annotation with biological
data in the form of other types from the packages from BioJulia:
@doc """
PhyExtension allows defining arbitrary metadata to annotate nodes.
This allows the PhyNode type to support any phylogenetic tree format
that includes annotations (e.g. PhyloXML, NeXML), and allows programmatic
extension of nodes with annotations.
""" ->
type PhyExtension{T}
value::T
end
@doc """
PhyNode represents a node in a phylogenetic tree.
A node can have:
- `name`
- `branchlength`
- one or more `extensions`
- a reference to its `parent` PhyNode
- reference to one or more `children`
""" ->
type PhyNode
name::String
branchlength::Float64
confidence::Float64
extensions::Vector{PhyExtension}
children::Vector{PhyNode}
parent::PhyNode
# Inner constructor goes here.
As you can see - PhyExtension is parametric so can be constructed to
contain any type.
I'm wondering, though is this the best that can be done, can I handle the
potential to hold any number of types with unknown variables any better -
if so, how?
Is specifying a Vector of PhyExtension, where a PhyExtenision is a type
that contains any other type really giving that much information to the
Julia system to work on efficiently?
My understanding is that PhyExtension is parametric so a version is
effectively defined for every possible {T} (including user defined
composite types they might come up with). But then I imagine that's not
much information when creating the Vector{PhyExtension} as an element could
be any of the many possible PhyExtensions - the compiler has to allow for
an array that can store any PhyExtension? Or is it that the array contains
references to PhyExtensions so actually the array is simple?
Thanks,
Ben.
