<div dir="ltr"><div>FWIW, </div>Here is what I've been doing in TR with regard to #:prefab struct: as a mechanism for ser/de-ser. Notice the cast to the struct: type after deserialization from a string. Of course the #:prefab struct: definition must be in both client and server code and the definitions in sync. #lang typed/racket/base (provide deserialize-struct-from-string serialize-struct-to-string) ;; Open question here on what is best approach for serialization of struct: lot's of APIs in R. ;; For now simple. This assumes the structure is prefab or equivalent. (define-syntax deserialize-struct-from-string (syntax-rules () ((_ str type) (let ((sin (open-input-string str))) (let ((s (cast (read sin) type))) (close-input-port sin) s))))) (define-syntax serialize-struct-to-string (syntax-rules () ((_ struc) (let ((outp (open-output-string))) (write struc outp) (close-output-port outp) (get-output-string outp))))) </div><div class="gmail_extra"> <div class="gmail_quote">On Mon, May 6, 2013 at 1:39 PM, Asumu Takikawa <<a href="mailto:asumu@ccs.neu.edu" target="_blank">asumu@ccs.neu.edu</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class="im">On 2013-05-06 08:46:04 -0700, Eric Dobson wrote: > Couldn't this be solved by protecting the struct on export? </div>I'm not sure this is sufficient. Consider the following code: <div class="im"> #lang racket/load (module foo racket </div> (struct foo ([f #:mutable]) #:prefab) (define y (foo values)) (define (mutater) (set-foo-f! y (ë (x) (string->number x)))) (provide y mutater)) (module bar typed/racket (struct: foo ([f : (Float -> Float)]) #:mutable #:prefab) (require/typed 'foo [y foo] [mutater (-> Void)]) (mutater) ((foo-f y) 5.3)) The use of mutation lets you sneak values that don't match the type. Even if you require the struct instance with `struct/dc` and apply an impersonator-based contract, you can't prevent the un-impersonated access on the `foo` side. This actually looks like it's a problem even without #:prefab structs: <div class="im"> #lang racket/load (module foo racket </div> (struct foo ([f #:mutable])) (define y (foo values)) (define (mutater) (set-foo-f! y (ë (x) (string->number x)))) (provide y (struct-out foo) mutater)) (module bar typed/racket (require/typed 'foo [#:struct foo ([f : (Float -> Float)])] [y foo] [mutater (-> Void)]) (mutater) ((foo-f y) 5.3)) Another thing to be careful of is struct inheritance. For example: #lang racket/load <div class="im"> (module foo typed/racket (struct: foo ([f : (Float -> Float)]) #:prefab) </div> (struct: foo2 foo ([g : (Float -> Float)]) #:prefab) (define x (ann (foo2 (ë (x) (* x 5.3)) (ë (x) (* x 5.3))) foo)) ;; Note that this is a type error ;(foo2-g x) (provide x)) <div class="im"> (module bar racket (require 'foo) (struct foo (f) #:prefab) </div> (struct foo2 foo (g) #:prefab) ((foo2-g x) "foo")) In this case, `foo2` inherits from `foo` and so you can upcast an instance of `foo2` to `foo`. But then you forget a field, and if the type->contract translation isn't smart, then you may fail to protect all the fields (that an untyped client can now guess and misuse). Cheers, Asumu </blockquote></div> </div>