For both sophisticated reduction and path caching (#217), we could do with a way of saying 'how does the application, or revocation, of this action affect paths in other actions?'. To the best of my knowledge, this boils down to checking the effect of one path on another. For instance:
an insertion to index X in block B causes all references to indices from X downwards in block B to become indices to X+1;
revoking that insertion causes references to index X to invalidate, and everything below to decrement again;
list transformations cause any paths into the affected span to invalidate;
a transformation in block B1 doesn't affect indices in another block B2;
etc.
It should be eminently doable (though need some thought and/or theory!) to come up with some functions that calculate these path motions; then, we should be able to find a way to project them up and down a trace for reduction, and to update the cache for caching.
I imagine there'll need to be some functionality to try to work out the common subpath of two paths, and then some functionality to work out if the paths overlap from there, and so on and so forth. Sounds fun.
For both sophisticated reduction and path caching (#217), we could do with a way of saying 'how does the application, or revocation, of this action affect paths in other actions?'. To the best of my knowledge, this boils down to checking the effect of one path on another. For instance:
etc.
It should be eminently doable (though need some thought and/or theory!) to come up with some functions that calculate these path motions; then, we should be able to find a way to project them up and down a trace for reduction, and to update the cache for caching.
I imagine there'll need to be some functionality to try to work out the common subpath of two paths, and then some functionality to work out if the paths overlap from there, and so on and so forth. Sounds fun.