sz0_ has quit [Quit: Connection closed for inactivity]
markong has joined #lisp
margeas has quit [Ping timeout: 246 seconds]
<phoe>
(concatenate 'string ...) the mapcar'd results
<phoe>
it will work for short lists
<phoe>
if you want longer lists, then go for a custom concatenator whom you feed a list of strings, which makes a fresh string of length (reduce #'+ strings :key #'length) and then copy-seqs each string into its respective place inside the result string.
nullman has quit [Ping timeout: 240 seconds]
nullman has joined #lisp
jfb4 has quit [Ping timeout: 248 seconds]
margeas has joined #lisp
jfb4 has joined #lisp
<borei>
i'm implementing basic linear algebra library, was working on the matricies arithmetic operations - like '+', '-', multiplication by number, but COMMON-LISP package already has that operation defined as ordinary functions, does it mean that i can't use above operation normally like for example in C++ ? without package prefix like cl:+ ?
markong has quit [Ping timeout: 256 seconds]
attila_lendvai42 has quit [Quit: Leaving.]
pilfink has quit [Ping timeout: 248 seconds]
margeas has quit [Ping timeout: 264 seconds]
<Xach>
borei: that's about right, if you shadow cl:+ etc
FreeBirdLjj has joined #lisp
<borei>
but i can't completely shadow it, because i still need to add numbers
<borei>
seems like best approach would be introduction of alphanumerical functions names like - add, subtract, mult, divide etc
damke_ has joined #lisp
FreeBirdLjj has quit [Ping timeout: 265 seconds]
itruslove has quit [Ping timeout: 276 seconds]
jonh has left #lisp ["WeeChat 0.4.2"]
damke has quit [Ping timeout: 264 seconds]
antoszka has quit [Ping timeout: 276 seconds]
antoszka has joined #lisp
itruslove has joined #lisp
felideon has quit [Ping timeout: 276 seconds]
jameser has joined #lisp
epony has quit [Remote host closed the connection]
felideon has joined #lisp
jstypo has joined #lisp
Oladon has joined #lisp
<Xach>
borei: "shadow" in the lisp sense means what happens when you use a package but don't want to use it all
JuanDaugherty has quit [Quit: Ex Chat]
nirved has quit [Quit: Leaving]
epony has joined #lisp
Bike has joined #lisp
JonSmith has quit [Remote host closed the connection]
epony has quit [Max SendQ exceeded]
epony has joined #lisp
groovy2shoes has quit [Ping timeout: 265 seconds]
varjag has joined #lisp
<jasom>
Shinmera: all I know is that whatever heuristic sbcl uses for invoking the GC doesn't usually do what I want. I typically invoke the GC manually
smasta has joined #lisp
groovy2shoes has joined #lisp
JonSmith has joined #lisp
varjag has quit [Ping timeout: 248 seconds]
JonSmith has quit [Ping timeout: 248 seconds]
varjag has joined #lisp
varjag has quit [Ping timeout: 256 seconds]
test1600 has joined #lisp
<aeth>
borei: If you're writing a linear algebra library and you want generic arithemtic operators, you probably want to use specialization-store by pillton instead of writing your own macros. https://github.com/markcox80/specialization-store/
<aeth>
You *might* be able to use it to still call cl:+ for types that cl:+ supports, with most of the work done for you.
ebrasca has joined #lisp
<aeth>
specialization-store basically lets you define functions that work in (roughly) the same way as the built-in CL functions that are generic over sequences or numbers. Runtime dispatch on unknown types, but more efficient code if the types are known.
<aeth>
(This only happens when inline, but if you want a middle ground for more complex functions that probably shouldn't be inline, you could define functions that are called by inline specializations.)
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 248 seconds]
<aeth>
(And you'd probably want to wrap that function call in (the foo-type ...) if the return type is known)
igemnace has joined #lisp
<aeth>
(Actually, it'd be great if specialization-store had something like :inline-function-call that did this automatically.)
<ebrasca>
No applicable methods to generic function #<Standard-Generic-Function PARSE-NAMESTRING-USING-HOST 400000002539> (PARSE-NAMESTRING-USING-HOST) when called with (#<Mezzano.Fat32-File-System::Fat32-Host 400001E51469> ">Fonts>LICENSE" NIL).
<ebrasca>
What does it mean?
<Bike>
parse-namestring-using-host is a generic function, and it doesn't have any methods that would fit the classes of those objects.
<jasom>
ebrasca: looks like a mezanno specific thing froggey can help maybe?
damke has joined #lisp
<ebrasca>
jasom: ok
<aeth>
Bike: Is it possible to write hygienic macros in CL without any libraries? If not, is it possible to write hygienic macros in CL with introspect-environment? Or is there some vital information missing? https://github.com/Bike/introspect-environment
<aeth>
The main thing I know about hygienic macros is that they require knowledge of the environment.
esthlos has quit [Remote host closed the connection]
esthlos has joined #lisp
esthlos has quit [Remote host closed the connection]
esthlos has joined #lisp
smaster has joined #lisp
smasta has quit [Ping timeout: 260 seconds]
pagnol has quit [Ping timeout: 248 seconds]
<aeth>
hmm... I might actually write cl-cl after cl-scheme.
<aeth>
Here's why: I think I could actually produce faster CL code by generating CL code from CL code since cl-cl would be able to analyze the whole program and essentially automatically apply little optimization tricks.
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
openthesky has quit [Quit: Page closed]
warweasle has joined #lisp
fortitude_ has joined #lisp
fikka has joined #lisp
<asarch>
"Today, I want to use CLISP instead of SBCL" <- Is there any way to start SLIME with a different Lisp?
<sigjuice>
asarch: C-u M-x slime
<ebrasca>
asarch: I think with (setq inferior-lisp-program "clisp")
reverse_light has joined #lisp
<asarch>
ebrasca, yeah but from a different lisp from .emacs file
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<sigjuice>
asarch: the Run Lisp: prompt in the minibuffer should also have history, accessible by <up>/<down>
<raynold>
ahh it's a wonderful day
test1600 has quit [Ping timeout: 240 seconds]
d4ryus has quit [Ping timeout: 264 seconds]
<asarch>
Thank you guys
<asarch>
Thank you very much :-)
nkfx has joined #lisp
<sigjuice>
This is also super convenient for trying out a different version of an SBCL binary release. There is no need to "install" anything. C-u M-x slime ~/sbcl-1.4.3-x86-linux/run-sbcl.sh RET
red-dot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
nkfx has quit [Quit: leaving]
orivej has joined #lisp
smurfrobot has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
<asarch>
Thank you
<asarch>
What is the correct way to exit from Slime?
smurfrobot has quit [Ping timeout: 268 seconds]
<sigjuice>
asarch I am not sure. I was wondering the same thing myself a couple of days ago.
<ebrasca>
asarch: Maybe " M-x slime-quit-lisp "
<asarch>
Because "Do you want to kill to process?" is quite terrible
turkja has joined #lisp
<sigjuice>
ebrasca thanks!
<sigjuice>
hmm. seems to leave behind a dead *slime-repl sbcl* buffer.
<asarch>
You can kill it with C-x k
<asarch>
Thanks ebrasca
jstypo has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
<sigjuice>
Also leaves behind a *slime-events* buffer. C-h f slime-quit-lisp RET says "Quit lisp, kill the inferior process and associated buffers.".
felideon has quit [Ping timeout: 276 seconds]
felideon has joined #lisp
RichardPaulBck[m has quit [Ping timeout: 276 seconds]
cryptomarauder has quit [Ping timeout: 276 seconds]
<sigjuice>
I have way too many buffers, so an extra couple here or there doesn't bother me :)
smurfrobot has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 240 seconds]
jstypo has joined #lisp
FreeBirdLjj has joined #lisp
orivej has joined #lisp
RichardPaulBck[m has joined #lisp
cryptomarauder has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
damke has joined #lisp
sjl has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
sjl has quit [Ping timeout: 268 seconds]
khisanth_ has quit [Ping timeout: 260 seconds]
varjag has joined #lisp
Oladon has quit [Quit: Leaving.]
d4ryus1 has joined #lisp
wigust has quit [Ping timeout: 248 seconds]
varjag has quit [Ping timeout: 260 seconds]
pierpa has joined #lisp
khisanth_ has joined #lisp
lemoinem has quit [Read error: Connection reset by peer]
lemoinem has joined #lisp
<jmercouris>
does anyone use mezzano as their primary os?
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
nika has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
<ebrasca>
jmercouris: Probably not used as primary os , but I can start mezzano in my PC bare metal.
warweasle has quit [Quit: Leaving]
quazimodo has joined #lisp
ircbrowse has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 248 seconds]
<jmercouris>
no way? that's amazing
<jmercouris>
did you have to write your own drivers?
ircbrowse has joined #lisp
sz0_ has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Patzy has quit [Ping timeout: 240 seconds]
Patzy has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
JonSmith has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
<ebrasca>
jmercouris: I have don't write my own drivers.
JonSmith has quit [Ping timeout: 248 seconds]
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
mhd has quit [Ping timeout: 265 seconds]
misv has quit [Ping timeout: 240 seconds]
misv has joined #lisp
<beach>
Good morning everyone!
Kaisyu7 has joined #lisp
brandonz has quit [Quit: WeeChat 2.0]
<ebrasca>
beach: Good morning
fikka has joined #lisp
smurfrobot has joined #lisp
Oladon has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
ebrasca-mezzano has joined #lisp
<ebrasca-mezzano>
Hi
ebrasca-mezzano has quit [Client Quit]
schoppenhauer has quit [Ping timeout: 265 seconds]
schoppenhauer has joined #lisp
orivej has joined #lisp
<aeth>
Is it possible to use static-vectors (which appears to be terribly documented) to allocate a big chunk of memory and use a subset of it? This appears to be very possible in C: static-vector-pointer has an offset parameter, which is either in bits or bytes (again, terrible documentation... I'm guessing bytes?) so the byte size given in cffi:foreign-type-size definitely can work there.
orivej has quit [Ping timeout: 264 seconds]
<aeth>
(Although it looks like making an offset pointer appears to be a complicated, consing process)
turkja has quit [Ping timeout: 276 seconds]
pankracy has quit [Ping timeout: 240 seconds]
pankracy has joined #lisp
Bike has quit [Quit: Lost terminal]
<pierpa>
looks like an implementation specific question
<aeth>
It looks like in SBCL's implementation part, you *can*, but not in general.
<aeth>
So one possibility would be to patch it to make it work in general, but another possibility is to just work with offsets.
shka has joined #lisp
<aeth>
So some range
<aeth>
I think an issue with working with a range, though, is that the function could bounds check each aref, which could become expensive for a large range (e.g. 16)
schasta has joined #lisp
<aeth>
At least in the SBCL I am on, not only does it have an INVALID-ARRAY-INDEX-ERROR for each index, it also doesn't appear to be smart enough to remove those checks automatically if I first do a manual length check
SuperJen has quit [Ping timeout: 240 seconds]
pierpa has quit [Quit: Page closed]
smaster has quit [Ping timeout: 264 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
broccolistem has quit [Ping timeout: 268 seconds]
<pillton>
That problem is hard.
red-dot has joined #lisp
<pillton>
I created the operator unsafe-row-major-aref for that purpose.
varjag has joined #lisp
<aeth>
well, now I have a problem.
<aeth>
The function is 1253 bytes when it knows the length, so inlining is out of the question
orivej has joined #lisp
<aeth>
Without known lengths, it's 5834 bytes.
varjag has quit [Ping timeout: 248 seconds]
<aeth>
It looks like it does 143 bounds checks
<aeth>
s/143/144/
<aeth>
That could be replaced with just 3 if safety is 0, which people say never to do
<aeth>
(3 manual bounds checks)
wigust has joined #lisp
<pillton>
Replace the aref with unsafe-aref so the (safety 0) is limited to an area.
<pillton>
i.e. (locally (declare (safety 0)) (aref ...))
<aeth>
aha
<aeth>
that keeps the other elements of the safety, which declaring the whole function unsafe would not do
<aeth>
smart idea
<pillton>
There are references in the book "Types and Programming Languages" by Pierce which discuss the subject of automatically removing array bound checks.
mathrick has joined #lisp
<aeth>
What's the correct way to manually do my own bounds checking?
<pillton>
Before any loops?
<aeth>
I guess if it's always a fixed size range only give the starting point of the range, and check that the (> (length foo) (+ start range-length))
<aeth>
but should I throw an error?
<pillton>
What else would you?
turkja has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
orivej has joined #lisp
asarch has quit [Quit: Leaving]
FreeBirdLjj has joined #lisp
<aeth>
Well, I could do something fancier. Is there something like this? #-(safety 0)
<aeth>
because otherwise it would perform worse with global safety 0 because it forces some limited bounds checks that otherwise wouldn't be there
<aeth>
pillton: I mean, is there a way to only do something when safety > 0?
<pillton>
I think CLtL2 has support for inspecting optimize declarations.
<aeth>
Otherwise, if the program is compiled with (safety 0) I will have accidentally introduced some safety to it
<pillton>
I'm happy to live with that decision.
brandonz has joined #lisp
jmercouris has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
chens has joined #lisp
vtomole has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 265 seconds]
smurfrobot has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 252 seconds]
orivej has quit [Quit: No Ping reply in 180 seconds.]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
orivej has joined #lisp
red-dot has joined #lisp
fortitude__ has joined #lisp
xrash has quit [Remote host closed the connection]
fortitude_ has quit [Ping timeout: 260 seconds]
larme has quit [Ping timeout: 252 seconds]
damke_ has joined #lisp
LocaMocha has joined #lisp
mishoo_ has joined #lisp
damke has quit [Read error: Connection reset by peer]
vibs29 has quit [Ping timeout: 248 seconds]
damke has joined #lisp
vibs29 has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
damke_ has quit [Ping timeout: 263 seconds]
Karl_Dscc has joined #lisp
oleo has quit [Quit: Leaving]
sjl has joined #lisp
Oladon has quit [Quit: Leaving.]
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
sjl has quit [Ping timeout: 240 seconds]
larme has joined #lisp
dec0n has joined #lisp
smurfrobot has joined #lisp
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
damke has joined #lisp
scymtym has quit [Ping timeout: 248 seconds]
fouric has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fouric has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
cromachina has quit [Read error: Connection reset by peer]
varjag has joined #lisp
damke has quit [Ping timeout: 246 seconds]
damke has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
varjag has quit [Ping timeout: 264 seconds]
shifty has quit [Ping timeout: 260 seconds]
damke_ has joined #lisp
damke has quit [Ping timeout: 246 seconds]
mishoo_ has quit [Ping timeout: 268 seconds]
Karl_Dscc has quit [Remote host closed the connection]
damke has joined #lisp
varjag has joined #lisp
shka has quit [Read error: Connection reset by peer]
shka has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
varjag has quit [Ping timeout: 240 seconds]
flamebeard has joined #lisp
dvdmuckle has quit [Quit: Bouncer Surgery]
dvdmuckle has joined #lisp
otwieracz has joined #lisp
Cthulhux has joined #lisp
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jameser has joined #lisp
varjag has joined #lisp
mishoo has joined #lisp
xaotuk has joined #lisp
Murii has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
jfb4 has quit [Ping timeout: 264 seconds]
<phoe>
pillton: correct, it has a mechanism for that, you can use its functions inside macros.
<phoe>
because you'll have the env object there.
<Shinmera>
borei: Any reason you're implementing yet another linalg system?
fikka has joined #lisp
<Shinmera>
Instead of using one of the dozens that are already out there
vhost- has quit [Ping timeout: 260 seconds]
vhost- has joined #lisp
jfb4 has joined #lisp
shaftoe has joined #lisp
pfdietz has quit []
<jdz>
Your regular reminder: don't use (SAFETY 0).
xaotuk has quit [Ping timeout: 255 seconds]
fortitude_ has joined #lisp
varjagg has joined #lisp
fortitude__ has quit [Ping timeout: 268 seconds]
varjagg has quit [Ping timeout: 240 seconds]
d4ryus1 is now known as d4ryus
QualityAddict has quit [Ping timeout: 264 seconds]
jfb4 has quit [Ping timeout: 248 seconds]
vhost- has quit [Ping timeout: 248 seconds]
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jfb4 has joined #lisp
vtomole has quit [Ping timeout: 260 seconds]
vhost- has joined #lisp
jameser has joined #lisp
scymtym has joined #lisp
<beach>
jdz: Sadly, many of the discussions here involve using Common Lisp to do unsafe things such as accessing memory directly.
schweers has joined #lisp
broccolistem has quit [Ping timeout: 252 seconds]
broccolistem has joined #lisp
quazimodo has quit [Ping timeout: 276 seconds]
marusich has joined #lisp
<jasom>
beach: sadly the rest of the world is unsafe and we have to interact with it
<beach>
I disagree. That's a choice.
<jasom>
much of the time the choice is between unsafe and irrelevant
<beach>
Well, since most people think Common Lisp is irrelevant as well, then one might as well use a language that is unsafe by design, rather than trying to twist an otherwise safe language into doing unsafe things.
damke has quit [Ping timeout: 264 seconds]
scymtym has quit [Remote host closed the connection]
scymtym has joined #lisp
<p_l>
beach: I'd argue that since our computational substrate doesn't provide some higher abstraction by itself, we should strive to give all the power we can while simultaneously making the easy problems trivial, hard problems easy, and insane problems doable, for the end user of the tool
<beach>
And we do that by turning Common Lisp into just another unsafe language?
fikka has quit [Ping timeout: 248 seconds]
<jackdaniel>
while direct memory access may be considered unsafe it is only a minor bug which may be avoided (that is a case for using language which manage memory for the programmer, I'm all for that and we have a lot of mainstream languages doing that too) - avoiding this class of problems doesn't make a language safe though
<beach>
So you are saying, Common Lisp is unsafe anyway, so we might as well go the extra mile to make it totally useless?
<jackdaniel>
no, that is not what I'm saying
<beach>
Enlighten me!
<jackdaniel>
what I'm saying is that trading "unsafe" language to Common Lisp is trading one "unsafe" language to another "unsafe" language, so it is not a very good argument to switch
Jarwin has joined #lisp
<jackdaniel>
happily CL has many other very good qualities which are very appealing
Jarwin is now known as Jarwin
<jackdaniel>
(for instance Java doesn't have direct memory access but many people seem to dislike it and software written in it still has bugs which lead to unsafe behavior, yet some of bloat could be mitigated with macro abstraction which it lacks)
<aeth>
Imo CL is about controlling when evaluation happens
<p_l>
beach: CL is "safer" in the default state. Essentially giving "sane defaults" while at the same time providing ways to expand *when needed*
<otwieracz>
Do you have any ideas for examples how to handle file upload properly with clack/ningle?
<p_l>
beach: someone nicely described "low-level language" as one where issues irrelevant to problem being solved are important :)
<varjag>
could anyone suggest an example of code handling cl+ssl errors?
<aeth>
And I'd love not to have to use CFFI at all. If we add window, input, sound, and 3D graphics to the next version of the standard, I guess that'll get rid of a lot of reasons to use it.
mingus has joined #lisp
<aeth>
Shift more work to the implementers
<varjag>
i wrap it into handler-case trying to invoke continue restarts
<varjag>
but it is probably not very intelligent
shaftoe has quit [Quit: WeeChat 2.0.1]
hhdave has joined #lisp
shaftoe has joined #lisp
<jackdaniel>
/another kind of safety improvement would be static typing which some could argue (me included) would be an overkill for CL/
<aeth>
jackdaniel: My Lisp is mostly typed
fikka has joined #lisp
damke has joined #lisp
<jackdaniel>
good for you ;-)
<aeth>
Because CL has sequence-generic and number-generic things, declaring types for sequences/arrays and numbers makes a big difference.
<aeth>
I don't think it really matters for anything else.
<aeth>
I think the compiler can normally tell what type is expected by what functions are being used on it, although I could be wrong.
<aeth>
I do wish it was standard that type declarations checked and aren't assumed when safety != 0, though
<aeth>
A lot of code assumes this, including mine
<jackdaniel>
aeth: by static typing I don't mean declarations but rather some enforcement from the compiler to make various informations certain and available at compilation time
<jackdaniel>
so some class of issues may be compromised before running the code
vibs29 has quit [Ping timeout: 248 seconds]
<aeth>
jackdaniel: It could be done, there would just need to be a way to handle functions differently.
Jarwin has quit [Ping timeout: 248 seconds]
<jackdaniel>
maybe, that's not my point though
<fiddlerwoaroof_>
That sort of thing is feasible to implement as a macro.
<beach>
jackdaniel: Static typing is known to be undecidable.
vibs29 has joined #lisp
<aeth>
fiddlerwoaroof_: pretty much, you'd just wrap a function foo with (the return-type (foo ...)) or (the (values return-type-0 return-type-1) (foo ...))
<beach>
jackdaniel: So what they do with languages that enforce static typing is to make the type system so restrictive that it severely hinders programmer productivity.
<aeth>
the issue is if you recompile foo at runtime, though
<jackdaniel>
beach: that's what I mean by "overkill"
damke has quit [Read error: Connection reset by peer]
damke_ has joined #lisp
<beach>
I see, yes.
<fiddlerwoaroof_>
minion: memo for Xach: I added a new Makefile to the repository that should work without any external dependencies. Just Make -f Makefile.minimal mkapp
Jarwin has joined #lisp
<minion>
Remembered. I'll tell Xach when he/she/it next speaks.
damke has joined #lisp
pagnol has joined #lisp
damke__ has joined #lisp
damke_ has quit [Ping timeout: 265 seconds]
<aeth>
jackdaniel: I think the future is a mix between static and dynamic typing within one language
<aeth>
Languages are slowly inching their way in that direction in different ways (of course, Lisp has always had type declarations)
<pillton>
beach: The discussion I had with aeth regarding unsafe array access was to eliminate redundant index checks.
<p_l>
aeth: having graphics et al in standard is quick way for obsolescence
<beach>
pillton: I know.
<p_l>
(look at COBOL, which has graphics in standard for example...)
orivej has joined #lisp
<Shinmera>
beach: I don't /want/ to do unsafe stuff, but I do want to get things done. Sometimes getting things done requires doing unsafe stuff. The benefit is that others won't have to anymore once someone has made a library that does it for them.
<aeth>
Ideally I can do one check before tons of arefs instead of one check on every aref. Very niche situation to need so many arefs, pretty much just matrix*
damke has quit [Ping timeout: 264 seconds]
paratox has joined #lisp
<aeth>
p_l: Tech is moving more slowly now, though.
<phoe>
nowadays software becomes slow faster than hardware becomes fast
<jackdaniel>
Tech is moving more slowly now, though, and it moves backwards as a bonus! ;-)
<aeth>
p_l: Stuff from 2010 is still prefectly viable today, and for the foreseeable future.
<aeth>
In 2000, stuff from 1992 was absolutely obsolete
* jackdaniel
uses technology standarized in 1994
<Shinmera>
jackdaniel: In actuality tech is moving more like a dry cleaner. The same stuff being done over and over.
fikka has quit [Ping timeout: 248 seconds]
<Shinmera>
And eventually someone changes the laundry
damke__ has quit [Ping timeout: 264 seconds]
<aeth>
jackdaniel: Tech totally moved backwards with apps + web.
<beach>
Shinmera: I totally agree. Stuff like that should be isolated behind some Common Lisp abstraction layer. The reason I uttered something in the first place, is that the discussions here are disproportionately about unsafe stuff, suggesting that not only do we hide stuff behind abstractions, but many applications programmers do it as a normal part of the application.
<p_l>
language standards take time, and just for graphics in one API family there were significant changes since 2000. Let's see, around 5 big changes?
<jackdaniel>
Shinmera: if it were just that. as an example: websockets are build on top of ton of abstractions, which when peeked at the bottom is build on top of sockets
<jackdaniel>
so it is rather a mudball which grows
<jackdaniel>
than a dry cleaner
<Shinmera>
So a clogged up washing machine? :^)
<p_l>
with toddlers playing in mud
<pillton>
beach: Ok. I don't really classify this problem as wanting to make CL programs unsafe.
<aeth>
beach: It might just be because the FFI stuff is harder and less obvious than native Lisp stuff
<Shinmera>
p_l: That even includes the unsafety angle! Perfect
<beach>
I am also very surprised that we still continue to claim that some features must be IN THE STANDARD in order to be useful, even though many people use languages without any standard whatsoever, and many others use libraries that are not part of the standard of the programming language they have chosen to use.
<phoe>
^
<aeth>
I was joking about putting graphics in the standard
<aeth>
Apparently the COBOL people heard me and did so with a time machine, though
<p_l>
beach: true. Personally, I'd rather see more cooperation on the CDR front, as essentially "enshrining" common library code
mrSpec has joined #lisp
<beach>
p_l: That sounds very good to me.
mrSpec has quit [Changing host]
mrSpec has joined #lisp
<p_l>
aeth: the standard even includes "visual" laying out of the UI! ;)
<aeth>
p_l: If SBCL, CCL, and ECL developers can agree on some language extension (CDR or otherwise), it will reach most users, at least in #lisp
<aeth>
But if SBCL, CCL, and ECL developers ignore it, then it probably won't reach too many people
<Shinmera>
aeth: Visual Basic would like to have a word
<aeth>
SBCL, CCl, ECL, ABCL, CLISP, CMUCL, MKCL, Clasp, and Mezzano are the only living FOSS implementations I could find.
alexmlw has joined #lisp
<aeth>
MKCL does not seem to be very popular.
<p_l>
aeth: I think a bunch of people would have to band to work on implementation of such extensions, because frankly speaking I think current set of developers already has enough on their plate
<jackdaniel>
well, many extensions are agreed upon, or have a reasonable portability layer
* p_l
has long ago relegated it into same closet as GCL
eschatologist has quit [Quit: ZNC 1.6.5+deb2build2 - http://znc.in]
<jackdaniel>
since when updating website is a prime way to judge activity?
* jackdaniel
checks in his memos where he should start doing that
<aeth>
MKCL is the only one I can't access through Roswell to run tests on. Well, I can't access Clasp, either, because it has a compilation error, but I can't see that compilation error from Roswell, I just see a Lisp stack trace saying the subprocess make failed
<jackdaniel>
I've tried Roswell, dumped it after one wasteful day
<aeth>
jackdaniel: The website announced a release 2017-01-18 and 2014-07-04
pjb has joined #lisp
<aeth>
jackdaniel: roswell is not very stable... it has issues with its C
<jackdaniel>
read my question again – release /= activity
<aeth>
If someone made something like Roswell entirely in CL, that would be great.
eschatologist has joined #lisp
<jackdaniel>
and roswell has more issues with its abstraction, it was impossible for me to add hand-compiled implementation to it (even if it was sbcl)
<aeth>
I don't use Roswell to get access of CL in general, I use it to get access of CLs that would be hard to get access to manually.
<p_l>
use a statically-linked ECL-built roswell replacement? ;)
* jackdaniel
dives in his stuff, see you \o
<aeth>
p_l: that would help... what really is needed in general is some way to run tests on SBCL, CCL, ECL, ABCL, CLISP, CMUCL, and Clasp.
<aeth>
Ideally in a way that's more convenient than manually building all of those
<p_l>
there's already some harness for running tests on many implementations
<aeth>
Well, not all tests are well-defined in test suites, sometimes SLIME is useful.
orivej has quit [Ping timeout: 246 seconds]
<aeth>
There might be an alternative that does SLIME + testing, I'd love to know, I'd consider using it instead if it's more stable
<aeth>
It took me an hour or so to fix Roswell last time I updated it and it broke
fikka has joined #lisp
<Cymew>
A community vote system really would be a nice thing to have, integrated in ql and in github.
<pjb>
write the code!
<pjb>
(vote '(write the code) 'Cymew)
<pjb>
with (ql:quickload :cymew-vote) (use-package :cymew-vote)
<aeth>
p_l: and, yeah, it would have to take a lot of coordination (and perhaps one person who knows the internals of several implementations) to get some extensions
<aeth>
Cymew: voting on what?
<Cymew>
:)
dddddd has joined #lisp
<p_l>
rubygems-like backend could be nice as well, to extend ql
<pjb>
(cymew-vote:open-elections) --> ((write the code) …)
<Cymew>
aeth: "This system is good and alive -> 5 stars" or "This system is not maintained -> 1 star".
<Cymew>
Something you could use when quickloading to see if you need to bother.
<aeth>
Cymew: only if there's a second star system for documentation
<Cymew>
I actually started to read the quicklisp code to figure out how to add features to it, then a paying job came around...
<aeth>
I would say with the majority of libraries I have to read the code because there's essentially 0 documentation
<pjb>
yea, paying jobs, the curse of all good thing. Promote Universal Basic Income!
<Cymew>
aeth: I think the exact details could be discussed, but yes I agree that is very important.
<aeth>
Rating based on documentation would be tricky, though, because do you reset it if it adds documentation?
<jackdaniel>
that sounds like a way for people who don't do to say people who do what to do ;-)
<beach>
Cymew: I think a voting system is an excellent idea. That's the main problem with finding something appropriate, namely knowing the opinions of others.
<aeth>
jackdaniel: but if there's a 5-star library with 1-star documentation, that gives someone looking for something to do a good suggestion of what they can do
randomstrangerb has quit [Ping timeout: 240 seconds]
<aeth>
I don't think people are going to reject documentation patches unless they're incorrect
randomstrangerb has joined #lisp
<aeth>
On the subject of documentation, how many public classes have :documentation filled out?
<aeth>
probably not many
* Shinmera
can't wait for the inevitable drama of people getting upset over their libraries getting low ratings
<Shinmera>
aeth: I document all types.
<Shinmera>
So you won't find (:documentation "foo") in my code, but that doesn't mean it isn't documented
<jackdaniel>
I rate it 2-stars, wait for `(:documentation …)` patches ;-)
BitPuffin has joined #lisp
damke__ has joined #lisp
<_death>
we could inflict ratings on other languages :d
<aeth>
2/10, cannot evaluate at read time
<phoe>
I go for #'(setf documentation) sometimes
damke__ has quit [Ping timeout: 264 seconds]
afterK has joined #lisp
afterK has quit [Changing host]
afterK has joined #lisp
afterK has quit [Client Quit]
sjl has joined #lisp
BitPuffin has quit [Remote host closed the connection]
BitPuffin has joined #lisp
varjagg has joined #lisp
sjl has quit [Ping timeout: 248 seconds]
varjagg has quit [Ping timeout: 265 seconds]
angavrilov has joined #lisp
chens has quit [Remote host closed the connection]
attila_lendvai42 has joined #lisp
drewc_ has quit [Ping timeout: 240 seconds]
Jarwin has quit [Ping timeout: 255 seconds]
knicklux has joined #lisp
attila_lendvai42 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 252 seconds]
scottj has quit [Quit: leaving]
attila_lendvai42 has joined #lisp
orivej has joined #lisp
<shaftoe>
there's a voting system already... the library downloads per month or how many other libraries depend on it
<shaftoe>
popularity might be a better word
<shaftoe>
you might give split-sequence 1 star, but it's one of the more heavily depended on and downloaded libs
<shaftoe>
likewise alexandria
<phoe>
alexandria actually has docs
<phoe>
(even though it's outdated)
<shaftoe>
alexandria draft manual from whenever
<Shinmera>
shaftoe: That doesn't reflect popularity nor how good a system is
<Shinmera>
The download stats are heavily falsified by CI systems
fikka has joined #lisp
<shaftoe>
point taken
<Shinmera>
Or, well, not falsified, but tainted.
<shaftoe>
one example where a popularity/rating system would be handy, was with graph libraries... there's at least 3 on quicklisp with various licenses and featuresets
<aeth>
Nah, most of the libraries I don't like were from the 2000-2010 era of Lisp, possibly without even having any updates since that time. Usually unpatched for years. Probably abandoned.
<aeth>
Library quality is higher these days.
<Shinmera>
Aw maaan
<pjb>
Shinmera: you live dangerously…
<Shinmera>
pjb: Hm?
<pjb>
With your pizza pictures!
<Shinmera>
Ah. That was taken from a "worst pizza ever" thread
<Shinmera>
Anyway, pizza crimes are probably for #lispcafe
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
pagnol has quit [Ping timeout: 248 seconds]
damke has quit [Ping timeout: 246 seconds]
JenElizabeth has joined #lisp
<fe[nl]ix>
aeth: such as ?
attila_lendvai42 has quit [Ping timeout: 248 seconds]
damke has joined #lisp
<aeth>
I'll name one because it's fairly common and because it's bad and because I've criticized it here before. A bit newer than the time range I was talking about. cl-json.
jameser has joined #lisp
<aeth>
Its default settings are just so bad, e.g. nil <-> null and nil <- false
fikka has quit [Ping timeout: 260 seconds]
<aeth>
Unless its documentation is wrong. I'll test it out since I already have it downloaded
dieggsy has joined #lisp
<aeth>
Nope, nil produces "null". Someone honestly sat down and thought generating "null" was a more reasonable default than "false".
pagnol has joined #lisp
jameser has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth>
It has good documentation, though
makomo has quit [Ping timeout: 265 seconds]
smurfrobot has joined #lisp
fikka has joined #lisp
damke_ has joined #lisp
smurfrobot has quit [Ping timeout: 276 seconds]
orivej has quit [Ping timeout: 252 seconds]
damke has quit [Ping timeout: 264 seconds]
damke__ has joined #lisp
Cymew has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
SaganMan has quit [Quit: laters]
wigust has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
damke__ has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
pagnol has quit [Quit: Ex-Chat]
Tobbi has joined #lisp
Tristam has joined #lisp
smurfrobot has joined #lisp
jameser has joined #lisp
jameser has quit [Client Quit]
smurfrobot has quit [Ping timeout: 276 seconds]
Tristam has quit [Ping timeout: 276 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
QualityAddict has joined #lisp
dieggsy has quit [Remote host closed the connection]
<schweers>
quick question: given a file-descriptor (on linux), can I create a common lisp file-stream?
red-dot has joined #lisp
smurfrobot has joined #lisp
<jackdaniel>
yes, but not portably
<jackdaniel>
it may be called for instance ext:make-fd-stream
<schweers>
so I’ll have to write code for each implementation I’d like to use?
<jackdaniel>
check out how its done in osicat or usocket (don't remember exactly)
<jackdaniel>
yes, but it is basically a oneliner for each implementation
<jackdaniel>
you may create trivial-fd-streams portability layer
<Cymew>
I do note a distinct shortage of docs, as per our earlier conversation in this channel. Have seen worse, though.
fikka_ has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 240 seconds]
djeis_ has joined #lisp
djeis_ is now known as djeis
<tazjin>
Cymew: assuming you're responding to me, the docs shortage isn't really the problem (API is very straightforward), it just doesn't quite seem to do what I expect :P
schasta has quit [Ping timeout: 265 seconds]
<Cymew>
That would be a problem. Myself, I have not used it. The author have written quite a few systems, and not all easy to use. I suspect overexposure to ruby, considering how some of the web stuff looks like.
msb has joined #lisp
fikka has joined #lisp
EvW has quit [Ping timeout: 252 seconds]
damke__ has joined #lisp
EvW1 has joined #lisp
djeis has quit [Remote host closed the connection]
orivej has joined #lisp
Jesin has quit [Quit: Leaving]
Kaisyu has quit [Quit: Connection closed for inactivity]
djeis has joined #lisp
wxie has joined #lisp
igemnace has quit [Quit: WeeChat 2.0.1]
Murii has quit [Remote host closed the connection]
djeis has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
asarch has joined #lisp
fikka has joined #lisp
test1600 has joined #lisp
zaquest has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
flamebeard has quit [Quit: Leaving]
zaquest has joined #lisp
wxie has quit [Remote host closed the connection]
sjl has joined #lisp
dtornabene has joined #lisp
damke__ has quit [Ping timeout: 264 seconds]
flamebeard has joined #lisp
<asarch>
Today is Knuth's birthday
damke__ has joined #lisp
Murii has joined #lisp
Fare has joined #lisp
damke has joined #lisp
drewc has joined #lisp
damke__ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<sjl>
flip214: bad news is that they don't intend to continue working on vlime
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
zaquest has quit [Quit: Leaving]
rumbler31 has joined #lisp
smurfrobot has joined #lisp
<crsc>
Nice to know. I installed vlime yesterday and it works fine for me. Hopefully he will come back in the future.
<dlowe>
I suspect someone else should probably pick it up
<dlowe>
Maybe YOU
<sjl>
It's pretty well documented, and the code is pretty clean from what I remember.
raynold has quit [Quit: Connection closed for inactivity]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
mishoo has joined #lisp
jfb4 has quit [Ping timeout: 240 seconds]
red-dot has joined #lisp
jfb4 has joined #lisp
dieggsy has quit [Remote host closed the connection]
JonSmith has joined #lisp
<makomo>
hm wait, sjl is steve losh? :-)
<sjl>
yeah
<makomo>
hah, hi there :D, i watched your (old?) stream about running lisp on an arudino and solving some PE problems
<sjl>
I generally use my initials for more tech-related things like github/irc and longer names for non tech stuff like photos
<makomo>
and also saw that cool-retro-term terminal emulator there
<sjl>
Oh, cool. I need to get back to streaming. Haven't done any over the holidays.
Jesin has joined #lisp
eudoxia has joined #lisp
turkja has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
randomstrangerb has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Remote host closed the connection]
randomstrangerb has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
python476 has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
eivarv has joined #lisp
fikka has joined #lisp
bgardner has quit [Ping timeout: 240 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
hexfive has quit [Read error: Connection reset by peer]
red-dot has joined #lisp
hexfive has joined #lisp
FreeBirdLjj has joined #lisp
varjag has joined #lisp
smurfrobot has joined #lisp
papachan has quit [Quit: WeeChat 2.0.1]
Jesin has quit [Quit: Leaving]
hexfive has quit [Remote host closed the connection]
hexfive has joined #lisp
schweers has quit [Remote host closed the connection]
papachan has joined #lisp
smurfrobot has quit [Remote host closed the connection]
ebdreger has joined #lisp
marusich has quit [Quit: Leaving]
igemnace has joined #lisp
fortitude_ has quit [Ping timeout: 252 seconds]
dieggsy has joined #lisp
al-damiri has joined #lisp
Karl_Dscc has joined #lisp
fikka has quit [Quit: leaving]
fikka has joined #lisp
jmercouris has joined #lisp
<jmercouris>
good evening
<beach>
Hello jmercouris.
<phoe>
Hey everyone
<phoe>
(that was a very short hey, since I have to run now)
<jmercouris>
hello, good bye :D
rpg has joined #lisp
Murii has quit [Ping timeout: 260 seconds]
dtornabene has quit [Remote host closed the connection]
makomo has quit [Quit: WeeChat 1.9.1]
randomstrangerb has quit [Ping timeout: 276 seconds]
randomstrangerb has joined #lisp
hhdave has quit [Ping timeout: 248 seconds]
BitPuffin has quit [Ping timeout: 252 seconds]
nika has quit []
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
drcode has quit [Ping timeout: 248 seconds]
m00natic has quit [Remote host closed the connection]
jpxe has quit [Read error: Connection reset by peer]
fikka has joined #lisp
Jarwin has joined #lisp
SuperJen has joined #lisp
drcode has joined #lisp
drcode has quit [Read error: Connection reset by peer]
drcode has joined #lisp
JenElizabeth has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 248 seconds]
Jarwin has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
test1600 has quit [Ping timeout: 264 seconds]
<shka>
good evening
Jarwin has joined #lisp
zaquest has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
randomstrangerb has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
randomstrangerb has joined #lisp
scymtym has quit [Ping timeout: 246 seconds]
fortitude has joined #lisp
Cthulhux has quit [Changing host]
Cthulhux has joined #lisp
smurfrobot has quit [Remote host closed the connection]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
makomo has joined #lisp
raynold has joined #lisp
kobain has quit [Ping timeout: 272 seconds]
gilez has joined #lisp
sonologico has joined #lisp
python476 has quit [Read error: Connection reset by peer]
<makomo>
if i have a file with, in order, some defclasses, some defuns and in the end some defconstants whose value forms create instances of the previously introduced classes
<makomo>
what's the reason i get an error message from SBCL?
<makomo>
are the defconstants not evaluated only once everything before in the file has been evaluated?
<phoe>
hm, the spec begs to disagree. it seems that loading refers only to files.
<makomo>
>to cause the code contained in the file to be executed.
Xach has quit [Ping timeout: 248 seconds]
<Shinmera>
loading is not the same as load-time
<makomo>
so loading a file entails reading the file, compiling the file and executing the file then?
<Shinmera>
only for source files
Xach has joined #lisp
<Shinmera>
loading a FASL won't incur compilation
<makomo>
oh i see. you're thinking of stuff liek fasls?
<makomo>
hmm right
<makomo>
like*
<ebdreger>
(it doesn't make life simpler that the compile and load phases are often blurred together by one's environment)
<Shinmera>
loading will cause either one of the following phases to happen: (read compile load execute) or (load execute)
<Shinmera>
While compile-file will cause (read compile) to happen
<Shinmera>
Note that things get more complicated still when you consider COMPILE and EVAL
* ebdreger
nods
<makomo>
yeah :^(, that's why it would be nice if the whole thing was described somewhere in one place
<Shinmera>
COMPILE will perform (compile load), though here the load is only relevant for load-time-value.
<Shinmera>
And EVAL will perform (compile load execute).
<ebdreger>
rule of thumb that makes life a little easier: don't use COMPILE or EVAL without good reason (usually dynamically-generated code that can't be created any other way)
<Shinmera>
Though EVAL only has to perform "minimal compilation"
<Shinmera>
So it can take shortcuts
fikka has joined #lisp
smurfrobot has joined #lisp
<makomo>
so what does load-time actually do?
<makomo>
load the function/class/etc. defs into the lisp image?
<Shinmera>
It "links" the file into the environment
<Shinmera>
or the definitions rather
<phoe>
ebdreger: I actually use compile in places like (compile nil (lambda (foo) (frob foo bar)))
<makomo>
so, if i had for example, a defun, followed by a top-level (+ 2 2) expression, followed by another defun
<makomo>
first the defuns would be loaded, and only then the (+ 2 2) expr eval'd?
<phoe>
where a lambda would do just as well, but compiled code is compiled code
<ebdreger>
phoe: ditto
<Shinmera>
makomo: depends on whether you're loading a source file or a fasl file
<makomo>
Shinmera: let's say it's a source file
<Shinmera>
makomo: in the source file case, forms are processed in order and go through all phases one by one
<makomo>
actually, i'm interested in both cases
<Shinmera>
Anyway, defuns are also evaluated.
<makomo>
Shinmera: oh, so there's an actual ordering. i thought that there might not be after what i've heard now (limiting ourselves to source files)
<Shinmera>
CL is rather strict about evaluation order in almost all things
<Shinmera>
(Thank god for that, too)
<Shinmera>
I'm not sure about the constraints of order for the load-time of a FASL.
<Shinmera>
But I think it has to be in order as well
<Shinmera>
One of the puzzling things to understand is that each phase can cause evaluation to happen
<Shinmera>
So, even if we speak of "load-time", there's probably just code being evaluated during it.
<ebdreger>
there also are fun tidbits like sb-ext:save-lisp-and-die that can help you distinguish the stages
<Shinmera>
Don't let it confuse you too much. Most of what you'll ever need to know is that some top level forms might not take effect until later, so you have to wrap them into (eval-when (:compile-toplevel :load-toplevel :execute) ..) to make their effects available at all times.
<Shinmera>
And you should know about load-time-value to emit constants without them needing to be FASL-dumpable.
<makomo>
i usually don't like using something without understanding the details of how it works. sometimes that's good, sometimes it leads me into a rabit hole that's hard to get out of
<Shinmera>
Well, I mean, compilation and evaluation semantics touch everything
<Shinmera>
But you really don't need to understand them in detail to use Lisp
nightfly has joined #lisp
<Shinmera>
Anyway, I'm not the best to talk to about this either-- I feel unsure about the exact workings of some parts. beach and Bike might know better.
<Bike>
huh what
<Shinmera>
We're talking about the various evaluation times and their precise workings.
pmc_ has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<Xach>
pmc_: it is specialized for characters. simple vectors are not specialized.
<minion>
Xach, memo from fiddlerwoaroof_: I added a new Makefile to the repository that should work without any external dependencies. Just Make -f Makefile.minimal mkapp
<pmc_>
ok, thanks!
<Xach>
...there should be a nice punchline for that seutp.
<phoe>
one of my most recent frustrations with the standard is related to the naming of simple-arrays and simple-vectors
<phoe>
...and simple-strings
whoman has joined #lisp
<Shinmera>
well, simple-vectors not allowing a specialisation is just weird in my opinion
<phoe>
for some reason, (simple-array type (n)) does NOT equate (simple-vector n)
<Shinmera>
like, the point of it being simple seems to me to allow optimisations
<sjl>
it is a little odd that vectors are one-dimensional arrays, but a one-dimensional simple-array is not necessarily a simple-vector
<phoe>
which would be God damn logical
pagnol has joined #lisp
<Shinmera>
sjl: But it's still a vector!
<phoe>
#justlispthings
damke has joined #lisp
<sjl>
yep
<sjl>
it is
<sjl>
just not a simple- one
<sjl>
naming is hard
<rme>
after tag checking, svref is a single instruction (on x86, anyway)
<phoe>
I think it's a single pointer dereference
<phoe>
because you have a vector of objects of type T
<phoe>
so you check basic tags like ones for fixnums and such, and then dereference
damke_ has quit [Ping timeout: 264 seconds]
<Shinmera>
Sure, but point being if you have an immediate type you don't need to tag check, making it even faster.
<Shinmera>
Or rather, you wouldn't need to tag check if you had the element-type information
<pjb>
makomo: in any case, it is not useful to use defconstant to bind instances to variables.
<phoe>
yep, but simple-vectors are built around the idea of *not* having element-type information.
<pjb>
makomo: notice that defconstant defines (constant) _variables_.
scymtym has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
<makomo>
pjb: yup, i'll be changing my code
<pjb>
makomo: the point of defconstant is to tell the compiler that it may generate the value as immediate value (thus making copies of the value) in the binary instructions. Therefore it's only useful for values that can be immediate in the native instruction set, ie. basically integers and characters.
<pjb>
(perhaps also floating-points). It's not useful to use defconstant on other types.
<pjb>
In general, defparameter is more useful.
SuperJen has quit [Remote host closed the connection]
SuperJen has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
warweasle is now known as warweasle_afk
arbv has joined #lisp
Jarwin has quit [Ping timeout: 268 seconds]
emaczen has joined #lisp
shka has quit [Ping timeout: 240 seconds]
red-dot has joined #lisp
shka has joined #lisp
eudoxia has quit [Quit: Leaving]
fortitude_ has joined #lisp
fortitude has quit [Ping timeout: 240 seconds]
<borei>
is it possible to define setf for entire object, not for particular slot, but entire object ?
<_death>
(setf (entire-object object) new-value)
<pjb>
Of course.
warweasle_afk is now known as warweasle
<borei>
hmm, not what im looking for, better to provide example
<borei>
i have object of type matrix (for example)
<borei>
i'd like to have
<pjb>
Notice that the semantics of the slots is dependent on the class of the instance
<borei>
(setf matrix 5.0d0) - all elements of the matrix =5
<aeth>
borei: what you probably want it something like (setf (matrix-value matrix) 5.0d0)
<borei>
so it will sort of fake slot ?
<aeth>
Although it's confusing to have a setf function without an equivalent regular function and I'm not sure what a regular function would do by default.
<aeth>
You can have a writer without a reader
<pjb>
slots can contain immutable data (that can be copied), or references to immutable data (the reference can be copied, thus sharing the immutable data), or references to mutable data (that may or may not be copied, thus sharing or not sharing the mutable state), or also the may contain derived data or cached data, that is computed and updated "automatically".
<pjb>
borei: therefore we cannot give you a generic method to copy the slots from one instance to another: you have to provide it yourself!
<borei>
i got idea
<phoe>
borei: what do you mean, entire object?
<phoe>
setf is for setting places, not objects.
<_death>
you can also have (set-all-elements matrix 5.0d0)
<borei>
yep yep
<aeth>
Don't do that one
<aeth>
A writer makes perfect sense imo
<pjb>
ALERT: Edi Weitz took over cdr.eurolisp.org!
<phoe>
you can't modify whole objects in-place - you can only modify references. and places are references.
<aeth>
I use writers for strange things.
<pjb>
borei: there's a CDR specifying a copying generic function.
<phoe>
pjb: is it wat yet?
<pjb>
What does "wat" mean?
<phoe>
uh
<phoe>
is it war yet?
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
<jmercouris>
I still don't know what you mean, even with the correction
<pjb>
phoe: No, war is over, the USA won, and Europe is vasal. We can be raped anytime, and this occurs all the time
<aeth>
borei: If you write an accessor that only works on one value you can use with-accessors just like a CLOS accessor, and then you could do (setf matrix 5.0d0) while really calling the accessor
<jmercouris>
pjb: vassal, isn't that a french word?
oystewh has joined #lisp
<aeth>
borei: If you write an accessor that works on more than one value, you'll have to manually use symbol-macrolet yourself, but the same principle applies
<aeth>
(technically the setf accessor really has one more value than it looks like it has, though, the new value)
angavrilov has quit [Remote host closed the connection]
<jmercouris>
pjb: "Middle English, borrowed from Anglo-French, borrowed from Medieval Latin vassallus" - it's kinda french :P
<pjb>
jmercouris: Not my fault if English is deficient (or should I say inexistant).
<pjb>
The fact that we don't write French here is also a hint that we lost.
<jmercouris>
pjb: something something lingua franca counting eggs too soon
<jmercouris>
there's a lot of french speaking countries that refuse to learn english, don't feel so bad :P
pmc_ has quit [Quit: Leaving]
<jmercouris>
i like the people that suggest that we'll all be speaking chinese, like population of speakers is the only criteria for adoption of language, nevermind the impossible writing and pronounciation
<aeth>
The heart of with-accessors or something similar to it is (let ((thing (gensym))) `(let ((,thing ,object)) (declare (ignorable ,thing)) (symbol-macrolet #|fancy stuff|#) ,@body)))
schasta has quit [Ping timeout: 240 seconds]
<aeth>
(If you want to write your own symbol-macrolets for fancier accessors)
<aeth>
But this sort of thing only works if you stick to accessors
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<pjb>
jmercouris: Chinese, not because of the population, but because of the economic might. The USA is falling fast.
smurfrobot has quit [Remote host closed the connection]
<jmercouris>
yeah, that's not enough, good luck learning chinese
pmetzger has joined #lisp
<aeth>
pjb: That doesn't take into account that French was still the lingua franca after France stopped being the superpower, during pretty much the entire era of the British Empire's dominance
<_death>
chinual already has a meaning
<aeth>
English afaik really became the world language after 1945, with the primary countries of the competing languages of French and German in ruins
<aeth>
(Although even then, Russian was a competing world language through the Cold War.)
<pjb>
aeth: that's the difference between British empire and USA empire :-)
<jmercouris>
Russian was a language forced onto all of their satellite countries, I wouldn't say it was "competing" so much as "coerced"
<aeth>
well, yeah
<jmercouris>
as much as english sucks, it's an easy language to speak incorrectly and still be understood, the same cannot be said of most other languages
<pjb>
France hasn't been beaten by the United Kingdom. Europe has been beaten by the USA.
<phoe>
#lispcafe
<pjb>
jmercouris: speak incorrectly, and be understood incorrectly.
warweasle has quit [Quit: For I have no bum and I must poo.]
krasnal has joined #lisp
ebrasca has left #lisp ["ERC (IRC client for Emacs 25.2.1)"]
fikka has quit [Ping timeout: 265 seconds]
zmt01 has joined #lisp
shka has quit [Ping timeout: 264 seconds]
oystewh has quit [Quit: Lost terminal]
zmt00 has quit [Ping timeout: 248 seconds]
Tobbi has quit [Quit: Leaving]
Tobbi has joined #lisp
fikka has joined #lisp
dieggsy has quit [Ping timeout: 252 seconds]
wigust has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fikka has quit [Ping timeout: 248 seconds]
red-dot has joined #lisp
quazimodo has joined #lisp
Folkol has joined #lisp
fikka has joined #lisp
pmetzger has quit []
dyelar has quit [Ping timeout: 264 seconds]
eivarv has quit [Quit: Sleep]
josemanuel has joined #lisp
Draz has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
xaotuk has joined #lisp
xaotuk has quit [Client Quit]
<jmercouris>
anybody working on some els papers they could use some help on?
Draz has quit [Quit: Leaving]
dyelar has joined #lisp
fikka has joined #lisp
gilez has quit [Ping timeout: 265 seconds]
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<Shinmera>
Wish I was
papachan has quit [Quit: WeeChat 2.0.1]
Tristam has joined #lisp
Tristam is now known as Guest97349
Guest97349 has quit [Max SendQ exceeded]
rumbler31 has quit [Ping timeout: 260 seconds]
tristam__ has joined #lisp
fortitude_ has quit [Ping timeout: 240 seconds]
dvdmuckle has quit [Quit: Bouncer Surgery]
alecigne has joined #lisp
dvdmuckle has joined #lisp
Jesin has joined #lisp
tristam__ has quit [Ping timeout: 248 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
margeas is now known as markong
mishoo has quit [Ping timeout: 256 seconds]
pilfink has joined #lisp
Oladon has joined #lisp
wxie has joined #lisp
bkst has quit [Quit: leaving]
randomstrangerb has quit [Ping timeout: 240 seconds]
bkst has joined #lisp
alecigne has left #lisp ["ERC (IRC client for Emacs 25.2.2)"]
Bike has quit [Ping timeout: 260 seconds]
asarch has quit [Quit: Leaving]
Baggers has joined #lisp
LiamH has quit [Quit: Leaving.]
Jesin has quit [Quit: Leaving]
josemanuel has quit [Quit: leaving]
varjag has quit [Ping timeout: 255 seconds]
Karl_Dscc has quit [Remote host closed the connection]
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
wxie has quit [Quit: Bye.]
smurfrobot has joined #lisp
Tobbi has quit [Remote host closed the connection]
Tobbi has joined #lisp
sjl has quit [Ping timeout: 268 seconds]
nightfly has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
nirved has quit [Quit: Leaving]
Baggers has quit [Remote host closed the connection]
nightfly has joined #lisp
Bike has joined #lisp
varjag has quit [Ping timeout: 264 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 24.5.1)]