Recent changes to Generics

Generics modified by Will Pittenger

Will Pittenger — Sun, 16 Feb 2014 10:31:14 -0000

--- v6
+++ v7
@@ -41,9 +41,10 @@

 A simple generic class
 ----------------------
-The class below takes two type parameters.  Notice the type parameters go between the [**class**] keyword and the class's identifier.  This will be explained with the talk on generic procedures.  These samples don't show interfaces, structures, unions, or type aliases; but the syntax is the same.
+The class below takes two type parameters.  Notice the type parameters go between the **[class](keywords-class)** keyword and the class's identifier.  This will be explained with the talk on generic procedures.  These samples don't show interfaces, structures, unions, or type aliases; but the syntax is the same.

 ~~~~
+:::text
 class  Name
   public function GoLeft a HowMuch
       returns b
@@ -52,9 +53,10 @@

 A generic class with restrictions on the type parameters
 --------------------------------------------------------
-If you need to ensure the passed type has some members, the [**where**] clause comes in handy.  This class requires a passed type to derive from X and implement IComparable.
+If you need to ensure the passed type has some members, the **[where](keywords-where)** clause comes in handy.  This class requires a passed type to derive from X and implement IComparable.

 ~~~~
+:::text
 class  Name
     where
       a
@@ -66,6 +68,7 @@
 This generic class takes type parameters with a different type of restriction.

 ~~~~
+:::text
 class  Class2
     where
       a = enum ' must be an enum
@@ -76,9 +79,10 @@

 Generic procedures
 ------------------
-Commands, functions, and complex structures can all be generic.  The code sample below shows samples of each.  The [**returns**] and [**where**] clauses for generic functions can occur in any order.  (Note: The samples only show prototypes.)
+Commands, functions, and complex structures can all be generic.  The code sample below shows samples of each.  The **[returns](keywords-returns)** and **[where](keywords-where)** clauses for generic functions can occur in any order.  (Note: The samples only show prototypes.)

 ~~~~
+:::text
 command  GenericCommand var a A
   where
     a = enum
@@ -101,6 +105,7 @@
 Expanding a generic class is similar to C++, C#, and Java.  Use the syntax shown below.

 ~~~~
+:::text
 var GenericClass name = new GenericClass
 ~~~~

@@ -109,6 +114,7 @@
 Now that ASIL is expecting type parameters, it can expect, and even require, them.  So use this syntax.

 ~~~~
+:::text
 GenericCommand myEnumInstance

 var String name 
@@ -123,6 +129,7 @@
 It is unknown how useful Contravariance is.  But Covariance can be used.  Both are shown here, but Contravariance might not survive.

 ~~~~
+:::text
 var GenericClass ' Covariance
 var GenericClass ' Contravariance
 ~~~~

Generics modified by Will Pittenger

Will Pittenger — Thu, 13 Feb 2014 22:51:39 -0000

--- v5
+++ v6
@@ -4,7 +4,7 @@
 --------
 Generics in ASIL are closer to .NET generics most closely in usage than Java.  That's because Java generics are more like "pseudo-generics".  Java strips the type information out and converts the generics into their raw form.  This makes it impossible to access information about the type parameters at run time.  The syntax is loosely adapted from C#.

-Note: The names of your type parameters must be unique inside whatever is generic.  So if you have a generic class with a type paremter named "x", "x" can't be the name of any member.
+Note: The names of your type parameters must be unique inside whatever is generic.  So if you have a generic class with a type parameter named "x", "x" can't be the name of any member.

 What can and can't be generic
 -----------------------------
@@ -23,7 +23,7 @@
 Data member variable | ✗
 Destructors | ✗
 Function | ✓
-Global variable (DASIL) | ✗
+Global variable ([DASIL](Derivatives-DASIL)) | ✗
 Interface | ✓
 Local variable | ✗
 Operator | ✗
@@ -89,7 +89,7 @@
     c
       implements IComparable

-statement  GenericStatement var & g G
+statement  GenericStatement var ref g G
   where
     g = struct
 ~~~~
@@ -114,7 +114,7 @@
 var String name 
 name = GenericFunction "test"

