morrisonlevi

In PHP anonymous functions and closures are really useful for callbacks but they are verbose:

array_map(function($x) {
    return $x * $x * $x; 
}, $input);

The short-closure proposal by Bob tries to address this by introducing ~>:

array_map($x ~> $x * $x * $x, $input);

// or

morrisonlevi

<?php

namespace Spl;

/**
 * Indicates that a structure is designed to operate efficiently at both the
 * front and the back of a dataset.
 * @template T
 */
interface Deque

morrisonlevi

<?php
namespace PHP {

	/* new semantic: $var[] = ; will look for ArrayAppendAccess first,
	 * then it will try ArrayWriteAccess with null key, which may fail.
	 */
	interface ArrayAppendAccess<-V> {
		function offsetAppend(V $value): void;
	}

morrisonlevi

cmake_minimum_required(VERSION 3.12)
project(objectlib LANGUAGES CXX)

add_library(box OBJECT box.cc box.hh)
add_library(make_box OBJECT make_box.cc make_box.hh)
target_link_libraries(make_box PUBLIC box)

add_executable(main main.cc)
target_link_libraries(main PUBLIC make_box)

morrisonlevi

cmake_minimum_required(VERSION 3.12)
project(objectlib LANGUAGES CXX)

add_library(box OBJECT box.cc box.hh)
add_library(make_box OBJECT make_box.cc make_box.hh)
target_link_libraries(make_box PUBLIC box)

add_executable(main main.cc)
target_link_libraries(main PUBLIC make_box)

morrisonlevi

In EcmaScript 2015 (ES6) the expression (x) => x * 2 means to create an anonymous function with one parameter x that will return x * 2. For example:

(x) => x * 2
// is equivalent to:
function(x) { return x * 2; }

A modified example from [documentation by Mozilla Developer Network][1] page demonstrates how they are useful:

var a = [

"Hydrogen",

morrisonlevi

Out and inout parameters

• Date: 2017-12-05
• Author: Levi Morrison levim@php.net
• Proposed for: PHP 7.NEXT or 8.0
• Status: Draft

Introduction

Taking parameters by references allows functions to modify variables and those modifications are viewable in the sender. This comes at a price: the variable must be moved to the heap to be reference counted. Additionally, the type of the argument is checked on function entry but not on function exit. Interested parties can return by reference and add a return type but this does not scale beyond one parameter. This RFC proposes out and inout parameters which solve these issues while providing additional safety.

morrisonlevi

Let's consider ArrayAccess as a generic type. In order to preseve backwards- compatibility let's default the types to any type. Although I don't like the name mixed this is what documentation uses so I'll use it here:

class ArrayAccess<Element = mixed, Key = mixed> {
    function offsetExists(Key $offset): boolean;
    function offsetGet(Key $offset): Value;
    function offsetSet(?Key $offset, Element $value): void;
    function offsetUnset(Key $offset): void;

morrisonlevi

diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index f1a7e38..a9b5a48 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -550,7 +550,6 @@ foreach_variable:
 		variable			{ $$ = $1; }
 	|	'&' variable		{ $$ = zend_ast_create(ZEND_AST_REF, $2); }
 	|	T_LIST '(' array_pair_list ')' { $$ = $3; $$->attr = ZEND_ARRAY_SYNTAX_LIST; }
-	|	'[' array_pair_list ']' { $$ = $2; $$->attr = ZEND_ARRAY_SYNTAX_SHORT; }
 ;

morrisonlevi

This is the basis for what I think a backwards compatibility break should be defined as and where they are appropriate.

Generally any change which will alter the previous behavior in any way is considered a backwards compatibility break. All backwards compatibility breaks must be voted on as per whatever the current voting rules are.

There are acceptable backwards compatibility breaks for minor releases (again, assuming they pass the vote):

• Emitting new warnings, notices, and deprecations
• Elevating a previous warning, notice or deprecation to be more strict (but not to an exception)
• Adding a concrete method, property or constant to an existing class or trait
• Adding an abstract method is not acceptable