Plan is confusing when output value changes between tuple type and list type with the same elements values

[Nuru]

Changing

output "test" {
  value = ["first", "second"]
}

to

output "test" {
  value = true ? ["first", "second"] : [] # ["first", "second"]
}

unexpectedly and incorrectly produces a plan with a change like

Changes to Outputs:
  ~ test = [
      - "first",
      - "second",
    ] -> [
      + "first",
      + "second",
    ]

This occurs in Terraform v1.2.0 and earlier versions, such as 1.1.7.

Terraform Version

Terraform v1.2.0
on darwin_amd64
+ provider registry.terraform.io/hashicorp/aws v4.15.1

[jbardin]

Hi @Nuru,

Thanks for filing the issue!

Altering the configuration in this way is changing the type of the output value, going from a tuple(string, string) to a list(string). While these differences may be important in many situations (including for nested module outputs), for root module outputs the change is not going to be important for the end user.

Since outputs are dynamically typed, we should be able to check if root module outputs can serialize to the same value and avoid the extra diff in the plan.

Thanks!

[apparentlymart]

It could potentially be significant if the output values are consumed elsewhere using terraform_remote_state, so perhaps another way to proceed here would be to use similar annotations as we use in terraform console and, I think, in the final apply success messages, to distinguish a list from a tuple by wrapping it in a tolist( ... ) call, so that in this case the "after" value would at least be rendered differently than the "before" value.

Admittedly a change from a tuple to a list would still not be super clear to someone who isn't yet familiar with the type system details, but it would at least show that the type is changing and thus hopefully give a better clue that there's something to learn about the type system here.

Changes to Outputs:
  ~ test = [
      - "first",
      - "second",
    ] -> tolist([
      + "first",
      + "second",
    ])

[jbardin]

Thanks @apparentlymart, for some reason I was thinking we still serialized these without type information. I even said these are dynamically typed, which would indicate that the type information is encoded in the state, therefore the serialized representations wouldn't match anyway.

[Nuru]

@apparentlymart Thank you for pointing this out. I agree with you that showing the output changed from tuple to list would be helpful. Despite using Terraform practically every working day for 2 years now, I still sometimes get confused about whether I am dealing with a tuple or a list and what causes a tuple to get converted to a list, and it does sometimes cause problems because my tuples are not always valid lists.

More to the point, @jbardin, why is the output changing from tuple to list? How can I keep the output type from changing?

[apparentlymart]

What's happening here is that Terraform is noticing that the two arms of your conditional expression have different types and so rather than immediately returning an error Terraform is trying to find a type that they can both convert to, and assuming that you intended to make those conversions.

In the expression true ? ["first", "second"] : [], the "true" result is of type tuple([string, string]) while the "false" result is of type tuple([]) (the empty tuple type). Terraform noticed that a tuple whose elements are all strings and a tuple with no elements at all can both convert to list(string), and so it guessed that what you meant and made the result be a list of strings.

The purpose of tuple types is to make the individual element types be part of the type so that we can support different elements having different types. We have this in the type system primarily so that Terraform's type system will be a superset of JSON's: Terraform's tuple types correspond with JSON arrays. That means there isn't any way for this conditional expression to return a tuple type though, because there is no tuple type that both of these values can convert to. List types, on the other hand, represent any number of elements of the same type, and so are a good type to use if you want to conditionally decide on how many elements there will be, as is the case here.

With that said then, there is no way to write this so that the new expression would return a tuple type, but in this case it could in principle have been a list type in the original example, which would mean that addition the condition would not change the type:

output "test" {
  value = tolist(["first", "second"])
}

output "test" {
  value = true ? tolist(["first", "second"]) : tolist([])
}

[Nuru]

@apparentlymart This now seems to me a bigger problem.

In practice, of course, the output is not all constants, and the old value may not be a list. It might be a tuple, in which case the output now breaks:

output "test" {
  value = true ? ["first", { second = "second" }] : []
}

of course breaks with

The true and false result expressions must have consistent types

This would catch me by surprise, and is undesirable. The reason I don't use

output "test" {
  value = true ? ["first", { second = "second" }] : null
}

is because in the false case, null breaks length(module.example.test) (and also because, in a root module, the output does not show up in the results ((null outputs are suppressed)) ).

I would like a way to keep this conditional output a tuple.

[apparentlymart]

This issue is currently representing the fact that Terraform's rendering of output values is confusing in cases where the type has changed in a way where the new value renders the same as the old.

It sounds like you also want to talk about ways to make output values have different types depending on other data in the module. I would typically suggest thinking of output values as having static types in most cases, but since Terraform has a hybrid static/dynamic type system in order to ergonomically support working with JSON, so there are some ways to achieve it if you work a bit against the design of the language. If you want to talk more about that, let's do it in the community forum because it's more appropriate for this sort of unstructured discussion.

[Nuru]

It sounds like you also want to talk about ways to make output values have different types depending on other data in the module.

Really all I want here is the ability to preserve the output type of tuple while using a conditional. Personally I don't consider tuple(object, object) any more or less dynamic than list(object) but I confess I don't think about it that much or that deeply. At the moment, I do not want to participate in that discussion, so if you just tell me there is no way to keep the output a tuple with a length(), then we can leave it there and limit this issue to the plan output being clearer.