diff --git a/.editorconfig b/.editorconfig
index ccd32b0..f209fa5 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -9,3 +9,6 @@ indent_size = 2
 trim_trailing_whitespace = true
 charset = utf-8
 
+[*.d]
+dfmt_split_operator_at_line_end = true
+
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3dd6e9d..826f671 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# v0.3.0
+
+* Rename module to pijamas.
+* .empty for arrays, associative arrays and strings.
+
 # v0.2.2
 
 Versions v0.2.x must keep being source compatible with Pyjamas.
diff --git a/README.md b/README.md
index 1487ada..3b362a5 100644
--- a/README.md
+++ b/README.md
@@ -99,12 +99,22 @@ value.
 #### `U length(U)(U length, string file = __FILE__, size_t line = __LINE__);`
 
 Asserts for the `.length` property or function value to equal some value.
+
 ```d
 [1, 2, 3, 4].should.have.length(4);
 "abcdefg".should.have.length(0);
 // ^^ - Throws an Exception "expected 'abcdefg' to have length of 0"
 ```
 
+#### `bool empty(string file = __FILE__, size_t line = __LINE__);`
+
+Asserts that the .lenght property or function value is equal to 0;
+
+```d
+[].should.be.empty;
+"".should.be.empty;
+```
+
 #### `auto match(RegEx)(RegEx re, string file = __FILE__, size_t line = __LINE__);`
 
 Asserts for a string wrapped around the Assertion to match a regular expression.
diff --git a/docs/changelog.md b/docs/changelog.md
index a81f75e..558bcea 100644
--- a/docs/changelog.md
+++ b/docs/changelog.md
@@ -2,6 +2,11 @@
 layout: default
 title: Changelog
 ---
+# v0.3.0
+
+* Rename module to pijamas.
+* .empty for arrays, associative arrays and strings.
+
 # v0.2.2
 
 Versions v0.2.x must keep being source compatible with Pyjamas.
diff --git a/docs/index.md b/docs/index.md
index da7cffb..e6dae03 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -103,12 +103,22 @@ value.
 #### `U length(U)(U length, string file = __FILE__, size_t line = __LINE__);`
 
 Asserts for the `.length` property or function value to equal some value.
+
 ```d
 [1, 2, 3, 4].should.have.length(4);
 "abcdefg".should.have.length(0);
 // ^^ - Throws an Exception "expected 'abcdefg' to have length of 0"
 ```
 
+#### `bool empty(string file = __FILE__, size_t line = __LINE__);`
+
+Asserts that the .lenght property or function value is equal to 0;
+
+```d
+[].should.be.empty;
+"".should.be.empty;
+```
+
 #### `auto match(RegEx)(RegEx re, string file = __FILE__, size_t line = __LINE__);`
 
 Asserts for a string wrapped around the Assertion to match a regular expression.
diff --git a/docs/pyjamas.html b/docs/pijamas.html
similarity index 92%
rename from docs/pyjamas.html
rename to docs/pijamas.html
index e12c8ad..82bdcbd 100644
--- a/docs/pyjamas.html
+++ b/docs/pijamas.html
@@ -3,7 +3,7 @@
 <html>
   <head>
     <meta charset="UTF-8">
-    <title>pyjamas</title>
+    <title>pijamas</title>
     <style type="text/css" media="screen">
       html, body, div, span, object, iframe, h1, h2, h3, h4, h5, h6, p,
       blockquote, pre, a, abbr, address, cite, code, del, dfn, em, figure,
@@ -508,7 +508,7 @@
   <body id="ddoc_main" class="ddoc dlang">
     <div class="content_wrapper">
       <article class="module">
-        <h1 class="module_name">pyjamas</h1>
+        <h1 class="module_name">pijamas</h1>
         <section id="module_content"><section class="section ddoc_sections">
   <div class="ddoc_summary">
   <p class="para">
@@ -1103,6 +1103,56 @@ <h4>Examples</h4>
 
 </div>
 