-GenericStatement var MyStruct myStructInstance
+GenericStatement var MyStruct myStructInstance
   ' Do something
 ~~~~

Generics modified by Will Pittenger

Will Pittenger — Sun, 09 Feb 2014 13:10:39 -0000

--- v4
+++ v5
@@ -12,6 +12,7 @@

 Identifier type | Yes or no
 ----------------|----------
+Bitfield | ✗
 Class | ✓
 Command | ✓
 Complex Statement | ✓
@@ -30,14 +31,17 @@
 Properties | ✗
 Structure | ✓
 Structure-based enum | ✓
+Type alias | ✓ (if based on a generic)
+Union with external controlling member | ✗
+Union with internal controlling member | ✓

 Types of generic type parameters
 --------------------------------
-ASIL generic type fall into several categories.  Those are primitives, enums, structs, struct-based enums, and classes.  [Delegates] and [Events] are considered to be instances of classes.
+ASIL generic type parameters fall into several categories.  Those are primitives, enums, structs, struct-based enums, and classes.  [Delegates] and [Events] are considered to be instances of classes.

 A simple generic class
 ----------------------
-The class below takes two type parameters.  Notice the type parameters go between the [**class**] keyword and the class's identifier.  This will be explained with the talk on generic procedures.  These samples don't show interfaces or structures, but the syntax is the same.
+The class below takes two type parameters.  Notice the type parameters go between the [**class**] keyword and the class's identifier.  This will be explained with the talk on generic procedures.  These samples don't show interfaces, structures, unions, or type aliases; but the syntax is the same.

 ~~~~
 class  Name

Generics modified by Will Pittenger

Will Pittenger — Sat, 08 Feb 2014 13:27:32 -0000

--- v3
+++ v4
@@ -12,21 +12,24 @@

 Identifier type | Yes or no
 ----------------|----------
+Class | ✓
+Command | ✓
+Complex Statement | ✓
 Conditional variable | ✗
+Constant | ✗
+Constructors | ✗
+Creators | ✗
+Data member variable | ✗
+Destructors | ✗
+Function | ✓
+Global variable (DASIL) | ✗
+Interface | ✓
+Local variable | ✗
 Operator | ✗
-Constant | ✗
-Global variable (DASIL) | ✗
-Local variable | ✗
-Data member variable | ✗
 Primitive-based enum | ✗
 Properties | ✗
 Structure | ✓
-Class | ✓
-Interface | ✓
 Structure-based enum | ✓
-Command | ✓
-Function | ✓
-Complex Statement | ✓

 Types of generic type parameters
 --------------------------------
@@ -34,7 +37,7 @@

 A simple generic class
 ----------------------
-The class below takes two type parameters.  Notice the type parameters go between the [**class**] word and the class identifier.  This will be explained with the talk on generic procedures.  These samples don't show interfaces or structures, but the syntax is the same.
+The class below takes two type parameters.  Notice the type parameters go between the [**class**] keyword and the class's identifier.  This will be explained with the talk on generic procedures.  These samples don't show interfaces or structures, but the syntax is the same.

 ~~~~
 class  Name

Generics modified by Will Pittenger

Will Pittenger — Thu, 06 Feb 2014 20:22:22 -0000

--- v2
+++ v3
@@ -87,7 +87,7 @@
     g = struct
 ~~~~

-Now you should be able to see why ASIL puts the declaration of type parameters before the name of what is being declared.  If the order were command GenericCommand<a> var a A, would "" be part of the syntax or the type parameters?
+Now you should be able to see why ASIL puts the declaration of type parameters before the name of what is being declared.  If the order were command GenericCommand<a> var a A", would "<a>" be part of the syntax or the type parameters?

 Referencing a generic class
 ---------------------------

Generics modified by Will Pittenger

Will Pittenger — Thu, 06 Feb 2014 20:19:52 -0000

--- v1
+++ v2
@@ -3,6 +3,8 @@
 Overview
 --------
 Generics in ASIL are closer to .NET generics most closely in usage than Java.  That's because Java generics are more like "pseudo-generics".  Java strips the type information out and converts the generics into their raw form.  This makes it impossible to access information about the type parameters at run time.  The syntax is loosely adapted from C#.
