Brilliant. I knew there had to be a clean way and both of these sound
On Mon, May 14, 2018 at 4:56 PM, Alexis King <lexi.lam...@gmail.com> wrote:
> In addition to what Matthias says, you can also sometimes break these
> kinds of cycles using lazy-require, which defers the requiring the other
> module until it is first needed. This is simpler than using units and
> provides stronger guarantees than using callbacks, but it is a bit more
> ad-hoc than both of them, and it only works when the lazily-loaded
> module isn’t needed as part of module initialization (that is, the
> function isn’t called from the top level of a module). When it works,
> though, it can be a less invasive solution to the problem.
>> On May 14, 2018, at 4:28 PM, David Storrs <david.sto...@gmail.com> wrote:
>> My application retrieves chunks of files from the network and writes
>> them to disk, as well as writing certain data about them to the
>> database (e.g. where they are on disk and where they came from on the
>> I've split these functions into separate files:
>> This worked fine until now, but I've gotten to a point where they're
>> circular -- the network code needs to receive the chunk and then
>> forward it to the DB code, but if certain error conditions come up
>> then the DB code needs to tell the network code to re-request the
>> There's various ways I could work around this (simplest being to put
>> all the functions in one file), but I'm wondering if there's a
>> recommended way? C would solve this with a .h file. Perl would solve
>> it with function prototypes (or simply be able to sort it out without
>> intervention). What is the preferred Racket way, or am I simply not
>> thinking about it correctly?
You received this message because you are subscribed to the Google Groups
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
For more options, visit https://groups.google.com/d/optout.