<shka_>
pfdietz: notice how test1 will give 2 notes about simple-array possibility while test2 will give 0 notes
<shka_>
i find it weird because SBCL does not have adjustable-arrays that are also simple-arrays
<shka_>
or does it?
<shka_>
furthermore, adding (assert (array-has-fill-pointer-p vector)) in the test1 will also remove notes
<shka_>
which is curious
<Xach>
shka_: simple-arrays by definition are not expressly adjustable
<Xach>
Oh, sorry, I misread what you wrote.
<Bike>
shka_: you mean notes like "can't optimize because it's not a simple array"? I think if you expressly declare it's not a simple array those notes are suppressed
<Bike>
and sbcl might not be smart enough to use satisfies types to figure out array complexity
<shka_>
Bike: no, notes are about sbcl having to check if vector is a simple-array, however type in the SBCL at least means: not a simple-array
<shka_>
oh, ok, this makes sense
<shka_>
pity though :(
<shka_>
Xach: actually, according to the standard simple-arrays CAN be adjustable
<jackdaniel>
it is undefined whether simple-arrays are adjustable, it is conforming for them not to be
<jackdaniel>
Xach: simple arrays *may* be expressly adjustable
<shka_>
Xach: nah, it just says list conditions that implies that array is expressly adjustable
<jackdaniel>
the implication goes the other way around
<jmercouris>
pjb: could you expand on that? have you used it to transform JS into parenscript?
<pjb>
jmercouris: probbaly a tad bitrotten, and surely incomplete, sorry.
<jmercouris>
ah, OK
<jmercouris>
no problem, I will investigate
<jackdaniel>
if it is not expressly adjustable, not yada yada and yada, then it is => simple-array
<pjb>
jmercouris: and without batteries included; yes, I used this a long time ago to turn JS into parenscript.
<Xach>
jackdaniel: oh, i think i see that possibility by the "subtype" language
<pjb>
With additionnal proprietary code.
<shka_>
… or, otherwise, it may still be simple-array ;-)
<Xach>
I was referencing this: The type of an array that is not displaced to another array, has no fill pointer, and is not expressly adjustable is a subtype of type simple-array.
<jmercouris>
OK, I see
<pjb>
jmercouris: probably you'll have more luck with banckward-parenscript.
<shka_>
Xach: i got this wrong as well the first time
<jmercouris>
perhaps it'll be a good starting point, and it will just require a bit of tweaking
<jackdaniel>
Xach: right, but it is not said, that array which is displaced or has a fill pointer or is expressly adjustable is *not* a subtype of type simple-array
<jackdaniel>
it is undefined behavior wether it is
<jackdaniel>
whether
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
ikki has joined #lisp
<jmercouris>
does quicklisp download all of the software from its sources or is a copy made on some sort of quicklisp server?
<Xach>
jmercouris: the files you download via quicklisp are on a central server
cosimone has joined #lisp
<jmercouris>
Xach: do you have therefore an archive of all quicklisp verisons on the server?
<pjb>
jmercouris: downloading from sources is to this central server is done once a month.
<Xach>
jmercouris: i do, going back to 2010
<jmercouris>
so basically I imagine you would have just about every important CL project since then
<jmercouris>
how much disk space does that take?
<jmercouris>
or, how much disk space does a given month take?
<Xach>
I haven't checked lately. It's stored on S3 and I bet it's under 5GB.
<jmercouris>
not bad! that's quite good
<jmercouris>
Xach: is there a way to download every single repository available on quicklisp and to have them ready to be quickloaded even when offline?
<Xach>
A given month is only differentially bigger than the previous month.
<jmercouris>
what would have to change to allow multiple versions of the same library to be quickloaded?
<jmercouris>
would we need what beach calls 'environments'?
<jmercouris>
something to change all of the symbols and provide some version specific accessor to them?
<jmercouris>
I'm just interested purely from an academic perspective, Ie have no need to do this practically
heisig has quit [Ping timeout: 240 seconds]
Inline has joined #lisp
<Bike>
well, there'd have to be some way for them to bind symbols with the same name and package to different things. so either some kind of transparent package renaming or environments, probably.
<pjb>
jmercouris: the common resource are the package names, keywords, and global (special) CL variables.
<jmercouris>
OK, interesting to know, thanks
<jmercouris>
Is there any interest in this functionality?
<beach>
jmercouris: I didn't invent the term "environments". It is in the Common Lisp HyperSpec already.
cosimone has quit [Remote host closed the connection]
<beach>
What I did was to turn them first-class, which the Common Lisp HyperSpec does not require.
<jmercouris>
Why was it not first-class? what is the reasoning of the original authors?
<beach>
Backward compatibility.
cosimone has joined #lisp
<jmercouris>
why does it break backwards compatibility to add a language feature?
<beach>
Lisp has a long history of spreading out the global environment everywhere in the system.
<beach>
Symbols have a function cell, for instance.
<jmercouris>
ah, so people depend on that in the code they write
<jmercouris>
and so it would break many programs
<beach>
No, but it would require the creators of Common Lisp systems to invent what I only just did.
<jmercouris>
so when you say 'backward compatibility', is that a codeword for 'more work'?
wxie has quit [Ping timeout: 260 seconds]
<jackdaniel>
clhs was already enormous in scope when it was written (and I think they were running out of money); adding new features would be, well, unwise
<beach>
And I am guessing the creators of the standard did not want to burden the suppliers of Common Lisp systems with that extra requirement, especially since they didn't know how to make the feature efficient.
<beach>
It is not just another feature.
<jmercouris>
what makes it particularly expensive?
<beach>
It would require someone to have done the research that I did.
<beach>
And they didn't, so they didn't know how to make it fast.
<Bike>
it's kind of hard to answer questions about why something wasn't invented earlier than it was.
<jackdaniel>
beach: yes, my point is that even for "normal" features that would be unwise, inventing new stuff even more so
<beach>
So, since the vendors were members of the committee that created Common Lisp, they did not consider making it mandatory.
william1 has joined #lisp
<jackdaniel>
(even if they knew what and potentiallyh how)
<jmercouris>
Bike: sometimes yes, sometimes no. For example, why wasn't the light bulb invented in 1000BC? Because many pre-requisite technologies and knowledge was missing
<beach>
jmercouris: It isn't expensive if you do what I do. But previous proposals required a hash-table lookup for each function application. Whereas the tradition was to access a slot in the symbol.
<beach>
jackdaniel: I agree with you.
<beach>
jmercouris: With my proposal, calling FDEFINITION or FBOUNDP with a non-constant argument still requires a hash-table lookup.
<jmercouris>
beach: hash table is O(1), how is that expensive?
<beach>
Heh, funny.
<jmercouris>
I'm not being funny, hash table is an unbelievably fast data structure
<beach>
A function call is just a few instructions, adding a O(1) lookup that may require hundreds of instructions and several memory accesses is out of the question.
<Bike>
jmercouris: doing a hash table lookup for every symbol access would kind of suck.
<jmercouris>
interesting, I didn't realize things were so fast for function calls
quazimodo has quit [Ping timeout: 268 seconds]
<beach>
jmercouris: You have the pointer to the symbol. You access the function slot, then the entry point of the function. You set the arguments, and then do a CALL instruction.
<beach>
jmercouris: You can read about global environments in that section.
<beach>
Notice that they allow for all the different global environments to be one and the same.
<jmercouris>
however they are not guaranteed to be the same?
<jmercouris>
also the definition is interesting
<jmercouris>
environment n. 1. a set of bindings.
<beach>
jmercouris: What I did was just to have the function slot disembodied. So my call protocol looks the same with a small difference: You have a pointer to a cell. You access the contents of that cell (the function object), then the entry point of the function. You set the arguments, and then do a CALL instruction.
<beach>
jmercouris: They are not guaranteed to be the same, and SICL will likely be the first implementation in which they are not.
<jmercouris>
what is a 'disembodied slot'?
<jmercouris>
is it just an accessor?
<beach>
A slot that is not in the symbol, but exists elsewhere.
yottabyte has left #lisp [#lisp]
<jmercouris>
some other type of data structure?
<beach>
... in a "cell". I just use a CONS cell.
<beach>
Or a singleton list if you prefer.
<jmercouris>
OK
<jmercouris>
interesting
<beach>
jmercouris: It is all in my paper.
<jmercouris>
does performance degreate with the number of environments?
<jmercouris>
degrade*
<beach>
Nope.
<jmercouris>
what if we have 10,000 environments that all define the symbol *potato-chip*
<Bike>
if you understand the method you'll understand that the number of environments doesn't affect the lookup speed.
<jmercouris>
won't we have to look for the correct symbol among all the environments using the disemodied function slot?
<beach>
There is only one such symbol in the system.
<jmercouris>
right, sorry
<beach>
jmercouris: The paper is not that hard to read, I hope.
<jmercouris>
which paper?
quazimodo has joined #lisp
<beach>
metamodular.com/SICL/environments.pdf
<jmercouris>
OK, I read
lennonwoo has quit [Quit: Connection closed for inactivity]
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life has joined #lisp
cosimone has quit [Quit: Terminated!]
william1_ has joined #lisp
cosimone has joined #lisp
jmercouris has quit [Ping timeout: 240 seconds]
vms14 has joined #lisp
oxum_ has joined #lisp
whartung has joined #lisp
oxum_ has quit [Remote host closed the connection]
oxum has quit [Ping timeout: 268 seconds]
jmercouris has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
brown121408 has quit [Ping timeout: 240 seconds]
heisig has joined #lisp
brown121407 has joined #lisp
oxum has joined #lisp
heisig has quit [Ping timeout: 258 seconds]
brown121408 has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
cantstanya has quit [Ping timeout: 240 seconds]
heisig has joined #lisp
cantstanya has joined #lisp
raghavgururajan has joined #lisp
jebes has joined #lisp
brown121408 has quit [Ping timeout: 240 seconds]
brown121408 has joined #lisp
anewuser has joined #lisp
gravicappa has joined #lisp
jonatack has joined #lisp
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
m00natic has joined #lisp
jmercouris has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 268 seconds]
skeuomorf has joined #lisp
skeuomorf has left #lisp [#lisp]
EvW has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
vidak` has quit [Read error: No route to host]
cosimone has quit [Quit: Terminated!]
raghavgururajan has quit [Remote host closed the connection]
izh_ has quit [Quit: Leaving]
abordado has quit [Read error: Connection reset by peer]
abordado has joined #lisp
karlosz has joined #lisp
Bourne has quit [Remote host closed the connection]
flip214 has quit [Read error: Connection reset by peer]
Bourne has joined #lisp
EvW has quit [Ping timeout: 248 seconds]
flip214 has joined #lisp
jprajzne has quit [Quit: Leaving.]
sjl has quit [Quit: WeeChat 2.2-dev]
easye` has quit [Read error: Connection reset by peer]
brown121408 has quit [Read error: Connection reset by peer]
brown121408 has joined #lisp
easye` has joined #lisp
hiroaki has joined #lisp
william1 has quit [Ping timeout: 258 seconds]
Necktwi has joined #lisp
khisanth_ has quit [Ping timeout: 260 seconds]
patlv has joined #lisp
vms14 has quit [Remote host closed the connection]
ggole has quit [Quit: Leaving]
xkapastel has quit [Quit: Connection closed for inactivity]
khisanth_ has joined #lisp
william1 has joined #lisp
varjag has joined #lisp
m00natic has quit [Remote host closed the connection]
william1 has quit [Ping timeout: 258 seconds]
pilne has joined #lisp
bitmapper has joined #lisp
EvW has joined #lisp
nowhere_man has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
gigetoo has quit [Ping timeout: 258 seconds]
gigetoo has joined #lisp
retropikzel has joined #lisp
karlosz has quit [Quit: karlosz]
william1 has joined #lisp
_paul0 is now known as paul0
william1 has quit [Ping timeout: 268 seconds]
clothespin has joined #lisp
jebes has quit [Remote host closed the connection]
priyadarshan has quit [Remote host closed the connection]
Bourne has quit [Ping timeout: 268 seconds]
cosimone has quit [Quit: Quit.]
heisig has quit [Ping timeout: 258 seconds]
shangul has quit [Ping timeout: 240 seconds]
Bike has quit [Remote host closed the connection]
Bike has joined #lisp
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
MightyJoe has joined #lisp
cyraxjoe has quit [Ping timeout: 265 seconds]
xuxuru has joined #lisp
gigetoo has quit [Remote host closed the connection]
xuxuru has quit [Client Quit]
xuxuru has joined #lisp
Bike has quit [Remote host closed the connection]
heisig has joined #lisp
Bike has joined #lisp
jeosol has quit [Remote host closed the connection]
william1 has joined #lisp
william1 has quit [Ping timeout: 258 seconds]
je4i has quit [Read error: Connection reset by peer]
sauvin has quit [Ping timeout: 265 seconds]
je4i has joined #lisp
cosimone has joined #lisp
jfb4_ has joined #lisp
jfb4 has quit [Ping timeout: 268 seconds]
Bourne has joined #lisp
pnp has joined #lisp
torbo has joined #lisp
pfdietz has quit [Remote host closed the connection]
jebes has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 248 seconds]
rdh has joined #lisp
Codaraxis has quit [Ping timeout: 265 seconds]
william1_ has quit [Quit: WeeChat 1.9.1]
william1 has joined #lisp
retropikzel has quit [Quit: Leaving]
asdf_asdf_asdf has joined #lisp
<rdh>
hello, i am coming back to clisp and hoping someone can help me out (i do not have to much exp with setting it up) but i have quicklisp installed and everytime i run (ql:quickload "cffi"), i get an error but when clisp offers a restart, taking the option "Retry finding system cffi after reinitializing the source-registry" cffi loads fine.
<rdh>
the error: DESTRUCTURING-BIND: (OPERATE 'TEST-OP :CFFI-TESTS) does not match lambda
<rdh>
list element (O
<rdh>
C)
cosimone has quit [Quit: Quit.]
<rdh>
I do not understand what is going on. is this some thing I over looked setting up quicklisp or a bug with cffi.
gareppa has joined #lisp
<asdf_asdf_asdf>
rdh, paste piece of code.
stepnem_ has joined #lisp
<rdh>
asdf_asdf_asdf, sure one sec...
<asdf_asdf_asdf>
Maybe problem is in code not in configuration.
<jackdaniel>
the problem is that asdf broke its api contract. you need to download upstream asdf and (load (compile-file /it/)) before loading quicklisp
<jackdaniel>
for asdf defense one could say, that clisp didn't update bundled asdf for ages
<asdf_asdf_asdf>
Because You should SBCL, not Clisp?
<Bike>
clisp is... i think it's maintained now, but it wasn't for a while?
<didi>
So, how much of an offense is to use both &optional and &key in a lambda-list?
<minion>
didi, memo from pjb: note that CL:ASSERT let you fix the problem: Try: (let ((list (list 1 2 3))) (assert (= 1 (length list)) (list) "should be a list of 1 element")) and select the restart that let you enter a new value for LIST.
<asdf_asdf_asdf>
Which is your operating system?
<Bike>
might be a bit old.
<Bike>
didi: sbcl gives a style warning, i think. mostly it's just confusing.
<jackdaniel>
didi: sometimes useful, usually stylistically yuck
<jackdaniel>
rdh: because they didn't release for a long time. there is also that asdf is just a program, nobody expects gcc to ship make with it
<didi>
pjb: Thanks, but in the case I was thinking, it should never happen; it's deep inside an algorithm; and there is no saving from sinking.
<didi>
Bike, jackdaniel: Thank you.
jxy has joined #lisp
<rdh>
oh, should i switch to sbcl before even getting into clisp?
<rdh>
if i remember correctly, sbcl compiles everything first?
<Bike>
well, usually we prefer other implementations, yeah. there's also ccl and stuff.
<rdh>
obviously among other differences...
<Bike>
sbcl usually compiles, yeah. you can configure it to use an evaluator.
<asdf_asdf_asdf>
rdh, SBCL is compiler no environment programming.
<rdh>
ok, im justing emacs/slime
<Bike>
this won't really matter to your user experience though, generally.
<Bike>
sbcl and ccl and everyone work fine with slime.
<jackdaniel>
rdh: "compiles it first" doesn't mean it is slugish
<jackdaniel>
quite the contrary, repl works top-notch fast
<rdh>
jackdaniel, Ok
tst` has quit [Quit: Leaving]
<copec>
clisp has an awesome non-slime repl
shka_ has quit [Ping timeout: 265 seconds]
<copec>
(Hence the reason why it is GPL)
<copec>
Its bytecode progs are small, and even significantly faster then cpython when I did a bunch of testing with it like 10 years ago
<copec>
I don't like the "just use SBCL" mentality, even though I <3 SBCL
* jackdaniel
endorses ECL ;-)
<jackdaniel>
but it is sluggish at times, p
<copec>
How much bytecode interpretation does ECL share with Clisp?
<rdh>
I think ill go with sbcl, seems to be well maintained.
scymtym has joined #lisp
<jackdaniel>
rdh: sbcl is a solid choice
<jackdaniel>
copec: zero, it was written from scratch. also ecl has two compilers (one is a bytecode, second is via C source code, the latter produces way faster code)
<copec>
I just started playing with ECL a couple of days ago, actually
<jackdaniel>
enjoy! :)
<jebes>
i was thinking of using ecl to create an opengl engine
<copec>
Is there a way for disassemble to actually show you the C source?
<jackdaniel>
when you call compile-file you may provide :c-file :data-file and :h-file arguments
<jackdaniel>
files won't be deleted then but rather saved at the location you want them to
karlosz has joined #lisp
<jackdaniel>
you may also try (disassemble nil '(lambda () 42))
pnp has quit [Remote host closed the connection]
efm has quit [Quit: Konversation terminated!]
<copec>
I was reading the other day that Haskell uses a C--, have you ever looked at that jackdaniel?
<jackdaniel>
if it can be implemented without it, then it could be implemented with it, sure ,) some structures are easier to implement with continuations. that said call/cc is not that much useful
<Bike>
it's usually implemented on top of block/return-from and special variable binding
<Bike>
and block/return-from is equivalent to call/ec
<jackdaniel>
delimited continuations cover most of things you want to have (and are *much* easier to implement)
<copec>
ah
<copec>
I've only used call/cc for some educational dynamic programming, but never needed it for an application I was working on
<jackdaniel>
I've mentioned call/cc only to show limits of what compilation to C can achieve without hacks
<copec>
The chicken impl. is very cool from what I've understood reading about it
<didi>
jackdaniel: Word on the street is that it doesn't leak like call/cc.
<copec>
Thanks for the link Fade
<jebes>
doesn't scheme have something akin to unwind-protect for call/cc
<jebes>
i haven't looked into contuation implementation stuff in a long time
<jebes>
copec: i have a copy right beside me right now. Its pretty solid. Pricey though, now
<jackdaniel>
lisp in small pieces is a very valuable read if you are interested /how/ lisps could be implemented
<copec>
I've gone through the dragon book
<jackdaniel>
I've never read the dragon book, but from what I've heard half of it is about parsing
<copec>
yup
<jackdaniel>
and parsing is not very fascinating topic
<jebes>
i don't think i've ever seen a book about gory back end details
cosimone has joined #lisp
<copec>
It is a very traditional language compiler book
jmercouris has quit [Ping timeout: 258 seconds]
<Bike>
"doesn't scheme have something akin to unwind-protect for call/cc" dynamic-wind.
<jackdaniel>
dynamic-windu s/dynamic/master/ and voila, master windu ;-) see you o/
<copec>
What does clasp use as an intermediate language with llvm?
<jebes>
besides llvm's ir?
<copec>
does it translate cl directly into llvm ir?
didi has left #lisp ["O bella ciao bella ciao bella ciao, ciao, ciao."]
EvW has joined #lisp
<Bike>
it translates common lisp into Cleavir's IR, then that into LLVM-IR.
<Bike>
during bootstrapping it does translate lisp pretty directly into llvm-ir.
<copec>
Is there a relatively simple way to disassemble to llvm-ir from the repl?
<Bike>
in clasp? sure.
<Bike>
(disassemble '(lambda ...) :type :ir)
* copec
amazes
<Bike>
you can't do it for already-compiled reasons for what i imagine are similar reasons to ECL and C
<Bike>
for already-compiled fun tions*
<Bike>
functions* jesus
<phoe>
Bike: I guess there could be a compiler switch that remembers IR representations for functions for later disassembly
<phoe>
but then again, why would it be needed if you have all the source available
<Bike>
wouldn't just be a compiler switch, you'd also have to store it in the function.
<phoe>
Bike: uh yes, I meant that - remember and store it in the object.
<Bike>
but yeah i guess it's possible.
<phoe>
but then, it's possible, but is it really worth it
<Bike>
the llvm-ir can't really be recovered from the machine code, it's too abstracted.
<phoe>
obviously, yes
HumanGeode has joined #lisp
<phoe>
I guess someone would want to use (disassemble #'foo :type :ir) real bad for this switch to become actually worth the time spent on implementing it
<Bike>
i don't think it would be too complicated to do. we just don't have much reason to.
<Bike>
i only even look at llvm-ir when i'm debugging the compiler, which ideally is not something a user has to concern themselves with
<phoe>
that's why I said that *someone* would want to use the IR disassembly
<phoe>
IR disassembly mode, I mean
<phoe>
if the current developers don't need it that way, then everything's pretty fine
<Bike>
for seeing if optimizations have been applied and other stuff, it would probably be clearest with the cleavir IR, but it's nonlinear so that's kind of tricky
Codaraxis has joined #lisp
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
gendarme has joined #lisp
<copec>
Is there a spec for cleavir ir?
* copec
checks documentation dir for more information
<rdh>
sweet, thanks guys i have sbcl, emacs and slime working perfectly together.
<copec>
^That is a beautiful combination
<Bike>
copec: Yes, there's a cleavir.pdf that explains it, though the one in the documentation is a little outdated
<copec>
someday .pdf will be a tld
<Bike>
is it not already?
<Bike>
i thought i remembered people complaining. maybe i was hallucinating.
<copec>
Do you have a link to said pdf Bike?
<Bike>
i don't think so, sorry. you should be able to make it from the repository.
<copec>
okay
<Bike>
you could ask beach when he's awake.
<Bike>
beach is also in the middle of a major update to cleavir which will somewhat alter the IR
<Bike>
since clasp and sicl are the only things using it we kind of change it as we go.
<phoe>
what's being changed?
<Bike>
representation of handling of multiple return values and the dynamic environment, mainly
<Bike>
cleavir at the moment can't represent unwind-protect or special variable bindings so these have to be done through function calls. that will no longer be the case.
<phoe>
what's the cleavir method of representing u-p via function calls?
<Bike>
and funwind-protect is not compiled by cleavir. in clasp's case it's a C++ function using RAII.
<Bike>
or try catch i guess. whatever.
<phoe>
got it
hiroaki has quit [Ping timeout: 268 seconds]
Kevslinger has quit [Quit: Connection closed for inactivity]
hiroaki has joined #lisp
xuxuru has quit [Quit: xuxuru]
william1_ has joined #lisp
xuxuru has joined #lisp
<Xach>
william1_ has quit [Ping timeout: 240 seconds]
rdh has quit [Ping timeout: 260 seconds]
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
gareppa has quit [Quit: Leaving]
narimiran has quit [Ping timeout: 260 seconds]
xuxuru has quit [Quit: xuxuru]
clothespin has quit [Ping timeout: 248 seconds]
jmercouris has joined #lisp
<stylewarning>
Any thoughts on building a portable hash table library (that has a wider range of efficient custom hash functions), that isn't just a TRIVIAL-* library?
<jmercouris>
why not build a hashing library, and then a hash table library on top of your hashing library?
<no-defun-allowed>
stylewarning: I do think it's good.
<phoe>
but also hell yes sounds good
<stylewarning>
phoe: I've seen this; i consider it to be a bit of a cop-out solution. It solves the problem of portability (of some features: custom hash funs) but doesn't really care about efficiency, multithreadedness, etc
<stylewarning>
jmercouris: it doesn't seem like a useful separation of concerns imho
shifty has joined #lisp
<jmercouris>
perhaps, it was just an idea
<heisig>
We also need a good hash table implementation for SICL, so there is some potential for collaboration :)
<no-defun-allowed>
Oh, good...evening heisig!
<Bike>
well, some people seem to like being able to supply their own hash functions
clothespin has joined #lisp
<stylewarning>
heisig: we have been abusing hash tables non-portably, and many of the hash tables are just sparse integer maps, so we thought we could implement a better one (famous last words) that works more efficiently and as flexibly as needed
<stylewarning>
(there's of course a separate question: is a hash table the right data structure for a sparse integer map? but that's neither here nor there. We also use tons of custom hash functions)
<jmercouris>
is hash table the right data structure for a sparse integer map... difficult question
<jmercouris>
that really depends on *how* the data structure is being used
<stylewarning>
another feature I've wanted is being able to specify key/value types for safety. Maybe that doesn't deserve to be in the hash table interface but almost all tables I create have concrete key and value types
<stylewarning>
and of course CL's HTs are designed with the opposite in mind: any kind of key and any kind of value
<jmercouris>
why have you wanted this feature? I am diametrically opposed to it
<phoe>
type safety
<jmercouris>
I am opposed to type safety
<phoe>
well, I'm not
<jmercouris>
I used to be a Java programmer way back when...
<stylewarning>
jmercouris: your key and value types can be T and T respectively :
<stylewarning>
:)
<jmercouris>
lol :-D
<stylewarning>
Why MAKE-ARRAY :element-type wasn't exactly designed for safety, and it has wackiness with upgraded types and whathaveyou, i think it's a nice design element
<phoe>
as verbose as Java is, it gets its type safety mostly right - and declaring types for hashtables is one thing that I enjoy in it
<Bike>
ugh, please don't copy the type upgrading thing again
<jmercouris>
I actually really disliked that, it is a preference however, I understand it, I just didn't believe in it
<stylewarning>
Bike: haha, that is the part i would *NOT* want to copy
<phoe>
now we upgradin' hash table key types Bike
<phoe>
it's the current fad
<phoe>
;; I agree, this is the part that we shouldn't copy over
<Bike>
treating it as a storage thing would be uh, weird. hash table implementation might put keys and values in the same vector...
<stylewarning>
jmercouris: so you much prefer that you supply a test function such that the hash function and test function form a reverse implication on the key types you have, and the value types are Whatever You Feel Like Whenever You Woke Up? ;)
<phoe>
even if it would be just for runtime checks, there is some value in runtime safety alone
<jmercouris>
stylewarning: the test function is only a mild implication, and it can span across types!
<Bike>
i'd say if you want safety you can define gethash+(setf gethash) analogues that have declared/checked types respectively. don't feel strongly about it though.
<jmercouris>
that's what makes it so cool
<stylewarning>
Bike: I'm saying I like the design element of specifying a type in the constructor, not that it directly has to do with storage. (:
<stylewarning>
jmercouris: types in Lisp are sets, and sets can be unioned, so it still is all the same
<jmercouris>
:-D
learning has joined #lisp
<Bike>
if you do it in the constructor and have gethash/(setf gethash) check the types there you're doing type checks based on a type only known at runtime which is gonna be a lot less performant.
<Bike>
which you might not care about, but still
<stylewarning>
it would be nice if it could do w/e AREF does wrt type safety
<phoe>
so you seek a hashtable library which generates different code based on the compiler policy
Bike has joined #lisp
<Bike>
unfortunately that's generally tied into impleemntation type inference stuff so it's not possible to deal with portably
<phoe>
your GETHASH might include typechecks on default safety levels and no runtime checks on (declare (optimize :yes))
<copec>
*danger-zone* implies audio output
<Bike>
...but if you do want to do this, maybe start with having a table library, and then we can make my shed
<phoe>
copec: oh I laughed, thanks
<phoe>
Bike: maybe that's doable portably; an implementation should be able to elide surplus checks, like, if it knows that a thing is a FOO then it doesn't need to check if it's a FOO anymore
<Bike>
it wouldn't know that at compile time without some work though.
<Bike>
inexpressible work
<phoe>
ouch
<phoe>
that's correct
<phoe>
...this should be achievable with some compiler macros though
harovali has joined #lisp
<Bike>
then there's no type information.
<jmercouris>
what is 'inexprisible work'?
<Bike>
well, inferred type information
<phoe>
sigh. correct.
<Bike>
maybe i should just write out a thing about why type-directed transformations might be nice but aren't very doable, since this keeps coming up
<phoe>
you'd need to try and expand into the code that will then, hopefully, be optimized by the compiler.
<harovali>
hi! how can I exit when slime hangs saying "Type a form to be evaluated:" ?
<phoe>
harovali: Ctrl+G?
<harovali>
phoe: it does nothing
<jmercouris>
maybe if you press it really hard
william1 has quit [Ping timeout: 265 seconds]
<phoe>
That's the general "get me out of here" combo in emacs
<Bike>
what happens if you type a form to be evaluated
<phoe>
if you type in () and hit enter?
<harovali>
for now I'm exiting emacs wit C-x C-c which works
<phoe>
that's harsh
<harovali>
let me see
<phoe>
what did you do to end up in such a place?
<jmercouris>
if you are able to exit with C-x C-c then emacs is not frozen
<jmercouris>
which means you should be able, in the worst case to kill the repl and inferior lisp
<stylewarning>
SLIME's request for input in some random buffer has caused issues in live presentations once
<stylewarning>
i wish the interface for entering input for conditions was better
je4i has quit [Ping timeout: 264 seconds]
<harovali>
phoe: finally I could get out of there , maybe () did it
<harovali>
sometimes I get there typing the wrong key in the error menu
Seteeri has joined #lisp
<phoe>
ooh, yes, in the debugger
<harovali>
jmercouris: it's not frozen, right . Maybe it's slime in a loop which emacs cannot exit , and which eventually will exit itself
<phoe>
in that case just type in a () and then [q] to quit the debugger
<heisig>
I see two ways to obtain typed hash tables: 1. A defstruct-like macro that generates the hash table, its type, and its accessors. 2. Painful, non-portable SBCL hacking.
<harovali>
phoe: maybe yes
<phoe>
it's not in a loop I guess
<phoe>
it's waiting for user input
<harovali>
phoe: I'll try again with () next time
<harovali>
thanks !
Seteeri has quit [Client Quit]
Codaraxis has quit [Ping timeout: 260 seconds]
<stylewarning>
heisig: i'm probably in favor of a portable intf+impl with painful SBCL hacking
notzmv has joined #lisp
<stylewarning>
gotta give those SBCL folks something to do w/their time
<heisig>
So the portable interface would be something like (make-hash-table :key-type fixnum :value-type symbol :hash-function #'identity)?
<phoe>
stylewarning: this sounds exactly like the goal that this library that I linked above has
<Bike>
hopefully those are quoted.
<phoe>
it already has some fallback stuff plus depends on implementation-defined stuff if an implementation supports these
<phoe>
oh yes please quote these
<phoe>
mostly cause of (let ((fixnum 't) (symbol 'nil)) (make-hash-table :key-type fixnum :value-type symbol :hash-function #'identity))
<stylewarning>
heisig: tbh i'm not sure, i'll play around with an interface, maybe once I have a strawman we can mess around with it
<phoe>
...but yes, such an extension would be lovely
<jackdaniel>
first I need to truly separate passes in ecl, then why not ,) however, is there any reason that having this will improve anything hash-table-access-wise?
<phoe>
some more type inference information will be available
<jackdaniel>
to believe*
kajo has joined #lisp
<phoe>
a compiler will be able to warn if you try to use a non-fixnum key in the gethash, plus it'll know that the result will be (or null symbol)
<jackdaniel>
it will be able to do that if you always declare type of the hash table
<phoe>
(declaim (type *ht* ...)) ;)
<phoe>
but yes, that's one nuisance - you'll need to manually declare the types there
xuxuru has joined #lisp
<jackdaniel>
hash tables are fast *yet* slow for performance-crictical code (access-wise); the real question is that: is there any data to support thesis, that it would be worth the effort?
<pjb>
phoe: do you realize that you cannot put anything in the result of (let ((fixnum 't) (symbol 'nil)) (make-hash-table :key-type fixnum :value-type symbol :hash-function #'identity)) ?
<phoe>
pjb: yes, I do, the type NIL has no elements
jmercouris has quit [Remote host closed the connection]
xuxuru has quit [Quit: xuxuru]
<phoe>
I kinda wish #'EQ was associative the same way #'= is
Codaraxis has joined #lisp
<stylewarning>
do you mean (EQ x y z ...)?
<phoe>
yes
<phoe>
now I gotta do (and (eq a b) (eq b c) (eq c d))
<jackdaniel>
why not define a macro if you truly miss that?
<phoe>
or do some magic like (every (alexandria:curry #'eq a) (list b c d))
<stylewarning>
8 MEGABYTES AND (CONSTANTLY #'CONSING)
<jackdaniel>
or a function if you need function interface
cosimone has quit [Quit: Quit.]
<phoe>
stylewarning: I laughed harder than I should have, thank you
<phoe>
jackdaniel: right, I can do that
<phoe>
it's just that shadowing CL:EQ makes me die a little inside due to the side effects of that
ym has quit [Ping timeout: 260 seconds]
<jackdaniel>
name it eq*
<phoe>
hmm
<phoe>
doable, thanks for the idea
<Xach>
mfiano: was there a recent change to plain pngload? i reset my vcs cache and now it seems to be gone and completely replaced with pngload-fast.
<Xach>
I don't know if it's something that got jiggled around when I purged my cache or what.
<pjb>
jackdaniel: how do you justify a macro for eq*?
<jackdaniel>
sure, it wasn't very bright though, I've personally never encountered a situation where I'd need such eq, (every (curry #'eq a) other-values) would suffice too
<jackdaniel>
like I justify and vs every, not all arguments need to be evaluated
<stylewarning>
> (defmacro associate (op x y &rest z)
<Xach>
There was some discussion a while ago about having them both available separately and I'm not sure what happened to break things now. whether it's a local issue or something that coincidentally happened at the same time.
<Xach>
phoe: my question is not that it happened, but about the timing.
LiamH has quit [Quit: Leaving.]
<phoe>
Xach: gotcha
<Xach>
Whether it is something that took effect very recently, like today.
<mfiano>
Xach: checking
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
ym has joined #lisp
<mfiano>
Yeah an insignificant change, but a change nonetheless
<mfiano>
(replaced loop keyword with a keyword symbol)
<mfiano>
I actually didn't mean to commit to that repo since it is uhh unmaintained
<phoe>
;; I suggest to mark it as such then
<mfiano>
I was going to but you said you were going to merge the pngload-fast features into pngload with reader conditionals for implementations to have fallback support
<mfiano>
Wasn't sure if that was happening sooner than later apparently :)
<phoe>
oh god I forgot about that completely
<phoe>
please bang me against the nearest wall
<mfiano>
No problem. I had forgot too
<mfiano>
I prefer not thinking about either repo. They drain too much of my limited resources
abordado has quit [Read error: Connection reset by peer]
<phoe>
Xach: I have a curious question
<phoe>
I'm on SBCL and for some reason I have a package named QL-CLISP
<phoe>
I wonder why
gendarme has quit [Read error: Connection reset by peer]
gendarme has joined #lisp
gendarme has quit [Client Quit]
gendarme has joined #lisp
<harovali>
does anyone know of some current tutorial or documentation to cl-pdf and cl-typesetting?