Index: src/OFArray.h
==================================================================
--- src/OFArray.h
+++ src/OFArray.h
@@ -125,12 +125,14 @@
  * \return The last object of the OFArray or nil
  */
 - (id)lastObject;
 
 - addObject: (OFObject*)obj;
+- removeObject: (id)obj;
+- removeObjectIdenticalTo: (id)obj;
 - removeObjectAtIndex: (size_t)index;
 - removeNObjects: (size_t)nobjects;
 - removeNObjects: (size_t)nobjects
 	 atIndex: (size_t)index;
 @end
 
 #import "OFMutableArray.h"

Index: src/OFArray.m
==================================================================
--- src/OFArray.m
+++ src/OFArray.m
@@ -151,19 +151,19 @@
 
 - (id)mutableCopy
 {
 	OFArray *new = [[OFMutableArray alloc] init];
 	OFObject **objs;
-	size_t len, i;
+	size_t count, i;
 
 	objs = [array cArray];
-	len = [array count];
+	count = [array count];
 
-	[new->array addNItems: len
+	[new->array addNItems: count
 		   fromCArray: objs];
 
-	for (i = 0; i < len; i++)
+	for (i = 0; i < count; i++)
 		[objs[i] retain];
 
 	return new;
 }
 
@@ -217,25 +217,25 @@
 }
 
 - (BOOL)isEqual: (id)obj
 {
 	OFObject **objs, **objs2;
-	size_t i, len, len2;
+	size_t i, count, count2;
 
 	if (![obj isKindOfClass: [OFArray class]])
 		return NO;
 
-	len = [array count];
-	len2 = [obj count];
+	count = [array count];
+	count2 = [obj count];
 
-	if (len != len2)
+	if (count != count2)
 		return NO;
 
 	objs = [array cArray];
 	objs2 = [obj cArray];
 
-	for (i = 0; i < len; i++)
+	for (i = 0; i < count; i++)
 		if (![objs[i] isEqual: objs2[i]])
 			return NO;
 
 	return YES;
 }
@@ -262,27 +262,34 @@
 	return hash;
 }
 
 - (void)dealloc
 {
-	OFObject **objs;
-	size_t len, i;
-
-	if (array != nil) {
-		objs = [array cArray];
-		len = [array count];
-
-		for (i = 0; i < len; i++)
-			[objs[i] release];
-
-		[array release];
-	}
+	OFObject **objs = [array cArray];
+	size_t i, count = [array count];
+
+	for (i = 0; i < count; i++)
+		[objs[i] release];
+
+	[array release];
 
 	[super dealloc];
 }
 
 - addObject: (OFObject*)obj
+{
+	@throw [OFNotImplementedException newWithClass: isa
+					      selector: _cmd];
+}
+
+- removeObject: (id)obj
+{
+	@throw [OFNotImplementedException newWithClass: isa
+					      selector: _cmd];
+}
+
+- removeObjectIdenticalTo: (id)obj
 {
 	@throw [OFNotImplementedException newWithClass: isa
 					      selector: _cmd];
 }
 

Index: src/OFMutableArray.h
==================================================================
--- src/OFMutableArray.h
+++ src/OFMutableArray.h
@@ -21,10 +21,24 @@
  *
  * \param obj An object to add
  */
 - addObject: (OFObject*)obj;
 
+/**
+ * Removes the first object equivalent to the specified object.
+ *
+ * \param obj The object to remove
+ */
+- removeObject: (id)obj;
+
+/**
+ * Removes the first object that has the same address as the specified object.
+ *
+ * \param obj The object to remove
+ */
+- removeObjectIdenticalTo: (id)obj;
+
 /**
  * Removes the object at the specified index.
  *
  * \param index The index of the object to remove
  */

