Include File Parametric Polymorphism

I found some nice ways to abuse the include files with compilers that support them. I want to implement this into the compilers without it being generics... it is something simpler. I realize it could be reinventing features that other languages already have, and it could be reinventing part of generics or part of templates, or part of polymorphism... but... I don't care. It's the concept that counts and there are benefits to my simple idea here.

It is an extremely simple concept and not some brand new complex paradigm that one has to learn. It is just a way or reusing the same algorithms for different "types". An "array of integer" versus an "array of string" has the same algorithm to add more items to it, so why rewrite the same procedure over and over again in a strongly statically typed language? Problem solved at compile time so speed is not sacrificed, with below solution.

(Note: Standard Pascal was even worse where you had to write your own algorithm for each array that had different bounds.)

This particular pattern should be categorized as Abuse... and I admit it... but it works, and is a proof of concept. It is not too obfuscated if you just look at the template.inc file... the other include files are data hiding and something the programmer shouldn't ever care about. With that being said, this idea can be implemented into a language natively... so it doesn't require this workaround with include files.

Some demos are here:

  http://z505.com/download/lars-poly.zip
  http://z505.com/download/lars-poly2.zip

With a language that has an include file system, such as freepascal, a template looks like this... abusing the include files as our placeholders:

    procedure add(const item: {$I T.inc}; var arr: {$I TArr.inc}); overload;
    var len: integer;
    begin
      // below is the same for EVERY type! Reuse, Reuse!
      len:= length(arr);
      setlength(arr, len+1);
      arr[len]:= item;
    end;

The procedure contains declarations that can be programmed generically now. An array, of an unknown type in the above, is defined as our include file called T.inc, and TArr.inc as the second parameter (Array of T). We fill the include file with any types that we want... and they are no longer fixed since the type file is generic or it contains any type we want. The compiler knows them at compile time based on include file and IFDEF tricks. We can now program and design functions for arrays without reinventing the algorithm for each different type.

This trick is not just for arrays - I simply chose arrays to demonstrate the concept. The procedure implementation defined in "template.inc" maps Add() algorithm (add an item to an array) to several types magically.

This is how our include files look:

Include file: T.inc:

    {$ifdef stringType}string{$endif}
    {$ifdef integerType}integer{$endif}
    // add more types here.. anything.. literally anything

Include file: Tarr.inc

    {$ifdef stringType}astrarr{$endif}
    {$ifdef integerType}intarr{$endif}
    // add more types here.. anything.. I use arrays in this demo

Include file: tpl.inc:

    {$define integerType}{$I template.inc}{$undef integerType}
    {$define stringType} {$I template.inc}{$undef stringType}
    // add more template defines here for each type
    // with macro preproceessor, could be looped (i.e. more abuse,  but not needed)

Include file: template.inc:

    procedure add(const item: {$I T.inc}; var arr: {$I TArr.inc}); overload;
    var len: integer;
    begin
      len:= length(arr);
     {$ifdef integerType} // can tune the procedure for specific types
      if item = 0 then begin writeln('Ha! You can''t add a zero.. '); exit; end;
     {$endif}
     {$ifdef stringType}
      if item = '' then begin writeln('No empty string allowed. '); exit; end;
     {$endif}
      setlength(arr, len+1);
      arr[len]:= item;
    end;

A demo program showing the system in use:

  program example;

  type astrarr = array of string;
       intarr = array of integer;

  // procedure add(const item: string; var arr: astrarr);
  // procedure add(const item: integer; var arr: intarr);}
  // procedure add(const item: anything; var arr: anythingarray);}
  // procedure add(const item: foo; var arr: fooarray);}

  // below template is what above functions end up being
  // but without duplicating the code for each type
  {$I tpl.inc}

  var array1: astrarr;
      array2: intarr;
  begin
    add('blah blah', array1);
    add(123, array2);
    writeln('Item 0 in array1: ', array1[0]);
    writeln('Item 0 in array2: ',array2[0]);
    add('', array1);   // this will give you a nice warning ;-)
    add(0, array2);    // ... same here
    writeln('Length: ', length(array1));
    writeln('Length: ', length(array2));
    add('Foo Bar', array1);   // does it let us?? sure
    add(505,  array2);        // does it let us?? sure
    writeln('Item 1 in array1: ', array1[1]);
    writeln('Item 1 in array2: ', array2[1]);
    writeln('Length: ', length(array1));
    writeln('Length: ', length(array2));
    readln;
  end.

An interesting find that seems to be solving the same issue built into the language:

"ANYREC and ANYPTR

Each base record is implicitly regarded as an extension of the new abstract standard type ANYREC, even if it is declared without explicit base type. ANYREC is an empty record that forms the root of all record type hierarchies. ANYPTR is a new standard type that corresponds to a POINTER TO ANYREC.

These new types make it easier to achieve interoperability between independently developed frameworks, by allowing completely generic parameters. ANYREC = ABSTRACT RECORD END; ANYPTR = POINTER TO ANYREC; PROCEDURE (a: ANYPTR) FINALIZE-, NEW, EMPTY;"

http://npt.cc.rsu.ru/user/wanderer/ODP/component_pascal/component_pascal.html

However, I'll note that this only allows generic arrays... the include file hack could be used for any type and for more creative ideas and concepts.