begin vs. do

Pondering the philosophy behind the language
Locked
TedWalther
Posts: 608
Joined: Mon Feb 05, 2007 1:04 am
Location: Abbotsford, BC
Contact:

begin vs. do

Post by TedWalther »

I was just reading the wikipedia article on REXX tonight, after reading their article on COBOL. I was struck with how elegant REXX is. Not as LISP, mind you, but it had a couple nice things. I believe the (begin... construct came from the BASIC language. Right? In REXX, "do" serves the same role. If it isn't a reserved word, (I believe it isn't) I will start doing (constant 'do begin) and starting using (do...) in my code instead of (begin...)

Lutz, thanks for incorporating those $prefix type changes! In the next couple months I will try to implement an OpenBSD "port", or "package", of newlisp. There used to be one, I don't know why it was dumped.

Ted

Kazimir Majorinc
Posts: 388
Joined: Thu May 08, 2008 1:24 am
Location: Croatia
Contact:

Post by Kazimir Majorinc »

I think begin is from Algol and came here through Pascal and then Scheme but I agree that do fits better - it is shorter, similar to dolist, dotimes and brothers and it doesn't beg for end. It appears that author of the Clojure thought same way.

ale870
Posts: 297
Joined: Mon Nov 26, 2007 8:01 pm
Location: Italy

Post by ale870 »

"begin" is used in many very descriptive languages (even ada, modula2 and modula3, and even other "modern" language like pl/sql (oracle) based on ada, use that so long construct).

I agree with you, "do" fits better, but warning: it could be "confused" with something like "eval". In fact there are other functional languages that use it in this way (see Rebol at:
http://www.rebol.com/docs/words/wdo.html)
--

newBert
Posts: 156
Joined: Fri Oct 28, 2005 5:33 pm
Location: France

Post by newBert »

I think do is ambiguous. In some languages like Lua, Euphoria it is used to begin a block but it probably evals the block too. In any rate one would think so.

dotimes and dolist (in NewLISP) gives me the same impression. I think that begin is more expressive even if we don't find the correlated end, useless in NewLISP because of the (closing/ending) brackets.

We could say "block" instead of "begin" but IMHO it's not a very pretty word
;-)

P.S.: finally a block with begin is evaluated too. So ... do or begin ?
BertrandnewLISP v.10.7.6 64-bit on Linux (Linux Mint 20.1)

HPW
Posts: 1390
Joined: Thu Sep 26, 2002 9:15 am
Location: Germany
Contact:

Post by HPW »

And people coming from autolisp use (constant 'progn begin)!
;-)
Hans-Peter

ale870
Posts: 297
Joined: Mon Nov 26, 2007 8:01 pm
Location: Italy

Post by ale870 »

HPW wrote:And people coming from autolisp use (constant 'progn begin)!
;-)
This is an important point: even if newLisp is not Lisp, I think if there are some "compatibilities" they could simplify user "migration".

"block" could fit very well, but if the starting point of this discussion was finding a shorter word than "begin", I think "block" will cause incompatibilities but will not give a big benefit.

I think we could really round the corner with a hard solution: why don't we try to use a symbol like "^^" (or any other), or we could find a single word token like "b".

C language is good even for its code, and they use "{"

See here:

Code: Select all

(if (= 1 1)
    (begin
        (println "This is a test")
        ) )
We could have:

Code: Select all

(if (= 1 1)
    (b
        (println "This is a test")
        ) )

(if (= 1 1)
    (^^
        (println "This is a test")
        ) )

(if (= 1 1)
    (::
        (println "This is a test")
        ) )
--

HPW
Posts: 1390
Joined: Thu Sep 26, 2002 9:15 am
Location: Germany
Contact:

Post by HPW »

This is an important point: even if newLisp is not Lisp, I think if there are some "compatibilities" they could simplify user "migration".
I have no problem, that newLISP does have 'begin' for blocking code.

For me it is in the best sense of 'bottom-up design' described by Paul Graham in one of his essays:

http://www.paulgraham.com/progbot.html

So I am sure every newLISP'er user uses newLISP to make his own special language which gets the best fit to solve his own programming task.

So when I want to have 'progn' or 'do' what's the problem to switch to them with a one-liner?
Hans-Peter

cormullion
Posts: 2038
Joined: Tue Nov 29, 2005 8:28 pm
Location: latiitude 50N longitude 3W
Contact:

Post by cormullion »

think we could really round the corner with a hard solution: why don't we try to use a symbol like "^^" (or any other), or we could find a single word token like "b".
I think the only typographical asset currently under-utilized in newLISP is the opening square bracket... Perhaps, one day, in Lutz' careful hands, it could do something wonderful or surprising on its own, not just introducing [ text ], [ cmd ]. But it would be a shame to see a valuable resource used just to provide a simple synonym for 'begin'...

Oh, it also lets you do those weird symbol names:

Code: Select all

(constant (sym "[Please do all the following expressions in order:]") begin)

...

([Please do all the following expressions in order:] (println "hi" ) (println "there"))

hi
there
Me, I like begin. Particularly since you don't have to find a matching end... You can type it with confidence, knowing that in just a few seconds you can start writing some code that actually does some work...

ale870
Posts: 297
Joined: Mon Nov 26, 2007 8:01 pm
Location: Italy

Post by ale870 »

Basically I agree with you cormullion, in fact I don't like to find matching "end" from "begin".

I think Lutz could find a "special" symbol (not like open/close). Close must be like the standard: ")" (as every other function).
I really like newLisp for functions usage, symbols usage, etc... (against imperative languages).

SO if we want (Lutz wants!) to find an alternative, we MUST avoid to break newLisp fashion/magic :-)
--

