Furthermore, after some thought, I’ve decided to split up Fep arrays. In PHP arrays aren’t really arrays in the traditional sense, but more like array/associate array hybrids (JavaScript uses a similar concept). This can be confusing, error-prone and I don’t think that the benefits of having an hybrid array system outweighs the complexity.

Thus, in Fep, there will be two main collection types: lists and dictionaries. Here’s how a Fep list will look like:

// Fep
fep = [ "foo", 1, 2, "bar" ];
fep.count(); // == 4
fep.add( "baz" );
fep.find( x => x > 1 ); // == 2
 
// Will compile into this PHP
$fep = new FepList("foo", 1, 2, "bar");
$fep->count();
$fep->add( "baz" );
$fep->find( function( $x ) { return x > 1 } );

And here’s how a Fep dictionary will look:

// Fep
fep = { blah: "blah", foo: "bar", 0: "zero" };
fep.keys(); // == [ "blah", "foo", 0 ]
fep.containsKey( "foo" ); // == true
fep.remove( "foo" ); // == true
 
// PHP
$fep = new FepDict(array("blah" => "blah", "foo" => "bar", 
         0 => "zero"));
$fep->keys();
$fep->containsKey( "foo" );
$fep->remove( "foo" );

In this article, I’ll write a bit about how I think Fep arrays will look. Keep in mind this a work in progress and is by no means comprehensive. Without further ado…

In PHP, you define an array using the array() construct. Fep will follow the lead of languages like JavaScript, Python, Ruby and Groovy and use the square bracket [] notation.

Initialization

For example, a simple array in PHP is creating like this:

$arr = array(1, 2, 3);

In Fep, this would be done like this:

arr = [1, 2, 3]

There are actually three things to notice here. First, Fep uses square brackets. Second, Fep has optional semicolons (similar to JavaScript and Scala). Third, Fep doesn't prefix all variables with $. This should give your pinky finger a bit of rest and de-noise-ify your Fep code.

How about associative arrays? In this case, I don't want to deviate too much from PHP, so I'm going to go with the same syntax:

// PHP
$fruits = array(
  "fruits"  => array("a" => "orange", "b" => "banana", 
                     "c" => "apple"),
  "numbers" => array(1, 2, 3, 4, 5, 6),
  "holes"   => array("first", 5 => "second", "third")
);
 
// Fep
fruits = 
[
  "fruits"  => ["a" => "orange", "b" => "banana", 
                "c" => "apple"],
  "numbers" => [1, 2, 3, 4, 5, 6],
  "holes"   => ["first", 5 => "second", "third")
]

Decomposition

What about that convenient list construct? In Fep, we'll try again to reduce the typing and improve readability by introducing this syntax:

// PHP
list($a, $b, $c) = array("a", "b", "c");
 
// Fep
a, b, c = ["a", "b", "c"]

Accessors

To fetch a value from a Fep array, the regular PHP-style accessors will be used, with the main difference being that Fep will support negative indexing. That is, $array[-1] == $array[$array.length - 1].

arr = [1, 2, 3]
println $arr[0]    // 1
println [4, 5, 6][1] // 5
println $arr[-1]   // 3
 
mixed = ["a" => "b", "foo"]
println arr["a"] // b
println arr[0]   // foo

API

All arrays in Fep will be Array objects. As such, they'll have access to all the PHP array functions in an object-oriented way. Here's a few examples:

// PHP
$arr = array(1, 2, "x");
$len = count($arr);
array_push($arr, "y", "z");
in_array(1, $arr);
$merged = array_merge($arr, array("a", "b", "c"));
 
// Fep
arr = [1, 2, "x"]
len = arr.length
arr.push("y", "z")
arr.contains(1)
merged = arr + ["a", "b", "c"]

Fep has the following goals:

• Eliminate many of the inconsistencies of PHP while maintaining the core feel of the language. For example, why is there print and echo? Answer: it’s complicated. But it doesn’t have to be! isset() is a language construct that requires brackets but require doesn’t. These are the types of things I’d like to fix.
• PHP has a ton of string functions that are just screaming to be separated into classes. Fep will do this. This will be also done to groups of functions in a similar state.
• PHP isn’t the nicest language, but it’s easy and familiar. It also has a ton of support. Fep will be a sort of meta-language. Fep code will be converted to PHP code before it is run in order to maintain compatibility with the PHP ecosystem.
• PHP’s OO model is a bit strange. Why is the constructor called __construct? To me that’s ugly as shit. I’m also not a big fan of using -> to access methods and attributes. I’d much rather use ., but in order to do that, we’ll probably need to stop using . for concatenation. I’m ok with doing that.

That’s just a few of the things of the top of my head. The development process will follow this pattern:

1. write a series of articles to map out the language (maybe even write a language reference like Python),
2. write a compiler that’ll convert Fep code into PHP code,
3. write a module for Apache that’ll convert .fep files to .php files and then feed them to the PHP module.