Immutability and other attributes, please review

[Roman D. Boiko]

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.