Brainstorming on a concept for PHP I am calling "Projection" here.

!PhpProjection.md

Brainstorming on a concept for PHP I am calling "Projection" here. This could be a new API for PHP or just extensions to Reflection.

The examples below are far from complete and I am sure there are missing aspects in some of these interfaces as this is just an exploration of concept and not something fully tested.

Note that I used leading underscores on file names to order which files are displayed by Gist above the other files, except for _Class, _Interface and _Trait which have leading underscores to match the class names, because class, interface and trait are reserved words in PHP.

___main.php

<?php
/**
 * This illustrates how Projection might work to create a class
 */

$class = new ProjectionClass( 'ShoppingCart' );

$property = new ProjectionProperty( '_items' );
$property->setType( new ProjectionType( Projection::ARRAY ) );
$property->setDefaultValue( [] );
$property->setPrivate( true );
$class->addProperty( $property );

$method    = new ProjectionMethod( 'add_item' );
$parameter = new ProjectionParameter( 'item_id' );
$parameter->setType( new ProjectionType( Projection::INT ) );
$method->addParameter( $parameter );
$method->setClosure( function ( string $item_id ) {
	self::$_items[] = $item_id;
} );
$class->addMethod( $method );

$method = new ProjectionMethod( 'get_items' );
$method->setType( new ProjectionType( Projection::ARRAY ) );
$method->setClosure( function () {
	return self::$_items;
} );
$class->addMethod( $method );

Projection::declare( $class );

$cart = new ShoppingCart();
$cart->add_item( 'ABC-123' );
print_r( $cart->get_items() );

__Projection.php

<?php

class Projection {
	const ARRAY = 'array';
	const INT = 'int';

	static function declare( $projector ) {
		// Implement code to generate OpCode for the independent language element
	}
}

__ProjectionClass.php

<?php

use Projection\ClassConstant;
use Projection\Property;
use Projection\Method;

class ProjectionClass implements Projection\_Class {

	public function __construct( string $name ) { }

	function setNamespace( string $namespace_name ) {
		// TODO: Implement setNamespace() method.
	}

	function addConstant( ClassConstant $constant ) {
		// TODO: Implement addConstant() method.
	}

	function addProperty( Property $property ) {
		// TODO: Implement addProperty() method.
	}

	function setParent( string $class_name ) {
		// TODO: Implement setParent() method.
	}

	function addInterface( string $interface_name ) {
		// TODO: Implement addInterface() method.
	}

	function toReflectionClass(): ReflectionClass {
		// TODO: Implement toReflectionClass() method.
		return new ReflectionClass('');
	}

	function addMethod( Method $method ) {
		// TODO: Implement addMethod() method.
	}

	function addTrait( string $trait_name ) {
		// TODO: Implement addTrait() method.
	}
}

__ProjectionMethod.php

<?php

use Projection\Type;
use Projection\Parameter;

class ProjectionMethod implements Projection\Method {

	public function __construct( string $name ) { }

	function setStatic( bool $isStatic ) {
		// TODO: Implement setStatic() method.
	}

	function setPublic( bool $isPublic ) {
		// TODO: Implement setPublic() method.
	}

	function setPrivate( bool $isPrivate ) {
		// TODO: Implement setPrivate() method.
	}

	function setProtected( bool $isProtected ) {
		// TODO: Implement setProtected() method.
	}

	function setClosure( Closure $method ) {
		// TODO: Implement setClosure() method.
	}

	function setType( Type $type ) {
		// TODO: Implement setType() method.
	}

	function addParameter( Parameter $parameter ) {
		// TODO: Implement addParameter() method.
	}
}

__ProjectionParameter.php

<?php

use Projection\Type;

class ProjectionParameter implements Projection\Parameter {

	public function __construct( string $name ) { }

	function setDefaultValue( $value ) {
		// TODO: Implement setDefaultValue() method.
	}

	function setType( Type $type ) {
		// TODO: Implement setType() method.
	}
}

__ProjectionProperty.php

<?php

use  \Projection\Type;

class ProjectionProperty implements Projection\Property {

	public function __construct( string $name ) { }

	function setStatic( bool $isStatic ) {
		// TODO: Implement setStatic() method.
	}

	function setDefaultValue( $value ) {
		// TODO: Implement setDefaultValue() method.
	}

	function setDocComment( string $comment ) {
		// TODO: Implement setDocComment() method.
	}

	function setPublic( bool $isPublic ) {
		// TODO: Implement setPublic() method.
	}

	function setPrivate( bool $isPrivate ) {
		// TODO: Implement setPrivate() method.
	}

	function setProtected( bool $isProtected ) {
		// TODO: Implement setProtected() method.
	}

	function setType( Type $type ) {
		// TODO: Implement setType() method.
	}

