o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o john, with no particular reference to haskell, but just generically speaking, this sounds vaguely similar to what i worked on all through the 80's in lisp and pascal, when ut-lisp used to pull a hal 9k about cyclic d-structures so i had to start redoing everything from scratch on my own recognizance in turbo pascal, no really. vide my recent, very slow attempts to document this work at my inquiry list:
http://stderr.org/pipermail/inquiry/ http://stderr.org/cgi-bin/mailman/listinfo/inquiry here are the anchors of some pertinent threads: http://stderr.org/pipermail/inquiry/2003-March/000100.html -- exposition http://stderr.org/pipermail/inquiry/2003-March/000115.html -- source code http://stderr.org/pipermail/inquiry/2003-March/000120.html -- commentary http://stderr.org/pipermail/inquiry/2003-March/000141.html -- motivation it may be another year or so before i can finish (or even get back to) the te deums of documentality, but if anybody is remotely tantalized i will do my level best to explain what's going on there. jon awbrey o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o > Message: 10 > Date: Thu, 12 Jun 2003 19:02:55 -0700 > From: John Meacham <[EMAIL PROTECTED]> > Subject: a dream of databases > To: [EMAIL PROTECTED] > > so, I have been wanting to implement serialize to database functionality > for haskell in a certain way which may or may not be possible.. > > > what would be nice is if I could dump an entire complex haskell data > structure (perhaps cyclic, but not infinite) to a hash-table database > (like berkeley db). pointers would be swizzled into hash keys and each > haskell thunk would become an entry in the database. > > loading the database would return the haskell structure just as it was > put into the database but it would be demand loaded. meaning that > evaluating a data thunk will actually grab that entry out of the > database (like with lazy file reading) and entries that have not been > accessed in a while would be transparently reclaimed by the garbage > collector (and reloaded later if needed) > > And of course, these haskell data structures should be albe to be > arbitrary and would look no different from other haskell data > structures. they would just have appropriate instances derived for them > by DrIFT (or perhaps template haskell). > > now. I am pretty sure I can do the demand loading bit with some > goddawful code (inspired by HOODs internals) using unsafePerformIO and > Weak pointers in truly nefarious ways. The dumping to the database bit > is straightforward when working with trees. but I can't figure out a way > to do it for potentially complex datastructures. perhaps someone out > there has an idea? perhaps some template haskell tricks can be pulled to > make it happen? I realize that any solution will be quite hacky and > unlikely to be very portable. > > John > > --------------------------------------------------------------------------- > John Meacham - California Institute of Technology, Alum. - [EMAIL PROTECTED] > --------------------------------------------------------------------------- o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o~~~~~~~~~o _______________________________________________ Haskell mailing list [EMAIL PROTECTED] http://www.haskell.org/mailman/listinfo/haskell
