newLISP Fan Club

The previous code is wrong. Sorry.

Let's write a function that associates each index of a list with a different index of the list itself.
(define (sel-idx lst)
  (let ((out '()) (len (length lst)))
    (dolist (el lst)
      ; select and index of the list different from the current
      (while (= (setq idx (rand len)) $idx))
      ;(println "coppia: " $idx idx)
      (push (list $idx idx) out -1))
    out))

Now if lst has only one value, the function should loop (because it's not possible to select an index other than 0):
(sel-idx '(1))
;-> ((0 0))  --> ERROR
If lst has more than one value, the function should work correctly:
(sel-idx '(1 2))
;-> ((0 1) (1 0))  --> OK
(sel-idx '(1 2))
;-> ((0 1) (1 1))  --> ERROR
Why doesn't the function produce correct results?
Because 'until' (and 'while') also have an internal variable $idx.
So we're not comparing the generated value 'idx' to $idx from 'dolist', but to $idx from 'until'.
To fix this, we need to copy the value '$idx' from 'dolist' into a variable and apply it within the 'until' loop.
(define (sel-idx-ok lst)
  (let ((out '()) (len (length lst)) (tmp 0))
    (dolist (el lst)
      (setq tmp $idx)
      ; select and index of the list different from the current
      (while (= (setq idx (rand len)) tmp))
      ;(println "coppia: " $idx idx)
      (push (list tmp idx) out -1))
    out))

(sel-idx-ok '(1))
;-> ... --> infinite loop
(sel-idx-ok '(1 2))
;-> ((0 1) (1 0)) --> OK
(sel-idx '(0 1 2 3 4 5 6 7 8 9))
;-> ((0 4) (1 9) (2 4) (3 8) (4 8) (5 9) (6 1) (7 1) (8 6) (9 6))


(define (test lst)
  (let (len (length lst))
    (dolist (el lst)
      ; select and index of the list different from the current
      (while (!= (setq idx (rand len)) $idx)))
    (println "index: " idx)))
Why (test '(1 2 3 4 5)) fall (almost always) into an infinite loop?
Why (test '(1)) return always 0? The function should fall into an infinite loop.

I know the answer...

A fast function to generate all prime numbers less than or equal to a given number

(define (primes-to num)
"Generate all prime numbers less than or equal to a given number"
  (cond ((< num 2) '())
        ((< num 3) '(2))
        (true
          (letn ((m (/ (- num 3) 2))
                 (arr (array (+ m 1)))
                 (lim (/ (- (int (sqrt num)) 3) 2))
                 (lst '(2)))
            (for (i 0 lim)
              (when (nil? (arr i))
                (letn ((p (+ (* 2 i) 3))
                       (j (/ (- (* p p) 3) 2)))
                  (for (k j m p (> k m))
                    (setf (arr k) true)))))
            (for (i 0 m)
              (when (nil? (arr i))
                (push (+ (* 2 i) 3) lst -1)))
            lst))))

(time (println (length (primes-to 1e6))))
;-> 78498
;-> 100.292
(time (println (length (primes-to 1e7))))
;-> 664579
;-> 1396.784
(time (println (length (primes-to 1e8))))
;-> 5761455
;-> 15544.004
(time (println (length (primes-to 1e9))))
;-> 50847534
;-> 178960.989
S.O.: Windows 10
CPU: intel i7
RAM: 32 GB

It has been down for more than 48 hours. Most likely both DNS and hosting were with the same provider and the service was not paid. The domain itself is fine.

I'm getting "server not found" from www.newlisp.org this morning. Anyone else having the same problem?

Turbulent back and forth switching between (set 'sym ...) and (set sym ...) in an attempt
to find the right mental model and the paradigm shift.

set without quoted symbol name is the winner.

Summary:

set
  - Standard way to assign a value to a symbol/place.
    - (set a 1)
    - (set a 1 b 2 c '(3 4))
    - (set (nth 1 lst) exp)
    - (set f (fn (a b) ... ))
    - (set f (fn-macro (a b) ... ))
    - .. etc ...
  - Using a quoted symbol name is an error.
  - Replaces:
    - (set 'x 1) - error
    - (setf x 1) - primitive removed
    - (setq x 1) - primitive removed
    - (define x 1) - primitive removed

Purpose:
  - clear, direct symbol creation
  - no confusion anymore, symbol is never quoted
  - no ambiguity, sugars removed, can be aliased (alias 'setf set) if you want
  - no silent behavior

mut
  - *Opt-in*. You can use set all the time
  - Refers to a mutate operation.
  - Changes the value of an existing mutable symbol (created via set, let*, local).
  - Using a quoted symbol name is an error.
  - It is a visual marker for mutation.
  - It is meant for programmers who want to clearly distinguish in code
    where a symbol is created (using set, local, let*) and where it is later mutated (using mut).
  - It prevents quiet mutation of a symbol that was never created as a variable
    (e.g. due to a typo).
    (local (a b c)
       (mut a 1) ; OK: mutating an existing symbol
       (mut x 2) ; ERROR: symbol was never created in any scope (prevents silent bugs)
       (set x 2)  ; SILENT: creates or overwrites a symbol outside this scope as in newLISP
    )

tie
  - Works like newlisp set '
  - Unlike set, the name tie intentionally does not imply a standard assignment operation.
  - For now, intended for two special cases:

  1. When code generates another code containing at least one symbol assignment.
    - (map tie '(a b) '(1 2)) ... here map generates another code (tie 'a 1) (tie 'b 2)
    - (apply tie '(x 120))
    - macros
      (mac (defun _name _args)
        (tie _name (append '(fn ) (list _args) (args))))

  2. When a symbol points to another symbol, allowing indirect modification
    of the target symbol value.
    - (tie 'a 'b) (tie a 10) ... indirect assignment, b is 10.

  - I am not aware of any other cases where tie (and newlisp set 'sym) would need to be used.

  - Using tie in other cases:
    - is considered redundant/needless, use set instead.
    - will not be promoted in the manual as a standard assignment operation,
    - will be discouraged in the manual,
    - will never appear in Rebel ecosystem
    - is user's responsibility, it is not possible to disallow using tie in this way: (tie 'x 1)


func
  Creates a named function. Replaces define in this case.
  (func (f arg)) - OK
  (func f 1) - error, use set
  (func f (fn (arg) ...) - error, use set

If you want to try Rebel, please check the green checkmarks
in GitHub Actions before cloning. The repo moves fast
and may be temporarily broken.

https://github.com/ufko-org/rebel/actions


Ufko.

Ok, I apologize. I did say it was no big deal and I never said anything about losing me a a potential user. I'll continue to follow your project with interest and look forward to seeing what you can make of it.

Hi.

Losing users who consider long function
names to be language expressiveness is,
in my view, an extremely drastic change.

Rebel is not a subject of discussion;
my post was only an announcement.

Ufko.

Thanks, your post made it seem more drastic.

Just for the sake of discussion, though, I think I prefer write-file and append-file to fwrite and fappend. the latter might be more concise, but they are less expressive and not as natural to type. No biggie though. :-)

Hi,

Nothing broke functionally. Rebel keeps the same
language semantics; the changes are primarily in
function naming, not in behavior.

Rebel intentionally diverged to establish a concise,
more Unix/C-like naming for core functions.

There are two straightforward options for existing
newLISP code:

 - Rename function calls to the new Rebel names.
 - Define aliases for the original names.

Both approaches are fully supported and idiomatic.

The authoritative reference is primes.h, which
documents the active Rebel interface and naming.
See the header comment for orientation:

https://github.com/ufko-org/rebel/blob/main/src/primes.h

For renamed functions, the original newLISP name
can usually be inferred from the C primitive name,
which has not changed so far.

For example, new fwrite maps to p_writeFile, meaning
the original function name was write-file.

Regarding GitHub discussions/issues: they were disabled
intentionally to keep development focused.

Ufko