Projects/Vala/Manual/Generics

Generics

Contents

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\n", o.t);

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

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