newLISP Fan Club

Yes I like parentheses too . I remember Interlisp having square brackets as "meta parentheses" so as to avoid strings of stopping parentheses; the two forms interoperated so that ']' closed all '(' to match prior balancing '[', and likewise ')' closed all '[' to match prior balancing '('.
One could then write for example the following
(define (factorial n)
    [if (zero? n)
        1
        (* n (factorial (- n 1 ] )Perhaps it's clearer? But the reader has to know the syntax in any case.

I suppose one might use find-all for that. Though, find-all doesn't provide the character index, and it doesn't provide the match overlap variant. It wouldn't be terribly hard to patch the source to make find-all offer the index (eg as $index) similar to the match count.

However, one can use collect and a small helper function to get the following alternative solution:
> (define (regex-all EXP STR OPT ALL)
  (let ((i 0)
     (move-i (fn (X) (setq i (+ (X 1) (if ALL 1 (X -1)))) X)))
      (collect (if (regex EXP STR OPT i) (move-i $it)))))

> (setq a "AAAaBAAAABcADccAAAB")
> (regex-all "[A]{3}" a 0)
(("AAA" 0 3) ("AAA" 5 3) ("AAA" 15 3))
> (regex-all "[A]{3}" a 0 true)
(("AAA" 0 3) ("AAA" 5 3) ("AAA" 6 3) ("AAA" 15 3))

EDIT: I fixed to use EXP rather than hard-coded search pattern.

Yeah same here, parenthesis make everything easy to understand for me, I honestly don't get why anyone hates them.

Does anyone know of any more efficient methods than the following to calculate all the matches of a regex?
Thanks.
(define (regex-all regexp str all)
"Find all occurrences of a regex in a string"
  (let ( (out '()) (idx 0) (res nil) )
    (setq res (regex regexp str 64 idx))
    (while res
      (push res out -1)
      (if all
          (setq idx (+ (res 1) 1))        ; contiguos pattern (overlap)
          (setq idx (+ (res 1) (res 2)))) ; no contiguos pattern
      (setq res (regex regexp str 64 idx)))
    out))

(setq a "AAAaBAAAABcADccAAAB")
(regex "[A]{3}" a)
;-> ("AAA" 0 3)
(regex-all "[A]{3}" a)
;-> (("AAA" 0 3) ("AAA" 5 3) ("AAA" 15 3))
(regex-all "[A]{3}" a true)
;-> (("AAA" 0 3) ("AAA" 5 3) ("AAA" 6 3) ("AAA" 15 3))


Interesting, but I'm fond of parentheses.

Nice!

Problem Solving with newLISP
https://github.com/cameyo42/newLISP-Code
More than 3000 topics on newLISP:
- Algorithms
- Project Euler
- Rosetta Code
- Programming interview questions
- Library for recreational mathematics (344 functions)
- a lot of programming problems

Hi,
last week I got nerd-sniped when I saw an alternative to the 'parens-heavy' syntax of newlisp, wisp: https://www.draketo.de/software/wisp.

I've seen more alternative lisp syntaxes over the years (f.i. rhombus, shrubbery in Racket) but this is the first time that I can see this a viable alternative so I made a small newlisp module (indent.lsp) which you can download from https://github.com/luxint/wisp-newlisp.


As an example this is wisp syntax:

define : factorial n
  if : zero? n
    . 1
    * n : factorial : - n 1

which gets then transpiled into:

(define (factorial n )
  (if (zero? n)
    1
    (* n (factorial (- n 1)))))

Have fun and let me know if you like it!

I think experiments that people want to put effort into are worth trying. 👍

Hi guys,

How can we attract attention to newlisp from folks who recognize its worth and have the skills to maintain and improve it? Maybe fork it and re-write it in Nim, Go, or Rust? If we went that direction it might get people from those communities interested. We could name the fork Nimlisp, or something.

What do you think?