stz

stz

when to use a reference

There's two ways to pass objects as parameters in a method. Either as a copy or as a reference. If we're simply using the data, we pass it as a copy. If we intend to modify it we pass it as a reference. Copying large objects

stz

write file to stdout

Just for fun let's try and write a low level program using mmap to read a file and write it to stdout. requires: 'libc'. [main: arguments] [filename := arguments[0] else| panic. // Open file or die fd := (libc open: filename flags: O_RDONLY) else| panic. --- [libc

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