troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
troydm has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Read error: Connection reset by peer]
edgar-rft has joined #lisp
igemnace has joined #lisp
dbotton has quit [Quit: Leaving]
cods has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 272 seconds]
Nilby has joined #lisp
mmmattyx has quit [Quit: Connection closed for inactivity]
ludston has joined #lisp
nullman has joined #lisp
jedii has quit [Ping timeout: 272 seconds]
jedii has joined #lisp
wxie has joined #lisp
npfaro has joined #lisp
<npfaro>
hi
<npfaro>
i have a problem with slime/emacs. When i put the cursor inside a form where the auto-complete would kick in, it puts the Common Lisp one provided from slime in the minibuffer, but then about half a second later it's overwritten by the ELisp one
<npfaro>
which is quite annoying
<npfaro>
has this happened to anyone else
<ludston>
npfaro: Are you using the lastest version of Emacs/slime/your lisp implementation? What auto-complete package are you using in emacs?
<npfaro>
ludston: not really auto-complete but rather the little function signature that appears in the minibuffer. I think it's called eldoc? I just disabled eldoc-mode in the lisp buffer though and it's still doing it so idk
<npfaro>
I can try updating my stuff
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<npfaro>
i should be on the latest slime now
<npfaro>
no difference
judson_ has joined #lisp
<ludston>
Probably something in your .emacs file is hooking elisp to the same auto-complete lib? I assume you are coding in both elisp and CL?
<npfaro>
looks like global-semantic-idle-summary is the culprit
<npfaro>
Do any of you folks use that mode successfully
kaftejiman has quit [Remote host closed the connection]
<npfaro>
or is it even worth having turned on
iskander has quit [Ping timeout: 264 seconds]
<Nilby>
I realized all kinds of auto messages on timers annoyed me.
<Bike>
i don't use semantic.
<charles`>
If I want to change directory, load file, then change back, why doesn't this work. It doesn't seem to change directory properly?
<charles`>
(let ((cwd (uiop:getcwd)))
<charles`>
(load "file.lisp")
<charles`>
(uiop:chdir cwd)))
<charles`>
(uiop:chdir "new-dir")
<Nilby>
charles`: **default-pathname-defaults*
<charles`>
instead of uiop:chdir I change that variable?
<Nilby>
I'm sorry to say it's complicated and slightly implementation dependent. On some implementations you can just chdir, on some you have to set *default-pathname-defaults*, on some maybe both?
luckless_ has quit [Quit: luckless_]
<Nilby>
If you want I can share a thing that does it on most implementations?
<charles`>
That would be cool. I have seen shcl though
<Nilby>
You'll probably have to take out the (syscall ..) wrapper .
<Nilby>
I'd say this code is wrong, but it works.
<Nilby>
Also you can change safe-namestring to namestring
<charles`>
you seem very knowledgeable about different implementations
<Nilby>
I'm not. I don't even remember writing code.
<Nilby>
Or maybe I stole it?
luckless has joined #lisp
<Nilby>
Oh, I forgot shcl is the other shell. I use the asdf path for loading, but I guess "cd" and load still works.
devon has quit [Ping timeout: 246 seconds]
ralt has quit [Quit: Connection closed for inactivity]
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
<npfaro>
how do I set the value of a parameter/var without having the repl display the value
<npfaro>
I'm reading a multi-megabyte file into an array and I think slime is crashing every time it tries to print it
<npfaro>
I'm C-x C-e'ing (setf x (read-my-massive-array))
<Bike>
(progn (setf x (read-my-massive-array)) nil)
<npfaro>
that's just goofy
<Bike>
yes
<Bike>
sorry, do you mean for this to be like code in a file?
<Bike>
the progn thing is just what i do when i'm in the repl
<Bike>
and nobody can see this shame
<npfaro>
what do you do in a file then
<Bike>
i don't usually write that kind of procedural code in files, i suppose
<npfaro>
hrmmmm
<Bike>
let me see if slime has some kind of hook
<Bike>
doesn't look like it, i don't think
<Bike>
if you do M-- C-x C-e it will save it to the kill ring rather than print it
<Bike>
i don't know if that actually helps with huge output
<Bike>
well, seems like it works for me for a ten thousand element list, at least
<npfaro>
looks like there's a param called *print-vector-length*
<Bike>
oh, yeah, you can just set *print-length*
<Bike>
i do that in my sbclrc
<Bike>
that's a CL variable, not slime
<edgar-rft>
there's *PRINT-LENGTH* to limit the number of elements printed
<npfaro>
neato
<npfaro>
perfect, thanks
<edgar-rft>
oh, I just see that Bike won by a nose :-)
kini has quit [Ping timeout: 264 seconds]
kini has joined #lisp
mindCrime has quit [Ping timeout: 264 seconds]
iskander has joined #lisp
kini has quit [Ping timeout: 264 seconds]
kini has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
madage has quit [Remote host closed the connection]
madage has joined #lisp
aspr has joined #lisp
<shinohai>
////////////
Lycurgus has joined #lisp
<pillton>
(setf *print-array* nil) ?
* pillton
has had to wait for the REPL to print out a high-definition image a few times.
<npfaro>
Can i ask a dumb loop question
<Bike>
sure.
<npfaro>
I have an array of values such that there are groups of 4. so I want to loop over them in groups
<npfaro>
Say I have #(1 2 3 4 5 6 7 8) I'd like to loop over them so that I can treat them as '((1 2 3 4) (5 6 7 8))
<Bike>
you mean like you have #(0 1 2 3 4 5 6 7 ...) and you want to work with 0 1 2 3 first, then 4 5 6 7, etc?
<npfaro>
yeah
<Bike>
right.
<Bike>
you could do (loop for (a b c d) in (coerce vector 'list) ...), but that conses.
<ludston>
(loop for i = 0 then (+ 4 i) <someaggregate> (loop for j from i to (+ 3 j)) ?
<Bike>
i don't think there's a way to do it with the vector directly. you could cook up something with indices like that.
<Bike>
er, "on (coerce ...)" i meant
<Bike>
and then "by"... whatever, that code sucks anyway
<npfaro>
i can live with consing
<Bike>
(loop for (a b c d) on vector by #'cddddr ...) then
<npfaro>
I thought cdr doesn't work on vector
<Bike>
on (coerce vector 'list) i mean
<Bike>
i am scatterbrained to-nite
<ludston>
I'd just do it via the indices so that you don't get the O(n) copy
<npfaro>
hrm ok
<Bike>
i would also do it with the indices. if you want nicer syntax, you could probably design your own clause if you used ITERATE instead of loop
<Bike>
but i don't know much about that library
<npfaro>
I'm trying to stick to vanilla CL atm
<Bike>
fair enough
<Bike>
also, this wasn't a stupid question, so don't worry about that
<Nilby>
or something like (loop with a = #(1 2 3 4 5 6 7 8) for i from 0 below (length a) by 4 do (format t "~s~%" (subseq a i (+ i 4))))
<npfaro>
thanks
<Bike>
you can throw in like "for a = (aref vector i) for b = (aref vector (1+ i)) ..." etc
<ludston>
Again though, with subseq you are having O(n) copy
<ludston>
Avoiding memory allocation in GC'd languages I think is a good habit
<ludston>
Contraversial opinion though?
<edgar-rft>
I think displaced arrays are meant to be used for sub-arrays of big arrays but I need to fiddle out the syntax.
<Bike>
using displaced arrays usually involves consing, also.
<Bike>
and implementations may not optimize their use well
<Nilby>
sbcl seems to use about the same memory for displaced as subseq
orivej has joined #lisp
Alfr_ has joined #lisp
<Bike>
for large sections the displaced array probably uses less memory than subseq and involves less copying time
Alfr has quit [Ping timeout: 260 seconds]
<Nilby>
weirdly my test on sbcl runs faster for subseq on an array of 10000
<Bike>
you mean the array you're taking chunks out of is 10000 long?
<Nilby>
yes
<Nilby>
i suppose i should test bigger chunks
<Bike>
if the chunks are pretty short, i would guess that the copying overhead doesn't matter, and instead you hit slowness because you're using aref on a non simple array
<ludston>
What is a good word for destructuring a collection into chunks of n length? If it was pairs, you would say "zipping and unzipping"?
<Bike>
sbcl is probably smart enough to realize that if you're doing aref on subseq it's a simple aref
<aeth>
Almost everything has a start/end in CL, which helps a lot to avoid consing.
<aeth>
I can decompose an array of length 4 into multiple values, to avoid additional consing (in most circumstances)
<Nilby>
Good morning beach!
<aeth>
So e.g. (zr-utils:array-of-4 (vector 1 2 3 4)) => 1 2 3 4
<aeth>
This can compose well with most things, but LOOP doesn't afaik have a way to bind multiple values at once (without a SETF in the body, of course) so it might not be the best kind of iteration for that.
<Bike>
it does not, no.
<aeth>
I just recently extended my function to support offsets, so it can solve this problem in particular, e.g. (zr-utils:array-of-4 (vector 1 2 3 4 5 6 7 8) 4) => 5 6 7 8
<aeth>
Unfortunately, the API isn't stable yet and it's not in QL
<Nilby>
sbcl allows me to write atrociously slow code
<Bike>
as the gods intended.
<Nilby>
:)
<Bike>
a really fancy compiler could probably elide actually consing a displaced array for certain uses. i don't think any implementation actually bothers, though.
<aeth>
The problem is that "displaced arrays are slow" is common knowledge, so it's not idiomatic to use it, and non-idiomatic things aren't optimized because it's not worth the time.
<aeth>
If CL was as popular as JS, every corner would see optimizations, including that.
emaczen has quit [Ping timeout: 264 seconds]
<Bike>
i dunno if displaced arrays are even a nicer way of expressing things, though
<Bike>
at least the kind of immediate cursor i'm imagining being optimizable could just be done pretty straightforwardly with indices
<Bike>
passing them between functions could be nicer, but then interfunctional optimization is harder
bitmapper has quit [Quit: Connection closed for inactivity]
<aeth>
For 2-4 values, I love the compositional possibilities with the multiple-values route, although the syntax is pretty awkward. At the function boundary, you're basically forced to multiple-value-call. And it's not going to help you if you're calling a non-inline function that uses double-floats (or similarly boxed things).
<aeth>
Obviously if it's closer to, say, 20+ or especially 200+, then something like displaced arrays would be way better.
anewuser has joined #lisp
<Nilby>
If displaced arrays are optimized away inside a function, then they're probably fine as just a struct for passing indices around.
<pillton>
beach: I had a read of your call-site optimization paper. I like it. I think the information about the callers would be useful for editors or reflection. I also think you could perhaps mention if it is possible to compile the callee more than once to suit the type information provided by the caller.
<Nilby>
Why isn't there an nsubseq for arrays?
<Bike>
what would nsubseq do?
<Nilby>
I know it's not really the same concept. Just make a displaced array if it can.
<pillton>
beach: I wonder if the word "type" in the last sentence of the second paragraph of page 2 should be "class"?
<aeth>
Nilby: The problem is, most of the heavy optimizations are going to be inside of a function, or at least inside of a file, and the time when you'd really, really want to used displaced arrays is to treat a random subarray as an array when calling a general purpose function that expects the latter
<Nilby>
aeth: Right. But if your stuff is non-mutating maybe it's okay.
<aeth>
I suppose it could still help if those functions were inline, which could be a surprising amount of vector math stuff, especially if they were designed for this.
ZharX242 has joined #lisp
<Nilby>
Yes. And then have it work with shareable vectors so the gpu or os can have it.
<pillton>
aeth: I'd rather compilers focus on eliminating indice checks for vector math stuff.
<charles`>
is there a way to read a file that has lisp code and get what the result is? if a file contains (+ 1 2), (return-load "file") => 3
<aeth>
Nilby: Certain (1D) arrays can be bilingual CFFI/CL, which is all you need for the GPU
<aeth>
The downside is that you have to manually free them.
jedii has quit [Remote host closed the connection]
<beach>
pillton: I don't think it would be necessary to compile the callee more than once. It would typically have the structure so that a prefix would test the types, and part of that prefix can then be skipped so that the snippet jumps to the middle of the callee.
<beach>
pillton: Yes, I'll change "type" to "class".
adam4567 has joined #lisp
<beach>
pillton: I am not quite awake yet. Can you give me an executive summary?
<Nilby>
aeth: Thanks. I should probably be using that.
Bike has quit [Quit: Lost terminal]
iskander- has joined #lisp
mrcom has joined #lisp
iskander has quit [Ping timeout: 246 seconds]
<pillton>
beach: I can't at the moment as I have to go soon. I am in no hurry for you to read the link. I think it highlights the issue I am talking about better than I could explain it here.
<beach>
OK, I'll read it after I finished my coffee. Thanks again!
<Nilby>
charles`: or maybe (eval (uiop:read-file-form "foo.lisp"))
patience_ has joined #lisp
edgar-xyz has joined #lisp
bilegeek has quit [Quit: Leaving]
pillton` has joined #lisp
pillton` has quit [Client Quit]
amb007 has quit [Ping timeout: 256 seconds]
jprajzne has quit [Ping timeout: 256 seconds]
pillton` has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
ludston has quit [Ping timeout: 256 seconds]
pillton has quit [Ping timeout: 256 seconds]
edgar-rft has quit [Ping timeout: 256 seconds]
johnjay has quit [Ping timeout: 256 seconds]
wxie has quit [Ping timeout: 265 seconds]
Nilby has joined #lisp
johnjay has joined #lisp
judson_ has joined #lisp
Lycurgus has quit [Quit: Exeunt]
eden has joined #lisp
pillton has joined #lisp
wxie has joined #lisp
<beach>
pillton: I am not in favor of recompiling the callee according to the information provided by the current callers, but I can very well see compiling several versions of the callee according to the type information that ANY caller could provide to make the callee faster.
aeth has quit [Ping timeout: 264 seconds]
aeth has joined #lisp
ebrasca` has quit [Remote host closed the connection]
yangby has joined #lisp
yangby has quit [Client Quit]
<pillton>
beach: Sure. That system I linked to provides a mechanism for users to request a specific specialization of an operator. I found this to be easier than trying to implement systems which handle all of the subtypes of REAL and the corresponding array subtypes for every CL implementation.
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
Yes, I see.
mrcom has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
npfaro has quit [Ping timeout: 246 seconds]
mrcom has joined #lisp
ex_nihilo has quit [Quit: Leaving]
parjanya has quit [Remote host closed the connection]
eden has quit [Ping timeout: 268 seconds]
npfaro has joined #lisp
<charles`>
Nilby: doesn't work because eval uses some other environment. I tried putting *package* and *readtable* inside, but doesn't work still
judson_ has joined #lisp
patience_ has quit [Ping timeout: 240 seconds]
<Nilby>
Hmmm. Maybe you could wrap it with (let ((*package* (find-package :whatever)) (*readtable* (copy-readtable))) (eval (uiop:read-file-form "foo")))
<Nilby>
It seems like it's only a good technique for simple things.
<charles`>
I am trying (eval
<charles`>
(*readtable* ,*readtable*)
<charles`>
,(read-from-string
<charles`>
(*package* ,*package*))
<charles`>
`(let ((theme ,theme)
<charles`>
(uiop:read-file-string body-file))))
<beach>
charles`: Please use a paste site for code with more than one line.
<charles`>
okay
<beach>
Like plaster.tymoon.eu for instance.
andreyorst has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<npfaro>
Is there any way to advance a loop in the body of it
<npfaro>
Say I have a loop like (loop for (a b) on '(1 2 3 4)) and if a+b > 10 then move past both and onto the next pair
<beach>
npfaro: I think you would have to use FOR THEN for that.
<npfaro>
i ended up just writing a recursive function
Stanley00 has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
karlosz_ has quit [Quit: karlosz_]
<npfaro>
Any way to make it in SBCL so that when you type a string at the repl it doesn't respond with #<(SIMPLE-ARRAY CHARACTER (9)) foo... {1004DCC80F}>
<beach>
If you type a string literal, it should print that same literal, because string literals are self-evaluating objects, and they are printed as usual.
<npfaro>
<npfaro>
"wello"
<npfaro>
#<(SIMPLE-ARRAY CHARACTER (5)) wel... {1004E44C3F}>
<beach>
You must have somehow clobbered print-object, or you have some printer variable set wrong.
<npfaro>
I fixed it, had to set *print-vector-length* back to nil
<npfaro>
my bad!
<npfaro>
while you're here, do you know how to convert a vector to a (VECTOR (UNSIGNED-BYTE 8)) easily
<npfaro>
I'm trying to use sb-ext:octets-to-string but it ain't workin'
andreyorst` has quit [Remote host closed the connection]
<npfaro>
@beach thanks, that worked :)
<beach>
Sure.
andreyorst has quit [Ping timeout: 240 seconds]
zerno has quit [Quit: This computer has gone to sleep]
andreyorst` has joined #lisp
zerno has joined #lisp
karlosz has quit [Ping timeout: 264 seconds]
khisanth_ has joined #lisp
<aeth>
npfaro: COERCE also works, but you generally want to use MAKE-ARRAY because the :initial-contents part can be optimized when it's a quoted list like that...
vaporatorius__ has quit [Ping timeout: 246 seconds]
<aeth>
i.e. (coerce #(1 2 3 4) '(simple-array (unsigned-byte 8) (*))) where * is the size wildcard so you don't have to specify it (you could say (4) instead of (*))
Khisanth has quit [Ping timeout: 265 seconds]
<npfaro>
thanks!
<aeth>
In other words, use MAKE-ARRAY with a literal list as the initial-contents if you're making the array in the first place. Otherwise, if you already have a sequence and just need to convert it to another, COERCE.
<npfaro>
I'm htting it for the night, thank you all for the help :)
<aeth>
good night
npfaro has quit [Quit: ERC (IRC client for Emacs 26.3)]
narimiran has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
rgherdt has joined #lisp
zerno has quit [Quit: This computer has gone to sleep]
orivej has quit [Ping timeout: 256 seconds]
zerno has joined #lisp
_paul0 has joined #lisp
Oddity has joined #lisp
shka_ has joined #lisp
lowryder has quit [Ping timeout: 264 seconds]
Oddity- has quit [Ping timeout: 260 seconds]
paul0 has quit [Ping timeout: 260 seconds]
lowryder has joined #lisp
jprajzne has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
rumbler31 has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
emaczen has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Remote host closed the connection]
orivej has joined #lisp
villanella has quit [Remote host closed the connection]
random-nick has joined #lisp
ralt has joined #lisp
skapata has joined #lisp
gigetoo has quit [Ping timeout: 260 seconds]
gigetoo has joined #lisp
gaqwas has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
nullman has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
rogersm has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
edgar-xyz has quit [Quit: Leaving]
edgar-rft has joined #lisp
hjudt has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rgherdt has quit [Remote host closed the connection]
rgherdt has joined #lisp
logand has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
ljavorsk has joined #lisp
ljavorsk has quit [Ping timeout: 256 seconds]
andreyorst has joined #lisp
pve has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
liberliver has joined #lisp
adam4567 has quit [Remote host closed the connection]
andreyorst has quit [Ping timeout: 256 seconds]
tassleoff has joined #lisp
ukari has quit [Remote host closed the connection]
F________ has joined #lisp
F________ is now known as Feldman
zerno has quit [Quit: This computer has gone to sleep]
wxie has quit [Remote host closed the connection]
wxie has joined #lisp
orivej has joined #lisp
varjag has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
rwcom60280385034 is now known as nivet
heisig has joined #lisp
rumbler31 has joined #lisp
mood_ has joined #lisp
VincentVega has joined #lisp
mood has quit [Ping timeout: 256 seconds]
amb007 has quit [Ping timeout: 256 seconds]
ZharX242 has quit [Ping timeout: 256 seconds]
F________ has joined #lisp
amb007 has joined #lisp
ZharX242 has joined #lisp
F________ is now known as Feldman0
Feldman has quit [Ping timeout: 256 seconds]
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 246 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
frodef has quit [Remote host closed the connection]
frodef has joined #lisp
scymtym_ has quit [Remote host closed the connection]
albusp has quit [Quit: No Ping reply in 180 seconds.]
aartaka has joined #lisp
<jackdaniel>
Feldman0: i'll be in 15m
ljavorsk has joined #lisp
ZharX242 has quit [Ping timeout: 256 seconds]
galex-713 has quit [Ping timeout: 272 seconds]
albusp has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
galex-713 has joined #lisp
andreyorst has joined #lisp
<jackdaniel>
Feldman0: what's up?
galex-713 has quit [Ping timeout: 265 seconds]
galex-713 has joined #lisp
cosimone has quit [Quit: cosimone]
<beach>
I think Feldman0 wants to implement my generic-function dispatch technique for ECL, maybe.
<jackdaniel>
sounds good
<Feldman0>
yeah that's it
<jackdaniel>
currently ecl has gf dispatch mechanism operates on caches (see the file src/c/clos/gfun.d), however before the last release I've implemented class stamps
<jackdaniel>
that are a necessary prerequisite for that technique
<jackdaniel>
there are internal helper functions si::instance-obsolete-p and si::instance-sig-set to work with instances (used in clos/std-slot-value.lsp) defined in src/c/clos/instance.d
<jackdaniel>
there are a few problems: a single gf dispatch mechanism does not require additional compilation at runtime, while fast gf dispatch requires you to compile the dispatch function after gathering some information
<Feldman0>
Do you think that I'll have to implement it in C or in Lisp, I'm not quite sure in what what is done in ECL
<jackdaniel>
this function also may get invalidated for various reasons;
<jackdaniel>
I'm sure that it could be implemented in lisp and compiled with the compiler to c
<Feldman0>
My main struggle with reading the code base is, I'm not sure why something are in C or Lisp, is there a rule of thumb that is used or?
<jackdaniel>
so, regarding the problem -- compilation on ecl is slow, so either gf should be compiled in a separate thread, or manually triggered by i.e #'compile
<jackdaniel>
the common language runtime is implemented in c; while the rest is implemented in common lisp
<jackdaniel>
basically some low level operators needed to boostrap the language must be written in (or transpiled to) C (unless you decide to boostrap from another common lisp implementation)
<jackdaniel>
ecl also features a bytecodes compiler/interpreter (alongside native code compiler), and bytecmp is written in C
<Feldman0>
Ah right so it's like the clos-boot approach in SBCL, so my solution could be like the more fully featured clos written in CL
<jackdaniel>
you may think of the C part of the codebase as of a VM on top of which you could implement other languages (i.e common lisp)
<jackdaniel>
sure, you could think of it like that; notice that current gf dispatch machinery is written in C
<jackdaniel>
(and clos/ "just" uses it)
<jackdaniel>
afaik sbcl and ecl clos implementations are both based on the pcl implementation
<jackdaniel>
however they of course diverged with time
<jackdaniel>
if you have some detailed questions about ecl internals, you may join #ecl channel to not clutter the general chat with it
<jackdaniel>
(probably I should redirect you there from the beginning :)
<Feldman0>
I think this is probably fine for now; I just need to write up a draft project proposal and submit it to potential supervisior. It's a bit early for that even, but there's really only one good supervisor for this project so I'm trying to get him early.
<VincentVega>
Trying to pick a testing framework. Currently looking at prove. The lisp cookbook says "warning: Prove has a couple limitations and will soon be obsolete. We advise to start with another test framework." What limitations? Are there other frameworks that are better in some way?
<VincentVega>
I guess what I would want from a testing framework is that it just doesn't get in the way, so to speak. I want to have testing code at the top-level (right next the code that I need to test, I don't want to create a seperate file), but I don't want it to run during the compilation, but only be tracked by the framework, so that I can run it all
<VincentVega>
later if I want to. Eval'ing a form should run it though. Do any of the frameworks support this?
andreyorst has joined #lisp
<phoe>
I guess you can do that
<phoe>
parachute's define-test should support that
<VincentVega>
OK, I will take a look.
loke[m] has joined #lisp
<loke[m]>
Fiveam will also be do it
andreyorst has quit [Ping timeout: 240 seconds]
<VincentVega>
Sounds good : )
gxt has joined #lisp
<jackdaniel>
but if you want to be "the real common lisp programmer", you should write your own testing framework - it is a long lasting tradition among devs ,-)
<phoe>
;__;
<VincentVega>
jackdaniel: the one which would be better than all of them, right? tempting...
bjorkintosh has quit [Remote host closed the connection]
bjorkintosh has joined #lisp
frodef has quit [Remote host closed the connection]
awkravchuk has quit [Quit: Leaving]
<jmercouris>
why does string-equal exist when you can just use equal?
<jmercouris>
will it be faster?
frodef has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
<jackdaniel>
hint: it has a different lambda list
nullman has joined #lisp
sm2n_ has quit [Read error: Connection reset by peer]
<jmercouris>
jackhill: so what, you could also slice the lists and use equal
heredoc has joined #lisp
<jmercouris>
it's literally the same thing
tumdum has joined #lisp
<jackdaniel>
aha
<Bike>
if you slice the lists with subseq that will cons up a new substring.
sm2n_ has joined #lisp
<Bike>
string-equal can just iterate over the indices instead.
rumbler31_ has joined #lisp
<Bike>
sorry, if you slice the strings with subseq*
<jmercouris>
I see
<jmercouris>
ok, so there is a performance benefit
<jmercouris>
IF we are dealing with slicing
<Bike>
and string-equal can also use more direct comparisons, as you implied
<jmercouris>
fair enoug
<jmercouris>
s/enoug/enough
<Bike>
it can just do character comparisons instead of dispatching on types
<jmercouris>
hm I see
<jackdaniel>
Bike: equal could do that too (under the hood, after realizing that both are strings)
<jmercouris>
thank you
<Bike>
yeah you're right
<jmercouris>
I assume only the behavior of equal is defined, not the implementation details
<jmercouris>
but I think you would be writing something really complex if equal had to realize you were slicing
<jmercouris>
I guess there are more than two ways to slice a melon
<jackdaniel>
that's not what I've been saying
<jmercouris>
I know what you were saying
<jmercouris>
I was adding a tangential thought
<jmercouris>
also you are a goldfish
<jackdaniel>
you speak nonsense
<jmercouris>
that is a good thing, they are my favorite type of fish
<jmercouris>
I'm in a bit of a silly mood, yes
<Bike>
a sufficiently smart compiler TM maybe could elide the subseq calls sometimes
<Bike>
i don't know if any actual lisp does
<Bike>
i don't think sbcl does, though it does convert equal to string= when it can
<jmercouris>
at any rate, string= does adhere to the specificity style
<jmercouris>
the reader can see, aha! we are comparing strings
<jmercouris>
it gives some type information
<phoe>
the reader? you mean a human reader or the lisp reader?
<phoe>
or the compiler that recognizes that the values being compared are both strings?
<jmercouris>
human reader
bitmapper has joined #lisp
<jmercouris>
we should use the abbreviation hreader for human reader
<beach>
Use your abbrev processor.
<beach>
And yes, string= is more specific, so it falls under the rule that one should always use the more specific construct that will have the desired effect.
sjl has joined #lisp
<beach>
That rule does not apply to the creators of a language standard, though.
<jmercouris>
it applies to why we might use it
<jmercouris>
that's really my question
<beach>
Sure.
<pfdietz>
One could imagine a sufficiently smart compiler that would transform (equal (subseq s ...) (subseq s2 ...)) into a call to string=, but I don't think any existing compilers do that.
<beach>
But Common Lisp is not about minimalism. It's about giving the programmer a good toolbox.
<jmercouris>
pfdietz: that's what I was hinting at with my comment that jackdaniel did not understand
<pfdietz>
(Note to self: add rtp tests for equal + subseq)
frodef has quit [Remote host closed the connection]
tassleoff has joined #lisp
frodef has joined #lisp
ey[m]2 has quit [Quit: Bridge terminating on SIGTERM]
eymebolofscrumpe has quit [Quit: Bridge terminating on SIGTERM]
jonas[m]2 has quit [Quit: Bridge terminating on SIGTERM]
ey[m]1 has quit [Quit: Bridge terminating on SIGTERM]
ey[m] has quit [Quit: Bridge terminating on SIGTERM]
ThaEwat has quit [Quit: Bridge terminating on SIGTERM]
quanta[m] has quit [Quit: Bridge terminating on SIGTERM]
katco has quit [Quit: Bridge terminating on SIGTERM]
jdormit[m] has quit [Quit: Bridge terminating on SIGTERM]
christopheroei[m has quit [Quit: Bridge terminating on SIGTERM]
solideogloria[m] has quit [Quit: Bridge terminating on SIGTERM]
keizerrijk[m] has quit [Quit: Bridge terminating on SIGTERM]
etimmons has quit [Quit: Bridge terminating on SIGTERM]
stargazesparkle has quit [Quit: Bridge terminating on SIGTERM]
MrtnDk[m] has quit [Quit: Bridge terminating on SIGTERM]
santiagopim[m] has quit [Quit: Bridge terminating on SIGTERM]
ms[m] has quit [Quit: Bridge terminating on SIGTERM]
ecm has quit [Quit: Bridge terminating on SIGTERM]
even4void[m] has quit [Quit: Bridge terminating on SIGTERM]
backinaweek[m] has quit [Quit: Bridge terminating on SIGTERM]
arichiardi[m] has quit [Quit: Bridge terminating on SIGTERM]
dmiles[m] has quit [Quit: Bridge terminating on SIGTERM]
cairn has quit [Quit: Bridge terminating on SIGTERM]
posthuman_egrego has quit [Quit: Bridge terminating on SIGTERM]
infra_red[m] has quit [Quit: Bridge terminating on SIGTERM]
Lolicon[m] has quit [Quit: Bridge terminating on SIGTERM]
deselby has quit [Quit: Bridge terminating on SIGTERM]
kaisyu[m] has quit [Quit: Bridge terminating on SIGTERM]
loke[m] has quit [Quit: Bridge terminating on SIGTERM]
susam has quit [Quit: Bridge terminating on SIGTERM]
anotherone9999[m has quit [Quit: Bridge terminating on SIGTERM]
Gnuxie[m] has quit [Quit: Bridge terminating on SIGTERM]
malaclyps_ has quit [Quit: Bridge terminating on SIGTERM]
dieggsy has quit [Quit: Bridge terminating on SIGTERM]
chipk[m] has quit [Quit: Bridge terminating on SIGTERM]
Codaraxis__ has quit [Remote host closed the connection]
Codaraxis__ has joined #lisp
mrcom has joined #lisp
nckx has quit [Ping timeout: 264 seconds]
nckx has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
cairn has joined #lisp
rumbler31_ has quit [Ping timeout: 256 seconds]
<jackdaniel>
jmercouris: I've merely corrected you from implying I've said something that I did not. "sufficiently smart compilers" was a fad years before I've started working with common lisp
<jackdaniel>
s/was/were/
neirac has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
kaun_ has quit [Quit: bas]
lalitmee has joined #lisp
lalitmee has quit [Quit: Leaving]
even4void[m] has joined #lisp
Gnuxie[m] has joined #lisp
ThaEwat has joined #lisp
santiagopim[m] has joined #lisp
katco has joined #lisp
quanta[m] has joined #lisp
kaisyu[m] has joined #lisp
dieggsy has joined #lisp
MrtnDk[m] has joined #lisp
skye0[m] has joined #lisp
infra_red[m] has joined #lisp
deselby has joined #lisp
jdormit[m] has joined #lisp
malaclyps_ has joined #lisp
christopheroei[m has joined #lisp
loke[m] has joined #lisp
ms[m] has joined #lisp
posthuman_egrego has joined #lisp
arichiardi[m] has joined #lisp
dmiles[m] has joined #lisp
etimmons has joined #lisp
susam has joined #lisp
stargazesparkle has joined #lisp
chipk[m] has joined #lisp
32NAAL4OF has joined #lisp
anotherone9999[m has joined #lisp
ecm has joined #lisp
jonas[m]2 has joined #lisp
7ITAAI1SC has joined #lisp
Lolicon[m] has joined #lisp
keizerrijk[m] has joined #lisp
eymebolofscrumpe has joined #lisp
solideogloria[m] has joined #lisp
ukari has joined #lisp
mindCrime has joined #lisp
waleee-cl has joined #lisp
logand has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 265 seconds]
rumbler31_ has joined #lisp
aartaka has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
rumbler31_ has quit [Ping timeout: 240 seconds]
mrios22 has quit [Ping timeout: 260 seconds]
shka_ has quit [Quit: Konversation terminated!]
shka_ has joined #lisp
zerno_ has quit [Quit: This computer has gone to sleep]
zerno_ has joined #lisp
tassleoff has quit [Ping timeout: 260 seconds]
zerno_ has quit [Client Quit]
Nilby has joined #lisp
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 260 seconds]
andreyorst` has quit [Quit: andreyorst`]
vaporatorius has joined #lisp
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
frodef has quit [Remote host closed the connection]
Codaraxis_ has joined #lisp
Codaraxis__ has quit [Read error: Connection reset by peer]
zerno_ has joined #lisp
frodef has joined #lisp
rumbler31 has joined #lisp
<jmercouris>
jackdaniel: I merely corrected you from implying that I implied that you said something which you didn’t
<Bike>
can you please stop being so catty with each other every single time
rumbler31 has quit [Ping timeout: 264 seconds]
<Josh_2>
Ello
gproto23 has joined #lisp
bilegeek has joined #lisp
gproto23 has quit [Client Quit]
skapata has quit [Ping timeout: 272 seconds]
surabax has quit [Quit: Leaving]
zmv has quit [Ping timeout: 240 seconds]
Lord_of_Life_ has joined #lisp
gxt has quit [Remote host closed the connection]
skapata has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
orivej has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
liberliver has quit [Quit: liberliver]
hnOsmium0001 has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
rumbler31_ has joined #lisp
tassleoff has joined #lisp
dbotton has joined #lisp
<jmercouris>
Bike: :-D
<jmercouris>
Will try
VincentVega has quit [Quit: Ping timeout (120 seconds)]
pfdietz has quit [Quit: Ping timeout (120 seconds)]
logand has joined #lisp
<dbotton>
Is there documentation / some sort of tutorial on the best way today to handle foreign C code. Seems there are a few paths when last looked.
<jackdaniel>
dbotton: do you mean ffi calls or something else?
<dbotton>
Yes
<jackdaniel>
cffi is a usual goto answer (it also superseded uffi and provides compatibility layer with it)
<dbotton>
Is their a tutorial on how to use you maybe recommend?
<jackdaniel>
there is also cffi-groveller to generate bindings automatically (cl-autowrap seems to have a similar purpose) - I've never used grovellers though
<jackdaniel>
cffi has a documentation; when unsure I usually look at tests in the source code
<dbotton>
Ok and I assume works in scbl and ecl
<jackdaniel>
yes
<dbotton>
Thank you
<Nilby>
The cffi manual is quite good and has a tutorial.
<jackdaniel>
on ecl there is a special flag to make things faster (by writing inlined calls) it is disabled by default because there is no good translation between pointer types between ecl and cffi (something possible to fix with extra effort)
<jackdaniel>
basically it boils down to the fact, that modern C compilers won't accept a declaration void*(*)() to a function int*(*)()
<jackdaniel>
(mismatch between pointer return value declarations is not allowed)
<dbotton>
Would be good to use but don't want for this project anything that is implementation specific
<jackdaniel>
it is just a flag in cffi
<dbotton>
Ok
<jackdaniel>
#+ecl (setf cffi::*that-flag-I-don-t-rememmber-name-of* :static) or something in this spirit
paulj has joined #lisp
<jackdaniel>
(look up the code)
<dbotton>
I thought meant could do inline c
<dbotton>
In middle of lisp code
<jackdaniel>
no, it is a flag that decides how foreign calls are resolved
<jackdaniel>
ecl can do it three ways: dynamic ffi, dlopen ffi and static ffi - cffi implements all three
liberliver has joined #lisp
<jackdaniel>
the last one is not enabled by default because of the reason I've mentioned
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lucasb has joined #lisp
anticrisis has joined #lisp
Bahman has joined #lisp
secretmyth has joined #lisp
Bahman has quit [Quit: Connection closed]
McParen has joined #lisp
andreyorst has joined #lisp
mmmattyx has quit [Quit: Connection closed for inactivity]
pfdietz has joined #lisp
wsinatra_ has joined #lisp
wsinatra has quit [Read error: Connection reset by peer]
mmmattyx has joined #lisp
london has joined #lisp
flatheap has quit [Quit: Connection closed for inactivity]
Nilby has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 258 seconds]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
tumdum has quit [Quit: Leaving]
london has quit [Ping timeout: 246 seconds]
tumdum has joined #lisp
tumdum has joined #lisp
zerno_ has quit [Quit: This computer has gone to sleep]
mindCrime has joined #lisp
tassleoff_ has joined #lisp
tumdum has quit [Client Quit]
tumdum has joined #lisp
tumdum has joined #lisp
Lycurgus has joined #lisp
tassleoff has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
zerno_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Inline has joined #lisp
lowryder has quit [Ping timeout: 256 seconds]
Lycurgus has quit [Quit: Exeunt]
lowryder has joined #lisp
Sauvin has quit [Read error: Connection reset by peer]
mindCrime has quit [Ping timeout: 264 seconds]
aorst has joined #lisp
logand has quit [Ping timeout: 246 seconds]
ark has quit [*.net *.split]
shenghi1 has quit [*.net *.split]
billstclair has quit [*.net *.split]
parisienne has quit [*.net *.split]
jsatk has quit [*.net *.split]
p_l has quit [*.net *.split]
ark has joined #lisp
parisienne has joined #lisp
jsatk has joined #lisp
p_l has joined #lisp
shenghi1 has joined #lisp
billstclair has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
rumbler31 has joined #lisp
heisig has quit [Quit: Leaving]
charles` has quit [Ping timeout: 264 seconds]
rumbler31 has quit [Ping timeout: 246 seconds]
cage_ has quit [Quit: Leaving]
tgbugs has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
VincentVega has joined #lisp
aorst is now known as andreyorst[m]
McParen has left #lisp [#lisp]
VincentVega has quit [Quit: Connection closed]
andreyorst has quit [Ping timeout: 264 seconds]
paulj has quit [Remote host closed the connection]
npfaro has joined #lisp
<npfaro>
If I have an array with a fill pointer at a certain spot (with more room past the fill pointer) how do I copy another array into where the fill pointer is, advancing the fill pointer
<Bike>
i would manually increment the fill pointer and then use replace to do the copy, i think.
<Bike>
or of course you could vector-push repeatedly
<Bike>
i don't think there's a built in operator for this
<npfaro>
aight, thanks
aspr has quit [Ping timeout: 264 seconds]
rogersm has quit [Quit: Leaving...]
npfaro` has joined #lisp
anticrisis_ has joined #lisp
johnjay has quit [Ping timeout: 256 seconds]
devon has quit [Ping timeout: 256 seconds]
npfaro has quit [Ping timeout: 256 seconds]
andreyorst[m] has quit [Ping timeout: 256 seconds]
scymtym_ has joined #lisp
Lord_of_Life has quit [Excess Flood]
etothpiiminus1 has quit [Ping timeout: 256 seconds]
anticrisis has quit [Ping timeout: 256 seconds]
albusp has quit [Ping timeout: 256 seconds]
scymtym has quit [Ping timeout: 256 seconds]
random-nick has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #lisp
albusp has joined #lisp
random-nick has joined #lisp
frgo has joined #lisp
andreyorst[m] has joined #lisp
johnjay has joined #lisp
frgo_ has quit [Ping timeout: 272 seconds]
etothpiiminus1 has joined #lisp
etothpiiminus1 has quit [Ping timeout: 256 seconds]
charles` has joined #lisp
etothpiiminus1 has joined #lisp
shka_ has quit [Ping timeout: 265 seconds]
etothpiiminus1 has quit [Remote host closed the connection]
charles` has quit [Ping timeout: 264 seconds]
VincentVega has joined #lisp
zerno_ has quit [Quit: This computer has gone to sleep]
zerno_ has joined #lisp
scymtym_ has quit [Remote host closed the connection]
<pfdietz>
I came across this problem recently, and did it manually.
<pfdietz>
I had to manually adjust the array; just increasing the fill-pointer doesn't extend the array.
<npfaro`>
pfdietz: if you were replying to me (i disconnected for a bit sorry) then I already allocated the array to be big enough from the start
<pfdietz>
Understood. I had not.
<VincentVega>
kind of silly i haven't figured this one out yet, but in sly/slime how do you go to the line/function where an error occurs (when loading a project)? Looking at the backtrace every time is proving to be a bit of a hassle.
<Xach>
VincentVega: "v" on a frame is what i use
<VincentVega>
Xach: Oh good. It works. Thanks.
<VincentVega>
hmmm is there some trick to a frame that appears in the current project?
<Xach>
what do you mean by project? (and "trick"?)
<VincentVega>
package
<VincentVega>
trick to go to a frame
<VincentVega>
sry
<Xach>
Oh, like, to skip irrelevant-to-you frames and get to something that might be more meaningful?
<VincentVega>
yeah
<Xach>
I don't know of anything like that, but there are many things I don't know
<VincentVega>
that's cool : )
mindCrime has joined #lisp
<npfaro`>
How do you folks define a variable in the repl for temporary use?
<npfaro`>
defparameter/defvar or just setf'ing some nonexistant thing?
<npfaro`>
or somehow else?
<Xach>
npfaro`: i usually use (defparameter *myvar* ...)
<Xach>
I use sbcl which complains a lot if you use setf/setq.
<npfaro`>
even just for some throwaway var?
<Xach>
yes.
<npfaro`>
alright, thanks
<Xach>
if it's really throwaway i try to work with */**/***, and i'm learning sly's #vN history syntax too.
madand has left #lisp ["Killed buffer"]
dbotton has quit [Quit: This computer has gone to sleep]
Inline has quit [Ping timeout: 272 seconds]
judson_ has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
caret has quit [Quit: Leaving]
zerno_ has quit [Quit: This computer has gone to sleep]
trocado has quit [Ping timeout: 265 seconds]
zerno_ has joined #lisp
secretmyth has quit [Quit: Leaving]
wsinatra_ has quit [Quit: WeeChat 3.0]
zmv has joined #lisp
zmv has quit [Changing host]
zmv has joined #lisp
nij has joined #lisp
johnjay has quit [Ping timeout: 260 seconds]
johnjay has joined #lisp
narimiran has quit [Ping timeout: 260 seconds]
luckless has quit [Ping timeout: 268 seconds]
dbotton has joined #lisp
pillton has joined #lisp
dbotton has quit [Quit: Leaving]
luckless has joined #lisp
zmv is now known as livoreno
pve has quit [Quit: leaving]
[d] has quit [Remote host closed the connection]
zerno_ has quit [Quit: This computer has gone to sleep]
zerno_ has joined #lisp
Vultyre_ has quit [Quit: Leaving]
charles` has joined #lisp
scymtym has joined #lisp
emaczen has joined #lisp
mmmattyx has quit [Quit: Connection closed for inactivity]
sjl has quit [Ping timeout: 256 seconds]
rgherdt has quit [Ping timeout: 256 seconds]
galex-713 has quit [Ping timeout: 264 seconds]
[d] has joined #lisp
galex-713 has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
aeth has quit [Ping timeout: 265 seconds]
[d] has quit [Excess Flood]
[d] has joined #lisp
aeth has joined #lisp
bendersteed has joined #lisp
Josh_2 has quit [Remote host closed the connection]