specialize sequence/c for one-element sequences

this yields only a modest speed up and only when iterating
over long sequences, e.g. like in this program:

  #lang racket/base
  (require racket/sequence racket/contract/base)
  (define s (make-string 10000 #\a))
  (define str (contract (any/c . -> .  (sequence/c char?))
                        (λ (x) (in-string s))
                        'pos 'neg))
  (time
   (for ([x (in-range 100)])
     (for ([x (str 0)])
       (void))))

racket/collects/racket/sequence.rkt

@@ -202,6 +202,42 @@
      (define blame (blame-add-context orig-blame "an element of"))
      (define ps (for/list ([mk-proj (in-list elem/mk-projs)])
                   (mk-proj blame)))
+     (cond
+       [(and (= n-cs 1) (not min-count))
+        (define p (car ps))
+        (λ (seq neg-party)
+          (unless (sequence? seq)
+            (raise-blame-error
+             orig-blame #:missing-party neg-party seq
+             '(expected: "a sequence" given: "~e")
+             seq))
+          (define result-seq
+            (make-do-sequence
+             (lambda ()
+               (let*-values ([(more? next) (sequence-generate seq)])
+                 (values
+                  (lambda (idx)
+                    (call-with-values
+                     next
+                     (case-lambda
+                       [(elem)
+                        (p elem neg-party)]
+                       [elems
+                        (define n-elems (length elems))
+                        (raise-blame-error
+                         blame #:missing-party neg-party seq
+                         '(expected: "a sequence of ~a values" given: "~a values\n values: ~e")
+                         n-cs n-elems elems)])))
+                  add1
+                  0
+                  (lambda (idx) (more?))
+                  (lambda elems #t)
+                  (lambda (idx . elems) #t))))))
+          (cond
+            [(list? seq) (sequence->list result-seq)]
+            [(stream? seq) (sequence->stream result-seq)]
+            [else result-seq]))]
+       [else
         (λ (seq neg-party)
           (unless (sequence? seq)
             (raise-blame-error
@@ -246,7 +282,7 @@
           (cond
             [(list? seq) (sequence->list result-seq)]
             [(stream? seq) (sequence->stream result-seq)]
-         [else result-seq])))))
+            [else result-seq]))]))))
 
 
 ;; additional sequence constructors