--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/luan/modules/TableLuan.java	Fri Aug 26 14:36:40 2016 -0600
@@ -0,0 +1,120 @@
+package luan.modules;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import luan.Luan;
+import luan.LuanState;
+import luan.LuanTable;
+import luan.LuanFunction;
+import luan.LuanException;
+import luan.LuanRuntimeException;
+import luan.LuanMethod;
+import luan.LuanPropertyMeta;
+
+
+public final class TableLuan {
+
+	public static String concat(LuanState luan,LuanTable list,String sep,Integer i,Integer j) throws LuanException {
+		int first = i==null ? 1 : i;
+		int last = j==null ? list.length(luan) : j;
+		StringBuilder buf = new StringBuilder();
+		for( int k=first; k<=last; k++ ) {
+			Object val = list.get(luan,k);
+			if( val==null )
+				break;
+			if( sep!=null && k > first )
+				buf.append(sep);
+			String s = luan.toString(val);
+			buf.append(s);
+		}
+		return buf.toString();
+	}
+
+	public static void insert(LuanTable list,int pos,Object value) throws LuanException {
+		Utils.checkNotNull(list);
+		if( list.getMetatable() != null )
+			throw new LuanException("can't insert into a table with a metatable");
+		list.rawInsert(pos,value);
+	}
+
+	public static Object remove(LuanTable list,int pos) throws LuanException {
+		if( list.getMetatable() != null )
+			throw new LuanException("can't remove from a table with a metatable");
+		return list.rawRemove(pos);
+	}
+
+	private static interface LessThan {
+		public boolean isLessThan(Object o1,Object o2);
+	}
+
+	public static void sort(final LuanState luan,LuanTable list,final LuanFunction comp) throws LuanException {
+		if( list.getMetatable() != null )
+			throw new LuanException("can't sort a table with a metatable");
+		final LessThan lt;
+		if( comp==null ) {
+			lt = new LessThan() {
+				public boolean isLessThan(Object o1,Object o2) {
+					try {
+						return Luan.isLessThan(luan,o1,o2);
+					} catch(LuanException e) {
+						throw new LuanRuntimeException(e);
+					}
+				}
+			};
+		} else {
+			lt = new LessThan() {
+				public boolean isLessThan(Object o1,Object o2) {
+					try {
+						return Luan.checkBoolean(Luan.first(comp.call(luan,new Object[]{o1,o2})));
+					} catch(LuanException e) {
+						throw new LuanRuntimeException(e);
+					}
+				}
+			};
+		}
+		try {
+			list.rawSort( new Comparator<Object>() {
+				public int compare(Object o1,Object o2) {
+					return lt.isLessThan(o1,o2) ? -1 : lt.isLessThan(o2,o1) ? 1 : 0;
+				}
+			} );
+		} catch(LuanRuntimeException e) {
+			throw (LuanException)e.getCause();
+		}
+	}
+
+	public static LuanTable pack(Object... args) {
+		LuanTable tbl = new LuanTable(Arrays.asList(args));
+		tbl.rawPut( "n", args.length );
+		return tbl;
+	}
+
+	@LuanMethod public static Object[] unpack(LuanState luan,LuanTable tbl,Integer iFrom,Integer iTo) throws LuanException {
+		int from = iFrom!=null ? iFrom : 1;
+		int to = iTo!=null ? iTo : tbl.length(luan);
+		List<Object> list = new ArrayList<Object>();
+		for( int i=from; i<=to; i++ ) {
+			list.add( tbl.get(luan,i) );
+		}
+		return list.toArray();
+	}
+
+	public static LuanTable copy(LuanTable list,Integer from,Integer to) {
+		if( from == null )
+			return new LuanTable(list);
+		if( to == null )
+			to = list.rawLength();
+		return list.rawSubList(from,to);
+	}
+
+	public static LuanTable new_property_table() {
+		return LuanPropertyMeta.INSTANCE.newTable();
+	}
+
+	public static void clear(LuanTable tbl) {
+		tbl.rawClear();
+	}
+
+}