Symbols as parameters?

[Dave Angel]

Roald de Vries wrote:
> <div class="moz-text-flowed" style="font-family: -moz-fixed">Hi Martin,
>
> On Jan 21, 2010, at 8:43 AM, Martin Drautzburg wrote:
>> Hello all,
>>
>> When passing parameters to a function, you sometimes need a paramter
>> which can only assume certain values, e.g.
>>
>>        def move (direction):
>>                ...
>> If direction can only be "up", "down", "left" or "right", you can solve
>> this by passing strings, but this is not quite to the point:
>>
>>        - you could pass invalid strings easily
>>        - you need to quote thigs, which is a nuisance
>>        - the parameter IS REALLY NOT A STRING, but a direction
>>
>> Alternatively you could export such symbols, so when you "import *" you
>> have them available in the caller's namespace. But that forces you
>> to "import *" which pollutes your namespace.
>>
>> What I am really looking for is a way
>>
>>        - to be able to call move(up)
>>        - having the "up" symbol only in the context of the function call
>>
>> So it should look something like this
>>
>> ... magic, magic ...
>> move(up)
>> ... unmagic, unmagic ...
>> print up
>>
>> This should complain that "up" is not defined during the "print" call,
>> but not when move() is called. And of course there should be as little
>> magic as possible.
>>
>> Any way to achieve this?
>
> You could do something like this:
>
> class Move(object):
>     def __call__(self, direction):
>         print(direction)
>         return 0
>
>     def up(self):
>         return self('up')
>
> move = Move()
>
> Now move.up() means move('up'), and you can obviously do similar 
> things for other directions.
>
Once pointed down that road, how about:

class Move(object):
    def __call__(self, direction):
        print(direction)
        return 0

    @property
    def up(self):
        return self('up')

move = Move()

Now you can just say
move.up

with no parentheses.

When I've wanted a DSL (Domain Specific Language) in the past, I've used 
Forth.  It has so little syntax of its own, it's not hard to design your 
own simple syntax for a particular problem.  And one of the things you 
can do is to define keywords that intercept the compile process of the 
following token (or line, or whatever).

I am not claiming it's quick to become that proficient in Forth, 
however.  The learning curve has a couple of steep sections, and this 
sort of thing is one of them.

DaveA