BFlat. Classes. A list of features: - Classes. - Static Types and Type Checking. - Static Scoping. - Metaclasses

Transcription

1 BFlat This document serves to examine the CS345 project of Justin Lazarow and Adam Menz that continues the evolution of the BFlat language started in years previous. Although we started with BFlat in mind, it got clear that to reach the goals we wanted, a large rewrite would be needed. Thus, we share very little in common (with exception of name) with the past BFlat. However, with almost 3000 lines of code, we feel we have done a few iterations of the project in a single try. BFlat attempts to create a complete and pure enviroment with a primary emphasis on being dynamic. This makes things extremely powerful for the end-user. A list of features: - Classes - Static Types and Type Checking - Static Scoping - Metaclasses - Built-in Types: String, Boolean, Int, Float, List, Lambda - Dynamic SQL Selects (Requires MySQL) - Feature Filled Runtime - Dynamic Classes (and Methods and Ivars) - Object purity - Standard Library Functions - Lambda Functions and Closures We now go through the features starting with a sample file. Classes BFlat classes are quite similar to Java classes, with two exceptions. They do not support inheritance nor accessor attributes (e.g. private) however, they do have metaclass support (although this has hardly been tested). A sample BFlat file is given:

2 void main() MyClass inst = MyClass.new(3) class MyClass <OptionalMetaclass> int ivar1 String ivar2 // The constructor void init(int arg1) ivar1 = arg1; // This becomes: // ivar2 = String.new("hi") ivar2 = "hi "; void printself() String together = self.ivar2.concat(ivar1.str()) print(together) int getivar1() return self.ivar1; We see here many things. The main method is always required and is the entry point of any BFlat program. Semicolons are only used (and allowed) after return statements. Angled brackets are used to define what the class s metaclass is. A metaclass, put simply, is the class of classes. In BFlat, every class has a class itself. The base class, Object, is its own metaclass. Whenever a class is declared in a BFlat file, the interpreter creates an instance of the corresponding metaclass. The idea here is that there is no concept of static like there is in Java.

3 MyClass.someMethod() would invoke the somemethod method of the metaclass of MyClass. This shows a bit of the pureness in philosophy of BFlat. We also see that constructors are void in BFlat (really the return type is ignored to prevent user error). In the main method, we see the invocation of new on MyClass. This is a reserved method that is similar to new in Java. However, we feel that new should truly be thought of as a method on the class and not some special language construct like in Java. The reference self is the equivalent of Java s this. We mentioned earlier the concept of object purity. Although we clearly see in the previous class the use of literals in the code, literals do not truly exist in BFlat. The parser will find such literals and rewrite them as calls to new on the appropriate class. The comment shows this in code form. print() is a standard library function that prints out a string. It will not coerce its arguments to strings itself, which is why we see the use of built in methods like str() that do the coercing themselves. Runtime This is probably the crown-jewel of BFlat. The Runtime methods are Java methods that are the core of running a BFlat program. The parser and interpreters instruct the Runtime to add certain classes, methods, or instance variables to the program state. It allows us to bootstrap in the built in types like String and Int and gives the user the flexibility to do almost anything that is possible in the Java part of BFlat. The best part is that this is done dynamically. At bootstrap time (located in Bootstrap.java), a mapping is created from BFlat built in types to Java built in types. In addition, most of the runtime methods are then exported into the global scope of BFlat. Thus, when calling these runtime methods from BFlat, the BFlat objects are automatically bridged (by Bridger.java) to the correct Java counterparts and then the method is invoked, and the return type bridged back to a BFlat instance. A list of exported runtime methods is available in BFlatLibrary.java A great example of this is the DynamicCreation.bf file. void main() Class newclass = bflat_allocateclasspair("mynewclass", null) bflat_registerclasspair(newclass) List paramlist = List.new() Class intclass = bflat_getclassfromname("integer") BFlatIvar newivar = BFlatIvar.new("base", intclass)

4 newclass.addivar(newivar) paramlist.add(intclass) List cparamnames = List.new() cparamnames.add("base") Class voidclass = bflat_getclassfromname("void") BFlatMethod constructor = BFlatMethod.new("init", paramlist, cparamnames, voidclass) BFlatMethod cimpl = bflat_getmethod("myconstructor") constructor.setmethodimpl(cimpl) newclass.addmethod(constructor) Class dreturntype = intclass List dparamnames = List.new() dparamnames.add("myint") BFlatMethod newmethod = BFlatMethod.new("dynamicsum", paramlist, dparamnames, dreturntype) BFlatMethod dimpl = bflat_getmethod("dynamicsum") newmethod.setmethodimpl(dimpl) newclass.addmethod(newmethod) MyNewClass inst = MyNewClass.new(2) print(inst.dynamicsum(3).str()) void myconstructor(int base) self.base = base int dynamicsum(int myint) return self.base.add(myint); The amazing part of this code, is that Class is an actual Java class. None of it is implemented in BFlat. The same with BFlatMethod and BFlatIvar. They are all Java classes that are seamlessly bridged to create the correct Java instances and then brought back into the BFlat program. In the program, we call the runtime method bflat allocateclasspair and tell it we would like to have a new class available called MyNewClass. The second argument is unimportant and should always be null (null is also an object in BFlat, a static instance of Null). We then tell the BFlat runtime we are done with modifying the class (the reason for a two step

5 creation process is that normally between allocate and register, the metaclass would be set). As the code goes on, we are new methods to our class part by part. First, we add the constructor to the class. The runtime allows us to get the Runtime representation of any method by using bflat getmethod(). Here, we are getting the representation of myconstructor, which is a true BFlatMethod. From here, we could actually introspect myconstructor for what arguments it takes and what types it returns. We tell BFlat to call myconstructor as the init method of MyNewClass. We then do the same thing with dynamicsum. Then the big part. We create an instance of MyNewClass with the constructor arguments. A name/class that didn t exist at the beginning of the program! Thus, we see that we can modify our programs at runtime! Dynamic SQL This is then leveraged in the dynamic SQL proof of concept in BFlat. void main() Connection conn = CONNECT bflat root TO url:// List rows = SELECT id, name FROM conn.testtable print(rows.str()) testtable row = rows.get(0) print(row.id.str()) print(row.name) We do a normal connect and select query on a SQL database. Although this wouldn t be too hard to change, we elected to use MySQL as the only supported database. Notice that we have selected from a table called testtable. testtable is being used as a class though after! This is actually done behind the scenes. Simple tables (for now) have a dynamic class created with their name and columns as instance variables on SELECT. Thus, we are actually using a list of rows in the table as a list of instances of dynamic BFlat classes. This is pretty powerful as it smooths the gap between the object oriented mindset of a programmer, and the relational side of a database. A good project would be to extend this to complex queries like joins, etc and perhaps to end up creating a class for the Database as well. Then one might be able to delete rows by sending instances of classes and having this translated into a SQL query.

6 Lambda Functions The last major part of BFlat is Lambda functions. Lambda class, but are invoked as if you would invoke a function. Such functions are instances of the builtin void main() int b = 3 Lambda identity = lambda int a: return b.add(a); tryscope(identity) void tryscope(lambda l) int res = l(4) print(res.str()) return; Lambda functions in BFlat are one liners akin to how Python does it. The lambda prefix denotes the definition. When a lambda function is defined, it first captures the lexical scope it was defined in. When it is executed, as we see in tryscope, it will also capture the scope it was called in. Thus, b will be defined because it was in the lexical definition scope. And so we will get 7 as a result of the closures in BFlat. Closing Remarks There is still more to BFlat than just this. BFlat (we feel) can be a new foundation for others to started building great things. Thanks.