Component Parameter Type Parameterization

[lrennels]

Continuation of #469 discussion, deciding the best way to type parameterize the parameters of a component, with options such as:

1. param::Array{String, 1} = Parameter(index=[time])

2. paramName::String = Parameter(index=[time])

3. Avoid overloading Julia syntax and add a keyword to our Parameter definition, e.g.,
   paramName = Parameter(index=[time], type=String)

[davidanthoff]

So we go with option 3, but call the parameter eltype, and the old 2 option should error.

[rjplevin]

Do we want to support syntax option 2 for scalar values? That is, do we allow:

paramName::Int = Parameter(default=42)

or require:

paramName = Parameter(eltype=Int)

We could also keep both and only error when using ::Type when indexes are present.

[davidanthoff]

I think if we move things into the Parameter constructor, we should probably move everything in there?

But one question is whether we should use eltype for the scalar case... Does that make sense? Doesn't seem too bad...

[corakingdon]

I thought we were still going to support the (2) syntax, just not for using it to define the eltype of an array. But that the following would be okay:

paramName::Int = Parameter( )    # paramName would be an integer
paramName::String = Parameter( )    # paramName would be a string
paramName::Matrix{Float64} = Parameter( )    # paramName would be a matrix

But this would error, since the index implies that it needs to be an array:

paramName::String = Parameter(index=[time])    # not allowed

[davidanthoff]

Well, should we? I'm unsure... I almost feel that if we do away with the ::Foo syntax, we should do away with it entirely.

Btw., another option would be p1 = Parameter{Int}(...)... The benefit of this would be that we don't need to use a keyword arg like eltype that might be wrong for the scalar case.

[rjplevin]

p1 = Parameter{Int}(...)

I like that, though it's somewhat more complicated for less-Julia-expert modelers.

[corakingdon]

(I'm just writing this down now so we don't forget what we agreed on. I'm going to start trying to implement soon)

We will implement:

p1 = Parameter{Int}()    # ScalarModelParameter that is an Int
p2 = Parameter{Int}(index = [regions])    # ArrayModelParameter whose eltype is Int

p3 = Parameter{Matrix{Float64}}()    # ScalarModelParameter that is a Matrix

Basically, if there are "index"s listed in the Parameter definition, then it will be an ArrayModelParameter whose eltype is the type specified in the curly brackets. If there are no "index"s listed, then the type specified in the curly brackets is the actual type of the parameter value, and it will be represent by Mimi as a ScalarModelParameter