@@ -28,22 +28,21 @@
 
 OF_DIRECT_MEMBERS
 @interface OFListEnumerator: OFEnumerator
 {
 	OFList *_list;
-	of_list_object_t *_Nullable _current;
+	OFListItem *_Nullable _current;
 	unsigned long _mutations;
 	unsigned long *_Nullable _mutationsPtr;
 }
 
 - (instancetype)initWithList: (OFList *)list
 	    mutationsPointer: (unsigned long *)mutationsPtr;
 @end
 
 @implementation OFList
-@synthesize firstListObject = _firstListObject;
-@synthesize lastListObject = _lastListObject;
+@synthesize firstListItem = _firstListItem, lastListItem = _lastListItem;
 
 + (instancetype)list
 {
 	return [[[self alloc] init] autorelease];
 }
@@ -77,142 +76,138 @@
 	return self;
 }
 
 - (void)dealloc
 {
-	of_list_object_t *next;
+	OFListItem *next;
 
-	for (of_list_object_t *iter = _firstListObject;
-	    iter != NULL; iter = next) {
+	for (OFListItem *iter = _firstListItem; iter != NULL; iter = next) {
 		[iter->object release];
 		next = iter->next;
 		free(iter);
 	}
 
 	[super dealloc];
 }
 
-- (of_list_object_t *)appendObject: (id)object
-{
-	of_list_object_t *listObject;
-
-	listObject = of_alloc(1, sizeof(of_list_object_t));
-	listObject->object = [object retain];
-	listObject->next = NULL;
-	listObject->previous = _lastListObject;
-
-	if (_lastListObject != NULL)
-		_lastListObject->next = listObject;
-
-	_lastListObject = listObject;
-
-	if (_firstListObject == NULL)
-		_firstListObject = listObject;
-
-	_count++;
-	_mutations++;
-
-	return listObject;
-}
-
-- (of_list_object_t *)prependObject: (id)object
-{
-	of_list_object_t *listObject;
-
-	listObject = of_alloc(1, sizeof(of_list_object_t));
-	listObject->object = [object retain];
-	listObject->next = _firstListObject;
-	listObject->previous = NULL;
-
-	if (_firstListObject != NULL)
-		_firstListObject->previous = listObject;
-
-	_firstListObject = listObject;
-	if (_lastListObject == NULL)
-		_lastListObject = listObject;
-
-	_count++;
-	_mutations++;
-
-	return listObject;
-}
-
-- (of_list_object_t *)insertObject: (id)object
-		  beforeListObject: (of_list_object_t *)listObject
-{
-	of_list_object_t *newListObject;
-
-	newListObject = of_alloc(1, sizeof(of_list_object_t));
-	newListObject->object = [object retain];
-	newListObject->next = listObject;
-	newListObject->previous = listObject->previous;
-
-	if (listObject->previous != NULL)
-		listObject->previous->next = newListObject;
-
-	listObject->previous = newListObject;
-
-	if (listObject == _firstListObject)
-		_firstListObject = newListObject;
-
-	_count++;
-	_mutations++;
-
-	return newListObject;
-}
-
-- (of_list_object_t *)insertObject: (id)object
-		   afterListObject: (of_list_object_t *)listObject
-{
-	of_list_object_t *newListObject;
-
-	newListObject = of_alloc(1, sizeof(of_list_object_t));
-	newListObject->object = [object retain];
-	newListObject->next = listObject->next;
-	newListObject->previous = listObject;
-
-	if (listObject->next != NULL)
-		listObject->next->previous = newListObject;
-
-	listObject->next = newListObject;
-
-	if (listObject == _lastListObject)
-		_lastListObject = newListObject;
-
-	_count++;
-	_mutations++;
-
-	return newListObject;
-}
-
-- (void)removeListObject: (of_list_object_t *)listObject
-{
-	if (listObject->previous != NULL)
-		listObject->previous->next = listObject->next;
-	if (listObject->next != NULL)
-		listObject->next->previous = listObject->previous;
-
-	if (_firstListObject == listObject)
-		_firstListObject = listObject->next;
-	if (_lastListObject == listObject)
-		_lastListObject = listObject->previous;
-
-	_count--;
-	_mutations++;
-
-	[listObject->object release];
-	free(listObject);
-}
-
-- (id)firstObject
-{
-	return (_firstListObject != NULL ? _firstListObject->object : nil);
-}
-
-- (id)lastObject
-{
-	return (_lastListObject != NULL ? _lastListObject->object : nil);
+- (OFListItem *)appendObject: (id)object
+{
+	OFListItem *listItem;
+
+	listItem = of_alloc(1, sizeof(OFListItem));
+	listItem->object = [object retain];
+	listItem->next = NULL;
+	listItem->previous = _lastListItem;
+
+	if (_lastListItem != NULL)
+		_lastListItem->next = listItem;
+
+	_lastListItem = listItem;
+
+	if (_firstListItem == NULL)
+		_firstListItem = listItem;
+
+	_count++;
+	_mutations++;
+
+	return listItem;
+}
+
+- (OFListItem *)prependObject: (id)object
+{
+	OFListItem *listItem = of_alloc(1, sizeof(OFListItem));
+
+	listItem->object = [object retain];
+	listItem->next = _firstListItem;
+	listItem->previous = NULL;
+
+	if (_firstListItem != NULL)
+		_firstListItem->previous = listItem;
+
+	_firstListItem = listItem;
+	if (_lastListItem == NULL)
+		_lastListItem = listItem;
+
+	_count++;
+	_mutations++;
+
+	return listItem;
+}
+
+- (OFListItem *)insertObject: (id)object
+	      beforeListItem: (OFListItem *)listItem
+{
+	OFListItem *newListItem = of_alloc(1, sizeof(OFListItem));
+
+	newListItem->object = [object retain];
+	newListItem->next = listItem;
+	newListItem->previous = listItem->previous;
+
+	if (listItem->previous != NULL)
+		listItem->previous->next = newListItem;
+
+	listItem->previous = newListItem;
+
+	if (listItem == _firstListItem)
+		_firstListItem = newListItem;
+
+	_count++;
+	_mutations++;
+
+	return newListItem;
+}
+
+- (OFListItem *)insertObject: (id)object
+	       afterListItem: (OFListItem *)listItem
+{
+	OFListItem *newListItem = of_alloc(1, sizeof(OFListItem));
+
+	newListItem->object = [object retain];
+	newListItem->next = listItem->next;
+	newListItem->previous = listItem;
+
+	if (listItem->next != NULL)
+		listItem->next->previous = newListItem;
+
+	listItem->next = newListItem;
+
+	if (listItem == _lastListItem)
+		_lastListItem = newListItem;
+
+	_count++;
+	_mutations++;
+
+	return newListItem;
+}
+
+- (void)removeListItem: (OFListItem *)listItem
+{
+	if (listItem->previous != NULL)
+		listItem->previous->next = listItem->next;
+	if (listItem->next != NULL)
+		listItem->next->previous = listItem->previous;
+
+	if (_firstListItem == listItem)
+		_firstListItem = listItem->next;
+	if (_lastListItem == listItem)
+		_lastListItem = listItem->previous;
+
+	_count--;
+	_mutations++;
+
+	[listItem->object release];
+	free(listItem);
+}
+
+- (id)firstObject
+{
+	return (_firstListItem != NULL ? _firstListItem->object : nil);
+}
+
+- (id)lastObject
+{
+	return (_lastListItem != NULL ? _lastListItem->object : nil);
 }
 
 - (size_t)count
 {
 	return _count;
@@ -219,11 +214,11 @@
 }
 
 - (bool)isEqual: (id)object
 {
 	OFList *list;
-	of_list_object_t *iter, *iter2;
+	OFListItem *iter, *iter2;
 
 	if (object == self)
 		return true;
 
 	if (![object isKindOfClass: [OFList class]])
@@ -232,11 +227,11 @@
 	list = object;
 
 	if (list.count != _count)
 		return false;
 
-	for (iter = _firstListObject, iter2 = list.firstListObject;
+	for (iter = _firstListItem, iter2 = list.firstListItem;
 	    iter != NULL && iter2 != NULL;
 	    iter = iter->next, iter2 = iter2->next)
 		if (![iter->object isEqual: iter2->object])
 			return false;
 
@@ -249,12 +244,11 @@
 - (bool)containsObject: (id)object
 {
 	if (_count == 0)
 		return false;
 
-	for (of_list_object_t *iter = _firstListObject;
-	    iter != NULL; iter = iter->next)
+	for (OFListItem *iter = _firstListItem; iter != NULL; iter = iter->next)
 		if ([iter->object isEqual: object])
 			return true;
 
 	return false;
 }
@@ -262,65 +256,63 @@
 - (bool)containsObjectIdenticalTo: (id)object
 {
 	if (_count == 0)
 		return false;
 
-	for (of_list_object_t *iter = _firstListObject;
-	    iter != NULL; iter = iter->next)
+	for (OFListItem *iter = _firstListItem; iter != NULL; iter = iter->next)
 		if (iter->object == object)
 			return true;
 
 	return false;
 }
 
 - (void)removeAllObjects
 {
-	of_list_object_t *next;
+	OFListItem *next;
 
 	_mutations++;
 
-	for (of_list_object_t *iter = _firstListObject;
-	    iter != NULL; iter = next) {
+	for (OFListItem *iter = _firstListItem; iter != NULL; iter = next) {
 		[iter->object release];
 		next = iter->next;
 		free(iter);
 	}
 
-	_firstListObject = _lastListObject = NULL;
+	_firstListItem = _lastListItem = NULL;
 }
 
 - (id)copy
 {
 	OFList *copy = [[[self class] alloc] init];
-	of_list_object_t *listObject, *previous;
+	OFListItem *listItem, *previous;
 
-	listObject = NULL;
+	listItem = NULL;
 	previous = NULL;
 
 	@try {
-		for (of_list_object_t *iter = _firstListObject;
+		for (OFListItem *iter = _firstListItem;
 		    iter != NULL; iter = iter->next) {
-			listObject = of_alloc(1, sizeof(of_list_object_t));
-			listObject->object = [iter->object retain];
-			listObject->next = NULL;
-			listObject->previous = previous;
+			listItem = of_alloc(1, sizeof(OFListItem));
+			listItem->object = [iter->object retain];
+			listItem->next = NULL;
+			listItem->previous = previous;
 
-			if (copy->_firstListObject == NULL)
-				copy->_firstListObject = listObject;
+			if (copy->_firstListItem == NULL)
+				copy->_firstListItem = listItem;
 			if (previous != NULL)
-				previous->next = listObject;
+				previous->next = listItem;
 
 			copy->_count++;
 
-			previous = listObject;
+			previous = listItem;
 		}
 	} @catch (id e) {
 		[copy release];
 		@throw e;
 	}
 
-	copy->_lastListObject = listObject;
+	copy->_lastListItem = listItem;
 
 	return copy;
 }
 
 - (unsigned long)hash
@@ -327,11 +319,11 @@
 {
 	uint32_t hash;
 
 	OF_HASH_INIT(hash);
 
-	for (of_list_object_t *iter = _firstListObject;
+	for (OFListItem *iter = _firstListItem;
 	    iter != NULL; iter = iter->next)
 		OF_HASH_ADD_HASH(hash, [iter->object hash]);
 
 	OF_HASH_FINALIZE(hash);
 
@@ -345,11 +337,11 @@
 	if (_count == 0)
 		return @"[]";
 
 	ret = [OFMutableString stringWithString: @"[\n"];
 
-	for (of_list_object_t *iter = _firstListObject;
+	for (OFListItem *iter = _firstListItem;
 	    iter != NULL; iter = iter->next) {
 		void *pool = objc_autoreleasePoolPush();
 
 		[ret appendString: [iter->object description]];
 
@@ -370,11 +362,11 @@
 {
 	OFXMLElement *element =
 	    [OFXMLElement elementWithName: self.className
 				namespace: OF_SERIALIZATION_NS];
 
-	for (of_list_object_t *iter = _firstListObject;
+	for (OFListItem *iter = _firstListItem;
 	    iter != NULL; iter = iter->next) {
 		void *pool = objc_autoreleasePoolPush();
 
 		[element addChild: [iter->object XMLElementBySerializing]];
 
@@ -386,31 +378,31 @@
 
 - (int)countByEnumeratingWithState: (OFFastEnumerationState *)state
 			   objects: (id *)objects
 			     count: (int)count
 {
-	of_list_object_t *listObject;
+	OFListItem *listItem;
 
-	memcpy(&listObject, state->extra, sizeof(listObject));
+	memcpy(&listItem, state->extra, sizeof(listItem));
 
 	state->itemsPtr = objects;
 	state->mutationsPtr = &_mutations;
 
 	if (state->state == 0) {
-		listObject = _firstListObject;
+		listItem = _firstListItem;
 		state->state = 1;
 	}
 
 	for (int i = 0; i < count; i++) {
-		if (listObject == NULL)
+		if (listItem == NULL)
 			return i;
 
-		objects[i] = listObject->object;
-		listObject = listObject->next;
+		objects[i] = listItem->object;
+		listItem = listItem->next;
 	}
 
-	memcpy(state->extra, &listObject, sizeof(listObject));
+	memcpy(state->extra, &listItem, sizeof(listItem));
 
 	return count;
 }
 
 - (OFEnumerator *)objectEnumerator
@@ -426,11 +418,11 @@
 	    mutationsPointer: (unsigned long *)mutationsPtr
 {
 	self = [super init];
 
 	_list = [list retain];
-	_current = _list.firstListObject;
+	_current = _list.firstListItem;
 	_mutations = *mutationsPtr;
 	_mutationsPtr = mutationsPtr;
 
 	return self;
 }