or, add a third argument to callback, which is the "regex self" or the regex 
index?

Oops… sorry. My mistake. Test script is:

$repl = [
            '/(\d{2}|(?<!\d))([pm])(\d{2}|)([PMc])/e' => function($m) { return 
$this->_op($m[3], $m[4], rtrim($this->_op($m[1], $m[2]), ";"))'; },

            '/(\d{2}|)([MPmplrc])/e' => function ($m) { return $this->_op($m[1], 
$m[2]); },
        ];

$str = preg_replace_callback(array_keys($repl), array_values($repl), $str);

a simple patch attached, please also see my proposal: 
http://news.php.net/php.internals/67199

I think it would be better if prey_replace_callback function will accept array of 
callbacks as a 2nd argument.

Accepting an array of callbacks can lead to unreconcilable ambiguities. For example:

    class A {
        function __toString() { ... }
        function __invoke($a) { ... }
        function foo($a) { ... }
    }
    function foo($a) { ... }
    
    $a = new A;
    preg_replace_callback([..., ...], [$a, 'foo'], $subject);

There are three different ways of interpreting the callback argument, all equally valid:

1. `(string)$a` and `foo(...)`
2. `$a(...)` and `foo(...)`
3. `$a->foo(...)`

Yes, you are quite right.

I don't like the idea of passing the regex as a second callback argument. The main argument against it is having to test for the regex itself means you have to either globalize an array of regex or duplicate code to add a test inside the callback. Neither should be considered a good coding solution.

The idea behind preg_replace is that you have two arrays and the index of the matched regex is the index we need to use for the replace (i.e. we matched $search[2] so we're going to use $replace[2]). So the second argument of the callback should be the index of the regex in the array that was matched. Here's what I would like to see, expressed in code form

$str = preg_replace_callback(['/\d/', '/\s/'], function(Array $match, $index) { 
    $replace = ['digit', 'space'];
    return $replace[$index];
}, $str);

This is more intuitive, it's cleaner code-wise, it avoids any complicated solutions(no global array of callbacks or regex), it keeps the same basic functionality of preg_replace (array in, array out), and it's still simple enough where you could use an anonymous function inline (which the documentation currently recommends).

PHP 7 adds preg_replace_callback_array() to cover this use case: http://php.net/manual/en/function.preg-replace-callback-array.php