+
+Note: The names of your type parameters must be unique inside whatever is generic.  So if you have a generic class with a type paremter named "x", "x" can't be the name of any member.

 What can and can't be generic
 -----------------------------
@@ -32,7 +34,7 @@

 A simple generic class
 ----------------------
-The class below takes two type parameters.  Notice the type parameters go between the [**class**] word and the class identifier.  This will be explained with the talk on generic procedures.
+The class below takes two type parameters.  Notice the type parameters go between the [**class**] word and the class identifier.  This will be explained with the talk on generic procedures.  These samples don't show interfaces or structures, but the syntax is the same.

 ~~~~
 class  Name
@@ -65,3 +67,55 @@
       d = class ' Must be a class
 ~~~~

+Generic procedures
+------------------
+Commands, functions, and complex structures can all be generic.  The code sample below shows samples of each.  The [**returns**] and [**where**] clauses for generic functions can occur in any order.  (Note: The samples only show prototypes.)
+
+~~~~
+command  GenericCommand var a A
+  where
+    a = enum
+
+function  GenericFunction var c C
+  returns c
+  where
+    c
+      implements IComparable
+
+statement  GenericStatement var & g G
+  where
+    g = struct
+~~~~
+
+Now you should be able to see why ASIL puts the declaration of type parameters before the name of what is being declared.  If the order were command GenericCommand<a> var a A, would "" be part of the syntax or the type parameters?
+
+Referencing a generic class
+---------------------------
+Expanding a generic class is similar to C++, C#, and Java.  Use the syntax shown below.
+
+~~~~
+var GenericClass name = new GenericClass
+~~~~
+
+Calling a generic procedure
+---------------------------
+Now that ASIL is expecting type parameters, it can expect, and even require, them.  So use this syntax.
+
+~~~~
+GenericCommand myEnumInstance
+
+var String name 
+name = GenericFunction "test"
+
+GenericStatement var MyStruct myStructInstance
+  ' Do something
+~~~~
+
+Covariance and Contravariance
+-----------------------------
+It is unknown how useful Contravariance is.  But Covariance can be used.  Both are shown here, but Contravariance might not survive.
+
+~~~~
+var GenericClass ' Covariance
+var GenericClass ' Contravariance
+~~~~

Generics modified by Will Pittenger

Will Pittenger — Thu, 06 Feb 2014 18:58:00 -0000

Overview
What can and can't be generic
Types of generic type parameters
A simple generic class
A generic class with restrictions on the type parameters

Overview

Generics in ASIL are closer to .NET generics most closely in usage than Java. That's because Java generics are more like "pseudo-generics". Java strips the type information out and converts the generics into their raw form. This makes it impossible to access information about the type parameters at run time. The syntax is loosely adapted from C#.

What can and can't be generic

The table below shows what can and can't be generic. Note while the various types of variables and properties themselves can't be generic, they can be instances of generics.

Identifier type	Yes or no
Conditional variable	✗
Operator	✗
Constant	✗
Global variable (DASIL)	✗
Local variable	✗
Data member variable	✗
Primitive-based enum	✗
Properties	✗
Structure	✓
Class	✓
Interface	✓
Structure-based enum	✓
Command	✓
Function	✓
Complex Statement	✓

Types of generic type parameters

ASIL generic type fall into several categories. Those are primitives, enums, structs, struct-based enums, and classes. [Delegates] and [Events] are considered to be instances of classes.

A simple generic class

The class below takes two type parameters. Notice the type parameters go between the [class] word and the class identifier. This will be explained with the talk on generic procedures.

class <a, b> Name
  public function GoLeft a HowMuch
      returns b
    ' Do something with HowMuch and return a variable of type b

A generic class with restrictions on the type parameters

If you need to ensure the passed type has some members, the [where] clause comes in handy. This class requires a passed type to derive from X and implement IComparable.

class <a> Name
    where
      a
        inherits X
        implements IComparable
  ' Make use of A

This generic class takes type parameters with a different type of restriction.

class <a, b, c, d> Class2
    where
      a = enum ' must be an enum
      b = struct enum ' must be a struct-based enum
      c = struct ' must be a struct or class
      d = class ' Must be a class