Pascal:

But where is the paper that argues that fexprs are sometimes
better than macros because they are more flexible and
powerful than macros? Or easier to use, learn, etc? It sounds
like Mr.  Majorinc is confident enough that he should be
able to set about writing that paper. I'm looking forward to it!

;============================

I define macro (at-least-two arg1 ... argn)
that returns true if and only if at least
two of args evaluate to the true. Macro is
needed because we want lazy evaluation
of arg1 to argn, like in OR or AND.

Newlisp (17 tokens, very simple)

     (define-macro (at-least-two)
              (let (c)
                   (doargs (i (= c 2))
                           (if (eval i)
                               (inc c)))
                   (>= c 2)))

     ; test

     (println (at-least-two (= 1 1)
                            (= 3 2)
                            (= 2 5)
                            (= 2 20)))

     (exit)

(A) Could you write simpler, more elegant one in
     your favorite Lisp?

Only solution so far is Rainer Joswig's CL

     (defmacro at-least-two (&rest expressions)
       (let ((c (gensym)))
         `(let ((,c 0))
            (block nil
              ,@(loop for expression in expressions
                      collect `(when ,expression (incf ,c))
                      collect `(when (= ,c 2) (return t)))
              nil))))

It has 38 tokens, and I think it is significantly more
complicated (and not the first class.)

------------------------------------------------

(B) Fexprs are frequently described as "dangerous."
     Practice of Newlispers seems to be different:
     there are no complains. Probably because Newlispers
     typically use lexical / static scope constructs
     named "contexts."

     However, even without lexical scope, I believe
     that fexprs are pretty safe.

(B1) Is anyone able to find the expression that
      breaks at-least-two macro?

(B2) Is anyone able to find the expression that
      breaks at-least-two macro after trivial name
      mangling, for example, replacing i with
      at-least-two-i.

(B3) Is anyone able to find the expression that
      breaks at-least-two macro after single
      application of my function protect2 from
      my Newlisp library www.instprog.com,
      explained at my blog kazimirmajorinc.blogspot.com,
      post "Don't fear Dynamic Scope (2)"

------------------------------------------------
(C) I define more general macro at-least that should
accept expressions of the following kind:

(at-least 3 (= 1 1) (= 2 2) (= 4 4))
(at-least 7 (= 1 1) (= 7 2) ... )

Solution in Newlisp

(define-macro (at-least n)
          (let (c)
               (doargs (i (= c n))
                       (if (eval i)
                           (inc c)))
               (>= c n)))

From Wikipedia, Macro

 A macro in computer science is a rule or pattern that
 specifies how a certain input sequence (often a
 sequence of characters) should be mapped to an
 output sequence (also often a sequence of characters)
 according to a defined procedure. The mapping process
 which instantiates a macro into a specific output
 sequence is known as macro expansion.

Your code does not map an input sequence to an
output sequence, thus it is no macro and the
form should be named DEFINE-FEXPR.

You are a token counter? Here are slightly less tokens
for your more general version.

(defmacro at-least (n &rest es &aux (c (gensym)))
  `(let ((,c 0))
      (or ,@(loop for e in es collect `(and ,e (= (incf ,c) ,n))))))

Again your FEXPR fails to show the generated code,
because it can't.

Common Lisp can show me the generated code:

CL-USER 91 > (pprint (macroexpand-1 '(at-least 2 (= 1 1) (= 3 2) (= 2 2) (= 4 4))))

(LET ((#:G14745 0))
  (OR (AND (= 1 1) (= (INCF #:G14745) 2))
      (AND (= 3 2) (= (INCF #:G14745) 2))
      (AND (= 2 2) (= (INCF #:G14745) 2))
      (AND (= 4 4) (= (INCF #:G14745) 2))))

Well, your version iterates over all forms, counts the true values
and then returns if the sum is equal or greater to 2. So, it does NOT
stop when 2 is already reached.

Let me change my version so that it does the same:

(defmacro at-least (n &rest es &aux (c (gensym)))
  `(let ((,c 0))
     ,@(loop for e in es collect `(when ,e (incf ,c)))
     (>= ,c ,n)))

CL-USER 98 > (pprint (macroexpand-1 '(at-least 2 (= 1 1) (= 3 2) (= 2 2) (= 4 4))))

(LET ((#:G14786 0))
  (WHEN (= 1 1) (INCF #:G14786))
  (WHEN (= 3 2) (INCF #:G14786))
  (WHEN (= 2 2) (INCF #:G14786))
  (WHEN (= 4 4) (INCF #:G14786))
  (>= #:G14786 2))

The Newlisp manual also seems to have a wrong example for lambda-macro:

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

  (lambda-macro (a b) (set (eval a) b))  evaluates to (lambda (x) (* x x))

That would surprise me...

  [He can bore with Eff Sharp.
   He can snooze with Oh Camel.
   He measures code size
   at the character level.]

So, token count translates to flexiblity and power. Hmm!

(defun at-least-n (n-func &rest funcs)
  (loop with limit = (funcall n-func)
        with c = 0
        for f in funcs
        when (funcall f) do (incf c)
        when (>= c limit) do (return t)))

(defmacro lambda-call (function &rest exprs)
 `(funcall ,function ,@(mapcar (lambda (expr) `(lambda nil ,expr)) exprs)))

(lambda-call 'at-least-n 3 (print 'a) (print 'b) nil (print 'c) (print 'd))

  -> T

  output:
  A
  B
  C

Though LAMBDA-CALL is a special form, AT-LEAST-N is a first class function that
takes functional arguments:

  (at-least-n (lambda () 3) (lambda () (print 'a)) ...)

Lambdas are compiled when the program in which they are contained is compiled,
and give you access to lexical variables. E.g.:

  (let ((foo 42))
    (lambda-call #'funcall (incf foo))
    foo))

Your own ``first class'' while loop:

 (defun while (guard &rest body)
   (loop while (funcall guard)
         do (mapcar #'funcall body)))

  (let ((x 0))
    (lambda-call #'while (< x 10) (print x) (incf x)))

  -> NIL

  Output:
  0
  1
  2
  3
  4
  5
  6
  7
  8
  9

There is no need to have functions that take unevaluated arguments, because you
can make a special operator like LAMBDA-CALL that gives you syntactic sugar
into turning forms into the bodies of simple functions, and passing the
resulting functions to a function. The function then uses FUNCALL to
``evaluate'' these compiled bodies rather than EVAL. (Above, the function /is/
FUNCALL).

Though lambda-call isn't first class, it doesn't matter because it is one of a
kind. You would be indirecting upon different functions, not upon different
operators similar to LAMBDA-CALL.

  (doargs (i (= i 2) ...)
  (>= i 2)

I.e. `(doargs (,var ,until-expr) ...).  So DOARGS has a double condition for
terminating: implicitly running out of args, or the expression becoming true.

The code is slightly confusing because he it repeats the test again. After
the execution of the loop, it's not clear whether it terminated because it ran
out of arguments, or because i reached the maximum value.

It's like those silly C programs that do:

  for (i = 0; i < N; i++) {
    /* ... */
    if (found)
      break;
  }

  if (i == N) {
     /* ooops not found */
  }

Off course I know that i would be N if nothing was found, right after
the loop, at least in most "C" compilers that would be the case
(compilers that I know, used, etc), but at least for one such compiler
and specific optimization options that wasn't the case - on it, i was
equal to N-1 after the cycle (or N+1, can't remmember) - I think it was
a SH3 CodeWarrior compiler that we used for early Dreamcast dev. But
memory might play tricks on me.

Given a loop like for (i = 0; i < N; i++), provided that the loop does not have
some early break, and does not mess with the value of i; and provided that the
value N is not out of the range of the type of i; after the execution of that
loop, i must have the value N!  The predicate i == N is one of the basic
post-conditions of the loop, whose body keeps executing and incrementing i
while i < N.

On the last iteration, i is N-1 and the body is executed, and then the
increment step, which brings i to N. The guard is then evaluated (i < N) and
found to be false because i is N; the loop then terminates without doing
anything more to i.

I've actually stopped liking "C", much more because of "C++" and the
pressure it puts on people trying to grok it fully. (In fact I love "C",
but at work, I'm more or less forced to use "C++" and a "C++" without
exceptions and RTTI in the runtime (though we could use the latter only
for tools).

Btw, I've learned quite a lot from your latest posts!

Will your code eval the first two args in any case?
Even if only one is given? It seems to me that the (eval i)
will take place in the case when at-least-two was called with
exactly one argument.

Here I have a version in Clojure. It will return nil if less than
two args were given. In the other case it will evaluate the first
two arguments:

(defmacro at-least-two [& r]
   (let [c (take 2 r)]
     (when (= 2 (count c))
       `(do ~@c))))

This version is even better than yours in my opinion.
It also has 17 tokens. Your version needs 150% of the lines of code of
my version, and my version is also shorter in character count:
user> (count "(define-macro (at-least-two)
(let (c)
(doargs (i (= c 2))
(if (eval i)
(inc c)))
(>= c 2)))")
91

vs

user> (count "(defmacro at-least-two [& r]
(let [c (take 2 r)]
(when (= 2 (count c))
`(do ~@c))))")
83

As you see, I did not count the leading spaces. So, your version does
not fall too far behind.
So, your version has nearly 10% more chars.
But the best feature about my version is, in my opinion of course,
that it is dramatically much more readable.
There are no side effects. No counter c is increased.
There is no need for a loop. I find it very clear.
Take up to 2 args out of the given args. When 2 args were taken, then
compile it into code (that’s the “do”).
Perhaps you will agree with me. But I am open to hear that your opinion
is different, and that you find your version easier and more readable.

(defmacro at-least-two [n & r]
   (let [c (take n r)]
     (when (= n (count c))
       `(do ~@c))))

Again, I find my version simpler. Not much.
But, even for this short code, far more elegant.

 > Well, your version iterates over all forms, counts the true values
 > and then returns if the sum is equal or greater to 2. So, it does NOT
 > stop when 2 is already reached.

You somehow made mistake. It does stop. For debugging
purpose I added one print.
-------------------
CODE:

(define-macro (at-least n)
          (let (c)
               (doargs (i (= c n))
                       (print i) ;;;;;; This one
                       (if (eval i)
                           (inc c)))
               (>= c n)))

(at-least 3 (= 1 1) (= 2 2) (= 3 3) (= 4 4) (= 5 5))
(exit)

----
OUTPUT:

(= 1 1)(= 2 2)(= 3 3)true
-----------------
It works.

; Newlisp macro written in the Common Lisp style
(define-macro (at-least n)
   (println (append '(let (c))
                    (list
                       (cons 'or
                         (map (lambda(x)
                                (expand '(and x (inc c) (= c n))
                                        'x))
                              (args)))))))

This is fexpr that does exactly the same thing as your macro.
It generates code and prints it - if you want that it evaluates it,
just replace println with eval. It has 27 tokens. It is not natural to
force generating whole code in fexprs, but it is possible.

It was my original one:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-macro (at-least n)
          (let (c)
               (doargs (i (= c n))
                       (if (eval i)
                           (inc c)))
               (>= c n)))

As I myself wrote it, do you believe me that it was
easier?

So you cannot simply take two expressions and ignore the rest.

Your macro also can't just not emit any code at all when there are fewer than
two expressions. The expressions may have side effects. If there is only one
expression, you know that the result will have to be false, but the effect
of that expression still has to take place.

Let me guess:  (let ((i 'something)) (at-least-two (eval i)))   also
does not work.
doargs sets i to the list (eval i), and then evaluates it... which
does what?

(defmacro at-least-two [& x]
   `(= 2 (count (take 2 (filter eval '~x)))))

filter will lazily feed eval with the args that were passed to the macro.
Besides that, filter is like CLs remove-if-not.

This macro will eval all args passed to at-least-two until a maximum of
two of these args evaled to true. (that is: not “nil” and not “false”).
As Kaz suggested, now even those args that eval to nil or false will be
run, so side effects take place.

Obviously I find this version even more elegant than the one before.
And it is even shorter.
@Rainer: of course, counting characters is a very idiotic thing. But
it still is enjoyable for me to do it, because I feel a little bit like
“beat ‘em with their own weapons”.
I am not seriously drawing conclusions from these 5 liners. I just do it
for the fun. Also Tamas complained in the past about it. I ask you two
to just let me continue, for special friends.
Mostly for guys like Jillian James :-)

Shouldn't it count the expressions that evaluate to true over all
items?

Will that see variables?

In CL

(let ((a t) (b nil) (c t))
  (at-least-two a b c))

?

...

EVAL meets lazy sequences: a jam between psychedelic acid rock and progressive
metal!

:)

Let's do it in CL:

   (defun lazy-list (ordinary-list)
     (lambda ()
       (if ordinary-list
         (pop ordinary-list)
         (values nil t))))

   (defun lazy-filter (function lazy-list)
     (lambda ()
       (loop
         (multiple-value-bind (next nomore)
                              (funcall lazy-list)
           (cond
             (nomore (return (values nil t)))
             ((funcall function next) (return next)))))))

Test:

  [4]> (defparameter f (lazy-filter #'evenp (lazy-list '(1 2 3 4 5))))
  F
  [5]> (funcall f)
  2
  [6]> (funcall f)
  4
  [7]> (funcall f)
  NIL ;
  T
  [8]> (funcall f)
  NIL ;
  T

  (defun lazy-take (num lazy-list)
    (lambda ()
      (if (plusp (prog1 num (decf num)))
        (funcall lazy-list)
        (values nil t))))

  (defun lazy-count (lazy-list)
    (let ((count 0))
      (loop
        (multiple-value-bind (next nomore)
          (funcall lazy-list)
          (if nomore
            (return count)
            (incf count))))))

Now, transliterate the Clojure macro:

  (defmacro at-least-two (&rest x)
    `(= 2 (lazy-count (lazy-take 2 (lazy-filter #'eval (lazy-list ',x))))))

  [9]> (macroexpand '(at-least-two a b c d e))
  (= 2 (LAZY-COUNT (LAZY-TAKE 2 (LAZY-FILTER #'EVAL (LAZY-LIST '(A B C D E)))))) ;
  T

  [10]>   (at-least-two (princ 'a) nil nil (print 'b) (print 'c))
  AB
  T
  [11]>   (at-least-two (princ 'a) nil nil (print 'c))
  AC
  T
  [12]>   (at-least-two (princ 'a) (print 'c))
  AC
  T
  [13]>   (at-least-two (princ 'a))
  A
  NIL

Woiks for me!

def at_least n, list
  list.any?{|x| eval x and 0 == n -= 1}
end

(defmacro at-least-two [& x]
   `(= 2 (count (take 2 (filter eval [~@x])))))

The change is what follows the “eval”.
It was:       '~x
And now is:  [~@x]

Explanation:
x will be a list of all given args in the macro.
Inside a backquote expression x is just the symbol x.
To unquote it one uses “~” in Clojure, as “,” is just
whitespace (for readability really nice, IMO).
~x would place the list of all given args behind the eval.
In the case of (at-least-two a b c) this would be
(a b c)
But (filter eval (a b c)) does not make much sense typically,
because the function a is not defined.
So, a call like:
(let [a nil, b nil, c false, d true] (at-least-two a b c d))
would result in a NullPointerException.

In my original version I did not think about variable capture,
so a call like:
(at-least-two 5 6 7)
would result in (filter eval (5 6 7)) which also makes no sense,
as Clojure can’t call 5.

That’s why I quoted the ~x in my macro:  '~x
Now (at-least-two 5 6 7) results in a (filter eval '(5 6 7)).
This however can’t work if variables are in the game, because those
would be treated literally, as symbols.

If Clojure would put the rest args into a vector instead of a list,
then ~x would have been okay. But as this does not happen I say:
[~x] which would be ==> [(5 6 7)]
But [~@x]  ==>  [5 6 7]
Now it is not quoted anymore, and also variables are treated properly:

user> (let [a nil, b nil, c false, d true] (at-least-two a b (println 5) d))
5
false

Note that the false is the return value of the call to at-least-two.
The 5 directly above it is what was printed. Note that println just
prints and returns nil. So, unlike CLs print it won’t return 5.

(let [a nil, b nil, c false, d true] (at-least-two  b a d  c d))
==> true

 > (TAKE 2) does nothing, just produces a virtual sequence.

Exactly.

 > If you don't use that value, no evaluation happens. But COUNT must