     {
         var result:Array = [ ];
         var member:*;
-        var dict:Dictionary = new Dictionary();
+        var memberKey:*;
+        var seen:Dictionary = new Dictionary(true);
         var i:int;
 
         for (i = 0; i < array.length; i++)
         {
             member = array[i];
-            if (member !== null && member !== undefined)
-            {
-                dict[member] = member;
-            }
-        }
-        for each (member in dict)
-        {
-            result.push(member);
-        }
-        dict = null;
+            memberKey = valueToKey(member);
+
+            if (!seen[memberKey])
+            {
+                result.push(member);
+                seen[memberKey] = member;
+            }
+        }
+        seen = null;
         return result;
     }
 
-    /**
-     * Helper function: Wraps a 1-argument function with a function
-     * signature suitable for passing to the 3-argument functional methods
-     * of Array.
+
+    /**
+     * Returns true if the elements in Array are strictly equal (===) to
+     * the elements in Array b, and appear in the same order.
+     */
+    public static function arraysEqual(a:*, b:*):Boolean
+    {
+        var len:int = a.length;
+
+        if (!a && !b)
+        {
+            return true;
+        }
+        else if (!a || !b)
+        {
+            return false;
+        }
+        else if (a.length !== b.length)
+        {
+            return false;
+        }
+        else
+        {
+            for (var i:int = 0; i < len; i++)
+            {
+                if (a[i] !== b[i])
+                {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+
+    /**
+     * Returns true if the elements in Array are strictly equal (===) to
+     * the elements in Array b. Order is not considered.
+     */
+    public static function arraysEqualUnordered(a:*, b:*):Boolean
+    {
+        var aCount:Dictionary;
+        var bCount:Dictionary;
+        var item:*;
+
+        if (!a && !b)
+        {
+            return true;
+        }
+        else if (!a || !b)
+        {
+            return false;
+        }
+        else if (a.length !== b.length)
+        {
+            return false;
+        }
+        else
+        {
+            aCount = countElements(a);
+            bCount = countElements(b);
+
+            for (item in a)
+            {
+                if (aCount[item] !== bCount[item])
+                {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+
+    /**
+     * Wraps a 1-argument function with a function signature suitable for
+     * passing to the 3-argument functional methods of Array.
+     *
+     * @param func  A function that accepts one argument, an array item.
+     * @return      A function that accepts three arguments, an array item,
+     *              an index, and an array.
      *
      * @see Array#every
      * @see Array#filter

        return index >= 0 ? array[index] : null;
    }

    /**
     * Returns a copy of an array with equal items removed.  Equality
     * checking is strict <code>===</code>.

        return acc;
    }


    /**
     * Given an object or array, and an array of indices or properties,
     * use the latter to index into the former.  Useful when calling