+</li><li class="ddoc_member">
+  <div class="ddoc_member_header">
+  <div class="ddoc_header_anchor">
+  <a href="#Assertion.empty" id="Assertion.empty"><code class="code">empty</code></a>
+</div>
+</div><div class="ddoc_decl">
+  <section class="section">
+    <div class="declaration">
+      <h4>Declaration</h4>
+      <div class="dlang">
+        <p class="para">
+          <code class="code">
+            <span class="ddoc_anchor" id="Assertion.empty"></span>bool <code class="code">empty</code>(string <code class="code">file</code> = __FILE__, size_t <code class="code">line</code> = __LINE__);
+
+          </code>
+        </p>
+      </div>
+    </div>
+  </section>
+</div>
+<div class="ddoc_decl">
+  <section class="section ddoc_sections">
+  <div class="ddoc_summary">
+  <p class="para">
+    Asserts for the .length property or function value to be equal to 0.
+
+  </p>
+</div>
+<div class="ddoc_examples">
+  <h4>Examples</h4>
+  <p class="para">
+    
+<section class="code_listing">
+  <div class="code_sample">
+    <div class="dlang">
+      <ol class="code_lines">
+        <li><code class="code">[].should.be.<span class="psymbol">empty</span>;
+<span class="string_literal">""</span>.should.be.<span class="psymbol">empty</span>;
+</code></li>
+      </ol>
+    </div>
+  </div>
+</section>
+
+  </p>
+</div>
+</section>
+
+</div>
+
 </li><li class="ddoc_member">
   <div class="ddoc_member_header">
   <div class="ddoc_header_anchor">
diff --git a/source/pyjamas.d b/source/pijamas.d
similarity index 78%
rename from source/pyjamas.d
rename to source/pijamas.d
index 089ea87..ff79c01 100644
--- a/source/pyjamas.d
+++ b/source/pijamas.d
@@ -4,16 +4,15 @@
  * Authors: Pedro Tacla Yamada, Luis Panadero Guardeño
  * License: Licensed under the MIT license. See LICENSE for more information.
  */
-module pyjamas;
+module pijamas;
 
 import std.algorithm : canFind, isSorted;
 import std.conv : to;
-import std.range : isInputRange, isForwardRange, hasLength, ElementEncodingType,
-                   empty;
-import std.regex : Regex, StaticRegex;// & std.regex.match
+import std.range : isInputRange, isForwardRange, hasLength, ElementEncodingType, empty;
+import std.regex : Regex, StaticRegex;
 import std.string : format;
 import std.traits : hasMember, isSomeString, isCallable, isAssociativeArray,
-                    isImplicitlyConvertible, Unqual;
+  isImplicitlyConvertible, Unqual;
 
 /**
  * Pijamas exports a single function should meant for public use. Because of D’s lookup shortcut syntax, one is able
@@ -27,12 +26,14 @@ Assertion!T should(T)(T context)
 /// Class returned by should, that it's used to generate the fluent API
 class Assertion(T)
 {
-  static bool callable = isCallable!T;
-  bool negated = false;
-  string operator = "be";
-  T context;
+  private static bool callable = isCallable!T;
+  private bool negated = false;
+  private string operator = "be";
+  private T context;
 
-  this() {};
+  this()
+  {
+  };
   this(T _context)
   {
     context = _context;
@@ -74,12 +75,11 @@ class Assertion(T)
   }
 
   // Helper that evaluates the asserted expression
-  U ok(U)(U expr,
-          lazy string message,
-          string file = __FILE__,
-          size_t line = __LINE__)
+  U ok(U)(U expr, lazy string message, string file = __FILE__, size_t line = __LINE__)
   {
-    if(negated ? !expr : expr) return expr;
+    if (negated ? !expr : expr) {
+      return expr;
+    }
     throw new Exception(message, file, line);
   }
 
@@ -92,9 +92,7 @@ class Assertion(T)
    * 255.should.equal(10); // Throws an Exception "expected 255 to equal 10"
    * ```
    */
