Remove [const unit], and refactoring

lib/MonadPHP/Chain.php

@@ -13,19 +13,17 @@ public function __set($name, $value) {
 
     public function __get($name) {
         return $this->bind(function($obj) use($name) {
-            if (isset($obj->$name)) {
-                return $obj->$name;
-            }
-            return null;
+            return isset($obj->$name)
+                ? $obj->$name
+                : null;
         });
     }
 
     public function __call($name, array $args = array()) {
         return $this->bind(function($obj) use ($name, $args) {
-            if (is_callable(array($obj, $name))) {
-                return call_user_func_array(array($obj, $name), $args);
-            }
-            return null;
+            return is_callable(array($obj, $name))
+                ? call_user_func_array(array($obj, $name), $args)
+                : null;
         });
     }
 

lib/MonadPHP/Identity.php

@@ -4,6 +4,4 @@
 
 class Identity extends Monad {
 
-    const unit = "MonadPHP\Identity::unit";
-
 }

lib/MonadPHP/ListMonad.php

@@ -2,13 +2,14 @@
 
 namespace MonadPHP;
 
-class ListMonad extends Monad {
+use InvalidArgumentException;
+use Traversable;
 
-    const unit = "MonadPHP\ListMonad::unit";
+class ListMonad extends Monad {
 
     public function __construct($value) {
-        if (!is_array($value) && !$value instanceof \Traversable) {
-            throw new \InvalidArgumentException('Must be traversable');
+        if (!is_array($value) && !$value instanceof Traversable) {
+            throw new InvalidArgumentException('Must be traversable');
         }
         return parent::__construct($value);
     }
@@ -18,19 +19,11 @@ public function bind($function, array $args = array()) {
         foreach ($this->value as $value) {
             $result[] = $this->runCallback($function, $value, $args);
         }
-        return $this::unit($result);
+        return static::unit($result);
     }
 
     public function extract() {
-        $ret = array();
-        foreach ($this->value as $value) {
-            if ($value instanceof Monad) {
-                $ret[] = $value->extract();
-            } else {
-                $ret[] = $value;
-            }
-        }
-        return $ret;
+        return array_map([get_called_class(), 'extractValue'], $this->value);
     }
 
 }

lib/MonadPHP/Maybe.php

@@ -4,13 +4,10 @@
 
 class Maybe extends Monad {
 
-    const unit = "MonadPHP\Maybe::unit";
-
-    public function bind($function){
-        if (!is_null($this->value)) {
-            return parent::bind($function);
-        }
-        return $this::unit(null);
+    public function bind($function) {
+        return is_null($this->value)
+            ? static::unit(null)
+            : parent::bind($function);
     }
 
 }

lib/MonadPHP/Monad.php

@@ -11,21 +11,23 @@ public function __construct($value) {
     }
 
     public static function unit($value) {
-        if ($value instanceof static) {
-            return $value;
-        }
-        return new static($value);
+        return $value instanceof static
+            ? $value
+            : new static($value);
     }
 
     public function bind($function, array $args = array()) {
-        return $this::unit($this->runCallback($function, $this->value, $args));
+        return static::unit($this->runCallback($function, $this->value, $args));
     }
 
     public function extract() {
-        if ($this->value instanceof self) {
-            return $this->value->extract();
-        }
-        return $this->value;
+        return static::extractValue($this->value);
+    }
+
+    public static function extractValue($value) {
+        return $value instanceof self
+            ? $value->extract()
+            : $value;
     }
 
     protected function runCallback($function, $value, array $args = array()) {

lib/MonadPHP/Promise.php

@@ -2,9 +2,9 @@
 
 namespace MonadPHP;
 
-class Promise extends Monad {
+use BadMethodCallException;
 
-    const unit = "MonadPHP\Promise::unit";
+class Promise extends Monad {
 
     protected $isResolved = false;
     protected $succeed = null;
@@ -19,22 +19,21 @@ public function __construct($success = null, $failure = null) {
     }
 
     public static function unit($success = null, $failure = null) {
-        return new Promise($success, $failure); 
+        return new Promise($success, $failure);
     }
 
     public function bind($success, $failure) {
-        $obj = $this->unit($success, $failure);
-        if ($this->isResolved) {
-            $obj->resolve($this->succeed, $this->value);
-        } else {
-            $this->children[] = $obj;
-        }
+        $obj = static::unit($success, $failure);
+        $this->isResolved
+            ? $obj->resolve($this->succeed, $this->value)
+            : $this->children[] = $obj;
+
         return $obj;
     }
 
     protected function resolve($status, $value) {
         if ($this->isResolved) {
-            throw new \BadMethodCallException('Promise already resolved');
+            throw new BadMethodCallException('Promise already resolved');
         }
         $this->value = $value;
         $this->isResolved = true;

test/MonadPHP/IdentityTest.php

@@ -6,12 +6,12 @@ class IdentityTest extends \PHPUnit_Framework_TestCase {
 
     public function testBind() {
         $monad = new Identity(1);
-        $this->assertEquals($monad->unit(1), $monad->bind('intval'));
+        $this->assertEquals($monad::unit(1), $monad->bind('intval'));
     }
 
     public function testBindUnit() {
         $monad = new Identity(1);
-        $this->assertEquals($monad, $monad->bind($monad::unit));
+        $this->assertEquals($monad, $monad->bind([$monad, 'unit']));
     }
 
     public function testExtract() {