Typed Metadata

[machaval]

Typed Metadata

Pre-read: #40 .

We have already talk about what metadata is, and all it uses. One problem that I still see is that though we now have a way to apply metadata without the need of doing as with a type, using the new <~ operator. We still don't have nice way to type checkit.

For example in order of CData to be applied we have to set the metadata {cdata: true}, and here we have two problems one that users need to remember the name of the keys and its value type, and second that if you did some miss spelling like {cData: true} it doesn't work, and you don't get any error or hint why not.

Solutions

Use functions to apply metadata

One option would be let's create functions that allows us to apply metadata with typed values. For example this would be

%dw 2.0
output application/xml
fun cdata<T>(a: T, cdata: Boolean) : T = do {
    a <~ {cdata: cdata}
}
---
root: "DW Rocks" cdata true

Pros

1. Doesn't require anything new from the language
2. Fixes both issues as it will validate the argument and the tooling will validate the parameters

Drawback Open Questions

1. How is this going to work with type definitions
2. Is function call the proper tool to apply metadata that is something that is not really changing the value?. Does it contaminate the script?
3. Should we start investigating to handle types as values so we can apply functions to the types to attach metadata.

Use annotations

Use annotation to attach metadata

@Metadata(name: "cdata")
annotation CData(value: Boolean = true);
---
root: @CData() "DWRocks"

With this approach we can let the engine that all the fields of the Annotation should be attached to the value as metadata values.

We can take this approach and expand it to type expressions

@Metadata(name= "valueProvider")
annotation ValueProvider(value: () -> Array<String>);

type Test = {
	a: @ValueProvider(value = myValueProvider) String
}

fun myValueProvider() = ["Hello", "ByeBye"]

The @metadata will be used to mark any annotation that represents a Metadata Annotation, and specifies the name of the metadata element to be set.
Also the annotation must have only one parameter called value that will represent the value of the metadata to be injected.

Pros

1. As they are annotations they doesn't look like it polutes the scripting looks more like a second class thing
2. Tooling and verification are still possible

Cons

1. Yet another way to apply metedadata

[jorgegarciamule]

I felt the function approach more natural. One vote there. Now, if I write the data with output "dw", would I see anything? Is there any flag that can output this to validate the metadata is there?