[middayc]

Yes ... Rye is syntax-wise in similar camp than Lisps, only without parenthesis. Some say Lisp has no syntax (which is debatable), but has a point that there are no syntax rules. There are multiple token types and they always combine / apply in the same ways, there are no special forms like "how to define a function" or "how to write and if else". In Rye calling if or eihter (if/else) is no different than calling any other function.

[timbit42]

Carl Sassenrath, the creator of the Amiga OS, created REBOL after he did Amiga Logo. Logo is what REBOL's syntax was based on. Logo is often called, 'Lisp without parentheses'.

[galaxyLogic]

Note in Smalltalk ifTrue:ifFalse: is similarly just a method/function of the class Boolean. Rye seems very promising.

[middayc]

Thanks! Out of many languages I tried, I have to admit I never really worked with smalltalk. I should one day!

[lispm]

> There are multiple token types and they always combine / apply in the same ways, there are no special forms like "how to define a function" or "how to write and if else". In Rye calling if or eihter (if/else) is no different than calling any other function.

Not in Lisp. In Lisp IF, COND, ... are either special operators or macros which expand to more primitive special operators. They are not functions.

The syntax for COND is:

    cond {clause}* => result*
    clause::= (test-form form*)

For example:

    (cond ((> x 1) (print 'larger) 1)
          ((= x 1) (print 'equal) 1)
          (t       (print 'smaller)))

COND is not a function. It is a macro. In a function call all arguments would be evaluated. But COND does not work that way.

COND has a list of clauses. During evaluation, the first clause is looked at. It's first subform then is evaluated, here (> x 1). If that is true, then the following subforms are evaluated left to right and the values of the last form is returned. If the first subform form was not evaluated to true, the evaluation goes to the next form and repeats the process on the subform.

* COND is not a function

* COND has a special syntax

* COND has a special evaluation rule

The same is the case for defining functions. In Lisp the operator to define a global function is called DEFUN. DEFUN is a macro, not a function. It has special syntax (for example the second element in a DEFUN form needs to be an unevaluated function name, which usually (I omit some detail) needs to be a symbol (which will not be evaluated)...

Again, DEFUN is not a function, it has special syntax and special semantics with side effects during compilation.

[middayc]

Yes, you are correct. I wasn't exact e nough about it, the end result syntax wise is similar, but there are macros involved in Lisps case.

I wrote multiple times right about this difference between Rebol-s and Lisp-s. The main difference being that Lisps evaluate lists by default and you have to quote them to not be evaluated and Rebols don't evaluate blocks by default and you have to "do" them to evaluate them. That's why Rebol's can have if/loop/fn as ordinary functions and Lisps use Macros for them.

If in rebol would be more like (if (> x 1) '(print 'larger)) I think.

Thanks for making this clear ... it was a nice read.

[cardanome]

There is Lisps with so called f-expressions[0] which do not have special forms. That would be similar to the Rebol approach I think, I am a bit fuzzy on that.

The general consensus in the lisp community is that having a few special forms is worth it as it makes the compiler's job much easier. Basically it is a trap because yes it is much more elegant but practically it isn't worth the trouble, or at least some people see it that way. I also heard that Smalltalk is considered hard to compile for its lack of special forms.

But more complicated doesn't mean it is necessary impossible to still have a efficient compiler. It is definitely an interesting topic. Definitely would love to hear if you had any trouble on that front. If you already that far that you are thinking about optimization that is.

And your new languages looks amazing. Definitely going to check it out.

[0] https://web.cs.wpi.edu/~jshutt/kernel.html

[_19qg]

> Lisps use Macros

IF is a built-in special operator in Common Lisp. COND is a macro, which expands into IF forms.

> (if (> x 1) '(print 'larger))

Stuff like this would not really work Common Lisp for the following code example:

    (let ((x 1))
      (if (> x 1)
        '(print x)))

The evaluator would not know that the X in the print form refers to the lexically bound X from the LET form.