From 24430311dd5a9f94a0417ce6f7ef848dc8d1c780 Mon Sep 17 00:00:00 2001
From: Tim McIver <tim@timmciver.com>
Date: Sat, 12 Jan 2019 22:33:43 -0500
Subject: [PATCH 1/3] Fix Validation::apply and Validation::append to use a
 Semigroup instance for appending Failures.

---
 src/Typeclass/Applicative.php                 |  5 +-
 src/Validation/Failure.php                    | 16 +++---
 src/Validation/Success.php                    | 32 +++++++++--
 src/Validation/Validation.php                 | 20 ++++++-
 src/Validation/ValidationApplicative.php      | 19 ++++++-
 .../Applicative/ValidationApplicativeTest.php | 56 ++++++++++++++++++-
 test/Validation/ValidationApplicativeTest.php | 22 +++++---
 test/Validation/ValidationSemiGroupTest.php   | 18 ++++--
 8 files changed, 155 insertions(+), 33 deletions(-)

diff --git a/src/Typeclass/Applicative.php b/src/Typeclass/Applicative.php
index 2ca52d9..f302fa7 100644
--- a/src/Typeclass/Applicative.php
+++ b/src/Typeclass/Applicative.php
@@ -35,6 +35,7 @@ function apply($ff, $fa = null);
    * a context and `$fResult` is the result of calling the function on the
    * arguments - in a context.
    */
-  function __invoke();
+  // TODO Implement or remove. The Semigroup requirement makes this more awkward
+  //  than with other types.
+  //function __invoke();
 }
-
diff --git a/src/Validation/Failure.php b/src/Validation/Failure.php
index 70fdb53..e4375a6 100644
--- a/src/Validation/Failure.php
+++ b/src/Validation/Failure.php
@@ -25,31 +25,31 @@ protected function applyNoArg() {
     return $this;
   }
 
