Can we have type aliases?

I would like to be able to create type aliases, namely something like this:

...
type PathToFastq = File
type PathToFasta = File
...
task bwa {
    input {
        PathToFastq read1
        PathToFastq read2
        PathToFasta fasta
        ...
    }
    ...
}

What do other folks think? It would make reading the inputs a lot clearer and would allow folks to alias File to their favorite genomic file format (ex. BED, BAM, XLSX …).

I’d be happy to make a PR; since this is my first time adding to the spec, I wouldn’t mind some help figuring out where it would go.

[DavyCats]

I strongly agree with @patmagee here, names should indicate what the value of the variable represents and types should only indicate how they can be used. If your naming relies on the type to be understandable, you will have to look up its declaration whenever you encounter it at some other point in your code:

NumberOf samples = 12

[...many lines of code...]

call someTask {
    input:
        samples=samples 
        # Me when I see this: "Oh, this task recieves an array of samples.",
        # but really it's just given an Int! I probably should just have called it
        # numberOfSamples.
}

In addition, these custom type names will make it harder for a third party to read you wdl files:

input {
    Fastq reads
    # Is is this a File, a String or a Struct?
    # Do I now have to look for a struct definition or a type alias?

    # vs

    File fastq
    # Ah, cool, a File representing a Fastq!
}

I also wonder how this will interact with structs, this looks like it might create some ambiguity in the syntax.

Just as a note, typing has many benefits without clearifying what a variable represents.

It can speed up run/compile time, as you only need to check whether the type is approriate for a certain operation, not what the type actually is. I image it also simplifies how variables (and the underlying memory management) are handeled by the compiler/interpreter/execution-engine. It also lets other developers know what type should be used as parameter to function calls. This greatly reduces the chance of unexpected behavior and errors resulting from functions getting called with types the author of the function didn't expect. It allows IDEs to check and warn you of these kinds of mistakes and suggest functions that can be used for a given variable.

[patmagee]

I think the question here is really what does the type alias hope to accomplish that proper naming of the variable would not? IMO if you are using the type to infer meaning of the varibale to the user then you are not naming your variables properly.

Its also worth noting that the way you are naming the File varibale (PathToFastq) gives the impression that the File is actually a String type and not a File type. To me the naming pattern you suggest actually makes it harder to read, since I would look for a separate reference to a File somewhere else and would not think that the PathToFastq actually refers to a file