Language

Closures and "this"

What does the following (plain PHP) do?

  class Lambda {
    protected $greeting= 'Hello';
    
    protected function greeter() {
      return function($who) { return $this->greeting.' '.$who; };
    }
    
    public static function main($args) {
      $l= new self();
      $greeter= $l->greeter();
      echo $greeter($args[0] ?: 'World'), PHP_EOL;
    }
  }
  
  Lambda::main(array_slice($argv, 1));

XP on NodeJS: Class constants, annotations, stacktraces

More work has been put into the XP on NodeJS experiment: The compiler now knows how to correctly emit class constants and annotations, and a couple of minor bugs have been fixed. The bigger efforts have gone into stabilizing the XP "Microkernel" (which is what I've decied to call the miniature XP Framework implementation written in JavaScript and adopted to NodeJS as well as Windows Scripting Host):

• We're finally getting inheritance right (or are we ? - )?
  
• Class path is now assembled via class.pth files
  
• Classes can reside freely inside any of the class path elements
  
• Stack traces are now shown, including method names and arguments
  
• Parent class reflection now works
  
• The entry point scripts (tools/node.js and tools/cscript.js) are now generated from a common base
  
• When these are invoked without arguments, they show version and classpath info
  

XP on NodeJS: Flow control, exceptions, loops

The XP on NodeJS experiment continues to grow, with the following now implemented:

• Flow control, via if / else
  
• Exceptions, try, catch, throw and finally
  
• Loops - foreach, for, do and while
  
• ARM blocks
  

XP on NodeJS

Following discussions with Claus and Alex, with the XP compiler's long-thought-about strategy of enabling us to decouple the framework and the platform in mind, and based on the "JSXP" experiment I had started about a year ago, I created a first draft of a write-once, compile, run-multiple approach.

This is the starting point, the XP language in a file called Greet.xp.

public class Greet {
  protected string $greeting = 'Hello';
  
  public void printGreeting(string? $name) {
    util.cmd.Console::writeLine($this.greeting, ' ', $name);
  }
  
  public static void main(string[] $args) {
    new self().printGreeting($args[0]);
  }
}

The new lang.Closeable interface and ARM blocks

The new lang.Closeable interface and the io.streams classes being retrofitted to implement it may not seem very useful on the first glance, although they serve the purpose of supporting the so-called ARM blocks. These are a feature supported by XP Language and reuse the try keyword:

  try ($expression[, $expression[, ...]]) {
    // Statements
  }

XP language cheat sheet: Differences from PHP

Now that we know the basics about the XP language - how to write a "hello world" application, how to compile and run it, and after looking at the underlying type system, and have seen both is quite similar to PHP - let's explore the differences, the object and concatenation operators, changed foreach, array and map syntaxes, the removed function keyword, as well as the now syntactically supported annotations, chaining, enumerations, varargs, and finally, the finally block.

The XP language's type system

As promised in the first article of our XP language series, we will have a look at the type system. The XP language knows about the following types:

• Primitives - The following primitives exist: int, float, string and bool
  
• Reference types - Classes, interfaces and enums, e.g. lang.Object, util.log.Traceable and util.DateInterval
  
• Arrays - An array is a zero-based and continuously numbered list of any type, e.g. string[] or util.Date[].
  
• Maps - A map is a hashtable mapping string keys to any type, e.g. [:string] or [:lang.XPClass]
  
• The variable type - Marks a type that may either be a primitive or any reference type, declared with the keyword "var". The compiler will not be able to verify type correctness in this case and will warn about this - checks will be deferred until runtime.
  

First steps with the XP Language

The XP language is not completely different from the way PHP works, it keeps the flexibility and the general "look and feel" while adding syntactical support for features PHP doesn't support or doesn't support in all versions the XP Framework runs on.

Like in the XP framework, the entry point is always a class. In their most simple form, these classes have a static main() method. An example:

  public class HelloWorld {
    public static void main(string[] $args) {
      util.cmd.Console::writeLine('Hello World from ', self::class.getName(), '!');
    }
  }

Introducing: The next big thing

If you have recently updated your SVN checkout, you may have seen a line like the following flying by:

U    devel/xp/trunk/rfc/0052.rfc.txt

Stay tuned

Subscribe

You can subscribe to the XP framework's news by using RSS syndication.

Categories