doc/8.1.generic-with-autos

   1
   2 Generic programming with auto functions
   3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   4
   5  Auto-functions, as we already know, are a very powerful feature
   6 of lwc.  The code expansion can be easilly applied to achieve
   7 generic code: the same code used with different *types*.
   8
   9   As of lwc 1.2, auto functions are redefined if they reference
  10 local typedefs.  For example:
  11
  12         class X1 {
  13                 int i;
  14                 int compare (X1);
  15         };
  16
  17         class X2 : X1 {
  18                 int j;
  19                 int compare (X2);
  20         };
  21
  22         class A {
  23         typedef X1 X;
  24         auto    int a () {
  25                         X i, j;
  26                         return i.compare (j);
  27                 }
  28         };
  29
  30         class B : A {
  31         typedef X2 X;
  32         };
  33
  34 In class B, the auto function 'a()' is redefined and it uses
  35 the X2 type for its definition.  So A.a calls X1.compare and
  36 B.a calls X2.compare and therefore we avoid the overhead of
  37 the virtual table in classes X1 and X2.
  38
  39 Furthermore, local typedefs can be used in the prototypes (return
  40 value and arguments) of auto functions.
  41
  42         class A {
  43         typedef X1 X;
  44         modular
  45         auto    X* a (X1 *x) {
  46                         return (X*) x;
  47                 }
  48         };
  49
  50         class B : A {
  51         typedef X2 X;
  52         };
  53
  54 Which has an effect similar to C++'s covariant return types although
  55 it doesn't always work with virtual functions.
  56
  57 Still, 'template classes' are more generic since they allow the definition
  58 of generic data members. (see container)
  59
  60 ------------------------
  61 Future Directions:
  62
  63 The ability to have pure non-virtual functions and generic programming,
  64 comes naturally with the existance of auto-functions.  It is about
  65 compile-time polymorphism.  Our goal is to use compile-time polymorphism as
  66 much as possible and leave virtual calls in just the necessary places.
  67
  68 In this spirit we could also implement:
  69
  70  - Pure local typedefs.  For example:
  71
  72         class A {
  73         typedef X = 0;
  74         auto    X *a () { /* ... */ }
  75         };
  76
  77         class B : A {
  78         typedef int X;
  79         };
  80
  81    where no code is generated for A.a() because it uses a pure typedef.
  82
  83  - Pure data members.
  84
  85         class A {
  86         typedef X = 0;
  87                 X data;
  88         auto    void a ()       { /* uses this->data member */ }
  89                 void foo ()     { /* doesn't use anything generic */ }
  90         };
  91
  92         class B : A {
  93         typedef int X;
  94         };
  95
  96    where the data member 'data' is really created in class B and no code is
  97    emitted for A.a() because it uses this abstract data member.  With this
  98    addition, we can do almost as much as template classes.
  99
 100 Why not?
 101