On Fri, 22 Jun 2001, Tobin Baker wrote:

> #Ruby
> baz = nil
> myFoo.bar {|baz|}
> p baz #=> 10
...
> Is this reasonable syntax, or is it just getting too ugly?

One problem with this is that because you can't really get the values of
the "out" parameters in the block, you can't have inout parameters, as you
mentioned.  What's worse, you must now divide your parameters into two
groups: in parameters and out parameters.  While this might work fine for
RubyX11, it's not going to work well for CORBA.

If we have an IDL that looks like:

interface Foo {
    void f(in a, out b, inout c, in d);
}

Then we would have to call the function f like this:

    f(a, c, d) {|b, c|}

which is sorta confusing, because the arguments are completely out of
order.

On the other hand, using a helper class like Java uses allows us to
specify our arguments in the same order as found in the IDL.

Below is a helper class I've hacked together for inout parameters.  Each
helper gets a new type, so you can do type checking to make sure you are
sending the right type across the wire.  The only thing I wish were
different is that because FixnumHelper doesn't derive from Fixnum, you
can't necessarily use a FixnumHelper wherever you can use a Fixnum.
Unfortunately, if you derive from Fixnum, then you can't call set_value().

Paul

---------
class InoutHelper
end

class InoutHelperFactory
    def InoutHelperFactory.new_helper(wrapped_class)
        customer = Class.new(InoutHelper)
        customer.const_set("WRAPPED_CLASS", wrapped_class)
        customer.class_eval(%{
            def initialize(i)
                @i = i
            end
            def set_value(other)
                case other
                    when self.type
                        @i = other.i
                    when WRAPPED_CLASS
                        @i = other
                    else
                        raise TypeError
                end
            end
            def get_value()
                return @i
            end
            def to_s()
                return @i.to_s()
            end
            def method_missing(*args)
                @i.__send__(*args)
            end
        })
        return customer
    end
end

FixnumHelper = InoutHelperFactory.new_helper(Fixnum)
def foo(inout)
    inout.set_value(42)
end
a = FixnumHelper.new(10)
puts a
foo(a)
puts a
puts a + 5

#=>
10
42
47