Re: [Vala] Ownership syntax changes

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

(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

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