prelude

// The part of the standard library implemented in TranScript.

def loop(f, args*)
	def next(args*)
		return f.apply([next] + args);
	end;
	return next.apply(args);
end;

def identity(x) = x;

def writeString(dst, s)
	dst.writeBuffer(s.toBuffer());
end;

def invert(f) = fn(args*)
	return !f.apply(args);
end;

def repeat(f)
	if f() != done then
		return repeat(f);
	end;
end;

// Iteration
// =========
//
// An iterable supports one method: __iter__() that returns an iterator.
//
// An iterator supports two methods: __iter__() that returns itself and next()
// that moves the iterator onwards, returning the next item, or done if there
// are no more items.

// Coerce a value to an iterator.
def iter(x)
	if @__iter__.on(x) then
		return x.__iter__();
	end;
	if x.is(Number) then
		return iter(range(x));
	end;
	return FnIterator(x);
end;

// Call a function for every item in an iterable. That function may return done,
// so halting iteration.
def for(it, f)
	it = iter(it);
	return loop(fn(step)
		def x = it.next();
		if x != done then
			if f(x) != done then
				return step();
			end;
		end;
	end);
end;

// Turn a function into an iterator.
class FnIterator(Iterator)
	def create(f)
		this.f = f;
	end;
	def next() = this.f();
	def copy() = this;
private
	def f;
end;

// Create an iterator composed of the return values of applying a function to
// each item in a source iterable.
def imap(it, f)
	it = iter(it);
	return iter(fn()
		def x = it.next();
		if x != done then
			return f(x);
		end;
		return done;
	end);
end;

def reduce(it, acc, f)
	for(it, fn(x)
		acc = f(x, acc);
	end);
	return acc;
end;

// Create an iterator composed of all the items in an iterable that pass a
// criterion function.
def ifilter(it, f)
	it = iter(it);
	def check()
		def x = it.next();
		if x == done then
			return done;
		end;
		if f(x) then
			return x;
		end;
		return check();
	end;
	return iter(check);
end;

def none(it, f?)
	f = f || fn(x) = x;
	def fit = ifilter(it, f);
	return fit.next() == done;
end;

def any = invert(none);

def all(it, f?)
	f = f || fn(x) = x;
	return none(it, invert(f));
end;

// Create an iterator composed of a series of iterables. When one iterator
// signals it is at an end by returning done, the next iterable is used. When no
// more iterables remain, append returns done.
def iappend(it, rest*)
	it = iter(it);
	def next()
		def x = it.next();
		if x == done then
			if rest.size == 0 then
				return done;
			end;
			it = rest[0].__iter__();
			rest = rest.slice(1);
			return next();
		end;
		return x;
	end;
	return iter(next);
end;

def izip(its*)
	its = map(its, iter);
	return iter(fn()
		def cur = map(its, @next.call);
		if cur.size != its.size then
			return done;
		end;
		if any(cur, fn(x) = x == done) then
			return done;
		end;
		return cur;
	end);
end;

// Turn an iterator into an array.
def slurp(it)
	def res = [];
	for(it, fn(x) = res.add(x));
	return res;
end;

class NotEnoughItems(Error)
	def create()
		super.create("not enough items");
	end;
end;

// Put the first n items of an iterator into an array. Throws an error if there
// aren't enough items.
def take(n, it)
	it = it.__iter__();
	def res = [];
	for(range(n), fn(x)
		def cur = it.next();
		if cur == done then
			throw(NotEnoughItems());
		end;
		res.add(cur);
	end);
	return res;
end;

// Run take() over an iterator.
def isegment(n, it)
	it = it.__iter__();
	return FnIterator(fn()
		def res;
		def e = catch(fn() 
			res = take(n, it);
		end);
		if e.is(NotEnoughItems) then
			return done;
		end;
		if e then
			throw(e);
		end;
		return res;
	end);
end;

def map(it, f) = slurp(imap(it, f));
def filter(it, f) = slurp(ifilter(it, f));
def append(its*) = slurp(iappend.apply(its));
def zip(its*) = slurp(izip.apply(its));

// Find the first item in an iterable that passes a criterion function, or false
// if no items match.
def find(it, f)
	def res = ifilter(it, f).next();
	if res == done then
		return false;
	end;
	return res;
end;

// Represent a range of numbers as if it were an array.
class range()
	def create(from, to?)
		this.from = (to && from) || 0;
		this.to = to || from;
	end;
	def size get() = this.to - this.from;
	def __aget__(off)
		if off > this.size then
			throw(Error("index out of range"));
		end;
		return this.from + off;
	end;
	def __iter__()
		def cur = this.from, to = this.to;
		return iter(fn()
			if cur < to then
				cur = cur + 1;
				return cur - 1;
			end;
			return done;
		end);
	end;
private
	def from, to;
end;

// Printf-like function.
def printf(pat, xs*)
	print(pat.subst.apply(xs));
end;

// Schedule some code to run whether an error happened or not.
def finally(thk, clearup)
	def e = catch(thk);
	def f = catch(clearup);
	if e then
		throw(e);
	end;
	if f then
		throw(f);
	end;
end;

// Register a function to be called if an error is raised during the execution
// of a thunk.
def split(thk, h)
	def res;
	def e = catch(fn()
		res = thk();
	end);
	if e then
		return h(e);
	end;
	return res;
end;

def switchType(x, cs*)
	def f(x) = false;
	for(cs, fn(c)
		if x.is(c.left) then
			f = c.right;
			return done;
		end;
	end);
	return f();
end;

// Call a function with the ability to perform non-local escape.
//
// Calls f, and whatever it returns is returned by callWithCont(). f takes a
// single argument, an escape.
//
// The escape is a function that takes a single argument. When called, it causes
// callWithCont() to return the value of that argument immediately, skipping out
// anything that the function might do in that call.
//
// When control leaves the dynamic extent of the call to callWithEscape, however
// this might occur unwind, if provided, will be called without any arguments.
// Thus callWithEscape can be used to power context managers as well as 
// non-local escape.
//
// This is somewhat like call/cc combined with dynamic-wind in Scheme. However, 
// unlike Scheme's continuations, escapes are not valid after callWithEscape()
// returns.
def callWithEscape(f, unwind?)
	def key = Object(),
	    followed = false,
	    res;
	def e = catch(fn()
		res = f(fn(x)
			if followed then
				throw("stale escape");
			end;
			throw(key:x);
		end);
	end);
	followed = true;
	unwind && unwind();
	// normal return
	if !e then
		return res;
	end;
	// followed escape
	if e.is(Pair) && e.left == key then
		return e.right;
	end;
	// error/other escape
	throw(e);
end;

class Package()
end;

def packages = class()
	def packagePaths = ["/usr/local/go/src/pkg/github.com/bobappleyard/ts/pkg"];
	def create()
		def system = loadExtension("system");
		if system.env.contains("TSROOT") then
			def root = system.env["TSROOT"];
			this.packagePaths = [root.trimRight("/") + "/pkg"];
		end;
	end;
	def __aget__(nm)
		if this.pkgs.contains(nm) then
			return this.pkgs[nm];
		end;
		def p = false;
		def nmpath = nm.replace(".", "/") + ".pkg";
		for(this.packagePaths, fn(path)
			path = path + "/" + nmpath;
			def e = catch(fn() = load(path));
			if e then
				print(e);
				return;
			end;
			if this.pkgs.contains(nm) then
				p = this.pkgs[nm];
				return done;
			end;
		end);
		if !p then
			throw("undefined package: " + nm);
		end;
		return p;
	end;
	def __aset__(nm, p)
		this.pkgs[nm] = p;
	end;
	def __register__(nm, ctx, pkg)
		for(this.packagePaths, fn(path)
			if ctx.startsWith(path) then
				def l = (nm + ".pkg").size;
				def b = ctx.split().slice(path.size, ctx.size - l).join();
				b = b.trim("/").replace("/", ".");
				if b != "" then
					b = b + ".";
				end;
				this.pkgs[b + nm] = pkg;
			end;
		end);
	end;
private
	def pkgs = {};
end();

def record = fn()
	def cache = {};
	
	def template = "fn()"                    +
	               "	class Record()"      +
	               "		def %;"          +
	               "		def create(%)"   +
	               "			%;"          +
	               "		end;"            +
	               "	end;"                +
	               "	return Record;"      +
	               "end();";
	
	return fn(slots*)
		slots = map(slots, @name.get);
		
		def sl = slots.join(", ");
		
		if cache.contains(sl) then
			return cache[sl];
		end;
		
		def init = map(slots, fn(x)
			return "this.% = %".subst(x, x);
		end).join(";");
		
		def expr = template.subst(sl, sl, init);
		def res = eval(expr);
		cache[sl] = res;
		
		return res;
	end;
	
end();

class Key(Sequence)
	def create(items*)
		this.items = items;
	end;
	
	def __key__() = this.items.join(1.toChar());

	def size get() = this.items.size;
	def __aget__(ix) = this.items[ix];
	def __aset__(ix, v) this.items[ix] = v; end;
	
	def toString() = "#<Key " + map(this.items, fn(item)
		if item.is(String) then
			return item.quote();
		end;
		return item;
	end).join(", ") + ">";
private
	def items;
end;