3.1.18  Release 2

“What a ship is, you know, it’s not just a keel and a hull and a deck and sails.
  That is what a ship needs. But what a ship is — really is — is freedom.”

                            — Johnny Depp as Captain Jack Sparrow, Pirates of the Caribbean

Version 2009-08-19-14.01.49.

Changes relative to previous release:

• First-cut OOP support. class is now a reserved word.
• Added an “Experimental Object Oriented Programming Support” tutorial to the “Full Monte” section.
• Added a “Roll-Your-Own Objected Oriented Programming” tutorial to the “Delving Deeper” section.
• Website html pages were previously sequentially numbered; this meant that in general each doc revision changed the names of many pages, defeating deep linking. Page names are now derived from page titles, making them much more stable over time.
• Syntax finalization, including:
  • (IMPORTANT!) The list-forming ("cons") operator is now ’!’ instead of ’.’ — the latter will be needed for dot-product soon.
  • Elimination of a number of reserved words:
    • op is no longer a reserved word. To pass an infix operator as an argument, write (+) instead of (op +).
    • type is no longer a reserved word.
    • generic is no longer a reserved word. Write generic package foo ... instead of generic foo ....
    • generic_api is no longer a reserved word. Write generic api Foo ... instead of generic_api Foo ....
    • rec is no longer a reserved word. Write recursive my ... instead of val rec .... (NB: recursive is not a reserved word.)
    • raise is no longer a reserved word. Write raise exception FOO ... instead of raise FOO ....
    • infix is no longer a reserved word. To declare an operator infix use infix my ... instead of infix ....
    • infixr is no longer a reserved word. To declare an operator right-associative infix use infixr my ... instead of infixr ....
    • nonfix is no longer a reserved word. To declare an operator non-infix use nonfix my ... instead of nonfix ....
    • overload is no longer a reserved word. Syntax to declare an overloaded opeerator now looks like:

          overloaded my + :   ((X, X) -> X)
              =
              ( tagged_int::(+),
                one_word_int::(+),
                two_word_int::(+),
                intgr::(+),
                tagged_unt::(+),
                strcat,
                one_word_unt::(+),
                two_word_unt::(+),
                flt64::(+),
                unt08plus
              );
      
      

• Support for incremental addition of functions to overloaded operators. Just use ’+=’ instead of ’=’ in above syntax.
• Improved support for conventional vector/matrix notation:
  • matrix[i,j] is now supported. (vector[i] was already supported.)
  • matrix[i,j] := ... and vector[i] := ... are now supported.
• Fixed various documentation bugs pointed out by Aurelien and Phil Rand — thanks!
• Incorporated a portability bugfix contributed by Pippijn van Steenhoven — thanks!

We now have thirty-one alphabetic reserved words:

also and api as case class elif else end eqtype esac except exception fi for fprintf fun herein if include my or package printf sharing sprintf stipulate then where with withtype

This is a small enough set to be reasonably easily learned. Few of them are common nouns or verbs likely to be wanted by application programmers as identifiers: the main offenders are api, case, class, end, exception, package and val, and none of them are easily dispensed with. (I considered using "class package" instead of "class" but just could not warm up to it. We might eventually demote class to being a #DEFINE that expands to class package.)

The reserved word eqtype ise obsolescent and should be phased out eventually, but I wouldn’t hold my breath.

The reserved words fprintf, printf and sprintf should ideally be vanilla library functions, but they need special parser support not yet available in generic form to library functions, so I wouldn’t hold my breath on that either.

The reserved words my and val are exactly synonymous. The my form is shorter when used alone; the val form reads better when preceded by modifiers.

The reserved words class and package were synonymous for awhile, but the compiler does now cue on the difference between them to avoid scanning all packages for OOP constructs.

Thus, we might concievably eventually reduce the alphabetic reserved word count to perhaps thirty; we are unlikely to get below that. I do not anticipate us adding reserved words in the foreseeable future; adding non-reserved modifiers to existing reserved words should satisfy our evolutionary needs. (This is inspired by Larry Wall’s focus on Perl evolvability by design, although the Mythryl approach is quite a bit different.)