Slice generator #1927

foxtran · 2022-08-05T14:32:51Z

Here, I propose slices which are presented in QuickSort. The proposed syntax is closed to Fortran, Python, and Go slices (Obviously the list of languages could go on).

zygoloid

I like the idea of supporting both array slicing and forming integer ranges using the same form of expression.

I'd be interested in more discussion of the type of a slice generator expression and its representation. Given the support for unbounded slices, I assume slice generators are lazy, and don't form an array of indexes up-front?

Can they be used in for loops: for (n: i32 in 0:5), without creating an intermediary array? If so, it'd be useful for the proposal to mention that in some way.

zygoloid · 2022-08-08T22:44:58Z

proposals/p1927.md

+is the same as `::`. If `s` is negative, lower and upper bounds are replaces
+each other.


Suggested change

is the same as `::`. If `s` is negative, lower and upper bounds are replaces

each other.

is the same as `::`. If `s` is negative, lower and upper bounds replace each

other.

I'd like to check I'm following this properly: does this mean that the lower bound is b and the upper bound is a in that case, but that we always start with a and end with b, even when the step is negative? Or is the intent that (1:5:-1) starts at 5 and counts downwards?

proposals/p1927.md

zygoloid · 2022-08-08T22:47:17Z

proposals/p1927.md

+
+Slice as generator of array:
+```carbon
+  var array: auto = (1:5:2); // array = (1,3,5)


In this case, what happens if you omit a? What is the first element of (::-1)?

One possibility might be to add a symbolic constant end, so that the elements of (::-1) are end-1, end-2, end-3, .... It'd also be useful to be able to use this separately from slices, so that array[end-1] is the last element, much like Python's array[-1] but without the discontinuity problems near 0 and the extra branches.

(This is inspired by the C++ ranges-v3 library, which allows using end in this way.)

I'm agree with creating of end keyword. Probably, it would be better to create a new proposal for this keyword.

In this case, what happens if you omit a? What is the first element of (::-1)?

In the case of creating array: Round brackets and s may be omitted, a and b must be presented. I have updated this part and it should be clearer now.

zygoloid · 2022-08-08T22:50:18Z

proposals/p1927.md

+  var array: auto = (1:5:2); // array = (1,3,5)
+  var arrav: auto = 1:5:2; // arrav = (1,3,5)
+```
+Round brackets may be omitted.


It's probably going to be very important from a parsing ambiguity perspective that enclosing brackets (whether they're (...) or [...]) are required if either the first or last expression is omitted. For example:

// No obvious parsing problems here. var a: auto = (1:)-x; // This is ambiguous: (1:)-x, or 1:(-x)? // There might be an overloaded `-` that takes a slice and an `X`, // and `-x` might be valid as the end of a slice. var b: auto = 1:-x;

Now, the proposal says that lower and upper limits should be mentioned.

zygoloid · 2022-08-08T22:53:40Z

proposals/p1927.md

+Slice syntax is `a:b:s`. Here, `a` is the beginning of slice, `b` is the end of
+slice and `s` is the step in slice. In array indexing, `:s` can be omitted, then


Is b included or excluded? The examples below suggest it's included -- eg, (1:5:2) includes 5 -- but for example in Python and Rust it's excluded, and Swift provides two operators for closed and half-open ranges. I'd like to see the proposal discuss this question; maybe closed ranges are the right answer, but given that we presumably will use 0-based indexing by default, half-open ranges seem likely to fit better in that context.

b is included. For having something like half-open range, I think that end keyword proposed by you is fine.

zygoloid · 2022-08-08T23:12:26Z

proposals/p1927.md

+  var array: auto = (1:5:2); // array = (1,3,5)
+  var arrav: auto = 1:5:2; // arrav = (1,3,5)
+```
+Round brackets may be omitted.


What is the precedence of the : / :: operator? For example:

// Is this `(1:N) - 1`, or `1:(N - 1)`, or an error? var x: auto = 1:N - 1;

See line 54 of current version. Anyway, it should be the lowest of them for avoiding brackets while ranging in array like array[1:N-1].

jonmeow · 2022-08-12T18:08:14Z

This hadn't explicitly been marked as an rfc, but given it's been tagged as ready for review, I'm adding the label. See #1898 for context.

proposals/p1927.md

geoffromer · 2022-08-15T20:31:25Z

proposals/p1927.md

+    -   Here, there is a problem with interacting with std::span/std::mdspan
+        comes from C++.
+
+## Alternatives considered


I think it's important to consider the alternative of having this feature be provided by the library, with no special core-language syntax for it.

geoffromer · 2022-08-15T20:33:46Z

proposals/p1927.md

+
+`:` has the lowest priority for making possible `a[1:N-1]` without any brackets.
+
+Slice generator may return `i32`, `i64`, `i128` and unsigned versions of them.


Can user-defined types be customized to work with this syntax? If so, how does that customization work? See also #1885.

zygoloid · 2022-09-14T20:18:34Z

proposals/p1927.md

+    -   Here, there is a problem with interacting with std::span/std::mdspan
+        comes from C++.
+
+## Alternatives considered


Please talk about the alternative of using half-open ranges rather than closed ranges here. This seems like a significant divergence from what I think at least C++ and Python programmers would expect, so if it's the right choice then we need rationale for that.

zygoloid · 2022-09-14T20:22:58Z

proposals/p1927.md

+is the same as `::`. If `s` is negative and `a` or `b` or both are skipped,
+instead of `a`, upper bound is and, instead of `b`, lower bound is. Slice has


I don't understand this sentence. I think what you mean is that if s is negative, then if a is omitted the slice starts from the end of the array, and if b is omitted then the slice ends at the start of the array. Is that right?

zygoloid · 2022-09-14T20:29:32Z

proposals/p1927.md

+  var array2: auto = (1:5); // array1 = (1,2,3,4,5)
+```
+
+Round brackets, `a`, and `b` must be presented, `s` may be omitted,


