chuckadams/module_demo.php-ish

## module_demo.php-ish
////////////////
module My\Stuff\MyModule; // implies “namespace My\Stuff\MyModule”

export class Foo {  }

export function foo() {  }

function bar() {  } // not exported

export string $message = “your ad here”;

export const BEST_NUMBER = 69;

////////////////
module Other\Stuff\OtherModule ;

// import specific items.  Specific syntax like ordering is obviously not set in stone.
import foo as my_foo from My\Stuff\MyModule;
my_foo()

//// module objects, in the const namespace (like classes afaik)
import My\Stuff\MyModule as mod;

mod::Foo $foo = new mod::Foo(); // static things use static syntax
mod::BEST_NUMBER;               // consts also being static things

mod->foo();    // functions become instance methods
mod->message;  // variables become props

//// Above is the most basic stuff.  Nice-to-have features below.

//// dynamic imports
$modname = “My\\Stuff\\MyModule”; // yeah, friggin backslashes i know
$modref = import($modname);
$modref->foo();

//// ::module literals
$modname = My\Stuff\MyModule::module;
$modref = import($modname);

// My\Stuff\MyModule::module doesn’t *have* to be just a string like ::class is,
// but should probably stringify the same for interoperability.
// If ::module were fancier than a string, then perhaps auto-importing...
$modref = My\Stuff\MyModule::module;
$modref->foo();	// -> and :: operators trigger auto-import

//// Module metadata (not specified: how to declare or set it)

// you didn't think we'd use _global_ functions to manage a _module_ system, did you?
$meta = PHP\Module\Metadata::module;
$mm = My\Stuff\MyModule::module;
$meta = $meta->load($mm);

// alternatively, just this:
$meta = PHP\Module\Metadata->load(\My\Stuff\MyModule::module);

$meta->version;
$meta->source;
$meta->bytecode;  // ok maybe not :)
$meta->get('user-defined-key', 'defaultval');

//// random thoughts on a package system
$pkg = $meta->package;
$pkg->version;
$pkg->license;
$pkg->author->name;
$pkg->author->url;

// Now for the money shot.  The syntax is definitely up for grabs here.
import Symfony\Component\Messenger as m in "my-forked/messenger" with ['version' => '>=2.4'];

## wilder-ideas.php-kinda
//// parameterized modules
module Greeter;

export readonly var $name;  // let's resurrect 'var' for declarations
\PHP\Module\Lifecycle->on_import(fn(array $args) => $name = $args['name']);

export function hello() {
  echo "hello $name!\n";
}

// on_import is arbitrary code.  the sky is the limit, as is the deepest level of hell.

module App;
import * as greeter from Acme\Greeter with ['name' => "Jeff"];

greeter->hello();
$dude = greeter->name;  // also exported

//// importing a legacy namespace as a module, then using that module as a namespace
import * as msgr from Symfony\Component\Messenger;

export $send = fn(msgr\MessageBusInterface $bus, ...$args) => $bus->dispatch(...$args)


//// anonymous modules.  with parameters too, why not.  it's basically a function with 162% More Fun.


$greeter = module(string $name, Writer $out) {

  // no special class member syntax, it's all top-level PHP in here.
  $name === 'donnie' and throw new STFUException();

  export $greet = fn() => $out->printLine("hello $name!");
};

$g = $greeter("dude", $some_out_thingie);
$g->greet();
	////////////////
	module My\Stuff\MyModule; // implies “namespace My\Stuff\MyModule”

	export class Foo { }

	export function foo() { }

	function bar() { } // not exported

	export string $message = “your ad here”;

	export const BEST_NUMBER = 69;

	////////////////
	module Other\Stuff\OtherModule ;

	// import specific items. Specific syntax like ordering is obviously not set in stone.
	import foo as my_foo from My\Stuff\MyModule;
	my_foo()

	//// module objects, in the const namespace (like classes afaik)
	import My\Stuff\MyModule as mod;

	mod::Foo $foo = new mod::Foo(); // static things use static syntax
	mod::BEST_NUMBER; // consts also being static things

	mod->foo(); // functions become instance methods
	mod->message; // variables become props

	//// Above is the most basic stuff. Nice-to-have features below.

	//// dynamic imports
	$modname = “My\\Stuff\\MyModule”; // yeah, friggin backslashes i know
	$modref = import($modname);
	$modref->foo();

	//// ::module literals
	$modname = My\Stuff\MyModule::module;
	$modref = import($modname);

	// My\Stuff\MyModule::module doesn’t have to be just a string like ::class is,
	// but should probably stringify the same for interoperability.
	// If ::module were fancier than a string, then perhaps auto-importing...
	$modref = My\Stuff\MyModule::module;
	$modref->foo(); // -> and :: operators trigger auto-import

	//// Module metadata (not specified: how to declare or set it)

	// you didn't think we'd use _global_ functions to manage a _module_ system, did you?
	$meta = PHP\Module\Metadata::module;
	$mm = My\Stuff\MyModule::module;
	$meta = $meta->load($mm);

	// alternatively, just this:
	$meta = PHP\Module\Metadata->load(\My\Stuff\MyModule::module);

	$meta->version;
	$meta->source;
	$meta->bytecode; // ok maybe not :)
	$meta->get('user-defined-key', 'defaultval');

	//// random thoughts on a package system
	$pkg = $meta->package;
	$pkg->version;
	$pkg->license;
	$pkg->author->name;
	$pkg->author->url;

	// Now for the money shot. The syntax is definitely up for grabs here.
	import Symfony\Component\Messenger as m in "my-forked/messenger" with ['version' => '>=2.4'];
	//// parameterized modules
	module Greeter;

	export readonly var $name; // let's resurrect 'var' for declarations
	\PHP\Module\Lifecycle->on_import(fn(array $args) => $name = $args['name']);

	export function hello() {
	echo "hello $name!\n";
	}

	// on_import is arbitrary code. the sky is the limit, as is the deepest level of hell.

	module App;
	import * as greeter from Acme\Greeter with ['name' => "Jeff"];

	greeter->hello();
	$dude = greeter->name; // also exported

	//// importing a legacy namespace as a module, then using that module as a namespace
	import * as msgr from Symfony\Component\Messenger;

	export $send = fn(msgr\MessageBusInterface $bus, ...$args) => $bus->dispatch(...$args)


	//// anonymous modules. with parameters too, why not. it's basically a function with 162% More Fun.


	$greeter = module(string $name, Writer $out) {

	// no special class member syntax, it's all top-level PHP in here.
	$name === 'donnie' and throw new STFUException();

	export $greet = fn() => $out->printLine("hello $name!");
	};

	$g = $greeter("dude", $some_out_thingie);
	$g->greet();