diff --git a/bflibcpp/makefile b/bflibcpp/makefile
index 6778839..4291164 100644
--- a/bflibcpp/makefile
+++ b/bflibcpp/makefile
@@ -33,11 +33,13 @@ defer
 ifeq ($(CONFIG),release) # release
 BIN_NAME = $(LIB_FILE_NAME_RELEASE)
 FLAGS = $(CPPFLAGS) -Isrc/ $(CPPSTD) -I../bflibc/bin/release
+
 ### Debug settings
 else ifeq ($(CONFIG),debug) # debug
 BIN_NAME = $(LIB_FILE_NAME_DEBUG)
 #ADDR_SANITIZER = -fsanitize=address
 FLAGS = $(CPPFLAGS) -DDEBUG -g -Isrc/ $(ADDR_SANITIZER) $(CPPSTD) -I../bflibc/bin/debug
+
 ### Test settings
 else ifeq ($(CONFIG),test) # test
 BIN_NAME = libbfcpp-test
diff --git a/bflibcpp/src/array.hpp b/bflibcpp/src/array.hpp
index df20bf1..342ea99 100644
--- a/bflibcpp/src/array.hpp
+++ b/bflibcpp/src/array.hpp
@@ -14,6 +14,7 @@
 #include "vector.hpp"
 #include <string.h>
 #include "exception.hpp"
