[racket] struct generics and mutual dependencies

Could you elaborate, maybe provide an example? I'm not sure what you
have in mind.

-Jon


On Tue, Aug 19, 2014 at 8:40 AM, Roman Klochkov <kalimehtar at mail.ru> wrote:
> 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