[racket] struct generics and mutual dependencies

 Recommended way for mutual dependencies is to use units:

http://docs.racket-lang.org/guide/units.html

You may define struct accessors as unit exports/imports and then link them


Mon, 18 Aug 2014 23:44:11 -0400 от Jon Zeppieri <zeppieri at gmail.com>:
>Say I want to do basically the following, except with larger, more
>complicated generic interfaces:
>
>```racket
>#lang racket/base
>
>(require racket/generic)
>
>(define-generics ->foo-provider
>  (->foo ->foo-provider))
>
>(define-generics ->bar-provider
>  (->bar ->bar-provider))
>
>(struct foo (x)
>  #:methods gen:->foo-provider
>  [(define (->foo f) f)]
>
>  #:methods gen:->bar-provider
>  [(define (->bar f) (bar (foo-x f)))])
>
>(struct bar (x)
>  #:methods gen:->foo-provider
>  [(define (->foo b) (foo (bar-x b)))]
>
>  #:methods gen:->bar-provider
>  [(define (->bar b) b)])
>```
>
>That is, I want to have struct types that can use generic methods to
>construct instances of one another. Since the actual struct types are
>rather more complicated than this example, I'd really like to split up
>their implementations into separate modules. If I weren't using
>generics, this would be straightforward; I'd put the struct type
>definitions themselves in a module, or set of modules, and I'd put the
>operations in modules specific to their respective struct types. The
>modules containing the operations would be able to require all of the
>struct type definitions, so they could freely construct instances of
>one another.
>
>In the present case, however, the method implementations need to be
>defined along with the struct type definition. I can't do something
>like:
>
>```
>[(define ->foo bar->foo)]
>```
>... where bar->foo comes from a bar-specific module, because that
>would lead to a circular dependency (bar->foo needs the foo
>constructor, which is defined in this module, while this module needs
>bar->foo).
>
>I could work around this with mutable bindings (either at the module
>level or, better, in method dispatch), but I'm not fond of either
>approach. With the right structure inspector maybe (?) it would be
>possible to modify whatever dispatch table is actually used, but that
>sounds hairy. I guess I'm wondering if some other trick is possible
>here.
>
>-Jon
>____________________
>  Racket Users list:
>   http://lists.racket-lang.org/users


-- 
Roman Klochkov
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.racket-lang.org/users/archive/attachments/20140819/72b53d22/attachment-0001.html>