stz killing receiverless

For many days now we've been embracing the syntax: { type | calls... } to create something on the stack. At compile time the type is computed and that tells the compiler how to construct the stack frame. But do we need it? What is a variable? when it's

stz scoping variables and things

We can scope methods easily enough: public [ a-public-method | -> ø ] package [ a-package-method | -> ø ] private [ a-private-method | -> ø ] But when we want to create a class or a trait we suddenly lose that granularity at the variables and constants level. It is an array after all. But

stz strings

Strings are a powerful beast. They can come in many different forms and encodings. Some have character escaping and others have interpolation. In a previous blog post we realised we needed more than just plain characters for our strings. The first rule of thumb to make is all compilation strings

stz constants:

When we send constants: to a class or a trait we're not just recording that there is one but we also want to generate a method for accessing that value easily later. The simple example: iterable-t = { trait | constants: ( element-class: class, ) } We want that to produce a method like

stz the compiler

It's time to talk about the compiler. The compiler has to provide a minimum level of capability so that the rest of the code can construct itself. Without the compiler there is no point to Smalltalk Zero. (Part of me does wonder if stz can eventually elevate itself

stz requires

Currently traits have a property called requires: which is an array of method signatures. We need a way to specify more than just implementations that must exist for a class to be part of a trait group. Let's segway a moment and figure out what a class even

stz unbound variables

Breaking down the class definition we have a problem: list = { class | parameters: (of: object-t,), constants: (element-class: of,), traits: (sequenceable-t of: element-class,), variables: ( elements: &array of: element-class, length: uint, allocator: &memory-allocator,) } The constants section references a variable that doesn't exist. The traits section references a variable that

stz getters and setters

Just as an side back to the getters and setters of Person's name. My intention is that declaring the class auto-creates the getter and setter for you. Person = ( name: string, age: (quantity of: seconds) ) However, how do you specify which variables you want to be public and which

stz from stack to heap

One of the hallmarks of Smalltalk code is sending 'new' to a class. This creates you a new object that you can then configure with message sends, eg: Person new name: 'Jane'; height: 5 foot + 6 inches; yourself If we were to use this approach for

stz syntax highlighting

For my own sanity, now that the examples are getting more complicated, I really needed some syntax highlighting support for the language. I need it in two places - here in ghost, the blogging software I use, and in zed.dev the editor i'm using. This was a

stz parser ambiguity

Since I'm trying to write example code I have found it annoying that I don't have syntax highlighting. My editor of choice these days is zed which uses tree-sitter as its parser. I suppose I could take everything we know and try to make a parser

stz parameter specialisation

One of the cool features of the maybe pattern is how some values have a 'not instantiated' state by default - such as pointers. A memory-address of 0 can mean 'there is no pointer' while any other value means there is a pointer. The default maybe