On Sam, 2007-04-21 at 23:54 +0100, Phil Housley wrote:

• Hi, I'm pretty excited about how vala is coming on, but there are some things that I just don't follow. It's quite possible that I would understand a lot more if I knew more about glib/gobject, but I don't sadly. However, if vala is going to be adopted, it probably needs to appeal more to people like me, right?

Welcome to Vala. I hope this mail will help you in understanding how it works and why it's done like that.

• The specific problem I have is trying to work out how to do something that's very simple in most languages. I want a constructor to take a parameter that is only of use in the constructor, and is never stored. Normally I would just:

  class SomeThing extends Thing {
      public SomeThing(int x) {
          initialize_things(x);
      }
  }

  But vala tells me that this constructor can't do anything except set member values. I'm sure this is a common thing to do, yet vala seems to make it very tricky. I don't want to store that "x" anywhere, just use it and forget about it.

You can do this with construct-only properties without storing the value anywhere.

class SomeThing : Thing {
        public int x {
                construct {
                        // you can access the new value with `value'
                        // as in property setters in C#
                        initialize_things (value);
                }
        }

        // we call this a creation method
        // not guaranteed to be called
        // only allowed to set properties
        public SomeThing (construct int x) {
        }

        // that's how you can declare a constructor
        // where you can write arbitrary code that
        // is guaranteed to be called when creating
        // an instance of this class or a subclass
        construct {
        }
}

The construct in the parameter of the creation method is just a short version of setting the property x to the value of the argument x.

• I guess overall I find the whole object construction thing very confusing. There seem to be 3 different ways to set the value of properties, and yet none of them can easily take arguments. This might all make sense if I knew more about glib, but I've tried to learn that and failed twice already.

Yes, it can be very confusing if you're used to languages like Java or C#. The reason why Vala is that different is that it follows GObject. In Vala - and GObject in general - creation methods are not guaranteed to be called, for example the creation method of Thing won't be called when creating a new instance of SomeThing.

That's why we don't allow to write arbitrary code in creation methods as it could make it impossible to create a conforming subclass. If you have code that should always be executed, use a constructor as shown in the example above.

• The other language I'm watching at the moment is D, which feels a lot more intuitive so far. I'd much rather use vala though, as it fits so nicely with everything else - gtk being a big selling point for me.

D uses its own object model so it's obviously not restricted to follow existing API and ABI as we are with GObject. The advantage of Vala is that it doesn't invent yet another object model and doesn't add yet another runtime to the many platforms we already have, it's just a language designed to leverage the existing GNOME platform.

Regards, Jürg