Re: Bart's Language

On 2025-03-20, Waldek Hebisch <antispam@fricas.org> wrote:

bart <bc@freeuk.com> wrote:

On 18/03/2025 15:10, Waldek Hebisch wrote:

bart <bc@freeuk.com> wrote:

On 18/03/2025 12:17, Waldek Hebisch wrote:

bart <bc@freeuk.com> wrote:

>
This is the document I produced:
>
https://github.com/sal55/langs/blob/master/MFeatures.md
>
A couple of more substantial demo programs are here:
https://github.com/sal55/langs/tree/master/MExamples
>
(The bignum.m file was ported - by hand - to the bignum.c version that I
posted recently.)

>
Looking at features, can you say if the program below works?
And if it works, what is retrun value of foo?  "Equvalent" can
be written in C, but in C you have to keep sane order.

>
>
There were some tweaks needed; it indicates some basic info missing from
my write-up! (For example, that the function call needs to be bar() not
bar; 'const' is only for compile-time expressions; and that C's 'const'
doesn't exist - it only briefly mentions an attempt at 'let'.)
>
The revised code is shown below, with what I assumed were your
intentions.

 
Well, my intentions beter correspond to the C version below:
 
int foo() {
     const int c = c1(10);
     const int b = c + c2(2);
     const int a = b+c3(c);
     bar();
     baz();
     return c;
}

 
 
In this case, just write it like that, and only adjust it for the
somewhat different syntax:
 
  func foo:int =
      let int c := c1(10)
      let int b := c + c2(2)
      let int a := b+c3(c)
      bar()
      baz()
      return c
  end

>
In your description you wrote that declarations can be written
"out of order" and compiler will rearrange them in correct
order.  That looked like great opportunity to write obfuscated
code.

I made a language feature like that: mlet.

https://www.nongnu.org/txr/txr-manpage.html#N-2B3072E9

This allows for circular references in order to support
the construction of lazy objects:

1> (mlet ((a (lcons 1 b))
          (b (lcons 0 a)))
    (take 20 a))
(1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0)

If we use the regular cons function, rather than the
lcons lazy cons macro operator:

2> (mlet ((a (cons 1 b))
          (b (cons 0 a)))
    (take 20 a))
** expr-1:1: force: recursion forcing delayed form (cons 1 b) (expr-1:1)

When there isn't circularity, the expressions can be in
any order; the lazy machinery will force the evaluation
of everything in the correct order:

2> (mlet ((x (+ y 3))
          (z (+ x 1))
          (y 4))
     (+ z 4))
12

First y gets 4, so (+ y 3) can initialize x to 7,
after which z can take (+ x 1) to get 8. Then
the body evaluates (+ z 4) to 12.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca