dikini.net

Intent

return the next context of computation, enable simple and flexible sequencing of computation

Motivation

We want to provide a small domain specific language to improve the readability of the code

Implementation

return the next expected object (state)

Examples

class fluent_class {
  var $state_var;
  function self_next( $arg ) {
    ....
    return $this;
  }
  function other_next( $arg ) {
    ....
    return $this->another;
  }
}

$obj = new fluent_class();
$obj->self_next(1)
    ->self_next(2)
    ->other_next(3)
    ->something_else(4);

Note

This is an awkward idea to explain in words. Essentially you are delegating the desision what is the next object in the chain to the executable methods. It probably should be combined with weaving the values, which we would otherwise return, using accumulator style passing, or some other store method.

Have a look at Jonnay's post for better and more sensible code examples and the Fluenter class.

I sometimes look at this as the imperative "version" of continuation passing, but let's not even get there.

Googles Summer of yawn. - Google's "Summer of Code" has started and they have announced a few PHP projects. Some of them look interesting and useful. However, I am going to pick apart one in particular, that to be honest, looks neither interesting or useful: The PHP Macro Preprocessor.
....

Why does the PHP Preprocessor need to be stuck in a world of #ifdefs and #includes? Instead of blindly copying what the C preprocessor does, why not focus on the languages strengths and deficiencies? The object system of PHP needs to be looked at, and see if it can be improved upon through a method of code transformation.

[sacrificial rabbit]

I sooo totally agree with Jonnay on this. In fact it is simply like reading my own thoughts, just put it better english, , ok, nearly. But what to do about it? I don't really know, I'm afraid I chicken out from digging into the guts of php. When I last looked there it was really scary.

Intent

Abstract out naturally parrallel evaluation

Motivation

Merge two functional streams

Implementation

The coroutines can be implemented using generators. The example shows an example application

Examples

//if gen and gen2 are generators
function merge_data() {
  try {
    do {
      $data[] = 10*gen() + 5 + 4*gen2();
      ...
    } while( some_condition( ... ) );
  } catch ( $e ) { .... }
  return $data;
}

Intent

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

Motivation

We want to be able to postpone the effects of a computation, for example delay printing from a function to webserver output until whole web-page is assembled

Implementation

This is an alternative implementation based on protocol method, rather than interfaces

Examples

class alt_iterator {
  private $st = array();

  function next() { ... }
  function current() { ... }
  function valid() { ... }
  //... put the rest here

  function protocol() {
    return array(
             array($this,'next'),
             array($this,'current'),
             array($this,'valid'),
	     .....
	     );
  }
  
}

//an example use
function do_them($itor, $callback ) {
  list($next, $current, $valid, ...) = $itor->protocol();
  while($valid) {
    $callback( $current );
    $next();
  }
}

Intent

A function/method call results in a promise for future computation

Motivation

We want to be able to postpone the effects of a computation, for example delay printing from a function to webserver output until whole web-page is assembled

Implementation

Instead of evaluating a function, we deliver a promise - a callable with no arguments, which when forced is executed

Examples

//for simplicity handle only functions with one argument 
class promise { 
  private $args = null;
  private $func = null;
  function __construct($func, $args) { 
    $this->func = $func; 
    $this->args = $args;
  } 
  function evaluate() { 
    call_user_func($this->func,$this->args);
  } 
} 

function delay( $func, $arg ) {
  return array(new promise($func, $arg), 'evaluate'); 
}

//example use
...
$chunks[] = delay('a_printer',$a_variable);
...
foreach($chunks as $chunk ) {
  if(is_callable($chunk)) {
    $chunk(); //force - this does it's own printing in this example
  } else {
    print $chunk;
  }
}