Topic: AutoLisp or/and not complying to CL's

[irneb]

OK, AL's or and and only return T or nil. According to the CLHS, this is incorrect.

This is my take on attempling a CL or / CL and:

Code - Auto/Visual Lisp: [Select]

1. (defun cl_or (forms / now)
2.   (while (and (not (setq now (car forms)))
3.               (setq forms (cdr forms))))
4.   now)
5.  
6. (defun cl_and (forms / )
7.   (if (apply 'and forms) (last forms)))

[Lee Mac]

Another for OR:

Code - Auto/Visual Lisp: [Select]

1. (defun _or ( forms )
2.     (cond ((car forms)) (forms (_or (cdr forms))))
3. )

AND, not so elegant:

Code - Auto/Visual Lisp: [Select]

1. (defun _and ( forms )
2.     (if (and (car forms) (cdr forms)) (_and (cdr forms)) (car forms))
3. )

[irneb]

Another alternative for OR:

Code - Auto/Visual Lisp: [Select]

1. (defun _or (forms / )
2.   (vl-some '(lambda (item) item) forms))

[irneb]

A version of AND which doesn't use the current AND:

Code - Auto/Visual Lisp: [Select]

1. (defun _and  (forms)
2.   (cond ((car forms)
3.          (cond ((cdr forms) (_and (cdr forms)))
4.                ((car forms))))))

[Stefan]

Or variation

Code - Auto/Visual Lisp: [Select]

1. (defun ph:or (forms)
2.   (car (vl-remove nil forms))
3.   )

[Lee Mac]

Another OR:

Code - Auto/Visual Lisp: [Select]

1. (defun _or ( forms ) (vl-some ''((x) x) forms))

[irneb]

Wow! Didn't know that one! So you don't actually need a lambda:

Code: [Select]

Command: ('((x) (1+ x)) 2)
3A quote does just fine!

[Lee Mac]

Indeed 

[BlackBox]

Wow! Didn't know that one! So you don't actually need a lambda:

Code: [Select]

Command: ('((x) (1+ x)) 2)
3A quote does just fine!

Awesome. 

[BlackBox]

[OffTopic]

... Wait a minute.

Are you guys seeing the same differences in speed, or am I missing something? 

Code - Auto/Visual Lisp: [Select]

1. (defun lambda1 ()
2.   ('((acDoc)
3.      (vla-get-name acDoc)
4.     )
5.     (vla-get-activedocument (vlax-get-acad-object))
6.   )
7. )
8.  
9. (defun lambda2 ()
10.   ((lambda (acDoc)
11.      (vla-get-name acDoc)
12.    )
13.     (vla-get-activedocument (vlax-get-acad-object))
14.   )
15. )
16.  
17. (defun lambda3 ()
18.   (car
19.     (mapcar
20.       (function
21.         (lambda (acDoc)
22.           (vla-get-name acDoc)
23.         )
24.       )
25.       (list (vla-get-activedocument (vlax-get-acad-object)))
26.     )
27.   )
28. )
29.  
30. (bench '(lambda1 lambda2 lambda3) '() 100000)
31.  

Benchmark result:

Code - Auto/Visual Lisp: [Select]

1. LAMBDA1
2. Elapsed: 9641
3. Average: 0.0964
4.  
5. LAMBDA2
6. Elapsed: 5101
7. Average: 0.051
8.  
9. LAMBDA3
10. Elapsed: 5974
11. Average: 0.0597
12.  

[/OffTopic]

[Lee Mac]

Without testing, I don't doubt that the quoted format of the lambda function will be slower since without the use of a lambda function intently expressed there is more work for the LISP interpreter to interpret the list structure as a lambda function; this behaviour is similar to the use of the function function in place of a quote.

[BlackBox]

Thanks for the clarification, Lee... Sorry for the tangent, Irne 

[ElpanovEvgeniy]

To analyze AND / OR you can use code like this, sometimes this approach is very useful!

Code - Auto/Visual Lisp: [Select]

1. (apply '+ (mapcar '(lambda (a) (if a 1 0)) l))

[irneb]

Never mind the inability to define default / infinite arguments - causing the call to have to pass all forms inside one list!

What I still can't figure out how to accomplish is to stop pre-evaluation of arguments. You'll notice the CLHS defines and/or as macros instead of functions. That means none of the forms are evaluated prior to and/or is called - then they're only called one at a time until the boolean logic causes the macro to stop.

Therefore you can do something like this for global values:

Code - Auto/Visual Lisp: [Select]

1. (setq *doc* (or *doc* (vla-get-ActiveDocument (vlax-get-acad-object))))

In current AL that won't only not give the correct result, but would have no efficiency gain (since both the forms are evaluated prior to passing it to _or).

You could of course quote the forms individually, but then it's breaking from what normal lisp coders would expect.

I suppose one could do something like this:

Code - Auto/Visual Lisp: [Select]

1. (defun _or  (forms /)
2.   (vl-some '(lambda (item) (eval item)) forms))
3.  
4. (defun _and  (forms / result)
5.   (vl-every '(lambda (item) (setq result (eval item))) forms)
6.   result)

But that means to use it you need to call it thus:

Code - Auto/Visual Lisp: [Select]

1. (setq *doc* (_or (list '*doc* '(vla-get-ActiveDocument (vlax-get-acad-object)))))

In which case, you loose the elegance of your code in order to jump through the limitation hoops of AL.

[Kerry]

< ..>

Code - Auto/Visual Lisp: [Select]

1. (setq *doc* (or *doc* (vla-get-ActiveDocument (vlax-get-acad-object))))

In current AL that won't only not give the correct result, but would have no efficiency gain (since both the forms are evaluated prior to passing it to _or).

Personally I see nothing wrong with the current AutiLisp functionality.
I don't understand why you'd want to make it look like CommonLisp

This is perfectly clear and functional

Code - Auto/Visual Lisp: [Select]

1. (or *doc* (setq *doc*(vla-get-ActiveDocument (vlax-get-acad-object))))