Hm, I think this syntax is still problematic. It doesn't look like we can disambiguate between this and a binding in a pattern:

fn F(a: i32, b: i32) { match ((1:2)) { case (a:b) => { ... } } } // vs fn G(b:! Type, n: b) { match (n) { case (a:b) => { ... } } }

We could maybe use a named constructor, eg Slice(a, b, s) for the unusual case of constructing a slice anywhere other than in [], and specify x[a:b:s] as desugaring to x[Slice(a,b,s)].

zygoloid · 2022-09-14T20:30:37Z

proposals/p1927.md

+
+## Background
+
+There is no requirements for background.


It would be useful to describe what other languages do in this space here.

zygoloid · 2022-09-14T20:34:33Z

proposals/p1927.md

+In operator `[]` of array, slices can be used in the following ways:
+
+```
+  var array: auto = (1:5:2); // array = (1,3,5)


This seems likely to be an efficiency surprise. As with python's range, I think we'll want a slice generator to lazily produce the elements of the slice. Having a conversion from slice generator to array seems like it might be reasonable, but only if the developer somehow asks for it (eg, by writing an array type).

github-actions · 2022-12-14T02:03:40Z

We triage inactive PRs and issues in order to make it easier to find active work. If this PR should remain active, please comment or remove the inactive label.
This PR is labeled inactive because the last activity was over 90 days ago. This PR will be closed and archived after 14 additional days without activity.

github-actions · 2022-12-29T01:59:24Z

We triage inactive PRs and issues in order to make it easier to find active work. If this PR should remain active or becomes active again, please reopen it.
This PR was closed and archived because there has been no new activity in the 14 days since the inactive label was added.

foxtran force-pushed the proposal-slice-generator branch from 597d662 to 5aa6015 Compare August 5, 2022 14:33

Slice generator

2bb2796

foxtran force-pushed the proposal-slice-generator branch from 5aa6015 to 2bb2796 Compare August 5, 2022 15:38

foxtran marked this pull request as ready for review August 5, 2022 15:46

foxtran mentioned this pull request Aug 5, 2022

Multidimensional arrays #1839

Closed

foxtran requested a review from a team August 6, 2022 17:17

foxtran added the proposal A proposal label Aug 6, 2022

foxtran mentioned this pull request Aug 7, 2022

Arrays #1928

Closed

zygoloid reviewed Aug 8, 2022

View reviewed changes

jonmeow added the proposal rfc Proposal with request-for-comment sent out label Aug 12, 2022

jonmeow reviewed Aug 12, 2022

View reviewed changes

proposals/p1927.md Show resolved Hide resolved

jonmeow mentioned this pull request Aug 12, 2022

Vector operations #1937

Closed

Update proposal

4af3c62

geoffromer reviewed Aug 15, 2022

View reviewed changes

zygoloid reviewed Sep 14, 2022

View reviewed changes

github-actions bot added the inactive Issues and PRs which have been inactive for at least 90 days. label Dec 14, 2022

github-actions bot closed this Dec 29, 2022

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Slice generator #1927

Slice generator #1927

foxtran commented Aug 5, 2022 •

edited

Loading

zygoloid left a comment •

edited

Loading

zygoloid Aug 8, 2022 •

edited

Loading

zygoloid Aug 8, 2022

zygoloid Aug 8, 2022

foxtran Aug 13, 2022

foxtran Aug 13, 2022

zygoloid Aug 8, 2022

foxtran Aug 13, 2022

zygoloid Aug 8, 2022

foxtran Aug 13, 2022

zygoloid Aug 8, 2022

foxtran Aug 13, 2022

jonmeow commented Aug 12, 2022

geoffromer Aug 15, 2022

geoffromer Aug 15, 2022

zygoloid Sep 14, 2022

zygoloid Sep 14, 2022

zygoloid Sep 14, 2022

zygoloid Sep 14, 2022

zygoloid Sep 14, 2022

github-actions bot commented Dec 14, 2022

github-actions bot commented Dec 29, 2022

		is the same as `::`. If `s` is negative, lower and upper bounds are replaces
		each other.

		Slice syntax is `a:b:s`. Here, `a` is the beginning of slice, `b` is the end of
		slice and `s` is the step in slice. In array indexing, `:s` can be omitted, then


		`:` has the lowest priority for making possible `a[1:N-1]` without any brackets.

		Slice generator may return `i32`, `i64`, `i128` and unsigned versions of them.

		is the same as `::`. If `s` is negative and `a` or `b` or both are skipped,
		instead of `a`, upper bound is and, instead of `b`, lower bound is. Slice has

Slice generator #1927

Slice generator #1927

Conversation

foxtran commented Aug 5, 2022 • edited Loading

zygoloid left a comment • edited Loading

Choose a reason for hiding this comment

zygoloid Aug 8, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jonmeow commented Aug 12, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

github-actions bot commented Dec 14, 2022

github-actions bot commented Dec 29, 2022

foxtran commented Aug 5, 2022 •

edited

Loading

zygoloid left a comment •

edited

Loading

zygoloid Aug 8, 2022 •

edited

Loading