Temporary Types

Creates a temporary copy of a user defined type

Syntax
   result = Type( initializers, ... )
      or
   result = Type<typename>( initializers, ... )

Parameters
   initializers
      Initial values for the type (or only the firsts)
   typename
      The name of the Type or Union

Return Value
   A temporary copy of the type.

Description
   Used to create a temporary type.  If typename is not explicitly given, 
   it will be inferred from its usage if possible.  Usage of the temporary 
   copy may include assigning it to a variable, passing it as a parameter 
   to a procedure, or returning it as a value from a procedure.

   For a type without own or inherited constructor (excluding also any type 
   that is directly or indirectly derived from Object), the temporary type 
   syntax is allowed if all type data-fields (including those inherited) 
   are numeric primitives only and without any default initializers.
   If at same time the type is without destructor, the compiler does a 
   direct assignment instead of using a temporary copy.

   The Constructor for the type, if there is one with parameters matching 
   with the initializers provided, will be called when the temporary copy 
   is created, and the Destructor for the type, if there is one, will be 
   called immediately after its use. But when there is a matching 
   constructor, the temporary type expression may be simply replaced by 
   typename( initializers, ... ).
   If there is a constructor at least but none which matches with the 
   initializers, the temporary type syntax is obviously disallowed.

   It can create not only a temporary copy of an user defined type, but 
   also a temporary copy of predefined data-type as a variable-length 
   string or any numeric data-type (all standard data-types excluding 
   fixed-length strings).

   It can also be used as an even shorter shortcut than With (see below) if 
   you are changing all the data-fields (or the n firsts only).

   A temporary object is destroyed at the end of execution of the statement 
   (where it's defined), but its corresponding allocated memory is not 
   released and remains available (unused) until going out the scope where 
   statement is.

   Note: Static qualifier used at procedure definition level does not apply 
   to temporary types.

Example
   Type Example
      As Integer field1
      As Integer field2
   End Type

   Dim ex As Example

   '' Filling the type by setting each field
   ex.field1 = 1
   ex.field2 = 2

   '' Filling the type by setting each field using WITH
   With ex
      .field1 = 1
      .field2 = 2
   End With

   '' Fill the variable's fields with a  temporary type
   ex = Type( 1, 2 )

   '' Passing a user-defined types to a procedure using a temporary type
   '' where the type can be inferred.

   Type S
     As Single x, y
   End Type

   Sub test ( v As S )
     Print "S", v.x, v.y
   End Sub

   test( Type( 1, 2 ) )

   '' Passing a user-defined type to a procedure using temporary types
   '' where the type is ambiguous and the name of the type must be specified.

   Type S
     As Single x, y
   End Type

   Type T
     As Integer x, y
   End Type

   Union U
     As Integer x, y
   End Union

   '' Overloaded procedure test()
   Sub test Overload ( v As S )
     Print "S", v.x, v.y
   End Sub

   Sub test ( v As T )
     Print "T", v.x, v.y
   End Sub

   Sub test ( v As U )
     Print "U", v.x, v.y
   End Sub

   '' Won't work: ambiguous
   '' test( type( 1, 2 ) )

   '' Specify name of type instead
   test( Type<S>( 1, 2 ) )
   test( Type<T>( 1, 2 ) )
   test( Type<U>( 1 ) )

Differences from QB
   * New to FreeBASIC

See also
   * Type...End Type
   * Type (Alias)

