Index: src/OFArray.m
==================================================================
--- src/OFArray.m
+++ src/OFArray.m
@@ -179,11 +179,11 @@
 - (BOOL)isEqual: (id)obj
 {
 	OFObject **objs, **objs2;
 	size_t i, len, len2;
 
-	if (![obj isKindOf: [OFArray class]])
+	if (![obj isKindOfClass: [OFArray class]])
 		return NO;
 
 	len = [array count];
 	len2 = [obj count];
 

Index: src/OFAutoreleasePool.m
==================================================================
--- src/OFAutoreleasePool.m
+++ src/OFAutoreleasePool.m
@@ -25,11 +25,11 @@
 {
 	of_list_object_t *first, *iter;
 	IMP release;
 
 	if ((first = [(OFList*)list first]) != NULL)
-		release = [first->object methodFor: @selector(release)];
+		release = [first->object methodForSelector: @selector(release)];
 
 	for (iter = first; iter != NULL; iter = iter->next)
 		release(iter->object, @selector(release));
 
 	[(OFList*)list release];

Index: src/OFDataArray.m
==================================================================
--- src/OFDataArray.m
+++ src/OFDataArray.m
@@ -132,11 +132,11 @@
 	return new;
 }
 
 - (BOOL)isEqual: (id)obj
 {
-	if (![obj isKindOf: [OFDataArray class]])
+	if (![obj isKindOfClass: [OFDataArray class]])
 		return NO;
 	if ([obj count] != count || [obj itemsize] != itemsize)
 		return NO;
 	if (memcmp([obj data], data, count * itemsize))
 		return NO;
@@ -146,11 +146,11 @@
 
 - (int)compare: (id)obj
 {
 	int ret;
 
-	if (![obj isKindOf: [OFDataArray class]])
+	if (![obj isKindOfClass: [OFDataArray class]])
 		@throw [OFInvalidArgumentException newWithClass: isa
 						    andSelector: _cmd];
 	if ([obj itemsize] != itemsize)
 		@throw [OFInvalidArgumentException newWithClass: isa
 						    andSelector: _cmd];

Index: src/OFList.m
==================================================================
--- src/OFList.m
+++ src/OFList.m
@@ -206,11 +206,11 @@
 
 - (BOOL)isEqual: (id)obj
 {
 	of_list_object_t *iter, *iter2;
 
-	if (![obj isKindOf: [OFList class]])
+	if (![obj isKindOfClass: [OFList class]])
 		return NO;
 
 	for (iter = first, iter2 = [obj first]; iter != NULL && iter2 != NULL;
 	    iter = iter->next, iter2 = iter2->next)
 		if (![iter->object isEqual: iter2->object])

Index: src/OFNumber.m
==================================================================
--- src/OFNumber.m
+++ src/OFNumber.m
@@ -713,11 +713,11 @@
 	RETURN_AS(long double)
 }
 
 - (BOOL)isEqual: (id)obj
 {
-	if (![obj isKindOf: [OFNumber class]])
+	if (![obj isKindOfClass: [OFNumber class]])
 		return NO;
 
 	switch (type) {
 	case OF_NUMBER_CHAR:
 	case OF_NUMBER_SHORT:

Index: src/OFObject.h
==================================================================
--- src/OFObject.h
+++ src/OFObject.h
@@ -56,11 +56,11 @@
 /**
  * \param protocol The protocol which should be checked for conformance
  *
  * \return A boolean whether the class conforms to the specified protocol
  */
-+ (BOOL)conformsTo: (Protocol*)protocol;
++ (BOOL)conformsToProtocol: (Protocol*)protocol;
 
 /**
  * Replace a method implementation with another implementation.
  *
  * \param selector The selector of the method to replace
@@ -105,32 +105,32 @@
 /**
  * \param class The class whose kind is checked
  *
  * \return A boolean whether the object is of the specified kind
  */
-- (BOOL)isKindOf: (Class)class;
+- (BOOL)isKindOfClass: (Class)class;
 
 /**
  * \param selector The selector which should be checked for respondance
  *
  * \return A boolean whether the objects responds to the specified selector
  */
-- (BOOL)respondsTo: (SEL)selector;
+- (BOOL)respondsToSelector: (SEL)selector;
 
 /**
  * \param protocol The protocol which should be checked for conformance
  *
  * \return A boolean whether the objects conforms to the specified protocol
  */
-- (BOOL)conformsTo: (Protocol*)protocol;
+- (BOOL)conformsToProtocol: (Protocol*)protocol;
 
 /**
  * \param selector The selector for which the method should be returned
  *
  * \return The implementation for the specified selector
  */
-- (IMP)methodFor: (SEL)selector;
+- (IMP)methodForSelector: (SEL)selector;
 
 /**
  * Compare two objects.
  * Classes containing data (like strings, arrays, lists etc.) should reimplement
  * this!

Index: src/OFObject.m
==================================================================
--- src/OFObject.m
+++ src/OFObject.m
@@ -95,21 +95,21 @@
 #else
 	return class_getName(self);
 #endif
 }
 
-+ (BOOL)conformsTo: (Protocol*)protocol
++ (BOOL)conformsToProtocol: (Protocol*)protocol
 {
 #ifdef __objc_INCLUDE_GNU
 	Class c;
 	struct objc_protocol_list *pl;
 	size_t i;
 
 	for (c = self; c != Nil; c = class_get_super_class(c))
 		for (pl = c->protocols; pl != NULL; pl = pl->next)
 			for (i = 0; i < pl->count; i++)
-				if ([pl->list[i] conformsTo: protocol])
+				if ([pl->list[i] conformsToProtocol: protocol])
 					return YES;
 
 	return NO;
 #else
 	Class c;
@@ -189,11 +189,11 @@
 #else
 	return class_getName(isa);
 #endif
 }
 
-- (BOOL)isKindOf: (Class)class
+- (BOOL)isKindOfClass: (Class)class
 {
 	Class iter;
 
 #ifdef __objc_INCLUDE_GNU
 	for (iter = isa; iter != Nil; iter = class_get_super_class(iter))
@@ -204,11 +204,11 @@
 			return YES;
 
 	return NO;
 }
 
-- (BOOL)respondsTo: (SEL)selector
+- (BOOL)respondsToSelector: (SEL)selector
 {
 #ifdef __objc_INCLUDE_GNU
 	if (object_is_instance(self))
 		return class_get_instance_method(isa, selector) != METHOD_NULL;
 	else
@@ -216,16 +216,16 @@
 #else
 	return class_respondsToSelector(isa, selector);
 #endif
 }
 
-- (BOOL)conformsTo: (Protocol*)protocol
+- (BOOL)conformsToProtocol: (Protocol*)protocol
 {
-	return [isa conformsTo: protocol];
+	return [isa conformsToProtocol: protocol];
 }
 
-- (IMP)methodFor: (SEL)selector
+- (IMP)methodForSelector: (SEL)selector
 {
 #ifdef __objc_INCLUDE_GNU
 	if (object_is_instance(self))
 		return method_get_imp(class_get_instance_method(isa, selector));
 	else

Index: src/OFString.m
==================================================================
--- src/OFString.m
+++ src/OFString.m
@@ -279,21 +279,21 @@
 	return [[OFMutableString alloc] initWithString: self];
 }
 
 - (BOOL)isEqual: (id)obj
 {
-	if (![obj isKindOf: [OFString class]])
+	if (![obj isKindOfClass: [OFString class]])
 		return NO;
 	if (strcmp(string, [obj cString]))
 		return NO;
 
 	return YES;
 }
 
 - (int)compare: (id)obj
 {
-	if (![obj isKindOf: [OFString class]])
+	if (![obj isKindOfClass: [OFString class]])
 		@throw [OFInvalidArgumentException newWithClass: isa
 						    andSelector: _cmd];
 
 	return strcmp(string, [obj cString]);
 }

Index: src/OFXMLElement.m
==================================================================
--- src/OFXMLElement.m
+++ src/OFXMLElement.m
@@ -114,12 +114,12 @@
 			OFXMLElement **data = [children data];
 			size_t count = [children count];
 			IMP append;
 
 			tmp = [OFMutableString string];
-			append = [tmp methodFor: @selector(
-			    appendCStringWithoutUTF8Checking:)];
+			append = [tmp methodForSelector:
+			    @selector(appendCStringWithoutUTF8Checking:)];
 
 			for (j = 0; j < count; j++)
 				append(tmp, @selector(
 				    appendCStringWithoutUTF8Checking:),
 				    [[data[j] string] cString]);