Implied types for intermediate declarations

[cjllanwarne]

I wonder whether this would be a great idea or a terrible one...

A lot of languages allow implied types (ie the language is strongly typed but the author doesn't need to type it out in full - they let the language do that for them).

Here's an example from a recent test case I was writing:

version draft-3

workflow lots_of_nesting {

  Boolean b0 = true
  Boolean b1 = true
  Boolean b2 = true

  Array[Int] i0s = range(2)
  Array[Int] i1s = range(2)
  Array[Int] i2s = range(2)

  String s0 = "hello"
  String s1 = "world"

  if (b0) {
    scatter(i0 in i0s) {
      if (b1) {
        scatter(i1 in i1s) {
          if (b2) {
            scatter(i2 in i2s) {
              String s = s0 + s1
            }
          }
        }
      }
    }
  }

  Array[Array[Array[String]?]?]? s_intermediate = s

  output {
    Array[Array[Array[String]?]?]? s_out = s_intermediate
  }
}

So that intermediate type... it's a bit messy to have to write it out in full (especially since it has to by typed out again in the outputs!).

Suggestion: Let users use value as a placeholder instead of the full type for intermediate values. We would still validate any future uses of the value as though it were fully typed, and I would still want full types for inputs and outputs (so that the interface can be read directly from the WDL file):

  value s_intermediate = s
  output {
    Array[Array[Array[String]?]?]? s_out = s_intermediate
  }

[orodeh]

@cjllanwarne, IMHO, we could consider it for version 2.0. The type landscape will significantly change after adding structs and directories (and hopefully removing objects).

I believe another name for this feature (at least in the ocaml world) is type-inference. It is complicated by generics and sub-typing, which we don't have as of yet, but may wish to add.

[geoffjentry]

Here's hoping I never hear the phrase "Hindley-Milner" in relation to WDL :P

[orodeh]

On a related note, dxWDL has to figure out variable and expression types, much like the value notation. There is a test case for this, which uses the WdlNamespace.lookupType. There are two issues:

1. LookupType is private
2. What is the equivalent in draft3?

Currently, I use a local copy of lookupType, but that is not really a good idea.

[jdidion]

I think the OP's example is extreme and it's not very common to encounter such long types. I don't think I'd want to introduce type inference just for this edge case. What about type aliases? For example:

type MyArray = Array[Array[Array[String]?]?]?

task foo {
  MyArray a = ...
}