Back to Vala Reference Manual

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);
        }
}