fixing issue #21, allow only [a,b,...] and [a b;c d] syntaxes for arrays

Author: JeffBezanson

src/julia-parser.scm

@@ -703,50 +703,78 @@
        ranges))
 
 ; parse [] concatenation expressions and {} cell expressions
-(define (parse-cat s closer)
-  (with-normal-ops
-   (with-space-sensitive
-    (parse-cat- s closer))))
-(define (parse-cat- s closer)
+(define (parse-vcat s first closer)
+  (let loop ((lst '())
+	     (nxt first))
+    (let ((t (require-token s)))
+      (if (eqv? t closer)
+	  (begin (take-token s)
+		 (cons 'vcat (reverse (cons nxt lst))))
+	  (case t
+	    ((#\,)
+	     (take-token s)
+	     (if (eqv? (require-token s) closer)
+		 ;; allow ending with ,
+		 (begin (take-token s)
+			(cons 'vcat (reverse (cons nxt lst))))
+		 (loop (cons nxt lst) (parse-eq* s))))
+	    ((#\;)
+	     (error "unexpected semicolon in array expression"))
+	    ((#\] #\})
+	     (error (string "unexpected " t)))
+	    (else
+	     (error "missing separator in array expression")))))))
+
+(define (parse-matrix s first closer)
   (define (fix head v) (cons head (reverse v)))
-  (let loop ((vec '())
-	     (outer '())
-	     (first #t))
-    (let ((update-outer (lambda (v)
-			  (cond ((null? v)       outer)
-				((null? (cdr v)) (cons (car v) outer))
-				(else            (cons (fix 'hcat v) outer))))))
-      (if (eqv? (require-token s) closer)
+  (define (update-outer v outer)
+    (cond ((null? v)       outer)
+	  ((null? (cdr v)) (cons (car v) outer))
+	  (else            (cons (fix 'hcat v) outer))))
+  (let loop ((vec   (list first))
+	     (outer '()))
+    (let ((t  (if (eqv? (peek-token s) #\newline)
+		  #\newline
+		  (require-token s))))
+      (if (eqv? t closer)
 	  (begin (take-token s)
 		 (if (pair? outer)
-		     (fix 'vcat (update-outer vec))
+		     (fix 'vcat (update-outer vec outer))
 		     (if (or (null? vec) (null? (cdr vec)))
 			 (fix 'vcat vec)    ; [x]   => (vcat x)
-			 (fix 'hcat vec)))) ; [x,y] => (hcat x y)
-	  (let ((nv (cons (if first
-			      (without-bitor (parse-eq* s))
-			      (parse-eq* s))
-			  vec)))
-	    (case (if (eqv? (peek-token s) #\newline)
-		      #\newline
-		      (require-token s))
-	      ((#\]) (if (eqv? closer #\])
-			 (loop nv outer #f)
-			 (error "unexpected ]")))
-	      ((#\}) (if (eqv? closer #\})
-			 (loop nv outer #f)
-			 (error "unexpected }")))
-	      ((|\||)
-	       (begin (take-token s)
-		      (let ((r (parse-comma-separated-assignments s)))
-			(if (not (eqv? (require-token s) closer))
-			    (error (string "expected " closer))
-			    (take-token s))
-			`(comprehension ,(car nv) ,@(colons-to-ranges r)))))
-	      ((#\, #\; #\newline)
-	       (begin (take-token s) (loop '() (update-outer nv) #f)))
-	      (else
-	       (begin (loop nv outer #f)))))))))
+			 (fix 'hcat vec)))) ; [x y] => (hcat x y)
+	  (case t
+	    ((#\; #\newline)
+	     (take-token s) (loop '() (update-outer vec outer)))
+	    ((#\,)
+	     (error "unexpected comma in matrix expression"))
+	    ((#\] #\})
+	     (error (string "unexpected " t)))
+	    (else
+	     (loop (cons (parse-eq* s) vec) outer)))))))
+
+(define (parse-cat s closer)
+  (with-normal-ops
+   (with-space-sensitive
+    (parse-cat- s closer))))
+(define (parse-cat- s closer)
+  (if (eqv? (require-token s) closer)
+      (begin (take-token s)
+	     (list 'vcat))  ; [] => (vcat)
+      (let ((first (without-bitor (parse-eq* s))))
+	(case (peek-token s)
+	  ;; dispatch to array syntax, comprehension, or matrix syntax
+	  ((#\,)
+	   (parse-vcat s first closer))
+	  ((|\||)
+	   (take-token s)
+	   (let ((r (parse-comma-separated-assignments s)))
+	     (if (not (eqv? (require-token s) closer))
+		 (error (string "expected " closer))
+		 (take-token s))
+	     `(comprehension ,first ,@(colons-to-ranges r))))
+	  (else
+	   (parse-matrix s first closer))))))
 
 ; for sequenced evaluation inside expressions: e.g. (a;b, c;d)
 (define (parse-stmts-within-expr s)

test/perf.j

@@ -115,7 +115,7 @@ function randmatstat(t)
         c = randn(n, n)
         d = randn(n, n)
         P = [a b c d]
-        Q = [a b, c d]
+        Q = [a b; c d]
         v[i] = trace((P.'*P)^4)
         w[i] = trace((Q.'*Q)^4)
     end

test/tests.j

@@ -713,8 +713,8 @@ glotest()
 X = [ i+2j | i=1:5, j=1:5 ]
 @assert X[2,3] == 8
 @assert X[4,5] == 14
-@assert ones(2,3) * ones(2,3)' == [3. 3., 3. 3.]
-@assert [ [1,2] | i=1:2, : ] == [1 2, 1 2]
+@assert ones(2,3) * ones(2,3)' == [3. 3.; 3. 3.]
+@assert [ [1,2] | i=1:2, : ] == [1 2; 1 2]
 # where element type is a Union. try to confuse type inference.
 foo32_64(x) = (x<2) ? int32(x) : int64(x)
 boo32_64() = [ foo32_64(i) | i=1:2 ]
@@ -723,8 +723,8 @@ let a36 = boo32_64()
 end
 
 # concatenation
-@assert [ones(2,2)  2*ones(2,1)] == [1 1 2, 1 1 2]
-@assert [ones(2,2), 2*ones(1,2)] == [1 1, 1 1, 2 2]
+@assert [ones(2,2)  2*ones(2,1)] == [1 1 2; 1 1 2]
+@assert [ones(2,2), 2*ones(1,2)] == [1 1; 1 1; 2 2]
 
 # "end"
 X = [ i+2j | i=1:5, j=1:5 ]