Add any(...) and all(iterable $input, ?callable $cb=null)

Create iterator_every() and iterator_any()

This has merge conflicts which were resolved in the subsequent commit(s).
This commit was used as a basis for implementing an alternate approach to
checking if all()/any() elements in an iterable satisfy a predicate.

Cherry-picked from GH-3597 with modifications

Combine helpers into any() and all(), modernize for php 8

Properly free the result of the callback if it was a refcounted
type such as a string/array.

Fix the default value of the callback.

Co-Authored-By: bugreportuser
Co-Authored-By: Tyson Andre <[email protected]>

Author: 2 people

ext/standard/array.c

@@ -6264,3 +6264,154 @@ PHP_FUNCTION(array_combine)
 	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
+
+static inline void php_array_until(zval *return_value, HashTable *htbl, zend_fcall_info fci, zend_fcall_info_cache fci_cache, int stop_value) /* {{{ */
+{
+	zval args[1];
+	zend_bool have_callback = 0;
+	zval *operand;
+	zval retval;
+	int result;
+
+	if (zend_hash_num_elements(htbl) == 0) {
+		RETURN_BOOL(!stop_value);
+	}
+
+	if (ZEND_FCI_INITIALIZED(fci)) {
+		have_callback = 1;
+		fci.retval = &retval;
+		fci.param_count = 1;
+		fci.params = args;
+	}
+
+	ZEND_HASH_FOREACH_VAL(htbl, operand) {
+		if (have_callback) {
+			zend_bool retval_true;
+			ZVAL_COPY(&args[0], operand);
+
+			/* Treat the operand like an array of size 1  */
+			result = zend_call_function(&fci, &fci_cache);
+			zval_ptr_dtor(operand);
+			if (result == FAILURE) {
+				return;
+			}
+			retval_true = zend_is_true(&retval);
+			zval_ptr_dtor(&retval);
+			/* The user-provided callback rarely returns refcounted values. */
+			if (retval_true == stop_value) {
+				RETURN_BOOL(stop_value);
+			}
+		} else {
+			if (zend_is_true(operand) == stop_value) {
+				RETURN_BOOL(stop_value);
+			}
+		}
+	} ZEND_HASH_FOREACH_END();
+
+	RETURN_BOOL(!stop_value);
+}
+/* }}} */
+
+typedef struct {
+	zval                   *obj;
+	int                    stop_value;
+	int                    result;
+	int                    found;
+	zend_long              has_callback;
+	zend_fcall_info        fci;
+	zend_fcall_info_cache  fcc;
+} php_iterator_until_info;
+
+static int php_traversable_func_until(zend_object_iterator *iter, void *puser) /* {{{ */
+{
+	zend_fcall_info fci;
+	zval retval;
+	php_iterator_until_info *until_info = (php_iterator_until_info*) puser;
+	int result;
+	zend_bool stop;
+
+	fci = until_info->fci;
+	if (ZEND_FCI_INITIALIZED(fci)) {
+		zval *operand = iter->funcs->get_current_data(iter);
+		fci.retval = &retval;
+		fci.param_count = 1;
+		/* Use the operand like an array of size 1 */
+		fci.params = operand;
+		fci.retval = &retval;
+		Z_TRY_ADDREF_P(operand);
+		result = zend_call_function(&fci, &until_info->fcc);
+		zval_ptr_dtor(operand);
+		if (result == FAILURE) {
+			until_info->result = FAILURE;
+			return ZEND_HASH_APPLY_STOP;
+		}
+
+		stop = zend_is_true(&retval) == until_info->stop_value;
+		zval_ptr_dtor(&retval);
+	} else {
+		stop = zend_is_true(iter->funcs->get_current_data(iter)) == until_info->stop_value;
+	}
+	if (stop) {
+		until_info->found = 1;
+		return ZEND_HASH_APPLY_STOP;
+	}
+	return ZEND_HASH_APPLY_KEEP;
+}
+/* }}} */
+
+static inline void php_iterable_until(INTERNAL_FUNCTION_PARAMETERS, int stop_value) /* {{{ */
+{
+	zval *input;
+	zend_fcall_info fci = empty_fcall_info;
+	zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
+
+	ZEND_PARSE_PARAMETERS_START(1, 2)
+		Z_PARAM_ZVAL(input)
+		Z_PARAM_OPTIONAL
+		Z_PARAM_FUNC_OR_NULL(fci, fci_cache)
+	ZEND_PARSE_PARAMETERS_END();
+
+	switch (Z_TYPE_P(input)) {
+		case IS_ARRAY:
+			php_array_until(return_value, Z_ARRVAL_P(input), fci, fci_cache, stop_value);
+			return;
+		case IS_OBJECT:
+			if (instanceof_function(Z_OBJCE_P(input), zend_ce_traversable)) {
+				php_iterator_until_info until_info;
+
+				until_info.obj = input;
+				until_info.fci = fci;
+				until_info.fcc = fci_cache;
+
+				until_info.stop_value = stop_value;
+				until_info.result = SUCCESS;
+				until_info.found = 0;
+
+				if (spl_iterator_apply(until_info.obj, php_traversable_func_until, (void*)&until_info) == SUCCESS && until_info.result == SUCCESS) {
+					RETURN_BOOL(!(until_info.found ^ stop_value));
+				}
+				return;
+			}
+			/* fallthrough */
+		default:
+			zend_argument_type_error(1, "must be of type iterable, %s given", zend_zval_type_name(input));
+			RETURN_THROWS();
+			break;
+	}
+}
+
+/* {{{ proto bool all(array input, ?callable predicate = null)
+   Determines whether the predicate holds for all elements in the array */
+PHP_FUNCTION(all)
+{
+	php_iterable_until(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
+}
+/* }}} */
+
+/* {{{ proto bool any(array input, ?callable predicate = null)
+   Determines whether the predicate holds for at least one element in the array */
+PHP_FUNCTION(any)
+{
+	php_iterable_until(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
+}
+/* }}} */

ext/standard/basic_functions.stub.php

@@ -238,6 +238,10 @@ function array_map(?callable $callback, array $array, array ...$arrays): array {
 /** @param string|int $key */
 function array_key_exists($key, array $array): bool {}
 
+function any(iterable $iterable, ?callable $callback = null): bool {}
+
+function all(iterable $iterable, ?callable $callback = null): bool {}
+
 /**
  * @param string|int $key
  * @alias array_key_exists

ext/standard/basic_functions_arginfo.h

@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 4edb7cad23ccb051dbe267b3979e98892607c98f */
+ * Stub hash: 7254e1bfd2ef7060f6682144462d4a9221205aa6 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_set_time_limit, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0)
@@ -347,6 +347,13 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_key_exists, 0, 2, _IS_BOOL
 	ZEND_ARG_TYPE_INFO(0, array, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_any, 0, 1, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, iterable, IS_ITERABLE, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, callback, IS_CALLABLE, 1, "null")
+ZEND_END_ARG_INFO()
+
+#define arginfo_all arginfo_any
+
 #define arginfo_key_exists arginfo_array_key_exists
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_chunk, 0, 2, IS_ARRAY, 0)
@@ -2307,6 +2314,8 @@ ZEND_FUNCTION(array_reduce);
 ZEND_FUNCTION(array_filter);
 ZEND_FUNCTION(array_map);
 ZEND_FUNCTION(array_key_exists);
+ZEND_FUNCTION(any);
+ZEND_FUNCTION(all);
 ZEND_FUNCTION(array_chunk);
 ZEND_FUNCTION(array_combine);
 ZEND_FUNCTION(base64_encode);
@@ -2930,6 +2939,8 @@ static const zend_function_entry ext_functions[] = {
 	ZEND_FE(array_filter, arginfo_array_filter)
 	ZEND_FE(array_map, arginfo_array_map)
 	ZEND_FE(array_key_exists, arginfo_array_key_exists)
+	ZEND_FE(any, arginfo_any)
+	ZEND_FE(all, arginfo_all)
 	ZEND_FALIAS(key_exists, array_key_exists, arginfo_key_exists)
 	ZEND_FE(array_chunk, arginfo_array_chunk)
 	ZEND_FE(array_combine, arginfo_array_combine)

ext/standard/tests/iterable/all_array.phpt

@@ -0,0 +1,65 @@
+--TEST--
+Test all() function
+--FILE--
+<?php
+/*
+    Prototype: bool all(array $array, mixed $callback);
+    Description: Iterate array and stop based on return value of callback
+*/
+
+function is_int_ex($item)
+{
+    return is_int($item);
+}
+
+echo "\n*** Testing not enough or wrong arguments ***\n";
+
+function dump_all(...$args) {
+    try {
+        var_dump(all(...$args));
+    } catch (Error $e) {
+        printf("Caught %s: %s\n", $e::class, $e->getMessage());
+    }
+}
+
+dump_all();
+dump_all(true);
+dump_all([]);
+dump_all(true, function () {});
+dump_all([], true);
+
+echo "\n*** Testing basic functionality ***\n";
+
+dump_all([1, 2, 3], 'is_int_ex');
+dump_all(['hello', 1, 2, 3], 'is_int_ex');
+$iterations = 0;
+dump_all(['hello', 1, 2, 3], function($item) use (&$iterations) {
+    ++$iterations;
+    return is_int($item);
+});
+var_dump($iterations);
+
+echo "\n*** Testing edge cases ***\n";
+
+dump_all([], 'is_int_ex');
+
+echo "\nDone";
+?>
+--EXPECTF--
+*** Testing not enough or wrong arguments ***
+Caught ArgumentCountError: all() expects at least 1 parameter, 0 given
+Caught TypeError: all(): Argument #1 ($iterable) must be of type iterable, bool given
+bool(true)
+Caught TypeError: all(): Argument #1 ($iterable) must be of type iterable, bool given
+Caught TypeError: all(): Argument #2 ($callback) must be a valid callback, no array or string given
+
+*** Testing basic functionality ***
+bool(true)
+bool(false)
+bool(false)
+int(1)
+
+*** Testing edge cases ***
+bool(true)
+
+Done

ext/standard/tests/iterable/all_traversable.phpt

@@ -0,0 +1,60 @@
+--TEST--
+Test all() function
+--FILE--
+<?php
+/*
+    Prototype: bool all(array $array, ?callable $callback = null, int $use_type = 0);
+    Description: Iterate array and stop based on return value of callback
+*/
+
+function is_int_ex($item)
+{
+    return is_int($item);
+}
+
+function dump_all(...$args) {
+    try {
+        var_dump(all(...$args));
+    } catch (Error $e) {
+        printf("Caught %s: %s\n", $e::class, $e->getMessage());
+    }
+}
+
+
+echo "\n*** Testing not enough or wrong arguments ***\n";
+
+dump_all(new ArrayIterator());
+dump_all(new ArrayIterator(), true);
+
+echo "\n*** Testing basic functionality ***\n";
+
+dump_all(new ArrayIterator([1, 2, 3]), 'is_int_ex');
+dump_all(new ArrayIterator(['hello', 1, 2, 3]), 'is_int_ex');
+$iterations = 0;
+dump_all(new ArrayIterator(['hello', 1, 2, 3]), function($item) use (&$iterations) {
+    ++$iterations;
+    return is_int($item);
+});
+var_dump($iterations);
+
+echo "\n*** Testing edge cases ***\n";
+
+dump_all(new ArrayIterator(), 'is_int_ex');
+
+echo "\nDone";
+?>
+--EXPECTF--
+*** Testing not enough or wrong arguments ***
+bool(true)
+Caught TypeError: all(): Argument #2 ($callback) must be a valid callback, no array or string given
+
+*** Testing basic functionality ***
+bool(true)
+bool(false)
+bool(false)
+int(1)
+
+*** Testing edge cases ***
+bool(true)
+
+Done