From 3e9f23a2c8f42e7a7b9a9a024b43e6ea52f88357 Mon Sep 17 00:00:00 2001
From: Robby Findler <robby@racket-lang.org>
Date: Wed, 26 Nov 2014 11:35:26 -0600
Subject: [PATCH] fix enum printer for small enumerations

---
 .../data-enumerate-lib/data/enumerate.rkt     | 65 ++++++++++---------
 .../data-test/tests/data/enumerate.rkt        |  1 +
 2 files changed, 37 insertions(+), 29 deletions(-)

diff --git a/pkgs/data-pkgs/data-enumerate-lib/data/enumerate.rkt b/pkgs/data-pkgs/data-enumerate-lib/data/enumerate.rkt
index 2bc4cd4a63..13e3a69f9b 100644
--- a/pkgs/data-pkgs/data-enumerate-lib/data/enumerate.rkt
+++ b/pkgs/data-pkgs/data-enumerate-lib/data/enumerate.rkt
@@ -205,38 +205,45 @@
          [(#f) display]
          [else (lambda (p port) (print p port mode))]))
      (display "#<enum" port)
-     (parameterize ([enum-printing (+ (enum-printing) 1)])
-       (let loop ([i 0] [chars 0])
-         ;; chars is an approximation on how much
-         ;; we've printed so far.
-         (when (<= chars 20)
-           (define ele (from-nat enum i))
-           (define sp (open-output-string))
-           (recur ele sp)
-           (define s (get-output-string sp))
+     (define the-size (enum-size enum))
+     (define more-to-go?
+       (parameterize ([enum-printing (+ (enum-printing) 1)])
+         (let loop ([i 0] [chars 0])
+           ;; chars is an approximation on how much
+           ;; we've printed so far.
            (cond
-             [(equal? s "")
-              ;; if any enumeration values print as empty 
-              ;; strings, then we just give up so as to avoid
-              ;; 'i' never incrementing and never terminating
-              (display ">" port)]
-             [else
-              (if (zero? i)
-                  (display ": " port)
-                  (display " " port))
-              
-              ;; only print twice up to depth 2 in order to avoid bad
-              ;; algorithmic behavior (so enumerations of enumerations
-              ;; of enumerations might look less beautiful in drracket)
+             [(not (< i the-size)) #f]
+             [(<= chars 20)
+              (define ele (from-nat enum i))
+              (define sp (open-output-string))
+              (recur ele sp)
+              (define s (get-output-string sp))
               (cond
-                [(<= (enum-printing) 2)
-                 (display s port)]
+                [(equal? s "")
+                 ;; if any enumeration values print as empty 
+                 ;; strings, then we just give up so as to avoid
+                 ;; 'i' never incrementing and never terminating
+                 #t]
                 [else
-                 (recur ele port)])
-              
-              (loop (+ i 1)
-                    (+ chars (string-length s) 1))]))))
-     (display "...>" port))])
+                 (if (zero? i)
+                     (display ": " port)
+                     (display " " port))
+                 
+                 ;; only print twice up to depth 2 in order to avoid bad
+                 ;; algorithmic behavior (so enumerations of enumerations
+                 ;; of enumerations might look less beautiful in drracket)
+                 (cond
+                   [(<= (enum-printing) 2)
+                    (display s port)]
+                   [else
+                    (recur ele port)])
+                 
+                 (loop (+ i 1)
+                       (+ chars (string-length s) 1))])]
+             [else #t]))))
+     (if more-to-go?
+         (display "...>" port)
+         (display ">" port)))])
 
 ;; size : enum a -> Nat or +Inf
 (define (size e)
diff --git a/pkgs/data-pkgs/data-test/tests/data/enumerate.rkt b/pkgs/data-pkgs/data-test/tests/data/enumerate.rkt
index 7f01090e05..5d5823d250 100644
--- a/pkgs/data-pkgs/data-test/tests/data/enumerate.rkt
+++ b/pkgs/data-pkgs/data-test/tests/data/enumerate.rkt
@@ -468,6 +468,7 @@
 (check-equal? (to-str nat/e #t) "#<enum: 0 1 2 3 4 5 6 7 8 9 10...>")
 (check-equal? (to-str (cons/e nat/e nat/e) #t) "#<enum: '(0 . 0) '(0 . 1) '(1 . 0)...>")
 (check-equal? (to-str (cons/e nat/e nat/e) #f) "#<enum: (0 . 0) (0 . 1) (1 . 0)...>")
+(check-equal? (to-str (const/e 0) #t) "#<enum: 0>")
 
 ;; just check that it doesn't crash when we get deep nesting
 ;; (checks that we end up in the case that just uses the string