<html><head><meta http-equiv="Content-Type" content="text/html charset=us-ascii"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;"><div>I think you can also do it with lazy-require:</div><div><br></div><div><div><font face="Courier New">#lang racket/base</font></div><div><font face="Courier New"><br></font></div><div><font face="Courier New">(module generics racket/base</font></div><div><font face="Courier New"> (provide (all-defined-out))</font></div><div><font face="Courier New"> (require racket/generic)</font></div><div><font face="Courier New"> (define-generics ->foo-provider</font></div><div><font face="Courier New"> (->foo ->foo-provider))</font></div><div><font face="Courier New"> </font></div><div><font face="Courier New"> (define-generics ->bar-provider</font></div><div><font face="Courier New"> (->bar ->bar-provider)))</font></div><div><font face="Courier New"><br></font></div><div><font face="Courier New">(module foo racket/base</font></div><div><font face="Courier New"> (provide (struct-out foo))</font></div><div><font face="Courier New"> (require racket/lazy-require</font></div><div><font face="Courier New"> (submod ".." generics))</font></div><div><font face="Courier New"> (lazy-require</font></div><div><font face="Courier New"> [(submod ".." bar) (bar)])</font></div><div><font face="Courier New"> (struct foo (x)</font></div><div><font face="Courier New"> #:methods gen:->foo-provider</font></div><div><font face="Courier New"> [(define (->foo f) f)]</font></div><div><font face="Courier New"> </font></div><div><font face="Courier New"> #:methods gen:->bar-provider</font></div><div><font face="Courier New"> [(define (->bar f) (bar (foo-x f)))]))</font></div><div><font face="Courier New"><br></font></div><div><font face="Courier New">(module bar racket/base</font></div><div><font face="Courier New"> (provide (struct-out bar))</font></div><div><font face="Courier New"> (require (submod ".." generics)</font></div><div><font face="Courier New"> (submod ".." foo))</font></div><div><font face="Courier New"> (struct bar (x)</font></div><div><font face="Courier New"> #:methods gen:->foo-provider</font></div><div><font face="Courier New"> [(define (->foo b) (foo (bar-x b)))]</font></div><div><font face="Courier New"> </font></div><div><font face="Courier New"> #:methods gen:->bar-provider</font></div><div><font face="Courier New"> [(define (->bar b) b)]))</font></div><div><font face="Courier New"><br></font></div><div><font face="Courier New">(module+ test</font></div><div><font face="Courier New"> (require rackunit)</font></div><div><font face="Courier New"> (require (submod ".." generics)</font></div><div><font face="Courier New"> (submod ".." foo)</font></div><div><font face="Courier New"> (submod ".." bar))</font></div><div><font face="Courier New"> (check-equal? (foo-x (->foo (bar 1))) 1)</font></div><div><font face="Courier New"> (check-equal? (bar-x (->bar (foo 1))) 1))</font></div></div><br><div><div>On Aug 18, 2014, at 11:44 PM, Jon Zeppieri <<a href="mailto:zeppieri@gmail.com">zeppieri@gmail.com</a>> wrote:</div><br class="Apple-interchange-newline"><blockquote type="cite">Say I want to do basically the following, except with larger, more<br>complicated generic interfaces:<br><br>```racket<br>#lang racket/base<br><br>(require racket/generic)<br><br>(define-generics ->foo-provider<br> (->foo ->foo-provider))<br><br>(define-generics ->bar-provider<br> (->bar ->bar-provider))<br><br>(struct foo (x)<br> #:methods gen:->foo-provider<br> [(define (->foo f) f)]<br><br> #:methods gen:->bar-provider<br> [(define (->bar f) (bar (foo-x f)))])<br><br>(struct bar (x)<br> #:methods gen:->foo-provider<br> [(define (->foo b) (foo (bar-x b)))]<br><br> #:methods gen:->bar-provider<br> [(define (->bar b) b)])<br>```<br><br>That is, I want to have struct types that can use generic methods to<br>construct instances of one another. Since the actual struct types are<br>rather more complicated than this example, I'd really like to split up<br>their implementations into separate modules. If I weren't using<br>generics, this would be straightforward; I'd put the struct type<br>definitions themselves in a module, or set of modules, and I'd put the<br>operations in modules specific to their respective struct types. The<br>modules containing the operations would be able to require all of the<br>struct type definitions, so they could freely construct instances of<br>one another.<br><br>In the present case, however, the method implementations need to be<br>defined along with the struct type definition. I can't do something<br>like:<br><br>```<br>[(define ->foo bar->foo)]<br>```<br>... where bar->foo comes from a bar-specific module, because that<br>would lead to a circular dependency (bar->foo needs the foo<br>constructor, which is defined in this module, while this module needs<br>bar->foo).<br><br>I could work around this with mutable bindings (either at the module<br>level or, better, in method dispatch), but I'm not fond of either<br>approach. With the right structure inspector maybe (?) it would be<br>possible to modify whatever dispatch table is actually used, but that<br>sounds hairy. I guess I'm wondering if some other trick is possible<br>here.<br><br>-Jon<br>____________________<br> Racket Users list:<br> <a href="http://lists.racket-lang.org/users">http://lists.racket-lang.org/users</a><br></blockquote></div><br></body></html>