stz

break

[self my-method: arg] [:MyClass, :Integer -> ø | [ -> break | arg = 1 then: [self do-thing-one; break]; arg = 2 then: [self do-thing-two; break]; arg = 3 then: [self do-thing-three-fall-through]; arg ≤ 4 then: [self do-thing-four; break]; self do-thing-default; ] self do-other-stuff] This falls out of the current syntax nicely. You can even assign

stz

another pass at blocks

I know I've painted this bike shed a few times but it dawned on me that it's iterated enough that we can swing back around to some Smalltalk syntax. The original idea was to use [ signature | types | code ] and [ types | code ] to reflect the Smalltalk-80 block

stz

streaming without coroutines

Let's try again but this time we do things the simpler way. Brick and Mortar. That's the idea of low level programming anyway. Nothing fancy. We have a few combinations we care about: socket file array block socket X X X X file X X X

stz

streaming with coroutines

It's worth considering just how the | operator works when it hits a terminal. There are three cases we want to consider 1) processing with a block, 2) writing in to another collection, and 3) writing to a socket. In the first scenario we want to read from the

stz

node tree

Let's try and code something simple. A tree of nodes: Node (name: String, children: (Array of: Node)) We can likely use this right away to simulate HTML (without attributes): document: Node = {name: 'html', children: ( {name: 'head'}, {name: 'body'}) } Let's keep

stz

zero cost reinterpretation

Sometimes you have a piece of data and you want to treat it differently to how it currently is. Let's take a concrete example: a filename. Not a file, but its name. It could include a path, it might not. Underneath it all, it's a bunch

stz

I/O definition vs execution

In previous examples of IO I've been using the null-type to make a pipe of operations execute. Let's break this down a bit and find a better way to do that. people | [age ≥ 18] | stdout To better understand how the flow operates we should look at

stz

forms of [] and the ~

I added the ability to declare methods using signature ~ types [ code ] recently and it hasn't sat well with me since. The short hand for doing inline methods remained [ signature | types | code] and the way you write blocks is either [ types | code ] or [ code ]. I'm going to

stz

pattern matching unions

Currently you define unions in such a way that you can re-interpret the data in another form. This is the class C style union. pet (union | as-cat: cat, as-dog: dog) But what if we wanted tagged unions? essentially a type+data? To be useful we need to be able to

stz

the invasive maybe

Maybe is a really powerful concept. It's sometimes called Choice and it has a few other names too. The basic idea is a structure of 'value' and 'state' where that state might be an error-code, or it might simply be a true/false indicator

stz

iterating #2

Now that we've solved the syntactical problems of iteration we can circle back to some of the other ideas before we embraced python comprehensions. The one in particular I'd like to look at is composition of blocks. We know we can use the parameter type → return

stz

implicit first parameter

There has been, from the start, the idea of receiverless method calls where the receiver was bound to the current execution context. The 'self' variable, for want of a better name, didn't need to be written out. adult := self age ≥ 18 adult := age ≥ 18 In the