From a134d0c0a3176d5928d76a0c8b4e86ede2ba8a9d Mon Sep 17 00:00:00 2001
From: Matthew Flatt <mflatt@racket-lang.org>
Date: Sun, 15 May 2016 17:44:46 -0600
Subject: [PATCH] racket/serialize: support keywords and regexp values

---
 .../scribblings/reference/serialization.scrbl  |  8 +++++---
 racket/collects/racket/private/serialize.rkt   | 18 +++++++++++++++++-
 racket/collects/racket/serialize.rkt           |  4 ++--
 3 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/pkgs/racket-doc/scribblings/reference/serialization.scrbl b/pkgs/racket-doc/scribblings/reference/serialization.scrbl
index 2962dc1db5..dc2e0f5f3c 100644
--- a/pkgs/racket-doc/scribblings/reference/serialization.scrbl
+++ b/pkgs/racket-doc/scribblings/reference/serialization.scrbl
@@ -42,8 +42,8 @@ The following kinds of values are serializable:
        or @racket[define-serializable-class*];}
 
  @item{@tech{booleans}, @tech{numbers}, @tech{characters}, @tech{interned} symbols,
-       @tech{unreadable symbols}, @tech{strings}, @tech{byte strings}, @tech{paths} (for a
-       specific convention), @|void-const|, and the empty list;}
+       @tech{unreadable symbols}, @tech{keywords}, @tech{strings}, @tech{byte strings}, @tech{paths} (for a
+       specific convention), @tech{regexp values}, @|void-const|, and the empty list;}
 
  @item{@tech{pairs}, @tech{mutable pairs}, @tech{vectors}, @tech{flvectors}, @tech{fxvectors},
        @tech{box}es, @tech{hash tables}, and @tech{sets};}
@@ -70,7 +70,9 @@ currently do not handle certain cyclic values that @racket[read] and
 @racket[write] can handle, such as @racket['@#,read[(open-input-string "#0=(#0#)")]].}
 
 See @racket[deserialize] for information on the format of serialized
-data.}
+data.
+
+@history[#:changed "6.5.0.4" @elem{Added keywords and regexp values as serializable}]}
 
 @; ----------------------------------------------------------------------
 
diff --git a/racket/collects/racket/private/serialize.rkt b/racket/collects/racket/private/serialize.rkt
index 0c18f2b8da..c5eac794f3 100644
--- a/racket/collects/racket/private/serialize.rkt
+++ b/racket/collects/racket/private/serialize.rkt
@@ -41,6 +41,9 @@
 	(and (symbol? v)
              (or (symbol-interned? v)
                  (eq? v (string->unreadable-symbol (symbol->string v)))))
+        (keyword? v)
+        (regexp? v)
+        (byte-regexp? v)
 	(string? v)
 	(path-for-some-system? v)
 	(bytes? v)
@@ -201,6 +204,7 @@
 	      (number? v)
 	      (char? v)
 	      (symbol? v)
+	      (keyword? v)
 	      (null? v)
 	      (void? v)
               (srcloc? v))
@@ -239,6 +243,8 @@
             (for-each loop (struct->list v))]
 	   [(or (string? v)
 		(bytes? v)
+                (regexp? v)
+                (byte-regexp? v)
 		(path-for-some-system? v))
 	    ;; No sub-structure
 	    (void)]
@@ -286,6 +292,9 @@
             (null? v)
             (string? v)
             (symbol? v)
+            (keyword? v)
+            (regexp? v)
+            (byte-regexp? v)
             (bytes? v))))
 
   (define (serialize-one v share check-share? mod-map mod-map-cache)
@@ -294,7 +303,8 @@
        [(or (boolean? v)
 	    (number? v)
 	    (char? v)
-	    (null? v))
+	    (null? v)
+            (keyword? v))
 	v]
        [(symbol? v)
         (if (symbol-interned? v)
@@ -309,6 +319,9 @@
 		 (bytes? v))
 	     (immutable? v))
 	v]
+       [(or (regexp? v)
+            (byte-regexp? v))
+        v]
        [(serializable-struct? v)
 	(let ([info (serializable-info v)])
 	  (cons (mod-to-id info mod-map mod-map-cache) 
@@ -492,6 +505,9 @@
 	    (number? v)
 	    (char? v)
 	    (symbol? v)
+            (keyword? v)
+            (regexp? v)
+            (byte-regexp? v)
 	    (null? v))
 	v]
        [(string? v)
diff --git a/racket/collects/racket/serialize.rkt b/racket/collects/racket/serialize.rkt
index 64f4658b65..2015a23c6c 100644
--- a/racket/collects/racket/serialize.rkt
+++ b/racket/collects/racket/serialize.rkt
@@ -176,12 +176,12 @@
                        (lambda (s)
                          #,@(if super-info
                                 (map (lambda (set get)
-                                       #`(#,set s0 (#,get s)))
+                                       #`((or #,set void) s0 (#,get s)))
                                      (list-ref super-info 4)
                                      (list-ref super-info 3))
                                 null)
                          #,@(map (lambda (getter setter)
-                                   #`(#,setter s0 (#,getter s)))
+                                   #`((or #,setter void) s0 (#,getter s)))
                                  getters
                                  setters)
                          (void))))))))