cue-lang/cue v0.18.0-alpha.2

on GitHub

Changes which may break some users are marked below with: ⚠️

Language

As a reminder, the try experiment and the shortcircuit experiment introduced in v0.17.0 are both still ongoing. Please give them a try and report any issues or feedback!

⚠️ Strict embedding and the ... operator

The explicitopen experiment, ongoing since v0.15.0, is now stable: from language version v0.18.0 on, embedding is strict and needs no opt-in. A struct which embeds a closed value is now closed to that value's fields, where before the embedding constrained only itself and left its sibling fields alone, and a comprehension's conjunct closes its struct just like any other conjunct. The new postfix ... operator opens an embedded value again, so #A... embeds #A without closing the struct around it.

#A: {a: int}

x: {
	#A     // x is now closed to #A's fields
	b: 1   // error: field not allowed
}
y: {
	#A...  // spread leaves y open
	b: 1
}

Migrate a module by running cue fix --exp=explicitopen while it is still at an older language version, and only then raise language.version in cue.mod/module.cue: a file at v0.18.0 or later has no way back, as an @experiment attribute can only enable an experiment. See the how-to guide and the proposal for the full design.

⚠️ Postfix aliases and self

The aliasv2 experiment, also ongoing since v0.15.0, is now stable: from language version v0.18.0 on, the postfix alias syntax and the predeclared self identifier need no opt-in, and the old prefix syntax is no longer accepted.

x~(X):          {a: 1, b: X.a} // was x: X={a: 1, b: X.a}
[string]~(K,_): {name: K}      // was [K=string]: {name: K}

// A value alias becomes a let binding on self.
y: {
	let Y = self
	c: 2
	d: Y.c // was y: Y={c: 2, d: Y.c}
}

As above, run cue fix --exp=aliasv2 to rewrite the prefix form before the module moves to v0.18.0; cue fix --exp=explicitopen,aliasv2 applies both of this release's migrations in one pass. See the how-to guide and the proposal.

The new functions experiment

This release introduces the functions experiment, which adds function literals, function types, and calls to the language. A function literal declares its parameters, may constrain its result with ->, and defines its body after the final :; a call supplies arguments by position or by label. Functions are values: they unify with themselves and with function types, they capture the scope they are declared in, and they may be applied partially.

You can try this experiment on a module at language version v0.18.0 via the @experiment(functions) file attribute:

@experiment(functions)

add:   func(a: int, b: int) -> int: a + b
scale: func(x: int) -> int: x * 2
out:   add(1, scale(3)) // 7

A literal without a body denotes a function type, which constrains a function value in the same way a schema constrains a struct. See the proposal discussion for the full design, including parameter forms, contract labels, and partial application.

Evaluator

Fix a recursive disjunction wrapped in a struct dropping disjuncts and growing exponentially in cost (#4475), and a definition whose body compares the definition itself against _|_ overflowing the stack (#4176).

Further bugs causing spurious errors have been fixed: let bindings referring to their enclosing scope could still misresolve or fail as cyclic in some cases (#4474, #4478), and a struct literal embedding a self-referencing scalar reported a structural cycle (#4479). Thank you to all who reported these.

A comprehension now runs after the sibling conjuncts whose values it reads, rather than in declaration order, so a configuration which resolved only when its fields happened to be written in the right order now resolves either way (#4098).

== and != now compare integers and floats numerically wherever they appear, so {a: 1.0} == {a: 1} and [1.0] == [1] are true, matching how 1.0 == 1 already behaved at the top level (#4120). cue.Value.Equals and list.Contains change in the same way.

Error reporting is more precise in two further ways. An error about a field which was closed off by an earlier comprehension or reference cycle now points at the declaration responsible for it (#2615). Failing disjuncts which report different errors at the same position are no longer collapsed into one, so all of the reasons a disjunction failed are shown (#4477).

cmd/cue

cue cmd now unifies data files named on the command line with the loaded package, as the other commands do and as cue help inputs documents, so tool files can finally see that data (#4473).

-e expressions are now parsed and compiled at the language version of the module they are evaluated against, so they may use the features which are stable there, such as self to select a field whose name is not an identifier (#358, #4297).

tool/http.Do gains a timeout field and now aborts when its task is canceled (#4467), and tls.caCert accepts the CERTIFICATE PEM blocks which certificate authorities hand out rather than only PUBLIC KEY blocks, reporting an error instead of trusting nothing when it yields no certificates (#4468).

tool/http.Serve no longer crashes the whole cue cmd process on an out-of-range statusCode, and writes nothing until the entire response is known (#4465).

Modules

Each module's files are now parsed at the language version that module declares, rather than at the main module's version, so a module which has moved to v0.18.0 can still depend on packages written for an older version of CUE.

An HTTP failure from a module registry, such as a rate limit, is now reported as such instead of as an opaque decoding error (#3696).

A module version is now downloaded at most once per process, which avoids redundant fetches and the "Access is denied" failures seen on Windows when two fetches of the same version overlapped (#3413).

LSP server

Standard library imports now resolve, so strings, list, and the rest offer completion and hover like any other package, and builtin functions show their signature rather than an opaque _.

Organize Imports now groups imports the way goimports does, preserving the groups written in the source and sorting standard library imports ahead of module imports within each group, and leaves the buffer alone when it does not parse cleanly.

Doc comments are now surfaced on comprehensions, let declarations, embeddings, list elements, and call arguments, and completion no longer fires in places where no identifier can go, such as inside attributes and import specs.

The language server now also reloads the packages which import a module that has gone away, and fixes further panics and cache staleness bugs.

As always, the language server is under active development: please report any bugs or missing features you encounter via the Issue tracker or via the #lsp channels on Discord or Slack. See our Getting Started wiki page for instructions on how to set it up with your editor.

Encodings

The JSON Schema encoder gains two further generation improvements: list.MinItems for the minItems keyword, and positional item schemas encoded by index (#3485).

The JSON Schema decoder now gives every decoded constant the position it came from, so an error against one member of an enum points at that member rather than at the keyword (#4477).

Go API

The new cue/ast.Clone function copies a syntax tree, including its comments and its resolved references, so a tree can be rewritten without disturbing the original.

cue/format exposes the knobs of the new formatter: its new Indent, IndentWidth and LineWidth options control the indentation string, its visual width, and the target line width, and its new Compact option renders a value on a single line. UseSpaces and TabIndent are deprecated in favor of Indent and IndentWidth; go fix migrates uses of UseSpaces.

Inlining imports, via cue def --inline-imports or cue.InlineImports, now handles let declarations and values which have been unified or merged with data files, rather than emitting unresolved references (#2252, #2495, #3484).

A failed lookup of a hidden field now names the package scope it searched, and the scopes under which a field of that name does exist, instead of reporting it as simply absent (#2561).