newlispfanclub.alh.net

William James

Before version 24.1, EMACS Lisp was dynamically scoped; now lexical scoping is an option. When a closure was needed, it was customary to load the CL package and use lexical-let. It would be very nice if lexical-let were added to newLISP. Closures could be created more easily, by a method that is mor...

William James

(macro (assoc-push Alist Key Val) (let (key Key val Val) (or (catch (push val (or (lookup key Alist) (throw nil)) -1)) (push (list key (list val)) Alist -1)))) (macro (assoc++ Alist Key Val) (let (key Key val Val) (or (catch (++ (or (lookup key Alist) (throw nil)) (or val 1))) (push (list key (or v...

William James

I just tested the speed using Lutz's 'fun workaround. The composed function is just as fast as the lambda (fn (a b) (< (last a) (last b))) . Perhaps I should explain the name f<g= . If I remember correctly, J (descended from APL) gives names to its operators that compose functions like fork, atop, c...

William James

Thanks for the fast and helpful reply.

Function composition is a powerful and fun technique.
I'm hoping that

Code: Select all

(sort (copy test-list) (f<g= < last))

won't be slower than

Code: Select all

(sort (copy test-list) (fn (a b) (< (last a) (last b))))

William James

;; Function composition. (define (f<g= f g) (expand (fn (a b) (f (g a) (g b))) 'f 'g)) ((f<g= < last) '(a 2) '(b 3)) ==> true ((f<g= < last) '(b 3) '(a 2)) ==> nil (set 'lst '((b 5) (a 2))) (sort lst (f<g= < last)) ==> ((a 2) (b 5)) (set 'lst '((a 2) (b 5))) (sort lst (f<g= < last)) ==> ((a 2) (b 5...

William James

Here's a REPL that I cobbled together. It probably has bugs, but it works pretty well for me. (println "Quit with (exit).") (define (input__complete? str) (if (or (find "^\s*$" str 0) (find "^\s*;[^\n]*$" str 0)) true (let (error-message "" scanned 0) (if (catch (begin (read-expr str) (setq scanned ...

William James

Code: Select all

> (set 'a (fn (n) (if (zero? n) 1 (* n (a (- n 1))))))
(lambda (n)
 (if (zero? n)
  1
  (* n (a (- n 1)))))
> (a 5)
120

William James

Code: Select all

(define (my-func s1 s2 a b c)
  (dup (string s1 s2 a b) c))

> (my-func "o" "-" 1984 9 3)
"o-19849o-19849o-19849"

> (apply my-func (cons "o" (cons "-" '(1984 9 3))))
"o-19849o-19849o-19849"

> (apply my-func (append '("o" "-") '(1984 9 3)))
"o-19849o-19849o-19849"

William James

Code: Select all

(define (half-string str)
  ((div (length str) 2) str))

(while (read-line)
  (println (half-string (current-line))))

William James

It seems that gensym isn't really needed anymore.

One can simply do (sym (uuid)).

William James

I'm processing some text so that various characters are replaced with alternative formulations. The problem is that the curly braces in the original text need to be replaced with \letteropenbrace{} but the backslashes need to be replaced with \letterbackslash{}, and I can't do both these operations...

William James

Code: Select all

;; using sym for simulating hash tables

(set (sym "John Doe" 'MyDB') 1.234)

There should not be a single-quote after 'MyDB.

William James

Interesting approach; I'm not very familiar with letex. Since we are putting each macro in its own context, I think you can safely use func instead of _func. I like "(if $args" instead of "(if (empty? (args))"; shorter and cleaner. You gave me the idea of just using one eval : (context '->>) (define...

William James

Here are two "threading" or pipelining macros, similar to those in Clojure: (context '->>) (define-macro (->>:->> E form) (if (empty? (args)) (if (list? form) (eval (push E form -1)) (eval (list form E))) (eval (cons '->> (cons (list '->> E form) (args)))))) (context '->) (define-macro (->:-> E form...

William James

Slightly improved. To quit, type "(exit)". (define (input__complete? str) (if (or (find "^\s*$" str 0) (find "^\s*;[^\n]*$" str 0)) true (let (error-message "" scanned 0) (if (catch (begin (read-expr str) (setq scanned $0)) 'error-message) (input__complete? (slice str scanned)) (when (find {^ERR: sy...

William James

Allows you to spread your expressions over several lines. : ( factor 99999999991 ) (83 1289 934693) If botched input keeps the prompt from appearing, control-Z (under Windows; for Linux, try control-D) should clear up the problem: : * 2 3) ) ) ^Z ERR: string expected : nil A work in progress. Modify...

William James

Thanks. I think it would be nice if gensym were built into newLISP.

William James

Slightly improved, and with an example in which two lambdas share a variable. (define-macro (closure varval-pairs) (let (body (cons 'begin (args)) alist (map (fn(x) (list (x 0) (gensym) (eval (x 1)))) (explode varval-pairs 2))) (bind (map (fn (x) (rest x)) alist)) (dolist (x alist) (set-ref-all (x 0...

William James

(define (gensym:gensym) (sym (string "gensym-" (inc gensym:counter)))) (define-macro (closure varval-pairs body) (let (alist (map (fn(x) (list (x 0) (gensym) (eval (x 1)))) (explode varval-pairs 2))) (bind (map (fn (x) (rest x)) alist)) (dolist (x alist) (set-ref-all (x 0) body (x 1))) body)) (set ...

William James

Kazimir Majorinc wrote:I agree about union, not because it is particularly missing, but because it is low hanging fruit.

Good news, Kazimir. Lutz sent me a p.m. indicating that this will be added.

William James

I enjoy using the int-reduce option in apply.
When int-reduce is 2, the behavior is like fold or reduce; when it's larger than 2, it's even more fun.

Code: Select all

> (apply (fn(_ a b c)(println a b c)) (cons nil (sequence 1 9)) 4)
123
456
789

William James

rickyboy wrote:Don't know about Scheme, but in SBCL:
Code: Select all
* (mapc #'set '(ee ff gg) '(22 33 44))
(EE FF GG)
* ee
22
* ff
33
* gg
44

Yes, I later realized that. My post has been corrected.

William James

I never thought of

Code: Select all

(map set '(a b c) '(1 2 3))

... probably because it's not allowed in other languages.

Gambit Scheme:

Code: Select all

4> (map define '(ee ff gg) '(22 33 44))
*** ERROR IN (console)@8.6 -- Macro name can't be used as a variable: define

William James

This works for me:

Code: Select all

(define (for-all-args func)
  (for-all func (args)))

> (for-all-args number? 2 3 4 5)
true

> (for-all-args number? 2 3 'not 5)
nil

William James

These seem to work. ;; Compose two functions. Both accept only 1 argument. (define (atop f g) (expand (lambda (a) (f (g a))) 'f 'g)) ;; Compose two functions. The first to be called accepts ;; any number of arguments. (define (atop* f g) (expand (lambda () (f (apply g (args)))) 'f 'g)) Thanks to Kaz...

newlispfanclub.alh.net

Search found 58 matches

lexical-let

rewrite macros for updating association-lists

Re: Possible bug in sort

Re: Possible bug in sort

Possible bug in sort

Re: wish i could enter multiline expressions by default

Re: Is there an equivalent to flet or labels?

Re: list to values

Re: Use map to process list of lines from stdin?

Re: Pseudo-closures using gensym

Re: escaping characters problem

Re: Some minor errors about manual and ....

Re: Macros for pipelining

Macros for pipelining

Re: Yet another REPL

Yet another REPL

Re: Pseudo-closures using gensym

Re: Pseudo-closures using gensym

Pseudo-closures using gensym

Re: Set Operations

Re: dolist but getting more values at the same time

Re: extract analogous to extend?

Re: extract analogous to extend?

Re: all? or perhaps predicates that accept multiple args

Re: Function composition?