• "Ben Hinkle" <bhinkle mathworks.com> May 02 2005
• John Demme <me teqdruid.com> May 02 2005
• "Ben Hinkle" <ben.hinkle gmail.com> May 02 2005

While looking at the classes and interfaces I started pondering the SortedAA 
and LinkedAA structs and I'd like to make some non-backwards compatible 
changes (in case anyone cares give a holler).

1) change key slicing to exclude the upper endpoint. That way one can write 
nice slicing expressions like dictionary["a" .. "b"] for all the words that 
start with "a".

2) rename fromHead and fromTail to begin and end to be closer to C++-style 
iterators. Slices involving subarrays will be inclusive (as before) so that 
one can write x[x.begin .. x.end] and have it slice the entire thing. I'll 
add mixed-type slicing so that x["a" .. x.end] works, too.

3) add from(key) and to(key) to get one-item slices. from(key) is the 
smallest item greater than or equal to key and to(key) is the largest item 
less than key. So x["a" .. "b"] is equivalent to x[x.from("a") .. x.to("b")]

4) rename Seq to Sequence, SeqWithKeys to IndexedSequence

5) rip out all the mapSeq, findSeq and catSeq. 

On Mon, 2005-05-02 at 17:02 -0400, Ben Hinkle wrote:
 While looking at the classes and interfaces I started pondering the SortedAA 
 and LinkedAA structs and I'd like to make some non-backwards compatible 
 changes (in case anyone cares give a holler).



 
 1) change key slicing to exclude the upper endpoint. That way one can write 
 nice slicing expressions like dictionary["a" .. "b"] for all the words that 
 start with "a".


Previously (as I understand it) it would have been:
dict["a".."m"]
dict["n".."z"]
But with these changes, "a"'s and "z"'s wouldn't be included.

 
 2) rename fromHead and fromTail to begin and end to be closer to C++-style 
 iterators. Slices involving subarrays will be inclusive (as before) so that 
 one can write x[x.begin .. x.end] and have it slice the entire thing. I'll 
 add mixed-type slicing so that x["a" .. x.end] works, too.
 
 3) add from(key) and to(key) to get one-item slices. from(key) is the 
 smallest item greater than or equal to key and to(key) is the largest item 
 less than key. So x["a" .. "b"] is equivalent to x[x.from("a") .. x.to("b")]



 
 4) rename Seq to Sequence, SeqWithKeys to IndexedSequence
 
 5) rip out all the mapSeq, findSeq and catSeq. 
 
 


John Demme

 1) change key slicing to exclude the upper endpoint. That way one can 
 write
 nice slicing expressions like dictionary["a" .. "b"] for all the words 
 that
 start with "a".


 Previously (as I understand it) it would have been:
 dict["a".."m"]
 dict["n".."z"]
 But with these changes, "a"'s and "z"'s wouldn't be included.


The expression dict["a".."m"] wouldn't include keys like "mud" but it would 
include the key "m". Similarly dict["n".."z"] wouldn't include "zed". So it 
would only have split the table if it didn't include multi-letter words. 
With the new behavior dict["a".."m"] wouldn't include "m". To split dict in 
two one could write
dict[dict.begin() .. "m"]
dict["m" .. dict.end()];

 3) add from(key) and to(key) to get one-item slices. from(key) is the
 smallest item greater than or equal to key and to(key) is the largest 
 item
 less than key. So x["a" .. "b"] is equivalent to x[x.from("a") .. 
 x.to("b")]




dict[dict.begin() .. dict.to("m")]
dict[dict.from("m") .. dict.end()];
but that's not the main reason for from/to since it's the same as above. The 
use for from/to will be for getting "iterators" that one can manipulate 
efficiently.