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.

Reply via email to