Supporting typed, structured data

[mitchgrout]

A common trick I see used to reduce duplicated declarations is to iterate over a set of data; this might be a hash where each key/value represents some 'configuration' of sorts. An example of this could be a hash representing tests to be built+run, with the configuration containing key data such as:

1. What dependencies to link with
2. The test priority/group
3. Any extra sources that are required

Since a hash can store any type as a value, and AFAIK there is no user-level type checking permitted, it's possible to mess up the config and get bizarre error messages out the other side. For example, I might have

tests = {
  'test_foo.c': { 'dependencies': lib },
}

foreach filename, config: tests
  exe = executable(fs.stem(filename), filename, dependencies: config.get('dependencies'))
  test(exe.name(), exe)
endforeach

Since there is no way to ensure that the value of config.get('dependencies') is a lib, I will get a complaint from meson about a lib being passed in the dependencies field. However, the provenance is lost; I can't figure out from that message alone which row in the tests hash caused the problem.

My thoughts on this would be to either:

1. Have the ability to define a strongly-typed structure, or
2. Have the ability to type-check values

The first choice feels more accessible to me; the above example could possibly be something like...

test_config = structure(link_with: lib)
tests = { 'test_foo.c': test_config(link_with: dep) } # error: dep is not of type 'lib'

This would provide better provenance for the error, as it would actually be at the creation site rather than the use site.

[mitchgrout]

The ability to type-check values is still valuable in its own right, but does not really address the core problem I have here; it would resolve the error message being misleading, but would not tell me which row was causing the problem.