That's why include/require_once exists.

Thanks for your comment; I did already know about require_once(). Sorry if my test case was too simple; there are many better reasons for doing this, notably if the files to be included (or their children) contain a mix of functions and other code, in which case we only want to define the functions once, but we need to invoke the rest of the code every time. 


Here is a real example. I have a (complicated) website written in PHP, with multiple users. Each page is dynamically generated, according to both the query-string and the credentials saved in $_SESSION.

A user wants to export his data, essentially crawling part of the site, while logged in. Thus, we have something like the following (simplified) in export.php:

function capture_html ($page, $get){
   $_GET = $get; $_POST=array();   
   //but, we explicitly want to keep $_SESSION
   ob_start();
   include ($page);
   $html = ob_get_contents();
   ob_end_clean;
   return ($html);
}
   
//iterate over multiple sets of pages and files:
file_put_contents("1.html",capture_html("details.php", array("id" => "5") ));
file_put_contents("2.html",capture_html("details.php", array("id" => "6") )); 
file_put_contents("3.html",capture_html("messages.php",array("id" => "532"))); 
...
//and now zip the archive and offer the .zip to the user.
  

This is admittedly ugly in terms of recursion. The problem arises when the same $page is captured twice with different parameters: all the functions which normally don't clash then conflict with themselves. In this example, repeated use of file_get_contents($url) would be no good, because the view of ($url) would be for a non-loggedin user. 

I hope that makes sense.

That's a problem of architecture: you've clearly written your pages so that they cannot all be executed at once, but that's exactly what you're trying to do with them.
The standard practice of putting classes and functions in separate files, away from the "presentation" files, would save you from this problem.

I do see your point about the architecture, although even if I had put all the functions in separate pages, so that, (in my example), 

  details.php (the presentation layer) contains no functions, but itself
  requires header.php and functions.php (which contain only functions).

this still wouldn't help, unless every single function within the other files is also wrapped in function_exists().

I admit my example is a quick and dirty hack, trying to write a 1 hour wrapper around a 3-man-year website, which is reasonably well architected and factored, but by no means perfect, and without the time for a major job of refactoring.

Also, while important functions and classes do go into separate files, I can't believe most programmers are immune from having the occasional specific 3-line function within their presentation layer. 

Furthermore, this is an interesting way to attract bugs: it is relatively rare to test the convoluted code-path, whereas the normal "straight through" path is common. Adding a new function would work perfectly well in the common case, but would break the rare case (and most of us are good, but not 100% perfect at testing every last permutation).

Anyway, it seems to me that my proposal would be simple to implement, have no negative side effects, and eliminate a common frustration of wasted time, and sometimes corner-case crashes. Since the intent of the programmer is unambiguous, why not do it?  It would also be compatible with bash, perl,and python, all of which permit this. 

I'm sorry that I don't know the PHP internals well enough to offer a patch - but I'd have thought it's quite straightforward, changing the parser's logic on encountering a function from:

if (function F is already defined){
   print error message (earlier_file_linenum, this_file_linenum)
   die()
}else{
   parse function F
}

to:

if (function F is already defined){
   if (this_file_linenum ==  earlier_file_linenum
         skip_to_end_of F
         raise E_NOTICE
   }else{
        print error message (earlier_file_linenum, this_file_linenum)
        die()
   }
}else{
   parse function F
}