What happens if you want to store NULL?
How are you going to distinct between failure and success in this case?

Current behavior is to return FALSE both on error and when key was not found. 

Returning FALSE on failure and NULL on no-result-available feels more natural, at least for functions where a not-found state is not an indication of error. Other extensions (turck-mmcache, mysql, oci8, pdo) I've looked at varies in how they indicate error versus not-found.

Changing this would break interface compat for people using === for comparison though. Any thoughts?

Hi,

If you return FALSE for any reason other than FALSE was the value stored using Memcache::set() et al, how can I retrieve a value FALSE legitimately stored in memcached?

I guess it's just my personal style, but I find it very natural to treat NULL as being either an error or 'not found'.  isset() works similiar:

  $myVar = null;
  var_dump(isset($myVar));

isset() returns FALSE if a variable has been set to NULL, even though the variable does actually exist.

It'd be great to have some form of errorCode or errorMessage method, so that real errors can be quickly diagnosed and corrected in production environments, but maybe that's a different issue? :)

=== b/c break can be solved by releasing Memcache 2.1.0?

Best regards,
Stu

my 2 cents. 

I like to use === FALSE better as it is much more, natural, to me. I do not believe any function should return NULL to represent FALSE/not-found since they are so different. Then again, we see this all the time in external php libraries where developers sometimes use NULL and other times use FALSE. 

In the end, it doesn't matter as long as the devels stay consistent.

As far as getting the distinction between "not found" and "error", I say that in future memcahced versions, exceptions are thrown for errors and let the developer deal with the error case.

An alternative solution is to modify the memcache_get function to take a third parameters (reference) where the value will be stored.
I've implemented it and it works nicely, now i'm able to store  NULL and FALSE values.

Example usage code:
if (memcache_get($m, $key, $val))
{
  print "Got it: $val\n";
}
else
{
  print "Not found :-(\n";
}

If someone is interested i can post a patch for memcache-2.0.4

For the users who need to separate FALSE, NULL and not-found/error, it can be implemented in userspace by always serializing the value before calling Memcache::set()

class ExtendedMemcache extends Memcache {
  function get($key) {
    if (!($buffer = parent::get($key)))
      return false;
    return unserialize($buffer);
  }

  function getInto($key, &$value) {
    if (!($buffer = parent::get($key)))
      return false;
    return $value = unserialize($buffer);
  }

  function set($key, $value) {
    return parent::set($key, serialize($value));
  }
}

As to separating not-found from hard errors, cache clients should treat errors as if the key wasn't non-found and fall back to secondary (persistent, database, ..) storage anyway, with error reporting performed internally through the regular trigger_error(). Closing the bugreport.

//Mikael