> (empty? (array 2 '(1 2)))
ERR: list or string expected : (1 2)
I think any check function could accept any type of data.
I'd agree that
There are no empty arrays ;-)
I think array should have empty array, Just like other language.
I think "Not empty array" is a design error.
By default, we perceive an array as a special case of a list; so we expect it to act like a like in pretty much every way. So, even if an array is never empty, it makes sense for every function that acts on a list, to also act on an array and do the sensible thing. Even though under the hood, an array and list are very different. Principle of Least Surprise.
Quote from: "TedWalther"
Yes, but we can't effectively create an empty array :
> (array 0)
ERR: wrong dimensions in function array : 0
>
If we'd like to consider an array as a special case of a list, we must think it's above all a non-empty list.
So, the use of
Again, I haven't really used arrays in newlisp, so I don't mind the lack of empty arrays once told :-)
But upon review it seems that ideally the functions like
And (while loitering at the wishing well), maybe there could also be a binary search
Quote from: "Lutz"
+1 for pithy, direct answer. :)
... that unfortunately seemed to be ignored for a bit. :(
Since you can convert an array into a list, it is easy to overlook that there is no "list to array" function. But array creation does let you use a list as an "initializer". '() is a list... intuitively, until you try and fail, you wouldn't guess that the empty list isn't allowed as an array initializer.
The array-list function sets up a correspondance in the mind. This creates the expectation that arrays are just another type or format of list; so all the list functions should apply to it. Contexts are different enough from lists that you learn to treat them as their own data type from the beginning. Arrays are similar enough to lists, that it is jarring when they don't act like lists.
I need make array, hash, list use newLISP. SO i do like follows:
(define (is-blank-array x) (= x '()))
(define (is-list x) (list? x) (and (= (first x) "list") (list? (last x))))
(define (is-blank-hash x) (= x '(())))
(define (is-hash @x)
(and (list? @x) (for-all is-pair @x)))
(define (is-pair @x)
(and (list? @x) (= 2 (length @x)) (is-key (@x 0))))
(define (is-key @x) (or (string? @x) (number? @x)))
Hi ssqq,
Let's take this one by one.
Quote from: "ssqq"
(define (is-blank-array x) (= x '()))
The name `is-blank-array` belies what the procedure is actually doing which is checking that its input is an empty list. In other words, it has nothing to do with arrays. Also, recall that Lutz said that there are no empty arrays in newLISP.
Quote from: "ssqq"
(define (is-list x) (list? x) (and (= (first x) "list") (list? (last x))))
The `(list? x)` expression is superfluous (i.e., does nothing). Moreover, this function doesn't do what its name seems to intend. Witness:
nil
This is due to the fact that lists in newLISP are not implemented as "sequences" where the first item is the string "list". That's just wrong.
This doesn't even work.
nil
because `(list? (last x))` fails.
3
Lists like this will work:
true
but I think you intended a more general test.
Quote from: "ssqq"
(define (is-blank-hash x) (= x '(())))
(define (is-hash @x)
(and (list? @x) (for-all is-pair @x)))
This doesn't "describe" a "hash" (i.e., hash table/map), but an association list. Lispers have called this "alist" for short. So, your function names might be better expressed as `empty-alist?` and `alist?`.
Quote from: "ssqq"
(define (is-pair @x)
(and (list? @x) (= 2 (length @x)) (is-key (@x 0))))
(define (is-key @x) (or (string? @x) (number? @x)))
In an alist, the keys can usually be more than just strings or numbers -- they can be whatever data in the language is comparable under certain equality operators; these operators will be the ones used in your alist lookup functions, by the way. In hash tables/maps, keys are anything that is "hashable" (i.e., any data for which the hash function can produced a hash).
Quote from: "ssqq"
I think "Not empty array" is a design error.
I disagree. Why? Do you have a good use case?
Hello Ted!
Quote from: "TedWalther"
The subject of the action is incorrect here IMO. It's not the `array-list` function that "sets up a correspondence"; it's your own mind that is doing this. My mind is not making the same correspondence. :D
Quote from: "TedWalther"
In my mind, arrays are *different* enough from lists ... :)
in newLISP, no "true" hash, is just assoc-list. I just want simulate Hash, Array use newlisp.
Just like no Hash, List and symbol in C, but Lautz could write newLISP use C.
I write Spp language implement with newLISP, it have Array, Hash, List, Rule:
[]
> (@array << :a)
[:a]
> (my %hash {1 : 2, 3 : 4})
{1 ; 2, 3 : 4}
> (%hash 1)
2
> (my @lst :(1 2 3))
(1 2 3)