Index: src/OFMutableArray.m
==================================================================
--- src/OFMutableArray.m
+++ src/OFMutableArray.m
@@ -17,19 +17,19 @@
 @implementation OFMutableArray
 - (id)copy
 {
 	OFArray *new = [[OFArray alloc] init];
 	OFObject **objs;
-	size_t len, i;
+	size_t count, i;
 
 	objs = [array cArray];
-	len = [array count];
+	count = [array count];
 
-	[new->array addNItems: len
+	[new->array addNItems: count
 		   fromCArray: objs];
 
-	for (i = 0; i < len; i++)
+	for (i = 0; i < count; i++)
 		[objs[i] retain];
 
 	return new;
 }
 
@@ -38,29 +38,56 @@
 	[array addItem: &obj];
 	[obj retain];
 
 	return self;
 }
+
+- removeObject: (id)obj
+{
+	OFObject **objs = [array cArray];
+	size_t i, count = [array count];
+
+	for (i = 0; i < count; i++) {
+		if ([objs[i] isEqual: obj]) {
+			[objs[i] release];
+			[array removeItemAtIndex: i];
+		}
+	}
+
+	return self;
+}
+
+- removeObjectIdenticalTo: (id)obj
+{
+	OFObject **objs = [array cArray];
+	size_t i, count = [array count];
+
+	for (i = 0; i < count; i++) {
+		if (objs[i] == obj) {
+			[obj release];
+			[array removeItemAtIndex: i];
+		}
+	}
+
+	return self;
+}
 
 - removeObjectAtIndex: (size_t)index
 {
 	return [self removeNObjects: 1
 			    atIndex: index];
 }
 
 - removeNObjects: (size_t)nobjects
 {
-	OFObject **objs;
-	size_t len, i;
+	OFObject **objs = [array cArray];
+	size_t i, count = [array count];
 
-	objs = [array cArray];
-	len = [array count];
-
-	if (nobjects > len)
+	if (nobjects > count)
 		@throw [OFOutOfRangeException newWithClass: isa];
 
-	for (i = len - nobjects; i < len; i++)
+	for (i = count - nobjects; i < count; i++)
 		[objs[i] release];
 
 	[array removeNItems: nobjects];
 
 	return self;
@@ -67,23 +94,20 @@
 }
 
 - removeNObjects: (size_t)nobjects
 	 atIndex: (size_t)index
 {
-	OFObject **objs;
-	size_t len, i;
+	OFObject **objs = [array cArray];
+	size_t i, count = [array count];
 
-	objs = [array cArray];
-	len = [array count];
-
-	if (nobjects > len)
+	if (nobjects > count)
 		@throw [OFOutOfRangeException newWithClass: isa];
 
-	for (i = index; i < len && i < index + nobjects; i++)
+	for (i = index; i < count && i < index + nobjects; i++)
 		[objs[i] release];
 
 	[array removeNItems: nobjects
 		    atIndex: index];
 
 	return self;
 }
 @end

Index: tests/OFArray.m
==================================================================
--- tests/OFArray.m
+++ tests/OFArray.m
@@ -61,10 +61,18 @@
 	TEST(@"-[indexOfObject:]", [a[0] indexOfObject: c_ary[1]] == 1)
 
 	TEST(@"-[indexOfObjectIdenticalTo:]",
 	    [a[0] indexOfObjectIdenticalTo: c_ary[1]] == 1)
 
+	TEST(@"-[removeObject:]",
+	    [a[0] removeObject: c_ary[1]] && [a[0] count] == 2)
+
+	TEST(@"-[removeObjectIdenticalTo:]",
+	    [a[0] removeObjectIdenticalTo: c_ary[2]] && [a[0] count] == 1)
+
+	[a[0] addObject: c_ary[0]];
+	[a[0] addObject: c_ary[1]];
 	TEST(@"-[removeNObjects:]", [a[0] removeNObjects: 2] &&
 	    [a[0] count] == 1 && [[a[0] objectAtIndex: 0] isEqual: c_ary[0]])
 
 	a[1] = [[a[1] mutableCopy] autorelease];
 	TEST(@"-[removeObjectAtIndex:]", [a[1] removeObjectAtIndex: 1] &&