<remexre>
is there a way with iterate to iterate through all the active elements of an arbitrary array?
karlosz has joined #lisp
mindCrime has joined #lisp
mindCrime_ has joined #lisp
lavaflow has quit [Ping timeout: 240 seconds]
nanoz has joined #lisp
mindCrime has quit [Ping timeout: 264 seconds]
_whitelogger has joined #lisp
analogue has joined #lisp
eich has joined #lisp
mindCrime_ has quit [Ping timeout: 268 seconds]
lavaflow has joined #lisp
semz has quit [Ping timeout: 264 seconds]
semz_ has joined #lisp
semz_ has quit [Changing host]
semz_ has joined #lisp
user___ has quit [Ping timeout: 240 seconds]
libertyprime has quit [Read error: Connection reset by peer]
makomo has quit [Ping timeout: 244 seconds]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
semz_ has quit [Ping timeout: 264 seconds]
semz has quit [Client Quit]
Guest9575 has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
alexanderbarbosa has quit [Ping timeout: 276 seconds]
jonatack has quit [Ping timeout: 246 seconds]
t58 has quit [Quit: Leaving]
smazga has joined #lisp
stepnem_ has joined #lisp
stepnem has quit [Ping timeout: 245 seconds]
dddddd has quit [Remote host closed the connection]
Kevslinger has quit [Quit: Connection closed for inactivity]
karlosz has quit [Quit: karlosz]
eich has quit [Ping timeout: 240 seconds]
smazga has quit [Quit: leaving]
ralt has quit [Quit: Connection closed for inactivity]
nanoz has quit [Ping timeout: 246 seconds]
Denommus has joined #lisp
esrse has joined #lisp
superkumasan has quit [Ping timeout: 246 seconds]
eich has joined #lisp
khisanth_ has quit [Ping timeout: 268 seconds]
analogue has quit [Quit: Leaving]
Denommus has quit [Remote host closed the connection]
libertyprime has joined #lisp
nanoz has joined #lisp
khisanth_ has joined #lisp
ahungry has joined #lisp
<beach>
Good morning everyone!
xkapastel has quit [Quit: Connection closed for inactivity]
gravicappa has joined #lisp
georgie_ has joined #lisp
ahungry has quit [Ping timeout: 276 seconds]
jeosol has joined #lisp
georgie_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ahungry has joined #lisp
capadoodle has quit [Ping timeout: 252 seconds]
zbrown has quit [Ping timeout: 276 seconds]
rme has quit [Ping timeout: 276 seconds]
zbrown has joined #lisp
selwyn_ has quit [Ping timeout: 276 seconds]
capadoodle has joined #lisp
selwyn has joined #lisp
rme has joined #lisp
vutral has joined #lisp
eich has quit [Ping timeout: 245 seconds]
raghavgururajan has joined #lisp
fragamus has joined #lisp
yoeljacobsen has quit [Ping timeout: 245 seconds]
ahungry` has joined #lisp
fragamus has quit [Ping timeout: 246 seconds]
ahungry has quit [Ping timeout: 268 seconds]
akoana has left #lisp ["Leaving"]
torbo has quit [Remote host closed the connection]
user___ has joined #lisp
zbrown has quit [Changing host]
zbrown has joined #lisp
zbrown has joined #lisp
Bike has quit [Quit: Lost terminal]
fragamus has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
fragamus has quit [Ping timeout: 244 seconds]
nanoz has quit [Ping timeout: 245 seconds]
karlosz has quit [Client Quit]
anewuser has quit [Quit: anewuser]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 268 seconds]
nostoi has joined #lisp
ahungry` has quit [Remote host closed the connection]
nullniverse has joined #lisp
georgie has joined #lisp
SaganMan has joined #lisp
ljavorsk has joined #lisp
nostoi has quit [Quit: Verlassend]
manualcrank has quit [Quit: WeeChat 1.9.1]
sauvin has joined #lisp
voidlily has quit [Ping timeout: 276 seconds]
voidlily has joined #lisp
wusticality has quit [Ping timeout: 246 seconds]
wusticality has joined #lisp
dmiles has quit [Ping timeout: 245 seconds]
wusticality has quit [Ping timeout: 240 seconds]
dmiles has joined #lisp
fragamus has joined #lisp
SaganMan has quit [Ping timeout: 245 seconds]
frgo has quit [Ping timeout: 246 seconds]
<ebrasca>
beach: Good morning!
scymtym has quit [Ping timeout: 245 seconds]
shka_ has joined #lisp
ggole has joined #lisp
ravenousmoose has joined #lisp
JohnMS_WORK has joined #lisp
ravenousmoose has quit [Ping timeout: 246 seconds]
Necktwi has joined #lisp
nullniverse has quit [Ping timeout: 276 seconds]
ralt has joined #lisp
keep_learning has joined #lisp
shka_ has quit [Ping timeout: 240 seconds]
flamebeard has joined #lisp
<flip214>
remexre: what are "active elements"?
<flip214>
(loop for element across array do (print element))
<flip214>
(iterate (for element in-array array) (print element))
EvW1 has joined #lisp
<beach>
flip214: The glossary defines the term.
knicklux has quit [Remote host closed the connection]
<flip214>
beach: ah, thanks. well, the fill-pointer is used by LOOP and ITERATE anyway.
frgo has joined #lisp
georgie__ has joined #lisp
easye has quit [Remote host closed the connection]
georgie has quit [Ping timeout: 276 seconds]
easye has joined #lisp
georgie__ has quit [Ping timeout: 276 seconds]
georgie has joined #lisp
jello_pudding has joined #lisp
georgie has quit [Ping timeout: 244 seconds]
EvW1 has quit [Remote host closed the connection]
EvW has joined #lisp
georgie has joined #lisp
vlatkoB has joined #lisp
libertyprime has quit [Ping timeout: 276 seconds]
EvW has quit [Ping timeout: 252 seconds]
nowhere_man has quit [Ping timeout: 276 seconds]
libertyprime has joined #lisp
nanoz has joined #lisp
varjag has joined #lisp
scymtym has joined #lisp
georgie has quit [Remote host closed the connection]
libertyprime has quit [Read error: Connection reset by peer]
easye has quit [Ping timeout: 246 seconds]
georgie has joined #lisp
libertyprime has joined #lisp
<ljavorsk>
Hi everyone, does the lisp libraries have any name template for package name? (something like: lisp-<name>)? I have this problem, I'm packaging the pgloader-bundle and in the bundle section in Packaging Guidelines is written that every bundled library within this package must be in 'Provide' section. I wanted to start with the alexandria library, but I've found that alexandria exists in fedora, but it's some ruby package and this
<ljavorsk>
alexandria is from common-lisp. Do you have any suggestion how should I name it?
makomo has joined #lisp
<flip214>
ljavorsk: Debian uses eg cl-alexandria - collection of portable Common Lisp utilities
<jdz>
ljavorsk: Are you sure that pgloader should "provide" the libraries it uses?
<jdz>
It is my understanding that the whole "bundle" thing is so that pgloader does not interact with packages provided from other sources.
<ljavorsk>
Bundling and Duplication of system libraries --- section
jello_pudding has quit [Remote host closed the connection]
<flip214>
ljavorsk: how much value do you put on compatibility? You could have binary packages with only one FASL file, that would only need the exact matching SBCL version to work
<ljavorsk>
than why it have 67 -git files in /software folder
georgie_ has joined #lisp
<jdz>
ljavorsk: I bet it's so that the dependencies are in a known-good state (from the developer's point of view), and not some package maintainer's. dim can probably tell more.
georgie has quit [Ping timeout: 258 seconds]
<ljavorsk>
jdz, Hmm I don't know what is known-good state, actually this is my first package so I'm learning about packaging on it. Not to mention the lisp :D never seen it before
<ljavorsk>
A lot of stuff you write here is new for me, so I apologize if I don't understand correctly
easye has quit [Ping timeout: 246 seconds]
Necktwi has quit [Remote host closed the connection]
Necktwi has joined #lisp
<jdz>
ljavorsk: Maybe you can look into how Golang applications are packaged; as far as I know Go code can use libraries from git repositories (at specific branches/commits).
georgie_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
georgie has joined #lisp
fouric has quit [Ping timeout: 268 seconds]
gravicappa has quit [Ping timeout: 244 seconds]
<ljavorsk>
jdz, I have to wait for dim, need to ask him if these libraries in software/* are really needed, or if there is another way, because it's a lot to list them in Provides, and also to finding all of their versions, and in the case of name-conflict to figure out the correct name
gravicappa has joined #lisp
hhdave has joined #lisp
heisig has joined #lisp
ljavorsk_ has joined #lisp
jprajzne has joined #lisp
ljavorsk has quit [Ping timeout: 245 seconds]
easye has joined #lisp
fouric has joined #lisp
georgie has quit [Remote host closed the connection]
georgie has joined #lisp
kajo has quit [Remote host closed the connection]
kajo has joined #lisp
ljavorsk_ has quit [Quit: I'm out, bye]
ljavorsk has joined #lisp
flamebeard has quit [Remote host closed the connection]
ljavorsk has quit [Client Quit]
ljavorsk has joined #lisp
nanoz has quit [Ping timeout: 258 seconds]
georgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
flamebeard has joined #lisp
jonatack has joined #lisp
dddddd has joined #lisp
georgie has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life has joined #lisp
m00natic has joined #lisp
ljavorsk has quit [Ping timeout: 244 seconds]
georgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
maxxcan has joined #lisp
scymtym has quit [Ping timeout: 276 seconds]
JohnMS_WORK has quit [Read error: Connection reset by peer]
JohnMS_WORK has joined #lisp
xkapastel has joined #lisp
georgie_ has joined #lisp
seok has joined #lisp
<seok>
How do I kill child processes spawned by uiop:launch-program?
<seok>
terminate-process does not kill child processes
<pjb>
seok: using kill(2) or kill(1)
<seok>
huh xD
<seok>
you mean running another program with kill x?
<seok>
How would I find the pid of the child process?
<jeosol>
if are you on linux terminal: ps -ef | grep [name]
<jeosol>
not sure if you meant within the repl
georgie_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<thijso>
Where would I need to start looking if I get this error: Detected access to an invalid or protected memory address. occurred with errno: 0. ??
<thijso>
This is in ECL, btw
ljavorsk has joined #lisp
<ralt>
seok: terminate-process is supposed to work
georgie has joined #lisp
<ralt>
if you want to kill the children of the process started with uiop:launch-program, that's another story entirely.
<ralt>
it's the story of how linux works :)
<seok>
yeah, that's what I am trying to figure out
<ralt>
generally speaking, if you kill a process, you don't kill the children as well.
<ralt>
you have essentially 2 options
<seok>
I am on windows, but theyre both unix so it shouldn't matter
ljavorsk_ has joined #lisp
<ralt>
(1) either you control the processes you're running, and you can have each child trickle down its SIGTERM to its own children
<ralt>
or (2) you control them but you don't want to change their code, in that case the best is usually to start a supervisor, that will know how to shutdown its children when it gets a SIGTERM
<ralt>
or (3) you spawn the child process in a new PID namespace (e.g. docker container), and when killing your direct child, the namespace will be shut down and all the children will be gone
<ralt>
(yes, off-by-one)
<seok>
O 3 sounds clean
<seok>
how can I
<seok>
How can I do that?
<thijso>
I was just gonna say... "ralt says, 'you have 2 options', while holding up three fingers"... ;)
<ralt>
that's honestly not a question one can answer on IRC
<ralt>
thijso: I did point out "yes, off-by-one" :P
<thijso>
Yeah, that's why "I was just gonna say"
<seok>
He thought of the third one while writing the former two
<thijso>
But I said it anyway...
<ralt>
ha, misread
<thijso>
;)
<ralt>
my bad
<ralt>
I thought of the 2nd one while writing the first one, actually
ljavorsk has quit [Ping timeout: 276 seconds]
<ralt>
but yeah, "how do create docker container" or "how to spawn a child in new PID namespace" is largely googleable
<ralt>
s/do/to/
ramus has quit [Ping timeout: 276 seconds]
<ralt>
(is "googleable" even a word?)
<seok>
yeah
<seok>
google is in dictionary now
<ralt>
what a time to be alive
ljavorsk__ has joined #lisp
<seok>
How would you do 2 in lisp?
<seok>
would it be portable?
jonatack has quit [Quit: jonatack]
ljavorsk__ has quit [Client Quit]
ljavorsk has joined #lisp
<ralt>
You mean launching a supervisor? It's like launching any other process, except that process is e.g. supervisord or pm2 or whatever
maxxcan has quit [Quit: maxxcan]
<ralt>
If you mean writing a custom supervisor, well, that's... a bit of a bigger task.
<seok>
O it is a program
ljavorsk_ has quit [Ping timeout: 276 seconds]
<seok>
Hm.. this is a much bigger job than I anticipated
<seok>
I guess this is one of the reasons why CL is not as popular as mainstream languages
<no-defun-allowed>
What are you even trying to do now?
<seok>
trying to kill a subprocess spawned by uiop:launch-program
<ralt>
seok: that has nothing to do with CL there
<no-defun-allowed>
And it's not being killed with uiop:terminate-process?
<seok>
it only kills the main process
<seok>
not processes spawned by that process
<ralt>
you'll have exactly the same issue with python's subprocess.Popen(), or golang's os/exec, or whatever else. It's relevant to how OS/processes work, not to programming languages.
<no-defun-allowed>
Yeah, that's a Unix problem and not a CL one.
<seok>
I don't know, it is not just this issue. Whenever there is a problem in another language, usually there a library already which simplifies the problem
<seok>
When I am using CL, the problem can be fixed, but I need to learn all these new low level stuff in order to fix it
<ralt>
I'm not aware of anything like that, for this use case, in python, golang, php, or nodejs, which are the languages I regularly work with :)
<ralt>
(unless you count docker bindings...)
<seok>
For example, the case of web scraping, if I want to do anything serious in CL, I need to hand-write running javascript to simulate browser
<ralt>
you mean using chrome-headless?
<seok>
Whereas in node, I can just use puppeteer. This is the reason which made me run node via CL interface in the first place
<seok>
Yeah, writing CL interface to headless chromium is a pretty big jo
ramus has joined #lisp
<seok>
If there was a simpler solution in CL, I wouldn't be running subprocess under node in the first place
<ralt>
writing a CL interface to headless chromium is not a pretty big job, no, it's one uiop:launch-process + one drakma:http-request
<seok>
Where is the API for http control of chromium?
<seok>
I know there is one, but I cannot find it
<seok>
Heck, even interface for selenium is not complete and outdated, let alone chromium
<seok>
I love CL and want to build everything in it, but we should admit that there are a lot of aspects in CL which drives away new developers
<beach>
seok: It is a well known fact that Common Lisp has way fewer users than many other modern languages.
<beach>
It should not come as a surprise to you.
ramus has quit [Ping timeout: 258 seconds]
lavaflow has quit [Ping timeout: 244 seconds]
<no-defun-allowed>
seok: Then they should git gud, or probably git away.
<beach>
seok: So when you say something like that, what do you expect to happen?
<seok>
beach: I want to do away with no-defun-allowed's mindset, because it is not good for the language
<seok>
It only continues the cycle of high learning curve -> less developers -> less / incomplete libraries -> high learning curve
<beach>
seok: I don't think you have any evidence for there being fewer (not "less") developers over time who use Common Lisp.
<seok>
Like all of us in the community, I do believe CL is superior in a lot of ways than other popular languages, but I think we should do away with the arrogance which continues the cycle
<no-defun-allowed>
Or maybe they shouldn't and I was being needlessly cynical, but there's two things...
awolven has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
- they should recognise that not everything goes the Unix way because it's quite dumb, and when CL was standardised Unix hadn't killed off everything else - they should be able to tell the difference between a programming language problem, a library problem, ..., an operating system problem. This is probably the second and the last.
<beach>
seok: If you think a simple change of attitude on the part of Common Lisp programmers will magically attract more developers, I think you ignore recent research in psychology. There are many more, much stronger barriers that will continue to keep most developers away.
scymtym has joined #lisp
<seok>
beach: it is not clear what you mean by those barriers
<seok>
I suspect they are within the cycle I mentioned though
<no-defun-allowed>
And I do reserve the right to be needlessly cynical, because most newbies are more focused on who funds and who programs in a language.
<ralt>
The language itself; parentheses, Emacs being mostly required if you want the expected dev experience (it improved a bit lately but Emacs is still #1), the freedom that the language gives you (programmable programming language is both a blessing and a curse), etc etc
<ralt>
it's not hard to find reasons...
<seok>
Those all can be fixed with more developers though
<seok>
Newbies are wrong. That's why they are newbies
<ralt>
The Emacs thing can be fixed with more developers, but not the rest.
<seok>
But the it does the language much good with more developers, even if they are newbies
jprajzne has quit [Read error: Connection reset by peer]
<seok>
ralt: what other problems do you see drive people away?
<seok>
which cannot be solved by bigger, more active community
<ralt>
speaking of, I discovered manardb lately, it's amazing
jprajzne has joined #lisp
<beach>
seok: I recommend the works by Carol Dweck on the subject.
lavaflow has joined #lisp
<ralt>
I wish it was a bit more advanced (e.g. supporting upgrades), but in and of itself it's pretty great
<beach>
seok: The problem is that it is very unlikely that the number of Common Lisp developers will grow sufficiently fast for your taste.
<seok>
Is it only my taste?
<beach>
I have no problem with the number of Common Lisp developers myself.
<no-defun-allowed>
Probably, I couldn't care less how many people do the things I do.
<beach>
seok: Even with the kindest attitude, a Common Lisp programmer trying to tell a person with many years of investment in a more conventional language that he or she is using a language that is not optimal, and that there are better things out there, will not be believed. And that is because of the strong forces described by Carol Dweck.
ramus has joined #lisp
<seok>
Isn't it in every lisper's favor for CL to be used in more commercial projects, be taught in schools, become more standardized, more lisp jobs, become a practical language rather than just be the theoretical best?
<seok>
If I had thought wrong on that matter, then I was wrong from the beginning
<beach>
seok: It doesn't matter what the answer to that question is, because it just won't happen.
<seok>
I believe it can happen though
<beach>
Good luck!
<seok>
Thanks!
<thijso>
ralt: re: manardb, you mean the one by MSI (about 10 years old)? Looks interesting
<beach>
seok: The sooner you accept the facts, the sooner you will also find better ways of improving our infrastructure, rather than trying to convince more people to use Common Lisp.
<no-defun-allowed>
CL is standardised (see X13J3), is certainly designed to be practical (compare to Scheme), and in today's economy I would rather it isn't used as much, because then there would be a lot less dumb programming jobs as people become more efficient.
<beach>
seok: I gave up trying your strategy a very long time ago. It just doesn't work.
<seok>
I believe it can be done with just a few serious commercial projects which promotes real attention
<heisig>
beach: Your actions betray you :)
<seok>
It doesn't have to be theoretically complex
<seok>
Well, I am a newbie lisper myself, what do I know
<beach>
seok: The only think that I know that sometimes works, is to show that you can come up with good things, hopefully with less effort than other people using other languages. And if you don't believe even that is possible, I think your case in favor of Common Lisp is pretty weak and won't convince anyone.
<beach>
heisig: That ^ I admit trying to do. :)
<seok>
Well, from what I understand in trends, people are not as logical as we make them out to be
<beach>
seok: Exactly. So facts won't bite on them.
<seok>
The reason C became more popular over lisp is not because C is logically "better" language
<heisig>
Maybe we should rebrand Common Lis
<heisig>
p as Python 4
<seok>
Likewise, trend for CL will not start because it is the most efficient language (even if it is), but because of certain traction
<seok>
for example python got a boom thanks to deep learning
<beach>
seok: C is a disaster as a language for writing applications. It came to dominate because Unix was given away for free to universities, thereby exposing many generations to it and only it.
<seok>
Even though it was equally or more viable for deep learning to be implemented in a lot of other languages
<seok>
beach: exactly
<no-defun-allowed>
I don't think Python was designed for heavy computing work, rather more like a scripting tool. All the matrix math magic is done in C or FORTRAN (IIRC).
<beach>
seok: But, as you apparently know, people are not into facts. It's all psychology. Once you understand these forces, you will see that things are not as simple as they might initially seem.
<seok>
no-defun-allowed: yes exactly
<no-defun-allowed>
Then people get confused when you say that CL is a very dynamic language that can also run very efficiently.
<seok>
I started out programming with python, but moved away from it
igemnace has joined #lisp
<no-defun-allowed>
"Facts are nothing on the face of things."
<seok>
beach: that's what I am saying
<no-defun-allowed>
They come with expectations that are not fulfilled, and try to apply them anyway without considering if they're close to being correct.
<seok>
given that more developer is good for the health of the language, we should use means other than perfecting the language itself to promote the language
<no-defun-allowed>
So you can't tell them they're wrong easily.
cosimone has joined #lisp
<seok>
But only if you agree with the premise that more developers is good
georgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<seok>
Yes, having newbies around is difficult, but having newbies around is good in itself
<seok>
It's suffering that must be endured if there are to be more lispers
<seok>
Otherwise, old lispers will die of old age without new lispers to replace them
<Shinmera>
I can't wait to die of old age, personally
<seok>
Hahaha
<seok>
How old is everyone here by the way? Mind if I ask?
<no-defun-allowed>
Some friends and I started a "cooperative" where we do Lisp stuff, and none of us are older than 21 last time I checked.
<seok>
Nice, are you in Uni?
<no-defun-allowed>
Last year of high school.
<seok>
Amazing
amerlyq has joined #lisp
<seok>
I wish I knew lisp while I was in high school
<seok>
my "tech" teacher only made us do C#
<no-defun-allowed>
We were told to use Python a year after I got into serious programming.
<no-defun-allowed>
That's another thing, I don't think school provides good motivation, either, but it's not too relevant to the topic.
<seok>
Yeah, like heck I knew anything about programming in high school
<seok>
Teacher did not know anything either
jonatack has joined #lisp
<no-defun-allowed>
I was drawn to Lisp since the other alternatives I knew were Java (which required a bulky IDE that was too slow on my dinky computer at the time for any serious work), Haskell which I couldn't read, C or C++ which I could read better but couldn't ever get to work, Python which was slow, and BASIC which requires no justification really.
<seok>
Yeah, all the same reason
<seok>
A big selling point for me was syntax though
<seok>
A lot of people don't like lisp syntax but for me it makes more sense than other languages
<ralt>
thijso: yup, it's mmap based mapping to CLOS objects, with transaction support and lot of nifty things. It's pretty neat.
<thijso>
cool, I'll have to take a look at it
<thijso>
when I get my world domination app running, that is...
<thijso>
after, I mean
<seok>
what app are you making?
<thijso>
right now I'm still working on a supporting library, a Kademlia DHT
nanoz has joined #lisp
orivej has joined #lisp
<no-defun-allowed>
Oh, I think I'm ready to put code down to make cl-decentralise2 run a DHT now.
<no-defun-allowed>
My interpretation is most of the complexity is in the client for finding an appropriate node, and even then it's not too hard.
gareppa has joined #lisp
<no-defun-allowed>
(And then how I found Lisp was even weirder, someone that I absolutely cannot stand now posted lispers.org to a forum and it sounded interesting.)
cosimone has quit [Ping timeout: 245 seconds]
georgie_ has joined #lisp
spal_ is now known as spal
ljavorsk has quit [Ping timeout: 268 seconds]
* ebrasca
discovered prog1 and prog2.
esrse has quit [Ping timeout: 244 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
lucasb has joined #lisp
georgie_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Josh_2 has quit [Ping timeout: 246 seconds]
EvW1 has joined #lisp
frgo_ has joined #lisp
bitmapper has joined #lisp
frgo_ has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
frgo has quit [Ping timeout: 246 seconds]
nanozz has joined #lisp
nanoz has quit [Ping timeout: 276 seconds]
georgie has joined #lisp
makomo has quit [Quit: WeeChat 2.4]
ravenous_ has joined #lisp
<_death>
in BBN Lisp, prog2 took only two forms, and progn is described as an extension of it...
ravenous_ has quit [Ping timeout: 252 seconds]
EvW1 has quit [Ping timeout: 250 seconds]
manualcrank has joined #lisp
awolven has joined #lisp
superkumasan has joined #lisp
Josh_2 has joined #lisp
papachan has joined #lisp
bitmapper has quit [Read error: Connection reset by peer]
bitmapper has joined #lisp
lemoinem has joined #lisp
Bike has joined #lisp
zaquest has quit [Remote host closed the connection]
Lord_of_Life has quit [Read error: Connection reset by peer]
EvW has joined #lisp
Lord_of_Life has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
ravenous_ has joined #lisp
frgo_ has quit [Remote host closed the connection]
georgie has quit [Remote host closed the connection]
jhiikj has joined #lisp
jhiikj has left #lisp [#lisp]
LiamH has joined #lisp
georgie has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
<remexre>
flip214: neither of those actually work: loop's across wants a vector, and iterate doesn't have in-array
georgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
papachan has quit [Quit: Leaving]
red-dot has joined #lisp
t58 has joined #lisp
ravenous_ has quit [Ping timeout: 246 seconds]
gareppa has quit [Quit: Leaving]
mindCrime_ has joined #lisp
<_death>
remexre: you can add in-array to iterate.. or you can use a displaced vector (make-array (array-total-size array) :displaced-to array)
schweers has quit [Ping timeout: 250 seconds]
<Shinmera>
or just use array-total-size and row-major-aref
EvW has quit [Ping timeout: 276 seconds]
Inline has joined #lisp
Bahman has quit [Remote host closed the connection]
pjb has quit [Remote host closed the connection]
frgo has joined #lisp
q9929t has quit [Quit: q9929t]
kajo has joined #lisp
libertyprime has quit [Ping timeout: 240 seconds]
<remexre>
_death: oh, didn't know you could use displaced-to that way, I thought they were like slices
sjl_ has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
fragamus has quit [Ping timeout: 246 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
EvW has joined #lisp
<flip214>
remexre: if you want to loop across a multi-dimentional array, you can use (DOTIMES (i (reduce #'* (array-dimensions array))) ...) and a (row-major-aref array i)
makomo has joined #lisp
<heisig>
flip214: You don't like ARRAY-TOTAL-SIZE?
<flip214>
heisig: ah yeah, thanks. I thought there's some function for that, but CLHS ROW-MAJOR-AREF doesn't cross-reference it
fragamus has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
Guest9575 has quit [Ping timeout: 264 seconds]
semz has joined #lisp
LiamH has quit [Ping timeout: 244 seconds]
<Shinmera>
I mean, I literally already posted about it
Kevslinger has joined #lisp
<_death>
I usually just nest dotimes
<flip214>
Shinmera: sorry, got distracted and didn't read all the new lines before completing mine.
smazga has joined #lisp
<Shinmera>
I shall forgive your transgression... for now.
<flip214>
thank you so much! in exchange, I'll have a coffee for you at sbcl20.
<Shinmera>
I'd like to go, but I don't know if I can. Austria is close to me, but it's right during busy university time.
gxt has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 276 seconds]
gxt has joined #lisp
<flip214>
I won't rat you out
<Shinmera>
I don't have attendance requirements, so that's not what I'm worried about :)
<flip214>
come in via train on Saturday, leave on Tuesday evening...
<_death>
you can simply leave evaluation of it to the expanded code
<Bike>
maykbe you loaded the file instead of compiling it.
<seok>
Now I am loading the file its showing error
<Bike>
also yeah, if with-mongo-connection evaluates those arguments you don't need them in the macro
<Bike>
and having them in the macro might have weird problems if they're complex objects
<seok>
Ah, should I just make it a function?
<seok>
It is just short form to write with-mongo-connection
<seok>
Hm I don't think it will work as a function
<Bike>
no, just have the macro have +mongo-port+ instead of ,+mongo-port+
<seok>
Ah!
<seok>
Makes sense
kajo has quit [Ping timeout: 276 seconds]
<seok>
Nice, thank you!
<katco>
Xach: i was playing with zs3 and digitalocean's spaces last night. i am unsure if i have the time, but are you open to new issues? prs? is the project still being maintained?
user___ has quit [Ping timeout: 240 seconds]
kajo has joined #lisp
<flip214>
Bike: but defering constant macro constant expansion to compile time makes the comparison to C++ compile times worse! Raaaaah! ;)
<dlowe>
hard to compare compile times meaningfully when you can insert arbitrary computation into your compiler
gareppa has joined #lisp
vap1 has quit [Read error: Connection reset by peer]
tumdum has joined #lisp
tumdum has quit [Changing host]
tumdum has joined #lisp
tumdum has quit [Client Quit]
tumdum has joined #lisp
tumdum has quit [Changing host]
tumdum has joined #lisp
sigjuice has joined #lisp
user___ has joined #lisp
vaporatorius has joined #lisp
femi has quit [Ping timeout: 245 seconds]
sjl_ has quit [Ping timeout: 244 seconds]
salinasc has joined #lisp
Lycurgus has joined #lisp
dale has quit [Quit: dale]
stepnem_ has quit [Ping timeout: 245 seconds]
flamebeard has quit []
stepnem has joined #lisp
dmiles has quit [Ping timeout: 246 seconds]
salinasc has quit [Ping timeout: 276 seconds]
dmiles has joined #lisp
awolven has quit [Ping timeout: 258 seconds]
vaporatorius has quit [Read error: Connection reset by peer]
rippa has joined #lisp
EvW has quit [Ping timeout: 264 seconds]
rippa has quit [Read error: Connection reset by peer]
amerigo has quit [Quit: Connection closed for inactivity]
frgo_ has joined #lisp
rippa has joined #lisp
frgo has quit [Ping timeout: 245 seconds]
frgo_ has quit [Ping timeout: 276 seconds]
<thijso>
So, how can threads make usocket:wait-for-input barf? I have minimal code, depending on verbose and usocket, and when I open a UDP socket (socket-connect) and then do (usocket:wait-for-input ..) with some error logging, every second or so I get: "got error #<a USOCKET:UNKNOWN-ERROR>; restarting server in 0.1 second"
mnasoft has joined #lisp
<thijso>
This is on ECL, btw. I know verbose starts up a controller thread ( #<process "verbose-thread" 0x55f6f1219d00> ) but I'm not seeing how this can interfere with the socket.
<Bike>
that doesn't make any sense with what the :type option means.
chipolux has quit [Client Quit]
q9929t has joined #lisp
<Bike>
it means an "instance" of foo is actually a bit vector. so of course it can't have a slot that's another bit vector, its slots can only be bits
<remexre>
oh, hm
<Bike>
what did you think :type did?
<Bike>
i'm talking about the defstruct :type, not the defstruct slot :type, just to be clear. they're different things
<remexre>
I want a subtype of bit-vector I guess
<remexre>
I thought it made it a subtype, so it'd "inherit" all the functions of the representation
<Bike>
But with more slots or something? No, there's no capability to subclass built in classes in the language.
<remexre>
hm
ggole has quit [Quit: Leaving]
<Bike>
it would decrease efficiency.
<remexre>
I guess what I /really/ want
chipolux has joined #lisp
<remexre>
is to have some bit-vectors print as different things
Lycurgus has quit [Quit: Exeunt]
<remexre>
like I might want one to be a hex string, another to be an IP address, etc
q9929t has quit [Quit: q9929t]
<Bike>
Would it be possible for you to use different printing functions in different contexts? Like call print-as-ip instead of print.
<Bike>
If not, you might be able to manage it with the pretty printer but it'll be kind of weird.
<remexre>
possible-but-inconvenient :P
<Bike>
life is like that sometimes
gxt has joined #lisp
<remexre>
yeah...
<Bike>
You could also make an object that wraps bit vectors, i.e. has a slot that's a bit vector, and have it print however.
<Bike>
the penalty is the indirection, obviously
<remexre>
I'm doing something evil with the values though, so I need e.g. aref to work on the object
hiroaki has joined #lisp
<Bike>
Have you considered being less evil?
<beach>
remexre: It is very strange to hijack the built-in functions like the printer and AREF and such for application purposes.
<Bike>
or define your own aref like function, etc.
<beach>
remexre: Your application should build its own types, and its own protocol functions for those types.
<beach>
remexre: You can consider an array (including a bit vector) to be a "concrete data type", i.e. it is meant to be used for implementing abstract data types for your application to manipulate.
<beach>
remexre: So, again, it is very strange to just import the built-in concrete data types as your application types, and then try to twist the way these built-in concrete data types are accessed, printed, etc.
<Bike>
mhm. makes you fight the system.
<remexre>
Bike: heh, it's not /that/ evil
<remexre>
Unification on arbitrary values
<Bike>
if it's causing you problems you might want to consider its evilness is an unironic way
<Bike>
unification like logic? what does that have to do with ip addresses
<remexre>
Work thing :p
<Bike>
if you tell me something is evil, and that it's causing you problems, but you don't elaborate beyond that, i'm pretty much going to have to stop at "don't do the evil thing"
<remexre>
Fair
mindCrime_ has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
\emph{grumble} has quit [Quit: \end{document}]
pjb has joined #lisp
adom` has joined #lisp
grumble has joined #lisp
sjl_ has joined #lisp
awolven has joined #lisp
sjl_ has quit [Quit: WeeChat 2.3-dev]
<katco>
Xach: ok, thanks. i've only done a cursory examination, but i think it might be an issue with the unmarshaling of xml being inflexible. are you open to prs? or issue first, with some discussion?
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
gareppa has quit [Quit: Leaving]
<Xach>
I'd rather discuss.
Lycurgus has joined #lisp
sameerynho has joined #lisp
<katco>
ok, sounds good. thank you for responding.
ravenous_ has joined #lisp
vlatkoB has quit [Remote host closed the connection]
<thijso>
Shinmera: I'm looking at verbose again, and run into another error on ECL, namely when I stop the *global-controller* it gives a SIMPLE-ERROR with the msg: "Cannot interrupt the inactive process #<process verbose-thread 0x5556eee81700>"
<thijso>
Maybe I should just give up. Something in my stack just seems not mature enough to use. ECL, bordeaux-threads, usocket, verbose, I don't know.
<thijso>
I have a feeling it's actually ECL, but I could be wrong. I'm surely not the only one trying to use it for something more than just playing around...
sauvin has quit [Read error: Connection reset by peer]
bitmapper has joined #lisp
heisig has joined #lisp
xkapastel has joined #lisp
VHOST_ is now known as vhost-
Necktwi has quit [Quit: leaving]
khrbt has quit [Ping timeout: 258 seconds]
hh47 has joined #lisp
bitmapper has quit [Remote host closed the connection]
bitmapper has joined #lisp
makomo has quit [Quit: WeeChat 2.4]
cosimone has quit [Quit: Leaving]
bitmapper has quit [Ping timeout: 240 seconds]
aautcsh has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
hh47 has quit [Remote host closed the connection]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
kajo has quit [Ping timeout: 276 seconds]
<_death>
remexre: actually you can easily extend the pretty printer to print such objects in a special way
cosimone has joined #lisp
<_death>
remexre: the pretty printer function can discriminate objects in any way you see fit, so for example you look them up in some registry to know their semantic type..
ravenous_ has quit [Remote host closed the connection]
nanozz has quit [Ping timeout: 240 seconds]
ravenous_ has joined #lisp
mindthelion has joined #lisp
Boubert has joined #lisp
techquila has quit [Ping timeout: 276 seconds]
Boubert has quit [Client Quit]
scymtym has joined #lisp
ravenous_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
raghavgururajan has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
<_death>
there are limits in your use case though.. for example if you (copy-seq ip-address) the resulting vector will print ordinarily
shka_ has quit [Ping timeout: 246 seconds]
cosimone has quit [Remote host closed the connection]
madand has joined #lisp
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone has quit [Quit: Leaving]
ldb has joined #lisp
<ldb>
sup
superkumasan has quit [Ping timeout: 246 seconds]
<thijso>
Why do I get a TYPE-ERROR in identical code when I switch from (declaim (space 1)) to (space 2)?
<Bike>
space declarations could affect how the compiler inserts type checks in some way
amerlyq has quit [Quit: amerlyq]
gareppa has joined #lisp
<thijso>
Yeah, so then I would expect to get *more* TYPE-ERRORs with lower priority to space, right?
<thijso>
That's what confuses me
<Bike>
it could go either way.
<thijso>
Apparently it's not that simple
<Bike>
it's not defined or anything.
<thijso>
Yeah, I see
EvW has joined #lisp
<Bike>
Or for example, with higher priority on space, it might try actually enforcing dynamic-extent declarations it didn't before, which might entail being stricter about some types so it knows what sizes to allocate
<Bike>
who knows
Josh_2 has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
varjag has joined #lisp
ldb has quit [Ping timeout: 276 seconds]
eich has quit [Ping timeout: 240 seconds]
<remexre>
_death: huh, okay, I'll look into it
<remexre>
thanks
madand has quit [Ping timeout: 246 seconds]
bitmapper has joined #lisp
eich has joined #lisp
x[LGWs4x4i]uG2N0 has quit [Remote host closed the connection]
gareppa has quit [Quit: Leaving]
eich has quit [Ping timeout: 246 seconds]
Oladon has joined #lisp
Oladon1 has quit [Ping timeout: 245 seconds]
Oladon_wfh has quit [Ping timeout: 260 seconds]
Lord_of_Life_ has joined #lisp
eich has joined #lisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
kajo has joined #lisp
ravenous_ has joined #lisp
ravenous_ has quit [Ping timeout: 246 seconds]
user___ has quit [Ping timeout: 245 seconds]
<thijso>
So, I have an issue with usocket, bordeaux-threads, and ECL. A blocking (or with timeout) call to usocket:socket-receive will give an USOCKET:UNKNOWN-ERROR if there is a bt:condition-wait call being done with a timeout on a different thread.
<thijso>
For some reason the timeout on the condition-wait is interrupting the call to socket-receive.
<fe[nl]ix>
the implementation uses with-timeout, so that seems a likely culprit
heisig has quit [Ping timeout: 276 seconds]
<thijso>
Yeah, I'd found that code too.
<thijso>
I also see an issue in ECL that might have something to do with this. The line "but the short answer is that alarm is delivered to the signal servicing thread during handling another thread." is making me suspicious. This is in https://gitlab.com/embeddable-common-lisp/ecl/issues/420
parisienne has joined #lisp
<fe[nl]ix>
thijso: check if ECL implements timeouts natively nowadays
<fe[nl]ix>
that code is old and might be obsolete
lucasb has quit [Quit: Connection closed for inactivity]
stepnem has quit [Ping timeout: 258 seconds]
<fe[nl]ix>
indeed, it's 6 years old
kamog has joined #lisp
Oladon_wfh has joined #lisp
vms14 has joined #lisp
awolven has quit [Ping timeout: 245 seconds]
stepnem has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
jprajzne has quit [Remote host closed the connection]
<gordonfish>
I was just reading that page but the examples look a little different from what I normally see.
<White_Flame>
that's scheme, not common lisp
fragamus has quit [Ping timeout: 268 seconds]
<gordonfish>
ah
<edgar-rft>
gordonfish: the tutorial says "I should specify that this test is based on WeScheme."
<gordonfish>
Yeah I see that, some how I missed that part
<gordonfish>
(The title up top is a bit misleading)
<gordonfish>
(Sort of like saying "learn C" but it's actually C++ or C#, heh)
cosimone has quit [Quit: Leaving]
ldb has quit [Ping timeout: 276 seconds]
<edgar-rft>
gordonfish: Lots of people (like the author of that tutorial) confuse Lisp and Scheme :-) Scheme is technically a LIsp dialect, but the Common Lisp standard was meant to unify all other Lisps into a single Lisp language. Nontheless Scheme still has an active community on #scheme.
Bike has joined #lisp
vaporatorius has quit [Read error: Connection reset by peer]
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
vaporatorius has quit [Read error: Connection reset by peer]
eich has joined #lisp
moldybits has quit [Quit: WeeChat 2.4]
<adom`>
Hi! I'm wondering about concatenating arrays with concatenate. Is it more efficient in runtime than setting each element to each corresponding index? Where can I find information about that kind of thing?
<gordonfish>
edgar-rft: I see. Thanks for that, that does help clear thigns up :)
<no-defun-allowed>
Unless the array has a fill pointer and can fit both array's active elements, I don't believe you can "set each element" since there would be no room for the other array's elements.
<adom`>
In my case it's an array that has a predetermined size
<adom`>
And then I want to delete an element from some index and then fill the space it was in. And move each element by one.
<no-defun-allowed>
And you can probably assume NCONCATENATE is faster than CONCATENATE ever so slightly because it may use the first array as storage instead of allocating a new one (which is basically just incrementing a pointer on most implementations).
<no-defun-allowed>
Hm, it's probably faster to set the elements yourself then.
Aruseus has joined #lisp
<adom`>
Oh really!? Huh I wouldn't have expected that.
fragamus has joined #lisp
<no-defun-allowed>
So you're doing something like (concatenate 'vector (subseq vector 0 n) (subseq vector n))?
<adom`>
yeah
<adom`>
I guess I can just try it with a massive array :P
<Bike>
each of the subseqs will make a new vector, unless the compiler is really smart
<Bike>
so doing it yourself is probably better
<no-defun-allowed>
Yeah, you'd be iterating over the array three times (or two if you count each subseq as "half").
<adom`>
ohh
<adom`>
wow
MrBusiness3 has joined #lisp
MrBismuth has quit [Ping timeout: 250 seconds]
<adom`>
bc it's like a cons? with a head of one element and a tail with all of the rest?
<Bike>
no?
<adom`>
oh :P sorry
<Bike>
vectors are vectors, it's probably contiguous memory under the hood
<no-defun-allowed>
No, a vector is layed out as contiguous memory (on a self-respecting implementation) and each element takes O(1) time to aref.
<Bike>
anyway, you can make a vector of 1- the length of your starting vector, and then call replace twice
<Bike>
then you'll only allocate the one vector
<no-defun-allowed>
But to subseq, the implementation would probably make the new vector, loop over the old elements and set the elements of the vector.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<no-defun-allowed>
To concatenate, the implementation would make the new vector with size the sum of the input vectors and loop over those elements too.
alexanderbarbosa has quit [Ping timeout: 276 seconds]
<adom`>
oh I see. I was misreading. You were just saying 2 new vectors (1 for each subseq... it's very clear now)
<no-defun-allowed>
All up, it'd iterate over the vector length twice, as opposed to just once (worst case, or half in the average case).
<Bike>
with the concatenate subseqs you'd actually have three new vectors, since concatenate makes one too
<adom`>
sorry I'm slightly behind.
<adom`>
So the main cost isn't iterating, it's creating these new vectors?
<Bike>
well they're both costly.
<adom`>
I'm still unclear on whether concat/replace is just doing the same iteration I would do
<adom`>
gotcha gotcha
<Bike>
the concatenate function essentially: gets the lengths of all the sequences, makes a new sequence with the summed length, and then iterates over the sequences.
<no-defun-allowed>
I still believe iterating over the vector an average of two times rather than half of the vector is the slowest part.
<Bike>
i mean the concatenate subseq thing is worse with either consideration
<no-defun-allowed>
Yeah.
<adom`>
Okay, so it sounds like I'll just iterate over half and move them myself.
smazga has quit [Quit: leaving]
<no-defun-allowed>
Are you removing one element, or possibly a few?
<adom`>
Thanks bike/no-defun-allowed. But yeah, is there documentation that says this kind of thing clearly? Like the O(n) of different builtins?
<adom`>
Just one
<no-defun-allowed>
Then (remove item vector :count 1) could be less of a hassle too.
<adom`>
I'll look into that
<Bike>
well, subseq is described as making a new sequence
<Bike>
there aren't any mandated O times in the standard, i don't think
<aeth>
adom`: you don't need to iterate, either. If what you're doing is what no-defun-allowed said and it's (concatenate 'vector (subseq vector 0 n) (subseq vector n)) then you can just use replace twice to skip having the inefficient subseq and to skip having to manually iterate
<pjb>
Now, you could displace sequences to arrays, and concatenate the sequence, then displace an array to the resulting sequence. But you would have to find some consistent dimensions.
<pjb>
Finally if you are considering sequences, try to implement concatenate yourself, and see if you can find a more efficient way to do it.
<pjb>
If you don't want to implement concatenate yourself, you can always go have a look at the sources of your implementation.
<adom`>
I haven't really gone through the basics yet, so it wasn't obvious to me that a vector was not a sequence. I should definitely learn that stuff though.
<adom`>
And yeah, checking the source of my implementation definitely seems like the way to answer my question
<pjb>
This is because a vector is a sequence.
<adom`>
but not an array. array =/= vector
<adom`>
?
<adom`>
(I'll go look all of this up)
<adom`>
(I don't want to waste ppl's time)
<pjb>
adom`: well, checking the source of your implementation is a nice way to get some idea, but it is also dangerous, because you will see one specific implementation, but Common Lisp is a language, and several different implementations are possible.
<pjb>
a vector IS an array too!
<pjb>
multiple-inheritance.
<pjb>
adom`: now, the CLHS doesn't specify in general the algorithms or the complexities of the operators. Only for a few operators, some hints or some restrictions are given. But since there are several competing implementation, they will often use the best algorithms they can.
<aeth>
adom`: a vector is a 1D array.
<aeth>
adom`: a vector is also a sequence. arrays that are 0D or 2+D aren't sequences
<pjb>
adom`: as indicated, the constraint on concatenate, is that it must return a new sequence. Therefore the only overhead, beside copying, is that it must allocate the space of the result. The advantage is that it's purely functional: you will be able to mutate the result without having an impact on the pre-existing sequences.
<pjb>
(this is not the case eg. with APPEND).
<aeth>
This differs from how some other programming languages handle this. For instance, in C++ a vector basically an adjustable vector in CL terminology and there are C arrays and there are new std::arrays and, well, C++ probably was a poor choice of comparison
<pjb>
adom`: you may design an algorithm where you could pre-allocate the space of the result, and use REPLACE instead of CONCATENATE to store it repeatitively, without having to allocate it each time.
<aeth>
Unlike some languages, CL has true multi-dimensional arrays. You don't need to put an array-in-an-array, or use 1D arrays with special accessors to pretend that it's 2D (or more)
Aruseus has quit [Remote host closed the connection]
<pjb>
adom`: you can also use a vector with a fill-pointer if the result size may change, or an adjustable array if it may extend what you pre-allocated.
orivej has quit [Ping timeout: 276 seconds]
chipolux has quit [Quit: chipolux]
<aeth>
And vectors that aren't special in that sense are 1D simple-arrays, but not necessarily simple-vectors, because simple-vectors have to be T 1D simple-arrays, iirc.
<aeth>
a (simple-array T (3)) is a (simple-vector 3)
<aeth>
Probably the only really confusing part about vectors vs. arrays
<pjb>
adom`: that's old. Pascal had them already in 1970.
iovec has joined #lisp
<pjb>
Pascal even has array with user-specified bases instead of just 0.
<dlowe>
you can even use enums iirc
<aeth>
from the perspective of the type system, arrays have three relevant components: simple or not, the type they can hold, and the dimensions. 1D arrays no matter what are vectors (and vectors are sequences). simple-arrays are simple arrays, and simple-vectors are T simple vectors, not just simple vectors. The length (or dimensions) is part of the type, but usually it's * for anything and often even that is optional.
<pjb>
indeed.
<dlowe>
like type[foo...bar] or however it is
<pjb>
But, in CL, I can implement such arrays if I need them! :-)
<aeth>
And in case the "type" thing is unclear, an array/vector that holds T holds anything, since any type is a subtype of T (except NIL, but nothing is of type NIL, even the object nil is of type NULL, and not of type NIL).
<adom`>
(thanks, that was indeed unclear)
<aeth>
(The standard mandates character (1D character arrays are strings... yes, strings are just vectors) and bit, but practically speaking (unsigned-byte 8), informally octet, is near-mandiatory. Other integer sizes vary, but are usually included if they're signed/unsigned 8 16 32 64 as well as fixnum, and single-float/double-float are included in everything but CLISP.)
<aeth>
(You'll also see base-character, etc. The pattern is that it's basically just for numbers and characters.)