RFC: Host types for dentaku

[jneen]

The Problem

We currently have a good deal of dentaku code that deals with functions or complicated dictionaries, whose values are currently represented by :numeric or complex dictionary types. It would be much simpler if we could write functions against some sort of :use-code type, and choose how to represent those values at runtime.

This proposal

This is a proposal to add "host types" - types that Dentaku doesn't necessarily know about, but that can be accessed or created through Opencounter-provided functions. They use the same syntax as concrete types - for example :entity or :use-code would be considered a host type. They may also take arguments - for example :my-cool-container(:numeric).

For example,

Dentaku::AST::Function.register 'calculate_zoning(:address, :use-code, :string) = :zoning', ->(address, use_code, locale) {
  # implement here
}

This places no restrictions on how these values are represented at runtime - they could be numbers, strings, Ruby objects, or hashes. But the checker will guarantee that a value of type :my-cool-type will only ever show up in places where it is expected.

Potential Issues

• The syntax is confusing, since they look very similar to concrete types like :numeric. Should this be different? This would require a little bit of customization to the :param TypeExpression, since they have identical solving semantics and I'd like to avoid duplication.
• If there is code in production that uses "use codes" as numbers (i.e. doing math on them, etc) this will break. On the other hand, this will in the future guarantee that such things are not possible.

[jneen]

For reviewers, please look at the last two commits only - the rest are from dependencies of this branch.

[rtlong]

• This seems interesting! I'm not sure I see the use-case clearly, so perhaps if you could give a more concrete example it would clarify.

• I worry about that these look identical to concrete types while being implicitly defined. If there's a typo in one function definition it could lead to confusion. What if we had to explicitly register host types before use? I would feel okay about them looking like the concrete types in that case.

[jneen]

Explicitly registering them is a good idea.

[jneen]

The use-case is to allow us to have dentaku functions (in lib/dentaku_global_functions.rb) that operate on higher-level values, instead of using :numeric for things like :use-code, or dictionary types for :zoning-data. This will prevent config bugs that are currently possible like doing math on use codes.

[jneen]

After a conversation with @joshuabates, I think we're happy with having everything declared. This can also be used internally to Dentaku for its basic types like :string and :list (and actually makes a number of things cleaner). It would look something like this:

Dentaku::Type.declare(:string) # within Dentaku
Dentaku::Type.declare(:'use-code') # for all our bespoke OC types, incl. :zoning, :address, etc
Dentaku::Type.declare(:list, 1) # one type argument indicating the type of value in the list
Dentaku::Type.declare(:dict, 1) # similar to the above - a dict with arbitrary keys but one type of value

[jneen]

Closing as superseded by #20