By Limin Fu. Released under the GNU Free Documentation License. [NAME] ALL.dao.type [TITLE] Data Type [DESCRIPTION] Dao supports optional/hybrid typing that allows variables to be declared with or without type names. When a variable is declared without type name, its type will be automatically inferred at compiling time if possible. If a variable has an explicitly declared type or a successfully inferred type, static type checking will be carried out on this variable at compiling time, otherwise, it will be checked at running time. The most basic inference is based on assignment, so the simplest way to declare a variable to have certain type without explicitly specifying it is by assigning a value of the desired type to the variable at the declaration, for example id = 0 will decalare id as an integer, which is equivalent to id :int = 0. 1 Explicit Type Declaration The type of a variable can be declared explicitly in the following form: 1 variable : type 2 variable : type = value The same form can also be used in function parameter list: 1 routine MyFunction( name : string, index : int = 1 ) { ... } Multiple variables can be declared once with the same type and initial value: 1 variable1, variable2 : type 2 variable1, variable2 : type = value 2 Outline of Dao Types Dao supports a rich set of types to allow writing expressive codes. 2.1 Basic Types The basic types are the following: * int : integer type; * float : single precision floating point number; * double : double precision floating point number; * complex : complex number (double precision for each part); * long : arbitrary precision integer; * string : string type; * enum : enum type; Please see dao.type.typename for details. 2.2 Builtin Aggregated Types Dao has builtin support for some essential aggregated types including: * array : multi-dimensional numeric array; * tuple : tuple type; * list : list container; * map : map or hash map container; Please see dao.type.typename for details. 2.3 Other Types Dao also supports a number of other types such as: * Routine or function types (see dao.routine for details); * Wrapped C/C++ types (see dao.c-interface for details); * User defined Dao class types (see dao.class for details); * Abstract interface types (see dao.??? for details); * stream type for standard Input/Output and file Input/Output (see dao.type.stream for details); * Types for concurrent programming such future, mutex, condition and semaphore (see dao.concurrent for details); * Exception types (essentially wrapped C types). 2.4 Special Types * any: As its name suggests, it represents any type, so any value can match to this type. * ?: This special type name represents undefined types. Function parameters that have neither type annotations nor default values are automatically assigned with this type. Some variables whose types cannot be successfully inferred are also assigned with this type. This type can be specialized to a more specific type when more type information is available, for example, at function call point (compile time or runtime), parameters passed to a function call can provide concrete types to specialize the function (namely, specializing parameter types, local variable types and virtual machine instructions). * Type holder: Type holders are type names with a @ prefix. It also represents to-be-defined types, the same type holder represents the same type in a local context (a single composite type or a function prototype etc). For example, 1 tuple<@T,@T> represents a tuple type whose two items must have the same type. 1 routine Func( a :@T, b :@T ) declares a function that can only accept two parameters of the same type. * Value type: Constant values of basic types can also be used as types in a composite type. For example, 1 tuple<1,2> represents a tuple type whose first item must be 1 and its second must be 2! Such types are mainly useful when dealing with C++ template types. 2.5 Type Aliasing Type alias can be defined using the following syntax: 1 #TypeAliasing ::= 'type' Identifier '=' Type 2 type alias = another_type For example, 1 type StringList = list<string> 2 type Point3D = tuple<x:float,y:float,z:float> [STRUCTURE] dao.type--| dao.type: Data Type (44.4 KB) |--int------| dao.type.int: Integer Type (0.5 KB) |--float----| dao.type.float: Single Precision FP Number Type (0.6 KB) |--double---| dao.type.double: Double Precision FP Number Type (0.6 KB) |--complex--| dao.type.complex: Complex Number Type (0.6 KB) |--long-----| dao.type.long: Arbitrary Precision Integer Type (0.7 KB) |--enum-----| dao.type.enum: Enum or Symbol Type (2.4 KB) |--string---| dao.type.string: String Type (21.0 KB) | |--method------| dao.type.string.method: Dao string methods (4.9 KB) | | |--chop-----| dao.type.string.method.chop: chop( self :string ) (0.3 KB) | | |--erase----| dao.type.string.method.erase: erase( self :string ) (0.2 KB) | | |--find-----| dao.type.string.method.find: find( self :string ) (0.3 KB) | | |--insert---| dao.type.string.method.insert: insert( self :string ) (0.4 KB) | | |--replace--| dao.type.string.method.replace: replace( self :string ) (0.5 KB) | | |--expand---| dao.type.string.method.expand: expand( self :string ) (1.5 KB) | | |--resize---| dao.type.string.method.resize: resize( self :string ) (0.1 KB) | | |--size-----| dao.type.string.method.size: size( self :string ) (0.1 KB) | | |--split----| dao.type.string.method.split: split( self :string ) (0.5 KB) | | |--tolower--| dao.type.string.method.tolower: tolower( self :string ) (0.1 KB) | | |--toupper--| dao.type.string.method.toupper: toupper( self :string ) (0.1 KB) | | | |--functional--| dao.type.string.functional: Dao String Functional Methods (1.1 KB) | | |--iterate--| dao.type.string.functional.iterate: iterate( self :string ) (0.1 KB) | | |--count----| dao.type.string.functional.count: count( self :string ) (0.1 KB) | | |--map------| dao.type.string.functional.map: map( self :string ) (0.1 KB) | | |--select---| dao.type.string.functional.select: select( self :string ) (0.1 KB) | | |--index----| dao.type.string.functional.index: index( self :string ) (0.1 KB) | | |--apply----| dao.type.string.functional.apply: apply( self :string ) (0.1 KB) | | | |--pattern-----| dao.type.string.pattern: String Pattern Matching (11.1 KB) | |--pfind-----| dao.type.string.pattern.pfind: string.pfind() (0.6 KB) | |--match-----| dao.type.string.pattern.match: string.match() (0.3 KB) | |--submatch--| dao.type.string.pattern.submatch: string.submatch() (0.4 KB) | |--extract---| dao.type.string.pattern.extract: string.extract() (0.9 KB) | |--capture---| dao.type.string.pattern.capture: string.capture() (0.3 KB) | |--change----| dao.type.string.pattern.change: string.change() (0.7 KB) | | |--array----| dao.type.array: Multi-dimensional Numeric Array (3.3 KB) | |--method--| dao.type.array.method: Array methods (1.3 KB) | |--dim----| dao.type.array.method.dim: Array method dim() (0.0 KB) | |--index--| dao.type.array.method.index: Array method index() (0.0 KB) | | |--list-----| dao.type.list: List Container Type (3.0 KB) | |--method--| | |--map------| dao.type.map: Map or Hash Map Container Type (2.8 KB) | |--method--| | |--tuple----| dao.type.tuple: Tuple Type (1.5 KB) |--variant--| dao.type.variant: Variant or Disjoint Union Type (2.7 KB)