Hi Levente,


IMHO a DSL is very much about syntactic sugar. If we obviate it, we impede the development of richer and higher-level language concepts that abstract from repetitive and uninteresting basics such as the temporary variable in your example. Just my two cents. :-)


Best,

Christoph

________________________________
Von: Squeak-dev <squeak-dev-bounces at lists.squeakfoundation.org> im Auftrag von Levente Uzonyi <leves at caesar.elte.hu>
Gesendet: Dienstag, 30. März 2021 22:21:00
An: ma.chris.m at gmail.com; The general-purpose Squeak developers list
Betreff: Re: [squeak-dev] Extending the functionality of caseOf: (was: #identityCaseOf:)

Hi Chris,

On Sun, 28 Mar 2021, Chris Muller wrote:

>       > For example, passing the object to the condition block (or even the result
>       > block) could be useful:
>       >
>       > self someComplexExpression caseOf: {
>       >       [ 1 ] -> [ self success ]
>       >       [ :value | value odd ] -> [ :value | self processEvenValue: value -
>       >       1 ].
>       >       [ :value | true "it's even ] -> [ :value | self processEvenValue ] }
>
>       >
>       > There are two new things in the example:
>       > - the value of self someComplexExpression is optionally passed to the
>       > blocks. Yes, that could be done by creating a temporary variable.
>
>
> Here's the version using a temporary and existing API (with an added identity-check).
>
>    result := self someComplexExpression.
>    true caseOf:
>       { [result=1] -> [self success].
>       [result odd] -> [self processEvenValue: result-1].
>       [ result == identityValue ] -> [self processSomethingElse ].
>       [true] -> [self processEvenValue] }
>
> "true caseOf:" is my sneaky way to improve its flexibility.  The suggested expansion of the API seems too dilute, not enough bang.

Yes, it does the job, but it's a bit more verbose and probably less
efficient: you have to declare the variable yourself, and you have to
write result=1 instead of just 1.

>
>       The
>       > compiler could do exactly that behind the scenes.
>       > - when the value is passed to the matcher block, possibilities are greatly
>       > extended.
>
>
> The evaluation is done before any of the caseOf tests, so is it really extended with more expressive power?  Or just a different syntax that moves the variable declaration from a temporary to the block arg?

It's just syntactic sugar. The optimized evaluation would just reuse the
existing temporary instead of creating a new one all the time.
The default implementation would be

Object >> caseOf: aBlockAssociationCollection otherwise: aBlock

         aBlockAssociationCollection associationsDo:
                 [:assoc | (assoc key numArgs = 0
                         ifTrue: [ assoc key value = self ]
                         ifFalse: [ assoc key value: self ]) ifTrue: [^assoc value cull: self]].
         ^ aBlock cull: self


Levente

>
>       For example, it could even reproduce #identityCaseOf:
>       >
>       >       foo caseOf: {
>       >               [ :o | o == #foo ] -> [ self foo ].
>       >               [ :o | o == #bar ] -> [ self bar ] }
>       >
>       > The same thing could be done with the otherwise block too:
>       >
>       >       self foo
>       >               caseOf: { ... }
>       >               otherwise: [ :value | value ]
>       >
>       >
>       > Levente
>       >
>
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.squeakfoundation.org/pipermail/squeak-dev/attachments/20210407/502e2ce8/attachment.html>