Shorter and more consistent names (AST -> A).

git-svn-id: http://svn.drobilla.net/resp/tuplr@78 ad02d1e2-f140-0410-9f75-f8b11f17cedd

5 files changed, 116 insertions, 116 deletions

diff --git a/llvm.cpp b/llvm.cpp
index 78ab5cc..bd7ae7c 100644
--- a/llvm.cpp
+++ b/llvm.cpp
@@ -125,9 +125,9 @@ CEnv::write(std::ostream& os)
 
 #define LITERAL(CT, NAME, COMPILED) \
 template<> CValue \
-ASTLiteral<CT>::compile(CEnv& cenv) { return (COMPILED); } \
+ALiteral<CT>::compile(CEnv& cenv) { return (COMPILED); } \
 template<> void \
-ASTLiteral<CT>::constrain(TEnv& tenv) const { tenv.constrain(this, tenv.named(NAME)); }
+ALiteral<CT>::constrain(TEnv& tenv) const { tenv.constrain(this, tenv.named(NAME)); }
 
 /// Literal template instantiations
 LITERAL(int32_t, "Int",   ConstantInt::get(Type::Int32Ty, val, true))
@@ -135,7 +135,7 @@ LITERAL(float,   "Float", ConstantFP::get(Type::FloatTy, val))
 LITERAL(bool,    "Bool",  ConstantInt::get(Type::Int1Ty, val, false))
 
 static Function*
-compileFunction(CEnv& cenv, const std::string& name, const Type* retT, const ASTTuple& prot,
+compileFunction(CEnv& cenv, const std::string& name, const Type* retT, const ATuple& prot,
 		const vector<string> argNames=vector<string>())
 {
 	Function::LinkageTypes linkage = Function::ExternalLinkage;
@@ -177,20 +177,20 @@ compileFunction(CEnv& cenv, const std::string& name, const Type* retT, const AST
  ***************************************************************************/
 
 void
-ASTSymbol::lift(CEnv& cenv)
+ASymbol::lift(CEnv& cenv)
 {
 	if (!cenv.code.ref(this))
 		throw Error((string("undefined symbol `") + cppstr + "'").c_str(), loc);
 }
 
 CValue
-ASTSymbol::compile(CEnv& cenv)
+ASymbol::compile(CEnv& cenv)
 {
 	return cenv.compile(*cenv.code.ref(this));
 }
 
 void
-ASTClosure::lift(CEnv& cenv)
+AClosure::lift(CEnv& cenv)
 {
 	AType* type = cenv.tenv.type(this);
 	if (!type->concrete() || funcs.find(type))
@@ -206,7 +206,7 @@ ASTClosure::lift(CEnv& cenv)
 	vector<Value*> args;
 	const_iterator p = prot()->begin();
 	for (Function::arg_iterator a = f->arg_begin(); a != f->arg_end(); ++a, ++p)
-		cenv.vals.def(dynamic_cast<ASTSymbol*>(*p), &*a);
+		cenv.vals.def(dynamic_cast<ASymbol*>(*p), &*a);
 
 	// Write function body
 	try {
@@ -238,7 +238,7 @@ static
 AST*
 maybeLookup(CEnv& cenv, AST* ast)
 {
-	ASTSymbol* s = dynamic_cast<ASTSymbol*>(ast);
+	ASymbol* s = dynamic_cast<ASymbol*>(ast);
 	if (s) {
 		AST** val = cenv.code.ref(s);
 		if (val) return *val;
@@ -247,15 +247,15 @@ maybeLookup(CEnv& cenv, AST* ast)
 }
 
 CValue
-ASTClosure::compile(CEnv& cenv)
+AClosure::compile(CEnv& cenv)
 {
 	return funcs.find(cenv.tenv.type(this));
 }
 
 void
-ASTCall::lift(CEnv& cenv)
+ACall::lift(CEnv& cenv)
 {
-	ASTClosure* c = dynamic_cast<ASTClosure*>(maybeLookup(cenv, at(0)));
+	AClosure* c = dynamic_cast<AClosure*>(maybeLookup(cenv, at(0)));
 	
 	// Lift arguments
 	for (size_t i = 1; i < size(); ++i)
@@ -271,14 +271,14 @@ ASTCall::lift(CEnv& cenv)
 		throw Error((format("too few arguments to function `%1%'") % at(0)->str()).str(), loc);
 
 	for (size_t i = 1; i < size(); ++i)
-		cenv.code.def(checked_cast<ASTSymbol*>(c->prot()->at(i-1)), at(i));
+		cenv.code.def(checked_cast<ASymbol*>(c->prot()->at(i-1)), at(i));
 
 	c->lift(cenv); // Lift called closure
 	cenv.pop(); // Restore environment
 }
 
 CValue
-ASTCall::compile(CEnv& cenv)
+ACall::compile(CEnv& cenv)
 {
 	AST*      c = maybeLookup(cenv, at(0));
 	Function* f = dynamic_cast<Function*>(LLVal(cenv.compile(c)));
@@ -292,22 +292,22 @@ ASTCall::compile(CEnv& cenv)
 }
 
 void
-ASTDefinition::lift(CEnv& cenv)
+ADefinition::lift(CEnv& cenv)
 {
-	if (cenv.code.ref(checked_cast<ASTSymbol*>(at(1))))
+	if (cenv.code.ref(checked_cast<ASymbol*>(at(1))))
 		throw Error(string("`") + at(1)->str() + "' redefined", loc);
-	cenv.code.def((ASTSymbol*)at(1), at(2)); // Define first for recursion
+	cenv.code.def((ASymbol*)at(1), at(2)); // Define first for recursion
 	at(2)->lift(cenv);
 }
 
 CValue
-ASTDefinition::compile(CEnv& cenv)
+ADefinition::compile(CEnv& cenv)
 {
 	return cenv.compile(at(2));
 }
 
 CValue
-ASTIf::compile(CEnv& cenv)
+AIf::compile(CEnv& cenv)
 {
 	typedef vector< pair<Value*, BasicBlock*> > Branches;
 	Function*     parent  = cenv.engine.builder.GetInsertBlock()->getParent();
@@ -351,12 +351,12 @@ ASTIf::compile(CEnv& cenv)
 }
 
 CValue
-ASTPrimitive::compile(CEnv& cenv)
+APrimitive::compile(CEnv& cenv)
 {
 	Value*       a     = LLVal(cenv.compile(at(1)));
 	Value*       b     = LLVal(cenv.compile(at(2)));
 	bool         isInt = cenv.tenv.type(at(1))->str() == "Int";
-	const string n     = dynamic_cast<ASTSymbol*>(at(0))->str();
+	const string n     = dynamic_cast<ASymbol*>(at(0))->str();
 
 	// Binary arithmetic operations
 	Instruction::BinaryOps op = (Instruction::BinaryOps)0;
@@ -394,24 +394,24 @@ ASTPrimitive::compile(CEnv& cenv)
 }
 
 AType*
-ASTConsCall::functionType(CEnv& cenv)
+AConsCall::functionType(CEnv& cenv)
 {
-	ASTTuple* protTypes = new ASTTuple(loc, cenv.tenv.type(at(1)), cenv.tenv.type(at(2)), 0);
+	ATuple* protTypes = new ATuple(loc, cenv.tenv.type(at(1)), cenv.tenv.type(at(2)), 0);
 	AType* cellType = new AType(loc,
 			cenv.penv.sym("Pair"), cenv.tenv.type(at(1)), cenv.tenv.type(at(2)), 0);
 	return new AType(at(0)->loc, cenv.penv.sym("Fn"), protTypes, cellType, 0);
 }
 
 void
-ASTConsCall::lift(CEnv& cenv)
+AConsCall::lift(CEnv& cenv)
 {
 	AType* funcType = functionType(cenv);
 	if (funcs.find(functionType(cenv)))
 		return;
 	
-	ASTCall::lift(cenv);
+	ACall::lift(cenv);
 	
-	ASTTuple* prot = new ASTTuple(loc, at(1), at(2), 0);
+	ATuple* prot = new ATuple(loc, at(1), at(2), 0);
 
 	vector<const Type*> types;
 	size_t sz = 0;
@@ -451,7 +451,7 @@ ASTConsCall::lift(CEnv& cenv)
 }
 
 CValue
-ASTConsCall::compile(CEnv& cenv)
+AConsCall::compile(CEnv& cenv)
 {
 	vector<Value*> params(size() - 1);
 	for (size_t i = 1; i < size(); ++i)
@@ -462,7 +462,7 @@ ASTConsCall::compile(CEnv& cenv)
 }
 
 CValue
-ASTCarCall::compile(CEnv& cenv)
+ACarCall::compile(CEnv& cenv)
 {
 	AST*   arg  = maybeLookup(cenv, at(1));
 	Value* sP   = LLVal(cenv.compile(arg));
@@ -472,7 +472,7 @@ ASTCarCall::compile(CEnv& cenv)
 }
 
 CValue
-ASTCdrCall::compile(CEnv& cenv)
+ACdrCall::compile(CEnv& cenv)
 {
 	AST*   arg  = maybeLookup(cenv, at(1));
 	Value* sP   = LLVal(cenv.compile(arg));
@@ -528,7 +528,7 @@ eval(CEnv& cenv, const string& name, istream& is)
 		if (!ctype) throw Error("body has non-compilable type", cursor);
 
 		// Create function for top-level of program
-		Function* f = compileFunction(cenv, "main", ctype, ASTTuple());
+		Function* f = compileFunction(cenv, "main", ctype, ATuple());
 
 		// Compile all expressions into it
 		Value* val = NULL;
@@ -571,7 +571,7 @@ repl(CEnv& cenv)
 
 			if (lltype(bodyT)) {
 				// Create anonymous function to insert code into
-				Function* f = compileFunction(cenv, cenv.gensym("_repl"), lltype(bodyT), ASTTuple());
+				Function* f = compileFunction(cenv, cenv.gensym("_repl"), lltype(bodyT), ATuple());
 				try {
 					Value* retVal = LLVal(cenv.compile(body));
 					cenv.engine.builder.CreateRet(retVal); // Finish function
diff --git a/tuplr.cpp b/tuplr.cpp
index a4fd8b8..2cf2e63 100644
--- a/tuplr.cpp
+++ b/tuplr.cpp
@@ -26,7 +26,7 @@
 using namespace std;
 using boost::format;
 
-Funcs ASTConsCall::funcs;
+Funcs AConsCall::funcs;
 
 /***************************************************************************
  * Lexer                                                                   *
@@ -122,27 +122,27 @@ initLang(PEnv& penv, TEnv& tenv)
 
 	// Special forms
 	penv.reg(true, "fn",   PEnv::Handler(parseFn));
-	penv.reg(true, "if",   PEnv::Handler(parseCall<ASTIf>));
-	penv.reg(true, "def",  PEnv::Handler(parseCall<ASTDefinition>));
-	penv.reg(true, "cons", PEnv::Handler(parseCall<ASTConsCall>));
-	penv.reg(true, "car",  PEnv::Handler(parseCall<ASTCarCall>));
-	penv.reg(true, "cdr",  PEnv::Handler(parseCall<ASTCdrCall>));
+	penv.reg(true, "if",   PEnv::Handler(parseCall<AIf>));
+	penv.reg(true, "def",  PEnv::Handler(parseCall<ADefinition>));
+	penv.reg(true, "cons", PEnv::Handler(parseCall<AConsCall>));
+	penv.reg(true, "car",  PEnv::Handler(parseCall<ACarCall>));
+	penv.reg(true, "cdr",  PEnv::Handler(parseCall<ACdrCall>));
 	
 	// Numeric primitives
-	penv.reg(true, "+",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "-",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "*",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "/",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "%",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "and", PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "or",  PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "xor", PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "=",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "!=",  PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, ">",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, ">=",  PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "<",   PEnv::Handler(parseCall<ASTPrimitive>));
-	penv.reg(true, "<=",  PEnv::Handler(parseCall<ASTPrimitive>));
+	penv.reg(true, "+",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "-",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "*",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "/",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "%",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "and", PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "or",  PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "xor", PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "=",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "!=",  PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, ">",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, ">=",  PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "<",   PEnv::Handler(parseCall<APrimitive>));
+	penv.reg(true, "<=",  PEnv::Handler(parseCall<APrimitive>));
 }
 
 
diff --git a/tuplr.hpp b/tuplr.hpp
index 9a636b7..f095689 100644
--- a/tuplr.hpp
+++ b/tuplr.hpp
@@ -116,10 +116,10 @@ private:
 
 /// Literal value
 template<typename VT>
-struct ASTLiteral : public AST {
-	ASTLiteral(VT v, Cursor c) : AST(c), val(v) {}
+struct ALiteral : public AST {
+	ALiteral(VT v, Cursor c) : AST(c), val(v) {}
 	bool operator==(const AST& rhs) const {
-		const ASTLiteral<VT>* r = dynamic_cast<const ASTLiteral<VT>*>(&rhs);
+		const ALiteral<VT>* r = dynamic_cast<const ALiteral<VT>*>(&rhs);
 		return (r && (val == r->val));
 	}
 	void   constrain(TEnv& tenv) const;
@@ -128,22 +128,22 @@ struct ASTLiteral : public AST {
 };
 
 /// Symbol, e.g. "a"
-struct ASTSymbol : public AST {
+struct ASymbol : public AST {
 	bool   operator==(const AST& rhs) const { return this == &rhs; }
 	void   lift(CEnv& cenv);
 	CValue compile(CEnv& cenv);
 private:
 	friend class PEnv;
-	ASTSymbol(const string& s, Cursor c) : AST(c), cppstr(s) {}
+	ASymbol(const string& s, Cursor c) : AST(c), cppstr(s) {}
 	friend ostream& operator<<(ostream&, const AST*);
 	const string cppstr;
 };
 
 /// Tuple (heterogeneous sequence of fixed length), e.g. "(a b c)"
-struct ASTTuple : public AST, public vector<AST*> {
-	ASTTuple(const vector<AST*>& t=vector<AST*>(), Cursor c=Cursor()) : AST(c), vector<AST*>(t) {}
-	ASTTuple(size_t size, Cursor c) : AST(c), vector<AST*>(size) {}
-	ASTTuple(Cursor c, AST* ast, ...) : AST(c) {
+struct ATuple : public AST, public vector<AST*> {
+	ATuple(const vector<AST*>& t=vector<AST*>(), Cursor c=Cursor()) : AST(c), vector<AST*>(t) {}
+	ATuple(size_t size, Cursor c) : AST(c), vector<AST*>(size) {}
+	ATuple(Cursor c, AST* ast, ...) : AST(c) {
 		va_list args; va_start(args, ast);
 		push_back(ast);
 		for (AST* a = va_arg(args, AST*); a; a = va_arg(args, AST*))
@@ -151,7 +151,7 @@ struct ASTTuple : public AST, public vector<AST*> {
 		va_end(args);
 	}
 	bool operator==(const AST& rhs) const {
-		const ASTTuple* rt = dynamic_cast<const ASTTuple*>(&rhs);
+		const ATuple* rt = dynamic_cast<const ATuple*>(&rhs);
 		if (!rt || rt->size() != size()) return false;
 		const_iterator l = begin();
 		FOREACH(const_iterator, r, *rt)
@@ -175,11 +175,11 @@ struct ASTTuple : public AST, public vector<AST*> {
 };
 
 /// Type Expression, e.g. "Int", "(Fn (Int Int) Float)"
-struct AType : public ASTTuple {
-	AType(unsigned i, Cursor c=Cursor()) : ASTTuple(0, c), kind(VAR), id(i) {}
-	AType(ASTSymbol* s) : ASTTuple(0, s->loc), kind(PRIM), id(0) { push_back(s); }
-	AType(const ASTTuple& t, Cursor c) : ASTTuple(t, c), kind(EXPR), id(0) {}
-	AType(Cursor c, AST* ast, ...) : ASTTuple(0, c), kind(EXPR), id(0) {
+struct AType : public ATuple {
+	AType(unsigned i, Cursor c=Cursor()) : ATuple(0, c), kind(VAR), id(i) {}
+	AType(ASymbol* s) : ATuple(0, s->loc), kind(PRIM), id(0) { push_back(s); }
+	AType(const ATuple& t, Cursor c) : ATuple(t, c), kind(EXPR), id(0) {}
+	AType(Cursor c, AST* ast, ...) : ATuple(0, c), kind(EXPR), id(0) {
 		va_list args; va_start(args, ast);
 		push_back(ast);
 		for (AST* a = va_arg(args, AST*); a; a = va_arg(args, AST*))
@@ -210,7 +210,7 @@ struct AType : public ASTTuple {
 			switch (kind) {
 			case VAR:  return id == rt->id;
 			case PRIM: return at(0)->str() == rt->at(0)->str();
-			case EXPR: return ASTTuple::operator==(rhs);
+			case EXPR: return ATuple::operator==(rhs);
 			}
 		return false; // never reached
 	}
@@ -229,52 +229,52 @@ struct Funcs : public list< pair<AType*, CFunction> > {
 };
 
 /// Closure (first-class function with captured lexical bindings)
-struct ASTClosure : public ASTTuple {
-	ASTClosure(Cursor c, ASTSymbol* fn, ASTTuple* p, AST* b, const string& n="")
-		: ASTTuple(c, fn, p, b, NULL), name(n) {}
+struct AClosure : public ATuple {
+	AClosure(Cursor c, ASymbol* fn, ATuple* p, AST* b, const string& n="")
+		: ATuple(c, fn, p, b, NULL), name(n) {}
 	bool      operator==(const AST& rhs) const { return this == &rhs; }
 	void      constrain(TEnv& tenv) const;
 	void      lift(CEnv& cenv);
 	CValue    compile(CEnv& cenv);
-	ASTTuple* prot() const { return dynamic_cast<ASTTuple*>(at(1)); }
+	ATuple* prot() const { return dynamic_cast<ATuple*>(at(1)); }
 private:
 	Funcs  funcs;
 	string name;
 };
 
 /// Function call/application, e.g. "(func arg1 arg2)"
-struct ASTCall : public ASTTuple {
-	ASTCall(const SExp& e, const ASTTuple& t) : ASTTuple(t, e.loc) {}
+struct ACall : public ATuple {
+	ACall(const SExp& e, const ATuple& t) : ATuple(t, e.loc) {}
 	void   constrain(TEnv& tenv) const;
 	void   lift(CEnv& cenv);
 	CValue compile(CEnv& cenv);
 };
 
 /// Definition special form, e.g. "(def x 2)"
-struct ASTDefinition : public ASTCall {
-	ASTDefinition(const SExp& e, const ASTTuple& t) : ASTCall(e, t) {}
+struct ADefinition : public ACall {
+	ADefinition(const SExp& e, const ATuple& t) : ACall(e, t) {}
 	void   constrain(TEnv& tenv) const;
 	void   lift(CEnv& cenv);
 	CValue compile(CEnv& cenv);
 };
 
 /// Conditional special form, e.g. "(if cond thenexp elseexp)"
-struct ASTIf : public ASTCall {
-	ASTIf(const SExp& e, const ASTTuple& t) : ASTCall(e, t) {}
+struct AIf : public ACall {
+	AIf(const SExp& e, const ATuple& t) : ACall(e, t) {}
 	void   constrain(TEnv& tenv) const;
 	CValue compile(CEnv& cenv);
 };
 
 /// Primitive (builtin arithmetic function), e.g. "(+ 2 3)"
-struct ASTPrimitive : public ASTCall {
-	ASTPrimitive(const SExp& e, const ASTTuple& t) : ASTCall(e, t) {}
+struct APrimitive : public ACall {
+	APrimitive(const SExp& e, const ATuple& t) : ACall(e, t) {}
 	void   constrain(TEnv& tenv) const;
 	CValue compile(CEnv& cenv);
 };
 
 /// Cons special form, e.g. "(cons 1 2)"
-struct ASTConsCall : public ASTCall {
-	ASTConsCall(const SExp& e, const ASTTuple& t) : ASTCall(e, t) {}
+struct AConsCall : public ACall {
+	AConsCall(const SExp& e, const ATuple& t) : ACall(e, t) {}
 	AType* functionType(CEnv& cenv);
 	void   constrain(TEnv& tenv) const;
 	void   lift(CEnv& cenv);
@@ -283,15 +283,15 @@ struct ASTConsCall : public ASTCall {
 };
 
 /// Car special form, e.g. "(car p)"
-struct ASTCarCall : public ASTCall {
-	ASTCarCall(const SExp& e, const ASTTuple& t) : ASTCall(e, t) {}
+struct ACarCall : public ACall {
+	ACarCall(const SExp& e, const ATuple& t) : ACall(e, t) {}
 	void   constrain(TEnv& tenv) const;
 	CValue compile(CEnv& cenv);
 };
 
 /// Cdr special form, e.g. "(cdr p)"
-struct ASTCdrCall : public ASTCall {
-	ASTCdrCall(const SExp& e, const ASTTuple& t) : ASTCall(e, t) {}
+struct ACdrCall : public ACall {
+	ACdrCall(const SExp& e, const ATuple& t) : ACall(e, t) {}
 	void   constrain(TEnv& tenv) const;
 	CValue compile(CEnv& cenv);
 };
@@ -302,7 +302,7 @@ struct ASTCdrCall : public ASTCall {
  ***************************************************************************/
 
 /// Parse Time Environment (symbol table)
-struct PEnv : private map<const string, ASTSymbol*> {
+struct PEnv : private map<const string, ASymbol*> {
 	typedef AST* (*PF)(PEnv&, const SExp&, void*); // Parse Function
 	struct Handler { Handler(PF f, void* a=0) : func(f), arg(a) {} PF func; void* arg; };
 	map<const string, Handler> aHandlers; ///< Atom parse functions
@@ -315,22 +315,22 @@ struct PEnv : private map<const string, ASTSymbol*> {
 		map<string, Handler>::const_iterator i = handlers.find(s);
 		return (i != handlers.end()) ? &i->second : NULL;
 	}
-	ASTSymbol* sym(const string& s, Cursor c=Cursor()) {
+	ASymbol* sym(const string& s, Cursor c=Cursor()) {
 		const const_iterator i = find(s);
 		return ((i != end())
 			? i->second
-			: insert(make_pair(s, new ASTSymbol(s, c))).first->second);
+			: insert(make_pair(s, new ASymbol(s, c))).first->second);
 	}
 };
 
 /// The fundamental parser method
 static AST* parseExpression(PEnv& penv, const SExp& exp);
 
-static ASTTuple
+static ATuple
 pmap(PEnv& penv, const SExp& e)
 {
 	assert(e.type == SExp::LIST);
-	ASTTuple ret(e.list.size(), e.loc);
+	ATuple ret(e.list.size(), e.loc);
 	size_t n = 0;
 	FOREACH(SExp::List::const_iterator, i, e.list)
 		ret[n++] = parseExpression(penv, *i);
@@ -347,12 +347,12 @@ parseExpression(PEnv& penv, const SExp& exp)
 			if (handler) // Dispatch to list parse function
 				return handler->func(penv, exp, handler->arg);
 		}
-		return new ASTCall(exp, pmap(penv, exp)); // Parse as regular call
+		return new ACall(exp, pmap(penv, exp)); // Parse as regular call
 	} else if (isdigit(exp.atom[0])) {
 		if (exp.atom.find('.') == string::npos)
-			return new ASTLiteral<int32_t>(strtol(exp.atom.c_str(), NULL, 10), exp.loc);
+			return new ALiteral<int32_t>(strtol(exp.atom.c_str(), NULL, 10), exp.loc);
 		else
-			return new ASTLiteral<float>(strtod(exp.atom.c_str(), NULL), exp.loc);
+			return new ALiteral<float>(strtod(exp.atom.c_str(), NULL), exp.loc);
 	} else {
 		const PEnv::Handler* handler = penv.handler(false, exp.atom);
 		if (handler) // Dispatch to atom parse function
@@ -372,15 +372,15 @@ template<typename T>
 inline AST*
 parseLiteral(PEnv& penv, const SExp& exp, void* arg)
 {
-	return new ASTLiteral<T>(*reinterpret_cast<T*>(arg), exp.loc);
+	return new ALiteral<T>(*reinterpret_cast<T*>(arg), exp.loc);
 }
 
 inline AST*
 parseFn(PEnv& penv, const SExp& exp, void* arg)
 {
 	SExp::List::const_iterator a = exp.list.begin(); ++a;
-	return new ASTClosure(exp.loc, penv.sym("fn"),
-			new ASTTuple(pmap(penv, *a++)),
+	return new AClosure(exp.loc, penv.sym("fn"),
+			new ATuple(pmap(penv, *a++)),
 			parseExpression(penv, *a++));
 }
 
@@ -460,7 +460,7 @@ struct CEnv {
 	CEnv(PEnv& p, TEnv& t, CEngine& e, ostream& os=std::cout, ostream& es=std::cerr);
 	~CEnv();
 	
-	typedef Env<const ASTSymbol*, AST*>   Code;
+	typedef Env<const ASymbol*, AST*>   Code;
 	typedef Env<const AST*, CValue> Vals;
 	
 	string gensym(const char* s="_") { return (format("%s%d") % s % symID++).str(); }
diff --git a/typing.cpp b/typing.cpp
index 759a418..161a959 100644
--- a/typing.cpp
+++ b/typing.cpp
@@ -22,9 +22,9 @@
  ***************************************************************************/
 
 void
-ASTTuple::constrain(TEnv& tenv) const
+ATuple::constrain(TEnv& tenv) const
 {
-	AType* t = new AType(ASTTuple(), loc);
+	AType* t = new AType(ATuple(), loc);
 	FOREACH(const_iterator, p, *this) {
 		(*p)->constrain(tenv);
 		t->push_back(tenv.type(*p));
@@ -33,7 +33,7 @@ ASTTuple::constrain(TEnv& tenv) const
 }
 
 void
-ASTClosure::constrain(TEnv& tenv) const
+AClosure::constrain(TEnv& tenv) const
 {
 	at(1)->constrain(tenv);
 	at(2)->constrain(tenv);
@@ -43,22 +43,22 @@ ASTClosure::constrain(TEnv& tenv) const
 }
 
 void
-ASTCall::constrain(TEnv& tenv) const
+ACall::constrain(TEnv& tenv) const
 {
 	FOREACH(const_iterator, p, *this)
 		(*p)->constrain(tenv);
 	AType* retT = tenv.type(this);
-	AType* argsT = new AType(ASTTuple(), loc);
+	AType* argsT = new AType(ATuple(), loc);
 	for (size_t i = 1; i < size(); ++i)
 		argsT->push_back(tenv.type(at(i)));
 	tenv.constrain(at(0), new AType(at(0)->loc, tenv.penv.sym("Fn"), argsT, retT, 0));
 }
 
 void
-ASTDefinition::constrain(TEnv& tenv) const
+ADefinition::constrain(TEnv& tenv) const
 {
 	if (size() != 3) throw Error("`def' requires exactly 2 arguments", loc);
-	if (!dynamic_cast<const ASTSymbol*>(at(1)))
+	if (!dynamic_cast<const ASymbol*>(at(1)))
 		throw Error("`def' name is not a symbol", loc);
 	FOREACH(const_iterator, p, *this)
 		(*p)->constrain(tenv);
@@ -68,7 +68,7 @@ ASTDefinition::constrain(TEnv& tenv) const
 }
 
 void
-ASTIf::constrain(TEnv& tenv) const
+AIf::constrain(TEnv& tenv) const
 {
 	if (size() < 3)      throw Error("`if' requires exactly 3 arguments", loc);
 	if (size() % 2 != 0) throw Error("`if' missing final else clause", loc);
@@ -86,9 +86,9 @@ ASTIf::constrain(TEnv& tenv) const
 }
 
 void
-ASTPrimitive::constrain(TEnv& tenv) const
+APrimitive::constrain(TEnv& tenv) const
 {
-	const string n = dynamic_cast<ASTSymbol*>(at(0))->str();
+	const string n = dynamic_cast<ASymbol*>(at(0))->str();
 	enum { ARITHMETIC, BINARY, BITWISE, COMPARISON } type;
 	if (n == "+" || n == "-" || n == "*" || n == "/")
 		type = ARITHMETIC;
@@ -136,7 +136,7 @@ ASTPrimitive::constrain(TEnv& tenv) const
 }
 
 void
-ASTConsCall::constrain(TEnv& tenv) const
+AConsCall::constrain(TEnv& tenv) const
 {
 	if (size() != 3) throw Error("`cons' requires exactly 2 arguments", loc);
 	AType* t = new AType(loc, tenv.penv.sym("Pair"), 0);
@@ -148,7 +148,7 @@ ASTConsCall::constrain(TEnv& tenv) const
 }
 
 void
-ASTCarCall::constrain(TEnv& tenv) const
+ACarCall::constrain(TEnv& tenv) const
 {
 	if (size() != 2) throw Error("`car' requires exactly 1 argument", loc);
 	at(1)->constrain(tenv);
@@ -159,7 +159,7 @@ ASTCarCall::constrain(TEnv& tenv) const
 }
 
 void
-ASTCdrCall::constrain(TEnv& tenv) const
+ACdrCall::constrain(TEnv& tenv) const
 {
 	if (size() != 2) throw Error("`cdr' requires exactly 1 argument", loc);
 	at(1)->constrain(tenv);
@@ -175,14 +175,14 @@ ASTCdrCall::constrain(TEnv& tenv) const
  ***************************************************************************/
 
 static void
-substitute(ASTTuple* tup, AST* from, AST* to)
+substitute(ATuple* tup, AST* from, AST* to)
 {
 	if (!tup) return;
 	for (size_t i = 0; i < tup->size(); ++i)
 		if (*tup->at(i) == *from)
 			tup->at(i) = to;
 		else
-			substitute(dynamic_cast<ASTTuple*>(tup->at(i)), from, to);
+			substitute(dynamic_cast<ATuple*>(tup->at(i)), from, to);
 }
 
 TSubst
diff --git a/write.cpp b/write.cpp
index 7cad2c5..248e1e1 100644
--- a/write.cpp
+++ b/write.cpp
@@ -20,19 +20,19 @@
 ostream&
 operator<<(ostream& out, const AST* ast)
 {
-	const ASTLiteral<float>* flit = dynamic_cast<const ASTLiteral<float>*>(ast);
+	const ALiteral<float>* flit = dynamic_cast<const ALiteral<float>*>(ast);
 	if (flit)
 		return out << showpoint << flit->val;
 	
-	const ASTLiteral<int32_t>* ilit = dynamic_cast<const ASTLiteral<int32_t>*>(ast);
+	const ALiteral<int32_t>* ilit = dynamic_cast<const ALiteral<int32_t>*>(ast);
 	if (ilit)
 		return out << ilit->val;
 	
-	const ASTLiteral<bool>* blit = dynamic_cast<const ASTLiteral<bool>*>(ast);
+	const ALiteral<bool>* blit = dynamic_cast<const ALiteral<bool>*>(ast);
 	if (blit)
 		return out << (blit->val ? "#t" : "#f");
 
-	const ASTSymbol* sym = dynamic_cast<const ASTSymbol*>(ast);
+	const ASymbol* sym = dynamic_cast<const ASymbol*>(ast);
 	if (sym)
 		return out << sym->cppstr;
 	
@@ -45,7 +45,7 @@ operator<<(ostream& out, const AST* ast)
 		}
 	 }
 	
-	const ASTTuple* tup = dynamic_cast<const ASTTuple*>(ast);
+	const ATuple* tup = dynamic_cast<const ATuple*>(ast);
 	if (tup) {
 		out << "(";
 		for (size_t i = 0; i != tup->size(); ++i)