[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Various comments

This page is part of the web mail archives of SRFI 44 from before July 7th, 2015. The new archives for SRFI 44 contain all messages, not just those from before July 7th, 2015.

scgmille@xxxxxxxxxxxxxxxxxx wrote:

The short answer is that while an iterator can easily be functional and efficient (because it usually only needs a small amount of state, like a pointer), a datastructure may not be. Take as an example an actively balanced tree. A functional version of remove may have to do a lot of work to modify the tree, but even more if its not allowed to affect the original (possibly as bad as copying the entire tree). At best this creates a lot of extra GC pressure.

Fully functional datastructures do have some advantages though. For one it is possible
to store severeal instances of the same datastructure in different stages,
in order to provide undo-functionallity. Second, there are no problems with concurrency
if the process forks some children.

In order to accomodate a functional way of using collections, one could consider letting the remove! functions return the altered datastructure. This would make code like this
possible, that passes the datastructure it self around.

Silly example that removes the elements 1 2 3 from some set s:

 (let loop ([l (list 1 2 3)]
            [s ...some set...])
     (if (null? l)
         (loop (cdr l)
               (set-remove! (car l) s))))

I other words, I also prefer remove and friends to return something useful.

Jens Axel Søgaard