• "Ben Hinkle" <ben.hinkle gmail.com> Mar 23 2005
• "Ben Hinkle" <ben.hinkle gmail.com> Mar 26 2005
• bug d.com Mar 26 2005
• "Ben Hinkle" <ben.hinkle gmail.com> Mar 27 2005
• bug d.com Mar 27 2005
• "Ben Hinkle" <ben.hinkle gmail.com> Mar 27 2005

I've updated MinTL to work with dmd-119, though there could be a problem 
with MultiAA, which is an alias for Value[][Key]. The unittest fails when I 
try to concatenate onto the end of the Value[] array and set that back into 
the AA. I don't know what is going on with that so I'll have to check it out 
when I get more time.

I also added some functions to ArrayList to allow it to be used like an 
array with capacity. I added the new read/write property capacity and added 
a setter for length. For those who don't know MinTL an ArrayList is an array 
with efficient insert/delete from the head and tail. Basically it is a 
circular array. By keeping the head at 0 it becomes an array with capacity. 
I decided the tradeoff of reusing ArrayList is better than inventing a whole 
new type for tracking capacity.

Available from the usual place http://home.comcast.net/~benhinkle/mintl/ 

"Ben Hinkle" <ben.hinkle gmail.com> wrote in message 
news:d1tdnp$109m$1 digitaldaemon.com...
 I've updated MinTL to work with dmd-119, though there could be a problem 
 with MultiAA, which is an alias for Value[][Key]. The unittest fails when 
 I try to concatenate onto the end of the Value[] array and set that back 
 into the AA. I don't know what is going on with that so I'll have to check 
 it out when I get more time.


posted bug report with AAs indexed by double.

 I also added some functions to ArrayList to allow it to be used like an 
 array with capacity. I added the new read/write property capacity and 
 added a setter for length. For those who don't know MinTL an ArrayList is 
 an array with efficient insert/delete from the head and tail. Basically it 
 is a circular array. By keeping the head at 0 it becomes an array with 
 capacity. I decided the tradeoff of reusing ArrayList is better than 
 inventing a whole new type for tracking capacity.


After mulling over some MinTL behaviors that had grown to bug me, I've made 
some changes that break backwards compatibility. They are
1) removed seq and util modules and moved the contents elsewhere. Results in 
fewer modules needed to do basic stuff
2) made ArrayList resize automatically instead of throwing an error when the 
backing array is full
3) switched all (integer) indexing and length to use size_t instead of ints 
and uints.

I've update the zip file with these changes. 

Should the following two commonly used methods be added into mintl/list.d ?

Value first() { return head.data; }
Value last()  { return tail.data; }

<bug d.com> wrote in message news:d25bth$174i$1 digitaldaemon.com...
 Should the following two commonly used methods be added into mintl/list.d 
 ?

 Value first() { return head.data; }
 Value last()  { return tail.data; }


Maybe, but the same thing is x[0] and x[x.length-1], just like arrays. 
Typing ".last" is shorter than "[x.length-1]" but that is the only advantage 
I can see and that wasn't enough of an advantage to me to add them. But I'll 
think about it. 

In article <d26a9f$26cr$1 digitaldaemon.com>, Ben Hinkle says...
<bug d.com> wrote in message news:d25bth$174i$1 digitaldaemon.com...
 Should the following two commonly used methods be added into mintl/list.d 
 ?

 Value first() { return head.data; }
 Value last()  { return tail.data; }


Maybe, but the same thing is x[0] and x[x.length-1], just like arrays. 
Typing ".last" is shorter than "[x.length-1]" but that is the only advantage 
I can see and that wasn't enough of an advantage to me to add them. But I'll 
think about it. 


I think in the implementation, the actual pointer to head/tail is cached, so
x[0] take same time as first(), but x[x.length-1] will take O(N) instead of
O(1)!

<bug d.com> wrote in message news:d26v7a$2rdm$1 digitaldaemon.com...
 In article <d26a9f$26cr$1 digitaldaemon.com>, Ben Hinkle says...
<bug d.com> wrote in message news:d25bth$174i$1 digitaldaemon.com...
 Should the following two commonly used methods be added into 
 mintl/list.d
 ?

 Value first() { return head.data; }
 Value last()  { return tail.data; }


Maybe, but the same thing is x[0] and x[x.length-1], just like arrays.
Typing ".last" is shorter than "[x.length-1]" but that is the only 
advantage
I can see and that wasn't enough of an advantage to me to add them. But 
I'll
think about it.


 I think in the implementation, the actual pointer to head/tail is cached, 
 so
 x[0] take same time as first(), but x[x.length-1] will take O(N) instead 
 of
 O(1)!


For doubly-linked lists the length is cached, too. So to look up x[n] it 
starts from the head if n < length/2 and the tail if n > length/2. For 
singly-linked lists the length isn't cached and so there is the property 
tailList that returns a single-item slice for the tail item.