+#include "swap.hpp"
 
 namespace BF {
 
@@ -26,7 +27,7 @@ namespace BF {
  * Objects stored in array are assumed to be owned by owner of array 
  * object
  */
-template <typename T, typename S = size_t>
+template <typename T, typename S = long>
 class Array : public Vector<T,S> {
 public:
 	virtual const char * className() const {
@@ -382,12 +383,6 @@ class Array : public Vector<T,S> {
 
 public:
 
-	/*
-	T operator[](S index) const {
-		return this->objectAtIndex(index);
-	}
-	*/
-
 	void operator=(const std::initializer_list<T> & list) {
 		this->saveArray(list);
 	}
@@ -400,6 +395,14 @@ class Array : public Vector<T,S> {
 		return *this;
 	}
 
+	virtual T operator[](S index) const {
+		return this->objectAtIndex(index);
+	}
+
+	virtual T & operator[](S index) {
+		return this->refObjectAtIndex(index);
+	}
+
 // Comparators
 public:
 	/**
diff --git a/bflibcpp/src/bflibcpp.hpp b/bflibcpp/src/bflibcpp.hpp
index 4ec7af3..d3a1599 100644
--- a/bflibcpp/src/bflibcpp.hpp
+++ b/bflibcpp/src/bflibcpp.hpp
@@ -31,6 +31,7 @@
 #include "deque.hpp"
 #include "hash.hpp"
 #include "defer.hpp"
+#include "sort.hpp"
 
 #endif // BFLIBCPP_HPP
 
diff --git a/bflibcpp/src/list.hpp b/bflibcpp/src/list.hpp
index 86eefe8..541d5f7 100644
--- a/bflibcpp/src/list.hpp
+++ b/bflibcpp/src/list.hpp
@@ -9,11 +9,14 @@
 #include "access.hpp"
 #include "vector.hpp"
 #include "exception.hpp"
+#include "swap.hpp"
 #include <iostream>
 #include <initializer_list>
 
 namespace BF {
 
+template<template <typename...> class T> struct Sort;
+
 /**
  * Linked List implementation
  *
@@ -29,15 +32,18 @@ namespace BF {
  * Unless a callback is specified, by default the node
  * object memory will not be deallocated.
  */
-template <typename L, typename S = size_t>
+template <typename L, typename S = long>
 class List : public Vector<L,S> {
 public:
+	friend struct Sort<List>;
 	
 	/**
 	 * Bi-directional node
 	 */
 	class Node : public Object {
-		friend List<L, S>;
+		friend List<L,S>;
+	
+		friend struct Sort<List>;
 	public:
 		Node * next() const {
 			return this->right;
@@ -207,13 +213,13 @@ class List : public Vector<L,S> {
 	// returns object at index
 	// returns 0 if an error ocurred
 	virtual L objectAtIndex(S index) const {
-		Node * n = this->nodeAtIndex(index, this->_head, 0);
+		Node * n = this->nodeAtIndex(index, this->_head);
 		if (n) return n->object();
 		else return 0;
 	}
 
 	virtual L & refObjectAtIndex(S index) {
-		Node * n = this->nodeAtIndex(index, this->_head, 0);
+		Node * n = this->nodeAtIndex(index, this->_head);
 		if (n) return n->refobject();
 		throw Exception("no object found at %d", (int) index);
 	}
@@ -276,9 +282,8 @@ class List : public Vector<L,S> {
 		for (; n; n = n->prev()) {
 			// Get random node
 			int r = rand() % (i + 1);
-			Node * tmp = this->nodeAtIndex(r, this->_head, 0);
-			int err = this->swap(n, tmp); // swap nodes
-			if (err) return err; // leave if there was an error in swapping
+			Node * tmp = this->nodeAtIndex(r, this->_head);
+			BF::swap<L>(n->obj, tmp->obj); // swap nodes
 			i--;
 		}
 
@@ -316,20 +321,6 @@ class List : public Vector<L,S> {
 
 private:
 
-	/**
-	 * Swaps a and b objects
-	 */
-	static int swap(Node * a, Node * b) {
-		// Don't continue with this if a or b are null
-		if (!a || !b) return -1;
-		else {
-			L obj = a->obj;
-			a->obj = b->obj;
-			b->obj = obj;
-			return 0;
-		}
-	}
-
 	/**
 	 * Allows us to set list with {...} notation
 	 *
@@ -355,16 +346,20 @@ class List : public Vector<L,S> {
 	}
 
 	/**
-	 * Recursively traverses through linked list until we read the reqIndex'th node
+	 * iteratively traverses through linked list until we read the reqIndex'th node
+	 *
+	 * we start with the search from the `node` param
+	 * 
+	 * if reqIndex < 0, returns NULL
 	 */
-	Node * nodeAtIndex(S reqIndex, Node * node, S currIndex) const {
-		if (node) {
-			if (currIndex == reqIndex) {
-				return node;
-			} else {
-				return this->nodeAtIndex(reqIndex, node->right, ++currIndex);
-			}
-		} else return 0;
+	Node * nodeAtIndex(S reqIndex, Node * node) const {
+		if (reqIndex < 0) return NULL;
+
+		while (--reqIndex >= 0 && node) {
+			node = node->right;
+		}
+
+		return node;
 	}
 
 	/**
@@ -484,6 +479,14 @@ class List : public Vector<L,S> {
 		this->set(list);
 	}
 
+	virtual L operator[](S index) const {
+		return this->objectAtIndex(index);
+	}
+
+	virtual L & operator[](S index) {
+		return this->refObjectAtIndex(index);
+	}
+
 public:
 
 	/**
diff --git a/bflibcpp/src/sort.hpp b/bflibcpp/src/sort.hpp
new file mode 100644
index 0000000..abdf8d4
--- /dev/null
+++ b/bflibcpp/src/sort.hpp
@@ -0,0 +1,475 @@
+/**
+ * author: brando
+ * date: 4/23/25
+ */
+
+#ifndef SORT_HPP
+#define SORT_HPP
+
+#include "array.hpp"
+#include "list.hpp"
+//#include "typesortstrategy.hpp"
+
+namespace BF {
+
+template<template <typename...> class T> struct Sort;
+
+// Generic sort function
+template <template <typename...> class ContainerTemplate, typename... Args>
+int sort(ContainerTemplate<Args...>& v) {
+    Sort<ContainerTemplate> sorter; // Instantiate Sort with the container template
+    return sorter(v);
+}
+
+template <> struct Sort<List> {
+	template <typename L, typename S = size_t> 
+	int operator()(List<L,S> & list, SortStrategy strategy = kSortStrategyMerge) {
+		switch (strategy) {
+			case kSortStrategyBubble:
+				return Sort::sortBubble<L,S>(list);
+			case kSortStrategyInsertion:
+				return Sort::sortInsertion<L,S>(list);
+			case kSortStrategySelection:
+				return Sort::sortSelection<L,S>(list);
+			case kSortStrategyQuick:
+				return Sort::sortQuick<L,S>(list);
+			case kSortStrategyMerge:
+			default:
+				return Sort::sortMerge<L,S>(list);
+		}
+	}
+
+	/** BUBBLE SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortBubble(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		S len = c.size();
+		int itr = 0;
+		bool swapped = false;
+
+		while (itr < len) {
+			typename List<L,S>::Node * trav = head;
+			typename List<L,S>::Node * prev = head;
+			swapped = false;
+			
+			while (trav->next()) {
+				typename List<L,S>::Node * ptr = trav->next();
+				if (trav->object() > ptr->object()) {
+					swapped = true;
+					if (trav == head) {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev = ptr;
+						head = prev;
+					} else {
+						trav->right = ptr->right;
+						ptr->right = trav;
+						prev->right = ptr;
+						prev = ptr;
+					}
+
+					continue;
+				}
+				prev = trav;
+				trav = trav->next();
+			}
+
+			if (!swapped) {
+				break;
+			}
+			++itr;
+		}
+
+		c._head = head;
+
+		return 0;
+	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static typename List<L,S>::Node * sortInsertion(typename List<L,S>::Node * newNode, typename List<L,S>::Node * sorted) {
+		if (!sorted || sorted->object() >= newNode->object()) {
+			newNode->right = sorted;
+			sorted = newNode;
+		} else {
+			typename List<L,S>::Node * curr = sorted;
+			while (curr->right && curr->right->object() < newNode->object()) {
+				curr = curr->next();
+			}
+
+			newNode->right = curr->right;
+			curr->right = newNode;
+		}
+
+		return sorted;
+	}
+
+	template <typename L, typename S = size_t> 
+	static int sortInsertion(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		typename List<L,S>::Node * sorted = NULL;
+		typename List<L,S>::Node * curr = head;
+
+		while (curr) {
+			typename List<L,S>::Node * next = curr->next();
+			sorted = sortInsertion<L,S>(curr, sorted);
+			curr = next;
+		}
+
+		c._head = sorted;
+
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortSelection(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		for (typename List<L,S>::Node * start = head; start; start = start->next()) {
+			typename List<L,S>::Node * min = start;
+			for (typename List<L,S>::Node * curr = start->next(); curr; curr = curr->next()) {
+				if (curr->object() < min->object()) {
+					min = curr;
+				}
+			}
+
+			if (min != start) {
+				L val = start->object();
+				start->obj = min->object();
+				min->obj = val;
+			}
+		}
+
+		c._head = head;
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortQuick(List<L,S> & c) {
+		typename List<L,S>::Node * head = c.first();
+		typename List<L,S>::Node * tail = c.last();
+
+		sortQuick<L,S>(head, tail);
+
+		c._head = head;
+		return 0;
+	}
+	
+	template <typename L, typename S = size_t> 
+	static void sortQuick(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
+		if (!head || head == tail) {
+			return;
+		}
+
+		typename List<L,S>::Node * pivot = sortQuickGetPivot<L,S>(head, tail);
+
+		sortQuick<L,S>(head, pivot);
+		sortQuick<L,S>(pivot->next(), tail);
+	}
+	
+	template <typename L, typename S = size_t> 
+	static typename List<L,S>::Node * sortQuickGetPivot(typename List<L,S>::Node * head, typename List<L,S>::Node * tail) {
+		typename List<L,S>::Node * pivot = head;
+
+		typename List<L,S>::Node * pre = head;
+		typename List<L,S>::Node * curr = head;
+
+		while (curr != tail->next()) {
+			if (curr->object() < pivot->object()) {
+				BF::swap<L>(curr->obj, pre->right->obj);
+				pre = pre->next();
+			}
+
+			curr = curr->next();
+		}
+
+		BF::swap<L>(pivot->obj, pre->obj);
+
+		return pre;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	template <typename L, typename S = size_t> 
+	static int sortMerge(List<L,S> & c) {
+		c._head = sortMerge<L,S>(c._head);
+		return 0;
+	}
+
+	template <typename L, typename S = size_t> 
+	static typename List<L,S>::Node * sortMerge(typename List<L,S>::Node * head) {
+		if (!head || !head->next()) {
+			return head;
+		}
+
+		typename List<L,S>::Node * second = sortMergeSplit<L,S>(head);
+		head = sortMerge<L,S>(head);
+		second = sortMerge<L,S>(second);
+
+		return sortMerge<L,S>(head, second);
+	}
+	
+	template <typename L, typename S = size_t> 
+	static typename List<L,S>::Node * sortMerge(typename List<L,S>::Node * first, typename List<L,S>::Node * second) {
+		if (!first) return second;
+		if (!second) return first;
+
+		if (first->object() < second->object()) {
+			first->right = sortMerge<L,S>(first->next(), second);
+			return first;
+		} else {
+			second->right = sortMerge<L,S>(first, second->next());
+			return second;
+		}
+	}
+
+	template <typename L, typename S = size_t> 
+	static typename List<L,S>::Node * sortMergeSplit(typename List<L,S>::Node * head) {
+		typename List<L,S>::Node * fast = head;
+		typename List<L,S>::Node * slow = head;
+
+		while (fast && fast->next()) {
+			fast = fast->right->right;
+			if (fast) {
+				slow = slow->right;
+			}
+		}
+
+		typename List<L,S>::Node * tmp = slow->right;
+		slow->right = NULL;
+		return tmp;
+	}
+	
+	/** MERGE SORT - END **/
+};
+
+template <> struct Sort<Array> {
+	template <typename T, typename S = size_t> 
+	int operator()(Array<T,S> & array, SortStrategy strategy = kSortStrategyMerge) {
+		switch (strategy) {
+			case kSortStrategyBubble:
+				return Sort::sortBubble<T,S>(array);
+			case kSortStrategyInsertion:
+				return Sort::sortInsertion<T,S>(array);
+			case kSortStrategySelection:
+				return Sort::sortSelection<T,S>(array);
+			case kSortStrategyQuick:
+				return Sort::sortQuick<T,S>(array);
+			case kSortStrategyMerge:
+			default:
+				return Sort::sortMerge<T,S>(array);
+		}
+	}
+
+	/** BUBBLE SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortBubble(Array<T,S> & c) {
+		S n = c.size();
+		bool swapped = false;
+
+		for (S i = 0; i < n - 1; i++) {
+			swapped = false;
+			for (S j = 0; j < n - i - 1; j++) {
+				if (c[j] > c[j + 1]) {
+					swap(c[j], c[j + 1]);
+					swapped = true;
+				}
+			}
+
+			// If no two elements were swapped, then break
+			if (!swapped)
+				break;
+		}
+		return 0;
+	}
+
+	/** BUBBLE SORT - END **/
+	/** INSERTION SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortInsertion(Array<T,S> & c) {
+		S i, j;
+		T key;
+		S n = c.size();
+		for (i = 1; i < n; i++) {
+			key = c[i];
+			j = i - 1;
+	 
+			// Move elements of arr[0..i-1],
+			// that are greater than key, to one
+			// position ahead of their
+			// current position
+			while (j >= 0 && c[j] > key) {
+				c[j + 1] = c[j];
+				j = j - 1;
+			}
+			c[j + 1] = key;
+		}
+		return 0;
+	}
+
+	/** INSERTION SORT - END **/
+	/** SELECTION SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortSelection(Array<T,S> & c) {
+		S i, j, min_idx;
+		S n = c.size();
+
+		// One by one move boundary of
+		// unsorted subarray
+		for (i = 0; i < n-1; i++) {
+			// Find the minimum element in
+			// unsorted array
+			min_idx = i;
+			for (j = i+1; j < n; j++)
+				if (c[j] < c[min_idx])
+					min_idx = j;
+
+			// Swap the found minimum element
+			// with the first element
+			if (c[min_idx] != c[i]) {
+				swap(c[min_idx], c[i]);
+			}
+		}
+		return 0;
+	}
+
+	/** SELECTION SORT - END **/
+	/** QUICK SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortQuick(Array<T,S> & c) {
+		return sortQuick<T,S>(c, 0, c.size() - 1);
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortQuick(Array<T,S> & c, S low, S high) {
+		if (low < high) {
+			// pi is the partition return index of pivot
+			S pi = sortQuickPartition<T,S>(c, low, high);
+
+			// Recursion calls for smaller elements
+			// and greater or equals elements
+			sortQuick<T,S>(c, low, pi - 1);
+			sortQuick<T,S>(c, pi + 1, high);
+		}
+
+		return 0;
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortQuickPartition(Array<T,S> & c, S low, S high) {
+		// Choose the pivot
+		T pivot = c[high];
+	  
+		// Index of smaller element and indicates 
+		// the right position of pivot found so far
+		S i = low - 1;
+
+		// Traverse arr[;ow..high] and move all smaller
+		// elements on left side. Elements from low to 
+		// i are smaller after every iteration
+		for (S j = low; j <= high - 1; j++) {
+			if (c[j] < pivot) {
+				i++;
+				if (c[i] != c[j]) {
+					swap(c[i], c[j]);
+				}
+			}
+		}
+		
+		// Move pivot after smaller elements and
+		// return its position
+		if (c[i + 1] != c[high]) {
+			swap(c[i + 1], c[high]);
+		}
+		return i + 1;
+	}
+
+	/** QUICK SORT - END **/
+	/** MERGE SORT - START **/
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c) {
+		return sortMerge<T,S>(c, 0, c.size() - 1);
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c, S left, S right) {
+		if (left >= right)
+			return 0;
+
+		S mid = left + (right - left) / 2;
+		sortMerge<T,S>(c, left, mid);
+		sortMerge<T,S>(c, mid + 1, right);
+		sortMerge<T,S>(c, left, mid, right);
+		return 0;
+	}
+
+	template <typename T, typename S = size_t> 
+	static int sortMerge(Array<T,S> & c, S left, S mid, S right) {
+		S n1 = mid - left + 1;
+		S n2 = right - mid;
+
+		// Create temp vectors
+		T L[n1], R[n2];
+
+		// Copy data to temp vectors L[] and R[]
+		for (S i = 0; i < n1; i++)
+			L[i] = c[left + i];
+		for (S j = 0; j < n2; j++)
+			R[j] = c[mid + 1 + j];
+
+		S i = 0, j = 0;
+		S k = left;
+
+		// Merge the temp vectors back
+		// into arr[left..right]
+		while (i < n1 && j < n2) {
+			if (L[i] <= R[j]) {
+				c[k] = L[i];
+				i++;
+			}
+			else {
+				c[k] = R[j];
+				j++;
+			}
+			k++;
+		}
+
+		// Copy the remaining elements of L[],
+		// if there are any
+		while (i < n1) {
+			c[k] = L[i];
+			i++;
+			k++;
+		}
+
+		// Copy the remaining elements of R[],
+		// if there are any
+		while (j < n2) {
+			c[k] = R[j];
+			j++;
+			k++;
+		}
+		return 0;
+	}
+	
+	/** MERGE SORT - END **/
+};
+
+}
+
+#endif // SORT_HPP
+
diff --git a/bflibcpp/src/string.cpp b/bflibcpp/src/string.cpp
index 886ae2d..45c58b0 100644
--- a/bflibcpp/src/string.cpp
+++ b/bflibcpp/src/string.cpp
@@ -182,8 +182,16 @@ bool String::operator<(const String & s) const {
 	return this->compareString(s) < 0;
 }
 
+bool String::operator<=(const String & s) const {
+	return this->compareString(s) <= 0;
+}
+
 bool String::operator>(const String & s) const {
-	return this->compareString(s) >0;
+	return this->compareString(s) > 0;
+}
+
+bool String::operator>=(const String & s) const {
+	return this->compareString(s) >= 0;
 }
 
 int String::compareString(const String & s) const {
@@ -212,10 +220,6 @@ String & String::operator=(const String & str) {
 	return *this;
 }
 
-const char String::operator[](size_t index) const {
-	return this->objectAtIndex(index);
-}
-
 int String::toi(const String & s) {
 	return atoi(s.cString());
 }
diff --git a/bflibcpp/src/string.hpp b/bflibcpp/src/string.hpp
index 8ac7d39..3f5689d 100644
--- a/bflibcpp/src/string.hpp
+++ b/bflibcpp/src/string.hpp
@@ -132,14 +132,15 @@ class String : public Array<char, size_t> {
 		return out << s.cString();
 	}
 
-	bool operator==(const String & s) const;
-	bool operator==(const char * s) const;
-	bool operator<(const String & s) const;
-	bool operator>(const String & s) const;
-	bool operator!=(const String & s) const;
-	bool operator!=(const char * s) const;
+	virtual bool operator==(const String & s) const;
+	virtual bool operator==(const char * s) const;
+	virtual bool operator<(const String & s) const;
+	virtual bool operator<=(const String & s) const;
+	virtual bool operator>(const String & s) const;
+	virtual bool operator>=(const String & s) const;
+	virtual bool operator!=(const String & s) const;
+	virtual bool operator!=(const char * s) const;
 	virtual String & operator=(const String & str);
-	const char operator[](size_t index) const;
 
 // Conversions
 public:
diff --git a/bflibcpp/src/swap.hpp b/bflibcpp/src/swap.hpp
new file mode 100644
index 0000000..a06c76d
--- /dev/null
+++ b/bflibcpp/src/swap.hpp
@@ -0,0 +1,21 @@
+/**
+ * author: brando
+ * date: 4/22/25
+ */
+
+#ifndef SWAP_HPP
+#define SWAP_HPP
+
+namespace BF {
+
+template<typename T>
+void swap(T & a, T & b) {
+	T tmp = a;
+	a = b;
+	b = tmp;
+}
+
+}
+
+#endif // SWAP_HPP
+
diff --git a/bflibcpp/src/typesortstrategy.hpp b/bflibcpp/src/typesortstrategy.hpp
new file mode 100644
index 0000000..18c54a2
--- /dev/null
+++ b/bflibcpp/src/typesortstrategy.hpp
@@ -0,0 +1,18 @@
+/**
+ * author: brando
+ * date: 4/23/25
+ */
+
+#ifndef TYPE_SORT_STRATEGY_HPP
+#define TYPE_SORT_STRATEGY_HPP
+
+typedef enum {
+	kSortStrategyBubble = 1,
+	kSortStrategyInsertion = 2,
+	kSortStrategySelection = 3,
+	kSortStrategyMerge = 4,
+	kSortStrategyQuick = 5,
+} SortStrategy;
+
+#endif // TYPE_SORT_STRATEGY_HPP
+
diff --git a/bflibcpp/src/vector.hpp b/bflibcpp/src/vector.hpp
index 90fad20..9267d85 100644
--- a/bflibcpp/src/vector.hpp
+++ b/bflibcpp/src/vector.hpp
@@ -7,28 +7,17 @@
 #define VECTOR_HPP
 
 #include "collection.hpp"
-
-extern "C" {
-#include <bflibc/swap.h>
-}
+#include "typesortstrategy.hpp"
 
 namespace BF {
 
-typedef enum {
-	kVectorSortBubble = 1,
-	kVectorSortInsertion = 2,
-	kVectorSortSelection = 3,
-	kVectorSortMerge = 4,
-	kVectorSortQuick = 5,
-} VectorSort;
-
 /**
  * This class serves as a base class to all array type
  * implementations. Purpose is to abstract each class such
  * that I can have a set of mutable functions like sorting
  * to be used across different classes
  */
-template <typename T, typename S = size_t>
+template <typename T, typename S = long>
 class Vector : public Collection<S> {
 public:
 	virtual ~Vector() { }
@@ -37,228 +26,19 @@ class Vector : public Collection<S> {
 	virtual T & refObjectAtIndex(S index) = 0;
 	virtual T max() const = 0;
 
-	T operator[](S index) const {
+	virtual T operator[](S index) const {
 		return this->objectAtIndex(index);
 	}
 
-	T & operator[](S index) {
+	virtual T & operator[](S index) {
 		return this->refObjectAtIndex(index);
 	}
 
-	/**
-	 * sorts the vector in ascending order
-	 *
-	 * default algorithm is merge sort
-	 */
-	int sort(VectorSort type = kVectorSortMerge) {
-		switch (type) {
-			case kVectorSortBubble:
-				return Vector::sortBubble(*this);
-			case kVectorSortInsertion:
-				return Vector::sortInsertion(*this);
-			case kVectorSortSelection:
-				return Vector::sortSelection(*this);
-			case kVectorSortQuick:
-				return Vector::sortQuick(*this);
-			case kVectorSortMerge:
-			default:
-				return Vector::sortMerge(*this);
-		}
-	}
-
 protected:
 	Vector() : Collection<S>() { }
 
-private:
-	
-	/** BUBBLE SORT - START **/
-
-	static int sortBubble(Vector & c) {
-		int n = c.size();
-		bool swapped;
-
-		for (int i = 0; i < n - 1; i++) {
-			swapped = false;
-			for (int j = 0; j < n - i - 1; j++) {
-				if (c[j] > c[j + 1]) {
-					BFSwap(c[j], c[j + 1]);
-					swapped = true;
-				}
-			}
-
-			// If no two elements were swapped, then break
-			if (!swapped)
-				break;
-		}
-		return 0;
-	}
-
-	/** BUBBLE SORT - END **/
-	/** INSERTION SORT - START **/
-
-	static int sortInsertion(Vector & c) {
-		int i, key, j;
-		int n = c.size();
-		for (i = 1; i < n; i++) {
-			key = c[i];
-			j = i - 1;
-	 
-			// Move elements of arr[0..i-1],
-			// that are greater than key, to one
-			// position ahead of their
-			// current position
-			while (j >= 0 && c[j] > key) {
-				c[j + 1] = c[j];
-				j = j - 1;
-			}
-			c[j + 1] = key;
-		}
-		return 0;
-	}
-
-	/** INSERTION SORT - END **/
-	/** SELECTION SORT - START **/
-
-	static int sortSelection(Vector & c) {
-		int i, j, min_idx;
-		int n = c.size();
-
-		// One by one move boundary of
-		// unsorted subarray
-		for (i = 0; i < n-1; i++) {
-			// Find the minimum element in
-			// unsorted array
-			min_idx = i;
-			for (j = i+1; j < n; j++)
-				if (c[j] < c[min_idx])
-					min_idx = j;
-
-			// Swap the found minimum element
-			// with the first element
-			if (c[min_idx] != c[i]) {
-				BFSwap(c[min_idx], c[i]);
-			}
-		}
-		return 0;
-	}
-
-	/** SELECTION SORT - END **/
-	/** QUICK SORT - START **/
-
-	static int sortQuick(Vector & c) {
-		return sortQuick(c, 0, c.size() - 1);
-	}
-
-	static int sortQuick(Vector & c, int low, int high) {
-		if (low < high) {
-			// pi is the partition return index of pivot
-			int pi = sortQuickPartition(c, low, high);
-
-			// Recursion calls for smaller elements
-			// and greater or equals elements
-			sortQuick(c, low, pi - 1);
-			sortQuick(c, pi + 1, high);
-		}
-
-		return 0;
-	}
-
-	static int sortQuickPartition(Vector & c, int low, int high) {
-		// Choose the pivot
-		int pivot = c[high];
-	  
-		// Index of smaller element and indicates 
-		// the right position of pivot found so far
-		int i = low - 1;
-
-		// Traverse arr[;ow..high] and move all smaller
-		// elements on left side. Elements from low to 
-		// i are smaller after every iteration
-		for (int j = low; j <= high - 1; j++) {
-			if (c[j] < pivot) {
-				i++;
-				if (c[i] != c[j]) {
-					BFSwap(c[i], c[j]);
-				}
-			}
-		}
-		
-		// Move pivot after smaller elements and
-		// return its position
-		if (c[i + 1] != c[high]) {
-			BFSwap(c[i + 1], c[high]);
-		}
-		return i + 1;
-	}
-
-	/** QUICK SORT - END **/
-	/** MERGE SORT - START **/
-
-	static int sortMerge(Vector & c) {
-		return sortMerge(c, 0, c.size() - 1);
-	}
-
-	static int sortMerge(Vector & c, S left, S right) {
-		if (left >= right)
-			return 0;
-
-		S mid = left + (right - left) / 2;
-		sortMerge(c, left, mid);
-		sortMerge(c, mid + 1, right);
-		sortMerge(c, left, mid, right);
-		return 0;
-	}
-
-	static int sortMerge(Vector & c, S left, S mid, S right) {
-		int n1 = mid - left + 1;
-		int n2 = right - mid;
-
-		// Create temp vectors
-		int L[n1], R[n2];
-
-		// Copy data to temp vectors L[] and R[]
-		for (int i = 0; i < n1; i++)
-			L[i] = c[left + i];
-		for (int j = 0; j < n2; j++)
-			R[j] = c[mid + 1 + j];
-
-		int i = 0, j = 0;
-		int k = left;
-
-		// Merge the temp vectors back
-		// into arr[left..right]
-		while (i < n1 && j < n2) {
-			if (L[i] <= R[j]) {
-				c[k] = L[i];
-				i++;
-			}
-			else {
-				c[k] = R[j];
-				j++;
-			}
-			k++;
-		}
-
-		// Copy the remaining elements of L[],
-		// if there are any
-		while (i < n1) {
-			c[k] = L[i];
-			i++;
-			k++;
-		}
-
-		// Copy the remaining elements of R[],
-		// if there are any
-		while (j < n2) {
-			c[k] = R[j];
-			j++;
-			k++;
-		}
-		return 0;
-	}
-	
-	/** MERGE SORT - END **/
 };
+
 }
 
 #endif // VECTOR_HPP
diff --git a/bflibcpp/testbench/list_tests.hpp b/bflibcpp/testbench/list_tests.hpp
index f2d8478..373e963 100644
--- a/bflibcpp/testbench/list_tests.hpp
+++ b/bflibcpp/testbench/list_tests.hpp
@@ -8,7 +8,7 @@
 
 #define ASSERT_PUBLIC_MEMBER_ACCESS
 
-#include <list.hpp>
+#include "list.hpp"
 #include "release.hpp"
 
 extern "C" {
@@ -40,8 +40,8 @@ BFTEST_UNIT_FUNC(test_indexing, 2<<10, {
 	BF_ASSERT(l->add(1.0) == 0);
 	BF_ASSERT(l->add(1.2) == 0);
 	BF_ASSERT(l->add(1.3) == 0);
-	BF_ASSERT(l->objectAtIndex(0) == 1.0);
-	BF_ASSERT(l->objectAtIndex(1) == 1.2);
+	BF_ASSERT(l->objectAtIndex(0) == 1.0, "%f != 1.0", l->objectAtIndex(0));
+	BF_ASSERT(l->objectAtIndex(1) == 1.2, "%f != 1.2", l->objectAtIndex(1));
 
 	BFRelease(l);
 })
@@ -117,9 +117,9 @@ BFTEST_UNIT_FUNC(test_listMemoryHandling, 2<<10, {
 	BF_ASSERT(!l->deleteObjectAtIndex(0));
 	BF_ASSERT(l->count() == (listsize - 1), "count: %ld\n", l->count());
 
-	int index = BFRand() % l->count();
+	int index = BFMathAbs(BFRand() % l->count());
 	int * num = l->objectAtIndex(index);
-	BF_ASSERT(num != NULL, "num is null");
+	BF_ASSERT(num != NULL, "num is null at index=%d", index);
 	BF_ASSERT(*num == index+1, "list[%d]=%d", index, *num);
 
 	l->deleteAll();
@@ -191,65 +191,6 @@ BFTEST_UNIT_FUNC(test_InitializingFromRawArray, 2<<10, {
 	}
 })
 
-BFTEST_UNIT_FUNC(test_ListNullSwap, 2<<10,  {
-	List<int>::Node a, b;
-	a.obj = 0;
-	b.obj = 1;
-	BF_ASSERT(List<int>::swap(&a, 0) != 0);
-	BF_ASSERT(List<int>::swap(0, &b) != 0);
-	BF_ASSERT(List<int>::swap(0, 0) != 0);
-})
-
-BFTEST_UNIT_FUNC(test_ListSwap, 2<<10, {
-	List<int>::Node * a = new List<int>::Node;
-	a->obj = 1;
-	List<int>::Node * al = new List<int>::Node;
-	List<int>::Node * ar = new List<int>::Node;
-	a->left = al;
-	a->right = ar;
-	al->right = a;
-	ar->left = a;
-
-	List<int>::Node * b = new List<int>::Node;
-	b->obj = 2;
-	List<int>::Node * bl = new List<int>::Node;
-	List<int>::Node * br = new List<int>::Node;
-	b->left = bl;
-	b->right = br;
-	bl->right = b;
-	br->left = b;
-
-	BF_ASSERT(a->obj == 1);
-	BF_ASSERT(a->prev() == al);
-	BF_ASSERT(a->next() == ar);
-	BF_ASSERT(al->next() == a);
-	BF_ASSERT(ar->prev() == a);
-	BF_ASSERT(b->obj == 2);
-	BF_ASSERT(b->prev() == bl);
-	BF_ASSERT(b->next() == br);
-	BF_ASSERT(bl->next() == b);
-	BF_ASSERT(br->prev() == b);
-
-	BF_ASSERT(!List<int>::swap(a, b));
-	BF_ASSERT(a->obj == 2);
-	BF_ASSERT(a->prev() == al);
-	BF_ASSERT(a->next() == ar);
-	BF_ASSERT(al->next() == a);
-	BF_ASSERT(ar->prev() == a);
-	BF_ASSERT(b->obj == 1);
-	BF_ASSERT(b->prev() == bl);
-	BF_ASSERT(b->next() == br);
-	BF_ASSERT(bl->next() == b);
-	BF_ASSERT(br->prev() == b);
-	
-	BFRelease(a);
-	BFRelease(al);
-	BFRelease(ar);
-	BFRelease(b);
-	BFRelease(bl);
-	BFRelease(br);
-})
-
 BFTEST_UNIT_FUNC(test_shuffle, 1,  {
 	const int size = 2 << 14;
 	int array[size];
@@ -414,9 +355,7 @@ BFTEST_COVERAGE_FUNC(list_tests, {
 	BFTEST_LAUNCH(test_ListContains);
 	BFTEST_LAUNCH(test_InitializingWithInitList);
 	BFTEST_LAUNCH(test_InitializingFromRawArray);
-	BFTEST_LAUNCH(test_ListSwap);
 	BFTEST_LAUNCH(test_shuffle);
-	BFTEST_LAUNCH(test_ListNullSwap);
 	BFTEST_LAUNCH(test_ShuffleLargeDataSet);
 	BFTEST_LAUNCH(test_pluckingObject);
 	BFTEST_LAUNCH(test_rangeBasedLooping);
diff --git a/bflibcpp/testbench/vector_tests.hpp b/bflibcpp/testbench/vector_tests.hpp
index 5985dad..c905e56 100644
--- a/bflibcpp/testbench/vector_tests.hpp
+++ b/bflibcpp/testbench/vector_tests.hpp
@@ -9,6 +9,8 @@
 #define ASSERT_PUBLIC_MEMBER_ACCESS
 
 #include <list.hpp>
+#include <array.hpp>
+#include <sort.hpp>
 
 extern "C" {
 #include <bflibc/bflibc.h>
@@ -17,7 +19,7 @@ extern "C" {
 using namespace BF;
 
 template <typename T>
-int run_vectorSort(VectorSort type, size_t listsize, int reps) {
+int run_vectorSortDefault(SortStrategy type, size_t listsize, int reps) {
 	int result = 0;
 	int max = reps;
 	while (!result && max--) {
@@ -33,7 +35,53 @@ int run_vectorSort(VectorSort type, size_t listsize, int reps) {
 			l.add(val);
 		}
 
-		result = l.sort(type);
+		result = sort(l);
+
+		if (!result) {
+			if (l.size() != maxsize) {
+				result = 2;
+			}
+		}
+
+		if (!result) {
+			for (size_t i = 1; i < maxsize; i++) {
+				usleep(50);
+				if (l[i - 1] > l[i]) {
+					result = 1;
+					break;
+				}
+			}
+			for (size_t i = 0; i < maxsize; i++) {
+				usleep(50);
+				if (!l.contains(b[i])) {
+					result = 3;
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+template <template <typename...> class ContainerTemplate, typename... Args>
+int run_vectorSort(SortStrategy type, size_t listsize, int reps) {
+	int result = 0;
+	int max = reps;
+	while (!result && max--) {
+		usleep(50);
+		size_t maxsize = listsize;
+		srand(time(0));
+		ContainerTemplate<Args...> l;
+		ContainerTemplate<Args...> b;
+		for (size_t i = 0; i < maxsize; i++) {
+			usleep(50);
+			int val = rand();
+			b.add(val);
+			l.add(val);
+		}
+
+		Sort<ContainerTemplate> sorter;
+		result = sorter(l, type);
 
 		if (!result) {
 			if (l.size() != maxsize) {
@@ -62,52 +110,62 @@ int run_vectorSort(VectorSort type, size_t listsize, int reps) {
 }
 
 BFTEST_UNIT_FUNC(test_vectorListSortBubble, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortBubble, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyBubble, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortInsertion, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortInsertion, 2 << 10, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyInsertion, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortSelection, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortSelection, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategySelection, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortQuick, 1,  {
-	int err = run_vectorSort<List<int>>(kVectorSortQuick, 2 << 9, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyQuick, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorListSortMerge, 1, {
-	int err = run_vectorSort<List<int>>(kVectorSortMerge, 2 << 12, 1);
+	int err = run_vectorSort<List, int>(kSortStrategyMerge, 2 << 9, 1);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortBubble, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortBubble, 2 << 12, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyBubble, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortInsertion, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortInsertion, 2 << 13, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyInsertion, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortSelection, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortSelection, 2 << 13, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategySelection, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortQuick, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortQuick, 2 << 13, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyQuick, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
 BFTEST_UNIT_FUNC(test_vectorArraySortMerge, 1,  {
-	int err = run_vectorSort<Array<int>>(kVectorSortMerge, 2 << 12, 4);
+	int err = run_vectorSort<Array, int>(kSortStrategyMerge, 2 << 9, 4);
+	BF_ASSERT(err == 0);
+})
+
+BFTEST_UNIT_FUNC(test_vectorArraySortDefault, 1,  {
+	int err = run_vectorSortDefault<Array<int>>(kSortStrategyMerge, 2 << 9, 4);
+	BF_ASSERT(err == 0);
+})
+
+BFTEST_UNIT_FUNC(test_vectorListSortDefault, 1,  {
+	int err = run_vectorSortDefault<Array<int>>(kSortStrategyMerge, 2 << 9, 4);
 	BF_ASSERT(err == 0);
 })
 
@@ -122,6 +180,9 @@ BFTEST_COVERAGE_FUNC(vector_tests, {
 	BFTEST_LAUNCH(test_vectorArraySortSelection);
 	BFTEST_LAUNCH(test_vectorArraySortQuick);
 	BFTEST_LAUNCH(test_vectorArraySortMerge);
+	BFTEST_LAUNCH(test_vectorArraySortDefault);
+	BFTEST_LAUNCH(test_vectorListSortDefault);
+
 })
 
 #endif // VECTOR_TESTS_HPP
diff --git a/bflibcpp/todo.md b/bflibcpp/todo.md
index ec8578c..9c2e4ec 100644
--- a/bflibcpp/todo.md
+++ b/bflibcpp/todo.md
@@ -1,6 +1,10 @@
 
 - [ ] BF::Array to use new/delete for memory allocation
-- [ ] improve List sorting
+- [x] improve List sorting
+	- [x] move sort logic to array and list
+	- [x] reevaluate logic location, moved to sort.hpp
+	- [x] test if BF::Sort can access elements in list and array
+	- [x] can I easily add to sort outside of Sort<T> declaration?
 - [ ] Vectors to sort strings
 - [x] String append
 - [x] fix leaks in (RBTree specifically) - replaced with map