In article <1hqz8n1ubnxtt$.xm7d74d5jvd5$.dlg@40tude.net>, Derek Parnell says...
>
>On Mon, 2 May 2005 22:29:03 +0000 (UTC), B.G. wrote:
>
>> In article <d4ukpk$20s2$1@digitaldaemon.com>, Walter says...
>>>
>>>
>>>"B.G." <B.G._member@pathlink.com> wrote in message news:d4tb6a$pj0$1@digitaldaemon.com...
>>>> In article <d4r5it$19b5$1@digitaldaemon.com>, Walter says...
>>>> >
>>>> >
>>>> >"B.G." <B.G._member@pathlink.com> wrote in message news:d4r4pq$186g$1@digitaldaemon.com...
>>>> >> a[3 .. 20] = a[4 .. 21];  is prohibited,
>>>> >>
>>>> >> Slicing is a great idea leaving much space for optimizations done by
>>>> >compiler,
>>>> >> but the above situation is frequent enought, so is there any way to do
>>>it
>>>> >other
>>>> >> than a loop?
>>>> >
>>>> >You can use C's memmove().
>>>>
>>>> Do you mean casting array ref to a pointer and give it to memmove?
>>>
>>>Yes.
>>>
>>>> Is it safe to move object references this way?
>>>> There are some posts about moveable memory in future gc implementations,
>>>etc,
>>>> that's actually the reason for my concerns with this issue.
>>>
>>>It's safe if the implementation of memmove() will move pointer sized chunks at a time. DMC's will, but there's no guarantee others will.
>>>
>> I bag a pardon, what's DMC?
>> 
>> thanx.
>
>DMC == Digital Mars C++ Compiler.
>
>  http://www.digitalmars.com

Oops! Sorry, Walter ;-))))

The forum's most stupid question since ages, probably. Well, digitalmars means only D to me...

Seriously - OK, so memmove is not entirely 'nice' solution...
I just thought, it would be NOT BAD, to have a single approved cross-platform
function for that purpose, with correct implementation everywhere.

IMHO it would be more natural to have it in the language core
(it's in fact just a special case of slicing, at least from the programmer's
point of view), I just don't have an idea how to plug it into the language
in an elegant way.

Maybe as a further array property? something like

arr.overlap(srcIndex, destIndex, length)

or whatever...









>
>-- 
>Derek
>Melbourne, Australia
>3/05/2005 9:21:11 AM

In article <d4r6r5$1ane$1@digitaldaemon.com>, Andrew Fedoniouk says...
>
>Instead of
>
>a[3 .. 20] = a[4 .. 21];
>a[3] = something;
>
>you may use just
>
>a.ins( 3, something );
>
>if you will include following somewhere:
..
>

