From: Mark Hubbart <discordantus@...>
Date: 2005-05-03T01:02:22+09:00
Subject: Re: collections with values of fixed classes/lengths

On 5/2/05, Eric Mahurin <eric_mahurin@yahoo.com> wrote:
> > > I still think a more general extension would be nice.  And
> > > Robert, I guess you might say I'm guessing.  I'm new to
> > ruby,
> > > but from my perl usage, I know of many times I've dealt
> > with
> > > large amounts of data and would have wanted more C-like
> > > efficiency.
> >
> > ;-)
> >
> > As Mark has demonstrated, you can stuff anything into a
> > String with pack and
> > unpack.
> >
> > Btw, Mark, if you factor out conversion to string and from
> > string (hint
> > traits), you have a generic implementation for any fixed size
> > type.  Maybe
> > this should go somewhere into the std lib...
> 
> That would be great.  What do you mean by "fixed size type"?
> Does that mean you couldn't use this class to make a
> homogeneous array of strings, arrays, or hashes?  The way I was
> thinking you'd handle the complex object case would be to give
> "new" an initial object instead of a simply a class.  From
> this, you could tell how much flattening to do in the array.

I can see some benefit in an array (or even hash) of fixed-size data
items; sometimes memory usage considerations are more important than
flexibility. The fact that the homogeneity is enforced I saw as a
somewhat unfortunate side-effect, though maybe I'm just too used to
Ruby's very dynamic nature. Why would you want to artificially force
the contents of an array to be all the same type? Why preclude any
possibility of duck typing? I just have the feeling that anyone using
this would have it bite them later on, when they want to use the full
flexibility of Ruby, and can't.

> Now that I'm looking at Array.new, you could even use the same
> interface:
> 
> HomogeneousArray.new(size=0,defaultObject=nil)
> 
> Now, defaultObject is not only the default but its class is
> used to make the array homogeneous (if not nil)
> 
> Here are a few examples:
> 
> # like Array.new - objects can be anything (treat nil as Object
> instead of NilClass) and initialized to nil (when array
> expands)
> HomogeneousArray.new(0,nil)
> 
> # array of Floats initialized to 0.0
> HomogeneousArray.new(0,0.0)
> 
> # array of FixNums initialized to 0
> HomogeneousArray.new(0,0)
> 
> # array of Strings initialized to ""
> HomogeneousArray.new(0,"")
> 
> # array of name/address/zip structs where fields can be
> anything and are initialized to nil
> Customer = Struct.new(:name,:address,:zip)
> HomogeneousArray.new(0,Customer.new)
> 
> # now name/address/zip must be String/String/Fixnum and are
> initialized to empty strings and 0.  There is one more level of
> flattening in the array storage compared to above
> Customer = Struct.new(:name,:address,:zip)
> HomogeneousArray.new(0,Customer.new("","",0))
> 
> I think having something similar for a Hash would also be
> useful.  The "new" method with this homogenous hash class just
> needs one more optional argument:
> 
> HomogeneousHash.new(defaultValue=nil, defaultKey=nil)
> 
> Here would be a few examples:
> 
> HomogeneousHash.new(nil,nil) # same as Hash.new
> HomogeneousHash.new(nil,"") # keys must be Strings
> 
> # keys are Strings and values are String,Fixnum Structs
> CustomerData = Struct.new(:address,:zip)
> HomogeneousHash.new(CustomerData.new("",0),"")
> 
> # values must be true.  No value storage should be necessary
> since only one value is possible.  Only key storage should be
> needed.  This acts like an unordered set.
> HomogeneousHash.new(true,nil)
> 
> In addition to all this, some way to designate fixed-length
> Arrays, Strings, and Bignums (down to 1-bit) in the collection
> values would allow one more level of flattening in the storage.
>  You could have special classes or just designate a non-zero
> length to mean the objects should have a fixed length.  For
> Bignums/Fixnums, you'd just strip off the most significant 1 to
> allow easy specifying of bits and allow any default.  Here
> would be some more examples using this method for designating
> fixed-length Arrays, String, and Bignums:
> 
> # array of 64-bit integers with initial value of 0
> HomogeneousArray.new(0,2**64)
> 
> # array of 16-bit integers with initial value of 1
> HomogeneousArray.new(0,2**16+1)
> 
> # array of 1-bit integers with initial value of 0
> HomogeneousArray.new(0,2**1)
> 
> # array of array of 4 8-bit integers initialized to 0
> HomogeneousArray.new(0,[2**8]*4)
> 
> # array of 2 character string initialized to \0\0
> HomogeneousArray.new(0,"\0\0")
> 
> # array of array of 4 Objects initialized to nil
> HomogeneousArray.new(0,[nil]*4)
> 
> Well, I think this summarizes my proposal.  Maybe an RCR is in
> order.
> 
> 
> __________________________________________________
> Do You Yahoo!?
> Tired of spam?  Yahoo! Mail has the best spam protection around
> http://mail.yahoo.com
> 
>