[Cuis-dev] extending the syntax for blocks and methods

[Francisco Garau]

Dan Ingalls talks about the indexing operator in "The evolution of
Smalltalk: from Smalltalk-72 through Squeak" [1]

In Smalltalk--76

a • i ← b • i

In Smalltalk--80

a at: i put: (b at: i)

Smalltalk--80--didnahappen

a @ i := b @ i

or

a ! i := b ! i


[1]
http://worrydream.com/refs/Ingalls%20-%20The%20Evolution%20of%20Smalltalk.pdf

On 16 Jul 2022, at 10:51, Luciano Notarfrancesco <luchiano at gmail.com> wrote:

Hola!
Interesting. Actually methods written like this look more complicated than
the original Smalltalk-80 syntax to me, but it’s an interesting idea, maybe
looks complicated just because I’m not used to it. Let us know how it goes.

Note that in Cuis #: is a valid binary message. I use it, maybe I’m the
only one who uses it.

Another idea we discussed before was to compile ‘f(x)’ as ‘f value: x’.
Note that this is not ambiguous with Smalltalk-80. We could also compile
‘a[i]’ as ‘a at: i’. I’m not sure if it’s worth to complicate the
Smalltalk-80 syntax with things like this, tho, I also value simplicity.


On Sat, 16 Jul 2022 at 01:39 Francisco Garau via Cuis-dev <
cuis-dev at lists.cuis.st> wrote:

> Hola Amigos -- just wanted to share with you some ideas I've been
> thinking about for a while.
>
> It all started when someone mentioned the colon in the syntax for block
> arguments could have whitespace around the argument so that you could
> write  [ : n | n + 1]
>
> It makes perfect sense to see the block as an "inlined" method that
> doesn't require any method-lookup; therefore, the selector is superfluous.
> But if we accepted the selector inside the block, it could be used as the
> variable holding the block. So, instead of writing succ := [:n | n + 1]
> we could write  [succ: n | n + 1]
>
> Even better if the block evaluation accepts #: as a valid selector.  So
> you could write (succ: 3) = 4 instead of (succ value: 3) = 4.
>
> A short example will make this clear.
>
> Vanilla Smalltalk
>
> succ := [:n | n + 1].
>
> (succ value: 3) = 4.
>
>
> Extended Block Syntax
>
> [succ: n | n + 1].
>
> (succ: 3 ) = 4.
>
> "the above is equivalent to"
>
> (succ perform: #: with: 3) = 4.
>
>
> Being able to parse blocks with these syntax paves the way to unify the
> syntax for method definition—for example, a few hypothetical methods from
> the Point class.
>
> "Point class>x:y:"
>
> [x: xInteger y: yInteger |
>
>    ^self basicNew setX: xInteger setY: yInteger].
>
>
> "Point>>abs"
>
> [abs |
>
>    ^x abs @ y abs].
>
>
> "Point>>extent:"
>
> [extent: aPoint |
>
>    ^Rectangle origin: self extent: aPoint]
>
>
> Of course, it gets trickier when blocks have more than one argument..
>
> [add: a to: b | a + b].
>
> (add_to value: 3 value: 4) = 7. "old style block evaluation"
>
> (add: 3 to: 4) = 7.
>
> I think building a separate Parser is a sensible approach -- is there a
> Smalltalk Parser as a separate package that can be tweaked without
> affecting the running image?
>
> Thanks,
> Francisco
>
>
> --
> Cuis-dev mailing list
> Cuis-dev at lists.cuis.st
> https://lists.cuis.st/mailman/listinfo/cuis-dev
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.cuis.st/mailman/archives/cuis-dev/attachments/20220717/c68c28c3/attachment.htm>