various questions

[Jason Spencer]

I'm working on a program to do statistics on matrices of different sizes, and
I've run into a handful of situations where I just can't seem to find the
trick I need.  In general, I'm trying to make my functions work on static
arrays of the proper size, and template that up for the different sizes I need
to support.  I appeal to your experience and mercy on the various questions
below.  Any help on any point appreciated.

1.  How can I cast a single dimension dynamic array to a multi-dimension
static array?  I'm trying to do roughly the following:

   auto data = cast(float[100][100])std.file.read(fname, fsize);

which fails on the cast.  Is there any way to treat they memory returned
from read as a static array?  If I want to avoid the copy, am I relegated back
to pointers?  Is there a cast path through a pointer that would work?  I think
I'm essentially asking if I can make a reference to a static array and assign
that to the memory contained in a dynamic array.  I have a suspicion about the
answer....

2.  To work around 1., I've left one dimension of the cast floating.  This
means to bind both dimensions in my template args, I can no longer use
type parameter inference, so I have to explicitly instantiate the template
with the static size, but pass in a type that's dynamic in one dimension.  Is
there a way to deduce the equivalent static array type from the dynamic array?
(See code below).  How about just from a static array?  Even the following
fails:

   U foo(T: U[C][R], U, size_t C, size_t R)(T data, size_t c, size_t r)
   {
      return data[r][c];
   }

   int[4][5] data = [ [...] ];
   int bar = foo(data, 2, 3);

but

   int bar = foo!(int[4][5])(data, 2, 3);

works.  Why?

If I could solve that, then next I'd need to make this work:

   U foo(T: U[C][R], U, size_t C, size_t R)(U[C][] data, size_t c, size_t r)
   {
      return data[r][c];
   }

   int[4][] data = [ [...] ];
   int bar = foo(data, 2, 3);

Extra points for that one!


3.  I wanted to have a const static lookup table in a struct to map a string to an
int.  I figured an Associative array would be a good way to index by string.
But I was not able to give a literal AA.  I had to put it in static this().  I
assume that's because AA's aren't really initialized by the compiler, so
they're not really literals.  They're just arguments to some run-time function
that actually initializes them.  Is that right?  If so, that's too bad--making
different rules for different array types makes them feel like they're not
/really/ part of the language.  Plus, having immutable lookups, fixed at
compile time, would be really useful.

4.  Lastly, compiling.  In src/main.d, I had "import data.stats;", and in
src/data/stats.d, I had "module data.stats;".  On the command line in src, I figured
I'd just have to say "dmd main.d" and I'd be good to go.  Or maybe "dmd -I.
main.d" or "dmd -Idata main.d".  But I had to specify both files for the
compiler, as in "dmd main.d data/stats.d" to avoid undefined symbols from
stat.d at link time.  Is that right?  If so, how does dmd know where to get
phobos files from?  Is there a slicker way to do this with dmd?

Thanks,
Jason