Martin DeMello wrote:
In my current project, one of the main paradigms is code such as in
the following example. I'm wondering if there's a Ruby/OO designation
for it so that I wouldn't have to always show some excerpt when
describing the project. It's sort of an inverse continuation passing
scheme (which, in itself, isn't exactly a prime OO term).Technically currying, but from the example it looks like the intent is
simply function wrapping.
I suppose not quite currying either--although it's a fair terming. I'm
thinking (in the context of the actual application which you obviously
didn't have the benefit of witnessing) maybe a 'monadic state'.
e.g. we do this a lot at work:
one(args) {
ensure thread safety;
return two(args)
}two(args) {
ensure constraint satisfaction;
return three(args)
}three(args) {
do the actual work;
return the actual result;
}Is that the same thing you're using it for?
Not quite though the basic structure is the same. Essentially a state
and an environment is built/augmented while building up the stack and
there are certain operations performed while unwinding. In the end,
the computation is stored for use a bit later.
I should probably have mentioned that this is, at this stage, a
more-or-less direct translation of an O'Caml project of mine 
I agree with you three, though, I think I'll just implement this in
a more straightforward manner to begin with and refactor. Thanks!
martin
E
ยทยทยท
E S <eero.saynatkari@kolumbus.fi> wrote: