Over the last couple of weeks I’ve been building my own parser, interpreter and compiler for Small Basic, a dialect of BASIC with only 14 keywords aimed at beginners. Despite, or perhaps because of, Small Basic’s simplicity some really fun programs have been developed, from games like Tetris and 3D Maze to a parser for the language itself.
Small Basic provides primitive types for numbers, strings and associative arrays. There is no syntax provided for structures, but these can be easily modelled with the associative arrays. For example a 3D point can be constructed with named items or ordinals:
| Named items | Ordinals |
Point["X"] = 1.0
Point["Y"] = 2.0
Point["Z"] = 3.0
|
Point[0] = 1.0
Point[1] = 2.0
Point[2] = 3.0
|
In languages like Erlang and Python this could be more concisely expressed as a tuple:
| Erlang |
Python |
Point = {1.0, 2.0, 3.0}
|
point = (1.0, 2.0, 3.0)
|
In fact sophisticated Erlang programs are built entirely from tuples and lists, there is no explicit class or inheritance syntax in the language. Messages can be easily expressed with tuples and behaviour via pattern matching.
Alan Kay, inventor of the Smalltalk language has said:
The notion of object oriented programming is completely misunderstood. It's not about objects and classes, it's all about messages.
In Erlang a hierarchy of shapes can simply be modelled using tuples with atoms for names:
Circle = { circle, 5.0 }
Square = { square, 7.0 }
Rectangle = { rectangle, 10.0, 5.0 }
The area of a shape can be expressed using pattern matching:
area(Shape) ->
case Shape of
{ circle, R } -> pi() * R * R;
{ square, W } -> W * W;
{ rect, W, H } -> W * H
end.
Select Case
The Visual Basic family’s Select Case functionality is quite rich. More so than the switch/case statements of the mainstream C dialects: Java, C# and C++, which only match literals.
In Visual Basic it is already possible to match values with literals, conditions or ranges:
Select Case agerange
Case Is < 16
MsgBox("Minor")
Case 16 To 21
MsgBox("Still Young")
Case 50 To 64
MsgBox("Start Lying")
Case Is > 65
MsgBox("Be Yourself")
Case Else
MsgBox("Inbetweeners")
End Select
Given that Select Case in VB is already quite expressive, it feels support for tuples and pattern matching over them would feel quite natural in the language.
Extended Small Basic
To this end I have extended my Small Basic parser and compiler implementation with tuple and pattern matching support.
Tuples
Inspiration for construction and deconstruction was taken from F# and Python:
| F# |
Python |
let person = ("Phil", 27)
let (name, age) = person
|
person = ("Phil", 27)
name, age = person
|
So that tuples use explicit parentheses in the extended Small Basic implementation:
Person = ("Phil", 27)
(Name, Age) = Person
Internally tuples are represented using Small Basic’s built-in associative arrays.
Pattern Matching
First I implemented VB’s Select Case statements, which is not hugely dissimilar to parsing and compiling Small Basic’s If/ElseIf/Else statements.
Then I extended Select Case to support matching tuples with similar functionality to F#:
| F# |
Extended Small Basic |
let xor x y =
match (x,y) with
| (1,1) -> 0
| (1,0) -> 1
| (0,1) -> 1
| (0,0) -> 0
|
Function Xor(a,b)
Select Case (a,b)
Case (1,1)
Xor = 0
Case (1,0)
Xor = 1
Case (0,1)
Xor = 1
Case (0,0)
Xor = 0
EndSelect
EndFunction
|
Constructing, deconstructing and matching nested tuples is also supported.
Example
Putting it altogether, FizzBuzz can now be expressed in my extended Small Basic implementation with functions, tuples and pattern matching:
Function Mod(Dividend,Divisor)
Mod = Dividend
While Mod >= Divisor
Mod = Mod - Divisor
EndWhile
EndFunction
Sub Echo(s)
TextWindow.WriteLine(s)
EndSub
For A = 1 To 100 ' Iterate from 1 to 100
Select Case (Mod(A,3),Mod(A,5))
Case (0,0)
Echo("FizzBuzz")
Case (0,_)
Echo("Fizz")
Case (_,0)
Echo("Buzz")
Case Else
Echo(A)
EndSelect
EndFor
Conclusions
Extending Small Basic with first class support for tuples was relatively easy, and I feel quite natural in the language. It provides object orientated programming without the need for a verbose class syntax. I think this is something that would probably work pretty well in other BASIC dialects including Visual Basic.
Source code is available on BitBucket: https://bitbucket.org/ptrelford/smallbasiccompiler