cormullion
Posts: 2038
Joined: Tue Nov 29, 2005 8:28 pm
Location: latiitude 50N longitude 3W
Contact:

Post by cormullion »

Although I'm not convinced that an alternative is needed...

newLISP is fine the way it is (*)!

*edit: named parameters would be nice, though... :)

Lutz
Posts: 5289
Joined: Thu Sep 26, 2002 4:45 pm
Location: Pasadena, California
Contact:

Post by Lutz »

newLISP is fine the way it is (*)!

*edit: named parameters would be nice, though... :)
thanks ;) and you could use this:

http://www.newlisp.org/newlisp_manual.html#bind

scroll down to the last example.

ale870
Posts: 297
Joined: Mon Nov 26, 2007 8:01 pm
Location: Italy

Post by ale870 »

Hey Lutz, you are running at the light's speed!!! :-)

Example in the manual about binding (arguments) is great!

(I will steal that and put it in my blog ;-)
--

cormullion
Posts: 2038
Joined: Tue Nov 29, 2005 8:28 pm
Location: latiitude 50N longitude 3W
Contact:

Post by cormullion »

Lutz wrote:scroll down to the last example.
Yes, it's almost what I want, but:

Code: Select all

(context 'My-cool-context)

(define-macro (foo) 
    (local (len width height)
        (bind (args) true)
        (println "len:" len " width:" width " height:" height)))

(context MAIN)

(My-cool-context:foo (My-cool-context:width (+ 15 5)) (My-cool-context:height 30) (My-cool-context:len 10))
- in my view - less than perfect... :)

Kazimir Majorinc
Posts: 388
Joined: Thu May 08, 2008 1:24 am
Location: Croatia
Contact:

Post by Kazimir Majorinc »

Cormullion, I think you can find some ways around it. This is "proof of the concept" code only:

Code: Select all

(define (decontext-AL x)
        (list (sym (slice (string (first x))
                          (+ (or (find ":" 
                                       (string (first x)))
                                 -1)
                             1)))
              (last x)))

(context 'My-cool-context)

(define-macro (foo)
   (local (len width height)
      (bind (map MAIN:decontext-AL (args)) true) ; nil for macro!
      (println " len: " len " width: " width " height: " height)))

(foo (width (+ 15 5)) (height 30) (len 10))
; len: 10 width: 20 height: 30

(context MAIN)

(My-cool-context:foo (width (+ 15 5)) (height 30) (len 10))
; len: 10 width: 20 height: 30

cormullion
Posts: 2038
Joined: Tue Nov 29, 2005 8:28 pm
Location: latiitude 50N longitude 3W
Contact:

Post by cormullion »

Thanks, Kazimir!

There are indeed many workrounds, and yours is more excellent than most of those, but it remains a workround nonetheless.

This (now becoming off topic, sorry! :)) issue isn't really related to functionality, because there are many ways to pass some kind of label with arguments to functions. It's mostly - for me at least - related to readability. So workrounds aren't that important; they don't make things much more readable, and introduce more code (and presumably slow down execution speed).

Locked