-  protected function applyToArg($applicativeArgument) {
-    return $applicativeArgument->applyToFailure($this);
+  protected function applyToArg($applicativeArgument, SemiGroup $semiGroup) {
+    return $applicativeArgument->applyToFailure($this, $semiGroup);
   }
 
   protected function applyToSuccess($success) {
     return $this;
   }
 
-  protected function applyToFailure($failure) {
+  protected function applyToFailure($failure, SemiGroup $semiGroup) {
     // it's nice to be able to reuse this functionality!
-    return $this->appendToFailure($failure);
+    return $this->appendToFailure($failure, $semiGroup);
   }
 
-  public function append($other, SemiGroup $semiGroup = null) {
-    return $other->appendToFailure($this, $semiGroup);
+  public function append($other, SemiGroup $innerSemigroup) {
+    return $other->appendToFailure($this, $innerSemigroup);
   }
 
   protected function appendToSuccess($leftSuccess) {
     return $leftSuccess;
   }
 
-  protected function appendToFailure($failure, SemiGroup $semiGroup) {
+  protected function appendToFailure($failure, SemiGroup $innerSemigroup) {
     $leftVal = $failure->val;
     $rightVal = $this->val;
-    $appendedResult = $semiGroup->append($leftVal, $rightVal);
+    $appendedResult = $innerSemigroup->append($leftVal, $rightVal);
 
     return new Failure($appendedResult);
   }
diff --git a/src/Validation/Success.php b/src/Validation/Success.php
index d7fcd38..92c7b98 100644
--- a/src/Validation/Success.php
+++ b/src/Validation/Success.php
@@ -48,10 +48,27 @@ public function flatMap(callable $f) {
   }
 
   protected function applyNoArg() {
-    return call_user_func($this->val);
+    // Since we don't know if the wrapped function will throw an exception, we
+	// wrap the call in a try/catch. The result wiil be Failure if there's an
+	// exception or if the result is null.
+    $validationResult = null;
+	try {
+      $result = call_user_func($this->val);
+
+      // If the result is null, we return Nothing.
+      if (is_null($result)) {
+        $validationResult = self::failure("The result of calling the wrapped function was null.");
+      }
+	} catch (\Exception $e) {
+      $validationResult = self::failure("There was an exception when calling the wrapped function: " . $e->getMessage());
+	}
+
+	return is_null($validationResult) ?
+      new Success($result) :
+      $validationResult;
   }
 
-  protected function applyToArg($applicativeArgument) {
+  protected function applyToArg($applicativeArgument, SemiGroup $semiGroup) {
     return $applicativeArgument->applyToSuccess($this);
   }
 
@@ -65,11 +82,18 @@ protected function applyToSuccess($success) {
     return $this->map($pf);
   }
 
-  protected function applyToFailure($failure) {
+  protected function applyToFailure($failure, SemiGroup $semiGroup) {
     return $failure;
   }
 
-  public function append($other, SemiGroup $semiGroup = null) {
+  /**
+   * Append two 'Validation's together.
+   *
+   * @param $other the 'Validation' append to this one.
+   * @param $innerSemigroup A 'Semigroup' instance to use to append two
+   * 'Failure's together.
+   */
+  public function append($other, SemiGroup $innerSemigroup) {
     return $other->appendToSuccess($this);
   }
 
diff --git a/src/Validation/Validation.php b/src/Validation/Validation.php
index 5504937..026d62e 100644
--- a/src/Validation/Validation.php
+++ b/src/Validation/Validation.php
@@ -25,13 +25,29 @@ public function fail($msg = "An unknown error occurred when using a 'Validation'
     return self::failure($msg);
   }
 
+  public function apply($applicativeArgument, SemiGroup $semiGroup) {
+    return is_null($applicativeArgument) ?
+      $this->applyNoArg() :
+      $this->applyToArg($applicativeArgument, $semiGroup);
+  }
+
+  /**
+   * Calls the wrapped function with no arguments.
+   */
+  protected abstract function applyNoArg();
+
+  /**
+   * Calls the wrapped function on the value wrapped in the supplied argument.
+   */
+  protected abstract function applyToArg($applicativeArgument, SemiGroup $semiGroup);
+
   protected abstract function applyToSuccess($success);
 
-  protected abstract function applyToFailure($failure);
+  protected abstract function applyToFailure($failure, SemiGroup $semiGroup);
 
   protected abstract function appendToSuccess($success);
 
-  protected abstract function appendToFailure($failure, SemiGroup $semiGroup);
+  protected abstract function appendToFailure($failure, SemiGroup $innerSemigroup);
 
   public function pure($val) {
     return is_null($val) ?
diff --git a/src/Validation/ValidationApplicative.php b/src/Validation/ValidationApplicative.php
index 22d40cf..513b820 100644
--- a/src/Validation/ValidationApplicative.php
+++ b/src/Validation/ValidationApplicative.php
@@ -2,13 +2,28 @@
 
 namespace TMciver\Functional\Validation;
 
-use TMciver\Functional\Typeclass\BaseApplicativeForObjectApplicative;
+use TMciver\Functional\Typeclass\Applicative;
+use TMciver\Functional\Typeclass\SemiGroup;
 
-class ValidationApplicative extends BaseApplicativeForObjectApplicative {
+class ValidationApplicative implements Applicative {
+
+  private $failureSemigroup;
+
+  function __construct(SemiGroup $failureSemigroup) {
+    $this->failureSemigroup = $failureSemigroup;
+  }
 
   public function pure($v) {
     return is_null($v) ?
       new Failure("Error: called ValidationApplicative::pure with a null value.") :
       new Success($v);
   }
+
+  function map($v, callable $f) {
+    return $v->map($f);
+  }
+
+  function apply($ff, $fa = null) {
+    return $ff->apply($fa, $this->failureSemigroup);
+  }
 }
diff --git a/test/Typeclass/Applicative/ValidationApplicativeTest.php b/test/Typeclass/Applicative/ValidationApplicativeTest.php
index 48c044f..c8cd339 100644
--- a/test/Typeclass/Applicative/ValidationApplicativeTest.php
+++ b/test/Typeclass/Applicative/ValidationApplicativeTest.php
@@ -3,11 +3,65 @@
 namespace TMciver\Functional\Test\Typeclass\Applicative;
 
 use TMciver\Functional\Validation\ValidationApplicative;
+use TMciver\Functional\Validation\Validation;
+use TMciver\Functional\String\StringMonoid;
 
 class ValidationApplicativeTest extends ApplicativeTest {
 
+  private $applicative;
+
+  protected function setUp() {
+    $this->applicative = new ValidationApplicative(new StringMonoid());
+  }
+
   public function getApplicative() {
-    return new ValidationApplicative();
+    return $this->applicative;
+  }
+
+  public function testApplicativeForMultipleArgsNoFailures() {
+
+    // The function
+    $validationFn = Validation::fromValue('substr');
+
+    // The args
+    $validationStr = Validation::fromValue('Hello world!');
+    $validationStart = Validation::fromValue(6);
+    $validationLength = Validation::fromValue(5);
+
+    // Apply the function applicatively
+    $tmp1 = $this->applicative->apply($validationFn, $validationStr);
+    $tmp2 = $this->applicative->apply($tmp1, $validationStart);
+    $validationResult = $this->applicative->apply($tmp2, $validationLength);
+
+    $expectedResult = Validation::fromValue('world');
+
+    $this->assertEquals($expectedResult, $validationResult);
+  }
+
+  public function testApplicativeForMultipleArgsSomeFailures() {
+
+    // The function
+    $validationFn = Validation::fromValue('substr');
+
+    // The args
+    $validationStr = Validation::fromValue('Hello world!');
+    $validationStart = Validation::failure('I am Error!');
+    $validationLength = Validation::failure('I am another Error!');
+
+    // Assign the applicative to a variable in order to call it as a function
+    // (this is because it's an error to try to call it as
+    // $this->applicative(...))
+    $ap = $this->applicative;
+
+    // Apply the function applicatively
+    //$validationResult = $ap($validationFn, $validationStr, $validationStart, $validationLength);
+    $tmp1 = $this->applicative->apply($validationFn, $validationStr);
+    $tmp2 = $this->applicative->apply($tmp1, $validationStart);
+    $validationResult = $this->applicative->apply($tmp2, $validationLength);
+
+    $expectedResult = Validation::failure('I am Error!I am another Error!');
+
+    $this->assertEquals($expectedResult, $validationResult);
   }
 }
 
diff --git a/test/Validation/ValidationApplicativeTest.php b/test/Validation/ValidationApplicativeTest.php
index 5143574..a6e5907 100644
--- a/test/Validation/ValidationApplicativeTest.php
+++ b/test/Validation/ValidationApplicativeTest.php
@@ -2,28 +2,34 @@
 
 use PHPUnit\Framework\TestCase;
 use TMciver\Functional\Validation\Validation;
-use TMciver\Functional\Maybe\Maybe;
+use TMciver\Functional\String\StringMonoid;
 
 class ValidationApplicativeTest extends TestCase {
 
+  private $innerSemigroup;
+
+  protected function setUp() {
+    $this->innerSemigroup = new StringMonoid();
+  }
+
   public function testApplicativeForNoArgs() {
 
     // The function
-    $maybeFn = Maybe::fromValue(function() { return 42; });
+    $validationFn = Validation::fromValue(function() { return 42; });
 
     // Call the function
-    $maybeResult = $maybeFn();
+    $validationResult = $validationFn->apply(null, $this->innerSemigroup);
 
-    $expectedResult = Maybe::fromValue(42);
+    $expectedResult = Validation::fromValue(42);
 
-    $this->assertEquals($expectedResult, $maybeResult);
+    $this->assertEquals($expectedResult, $validationResult);
   }
 
   public function testApplyForSuccessSuccess() {
 
     $validationFunction = Validation::fromValue('addOne');
     $validationArg = Validation::fromValue(1);
-    $validationResult = $validationFunction->apply($validationArg);
+    $validationResult = $validationFunction->apply($validationArg, $this->innerSemigroup);
     $expected = Validation::fromValue(2);
 
     $this->assertEquals($expected, $validationResult);
@@ -33,7 +39,7 @@ public function testApplyForSuccessFailure() {
 
     $validationFunction = Validation::fromValue('addOne');
     $validationArg = Validation::failure("I am Error.");
-    $validationResult = $validationFunction->apply($validationArg);
+    $validationResult = $validationFunction->apply($validationArg, $this->innerSemigroup);
     $expected = $validationArg;
 
     $this->assertEquals($expected, $validationResult);
@@ -44,7 +50,7 @@ public function testApplyForFailureSuccess() {
     $validationFunction = Validation::failure("Error!");
     $validationArg = Validation::fromValue(1);
     
-    $validationResult = $validationFunction->apply($validationArg);
+    $validationResult = $validationFunction->apply($validationArg, $this->innerSemigroup);
     $expected = $validationFunction;
 
     $this->assertEquals($expected, $validationResult);
diff --git a/test/Validation/ValidationSemiGroupTest.php b/test/Validation/ValidationSemiGroupTest.php
index ff44d70..44bdd88 100644
--- a/test/Validation/ValidationSemiGroupTest.php
+++ b/test/Validation/ValidationSemiGroupTest.php
@@ -10,11 +10,17 @@
 
 class ValidationSemiGroupTest extends TestCase {
 
+  private $innerSemigroup;
+
+  protected function setUp() {
+    $this->innerSemigroup = new StringMonoid();
+  }
+
   public function testAppendForSuccessSuccess() {
 
     $success5 = Validation::fromValue(5);
     $success6 = Validation::fromValue(6);
-    $appended = $success5->append($success6);
+    $appended = $success5->append($success6, $this->innerSemigroup);
     $expected = Validation::fromValue(5);
 
     $this->assertEquals($expected, $appended);
@@ -24,7 +30,7 @@ public function testAppendForSuccessFailure() {
 
     $success = Validation::fromValue(5);
     $failure = Validation::failure("hi");
-    $appended = $success->append($failure);
+    $appended = $success->append($failure, $this->innerSemigroup);
     $expected = $success;
 
     $this->assertEquals($appended, $expected);
@@ -79,12 +85,12 @@ public function testAssociativity() {
     $success3 = Validation::fromValue(3);
 
     // First, combine the first two, then that result with the third one
-    $firstTwo = $success1->append($success2);
-    $result1 = $firstTwo->append($success3);
+    $firstTwo = $success1->append($success2, $this->innerSemigroup);
+    $result1 = $firstTwo->append($success3, $this->innerSemigroup);
 
     // Next, combine the first one with the result of combining the last two.
-    $lastTwo = $success2->append($success3);
-    $result2 = $success1->append($lastTwo);
+    $lastTwo = $success2->append($success3, $this->innerSemigroup);
+    $result2 = $success1->append($lastTwo, $this->innerSemigroup);
 
     $this->assertEquals($result1, $result2);
   }

From 5ffdc7615aa6040ebb96e07843b9843c2910e7aa Mon Sep 17 00:00:00 2001
From: Tim McIver <tim@timmciver.com>
Date: Tue, 15 Jan 2019 21:59:09 -0500
Subject: [PATCH 2/3] Rename project to "PhatCats".

---
 composer.json                                 | 10 ++++-----
 src/AssociativeArray.php                      |  4 ++--
 src/Attempt/Attempt.php                       | 10 ++++-----
 src/Attempt/AttemptMonad.php                  |  4 ++--
 src/Attempt/AttemptToMaybe.php                |  4 ++--
 src/Attempt/AttemptVisitor.php                |  2 +-
 src/Attempt/Failure.php                       |  4 ++--
 .../Monoid/AppendSuccessesAttemptMonoid.php   |  8 +++----
 .../Monoid/FirstSuccessAttemptMonoid.php      |  6 ++---
 src/Attempt/Success.php                       | 12 +++++-----
 src/Collection.php                            |  2 +-
 src/Either/Either.php                         |  6 ++---
 src/Either/EitherToMaybe.php                  |  4 ++--
 src/Either/EitherVisitor.php                  |  2 +-
 src/Either/Left.php                           |  4 ++--
 src/Either/Monad/RightFavoringEitherMonad.php | 14 ++++++------
 .../Monoid/AppendRightsEitherMonoid.php       |  8 +++----
 src/Either/Monoid/FirstRightEitherMonoid.php  |  6 ++---
 src/Either/Right.php                          | 12 +++++-----
 src/Int/IntProductMonoid.php                  |  4 ++--
 src/Int/IntSumMonoid.php                      |  4 ++--
 src/LinkedList/ArrayBackedLinkedList.php      |  8 +++----
 src/LinkedList/Cons.php                       | 10 ++++-----
 src/LinkedList/LinkedList.php                 | 18 +++++++--------
 src/LinkedList/LinkedListFactory.php          |  4 ++--
 src/LinkedList/LinkedListMonad.php            |  4 ++--
 src/LinkedList/ListMonoid.php                 |  6 ++---
 src/LinkedList/Nil.php                        |  8 +++----
 src/Maybe/Just.php                            | 16 +++++++-------
 src/Maybe/Maybe.php                           | 12 +++++-----
 src/Maybe/MaybeMonad.php                      |  4 ++--
 src/Maybe/MaybeMonoid.php                     |  8 +++----
 src/Maybe/MaybeT.php                          | 10 ++++-----
 src/Maybe/MaybeTMonad.php                     |  6 ++---
 src/Maybe/MaybeToEither.php                   |  6 ++---
 src/Maybe/MaybeVisitor.php                    |  2 +-
 src/Maybe/Nothing.php                         |  4 ++--
 src/ObjectTypeclass/ObjectApplicative.php     |  2 +-
 src/ObjectTypeclass/ObjectFoldable.php        |  6 ++---
 src/ObjectTypeclass/ObjectFunctor.php         |  2 +-
 src/ObjectTypeclass/ObjectMonad.php           |  2 +-
 src/ObjectTypeclass/ObjectMonoid.php          |  2 +-
 src/ObjectTypeclass/ObjectSemiGroup.php       |  4 ++--
 src/ObjectTypeclass/ObjectTraversable.php     |  2 +-
 src/PartialFunction.php                       |  2 +-
 src/String/StringMonoid.php                   |  4 ++--
 src/Tuple.php                                 |  2 +-
 src/Typeclass/Applicative.php                 |  2 +-
 src/Typeclass/BaseApplicative.php             |  2 +-
 .../BaseApplicativeForObjectApplicative.php   |  2 +-
 src/Typeclass/BaseMonad.php                   |  2 +-
 src/Typeclass/BaseMonadForObjectMonad.php     |  2 +-
 src/Typeclass/BaseMonoid.php                  |  4 ++--
 src/Typeclass/Functor.php                     |  2 +-
 src/Typeclass/FunctorForObjectFunctor.php     |  2 +-
 src/Typeclass/Monad.php                       |  2 +-
 src/Typeclass/Monoid.php                      |  2 +-
 src/Typeclass/SemiGroup.php                   |  2 +-
 src/Util.php                                  |  2 +-
 src/Validation/Failure.php                    |  6 ++---
 src/Validation/Success.php                    |  6 ++---
 src/Validation/Validation.php                 |  8 +++----
 src/Validation/ValidationApplicative.php      |  6 ++---
 test/Array/ArrayTest.php                      | 10 ++++-----
 test/Attempt/AttemptApplicativeTest.php       |  2 +-
 test/Attempt/AttemptFunctorTest.php           |  4 ++--
 test/Attempt/AttemptMonadTest.php             |  6 ++---
 test/Attempt/AttemptTest.php                  |  4 ++--
 test/Attempt/AttemptVisitorTest.php           |  6 ++---
 test/Either/EitherFunctorTest.php             |  4 ++--
 test/Either/EitherMonadTest.php               |  8 +++----
 test/Either/EitherTest.php                    |  4 ++--
 test/Either/EitherVisitorTest.php             |  6 ++---
 test/LinkedList/ArrayBackedLinkedListTest.php |  6 ++---
 test/LinkedList/ConsListTest.php              |  6 ++---
 test/LinkedList/LinkedListFactoryTest.php     |  8 +++----
 test/LinkedList/LinkedListTest.php            | 22 +++++++++----------
 test/Maybe/HeadTest.php                       |  2 +-
 test/Maybe/MaybeApplicativeTest.php           |  2 +-
 test/Maybe/MaybeFunctorTest.php               |  8 +++----
 test/Maybe/MaybeMonadTest.php                 |  6 ++---
 test/Maybe/MaybeTest.php                      |  8 +++----
 test/Maybe/MaybeVisitorTest.php               |  8 +++----
 test/Maybe/ToStringMaybeVisitor.php           |  4 ++--
 test/MaybeT/MaybeTTest.php                    | 10 ++++-----
 test/PartialFunctionTest.php                  |  2 +-
 test/StaticClass.php                          |  2 +-
 .../Typeclass/Applicative/ApplicativeTest.php | 10 ++++-----
 .../Applicative/AttemptApplicativeTest.php    |  6 ++---
 .../Applicative/LinkedListApplicativeTest.php |  4 ++--
 .../Applicative/MaybeApplicativeTest.php      |  4 ++--
 .../Applicative/MaybeTApplicativeTest.php     |  6 ++---
 .../RightFavoringEitherApplicativeTest.php    |  6 ++---
 .../Applicative/ValidationApplicativeTest.php |  8 +++----
 test/Typeclass/Functor/FunctorTest.php        |  2 +-
 .../Functor/LinkedListFunctorTest.php         |  6 ++---
 .../RightFavoringEitherFunctorTest.php        |  6 ++---
 test/Typeclass/Monad/AttemptMonadTest.php     |  8 +++----
 test/Typeclass/Monad/LinkedListMonadTest.php  | 10 ++++-----
 test/Typeclass/Monad/MaybeMonadTest.php       |  8 +++----
 test/Typeclass/Monad/MaybeTMonadTest.php      |  8 +++----
 test/Typeclass/Monad/MonadTest.php            |  2 +-
 .../Monad/RightFavoringEitherMonadTest.php    |  6 ++---
 .../Either/AppendRightsEitherMonoidTest.php   | 12 +++++-----
 .../Either/FirstRightEitherMonoidTest.php     | 10 ++++-----
 .../Typeclass/Monoid/IntProductMonoidTest.php |  4 ++--
 test/Typeclass/Monoid/IntSumMonoidTest.php    |  4 ++--
 test/Typeclass/Monoid/ListMonoidTest.php      |  6 ++---
 test/Typeclass/Monoid/MaybeMonoidTest.php     |  8 +++----
 test/Typeclass/Monoid/MonoidTest.php          |  2 +-
 test/Typeclass/Monoid/StringMonoidTest.php    |  4 ++--
 test/Validation/ValidationApplicativeTest.php |  4 ++--
 test/Validation/ValidationFunctorTest.php     |  6 ++---
 test/Validation/ValidationSemiGroupTest.php   | 12 +++++-----
 114 files changed, 328 insertions(+), 328 deletions(-)

diff --git a/composer.json b/composer.json
index 352ca8f..88eca52 100644
--- a/composer.json
+++ b/composer.json
@@ -1,7 +1,7 @@
 {
-  "name": "tmciver/functional-php",
-  "description": "A functional programming library for PHP.",
-  "keywords": ["functional", "fp"],
+  "name": "serenitylabs/phatcats",
+  "description": "A functional programming library that brings Haskell and Scala Cats like features to PHP.",
+  "keywords": ["functional", "fp", "category theory"],
   "authors": [
     {
       "name": "Tim McIver",
@@ -10,12 +10,12 @@
   ],
   "autoload": {
     "psr-4": {
-      "TMciver\\Functional\\": "src/"
+      "PhatCats\\": "src/"
     }
   },
   "autoload-dev": {
     "psr-4": {
-      "TMciver\\Functional\\Test\\": "test/"
+      "PhatCats\\Test\\": "test/"
     }
   },
   "require": {
diff --git a/src/AssociativeArray.php b/src/AssociativeArray.php
index 38b8529..38cef5d 100644
--- a/src/AssociativeArray.php
+++ b/src/AssociativeArray.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional;
+namespace PhatCats;
 
-use TMciver\Functional\ObjectTypeclass\ObjectTraversable;
+use PhatCats\ObjectTypeclass\ObjectTraversable;
 
 // Just a wrapper around the native PHP array to allow for cool FP goodness.
 class AssociativeArray {
diff --git a/src/Attempt/Attempt.php b/src/Attempt/Attempt.php
index 53a8ad1..14aaa4a 100644
--- a/src/Attempt/Attempt.php
+++ b/src/Attempt/Attempt.php
@@ -1,14 +1,14 @@
 <?php
 
-namespace TMciver\Functional\Attempt;
+namespace PhatCats\Attempt;
 
-use TMciver\Functional\ObjectTypeclass\ObjectMonad;
-use TMciver\Functional\ObjectTypeclass\ObjectMonoid;
+use PhatCats\ObjectTypeclass\ObjectMonad;
+use PhatCats\ObjectTypeclass\ObjectMonoid;
 
 abstract class Attempt {
   use ObjectMonad;
 
-    public static function fromValue($val, $errorMsg = 'Attempted to create TMciver\Functional\Attempt\Success with a null value.') {
+    public static function fromValue($val, $errorMsg = 'Attempted to create PhatCats\Attempt\Success with a null value.') {
         if (is_null($val)) {
             $try = self::fail($errorMsg);
         } else {
@@ -20,7 +20,7 @@ public static function fromValue($val, $errorMsg = 'Attempted to create TMciver\
 
     public static function failure($val) {
         if (is_null($val)) {
-            $try = self::fail('Attempted to create TMciver\Functional\Attempt\Failure with a null value.');
+            $try = self::fail('Attempted to create PhatCats\Attempt\Failure with a null value.');
         } else {
             $try = new Failure($val);
         }
diff --git a/src/Attempt/AttemptMonad.php b/src/Attempt/AttemptMonad.php
index be305c6..b7459dc 100644
--- a/src/Attempt/AttemptMonad.php
+++ b/src/Attempt/AttemptMonad.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Attempt;
+namespace PhatCats\Attempt;
 
-use TMciver\Functional\Typeclass\BaseMonadForObjectMonad;
+use PhatCats\Typeclass\BaseMonadForObjectMonad;
 
 class AttemptMonad extends BaseMonadForObjectMonad {
 
diff --git a/src/Attempt/AttemptToMaybe.php b/src/Attempt/AttemptToMaybe.php
index 5990cda..007da88 100644
--- a/src/Attempt/AttemptToMaybe.php
+++ b/src/Attempt/AttemptToMaybe.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Attempt;
+namespace PhatCats\Attempt;
 
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\Maybe;
 
 class AttemptToMaybe implements AttemptVisitor {
 
diff --git a/src/Attempt/AttemptVisitor.php b/src/Attempt/AttemptVisitor.php
index 2e1eefc..25ea7e9 100644
--- a/src/Attempt/AttemptVisitor.php
+++ b/src/Attempt/AttemptVisitor.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Attempt;
+namespace PhatCats\Attempt;
 
 interface AttemptVisitor {
 
diff --git a/src/Attempt/Failure.php b/src/Attempt/Failure.php
index e133046..77d0a69 100644
--- a/src/Attempt/Failure.php
+++ b/src/Attempt/Failure.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Attempt;
+namespace PhatCats\Attempt;
 
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Typeclass\SemiGroup;
 
 class Failure extends Attempt {
 
diff --git a/src/Attempt/Monoid/AppendSuccessesAttemptMonoid.php b/src/Attempt/Monoid/AppendSuccessesAttemptMonoid.php
index 95e9e15..371be42 100644
--- a/src/Attempt/Monoid/AppendSuccessesAttemptMonoid.php
+++ b/src/Attempt/Monoid/AppendSuccessesAttemptMonoid.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\Attempt\Monoid;
+namespace PhatCats\Attempt\Monoid;
 
-use TMciver\Functional\Typeclass\Monoid;
-use TMciver\Functional\Attempt\Attempt;
-use TMciver\Functional\Attempt\AttemptVisitor;
+use PhatCats\Typeclass\Monoid;
+use PhatCats\Attempt\Attempt;
+use PhatCats\Attempt\AttemptVisitor;
 
 /*
  * This Attempt monoid is a Success-preferring monoid and, in the case of two
diff --git a/src/Attempt/Monoid/FirstSuccessAttemptMonoid.php b/src/Attempt/Monoid/FirstSuccessAttemptMonoid.php
index b9b2b3d..91fac80 100644
--- a/src/Attempt/Monoid/FirstSuccessAttemptMonoid.php
+++ b/src/Attempt/Monoid/FirstSuccessAttemptMonoid.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Attempt\Monoid;
+namespace PhatCats\Attempt\Monoid;
 
-use TMciver\Functional\Typeclass\Monoid;
-use TMciver\Functional\Attempt\Attempt;
+use PhatCats\Typeclass\Monoid;
+use PhatCats\Attempt\Attempt;
 
 /*
  * This Attempt monoid gives the same behavior as Haskell's Attempt SemiGroup. In
diff --git a/src/Attempt/Success.php b/src/Attempt/Success.php
index 648ac22..236cc55 100644
--- a/src/Attempt/Success.php
+++ b/src/Attempt/Success.php
@@ -1,12 +1,12 @@
 <?php
 
-namespace TMciver\Functional\Attempt;
+namespace PhatCats\Attempt;
 
-use TMciver\Functional\Attempt\Failure;
-use TMciver\Functional\AssociativeArray;
-use TMciver\Functional\PartialFunction;
-use TMciver\Functional\Util;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Attempt\Failure;
+use PhatCats\AssociativeArray;
+use PhatCats\PartialFunction;
+use PhatCats\Util;
+use PhatCats\Typeclass\SemiGroup;
 
 class Success extends Attempt {
 
diff --git a/src/Collection.php b/src/Collection.php
index e4b14b6..22d8436 100644
--- a/src/Collection.php
+++ b/src/Collection.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional;
+namespace PhatCats;
 
 trait Collection {
   abstract function add($value);
diff --git a/src/Either/Either.php b/src/Either/Either.php
index 56a828d..d809763 100644
--- a/src/Either/Either.php
+++ b/src/Either/Either.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\Either;
+namespace PhatCats\Either;
 
 abstract class Either {
 
-    public static function fromValue($val, $errorMsg = 'Attempted to create TMciver\Functional\Either\Right with a null value.') {
+    public static function fromValue($val, $errorMsg = 'Attempted to create PhatCats\Either\Right with a null value.') {
         if (is_null($val)) {
             $either = self::fail($errorMsg);
         } else {
@@ -16,7 +16,7 @@ public static function fromValue($val, $errorMsg = 'Attempted to create TMciver\
 
     public static function left($val) {
         if (is_null($val)) {
-            $either = self::fail('Attempted to create TMciver\Functional\Either\Left with a null value.');
+            $either = self::fail('Attempted to create PhatCats\Either\Left with a null value.');
         } else {
             $either = new Left($val);
         }
diff --git a/src/Either/EitherToMaybe.php b/src/Either/EitherToMaybe.php
index 80513bc..3ce0cd3 100644
--- a/src/Either/EitherToMaybe.php
+++ b/src/Either/EitherToMaybe.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Either;
+namespace PhatCats\Either;
 
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\Maybe;
 
 class EitherToMaybe implements EitherVisitor {
 
diff --git a/src/Either/EitherVisitor.php b/src/Either/EitherVisitor.php
index 8d48681..5dbcee6 100644
--- a/src/Either/EitherVisitor.php
+++ b/src/Either/EitherVisitor.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Either;
+namespace PhatCats\Either;
 
 interface EitherVisitor {
 
diff --git a/src/Either/Left.php b/src/Either/Left.php
index e2c2203..8de25b5 100644
--- a/src/Either/Left.php
+++ b/src/Either/Left.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Either;
+namespace PhatCats\Either;
 
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Typeclass\SemiGroup;
 
 class Left extends Either {
 
diff --git a/src/Either/Monad/RightFavoringEitherMonad.php b/src/Either/Monad/RightFavoringEitherMonad.php
index afaa4ba..1e5fc09 100644
--- a/src/Either/Monad/RightFavoringEitherMonad.php
+++ b/src/Either/Monad/RightFavoringEitherMonad.php
@@ -1,11 +1,11 @@
 <?php
 
-namespace TMciver\Functional\Either\Monad;
+namespace PhatCats\Either\Monad;
 
-use TMciver\Functional\Typeclass\BaseMonad;
-use TMciver\Functional\Either\Right;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\PartialFunction;
+use PhatCats\Typeclass\BaseMonad;
+use PhatCats\Either\Right;
+use PhatCats\Either\Either;
+use PhatCats\PartialFunction;
 
 class RightFavoringEitherMonad extends BaseMonad {
 
@@ -16,7 +16,7 @@ public function pure($v) {
   }
 
   /**
-   * @see \TMciver\Functional\Typeclass\Functor::map()
+   * @see \PhatCats\Typeclass\Functor::map()
    */
   public function map($either, callable $f) {
     if ($either->isLeft()) {
@@ -35,7 +35,7 @@ public function map($either, callable $f) {
   }
 
   /**
-   * @see \TMciver\Functional\Typeclass\Monad::flatMap()
+   * @see \PhatCats\Typeclass\Monad::flatMap()
    */
   public function flatMap($either, callable $f) {
     if ($either->isLeft()) {
diff --git a/src/Either/Monoid/AppendRightsEitherMonoid.php b/src/Either/Monoid/AppendRightsEitherMonoid.php
index b43adba..c9f8ab3 100644
--- a/src/Either/Monoid/AppendRightsEitherMonoid.php
+++ b/src/Either/Monoid/AppendRightsEitherMonoid.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\Either\Monoid;
+namespace PhatCats\Either\Monoid;
 
-use TMciver\Functional\Typeclass\Monoid;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Either\EitherVisitor;
+use PhatCats\Typeclass\Monoid;
+use PhatCats\Either\Either;
+use PhatCats\Either\EitherVisitor;
 
 /*
  * This Either monoid is a Right-preferring monoid and, in the case of two
diff --git a/src/Either/Monoid/FirstRightEitherMonoid.php b/src/Either/Monoid/FirstRightEitherMonoid.php
index 973152b..c158c4e 100644
--- a/src/Either/Monoid/FirstRightEitherMonoid.php
+++ b/src/Either/Monoid/FirstRightEitherMonoid.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Either\Monoid;
+namespace PhatCats\Either\Monoid;
 
-use TMciver\Functional\Typeclass\Monoid;
-use TMciver\Functional\Either\Either;
+use PhatCats\Typeclass\Monoid;
+use PhatCats\Either\Either;
 
 /*
  * This Either monoid gives the same behavior as Haskell's Either SemiGroup. In
diff --git a/src/Either/Right.php b/src/Either/Right.php
index 057fd6c..8bbe7c9 100644
--- a/src/Either/Right.php
+++ b/src/Either/Right.php
@@ -1,12 +1,12 @@
 <?php
 
-namespace TMciver\Functional\Either;
+namespace PhatCats\Either;
 
-use TMciver\Functional\Either\Left;
-use TMciver\Functional\AssociativeArray;
-use TMciver\Functional\PartialFunction;
-use TMciver\Functional\Util;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Either\Left;
+use PhatCats\AssociativeArray;
+use PhatCats\PartialFunction;
+use PhatCats\Util;
+use PhatCats\Typeclass\SemiGroup;
 
 class Right extends Either {
 
diff --git a/src/Int/IntProductMonoid.php b/src/Int/IntProductMonoid.php
index 4dddb45..9419de1 100644
--- a/src/Int/IntProductMonoid.php
+++ b/src/Int/IntProductMonoid.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Int;
+namespace PhatCats\Int;
 
-use TMciver\Functional\Typeclass\Monoid;
+use PhatCats\Typeclass\Monoid;
 
 class IntProductMonoid implements Monoid {
 
diff --git a/src/Int/IntSumMonoid.php b/src/Int/IntSumMonoid.php
index dc1b13a..4bcc99a 100644
--- a/src/Int/IntSumMonoid.php
+++ b/src/Int/IntSumMonoid.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Int;
+namespace PhatCats\Int;
 
-use TMciver\Functional\Typeclass\Monoid;
+use PhatCats\Typeclass\Monoid;
 
 class IntSumMonoid implements Monoid {
 
diff --git a/src/LinkedList/ArrayBackedLinkedList.php b/src/LinkedList/ArrayBackedLinkedList.php
index 5fd3ad6..78d3770 100644
--- a/src/LinkedList/ArrayBackedLinkedList.php
+++ b/src/LinkedList/ArrayBackedLinkedList.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\LinkedList;
+namespace PhatCats\LinkedList;
 
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Tuple;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Tuple;
+use PhatCats\Typeclass\SemiGroup;
 
 /**
  * This class implements the `LinkedList` API using a native PHP array.
diff --git a/src/LinkedList/Cons.php b/src/LinkedList/Cons.php
index 99864c2..ea2e63b 100644
--- a/src/LinkedList/Cons.php
+++ b/src/LinkedList/Cons.php
@@ -1,11 +1,11 @@
 <?php
 
-namespace TMciver\Functional\LinkedList;
+namespace PhatCats\LinkedList;
 
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\PartialFunction;
-use TMciver\Functional\Tuple;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Maybe\Maybe;
+use PhatCats\PartialFunction;
+use PhatCats\Tuple;
+use PhatCats\Typeclass\SemiGroup;
 
 class Cons extends LinkedList {
 
diff --git a/src/LinkedList/LinkedList.php b/src/LinkedList/LinkedList.php
index e956497..a7e5f22 100644
--- a/src/LinkedList/LinkedList.php
+++ b/src/LinkedList/LinkedList.php
@@ -1,14 +1,14 @@
 <?php
 
-namespace TMciver\Functional\LinkedList;
+namespace PhatCats\LinkedList;
 
-use TMciver\Functional\ObjectTypeclass\ObjectFoldable;
-use TMciver\Functional\ObjectTypeclass\ObjectTraversable;
-use TMciver\Functional\ObjectTypeclass\ObjectMonad;
-use TMciver\Functional\ObjectTypeclass\ObjectMonoid;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Maybe\MaybeVisitor;
-use TMciver\Functional\Tuple;
+use PhatCats\ObjectTypeclass\ObjectFoldable;
+use PhatCats\ObjectTypeclass\ObjectTraversable;
+use PhatCats\ObjectTypeclass\ObjectMonad;
+use PhatCats\ObjectTypeclass\ObjectMonoid;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Maybe\MaybeVisitor;
+use PhatCats\Tuple;
 
 abstract class LinkedList {
   use ObjectFoldable, ObjectTraversable, ObjectMonoid, ObjectMonad;
@@ -46,7 +46,7 @@ public function cons($value) {
   protected abstract function numConsCells();
 
   /**
-   * @return TMciver\Functional\Maybe\Maybe containing value.
+   * @return PhatCats\Maybe\Maybe containing value.
    */
   public abstract function head();
 
diff --git a/src/LinkedList/LinkedListFactory.php b/src/LinkedList/LinkedListFactory.php
index 533887b..a70127b 100644
--- a/src/LinkedList/LinkedListFactory.php
+++ b/src/LinkedList/LinkedListFactory.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\LinkedList;
+namespace PhatCats\LinkedList;
 
 class LinkedListFactory {
 
@@ -58,7 +58,7 @@ public function cycle($l) {
 	});
 
       // Use reflection to mutate the tail reference of the last element.
-      $tailProp = new \ReflectionProperty('\TMciver\Functional\LinkedList\Cons', 'tail');
+      $tailProp = new \ReflectionProperty('\PhatCats\LinkedList\Cons', 'tail');
       $tailProp->setAccessible(true);
       $tailProp->setValue($last, $cycled);
     }
diff --git a/src/LinkedList/LinkedListMonad.php b/src/LinkedList/LinkedListMonad.php
index c6e7752..c939a76 100644
--- a/src/LinkedList/LinkedListMonad.php
+++ b/src/LinkedList/LinkedListMonad.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\LinkedList;
+namespace PhatCats\LinkedList;
 
-use TMciver\Functional\Typeclass\BaseMonadForObjectMonad;
+use PhatCats\Typeclass\BaseMonadForObjectMonad;
 
 class LinkedListMonad extends BaseMonadForObjectMonad {
 
diff --git a/src/LinkedList/ListMonoid.php b/src/LinkedList/ListMonoid.php
index a08606e..2afe889 100644
--- a/src/LinkedList/ListMonoid.php
+++ b/src/LinkedList/ListMonoid.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\LinkedList;
+namespace PhatCats\LinkedList;
 
-use TMciver\Functional\LinkedList\LinkedListFactory;
-use TMciver\Functional\Typeclass\BaseMonoid;
+use PhatCats\LinkedList\LinkedListFactory;
+use PhatCats\Typeclass\BaseMonoid;
 
 class ListMonoid extends BaseMonoid {
 
diff --git a/src/LinkedList/Nil.php b/src/LinkedList/Nil.php
index 3c24ba8..f62a604 100644
--- a/src/LinkedList/Nil.php
+++ b/src/LinkedList/Nil.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\LinkedList;
+namespace PhatCats\LinkedList;
 
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Tuple;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Tuple;
+use PhatCats\Typeclass\SemiGroup;
 
 class Nil extends LinkedList {
 
diff --git a/src/Maybe/Just.php b/src/Maybe/Just.php
index f94e55b..004afb6 100644
--- a/src/Maybe/Just.php
+++ b/src/Maybe/Just.php
@@ -1,13 +1,13 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
-
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Maybe\Nothing;
-use TMciver\Functional\AssociativeArray;
-use TMciver\Functional\PartialFunction;
-use TMciver\Functional\Util;
-use TMciver\Functional\Typeclass\SemiGroup;
+namespace PhatCats\Maybe;
+
+use PhatCats\Maybe\Maybe;
+use PhatCats\Maybe\Nothing;
+use PhatCats\AssociativeArray;
+use PhatCats\PartialFunction;
+use PhatCats\Util;
+use PhatCats\Typeclass\SemiGroup;
 
 class Just extends Maybe {
 
diff --git a/src/Maybe/Maybe.php b/src/Maybe/Maybe.php
index 4355570..793c5f9 100644
--- a/src/Maybe/Maybe.php
+++ b/src/Maybe/Maybe.php
@@ -1,12 +1,12 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
-use TMciver\Functional\ObjectTypeclass\ObjectMonad;
-use TMciver\Functional\ObjectTypeclass\ObjectMonoid;
-use TMciver\Functional\Typeclass\SemiGroup;
-use TMciver\Functional\Maybe\Just;
-use TMciver\Functional\Maybe\Nothing;
+use PhatCats\ObjectTypeclass\ObjectMonad;
+use PhatCats\ObjectTypeclass\ObjectMonoid;
+use PhatCats\Typeclass\SemiGroup;
+use PhatCats\Maybe\Just;
+use PhatCats\Maybe\Nothing;
 
 abstract class Maybe {
     use ObjectMonoid, ObjectMonad;
diff --git a/src/Maybe/MaybeMonad.php b/src/Maybe/MaybeMonad.php
index 117ad92..4128393 100644
--- a/src/Maybe/MaybeMonad.php
+++ b/src/Maybe/MaybeMonad.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
-use TMciver\Functional\Typeclass\BaseMonadForObjectMonad;
+use PhatCats\Typeclass\BaseMonadForObjectMonad;
 
 class MaybeMonad extends BaseMonadForObjectMonad {
 
diff --git a/src/Maybe/MaybeMonoid.php b/src/Maybe/MaybeMonoid.php
index 5930f51..97981dd 100644
--- a/src/Maybe/MaybeMonoid.php
+++ b/src/Maybe/MaybeMonoid.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
-use TMciver\Functional\Typeclass\BaseMonoid;
-use TMciver\Functional\Typeclass\Monoid;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Typeclass\BaseMonoid;
+use PhatCats\Typeclass\Monoid;
+use PhatCats\Maybe\Maybe;
 
 class MaybeMonoid extends BaseMonoid {
 
diff --git a/src/Maybe/MaybeT.php b/src/Maybe/MaybeT.php
index fb3fd15..5a85f01 100644
--- a/src/Maybe/MaybeT.php
+++ b/src/Maybe/MaybeT.php
@@ -1,11 +1,11 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
-use TMciver\Functional\Typeclass\Monad;
-use TMciver\Functional\ObjectTypeclass\ObjectFunctor;
-use TMciver\Functional\AssociativeArray;
-use TMciver\Functional\PartialFunction;
+use PhatCats\Typeclass\Monad;
+use PhatCats\ObjectTypeclass\ObjectFunctor;
+use PhatCats\AssociativeArray;
+use PhatCats\PartialFunction;
 
 class MaybeT {
   use ObjectFunctor;
diff --git a/src/Maybe/MaybeTMonad.php b/src/Maybe/MaybeTMonad.php
index 175904c..f05b777 100644
--- a/src/Maybe/MaybeTMonad.php
+++ b/src/Maybe/MaybeTMonad.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
-use TMciver\Functional\Typeclass\BaseMonadForObjectMonad;
-use TMciver\Functional\Typeclass\Monad;
+use PhatCats\Typeclass\BaseMonadForObjectMonad;
+use PhatCats\Typeclass\Monad;
 
 class MaybeTMonad extends BaseMonadForObjectMonad {
 
diff --git a/src/Maybe/MaybeToEither.php b/src/Maybe/MaybeToEither.php
index 755a4d0..9fd55b3 100644
--- a/src/Maybe/MaybeToEither.php
+++ b/src/Maybe/MaybeToEither.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
-use TMciver\Functional\Maybe\MaybeVisitor;
-use TMciver\Functional\Either\Either;
+use PhatCats\Maybe\MaybeVisitor;
+use PhatCats\Either\Either;
 
 class MaybeToEither implements MaybeVisitor {
 
diff --git a/src/Maybe/MaybeVisitor.php b/src/Maybe/MaybeVisitor.php
index 95ab124..a3a033f 100644
--- a/src/Maybe/MaybeVisitor.php
+++ b/src/Maybe/MaybeVisitor.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
 interface MaybeVisitor {
 
diff --git a/src/Maybe/Nothing.php b/src/Maybe/Nothing.php
index c87157c..0c96e4d 100644
--- a/src/Maybe/Nothing.php
+++ b/src/Maybe/Nothing.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Maybe;
+namespace PhatCats\Maybe;
 
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Typeclass\SemiGroup;
 
 class Nothing extends Maybe {
 
diff --git a/src/ObjectTypeclass/ObjectApplicative.php b/src/ObjectTypeclass/ObjectApplicative.php
index dc35dd5..d607393 100644
--- a/src/ObjectTypeclass/ObjectApplicative.php
+++ b/src/ObjectTypeclass/ObjectApplicative.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\ObjectTypeclass;
+namespace PhatCats\ObjectTypeclass;
 
 /**
  * A fuctor with application. An applicative containing a function can be
diff --git a/src/ObjectTypeclass/ObjectFoldable.php b/src/ObjectTypeclass/ObjectFoldable.php
index 156aeba..20c5c8e 100644
--- a/src/ObjectTypeclass/ObjectFoldable.php
+++ b/src/ObjectTypeclass/ObjectFoldable.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\ObjectTypeclass;
+namespace PhatCats\ObjectTypeclass;
 
-use TMciver\Functional\Collection;
-use TMciver\Functional\Typeclass\Monoid;
+use PhatCats\Collection;
+use PhatCats\Typeclass\Monoid;
 
 trait ObjectFoldable {
   // not sure if it's a good idea to extend Collection . . .
diff --git a/src/ObjectTypeclass/ObjectFunctor.php b/src/ObjectTypeclass/ObjectFunctor.php
index 5aac9db..2c9340d 100644
--- a/src/ObjectTypeclass/ObjectFunctor.php
+++ b/src/ObjectTypeclass/ObjectFunctor.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\ObjectTypeclass;
+namespace PhatCats\ObjectTypeclass;
 
 trait ObjectFunctor {
 
diff --git a/src/ObjectTypeclass/ObjectMonad.php b/src/ObjectTypeclass/ObjectMonad.php
index 5d0c129..5f8dd9a 100644
--- a/src/ObjectTypeclass/ObjectMonad.php
+++ b/src/ObjectTypeclass/ObjectMonad.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\ObjectTypeclass;
+namespace PhatCats\ObjectTypeclass;
 
 trait ObjectMonad {
   use ObjectApplicative;
diff --git a/src/ObjectTypeclass/ObjectMonoid.php b/src/ObjectTypeclass/ObjectMonoid.php
index 64cae16..4b6c108 100644
--- a/src/ObjectTypeclass/ObjectMonoid.php
+++ b/src/ObjectTypeclass/ObjectMonoid.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\ObjectTypeclass;
+namespace PhatCats\ObjectTypeclass;
 
 trait ObjectMonoid {
     use ObjectSemiGroup;
diff --git a/src/ObjectTypeclass/ObjectSemiGroup.php b/src/ObjectTypeclass/ObjectSemiGroup.php
index 08eb48b..0d51806 100644
--- a/src/ObjectTypeclass/ObjectSemiGroup.php
+++ b/src/ObjectTypeclass/ObjectSemiGroup.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\ObjectTypeclass;
+namespace PhatCats\ObjectTypeclass;
 
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Typeclass\SemiGroup;
 
 trait ObjectSemiGroup {
 
diff --git a/src/ObjectTypeclass/ObjectTraversable.php b/src/ObjectTypeclass/ObjectTraversable.php
index c4857d4..f1a869f 100644
--- a/src/ObjectTypeclass/ObjectTraversable.php
+++ b/src/ObjectTypeclass/ObjectTraversable.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\ObjectTypeclass;
+namespace PhatCats\ObjectTypeclass;
 
 trait ObjectTraversable {
 
diff --git a/src/PartialFunction.php b/src/PartialFunction.php
index bf32e34..6895152 100644
--- a/src/PartialFunction.php
+++ b/src/PartialFunction.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional;
+namespace PhatCats;
 
 use TRex\Reflection\CallableReflection;
 
diff --git a/src/String/StringMonoid.php b/src/String/StringMonoid.php
index 81a8433..1410015 100644
--- a/src/String/StringMonoid.php
+++ b/src/String/StringMonoid.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\String;
+namespace PhatCats\String;
 
-use TMciver\Functional\Typeclass\Monoid;
+use PhatCats\Typeclass\Monoid;
 
 class StringMonoid implements Monoid {
 
diff --git a/src/Tuple.php b/src/Tuple.php
index ad66cce..7485efb 100644
--- a/src/Tuple.php
+++ b/src/Tuple.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional;
+namespace PhatCats;
 
 class Tuple {
 
diff --git a/src/Typeclass/Applicative.php b/src/Typeclass/Applicative.php
index f302fa7..f13c4fc 100644
--- a/src/Typeclass/Applicative.php
+++ b/src/Typeclass/Applicative.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 interface Applicative extends Functor {
 
diff --git a/src/Typeclass/BaseApplicative.php b/src/Typeclass/BaseApplicative.php
index a125b6d..9d265b6 100644
--- a/src/Typeclass/BaseApplicative.php
+++ b/src/Typeclass/BaseApplicative.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 /**
  * An abstract class implementing the Applicative interface containing an
diff --git a/src/Typeclass/BaseApplicativeForObjectApplicative.php b/src/Typeclass/BaseApplicativeForObjectApplicative.php
index 408da50..9bc75e8 100644
--- a/src/Typeclass/BaseApplicativeForObjectApplicative.php
+++ b/src/Typeclass/BaseApplicativeForObjectApplicative.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 /**
  * Applicative to be used as the basis for an Applicative for a type that uses
diff --git a/src/Typeclass/BaseMonad.php b/src/Typeclass/BaseMonad.php
index c6b8151..872685c 100644
--- a/src/Typeclass/BaseMonad.php
+++ b/src/Typeclass/BaseMonad.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 /**
  * BaseMonad contains default implementations for both `flatMap` and `join`.
diff --git a/src/Typeclass/BaseMonadForObjectMonad.php b/src/Typeclass/BaseMonadForObjectMonad.php
index dc3dc83..f276e00 100644
--- a/src/Typeclass/BaseMonadForObjectMonad.php
+++ b/src/Typeclass/BaseMonadForObjectMonad.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 /**
  * Monad to be used as the basis for a Monad for a type that uses the
diff --git a/src/Typeclass/BaseMonoid.php b/src/Typeclass/BaseMonoid.php
index 8f5a732..c3c7b57 100644
--- a/src/Typeclass/BaseMonoid.php
+++ b/src/Typeclass/BaseMonoid.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
-use TMciver\Functional\Typeclass\Monoid;
+use PhatCats\Typeclass\Monoid;
 
 abstract class BaseMonoid implements Monoid {
 
diff --git a/src/Typeclass/Functor.php b/src/Typeclass/Functor.php
index 7a5fb48..6f24df0 100644
--- a/src/Typeclass/Functor.php
+++ b/src/Typeclass/Functor.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 interface Functor {
 
diff --git a/src/Typeclass/FunctorForObjectFunctor.php b/src/Typeclass/FunctorForObjectFunctor.php
index f1f3666..2f24ee0 100644
--- a/src/Typeclass/FunctorForObjectFunctor.php
+++ b/src/Typeclass/FunctorForObjectFunctor.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 /**
  * `DefaultFunctor` is a `Functor` that assumes that the first argument to `map`
diff --git a/src/Typeclass/Monad.php b/src/Typeclass/Monad.php
index 5977b73..60e1b91 100644
--- a/src/Typeclass/Monad.php
+++ b/src/Typeclass/Monad.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 interface Monad extends Applicative {
 
diff --git a/src/Typeclass/Monoid.php b/src/Typeclass/Monoid.php
index 9461eae..c37efd5 100644
--- a/src/Typeclass/Monoid.php
+++ b/src/Typeclass/Monoid.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 interface Monoid extends SemiGroup {
 
diff --git a/src/Typeclass/SemiGroup.php b/src/Typeclass/SemiGroup.php
index 49d5762..5ad725b 100644
--- a/src/Typeclass/SemiGroup.php
+++ b/src/Typeclass/SemiGroup.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Typeclass;
+namespace PhatCats\Typeclass;
 
 interface SemiGroup {
 
diff --git a/src/Util.php b/src/Util.php
index 18156ba..8d8eef2 100644
--- a/src/Util.php
+++ b/src/Util.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional;
+namespace PhatCats;
 
 class Util {
 
diff --git a/src/Validation/Failure.php b/src/Validation/Failure.php
index e4375a6..13ec8f4 100644
--- a/src/Validation/Failure.php
+++ b/src/Validation/Failure.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Validation;
+namespace PhatCats\Validation;
 
-use TMciver\Functional\Util;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Util;
+use PhatCats\Typeclass\SemiGroup;
 
 class Failure extends Validation {
 
diff --git a/src/Validation/Success.php b/src/Validation/Success.php
index 92c7b98..47aabd7 100644
--- a/src/Validation/Success.php
+++ b/src/Validation/Success.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Validation;
+namespace PhatCats\Validation;
 
-use TMciver\Functional\PartialFunction;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\PartialFunction;
+use PhatCats\Typeclass\SemiGroup;
 
 class Success extends Validation {
 
diff --git a/src/Validation/Validation.php b/src/Validation/Validation.php
index 026d62e..3590ddf 100644
--- a/src/Validation/Validation.php
+++ b/src/Validation/Validation.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\Validation;
+namespace PhatCats\Validation;
 
-use TMciver\Functional\ObjectTypeclass\ObjectSemiGroup;
-use TMciver\Functional\ObjectTypeclass\ObjectApplicative;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\ObjectTypeclass\ObjectSemiGroup;
+use PhatCats\ObjectTypeclass\ObjectApplicative;
+use PhatCats\Typeclass\SemiGroup;
 
 abstract class Validation {
   use ObjectSemiGroup, ObjectApplicative;
diff --git a/src/Validation/ValidationApplicative.php b/src/Validation/ValidationApplicative.php
index 513b820..4dd9e76 100644
--- a/src/Validation/ValidationApplicative.php
+++ b/src/Validation/ValidationApplicative.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Validation;
+namespace PhatCats\Validation;
 
-use TMciver\Functional\Typeclass\Applicative;
-use TMciver\Functional\Typeclass\SemiGroup;
+use PhatCats\Typeclass\Applicative;
+use PhatCats\Typeclass\SemiGroup;
 
 class ValidationApplicative implements Applicative {
 
diff --git a/test/Array/ArrayTest.php b/test/Array/ArrayTest.php
index 18d82c2..3b72f48 100644
--- a/test/Array/ArrayTest.php
+++ b/test/Array/ArrayTest.php
@@ -1,9 +1,9 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\AssociativeArray;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\AssociativeArray;
+use PhatCats\Either\Either;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
 
 class ArrayTest extends TestCase {
 
@@ -62,7 +62,7 @@ public function testTraverseForThrownException() {
         }, $this->monad);
         $expected = $this->monad->fail();
 
-        $this->assertInstanceOf(TMciver\Functional\Either\Left::class, $expected);
+        $this->assertInstanceOf(PhatCats\Either\Left::class, $expected);
     }
 
     public function testTraverseForReturningNull() {
@@ -73,7 +73,7 @@ public function testTraverseForReturningNull() {
         }, $this->monad);
         $expected = $this->monad->fail();
 
-        $this->assertInstanceOf(TMciver\Functional\Either\Left::class, $expected);
+        $this->assertInstanceOf(PhatCats\Either\Left::class, $expected);
     }
 
     public function testHandlingOfNullArgument() {
diff --git a/test/Attempt/AttemptApplicativeTest.php b/test/Attempt/AttemptApplicativeTest.php
index 7d358e7..9bb7964 100644
--- a/test/Attempt/AttemptApplicativeTest.php
+++ b/test/Attempt/AttemptApplicativeTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Attempt\Attempt;
+use PhatCats\Attempt\Attempt;
 
 class AttemptApplicativeTest extends TestCase {
 
diff --git a/test/Attempt/AttemptFunctorTest.php b/test/Attempt/AttemptFunctorTest.php
index 07ca785..4f03e85 100644
--- a/test/Attempt/AttemptFunctorTest.php
+++ b/test/Attempt/AttemptFunctorTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Attempt\Attempt;
+use PhatCats\Attempt\Attempt;
 
 class AttemptFunctorTest extends TestCase {
 
@@ -30,6 +30,6 @@ public function testMapFailure() {
 	$tryStr = Attempt::failure("We have a problem!");
 	$mappedAttemptStr = $tryStr->map($toUpper);
 
-	$this->assertInstanceOf('TMciver\Functional\Attempt\Failure', $mappedAttemptStr);
+	$this->assertInstanceOf('PhatCats\Attempt\Failure', $mappedAttemptStr);
     }
 }
diff --git a/test/Attempt/AttemptMonadTest.php b/test/Attempt/AttemptMonadTest.php
index 6ebc625..81ad556 100644
--- a/test/Attempt/AttemptMonadTest.php
+++ b/test/Attempt/AttemptMonadTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Attempt\Attempt;
+use PhatCats\Attempt\Attempt;
 
 class AttemptMonadTest extends TestCase {
 
@@ -14,7 +14,7 @@ public function testPure() {
 		// create a wrapped val
 		$wrappedVal = $try->pure("Hello!");
 
-		$this->assertInstanceOf('TMciver\Functional\Attempt\Success', $wrappedVal);
+		$this->assertInstanceOf('PhatCats\Attempt\Success', $wrappedVal);
 		$this->assertEquals($wrappedVal->get(), "Hello!");
 	}
 
@@ -35,6 +35,6 @@ public function testFlatMapForFailure() {
 			return Attempt::fromValue($i + 1);
 		});
 
-		$this->assertInstanceOf('TMciver\Functional\Attempt\Failure', $tryIntPlusOne);
+		$this->assertInstanceOf('PhatCats\Attempt\Failure', $tryIntPlusOne);
 	}
 }
diff --git a/test/Attempt/AttemptTest.php b/test/Attempt/AttemptTest.php
index 2d16a26..c706ce7 100644
--- a/test/Attempt/AttemptTest.php
+++ b/test/Attempt/AttemptTest.php
@@ -1,8 +1,8 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Attempt\Attempt;
-use TMciver\Functional\Attempt\Failure;
+use PhatCats\Attempt\Attempt;
+use PhatCats\Attempt\Failure;
 
 class AttemptTest extends TestCase {
 
diff --git a/test/Attempt/AttemptVisitorTest.php b/test/Attempt/AttemptVisitorTest.php
index 6c5c234..aa37f9e 100644
--- a/test/Attempt/AttemptVisitorTest.php
+++ b/test/Attempt/AttemptVisitorTest.php
@@ -1,9 +1,9 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Attempt\Attempt;
-use TMciver\Functional\Attempt\AttemptToMaybe;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Attempt\Attempt;
+use PhatCats\Attempt\AttemptToMaybe;
+use PhatCats\Maybe\Maybe;
 
 class AttemptVisitorTest extends TestCase {
 
diff --git a/test/Either/EitherFunctorTest.php b/test/Either/EitherFunctorTest.php
index 2a47574..bb1ad68 100644
--- a/test/Either/EitherFunctorTest.php
+++ b/test/Either/EitherFunctorTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Either\Either;
+use PhatCats\Either\Either;
 
 class EitherFunctorTest extends TestCase {
 
@@ -30,6 +30,6 @@ public function testMapLeft() {
 	$eitherStr = Either::left("We have a problem!");
 	$mappedEitherStr = $eitherStr->map($toUpper);
 
-	$this->assertInstanceOf('TMciver\Functional\Either\Left', $mappedEitherStr);
+	$this->assertInstanceOf('PhatCats\Either\Left', $mappedEitherStr);
     }
 }
diff --git a/test/Either/EitherMonadTest.php b/test/Either/EitherMonadTest.php
index fdc0088..3dbbe4d 100644
--- a/test/Either/EitherMonadTest.php
+++ b/test/Either/EitherMonadTest.php
@@ -1,8 +1,8 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\Either\Either;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
 
 class EitherMonadTest extends TestCase {
 
@@ -17,7 +17,7 @@ public function testPure() {
         // create a wrapped val
         $wrappedVal = $this->monad->pure("Hello!");
 
-        $this->assertInstanceOf('TMciver\Functional\Either\Right', $wrappedVal);
+        $this->assertInstanceOf('PhatCats\Either\Right', $wrappedVal);
         $this->assertEquals($wrappedVal->get(), "Hello!");
     }
 
@@ -38,7 +38,7 @@ public function testFlatMapForLeft() {
             return Either::fromValue($i + 1);
         });
 
-        $this->assertInstanceOf('TMciver\Functional\Either\Left', $eitherIntPlusOne);
+        $this->assertInstanceOf('PhatCats\Either\Left', $eitherIntPlusOne);
     }
 
     public function testEitherGetOrElseForRight() {
diff --git a/test/Either/EitherTest.php b/test/Either/EitherTest.php
index ff3da9f..63e781b 100644
--- a/test/Either/EitherTest.php
+++ b/test/Either/EitherTest.php
@@ -1,8 +1,8 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Either\Left;
+use PhatCats\Either\Either;
+use PhatCats\Either\Left;
 
 class EitherTest extends TestCase {
 
diff --git a/test/Either/EitherVisitorTest.php b/test/Either/EitherVisitorTest.php
index 1556fb0..f5be8d1 100644
--- a/test/Either/EitherVisitorTest.php
+++ b/test/Either/EitherVisitorTest.php
@@ -1,9 +1,9 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Either\EitherToMaybe;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Either\Either;
+use PhatCats\Either\EitherToMaybe;
+use PhatCats\Maybe\Maybe;
 
 class EitherVisitorTest extends TestCase {
 
diff --git a/test/LinkedList/ArrayBackedLinkedListTest.php b/test/LinkedList/ArrayBackedLinkedListTest.php
index 4db34be..8f5b9a4 100644
--- a/test/LinkedList/ArrayBackedLinkedListTest.php
+++ b/test/LinkedList/ArrayBackedLinkedListTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\LinkedList;
+namespace PhatCats\Test\LinkedList;
 
-use TMciver\Functional\Test\LinkedList\LinkedListTest;
-use TMciver\Functional\LinkedList\ArrayBackedLinkedList;
+use PhatCats\Test\LinkedList\LinkedListTest;
+use PhatCats\LinkedList\ArrayBackedLinkedList;
 
 /**
  * This class exists to implement the Template Pattern
diff --git a/test/LinkedList/ConsListTest.php b/test/LinkedList/ConsListTest.php
index 1a0d39a..ee1f579 100644
--- a/test/LinkedList/ConsListTest.php
+++ b/test/LinkedList/ConsListTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\LinkedList;
+namespace PhatCats\Test\LinkedList;
 
-use TMciver\Functional\Test\LinkedList\LinkedListTest;
-use TMciver\Functional\LinkedList\Cons;
+use PhatCats\Test\LinkedList\LinkedListTest;
+use PhatCats\LinkedList\Cons;
 
 /**
  * This class exists to implement the Template Pattern
diff --git a/test/LinkedList/LinkedListFactoryTest.php b/test/LinkedList/LinkedListFactoryTest.php
index 3e5ce8d..3dd7112 100644
--- a/test/LinkedList/LinkedListFactoryTest.php
+++ b/test/LinkedList/LinkedListFactoryTest.php
@@ -1,10 +1,10 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\LinkedList\LinkedListFactory;
-use TMciver\Functional\LinkedList\ArrayBackedLinkedList;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Tuple;
+use PhatCats\LinkedList\LinkedListFactory;
+use PhatCats\LinkedList\ArrayBackedLinkedList;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Tuple;
 
 class LinkedListFactoryTest extends TestCase {
 
diff --git a/test/LinkedList/LinkedListTest.php b/test/LinkedList/LinkedListTest.php
index 172c03a..f3098be 100644
--- a/test/LinkedList/LinkedListTest.php
+++ b/test/LinkedList/LinkedListTest.php
@@ -1,18 +1,18 @@
 <?php
 
-namespace TMciver\Functional\Test\LinkedList;
+namespace PhatCats\Test\LinkedList;
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\LinkedList\Cons;
-use TMciver\Functional\LinkedList\LinkedList;
-use TMciver\Functional\LinkedList\LinkedListFactory;
-use TMciver\Functional\LinkedList\ArrayBackedLinkedList;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Maybe\MaybeMonoid;
-use TMciver\Functional\Tuple;
-use TMciver\Functional\Int\IntSumMonoid;
-use TMciver\Functional\Int\IntProductMonoid;
-use TMciver\Functional\String\StringMonoid;
+use PhatCats\LinkedList\Cons;
+use PhatCats\LinkedList\LinkedList;
+use PhatCats\LinkedList\LinkedListFactory;
+use PhatCats\LinkedList\ArrayBackedLinkedList;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Maybe\MaybeMonoid;
+use PhatCats\Tuple;
+use PhatCats\Int\IntSumMonoid;
+use PhatCats\Int\IntProductMonoid;
+use PhatCats\String\StringMonoid;
 
 require_once __DIR__ . '/../util.php';
 
diff --git a/test/Maybe/HeadTest.php b/test/Maybe/HeadTest.php
index ddb0d3e..d5798b4 100644
--- a/test/Maybe/HeadTest.php
+++ b/test/Maybe/HeadTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\Maybe;
 
 class HeadTest extends TestCase {
 
diff --git a/test/Maybe/MaybeApplicativeTest.php b/test/Maybe/MaybeApplicativeTest.php
index a32b85a..962f029 100644
--- a/test/Maybe/MaybeApplicativeTest.php
+++ b/test/Maybe/MaybeApplicativeTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\Maybe;
 
 class MaybeApplicativeTest extends TestCase {
 
diff --git a/test/Maybe/MaybeFunctorTest.php b/test/Maybe/MaybeFunctorTest.php
index 437ef77..33cff79 100644
--- a/test/Maybe/MaybeFunctorTest.php
+++ b/test/Maybe/MaybeFunctorTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\Maybe;
 
 require_once __DIR__ . '/../util.php';
 
@@ -24,7 +24,7 @@ public function testMapForNothing() {
 	    return addOne($i);
 	});
 
-	$this->assertInstanceOf('TMciver\Functional\Maybe\Nothing', $maybeIntPlusOne);
+	$this->assertInstanceOf('PhatCats\Maybe\Nothing', $maybeIntPlusOne);
     }
 
     public function testMapExceptionHandling() {
@@ -34,7 +34,7 @@ public function testMapExceptionHandling() {
 	    return throwException($i);
 	});
 
-	$this->assertInstanceOf('TMciver\Functional\Maybe\Nothing', $maybeIntPlusOne);
+	$this->assertInstanceOf('PhatCats\Maybe\Nothing', $maybeIntPlusOne);
     }
 
     public function testMapNullHandling() {
@@ -44,6 +44,6 @@ public function testMapNullHandling() {
 	    return returnNull($i);
 	});
 
-	$this->assertInstanceOf('TMciver\Functional\Maybe\Nothing', $maybeIntPlusOne);
+	$this->assertInstanceOf('PhatCats\Maybe\Nothing', $maybeIntPlusOne);
     }
 }
diff --git a/test/Maybe/MaybeMonadTest.php b/test/Maybe/MaybeMonadTest.php
index d153245..8fef384 100644
--- a/test/Maybe/MaybeMonadTest.php
+++ b/test/Maybe/MaybeMonadTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\Maybe;
 
 class MaybeMonadTest extends TestCase {
 
@@ -14,7 +14,7 @@ public function testPure() {
 	// create a wrapped val
 	$wrappedVal = $maybe->pure("Hello!");
 
-	$this->assertInstanceOf('TMciver\Functional\Maybe\Just', $wrappedVal);
+	$this->assertInstanceOf('PhatCats\Maybe\Just', $wrappedVal);
 	$this->assertEquals($wrappedVal->get(), "Hello!");
     }
 
@@ -31,7 +31,7 @@ public function testFlatMapForNothing() {
 	$maybeInt = Maybe::nothing();
 	$maybeIntPlusOne = $maybeInt->flatMap('maybeAddOne');
 
-	$this->assertInstanceOf('TMciver\Functional\Maybe\Nothing', $maybeIntPlusOne);
+	$this->assertInstanceOf('PhatCats\Maybe\Nothing', $maybeIntPlusOne);
     }
 }
 
diff --git a/test/Maybe/MaybeTest.php b/test/Maybe/MaybeTest.php
index 66947c8..c2a59f2 100644
--- a/test/Maybe/MaybeTest.php
+++ b/test/Maybe/MaybeTest.php
@@ -1,9 +1,9 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Maybe\Nothing;
-use TMciver\Functional\Test\StaticClass;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Maybe\Nothing;
+use PhatCats\Test\StaticClass;
 
 class MaybeTest extends TestCase {
 
@@ -46,7 +46,7 @@ public function testOrElseForRight() {
     public function testStaticMethodCall() {
 
         $maybe = Maybe::fromValue("Hello world!");
-        $f = ['\TMciver\Functional\Test\StaticClass', 'toUpperCase'];
+        $f = ['\PhatCats\Test\StaticClass', 'toUpperCase'];
         $maybeUpperCase = $maybe->map($f);
         $expexted = Maybe::fromValue("HELLO WORLD!");
 
diff --git a/test/Maybe/MaybeVisitorTest.php b/test/Maybe/MaybeVisitorTest.php
index 614c27c..5dd812d 100644
--- a/test/Maybe/MaybeVisitorTest.php
+++ b/test/Maybe/MaybeVisitorTest.php
@@ -1,10 +1,10 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Maybe\MaybeToEither;
-use TMciver\Functional\Test\Maybe\ToStringMaybeVisitor;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Either\Either;
+use PhatCats\Maybe\MaybeToEither;
+use PhatCats\Test\Maybe\ToStringMaybeVisitor;
 
 class MaybeVisitorTest extends TestCase {
 
diff --git a/test/Maybe/ToStringMaybeVisitor.php b/test/Maybe/ToStringMaybeVisitor.php
index e1420c3..b43d571 100644
--- a/test/Maybe/ToStringMaybeVisitor.php
+++ b/test/Maybe/ToStringMaybeVisitor.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Test\Maybe;
+namespace PhatCats\Test\Maybe;
 
-use TMciver\Functional\Maybe\MaybeVisitor;
+use PhatCats\Maybe\MaybeVisitor;
 
 // This MaybeVisitor converts Just/Nothing to strings. In the case of Just, it
 // casts the contained value to a string; in the case of Nothing, it just
diff --git a/test/MaybeT/MaybeTTest.php b/test/MaybeT/MaybeTTest.php
index eab38f2..563fab9 100644
--- a/test/MaybeT/MaybeTTest.php
+++ b/test/MaybeT/MaybeTTest.php
@@ -1,11 +1,11 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Maybe\MaybeT;
-use TMciver\Functional\Maybe\MaybeTMonad;
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Either\Either;
+use PhatCats\Maybe\MaybeT;
+use PhatCats\Maybe\MaybeTMonad;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
 
 class MaybeTTest extends TestCase {
 
diff --git a/test/PartialFunctionTest.php b/test/PartialFunctionTest.php
index f036be0..5d5b349 100644
--- a/test/PartialFunctionTest.php
+++ b/test/PartialFunctionTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\PartialFunction;
+use PhatCats\PartialFunction;
 
 class PartialFunctionTest extends TestCase {
 
diff --git a/test/StaticClass.php b/test/StaticClass.php
index e1996bf..cba0f8b 100644
--- a/test/StaticClass.php
+++ b/test/StaticClass.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Test;
+namespace PhatCats\Test;
 
 /*
  * A class that exists simply to hold a static method for testing purposes.
diff --git a/test/Typeclass/Applicative/ApplicativeTest.php b/test/Typeclass/Applicative/ApplicativeTest.php
index b0d7c5a..6643c83 100644
--- a/test/Typeclass/Applicative/ApplicativeTest.php
+++ b/test/Typeclass/Applicative/ApplicativeTest.php
@@ -1,12 +1,12 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Applicative;
+namespace PhatCats\Test\Typeclass\Applicative;
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Maybe\MaybeT;
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Validation\Validation;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Maybe\MaybeT;
+use PhatCats\Either\Either;
+use PhatCats\Validation\Validation;
 
 abstract class ApplicativeTest extends TestCase {
 
diff --git a/test/Typeclass/Applicative/AttemptApplicativeTest.php b/test/Typeclass/Applicative/AttemptApplicativeTest.php
index 1eae7b6..4b93d44 100644
--- a/test/Typeclass/Applicative/AttemptApplicativeTest.php
+++ b/test/Typeclass/Applicative/AttemptApplicativeTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Applicative;
+namespace PhatCats\Test\Typeclass\Applicative;
 
-use TMciver\Functional\Attempt\AttemptMonad;
-use TMciver\Functional\Attempt\Attempt;
+use PhatCats\Attempt\AttemptMonad;
+use PhatCats\Attempt\Attempt;
 
 class AttemptApplicativeTest extends ApplicativeTest {
 
diff --git a/test/Typeclass/Applicative/LinkedListApplicativeTest.php b/test/Typeclass/Applicative/LinkedListApplicativeTest.php
index 462f37c..53028e5 100644
--- a/test/Typeclass/Applicative/LinkedListApplicativeTest.php
+++ b/test/Typeclass/Applicative/LinkedListApplicativeTest.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Applicative;
+namespace PhatCats\Test\Typeclass\Applicative;
 
-use TMciver\Functional\LinkedList\LinkedListMonad;
+use PhatCats\LinkedList\LinkedListMonad;
 
 class LinkedListApplicativeTest extends ApplicativeTest {
 
diff --git a/test/Typeclass/Applicative/MaybeApplicativeTest.php b/test/Typeclass/Applicative/MaybeApplicativeTest.php
index a47aa6f..9f44b80 100644
--- a/test/Typeclass/Applicative/MaybeApplicativeTest.php
+++ b/test/Typeclass/Applicative/MaybeApplicativeTest.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Applicative;
+namespace PhatCats\Test\Typeclass\Applicative;
 
-use TMciver\Functional\Maybe\MaybeMonad;
+use PhatCats\Maybe\MaybeMonad;
 
 class MaybeApplicativeTest extends ApplicativeTest {
 
diff --git a/test/Typeclass/Applicative/MaybeTApplicativeTest.php b/test/Typeclass/Applicative/MaybeTApplicativeTest.php
index 218fe4e..8e8a949 100644
--- a/test/Typeclass/Applicative/MaybeTApplicativeTest.php
+++ b/test/Typeclass/Applicative/MaybeTApplicativeTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Applicative;
+namespace PhatCats\Test\Typeclass\Applicative;
 
-use TMciver\Functional\Maybe\MaybeTMonad;
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\Maybe\MaybeTMonad;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
 
 class MaybeTApplicativeTest extends ApplicativeTest {
 
diff --git a/test/Typeclass/Applicative/RightFavoringEitherApplicativeTest.php b/test/Typeclass/Applicative/RightFavoringEitherApplicativeTest.php
index ce158b3..8a4f3a6 100644
--- a/test/Typeclass/Applicative/RightFavoringEitherApplicativeTest.php
+++ b/test/Typeclass/Applicative/RightFavoringEitherApplicativeTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Applicative;
+namespace PhatCats\Test\Typeclass\Applicative;
 
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
-use TMciver\Functional\Either\Either;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\Either\Either;
 
 class RightFavoringEitherApplicativeTest extends ApplicativeTest {
 
diff --git a/test/Typeclass/Applicative/ValidationApplicativeTest.php b/test/Typeclass/Applicative/ValidationApplicativeTest.php
index c8cd339..c59ddb7 100644
--- a/test/Typeclass/Applicative/ValidationApplicativeTest.php
+++ b/test/Typeclass/Applicative/ValidationApplicativeTest.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Applicative;
+namespace PhatCats\Test\Typeclass\Applicative;
 
-use TMciver\Functional\Validation\ValidationApplicative;
-use TMciver\Functional\Validation\Validation;
-use TMciver\Functional\String\StringMonoid;
+use PhatCats\Validation\ValidationApplicative;
+use PhatCats\Validation\Validation;
+use PhatCats\String\StringMonoid;
 
 class ValidationApplicativeTest extends ApplicativeTest {
 
diff --git a/test/Typeclass/Functor/FunctorTest.php b/test/Typeclass/Functor/FunctorTest.php
index 282c11d..cf63a82 100644
--- a/test/Typeclass/Functor/FunctorTest.php
+++ b/test/Typeclass/Functor/FunctorTest.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Functor;
+namespace PhatCats\Test\Typeclass\Functor;
 
 use PHPUnit\Framework\TestCase;
 
diff --git a/test/Typeclass/Functor/LinkedListFunctorTest.php b/test/Typeclass/Functor/LinkedListFunctorTest.php
index 05989ec..f0ba76c 100644
--- a/test/Typeclass/Functor/LinkedListFunctorTest.php
+++ b/test/Typeclass/Functor/LinkedListFunctorTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Functor;
+namespace PhatCats\Test\Typeclass\Functor;
 
-use TMciver\Functional\LinkedList\LinkedListMonad;
-use TMciver\Functional\LinkedList\LinkedListFactory;
+use PhatCats\LinkedList\LinkedListMonad;
+use PhatCats\LinkedList\LinkedListFactory;
 
 class LinkedListFunctorTest extends FunctorTest {
 
diff --git a/test/Typeclass/Functor/RightFavoringEitherFunctorTest.php b/test/Typeclass/Functor/RightFavoringEitherFunctorTest.php
index e5b9e41..2c41e98 100644
--- a/test/Typeclass/Functor/RightFavoringEitherFunctorTest.php
+++ b/test/Typeclass/Functor/RightFavoringEitherFunctorTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Functor;
+namespace PhatCats\Test\Typeclass\Functor;
 
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
-use TMciver\Functional\Either\Either;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\Either\Either;
 
 class RightFavoringEitherFunctorTest extends FunctorTest {
 
diff --git a/test/Typeclass/Monad/AttemptMonadTest.php b/test/Typeclass/Monad/AttemptMonadTest.php
index 1aa16f0..387a276 100644
--- a/test/Typeclass/Monad/AttemptMonadTest.php
+++ b/test/Typeclass/Monad/AttemptMonadTest.php
@@ -1,13 +1,13 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monad;
+namespace PhatCats\Test\Typeclass\Monad;
 
-use TMciver\Functional\Attempt\AttemptMonad;
-use TMciver\Functional\Attempt\Attempt;
+use PhatCats\Attempt\AttemptMonad;
+use PhatCats\Attempt\Attempt;
 
 /**
  * Class for testing `AttemptMonad`.
- * @see TMciver\Functional\Test\Typeclass\Monad\MonadTest;
+ * @see PhatCats\Test\Typeclass\Monad\MonadTest;
  */
 class AttemptMonadTest extends MonadTest {
 
diff --git a/test/Typeclass/Monad/LinkedListMonadTest.php b/test/Typeclass/Monad/LinkedListMonadTest.php
index b1c1d6e..a646463 100644
--- a/test/Typeclass/Monad/LinkedListMonadTest.php
+++ b/test/Typeclass/Monad/LinkedListMonadTest.php
@@ -1,14 +1,14 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monad;
+namespace PhatCats\Test\Typeclass\Monad;
 
-use TMciver\Functional\LinkedList\LinkedListMonad;
-use TMciver\Functional\LinkedList\LinkedList;
-use TMciver\Functional\LinkedList\LinkedListFactory;
+use PhatCats\LinkedList\LinkedListMonad;
+use PhatCats\LinkedList\LinkedList;
+use PhatCats\LinkedList\LinkedListFactory;
 
 /**
  * Class for testing `LinkedListMonad`.
- * @see TMciver\Functional\Test\Typeclass\Monad\MonadTest;
+ * @see PhatCats\Test\Typeclass\Monad\MonadTest;
  */
 class LinkedListMonadTest extends MonadTest {
 
diff --git a/test/Typeclass/Monad/MaybeMonadTest.php b/test/Typeclass/Monad/MaybeMonadTest.php
index e139805..2436c6c 100644
--- a/test/Typeclass/Monad/MaybeMonadTest.php
+++ b/test/Typeclass/Monad/MaybeMonadTest.php
@@ -1,13 +1,13 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monad;
+namespace PhatCats\Test\Typeclass\Monad;
 
-use TMciver\Functional\Maybe\MaybeMonad;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\MaybeMonad;
+use PhatCats\Maybe\Maybe;
 
 /**
  * Class for testing `MaybeMonad`.
- * @see TMciver\Functional\Test\Typeclass\Monad\MonadTest;
+ * @see PhatCats\Test\Typeclass\Monad\MonadTest;
  */
 class MaybeMonadTest extends MonadTest {
 
diff --git a/test/Typeclass/Monad/MaybeTMonadTest.php b/test/Typeclass/Monad/MaybeTMonadTest.php
index 96f859d..9164783 100644
--- a/test/Typeclass/Monad/MaybeTMonadTest.php
+++ b/test/Typeclass/Monad/MaybeTMonadTest.php
@@ -1,13 +1,13 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monad;
+namespace PhatCats\Test\Typeclass\Monad;
 
-use TMciver\Functional\Maybe\MaybeTMonad;
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\Maybe\MaybeTMonad;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
 
 /**
  * Class for testing `MaybeTMonad`.
- * @see TMciver\Functional\Test\Typeclass\Monad\MonadTest;
+ * @see PhatCats\Test\Typeclass\Monad\MonadTest;
  */
 class MaybeTMonadTest extends MonadTest {
 
diff --git a/test/Typeclass/Monad/MonadTest.php b/test/Typeclass/Monad/MonadTest.php
index 70482b0..2cc5208 100644
--- a/test/Typeclass/Monad/MonadTest.php
+++ b/test/Typeclass/Monad/MonadTest.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monad;
+namespace PhatCats\Test\Typeclass\Monad;
 
 use PHPUnit\Framework\TestCase;
 
diff --git a/test/Typeclass/Monad/RightFavoringEitherMonadTest.php b/test/Typeclass/Monad/RightFavoringEitherMonadTest.php
index 9b51a5a..ab8867a 100644
--- a/test/Typeclass/Monad/RightFavoringEitherMonadTest.php
+++ b/test/Typeclass/Monad/RightFavoringEitherMonadTest.php
@@ -1,12 +1,12 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monad;
+namespace PhatCats\Test\Typeclass\Monad;
 
-use TMciver\Functional\Either\Monad\RightFavoringEitherMonad;
+use PhatCats\Either\Monad\RightFavoringEitherMonad;
 
 /**
  * Class for testing `RightFavoringEitherMonad`.
- * @see TMciver\Functional\Test\Typeclass\Monad\MonadTest;
+ * @see PhatCats\Test\Typeclass\Monad\MonadTest;
  */
 class RightFavoringEitherMonadTest extends MonadTest {
 
diff --git a/test/Typeclass/Monoid/Either/AppendRightsEitherMonoidTest.php b/test/Typeclass/Monoid/Either/AppendRightsEitherMonoidTest.php
index ce704df..6e89562 100644
--- a/test/Typeclass/Monoid/Either/AppendRightsEitherMonoidTest.php
+++ b/test/Typeclass/Monoid/Either/AppendRightsEitherMonoidTest.php
@@ -1,12 +1,12 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid\Either;
+namespace PhatCats\Test\Typeclass\Monoid\Either;
 
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Either\Monoid\AppendRightsEitherMonoid;
-use TMciver\Functional\String\StringMonoid;
-use TMciver\Functional\Int\IntSumMonoid;
-use TMciver\Functional\Test\Typeclass\Monoid\MonoidTest;
+use PhatCats\Either\Either;
+use PhatCats\Either\Monoid\AppendRightsEitherMonoid;
+use PhatCats\String\StringMonoid;
+use PhatCats\Int\IntSumMonoid;
+use PhatCats\Test\Typeclass\Monoid\MonoidTest;
 
 class AppendRightsEitherMonoidTest extends MonoidTest {
 
diff --git a/test/Typeclass/Monoid/Either/FirstRightEitherMonoidTest.php b/test/Typeclass/Monoid/Either/FirstRightEitherMonoidTest.php
index cf4f675..685e5aa 100644
--- a/test/Typeclass/Monoid/Either/FirstRightEitherMonoidTest.php
+++ b/test/Typeclass/Monoid/Either/FirstRightEitherMonoidTest.php
@@ -1,11 +1,11 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid\Either;
+namespace PhatCats\Test\Typeclass\Monoid\Either;
 
-use TMciver\Functional\Either\Either;
-use TMciver\Functional\Either\Monoid\FirstRightEitherMonoid;
-use TMciver\Functional\String\StringMonoid;
-use TMciver\Functional\Test\Typeclass\Monoid\MonoidTest;
+use PhatCats\Either\Either;
+use PhatCats\Either\Monoid\FirstRightEitherMonoid;
+use PhatCats\String\StringMonoid;
+use PhatCats\Test\Typeclass\Monoid\MonoidTest;
 
 class FirstRightEitherMonoidTest extends MonoidTest {
 
diff --git a/test/Typeclass/Monoid/IntProductMonoidTest.php b/test/Typeclass/Monoid/IntProductMonoidTest.php
index e06349b..f0807a7 100644
--- a/test/Typeclass/Monoid/IntProductMonoidTest.php
+++ b/test/Typeclass/Monoid/IntProductMonoidTest.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid;
+namespace PhatCats\Test\Typeclass\Monoid;
 
-use TMciver\Functional\Int\IntProductMonoid;
+use PhatCats\Int\IntProductMonoid;
 
 class IntProductMonoidTest extends MonoidTest {
 
diff --git a/test/Typeclass/Monoid/IntSumMonoidTest.php b/test/Typeclass/Monoid/IntSumMonoidTest.php
index a4fc7e8..1cdcfe8 100644
--- a/test/Typeclass/Monoid/IntSumMonoidTest.php
+++ b/test/Typeclass/Monoid/IntSumMonoidTest.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid;
+namespace PhatCats\Test\Typeclass\Monoid;
 
-use TMciver\Functional\Int\IntSumMonoid;
+use PhatCats\Int\IntSumMonoid;
 
 class IntSumMonoidTest extends MonoidTest {
 
diff --git a/test/Typeclass/Monoid/ListMonoidTest.php b/test/Typeclass/Monoid/ListMonoidTest.php
index 3503986..2871a12 100644
--- a/test/Typeclass/Monoid/ListMonoidTest.php
+++ b/test/Typeclass/Monoid/ListMonoidTest.php
@@ -1,9 +1,9 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid;
+namespace PhatCats\Test\Typeclass\Monoid;
 
-use TMciver\Functional\LinkedList\LinkedListFactory;
-use TMciver\Functional\LinkedList\ListMonoid;
+use PhatCats\LinkedList\LinkedListFactory;
+use PhatCats\LinkedList\ListMonoid;
 
 class ListMonoidTest extends MonoidTest {
 
diff --git a/test/Typeclass/Monoid/MaybeMonoidTest.php b/test/Typeclass/Monoid/MaybeMonoidTest.php
index f5dfc95..3751c9d 100644
--- a/test/Typeclass/Monoid/MaybeMonoidTest.php
+++ b/test/Typeclass/Monoid/MaybeMonoidTest.php
@@ -1,10 +1,10 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid;
+namespace PhatCats\Test\Typeclass\Monoid;
 
-use TMciver\Functional\Maybe\MaybeMonoid;
-use TMciver\Functional\String\StringMonoid;
-use TMciver\Functional\Maybe\Maybe;
+use PhatCats\Maybe\MaybeMonoid;
+use PhatCats\String\StringMonoid;
+use PhatCats\Maybe\Maybe;
 
 class MaybeMonoidTest extends MonoidTest {
 
diff --git a/test/Typeclass/Monoid/MonoidTest.php b/test/Typeclass/Monoid/MonoidTest.php
index 7744092..ff7592c 100644
--- a/test/Typeclass/Monoid/MonoidTest.php
+++ b/test/Typeclass/Monoid/MonoidTest.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid;
+namespace PhatCats\Test\Typeclass\Monoid;
 
 use PHPUnit\Framework\TestCase;
 
diff --git a/test/Typeclass/Monoid/StringMonoidTest.php b/test/Typeclass/Monoid/StringMonoidTest.php
index 69ff480..ba9f313 100644
--- a/test/Typeclass/Monoid/StringMonoidTest.php
+++ b/test/Typeclass/Monoid/StringMonoidTest.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace TMciver\Functional\Test\Typeclass\Monoid;
+namespace PhatCats\Test\Typeclass\Monoid;
 
-use TMciver\Functional\String\StringMonoid;
+use PhatCats\String\StringMonoid;
 
 class StringMonoidTest extends MonoidTest {
 
diff --git a/test/Validation/ValidationApplicativeTest.php b/test/Validation/ValidationApplicativeTest.php
index a6e5907..1271ed1 100644
--- a/test/Validation/ValidationApplicativeTest.php
+++ b/test/Validation/ValidationApplicativeTest.php
@@ -1,8 +1,8 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Validation\Validation;
-use TMciver\Functional\String\StringMonoid;
+use PhatCats\Validation\Validation;
+use PhatCats\String\StringMonoid;
 
 class ValidationApplicativeTest extends TestCase {
 
diff --git a/test/Validation/ValidationFunctorTest.php b/test/Validation/ValidationFunctorTest.php
index a7cf259..5686179 100644
--- a/test/Validation/ValidationFunctorTest.php
+++ b/test/Validation/ValidationFunctorTest.php
@@ -1,7 +1,7 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Validation\Validation;
+use PhatCats\Validation\Validation;
 
 require_once __DIR__ . '/../util.php';
 
@@ -29,7 +29,7 @@ public function testMapExceptionHandling() {
     $validationInt = Validation::fromValue(1);
     $mappedValidationInt = $validationInt->map('throwException');
 
-    $this->assertInstanceOf('TMciver\Functional\Validation\Failure', $mappedValidationInt);
+    $this->assertInstanceOf('PhatCats\Validation\Failure', $mappedValidationInt);
   }
 
   public function testMapNullHandling() {
@@ -37,6 +37,6 @@ public function testMapNullHandling() {
     $validationInt = Validation::fromValue(1);
     $mappedValidationInt = $validationInt->map('returnNull');
 
-    $this->assertInstanceOf('TMciver\Functional\Validation\Failure', $mappedValidationInt);
+    $this->assertInstanceOf('PhatCats\Validation\Failure', $mappedValidationInt);
   }
 }
diff --git a/test/Validation/ValidationSemiGroupTest.php b/test/Validation/ValidationSemiGroupTest.php
index 44bdd88..4c799ed 100644
--- a/test/Validation/ValidationSemiGroupTest.php
+++ b/test/Validation/ValidationSemiGroupTest.php
@@ -1,12 +1,12 @@
 <?php
 
 use PHPUnit\Framework\TestCase;
-use TMciver\Functional\Validation\Validation;
-use TMciver\Functional\Maybe\Maybe;
-use TMciver\Functional\Maybe\MaybeMonoid;
-use TMciver\Functional\Int\IntSumMonoid;
-use TMciver\Functional\Int\IntProductMonoid;
-use TMciver\Functional\String\StringMonoid;
+use PhatCats\Validation\Validation;
+use PhatCats\Maybe\Maybe;
+use PhatCats\Maybe\MaybeMonoid;
+use PhatCats\Int\IntSumMonoid;
+use PhatCats\Int\IntProductMonoid;
+use PhatCats\String\StringMonoid;
 
 class ValidationSemiGroupTest extends TestCase {
 

From fe6ca9cc63754a403045f66f377f4d5f66c000a8 Mon Sep 17 00:00:00 2001
From: Tim McIver <tim@timmciver.com>
Date: Tue, 15 Jan 2019 22:36:07 -0500
Subject: [PATCH 3/3] Update readme.md

Add deprecation notice.
---
 readme.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/readme.md b/readme.md
index 3d22c22..6127a84 100644
--- a/readme.md
+++ b/readme.md
@@ -1,5 +1,7 @@
 [![CircleCI](https://circleci.com/gh/tmciver/functional-php.svg?style=svg)](https://circleci.com/gh/tmciver/functional-php)
 
+*This repository is no longer being maintained. It is now hosted here: https://github.com/serenitylabz/phatcats*
+
 # Functional PHP
 
 ## Contents