Consider sigils (in a proposed lisp-1) as an alternative to namespaces (in
a lisp-2).

They solve the traditional problem:

(let (($cons 5)) (cons $cons $cons)) ; → (5 . 5)

They also obviate funcall:

(defun abs ($x)
((if (< $x 0) &- &+) $x))

As well as making things generally more consistent:

(let ((&foo (lambda ($x) (+ 2 (* 2 $x)))) ; look, ma; no labels!
($foo 5)) ; uniform binding for all sorts
(foo $foo)) ; → 12

(An unsigilled symbol in the head position of a list to be evaluated is
treated as though it had the & sigil; this is just syntactic sugar:

(let ((&foo (lambda () 5))
($foo (lambda () 6)))
(foo) ; → 5
(&foo) ; → 5
($foo)) ; → 6)

(They also enable string interpolation which, though not a must-have, is
still pretty nice.)

Thoughts?

-E

On 2021-04-27, Elijah Stone <elronnd@elronnd.net> wrote:
> (let ((&foo (lambda () 5))
> ($foo (lambda () 6)))
> (foo) ; =E2=86=92 5
> (&foo) ; =E2=86=92 5
> ($foo)) ; =E2=86=92 6)
>
> (They also enable string interpolation which, though not a must-have, is
> still pretty nice.)
>
> Thoughts?

Please repost without MIME quoted printable encoding.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

Elijah Stone <elronnd@elronnd.net> wrote:

>
> (let ((&foo (lambda ($x) (+ 2 (* 2 $x)))) ; look, ma; no labels!
> ($foo 5)) ; uniform binding for all sorts
> (foo $foo)) ; → 12
>
> (An unsigilled symbol in the head position of a list to be evaluated is
> treated as though it had the & sigil; this is just syntactic sugar:
>

All the disadvantages of a Lisp-1 with all the disadvantages of a Lisp-2 at
the same time! Wonderful. You could add a special @ sigil for arrays
perhaps, to make it even better.

--
the small snake

On Tue, 27 Apr 2021, Kaz Kylheku wrote:

> Please repost without MIME quoted printable encoding.

Here:

Consider sigils (in a proposed lisp-1) as an alternative to namespaces (in a lisp-2).

They solve the traditional problem:

(let (($cons 5)) (cons $cons $cons)) ; -> (5 . 5)

They also obviate funcall:

(defun abs ($x)
((if (< $x 0) &- &+) $x))

As well as making things generally more consistent:

(let ((&foo (lambda ($x) (+ 2 (* 2 $x)))) ; look, ma; no labels!
($foo 5)) ; uniform binding for all sorts
(foo $foo)) ; -> 12

(An unsigilled symbol in the head position of a list to be evaluated is
treated as though it had the & sigil; this is just syntactic sugar:

(let ((&foo (lambda () 5))
($foo (lambda () 6)))
(foo) ; -> 5
(&foo) ; -> 5
($foo)) ; -> 6)

(They also enable string interpolation which, though not a must-have, is
still pretty nice.)

Thoughts?

-E

On 2021-04-27, Elijah Stone <elronnd@elronnd.net> wrote:
> On Tue, 27 Apr 2021, Kaz Kylheku wrote:
>
>> Please repost without MIME quoted printable encoding.
>
> Here:
>
> Consider sigils (in a proposed lisp-1) as an alternative to namespaces (in a lisp-2).
>
> They solve the traditional problem:
>
> (let (($cons 5)) (cons $cons $cons)) ; -> (5 . 5)
>
> They also obviate funcall:
>
> (defun abs ($x)
> ((if (< $x 0) &- &+) $x))

The question is, what are exactly & and $? It matters. Not always, but
sometimes.

Though subjectively, I wouldn't "go" for any version of this,
any halfway sane implementation should have it so that $abc and &abc
are both notations based on the same symbol abc. So that is to say,
they are a shorthand notation like:

$abc -> (var abc)
&abc -> (fun abc)

> As well as making things generally more consistent:
>
> (let ((&foo (lambda ($x) (+ 2 (* 2 $x)))) ; look, ma; no labels!
> ($foo 5)) ; uniform binding for all sorts
> (foo $foo)) ; -> 12
>
> (An unsigilled symbol in the head position of a list to be evaluated is
> treated as though it had the & sigil; this is just syntactic sugar:

But surely that's not what's happening with (let ...). The real rule has
to be that an unsigiled symbol in the head position is resolved in the
function space, where macros and special operators lie (other than
symbol macros).

Also, if foo is a macro, you probably don't want &foo to see it:

(let ((&foo (lambda ())))
(macrolet ((foo () ...))
&foo)) ;; expansion leaves this alone, so it refers to the lambda

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

Elijah Stone <elronnd@elronnd.net> writes:

> They also obviate funcall:
>
> (defun abs ($x)
> ((if (< $x 0) &- &+) $x))

What is it with funcall? You have to call a function eventually. instead
of using call or syscall; in common lisp they use funcall.

I mean reducing function calls is usually good.

> (They also enable string interpolation which, though not a must-have, is
> still pretty nice.)
>

> Thoughts?

I would love to have something like perl's format feature for lisp. Something
simple. Ahh, they'll probably use pcre or something...

> -E