-  T equal(U)(U other,
-             string file = __FILE__,
-             size_t line = __LINE__)
+  T equal(U)(U other, string file = __FILE__, size_t line = __LINE__)
   {
     auto t_other = other.to!T;
     ok(context == other, message(other), file, line);
@@ -118,10 +116,13 @@ class Assertion(T)
   T exist(string file = __FILE__, size_t line = __LINE__)
   {
     import std.traits : isPointer, isSomeString;
-    static if(isPointer!T || isSomeString!T || __traits(compiles, () { T t; assert(t is null);}))
+
+    static if (isPointer!T || isSomeString!T || __traits(compiles, () {
+        T t;
+        assert(t is null);
+      }))
     {
-      if(context is null)
-      {
+      if (context is null) {
         ok(false, message, file, line);
       }
     }
@@ -131,18 +132,14 @@ class Assertion(T)
   // Generates string message when an assertation fails
   string message(U)(U other)
   {
-    return format("expected %s to %s%s%s", context.to!string,
-                                           (negated ? "not " : ""),
-                                           operator,
-                                           (" " ~ other.to!string));
+    return format("expected %s to %s%s%s", context.to!string, (negated ?
+        "not " : ""), operator, (" " ~ other.to!string));
   }
 
   // Generates string message when an assertation fails
   string message()
   {
-    return format("expected %s to %s%s", context.to!string,
-                                         (negated ? "not " : ""),
-                                         operator);
+    return format("expected %s to %s%s", context.to!string, (negated ? "not " : ""), operator);
   }
 
   /**
@@ -175,7 +172,7 @@ class Assertion(T)
     return ok(context < other, message(other), file, line);
   }
 
-  static if(isForwardRange!T && __traits(compiles, context.isSorted))
+  static if (isForwardRange!T && __traits(compiles, context.isSorted))
   {
     /**
      * Asserts whether a forward range is sorted.
@@ -193,7 +190,8 @@ class Assertion(T)
     }
   }
 
-  static if(isAssociativeArray!T) {
+  static if (isAssociativeArray!T)
+  {
     /**
      * Asserts for an associative array to have a key equal to other.
      *
@@ -209,7 +207,7 @@ class Assertion(T)
     }
   }
 
-  static if(isInputRange!T || isAssociativeArray!T)
+  static if (isInputRange!T || isAssociativeArray!T)
   {
     /**
      * Asserts for an input range wrapped around an Assertion to contain/include a value.
@@ -223,8 +221,11 @@ class Assertion(T)
      */
     U include(U)(U other, string file = __FILE__, size_t line = __LINE__)
     {
-      static if(isAssociativeArray!T) auto pool = context.values;
-      else auto pool = context;
+      static if (isAssociativeArray!T) {
+        auto pool = context.values;
+      } else {
+        auto pool = context;
+      }
 
       operator = "contain value";
       ok(canFind(pool, other), message(other), file, line);
@@ -237,7 +238,7 @@ class Assertion(T)
     alias contain = include;
   }
 
-  static if(hasLength!T || hasMember!(T, "string") || isSomeString!T)
+  static if (hasLength!T || hasMember!(T, "string") || isSomeString!T)
   {
     /**
      * Asserts for the .length property or function value to equal some value.
@@ -255,11 +256,27 @@ class Assertion(T)
       ok(context.length == len, message(len), file, line);
       return len;
     }
+
+    /**
+     * Asserts for the .length property or function value to be equal to 0.
+     *
+     * Examples:
+     * ```
+     * [].should.be.empty;
+     * "".should.be.empty;
+     * ```
+     */
+    bool empty(string file = __FILE__, size_t line = __LINE__)
+    {
+      operator = "is empty";
+      return ok(context.length == 0, message(), file, line);
+    }
   }
 
   import std.regex : Regex, isRegexFor;
   import std.traits : isSomeString;
-  static if(isSomeString!T)
+
+  static if (isSomeString!T)
   {
 
     /**
@@ -275,9 +292,10 @@ class Assertion(T)
      * ```
      */
     auto match(RegEx)(RegEx re, string file = __FILE__, size_t line = __LINE__)
-      if (isSomeString!T && isRegexFor!(RegEx, T))
+        if (isSomeString!T && isRegexFor!(RegEx, T))
     {
       import std.regex : match;
+
       auto m = match(context, re);
       operator = "match";
       ok(!m.empty, message(re), file, line);
@@ -286,9 +304,10 @@ class Assertion(T)
 
     ///ditto
     auto match(U)(U re, string file = __FILE__, size_t line = __LINE__)
-      if (isSomeString!T && isSomeString!U)
+        if (isSomeString!T && isSomeString!U)
     {
       import std.regex : regex, match;
+
       auto m = match(context, regex(re));
       operator = "match";
       ok(!m.empty, message(re), file, line);
@@ -296,7 +315,7 @@ class Assertion(T)
     }
   }
 
-  static if(is(T == bool))
+  static if (is(T == bool))
   {
     /**
      * Asserts for a boolean value to be equal to true.
@@ -327,8 +346,8 @@ class Assertion(T)
     }
   }
 
-  static if(isCallable!T)
- {
+  static if (isCallable!T)
+  {
     /**
      * Asserts whether a callable object wrapped around the assertion throws an exception of type T.
      *
@@ -349,13 +368,15 @@ class Assertion(T)
      * should(&notThrowing).not.Throw;
      * ```
      */
-    void Throw(T : Throwable = Exception)(string file = __FILE__,
-                                          size_t line = __LINE__)
+    void Throw(T : Throwable = Exception)(string file = __FILE__, size_t line = __LINE__)
     {
       operator = "throw";
       bool thrown = false;
-      try context();
-      catch(T) thrown = true;
+      try {
+        context();
+      } catch (T) {
+        thrown = true;
+      }
       ok(thrown, message(), file, line);
     }
   }
@@ -363,44 +384,46 @@ class Assertion(T)
 }
 
 @("Should(v)")
-unittest {
+unittest
+{
   //  it("returns an Assertion", {
   assert(is(typeof(10.should) == Assertion!int));
 }
 
 @("Should Assertion")
-unittest {
+unittest
+{
   //  it("can be instantiated for ranges of structs without `opCmp`", {
-  struct Test {
+  struct Test
+  {
     int a;
     int b;
   }
 
-  cast(void) [ Test( 2, 3)].should;
+  cast(void)[Test(2, 3)].should;
 }
 
 @("Should Assertion.message")
-unittest {
+unittest
+{
   //  it("returns the correct message for binary operators",
   {
-    auto a = new Assertion!int( 10);
+    auto a = new Assertion!int(10);
     a.operator = "equal";
-    assert(a.message( 20) == "expected 10 to equal 20");
+    assert(a.message(20) == "expected 10 to equal 20");
   }
 
   //  it("returns the correct message for unary operators",
   {
-    auto a = new Assertion!string( "function");
+    auto a = new Assertion!string("function");
     a.operator = "throw";
     assert(a.message == "expected function to throw");
   }
 
   //  it("returns the correct message for negated operators",
   {
-    auto a = new Assertion!int( 10);
+    auto a = new Assertion!int(10);
     a.operator = "be";
-    assert(a.not.message( false) == "expected 10 to not be false");
+    assert(a.not.message(false) == "expected 10 to not be false");
   }
 }
-
-
diff --git a/tests/pyjamas_spec.d b/tests/pijamas_spec.d
similarity index 78%
rename from tests/pyjamas_spec.d
rename to tests/pijamas_spec.d
index 9a2a314..b030bb7 100644
--- a/tests/pyjamas_spec.d
+++ b/tests/pijamas_spec.d
@@ -4,14 +4,15 @@
  * Authors: Pedro Tacla Yamada, Luis Panadero Guardeño
  * License: Licensed under the MIT license. See LICENSE for more information.
  */
-module pyjamas_spec;
+module pijamas_spec;
 
 import std.exception;
 
-import pyjamas;
+import pijamas;
 
 @("Should Assertion.exist")
-unittest {
+unittest
+{
   //  it("existence of string",
   {
     // String
@@ -30,7 +31,11 @@ unittest {
     i.should.exist;
     i.should.not.exist;
 
-    struct S { int x;}
+    struct S
+    {
+      int x;
+    }
+
     S s;
     assertNotThrown!Exception(s.should.exist);
     assertNotThrown!Exception(s.should.not.exist);
@@ -51,10 +56,14 @@ unittest {
   //  it("Class reference"
   {
     // Class
-    class C {
+    class C
+    {
       int x;
-      this() {}
+      this()
+      {
+      }
     }
+
     C c;
     c.should.not.exist;
     assertThrown!Exception(c.should.exist);
@@ -62,7 +71,8 @@ unittest {
 }
 
 @("Should Assertion.True")
-unittest {
+unittest
+{
   // it("returns and asserts for true",
   {
     true.should.be.True;
@@ -77,7 +87,8 @@ unittest {
 }
 
 @("Should Assertion.False")
-unittest {
+unittest
+{
   // it("returns and asserts for false",
   {
     false.should.be.False;
@@ -92,7 +103,8 @@ unittest {
 }
 
 @("Should Assertion.equal")
-unittest {
+unittest
+{
   //  it("asserts whether two values are equal",
   {
     10.should.be.equal(10);
@@ -137,34 +149,38 @@ unittest {
 }
 
 @("Should Assertion.match")
-unittest {
+unittest
+{
   // it("returns whether a string type matches a Regex",
   {
     import std.regex : regex;
+
     string str = "Something weird";
-    str.should.match( regex( `[a-z]+`));
-    assertThrown!Exception(str.should.match( regex(`[0-9]+`)));
+    str.should.match(regex(`[a-z]+`));
+    assertThrown!Exception(str.should.match(regex(`[0-9]+`)));
   }
 
   // it("returns whether a string type matches a StaticRegex",
   {
-     import std.regex : ctRegex;
-     string str = "something 2 weird";
-     str.should.match(ctRegex!`[a-z0-9]+`);
-     assertThrown!Exception(str.should.match(ctRegex!`^[a-z]+$`));
+    import std.regex : ctRegex;
+
+    string str = "something 2 weird";
+    str.should.match(ctRegex!`[a-z0-9]+`);
+    assertThrown!Exception(str.should.match(ctRegex!`^[a-z]+$`));
   }
 
   // it("returns whether a string type matches a string regex",
   {
     string str = "1234numbers";
-    str.should.match( `[0-9]+[a-z]+`);
-    str.should.not.match( `^[a-z]+`);
-    assertThrown!Exception(str.should.match( `^[a-z]+`));
+    str.should.match(`[0-9]+[a-z]+`);
+    str.should.not.match(`^[a-z]+`);
+    assertThrown!Exception(str.should.match(`^[a-z]+`));
   }
 }
 
 @("Should Assertion.include")
-unittest {
+unittest
+{
   // it("asserts for arrays containing elements",
   {
     int[] a = [1, 2, 3, 4, 5, 6];
@@ -175,7 +191,7 @@ unittest {
 
   // it("asserts for associative arrays containing values",
   {
-    int[string] aa = ["something": 2, "else": 3];
+    int[string] aa = ["something" : 2, "else" : 3];
     aa.should.have.value(2);
     aa.should.not.have.value(4);
     assertThrown!Exception(aa.should.have.value(42));
@@ -193,7 +209,8 @@ unittest {
 }
 
 @("Should Assertion.length")
-unittest {
+unittest
+{
   // it("asserts for length equality for strings",
   {
     auto str = "1234567";
@@ -211,18 +228,48 @@ unittest {
   // it("asserts for length equality for associative arrays",
   {
     string[string] aa = [
-      "something": "here",
-      "what": "is",
-      "this": "stuff",
-      "we're": "doing"
+      "something" : "here", "what" : "is", "this" : "stuff", "we're" : "doing"
     ];
     aa.should.have.length(4);
     assertThrown!Exception(aa.should.have.length(24));
   }
 }
 
+@("Should Assertion.empty")
+unittest
+{
+  // it("asserts that a string is empty"
+  {
+    auto str = "1234567";
+    str.should.not.be.empty;
+    assertThrown!Exception(str.should.be.empty);
+    "".should.be.empty;
+  }
+
+  // it("asserts that an array is empty"
+  {
+    auto a = [1, 2, 3, 4, 5, 6];
+    a.should.not.be.empty;
+    assertThrown!Exception(a.should.be.empty);
+    int[] emptyArr;
+    emptyArr.should.be.empty;
+  }
+
+  // it("asserts that an associative array is empty",
+  {
+    string[string] aa = [
+      "something" : "here", "what" : "is", "this" : "stuff", "we're" : "doing"
+    ];
+    aa.should.not.be.empty;
+    assertThrown!Exception(aa.should.be.empty);
+    int[string] emptyAa;
+    emptyAa.should.be.empty;
+  }
+}
+
 @("Should Assertion.Throw")
-unittest {
+unittest
+{
   // it("asserts whether an expressions throws",
   {
     void throwing()
@@ -243,12 +290,11 @@ unittest {
 }
 
 @("Should Assertion.key")
-unittest {
+unittest
+{
   // it("asserts for `key` existence in types with `opIndex` defined",
   {
-    auto aArr = [
-      "something": "here",
-    ];
+    auto aArr = ["something" : "here",];
 
     aArr.should.have.key("something");
     aArr.should.not.have.key("else");
@@ -257,7 +303,8 @@ unittest {
 }
 
 @("Should Assertion.sorted")
-unittest {
+unittest
+{
   // it("asserts whether a range is sorted",
   {
     auto unsorted = [4, 3, 2, 1];
@@ -270,7 +317,8 @@ unittest {
 }
 
 @("Should Assertion.biggerThan")
-unittest {
+unittest
+{
   //it("asserts whether a value is bigger than other",
   {
     auto a1 = true;
@@ -285,7 +333,8 @@ unittest {
 }
 
 @("Should Assertion.smallerThan")
-unittest {
+unittest
+{
   // it("asserts whether a value is smaller than other",
   {
     auto a1 = false;
