On Friday, 15 June 2012 at 08:31:08 UTC, dennis luehring wrote:
Am 15.06.2012 08:25, schrieb Jacob Carlborg:
On 2012-06-14 17:32, Roman D. Boiko wrote:
I agree, just looking how to accomplish my goals. I decided
to get rid
of casting, and will store everything on heap. I don't know
how to put a
variable of type float to the heap, and thought that it would
be nice to
allow the user to pass anything inside, but copy when that is
not an
l-value.
Do you really need to put a float on the heap? Just pass it
around as a
value type, it's not like it's a big struct.
i think he needs to - else he encapsulate the float into an
struct which is then also on the heap
(ast/whatever)
nodex -> float
nodey -> string
nodez -> int
nodew -> double
etc.
in this example a node can contain from n types values - how
would you solve that? or better what is the smallest(maybe
fastest) representation
there need to be a queryable tree in the end - so there is a
need to hold the values - yes he can copy by value - but into
whom?
in the end it will be an variant-like type (with members for
each type) on heap - whichs is not that good because that will
cost much more mem
or something like an class FloatValue -> NodeValue -> Value
oop-hierachy whichs also will get onto the heap
i would try to use something like an base-types pool for all
the small
float,double,int,string etc values... and pointer to this pool
- or just use the heap :)
Well, my case is actually more complicated:
https://github.com/roman-d-boiko/dct/blob/master/fe/syntax.d
Node is a struct that holds:
* instances of Syntax **classes** (these are immutable AST nodes
without identity; please don't confuse Node which is a struct and
node which is a general term for part of a tree)
* information about their positions of Syntax nodes in source
code,
* and links to parent Node instances.
This way we have the ability to reuse most of Syntax nodes during
incremental source code edits, only regenerating lightweight Node
structs that introduce unique identity to those Syntax nodes.
As I already mentioned, Syntax nodes are immutable classes. They
have to be polymorphic (thus classes), but they are value types
without identity. They form immutable trees where each parent
knows its children. They don't know their positions in source
code, only their widths. Node structs know their parent Node
structs and on demand can quickly compute their children as
Node[] using information about children from their Syntax field.