Generics

Generic programming is a way of defining that something is applicable to a variety of potential types, without having to know these types before hand. The classic example would be a collection such as a list, which can be trivially customised to contain any type of data elements. Generics allow a Vala programmer to have these customisations done automatically.

Some of these are possible, which?

• class Wrapper < T > : Object { … }

• new Wrapper < Object > ( ) ;

• BUG: class StringWrapper : Wrapper < string > ( ) { … }

• FAIL: class WrapperWrapper < Wrapper < T > > : Object { … }

• FAIL: new WrapperWrapper < Wrapper < Object > > ( ) ;

• interface IWrapper < T > { … }

• class ImpWrapper1 < T > : Object, IWrapper < T > { … }

• BUG: class ImpWrapper2 : Object, IWrapper < string > { … }

Generics declaration

Some of the syntax could be best placed in the class/interface/struct pages, but that might overcomplicate them…

In class declaration - In struct declaration - In interface declaration - In base class declaration - In implemented interfaces declaration - In prerequesite class/interface declaration.

Declaration with type parameters introduces new types into that scope, identified by names given in declaration, e.g. T.

qualified-type-name-with-generic:

• qualified-class-name-with-generic

• qualified-interface-name-with-generic

• qualified-struct-name-with-generic

qualified-class-name-with-generic:

• [ qualified-namespace-name . ] class-name type-parameters

qualified-interface-name-with-generic:

• [ qualified-namespace-name . ] interface-name type-parameters

qualified-struct-name-with-generic:

• [ qualified-namespace-name . ] struct-name type-parameters

type-parameters:

• < generic-clause >

generic-clause:

• type-identifier [ , generic-clause ]

• qualified-type-name [ , generic-clause ]

type-identifier:

• identifier

type-identifier will be the type-name for the parameterised type.

Deal is: in the class/interface/struct sections, replace qualified--name with qualified--name-with-generic.

Instantiation

Only explanation here? Syntax should go with variable declaration statement?

When using generic for a type-name, only type-names can be used as type-parameters, not identifiers. NB. in scope of generic class, T etc. is a real type-name.

Examples

Demonstrating…

using GLib;

public interface With < T > {
        public abstract void sett(T t);
        public abstract T gett();
}


public class One : Object, With < int > {
        public int t;

        public void sett(int t) {
                this.t = t;
        }
        public int gett() {
                return t;
        }
}

public class Two < T, U > : Object, With < T > {
        public T t;

        public void sett(T t) {
                this.t = t;
        }
        public T gett() {
                return t;
        }

        public U u;
}

public class Test : GLib.Object {

        public static void main(string[] args) {
                var o = new One ();
                o.sett(5);
                stdout.printf("%d
", o.t);

                var t = new Two < int, double? > ();
                t.sett(5);
                stdout.printf("%d
", t.t);

                t.u = 5.0f;
                stdout.printf("%f
", t.u);
        }
}