Iterate over top-level fields?

[cueckoo]

Originally opened by @shykes in cuelang/cue#457

Is there a way to iterate over top-level fields? For example:

foo: {
  a: "bla"
  b: "bla"
  c: "bla"
}

bar: "bla"

// I an iterate over the fields of `foo`...
for k, v in foo {}

// But I cannot iterate over the top-level.

[cueckoo]

Original reply by @grantzvolsky in cuelang/cue#457 (comment)

I haven't found a solution to the more general problem of safely (without the risk of clashes from outer scopes) referencing fields within the current block/struct. The spec mentions neither self nor this.

[cueckoo]

Original reply by @shykes in cuelang/cue#457 (comment)

Perhaps the language could support a special form of comprehension which omits the target? For example:

foo: {}
bar: "bla"

for k, v {
  // if `in ...` is omitted, iterate over the field of the current scope.
}

[cueckoo]

Original reply by @mpvl in cuelang/cue#457 (comment)

@shykes, that is an interesting idea.

Having something like self or this would also be in the realm of possibilities.

In general, having a reference to the top-level scope is dangerous and there hasn't been a good syntactic solution that seems like an obvious candidate.

One workaround for now could be to have a builtin that implements self. Deprecating a builtin is not as bad as deprecating a language feature, in case it turns out to be a bad idea.

[cueckoo]

Original reply by @grantzvolsky in cuelang/cue#457 (comment)

In hindsight, relative and absolute paths may be a more natural fit for cue, as well as more powerful. The example given by shykes could be either for k, v in . {} or for k, v in / {}. Another example:

a: {
  b: {
    a: "Hello \(../a)"
  }
  a: "World"
}

[cueckoo]

Original reply by @mpvl in cuelang/cue#457 (comment)

I've considered using a path syntax for CUE. It has its advantages. But in the end, the ambiguity of / makes it too awkward in the end. It also makes it slightly more prone for differences in shells when specified on the command line.

Also, the use of absolute paths often leads to misleading outcomes: as the reference by definition will start at root, it is impossible for such a reference to ever be made concrete. Using a relative reference for that same value will not have that issue. This issue is not limited to the use of absolute values though, and in the new evaluator I've started experimenting with reporting an error when using references in a context where they need to be concrete but never can be. This could perhaps be the key to allowing absolute references without the pitfalls. If this works out and becomes an option, $ is already reserved as a candidate to refer to the root of the file (JSON Path).

There are also other constructs to consider. GCL used up. In practice this turned out to be not quite that great though. Another solution is to allow aliases to be combined with self. This would allow the definition of, say, a Root declaration

Root=self

This has the same problems as absolute references, but requires more typing, making it nicer to use.

[cueckoo]

Original reply by @myitcv in cuelang/cue#457 (comment)

Some related discussion in cuelang/cue#380

Moving the definition you want to iterate over to another package and embedding that package is one solution. But slightly depends what you are trying to do?

[cueckoo]

Original reply by @myitcv in cuelang/cue#457 (comment)

Actually, you don't need another package as @rudolph9 just pointed out - too early!

[cueckoo]

Original reply by @rudolph9 in cuelang/cue#457 (comment)

You could use an alias:

let foo = {
	A: "B"
	C: "D"
}

foo
{for k, v in foo {"\(v)": k}}

:!cue eval %!
(MISSING)
A: "B"
B: "A"
C: "D"
D: "C"

!:cue version
cue version 7fcef8a9b6429c935340c94c40e429c79b8bee98 linux/amd64