	function setValue( $value ) {
		// TODO: Implement setValue() method.
	}
}

__ProjectionType.php

<?php

class ProjectionType implements Projection\Type {

	public function __construct( string $name ) { }

	function setAllowsNull( bool $allowsNull ) {
		// TODO: Implement setAllowsNull() method.
	}

	function toReflectionType(): ReflectionType {
		// TODO: Implement toReflectionType() method.
		return new ReflectionType();
	}

	function __toString(): string {
		// TODO: Implement __toString() method.
		return '';
	}
}

_Class.php

<?php

namespace Projection;

use ReflectionClass;

interface _Class extends
	Named,
	CanBeNamespaced,
	CanImplementInterfaces,
	CanUseTraits,
	CanHaveOneParent,
	CanDeclareConstants,
	CanDeclareMethods,
	CanDeclareProperties {

	function toReflectionClass():ReflectionClass;
}

_Interface.php

<?php

namespace Projection;

interface _Interface extends
	Named,
	CanHaveManyParents,
	CanBeNamespaced,
	CanDeclareConstants,
	CanDeclareMethods,
	CanDeclareProperties {
	
}

_Trait.php

<?php

namespace Projection;

interface _Trait extends 
	Named,
	CanBeNamespaced,
	CanDeclareMethods,
	CanDeclareProperties {
	
	function setAlias(string $alias);

}

CanBeNamespaced.php

<?php

namespace Projection;

interface CanBeNamespaced {
	function setNamespace( string $namespace_name );
}

CanBeStatic.php

<?php

namespace Projection;

interface CanBeStatic {
	function setStatic(bool $isStatic);
}

CanDeclareConstants.php

<?php

namespace Projection;

interface CanDeclareConstants {
	function addConstant( ClassConstant $constant );
}

CanDeclareMethods.php

<?php

namespace Projection;

interface CanDeclareMethods {
	function addMethod( Method $method );
}

CanDeclareProperties.php

<?php

namespace Projection;

interface CanDeclareProperties {
	function addProperty( Property $property );
}

CanHaveDefault.php

<?php

namespace Projection;

interface CanHaveDefault {
	function setDefaultValue($value);
}

CanHaveDocComment.php

<?php

namespace Projection;

interface CanHaveDocComment  {
	function setDocComment(string $comment);
}

CanHaveManyParents.php

<?php

namespace Projection;

interface CanHaveManyParents {
	function addParent( string $interface_name );
}

CanHaveOneParent.php

<?php

namespace Projection;

interface CanHaveOneParent {
	function setParent( string $class_name );
}

CanHaveParameters.php

<?php

namespace Projection;

interface CanHaveParameters  {
	function addParameter(Parameter $parameter);
}

CanImplementInterfaces.php

<?php

namespace Projection;

interface CanImplementInterfaces {
	function addInterface( string $interface_name );
}

CanUseTraits.php

<?php

namespace Projection;

interface CanUseTraits {
	function addTrait( string $trait_name );
}

ClassConstant.php

<?php

namespace Projection;

interface ClassConstant extends
  Constant, 
  HasVisibility, 
  CanHaveDocComment {
}

Constant.php

<?php

namespace Projection;

interface Constant extends
	NamedAndValued, 
  Typed, 
  Valued {
}

HasVisibility.php

<?php

namespace Projection;

interface HasVisibility {
	function setPublic(bool $isPublic);
	function setPrivate(bool $isPrivate);
	function setProtected(bool $isProtected);
}

Method.php

<?php

namespace Projection;

use Closure;

interface Method extends
	Named,
	CanBeStatic,
	CanHaveParameters,
	HasVisibility,
	Typed {

	function setClosure(Closure $method);
}

Named.php

<?php

namespace Projection;

interface Named {
	function __construct(string $name);
}

NamedAndValued.php

<?php

namespace Projection;

interface NamedAndValued {
	function __construct(string $name, $value);
}

Parameter.php

<?php

namespace Projection;

interface Parameter
	extends Named, Typed, CanHaveDefault {
}

Property.php

<?php

namespace Projection;

interface Property extends
	Named,
	Typed,
	CanBeStatic,
	HasVisibility,
	CanHaveDocComment,
	CanHaveDefault,
	Valued {
}

toString.php

<?php

namespace Projection;

interface toString  {
	function __toString(): string;
}

Type.php

<?php

namespace Projection;

use ReflectionType;

interface Type extends 
  Named,
  toString {
    
	function setAllowsNull(bool $allowsNull);
	function toReflectionType():ReflectionType;
}

Typed.php

<?php

namespace Projection;

interface Typed {
	function setType(Type $type);
}

Valued.php

<?php

namespace Projection;

interface Valued {
	function setValue($value);
}