On Mon, 25 Jan 2016 14:51:21 +0000, pineapple wrote:
> I'm getting several of these since I'm trying to do the same thing in a
> few places. Here's a complete error:
>
> path\to\file.d(55): Error: variable
> units.unitvalue.opmethod!("sum(in unitvalue value)",
> "add(value)").methodtemplate cannot use template to add field to
> aggregate 'unitvalue'
> path\to\file.d(127): Error: template instance
> units.unitvalue.opmethod!("sum(in unitvalue value)", "add(value)") error
> instantiating
That looks like the right error.
> template opmethod(string methoddef, string methodcall){
> const char[] methodtemplate =
Change it from 'const' to 'enum' and Bob's your uncle.
Short explanation:
'enum' refers to compile-time constants. 'const' is a promise that you
will not mutate a variable through that reference. Anything that's not a
compile-time constant in an aggregate body requires storage space within
that aggregate, resulting in an unbounded set of fields.
Exhaustive explanation:
'const' indicates that you cannot mutate the data through this reference
(but it can be mutated elsewhere). It's not referring to compile-time
constants. For instance, it's entirely legal (and reasonable) to write:
class OptParse {
const(string[]) args;
this(const(string[]) args) {
this.args = args;
}
}
void main(string[] args) {
new OptParse(args);
}
Which indicates that OptParse is not going to modify the args array.
You're grabbing command-line arguments and passing them in, which means
they're not a compile-time constant. So the OptParse class has to include
a storage slot reserved for the 'args' variable.
In your case, 'methodtemplate' isn't declared as a compile-time constant.
It has an initializer that's a compile-time constant, but you aren't
guaranteeing that the value isn't going to be changed.
That would be fine, but it's inside a template. Templates can be
instantiated a potentially unlimited number of times. So the compiler
comes across this type, tries to compute its size and fields -- but it
doesn't know for certain at this point how many times you're
instantiating the template. So it can't list out all the fields.
It would be possible if D compiled a whole program at once. This would
prevent you from publishing closed-source libraries, however, and
increase compilation times.
