From ca991758856103f4ceb32a78e15d1b2c06239ea4 Mon Sep 17 00:00:00 2001 From: Matt Bauman Date: Sat, 7 Mar 2015 10:23:11 -0500 Subject: [PATCH] Remove special syntax for `:` in indexing `[]` Add news and a minor documentation update. --- NEWS.md | 6 ++++++ doc/manual/arrays.rst | 16 +++++++++------- src/julia-syntax.scm | 41 ++++++++--------------------------------- 3 files changed, 23 insertions(+), 40 deletions(-) diff --git a/NEWS.md b/NEWS.md index 155e4e384f804..565ed28438282 100644 --- a/NEWS.md +++ b/NEWS.md @@ -114,6 +114,11 @@ Language changes macro. Instead, the string is first unindented and then `x_str` is invoked, as if the string had been single-quoted ([#10228]). + * Colons (`:`) within indexing expressions are no longer lowered to the range + `1:end`. Instead, the `:` identifier is passed directly. Custom array types + that implement `getindex` or `setindex!` methods must also extend those + methods to support arguments of type `Colon` ([#10331]). + Command line option changes --------------------------- @@ -1422,6 +1427,7 @@ Too numerous to mention. [#10180]: https://github.com/JuliaLang/julia/issues/10180 [#10228]: https://github.com/JuliaLang/julia/issues/10228 [#10328]: https://github.com/JuliaLang/julia/issues/10328 +[#10331]: https://github.com/JuliaLang/julia/issues/10331 [#10332]: https://github.com/JuliaLang/julia/issues/10332 [#10333]: https://github.com/JuliaLang/julia/issues/10333 [#10380]: https://github.com/JuliaLang/julia/issues/10380 diff --git a/doc/manual/arrays.rst b/doc/manual/arrays.rst index 5a0c79d1a1487..2c571e7df46ee 100644 --- a/doc/manual/arrays.rst +++ b/doc/manual/arrays.rst @@ -222,9 +222,10 @@ The general syntax for indexing into an n-dimensional array A is:: where each ``I_k`` may be: 1. A scalar integer -2. A ``Range`` of the form ``:``, ``a:b``, or ``a:b:c`` -3. An arbitrary integer vector, including the empty vector ``[]`` -4. A boolean vector +2. A ``Range`` of the form ``a:b``, or ``a:b:c`` +3. A ``:`` or ``Colon()`` to select entire dimensions +4. An arbitrary integer vector, including the empty vector ``[]`` +5. A boolean vector The result ``X`` generally has dimensions ``(length(I_1), length(I_2), ..., length(I_n))``, with location @@ -286,10 +287,11 @@ The general syntax for assigning values in an n-dimensional array A is:: where each ``I_k`` may be: -1. A scalar value -2. A ``Range`` of the form ``:``, ``a:b``, or ``a:b:c`` -3. An arbitrary integer vector, including the empty vector ``[]`` -4. A boolean vector +1. A scalar integer +2. A ``Range`` of the form ``a:b``, or ``a:b:c`` +3. A ``:`` or ``Colon()`` to select entire dimensions +4. An arbitrary integer vector, including the empty vector ``[]`` +5. A boolean vector If ``X`` is an array, its size must be ``(length(I_1), length(I_2), ..., length(I_n))``, and the value in location ``i_1, i_2, ..., i_n`` of ``A`` is overwritten with diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm index 87536bf7f69f9..5d72708c3af0f 100644 --- a/src/julia-syntax.scm +++ b/src/julia-syntax.scm @@ -301,18 +301,17 @@ (define (expand-compare-chain e) (car (expand-vector-compare e))) -;; last = is this last index? +;; return the appropriate computation for an `end` symbol for indexing +;; the array `a` in the `n`th index. +;; `tuples` are a list of the splatted arguments that precede index `n` +;; `last` = is this last index? +;; returns a call to endof(a), trailingsize(a,n), or size(a,n) (define (end-val a n tuples last) (if (null? tuples) (if last (if (= n 1) `(call (top endof) ,a) `(call (top trailingsize) ,a ,n)) - #;`(call (top div) - (call (top length) ,a) - (call (top *) - ,@(map (lambda (d) `(call (top size) ,a ,(1+ d))) - (iota (- n 1))))) `(call (top size) ,a ,n)) (let ((dimno `(call (top +) ,(- n (length tuples)) ,.(map (lambda (t) `(call (top length) ,t)) @@ -321,8 +320,7 @@ `(call (top trailingsize) ,a ,dimno) `(call (top size) ,a ,dimno))))) -; replace end inside ex with (call (top size) a n) -; affects only the closest ref expression, so doesn't go inside nested refs +; replace `end` for the closest ref expression, so doesn't go inside nested refs (define (replace-end ex a n tuples last) (cond ((eq? ex 'end) (end-val a n tuples last)) ((or (atom? ex) (quoted? ex)) ex) @@ -335,29 +333,7 @@ (map (lambda (x) (replace-end x a n tuples last)) (cdr ex)))))) -; translate index x from colons to ranges -(define (expand-index-colon x) - (cond ((eq? x ':) `(call colon 1 end)) - ((and (pair? x) - (eq? (car x) ':)) - (cond ((length= x 3) - (if (eq? (caddr x) ':) - ;; (: a :) a: - `(call colon ,(cadr x) end) - ;; (: a b) - `(call colon ,(cadr x) ,(caddr x)))) - ((length= x 4) - (if (eq? (cadddr x) ':) - ;; (: a b :) a:b: - `(call colon ,(cadr x) ,(caddr x) end) - ;; (: a b c) - `(call colon ,@(cdr x)))) - (else x))) - (else x))) - -;; : inside indexing means 1:end -;; expand end to size(a,n), -;; or div(length(a), prod(size(a)[1:(n-1)])) for the last index +;; go through indices and replace the `end` symbol ;; a = array being indexed, i = list of indexes ;; returns (values index-list stmts) where stmts are statements that need ;; to execute first. @@ -386,8 +362,7 @@ (cons `(... ,g) ret)))) (loop (cdr lst) (+ n 1) stmts tuples - (cons (replace-end (expand-index-colon idx) a n tuples last) - ret))))))) + (cons (replace-end idx a n tuples last) ret))))))) (define (make-decl n t) `(|::| ,n ,t))