Re: [Vala] Ownership syntax changes

[Arto Karppinen <arto karppinen mail suomi net>]

Yu Feng wrote:
> On Sat, 2008-12-20 at 13:04 +0100, Jürg Billeter wrote:
> > On Sat, 2008-12-20 at 12:19 +0100, Xavier Bestel wrote:
> > > Le vendredi 19 décembre 2008 à 12:10 +0100, Jürg Billeter a écrit :
> > > > I just committed some ownership syntax changes to trunk. The old syntax
> > > > will continue to be supported but is planned to be deprecated after the
> > > > release of Vala 0.5.4.
> > > >
> > > >
> > > >       * `owned' type modifier replaces `#' type modifier
> > > >
> > > > This is not often used, but `#' was very unintuitive as a type modifier,
> > > > and I therefore decided to replace it by the hopefully better
> > > > understandable `owned' modifier. Example of new syntax:
> > > >
> > > > public void foo (owned string bar) {
> > > >     [...]
> > > > }
> > > I like the idea, but the word "owned" doesn't really tells by who it's
> > > owned (caller or callee). How about something like "callers" or
> > > "transfer" ?
> > `owned' applied to a parameter means that the parameter owns the object,
> > that is, the ownership of the object is transferred in the same
> > direction as the parameter value: to the callee for input paramters, to
> > the caller for output parameters, and input to the callee and output to
> > the caller for `ref' parameters.
> `owned' is still not much better than # because the world owned doesn't
> describe the flow of the ownership; and where people can easily get
> confused is the direction of the flow.
>
> I read into glib again and perhaps a steal/take pair can work together.
>
> void foo(take string bar); foo will take the ownership of bar from the
> caller context.
>
> foo(steal "bar"); the ownership of "bar" is stolen from the caller
> context.
>
> (notice the steal now is written in the caller code.)

I like this a lot, but steal is a bit ambiguous about who steals and 
what. You could think that caller steals something from the function.


How about give: Caller gives, function takes.

Like this:

void foo(take string bar);

foo(give "bar");


This would have the advantage of always being in the point of view of 
the code you are writing or reading. If you are writing a function, you 
write that you *take* something from the caller. If you are using the 
function, you can write that you *give* something to the function.

Also give and take would be nice, because they describe what I intend to 
do (give or take ownership), not what vala does with them. While owned / 
unowned to me fells like thinking from a code generation point of view.

--
Arto Karppinen
------------------------------
arto karppinen iki fi