cue: remove block comments and slices from the language
Block comments serve little purpose now embeddings
can uncomment large blocks. They also add quite a bit
of complexity.
Slices at the bytes and string level proved too confusing
and generally a bad idea for a data constraint language.
Using them only for lists hurts orthoganality and makes
them add too much baggage for their use, including
a fairly complicated interaction with default values.
Issue #87
Change-Id: I25cdd9b060f6515f2f50ff12e2b67d58625a724c
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/3244
Reviewed-by: Jonathan Amsterdam <jba@google.com>
diff --git a/doc/ref/spec.md b/doc/ref/spec.md
index 4945ffa..d8849be 100644
--- a/doc/ref/spec.md
+++ b/doc/ref/spec.md
@@ -135,14 +135,12 @@
## Lexical elements
### Comments
-Comments serve as program documentation. There are two forms:
+Comments serve as program documentation.
+CUE supports line comments that start with the character sequence //
+and stop at the end of the line.
-1. Line comments start with the character sequence // and stop at the end of the line.
-2. General comments start with the character sequence /* and stop with the first subsequent character sequence */.
-
-A comment cannot start inside string literal or inside a comment.
-A general comment containing no newlines acts like a space.
-Any other comment acts like a newline.
+A comment cannot start inside a string literal or inside a comment.
+A comment acts like a newline.
### Tokens
@@ -2014,76 +2012,6 @@
v: x[i] (x[i], 4)
```
-
-### Slice expressions
-
-<!-- TODO: consider removing slices alltogether
-Slice is or marginal utility in CUE. Also, it may be that we will use
-other notations to achieve the same.
-
-For now it seems saver to remove and provide slicing as builtins instead:
-
- list.Slice()
- strings.Runes().Slice() // slice by rune
- strings.Characters().Slice() // slice by character
- bytes.Slice() // slice by bytes
--->
-
-Slice expressions construct a slice from a list value.
-
-The primary expression
-```
-a[low : high]
-```
-constructs a slice.
-The indices `low` and `high` must be concrete integers and select
-which elements of operand `a` appear in the result.
-The result has indices starting at 0 and length equal to `high` - `low`.
-After slicing the list `a`
-<!-- TODO(jba): how does slicing open lists work? -->
-
-<!-- TODO: consider this.
-For `a` is a disjunction of the form `a1 | ... | an`, then the result is
-`a1[low:high] | ... | an[low:high]` observing the above rules.
--->
-```
-a := [1, 2, 3, 4, 5]
-s := a[1:4]
-```
-the list s has length 3 and elements
-```
-s[0] == 2
-s[1] == 3
-s[2] == 4
-```
-For convenience, any of the indices may be omitted.
-A missing `low` index defaults to zero; a missing `high` index defaults
-to the length of the sliced operand:
-```
-a[2:] // same as a[2 : len(a)]
-a[:3] // same as a[0 : 3]
-a[:] // same as a[0 : len(a)]
-```
-
-Indices are in range if `0 <= low <= high <= len(a)`,
-otherwise they are out of range.
-
-Both the slice operand and the slice indices may be associated with a default.
-
-<!--
-```
-va[vs:ve] => va[vs:ve]
-va[vs:(ve, de)] => (va[vs:ve], va[vs:de])
-va[(vs, ds):ve] => (va[vs:ve], va[ds:ve])
-va[(vs, ds):(ve, de)] => (va[vs:ve], va[ds:de])
-(va, da)[vs:ve] => (va[vs:ve], da[vs:ve])
-(va, da)[vs:(ve, de)] => (va[vs:ve], da[vs:de])
-(va, da)[(vs, ds):ve] => (va[vs:ve], da[ds:ve])
-(va, da)[(vs, ds):(ve, de)] => (va[vs:ve], da[ds:de])
-```
--->
-
-
### Operators
Operators combine operands into expressions.
