Defining generic types and functions
Note: This section is a stub.
We have showed how to use generic types, but not how to define them. This section explains how to define generic types. We also discuss generic functions.
This is a simple generic stack type:
class Stack<T> private var array =  as Array<T> def create() as void end def isEmpty() as Boolean return self.array ==  end def push(o as T) self.array.append(o) end def pop() as T self.array.removeAt(-1) end end
You can use it like this:
def Main() as void var s = Stack() as <Int> s.push(2) s.push(5) Print(s.pop()) -- 5 Print(s.isEmpty()) -- False end
Keep these things in mind when you define generic types:
- You can use type variables (T in the stack example) in type declarations within a generic type, and they behave almost like ordinary types.
- Two type variable types are not compatible with each other. A type variable type is compatible with Object, however.
- Values with type variable types only support operations available for the Object type, such as assignment and the == operator.
- You cannot cast a value to a type variable type.
- You can mix static and dynamic typing within the body of a generic type.
Alore also supports generic functions and methods. They have one or more type variables associated with them. Here is a simple generic function:
def First<T>(a as Array<T>) as T return a end var ia = [3, 5] as Array<Int> var sa = ['foo', 'bar'] as Array<Str> First(ia) -- 3 First(sa) -- 'foo'
You can replace the type variable (T in above example) with any type when calling the function. Usually the type checker can infer the value of the type variable, but you can also give it explicitly:
First(ai) as <Int>
Note that the syntax is similar to constructing instances of generic types.