Andrew, thanks for being kind enough to share your xarrayt.d code back in April (of which, I've just now gotten around to checking it out)...hope you don't mind, but I thought I'd post a minor bug fixed / addtional unittest to the code. I'm pretty sure others will find this code you've written as being very useful in their own projects!

# /+
#  ' Source    : XArrayT.d - D array extenders
#  '           : Template functions to handle array overlapping slices
#  ' Author    : Andrew Fedoniouk <news[at]terrainformatica[dot]com>
#  ' Created   : 28.Apr.05 with D v0.122
#  ' Modified  : 31.Jul.05 by David L. Davis
#  '           : Changed one '===' (which is now deprecated) with an 'is', plus
#  '           : added the missing *memmove() C function, then created a
#  '           : unittest for all the functions, and complied / tested
#  '           : under D v0.128.
#  '           :
#  ' Reference : http://www.digitalmars.com/drn-bin/wwwnews?digitalmars.D/22651
#  ' --------------------------------------------------------------------------
#  ' To complie for a unittest:
#  ' C:\dmd>bin\dmd xarrayt.d -debug=xarrayt -unittest
#  '
#  ' To compile a D program that uses xarrayt.d:
#  ' C:\dmd>bin\dmd MySource.d xarrayt.d
# +/
# module xarrayt;
#
# debug( xarrayt ) private import std.stdio;
#
# // Need to import the C memmove() function
# extern (C) void *memmove(void*, void*, uint);
#
# //|
# //| std D array extenders, these should be intrinsic
# //| ops for arrays in ideal D
# //|
# template xarrayT(T)
# {
#     // append array by one element
#     void push(inout T[] elements, T v)
#     {
#         int l = elements.length;
#         elements.length = l + 1;
#         elements[l] = v;
#     }
#
#     // del last element and return it
#     T pop(inout T[] elements)
#     {
#         int l = elements.length - 1;
#         assert(l >= 0);
#         T t = elements[l];
#         elements.length = l;
#         return t;
#     }
#
#     // insert element into array
#     void ins(inout T[] elements, uint at, T v)
#     {
#         uint l = elements.length;
#         if (at >= l) { elements ~= v; return; }
#         // for some reasons this does not compile:
#         // elements = elements[0..at] ~ v ~ elements[at..elements.length];
#         // so we use C way:
#         elements.length = l + 1;
#         memmove(&elements[at + 1],&elements[at],(l - at) * T.sizeof);
#         elements[at] = v;
#     }
#
#     // insert array into array
#     void insr(inout T[] elements, uint at, T[] va )
#     {
#         uint l = elements.length;
#         if (at >= l) { elements ~= va; return; }
#         elements.length = l + va.length;
#         memmove(&elements[at + va.length],&elements[at],(l - at) * T.sizeof);
#         elements[at..at + va.length] = va;
#     }
#
#     // del element and return it
#     T cut(inout T[] elements, uint at)
#     {
#         uint l = elements.length - 1;
#         if (at >= l) return pop(elements);
#         T t = elements[at];
#         memmove(&elements[at],&elements[at + 1],(l - at) * T.sizeof);
#         elements.length = l;
#         return t;
#     }
#
#     // del range and return its content
#     T[] cutr(inout T[] elements, uint at, uint end)
#     {
#           assert(at <= end);
#           if (at == end) return null;
#           T[] t = elements[at..end].dup;
#           uint l = elements.length - (end - at);
#           //if (at < l) { elements.length = at; return t; }
#           if (l - at <= 0) { elements.length = at; return t; }
#           memmove(&elements[at],&elements[end],(l - at) * T.sizeof);
#           elements.length = l;
#           return t;
#     }
#
#     // just del range
#     void del(inout T[] elements, int at, int end)
#     {
#           assert(at <= end);
#           if (at == end) return;
#           uint l = elements.length - (end - at);
#           if (at >= l) { elements.length = at; return; }
#           memmove(&elements[at],&elements[end],(l - at) * T.sizeof);
#           elements.length = l;
#     }
#
#     // find index of the element in array, -1 if not found
#     int index(in T[] elements,T t)
#     {
#        int i = elements.length - 1;
#        for (; i >= 0; --i)
#           if ( elements[i] is t ) break;
#        return i;
#     }
# }
#
# alias xarrayT!(byte).push     push;
# alias xarrayT!(ubyte).push    push;
# alias xarrayT!(short).push    push;
# alias xarrayT!(ushort).push   push;
# alias xarrayT!(int).push      push;
# alias xarrayT!(uint).push     push;
# alias xarrayT!(long).push     push;
# alias xarrayT!(ulong).push    push;
# alias xarrayT!(float).push    push;
# alias xarrayT!(double).push   push;
# alias xarrayT!(real).push     push;
# alias xarrayT!(ifloat).push   push;
# alias xarrayT!(idouble).push  push;
# alias xarrayT!(ireal).push    push;
# alias xarrayT!(cfloat).push   push;
# alias xarrayT!(cdouble).push  push;
# alias xarrayT!(creal).push    push;
# alias xarrayT!(char).push     push;
# alias xarrayT!(wchar).push    push;
# alias xarrayT!(dchar).push    push;
#
# alias xarrayT!(byte).pop     pop;
# alias xarrayT!(ubyte).pop    pop;
# alias xarrayT!(short).pop    pop;
# alias xarrayT!(ushort).pop   pop;
# alias xarrayT!(int).pop      pop;
# alias xarrayT!(uint).pop     pop;
# alias xarrayT!(long).pop     pop;
# alias xarrayT!(ulong).pop    pop;
# alias xarrayT!(float).pop    pop;
# alias xarrayT!(double).pop   pop;
# alias xarrayT!(real).pop     pop;
# alias xarrayT!(ifloat).pop   pop;
# alias xarrayT!(idouble).pop  pop;
# alias xarrayT!(ireal).pop    pop;
# alias xarrayT!(cfloat).pop   pop;
# alias xarrayT!(cdouble).pop  pop;
# alias xarrayT!(creal).pop    pop;
# alias xarrayT!(char).pop     pop;
# alias xarrayT!(wchar).pop    pop;
# alias xarrayT!(dchar).pop    pop;
#
# alias xarrayT!(byte).ins     ins;
# alias xarrayT!(ubyte).ins    ins;
# alias xarrayT!(short).ins    ins;
# alias xarrayT!(ushort).ins   ins;
# alias xarrayT!(int).ins      ins;
# alias xarrayT!(uint).ins     ins;
# alias xarrayT!(long).ins     ins;
# alias xarrayT!(ulong).ins    ins;
# alias xarrayT!(float).ins    ins;
# alias xarrayT!(double).ins   ins;
# alias xarrayT!(real).ins     ins;
# alias xarrayT!(ifloat).ins   ins;
# alias xarrayT!(idouble).ins  ins;
# alias xarrayT!(ireal).ins    ins;
# alias xarrayT!(cfloat).ins   ins;
# alias xarrayT!(cdouble).ins  ins;
# alias xarrayT!(creal).ins    ins;
# alias xarrayT!(char).ins     ins;
# alias xarrayT!(wchar).ins    ins;
# alias xarrayT!(dchar).ins    ins;
#
# alias xarrayT!(byte).insr     insr;
# alias xarrayT!(ubyte).insr    insr;
# alias xarrayT!(short).insr    insr;
# alias xarrayT!(ushort).insr   insr;
# alias xarrayT!(int).insr      insr;
# alias xarrayT!(uint).insr     insr;
# alias xarrayT!(long).insr     insr;
# alias xarrayT!(ulong).insr    insr;
# alias xarrayT!(float).insr    insr;
# alias xarrayT!(double).insr   insr;
# alias xarrayT!(real).insr     insr;
# alias xarrayT!(ifloat).insr   insr;
# alias xarrayT!(idouble).insr  insr;
# alias xarrayT!(ireal).insr    insr;
# alias xarrayT!(cfloat).insr   insr;
# alias xarrayT!(cdouble).insr  insr;
# alias xarrayT!(creal).insr    insr;
# alias xarrayT!(char).insr     insr;
# alias xarrayT!(wchar).insr    insr;
# alias xarrayT!(dchar).insr    insr;
#
# alias xarrayT!(byte).cut     cut;
# alias xarrayT!(ubyte).cut    cut;
# alias xarrayT!(short).cut    cut;
# alias xarrayT!(ushort).cut   cut;
# alias xarrayT!(int).cut      cut;
# alias xarrayT!(uint).cut     cut;
# alias xarrayT!(long).cut     cut;
# alias xarrayT!(ulong).cut    cut;
# alias xarrayT!(float).cut    cut;
# alias xarrayT!(double).cut   cut;
# alias xarrayT!(real).cut     cut;
# alias xarrayT!(ifloat).cut   cut;
# alias xarrayT!(idouble).cut  cut;
# alias xarrayT!(ireal).cut    cut;
# alias xarrayT!(cfloat).cut   cut;
# alias xarrayT!(cdouble).cut  cut;
# alias xarrayT!(creal).cut    cut;
# alias xarrayT!(char).cut     cut;
# alias xarrayT!(wchar).cut    cut;
# alias xarrayT!(dchar).cut    cut;
#
# alias xarrayT!(byte).cutr     cutr;
# alias xarrayT!(ubyte).cutr    cutr;
# alias xarrayT!(short).cutr    cutr;
# alias xarrayT!(ushort).cutr   cutr;
# alias xarrayT!(int).cutr      cutr;
# alias xarrayT!(uint).cutr     cutr;
# alias xarrayT!(long).cutr     cutr;
# alias xarrayT!(ulong).cutr    cutr;
# alias xarrayT!(float).cutr    cutr;
# alias xarrayT!(double).cutr   cutr;
# alias xarrayT!(real).cutr     cutr;
# alias xarrayT!(ifloat).cutr   cutr;
# alias xarrayT!(idouble).cutr  cutr;
# alias xarrayT!(ireal).cutr    cutr;
# alias xarrayT!(cfloat).cutr   cutr;
# alias xarrayT!(cdouble).cutr  cutr;
# alias xarrayT!(creal).cutr    cutr;
# alias xarrayT!(char).cutr     cutr;
# alias xarrayT!(wchar).cutr    cutr;
# alias xarrayT!(dchar).cutr    cutr;
#
# alias xarrayT!(byte).del     del;
# alias xarrayT!(ubyte).del    del;
# alias xarrayT!(short).del    del;
# alias xarrayT!(ushort).del   del;
# alias xarrayT!(int).del      del;
# alias xarrayT!(uint).del     del;
# alias xarrayT!(long).del     del;
# alias xarrayT!(ulong).del    del;
# alias xarrayT!(float).del    del;
# alias xarrayT!(double).del   del;
# alias xarrayT!(real).del     del;
# alias xarrayT!(ifloat).del   del;
# alias xarrayT!(idouble).del  del;
# alias xarrayT!(ireal).del    del;
# alias xarrayT!(cfloat).del   del;
# alias xarrayT!(cdouble).del  del;
# alias xarrayT!(creal).del    del;
# alias xarrayT!(char).del     del;
# alias xarrayT!(wchar).del    del;
# alias xarrayT!(dchar).del    del;
#
# alias xarrayT!(byte).index     index;
# alias xarrayT!(ubyte).index    index;
# alias xarrayT!(short).index    index;
# alias xarrayT!(ushort).index   index;
# alias xarrayT!(int).index      index;
# alias xarrayT!(uint).index     index;
# alias xarrayT!(long).index     index;
# alias xarrayT!(ulong).index    index;
# alias xarrayT!(float).index    index;
# alias xarrayT!(double).index   index;
# alias xarrayT!(real).index     index;
# alias xarrayT!(ifloat).index   index;
# alias xarrayT!(idouble).index  index;
# alias xarrayT!(ireal).index    index;
# alias xarrayT!(cfloat).index   index;
# alias xarrayT!(cdouble).index  index;
# alias xarrayT!(creal).index    index;
# alias xarrayT!(char).index     index;
# alias xarrayT!(wchar).index    index;
# alias xarrayT!(dchar).index    index;
#
# debug( xarrayt )
# {
# void displayLongArray(in long[] la)
# {
#     if (la.length > 1)
#         for ( int i = 0; i < la.length - 1; i++ )
#             writef("%d,", la[i]);
#
#     writefln("%d", la[la.length - 1]);
# }
#
# unittest
# {
#     writefln( "xarryt.unittest started." );
#     char[] s;
#     char[] st = "To Kill a Mocking Bird!";
#     char[] sub;
#     static long[] lsa = [ 10L, 20L, 21L, 25L, 30L, 40L, 45L, 50L ];
#     long[] la = lsa;
#     long[] la2;
#     int    i;
#
#     writefln("String (char[]) Array Test.");
#
#     // Appends one char at a time
#     for ( int i = 0; i < st.length; i++ )
#         s.push(st[i]);
#     writefln("push() s=\"%s\"", s);
#
#     // Removes the last character
#     for ( uint i = 0; i < st.length; i++ )
#         s.pop();
#     writefln("pop() s=\"%s\" (Looped thru to remove all the characters)", s);
#
#     // Inserts one character into a string
#     s = st;
#     s.ins(3, 'S');
#     writefln("ins() s=\"%s\"", s);
#
#     // Delete a character from [start] to [end] within a string
#     s.del(3,4);
#     writefln("del() s=\"%s\"", s);
#
#     // Replace a substring within the string
#     s.del(3,7);
#     s.insr(3, "Raise");
#     writefln("del() and insr() s=\"%s\"", s);
#
#     // Replace a substring within the string
#     s = st;
#     s.del(5,7);
#     s.insr(5, "ss");
#     writefln("del() and insr() s=\"%s\"", s);
#
#     // Cut a substring out of the string and append to it
#     sub = s.cutr(10, 23);
#     s ~= "puppy Dog!";
#     writefln("cutr() and '~=' s=\"%s\" sub=\"%s\"", s, sub);
#
#     // Get the position of a value
#     i = s.index('K');
#     writefln("index() 'K' found at position %d", i );
#
#     // Remove a value
#     s.cut(3);
#     writefln("cut() 'K' s=\"%s\"", s);
#
#     // Numerical test
#     //la = [ 10, 20, 21, 25, 30, 40, 45, 50 ];
#     writefln();
#     writefln("Numerical (long[]) Array Test.");
#     writef("la[]=");
#     displayLongArray(la);
#
#     // Add 60 and 70 to the long array
#     la.push(60);
#     la.push(70);
#     writef("push() la[]=");
#     displayLongArray(la);
#
#     // Removes the last value from the array
#     la.pop();
#     writef("pop() la[]=");
#     displayLongArray(la);
#
#     // Inserts a new value into the array
#     la.ins(1, 15);
#     writef("ins() la[]=");
#     displayLongArray(la);
#
#     // Removes a value from the array
#     la.del(3,4);
#     writef("del() la[]=");
#     displayLongArray(la);
#
#     // Cut a range of values to another array
#     la2 = la.cutr(1, 4);
#     writef("cutr() la[]=");
#     displayLongArray(la);
#     writef("la's cut to la2[]=");
#     displayLongArray(la2);
#
#     // Find and cut value from the original array
#     i =la.index(45);
#     writefln("index() value 45 found at position %d", i);
#     la2.length = 1;
#     la2[0] = la.cut(i);
#     writef("cut() la[]=");
#     displayLongArray(la);
#     writef("la's cut to la2[]=");
#     displayLongArray(la2);
# }
# }
#
# debug( xarrayt )
# {
# int main()
# {
#     std.stdio.writefln( "xarrayt.unittest finished!" );
#     return 0;
# }
# }

Output:
-------
C:\dmd>dmd xarrayt.d -debug=xarrayt -unittest C:\dmd\bin\..\..\dm\bin\link.exe xarrayt,,,user32+kernel32/noi;

C:\dmd>xarrayt
xarryt.unittest started.
String (char[]) Array Test.
push() s="To Kill a Mocking Bird!"
pop() s="" (Looped thru to remove all the characters)
ins() s="To SKill a Mocking Bird!"
del() s="To Kill a Mocking Bird!"
del() and insr() s="To Raise a Mocking Bird!"
del() and insr() s="To Kiss a Mocking Bird!"
cutr() and '~=' s="To Kiss a puppy Dog!" sub="Mocking Bird!"
index() 'K' found at position 3
cut() 'K' s="To iss a puppy Dog!"

Numerical (long[]) Array Test.
la[]=10,20,21,25,30,40,45,50
push() la[]=10,20,21,25,30,40,45,50,60,70
pop() la[]=10,20,21,25,30,40,45,50,60
ins() la[]=10,15,20,21,25,30,40,45,50,60
del() la[]=10,15,20,25,30,40,45,50,60
cutr() la[]=10,30,40,45,50,60
la's cut to la2[]=15,20,25
index() value 45 found at position 3
cut() la[]=10,30,40,50,60
la's cut to la2[]=45
xarrayt.unittest finished!

C:\dmd>

Thanks again for sharing it,
David L.

-------------------------------------------------------------------
"Dare to reach for the Stars...Dare to Dream, Build, and Achieve!"
-------------------------------------------------------------------

MKoD: http://spottedtiger.tripod.com/D_Language/D_Main_XP.html

Seems very useful indeed. Thanks for bringing this to public
attention (again).

Cheers,
Holger


In article <dcj82c$jn0$1@digitaldaemon.com>, David L. Davis says...
>
>In article <d4r6r5$1ane$1@digitaldaemon.com>, Andrew Fedoniouk says...
>>
>>Instead of
>>
>>a[3 .. 20] = a[4 .. 21];
>>a[3] = something;
>>
>>you may use just
>>
>>a.ins( 3, something );
>>
>>if you will include following somewhere:
>..
>>
>
>Andrew, thanks for being kind enough to share your xarrayt.d code back in April (of which, I've just now gotten around to checking it out)...hope you don't mind, but I thought I'd post a minor bug fixed / addtional unittest to the code. I'm pretty sure others will find this code you've written as being very useful in their own projects!
>
># /+
>#  ' Source    : XArrayT.d - D array extenders
>#  '           : Template functions to handle array overlapping slices
>#  ' Author    : Andrew Fedoniouk <news[at]terrainformatica[dot]com>
>#  ' Created   : 28.Apr.05 with D v0.122
>#  ' Modified  : 31.Jul.05 by David L. Davis
>#  '           : Changed one '===' (which is now deprecated) with an 'is', plus
>#  '           : added the missing *memmove() C function, then created a
>#  '           : unittest for all the functions, and complied / tested
>#  '           : under D v0.128.
>#  '           :
>#  ' Reference : http://www.digitalmars.com/drn-bin/wwwnews?digitalmars.D/22651
>#  ' --------------------------------------------------------------------------
>#  ' To complie for a unittest:
>#  ' C:\dmd>bin\dmd xarrayt.d -debug=xarrayt -unittest
>#  '
>#  ' To compile a D program that uses xarrayt.d:
>#  ' C:\dmd>bin\dmd MySource.d xarrayt.d
># +/
># module xarrayt;
>#
># debug( xarrayt ) private import std.stdio;
>#
># // Need to import the C memmove() function
># extern (C) void *memmove(void*, void*, uint);
>#
># //|
># //| std D array extenders, these should be intrinsic
># //| ops for arrays in ideal D
># //|
># template xarrayT(T)
># {
>#     // append array by one element
>#     void push(inout T[] elements, T v)
>#     {
>#         int l = elements.length;
>#         elements.length = l + 1;
>#         elements[l] = v;
>#     }
>#
>#     // del last element and return it
>#     T pop(inout T[] elements)
>#     {
>#         int l = elements.length - 1;
>#         assert(l >= 0);
>#         T t = elements[l];
>#         elements.length = l;
>#         return t;
>#     }
>#
>#     // insert element into array
>#     void ins(inout T[] elements, uint at, T v)
>#     {
>#         uint l = elements.length;
>#         if (at >= l) { elements ~= v; return; }
>#         // for some reasons this does not compile:
>#         // elements = elements[0..at] ~ v ~ elements[at..elements.length];
>#         // so we use C way:
>#         elements.length = l + 1;
>#         memmove(&elements[at + 1],&elements[at],(l - at) * T.sizeof);
>#         elements[at] = v;
>#     }
>#
>#     // insert array into array
>#     void insr(inout T[] elements, uint at, T[] va )
>#     {
>#         uint l = elements.length;
>#         if (at >= l) { elements ~= va; return; }
>#         elements.length = l + va.length;
>#         memmove(&elements[at + va.length],&elements[at],(l - at) * T.sizeof);
>#         elements[at..at + va.length] = va;
>#     }
>#
>#     // del element and return it
>#     T cut(inout T[] elements, uint at)
>#     {
>#         uint l = elements.length - 1;
>#         if (at >= l) return pop(elements);
>#         T t = elements[at];
>#         memmove(&elements[at],&elements[at + 1],(l - at) * T.sizeof);
>#         elements.length = l;
>#         return t;
>#     }
>#
>#     // del range and return its content
>#     T[] cutr(inout T[] elements, uint at, uint end)
>#     {
>#           assert(at <= end);
>#           if (at == end) return null;
>#           T[] t = elements[at..end].dup;
>#           uint l = elements.length - (end - at);
>#           //if (at < l) { elements.length = at; return t; }
>#           if (l - at <= 0) { elements.length = at; return t; }
>#           memmove(&elements[at],&elements[end],(l - at) * T.sizeof);
>#           elements.length = l;
>#           return t;
>#     }
>#
>#     // just del range
>#     void del(inout T[] elements, int at, int end)
>#     {
>#           assert(at <= end);
>#           if (at == end) return;
>#           uint l = elements.length - (end - at);
>#           if (at >= l) { elements.length = at; return; }
>#           memmove(&elements[at],&elements[end],(l - at) * T.sizeof);
>#           elements.length = l;
>#     }
>#
>#     // find index of the element in array, -1 if not found
>#     int index(in T[] elements,T t)
>#     {
>#        int i = elements.length - 1;
>#        for (; i >= 0; --i)
>#           if ( elements[i] is t ) break;
>#        return i;
>#     }
># }
>#
># alias xarrayT!(byte).push     push;
># alias xarrayT!(ubyte).push    push;
># alias xarrayT!(short).push    push;
># alias xarrayT!(ushort).push   push;
># alias xarrayT!(int).push      push;
># alias xarrayT!(uint).push     push;
># alias xarrayT!(long).push     push;
># alias xarrayT!(ulong).push    push;
># alias xarrayT!(float).push    push;
># alias xarrayT!(double).push   push;
># alias xarrayT!(real).push     push;
># alias xarrayT!(ifloat).push   push;
># alias xarrayT!(idouble).push  push;
># alias xarrayT!(ireal).push    push;
># alias xarrayT!(cfloat).push   push;
># alias xarrayT!(cdouble).push  push;
># alias xarrayT!(creal).push    push;
># alias xarrayT!(char).push     push;
># alias xarrayT!(wchar).push    push;
># alias xarrayT!(dchar).push    push;
>#
># alias xarrayT!(byte).pop     pop;
># alias xarrayT!(ubyte).pop    pop;
># alias xarrayT!(short).pop    pop;
># alias xarrayT!(ushort).pop   pop;
># alias xarrayT!(int).pop      pop;
># alias xarrayT!(uint).pop     pop;
># alias xarrayT!(long).pop     pop;
># alias xarrayT!(ulong).pop    pop;
># alias xarrayT!(float).pop    pop;
># alias xarrayT!(double).pop   pop;
># alias xarrayT!(real).pop     pop;
># alias xarrayT!(ifloat).pop   pop;
># alias xarrayT!(idouble).pop  pop;
># alias xarrayT!(ireal).pop    pop;
># alias xarrayT!(cfloat).pop   pop;
># alias xarrayT!(cdouble).pop  pop;
># alias xarrayT!(creal).pop    pop;
># alias xarrayT!(char).pop     pop;
># alias xarrayT!(wchar).pop    pop;
># alias xarrayT!(dchar).pop    pop;
>#
># alias xarrayT!(byte).ins     ins;
># alias xarrayT!(ubyte).ins    ins;
># alias xarrayT!(short).ins    ins;
># alias xarrayT!(ushort).ins   ins;
># alias xarrayT!(int).ins      ins;
># alias xarrayT!(uint).ins     ins;
># alias xarrayT!(long).ins     ins;
># alias xarrayT!(ulong).ins    ins;
># alias xarrayT!(float).ins    ins;
># alias xarrayT!(double).ins   ins;
># alias xarrayT!(real).ins     ins;
># alias xarrayT!(ifloat).ins   ins;
># alias xarrayT!(idouble).ins  ins;
># alias xarrayT!(ireal).ins    ins;
># alias xarrayT!(cfloat).ins   ins;
># alias xarrayT!(cdouble).ins  ins;
># alias xarrayT!(creal).ins    ins;
># alias xarrayT!(char).ins     ins;
># alias xarrayT!(wchar).ins    ins;
># alias xarrayT!(dchar).ins    ins;
>#
># alias xarrayT!(byte).insr     insr;
># alias xarrayT!(ubyte).insr    insr;
># alias xarrayT!(short).insr    insr;
># alias xarrayT!(ushort).insr   insr;
># alias xarrayT!(int).insr      insr;
># alias xarrayT!(uint).insr     insr;
># alias xarrayT!(long).insr     insr;
># alias xarrayT!(ulong).insr    insr;
># alias xarrayT!(float).insr    insr;
># alias xarrayT!(double).insr   insr;
># alias xarrayT!(real).insr     insr;
># alias xarrayT!(ifloat).insr   insr;
># alias xarrayT!(idouble).insr  insr;
># alias xarrayT!(ireal).insr    insr;
># alias xarrayT!(cfloat).insr   insr;
># alias xarrayT!(cdouble).insr  insr;
># alias xarrayT!(creal).insr    insr;
># alias xarrayT!(char).insr     insr;
># alias xarrayT!(wchar).insr    insr;
># alias xarrayT!(dchar).insr    insr;
>#
># alias xarrayT!(byte).cut     cut;
># alias xarrayT!(ubyte).cut    cut;
># alias xarrayT!(short).cut    cut;
># alias xarrayT!(ushort).cut   cut;
># alias xarrayT!(int).cut      cut;
># alias xarrayT!(uint).cut     cut;
># alias xarrayT!(long).cut     cut;
># alias xarrayT!(ulong).cut    cut;
># alias xarrayT!(float).cut    cut;
># alias xarrayT!(double).cut   cut;
># alias xarrayT!(real).cut     cut;
># alias xarrayT!(ifloat).cut   cut;
># alias xarrayT!(idouble).cut  cut;
># alias xarrayT!(ireal).cut    cut;
># alias xarrayT!(cfloat).cut   cut;
># alias xarrayT!(cdouble).cut  cut;
># alias xarrayT!(creal).cut    cut;
># alias xarrayT!(char).cut     cut;
># alias xarrayT!(wchar).cut    cut;
># alias xarrayT!(dchar).cut    cut;
>#
># alias xarrayT!(byte).cutr     cutr;
># alias xarrayT!(ubyte).cutr    cutr;
># alias xarrayT!(short).cutr    cutr;
># alias xarrayT!(ushort).cutr   cutr;
># alias xarrayT!(int).cutr      cutr;
># alias xarrayT!(uint).cutr     cutr;
># alias xarrayT!(long).cutr     cutr;
># alias xarrayT!(ulong).cutr    cutr;
># alias xarrayT!(float).cutr    cutr;
># alias xarrayT!(double).cutr   cutr;
># alias xarrayT!(real).cutr     cutr;
># alias xarrayT!(ifloat).cutr   cutr;
># alias xarrayT!(idouble).cutr  cutr;
># alias xarrayT!(ireal).cutr    cutr;
># alias xarrayT!(cfloat).cutr   cutr;
># alias xarrayT!(cdouble).cutr  cutr;
># alias xarrayT!(creal).cutr    cutr;
># alias xarrayT!(char).cutr     cutr;
># alias xarrayT!(wchar).cutr    cutr;
># alias xarrayT!(dchar).cutr    cutr;
>#
># alias xarrayT!(byte).del     del;
># alias xarrayT!(ubyte).del    del;
># alias xarrayT!(short).del    del;
># alias xarrayT!(ushort).del   del;
># alias xarrayT!(int).del      del;
># alias xarrayT!(uint).del     del;
># alias xarrayT!(long).del     del;
># alias xarrayT!(ulong).del    del;
># alias xarrayT!(float).del    del;
># alias xarrayT!(double).del   del;
># alias xarrayT!(real).del     del;
># alias xarrayT!(ifloat).del   del;
># alias xarrayT!(idouble).del  del;
># alias xarrayT!(ireal).del    del;
># alias xarrayT!(cfloat).del   del;
># alias xarrayT!(cdouble).del  del;
># alias xarrayT!(creal).del    del;
># alias xarrayT!(char).del     del;
># alias xarrayT!(wchar).del    del;
># alias xarrayT!(dchar).del    del;
>#
># alias xarrayT!(byte).index     index;
># alias xarrayT!(ubyte).index    index;
># alias xarrayT!(short).index    index;
># alias xarrayT!(ushort).index   index;
># alias xarrayT!(int).index      index;
># alias xarrayT!(uint).index     index;
># alias xarrayT!(long).index     index;
># alias xarrayT!(ulong).index    index;
># alias xarrayT!(float).index    index;
># alias xarrayT!(double).index   index;
># alias xarrayT!(real).index     index;
># alias xarrayT!(ifloat).index   index;
># alias xarrayT!(idouble).index  index;
># alias xarrayT!(ireal).index    index;
># alias xarrayT!(cfloat).index   index;
># alias xarrayT!(cdouble).index  index;
># alias xarrayT!(creal).index    index;
># alias xarrayT!(char).index     index;
># alias xarrayT!(wchar).index    index;
># alias xarrayT!(dchar).index    index;
>#
># debug( xarrayt )
># {
># void displayLongArray(in long[] la)
># {
>#     if (la.length > 1)
>#         for ( int i = 0; i < la.length - 1; i++ )
>#             writef("%d,", la[i]);
>#
>#     writefln("%d", la[la.length - 1]);
># }
>#
># unittest
># {
>#     writefln( "xarryt.unittest started." );
>#     char[] s;
>#     char[] st = "To Kill a Mocking Bird!";
>#     char[] sub;
>#     static long[] lsa = [ 10L, 20L, 21L, 25L, 30L, 40L, 45L, 50L ];
>#     long[] la = lsa;
>#     long[] la2;
>#     int    i;
>#
>#     writefln("String (char[]) Array Test.");
>#
>#     // Appends one char at a time
>#     for ( int i = 0; i < st.length; i++ )
>#         s.push(st[i]);
>#     writefln("push() s=\"%s\"", s);
>#
>#     // Removes the last character
>#     for ( uint i = 0; i < st.length; i++ )
>#         s.pop();
>#     writefln("pop() s=\"%s\" (Looped thru to remove all the characters)", s);
>#
>#     // Inserts one character into a string
>#     s = st;
>#     s.ins(3, 'S');
>#     writefln("ins() s=\"%s\"", s);
>#
>#     // Delete a character from [start] to [end] within a string
>#     s.del(3,4);
>#     writefln("del() s=\"%s\"", s);
>#
>#     // Replace a substring within the string
>#     s.del(3,7);
>#     s.insr(3, "Raise");
>#     writefln("del() and insr() s=\"%s\"", s);
>#
>#     // Replace a substring within the string
>#     s = st;
>#     s.del(5,7);
>#     s.insr(5, "ss");
>#     writefln("del() and insr() s=\"%s\"", s);
>#
>#     // Cut a substring out of the string and append to it
>#     sub = s.cutr(10, 23);
>#     s ~= "puppy Dog!";
>#     writefln("cutr() and '~=' s=\"%s\" sub=\"%s\"", s, sub);
>#
>#     // Get the position of a value
>#     i = s.index('K');
>#     writefln("index() 'K' found at position %d", i );
>#
>#     // Remove a value
>#     s.cut(3);
>#     writefln("cut() 'K' s=\"%s\"", s);
>#
>#     // Numerical test
>#     //la = [ 10, 20, 21, 25, 30, 40, 45, 50 ];
>#     writefln();
>#     writefln("Numerical (long[]) Array Test.");
>#     writef("la[]=");
>#     displayLongArray(la);
>#
>#     // Add 60 and 70 to the long array
>#     la.push(60);
>#     la.push(70);
>#     writef("push() la[]=");
>#     displayLongArray(la);
>#
>#     // Removes the last value from the array
>#     la.pop();
>#     writef("pop() la[]=");
>#     displayLongArray(la);
>#
>#     // Inserts a new value into the array
>#     la.ins(1, 15);
>#     writef("ins() la[]=");
>#     displayLongArray(la);
>#
>#     // Removes a value from the array
>#     la.del(3,4);
>#     writef("del() la[]=");
>#     displayLongArray(la);
>#
>#     // Cut a range of values to another array
>#     la2 = la.cutr(1, 4);
>#     writef("cutr() la[]=");
>#     displayLongArray(la);
>#     writef("la's cut to la2[]=");
>#     displayLongArray(la2);
>#
>#     // Find and cut value from the original array
>#     i =la.index(45);
>#     writefln("index() value 45 found at position %d", i);
>#     la2.length = 1;
>#     la2[0] = la.cut(i);
>#     writef("cut() la[]=");
>#     displayLongArray(la);
>#     writef("la's cut to la2[]=");
>#     displayLongArray(la2);
># }
># }
>#
># debug( xarrayt )
># {
># int main()
># {
>#     std.stdio.writefln( "xarrayt.unittest finished!" );
>#     return 0;
># }
># }
>
>Output:
>-------
>C:\dmd>dmd xarrayt.d -debug=xarrayt -unittest C:\dmd\bin\..\..\dm\bin\link.exe xarrayt,,,user32+kernel32/noi;
>
>C:\dmd>xarrayt
>xarryt.unittest started.
>String (char[]) Array Test.
>push() s="To Kill a Mocking Bird!"
>pop() s="" (Looped thru to remove all the characters)
>ins() s="To SKill a Mocking Bird!"
>del() s="To Kill a Mocking Bird!"
>del() and insr() s="To Raise a Mocking Bird!"
>del() and insr() s="To Kiss a Mocking Bird!"
>cutr() and '~=' s="To Kiss a puppy Dog!" sub="Mocking Bird!"
>index() 'K' found at position 3
>cut() 'K' s="To iss a puppy Dog!"
>
>Numerical (long[]) Array Test.
>la[]=10,20,21,25,30,40,45,50
>push() la[]=10,20,21,25,30,40,45,50,60,70
>pop() la[]=10,20,21,25,30,40,45,50,60
>ins() la[]=10,15,20,21,25,30,40,45,50,60
>del() la[]=10,15,20,25,30,40,45,50,60
>cutr() la[]=10,30,40,45,50,60
>la's cut to la2[]=15,20,25
>index() value 45 found at position 3
>cut() la[]=10,30,40,50,60
>la's cut to la2[]=45
>xarrayt.unittest finished!
>
>C:\dmd>
>
>Thanks again for sharing it,
>David L.
>
>-------------------------------------------------------------------
>"Dare to reach for the Stars...Dare to Dream, Build, and Achieve!"
>-------------------------------------------------------------------
>
>MKoD: http://spottedtiger.tripod.com/D_Language/D_Main_XP.html