karlosz has quit [Read error: Connection reset by peer]
slyrus1 has joined #lisp
slyrus2 has quit [Ping timeout: 246 seconds]
tgbugs has quit [Ping timeout: 264 seconds]
euandreh has quit [Ping timeout: 272 seconds]
<Josh_2>
Xach: It's been quite a while since I've looked at that chapter in PCL, I ended up looking in OO in CL by Sonja Keene
mikecheck has left #lisp ["WeeChat 2.9"]
orivej_ has joined #lisp
orivej has quit [Ping timeout: 276 seconds]
random-nick has quit [Ping timeout: 258 seconds]
tgbugs has joined #lisp
ebrasca has quit [Remote host closed the connection]
luni has quit [Quit: Connection closed]
mrchampion has quit [Ping timeout: 240 seconds]
mrchampion has joined #lisp
frodef has quit [Ping timeout: 256 seconds]
<Josh_2>
If I want to use (call-next-method) in primary methods and :most-specific-last do I have to define my own method combination?
<Bike>
do you want standard method combination or something else?
<Josh_2>
Standard should work
<Bike>
i don't think you can reverse the order in standard method combination, so i suppose you would need your own combination indeed.
<Josh_2>
oh boy
<Josh_2>
or would also work
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<Bike>
the reason call-next-method doesn't work in primary methods of the OR combination is that all the methods are involved without it anyway
<Bike>
e.g. if A is a subclass of B and they both have methods, you just have (or a-method b-method) or (or b-method a-method), so what would call-next-method be good for?
<Josh_2>
well if b-method takes a while then this is useful
Sweedish has joined #lisp
<Bike>
huh?
<Bike>
i mean, you can choose which order you want, but that doesn't involve call-next-method.
peasynt has quit [Quit: quit.]
<Bike>
can you describe what behavior you want exactly?
euandreh has joined #lisp
<Josh_2>
to call the least specific method first, if non nil then return this, otherwise keep calling until reaching most specific
<mfiano>
primary or auxillary?
<Josh_2>
primary
<mfiano>
Good. Changing the order in standard combination will not affect the aux methods
<mfiano>
Just write some dummy code and see if it behaves how you want? If not, come back and revise your question
<mfiano>
and we'll have code to see what you are doing and what you expect
<Bike>
in that case i don't see why you need call next method at all. just use the OR combination with :most-specific-last
<Bike>
it works exactly how you described.
<Josh_2>
That is what I assumed
<Josh_2>
I will just make sure that it isn't something else
_whitelogger has joined #lisp
_whitelogger has joined #lisp
Christ0pher has joined #lisp
CrazyEddy has quit [Ping timeout: 240 seconds]
<Josh_2>
Okay it worked
<Josh_2>
Thanks Bike
<Bike>
mhm
CrazyEddy has joined #lisp
notzmv has joined #lisp
<Josh_2>
Wasn't a problem due to method combinations etc I just wasnt getting a non nil val when I expected it, I sorted that and all is good
catt has quit [Remote host closed the connection]
charles` has quit [Ping timeout: 258 seconds]
toorevitimirp has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
attila_lendvai has quit [Ping timeout: 240 seconds]
mrcom has quit [Ping timeout: 265 seconds]
ralt has quit [Quit: Connection closed for inactivity]
semz has quit [Ping timeout: 258 seconds]
elflng has quit [Read error: No route to host]
elflng has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
logand` has joined #lisp
logand has quit [Ping timeout: 264 seconds]
marusich has joined #lisp
micro has quit [Ping timeout: 240 seconds]
micro has joined #lisp
Anonymous_ has joined #lisp
Codaraxis__ has joined #lisp
marusich has quit [Ping timeout: 240 seconds]
zacts has joined #lisp
asarch has joined #lisp
<asarch>
How could I print "2021-02-01" instead of "2021-2-1"? I mean, the leading 0s
<dbotton>
I will flesh out more of it, but then will start on the visual tools I have planned
notzmv has quit [Remote host closed the connection]
dbotton has quit [Quit: Leaving]
<beach>
Good morning everyone!
charles` has joined #lisp
Nilby has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
aartaka_d has joined #lisp
theothornhill has joined #lisp
aartaka has quit [Ping timeout: 276 seconds]
Bike has quit [Quit: Lost terminal]
theothornhill has quit [Ping timeout: 276 seconds]
marusich has quit [Ping timeout: 256 seconds]
notzmv has joined #lisp
emacsomancer has quit [Ping timeout: 246 seconds]
skapata has quit [Remote host closed the connection]
marusich has joined #lisp
Codaraxis_ has joined #lisp
terpri has quit [Ping timeout: 264 seconds]
zaquest has quit [Quit: Leaving]
Codaraxis__ has quit [Ping timeout: 258 seconds]
marusich has quit [Ping timeout: 276 seconds]
emacsomancer has joined #lisp
emacsomancer has quit [Excess Flood]
zaquest has joined #lisp
emacsomancer has joined #lisp
aorst has joined #lisp
aorst has quit [Client Quit]
narimiran has joined #lisp
terpri has joined #lisp
Stargazer2005 has joined #lisp
theothornhill has joined #lisp
iskander- has quit [Quit: bye]
waleee-cl has quit [Quit: Connection closed for inactivity]
theothornhill has quit [Remote host closed the connection]
sm2n has quit [Quit: Leaving]
sm2n has joined #lisp
mrcom has joined #lisp
texno has joined #lisp
Stargazer2005 has quit [Quit: Connection closed]
euandreh has quit [Ping timeout: 264 seconds]
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 265 seconds]
marusich has joined #lisp
orivej has joined #lisp
stirfoo has joined #lisp
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
stirfoo has quit [Quit: ERC (IRC client for Emacs 27.1)]
marusich has quit [Quit: Leaving]
hjudt has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
lowryder_ has quit [Ping timeout: 246 seconds]
lowryder_ has joined #lisp
shka_ has joined #lisp
hendursa1 has quit [Remote host closed the connection]
hendursa1 has joined #lisp
maier has joined #lisp
random-nick has joined #lisp
Cymew has joined #lisp
niceplace has joined #lisp
imode has quit [Ping timeout: 240 seconds]
Major_Biscuit has joined #lisp
maier has quit [Quit: Lost terminal]
<Nilby>
Is there a recommended way to iterate over generic sequences in parallel [not multi-threaded] ? By generic I mean at least something that could be a list or vector.
Codaraxis__ has joined #lisp
<jdz>
Nilby: MAP.
<no-defun-allowed>
You can use (map 'nil (lambda (element) ...) sequences ...) - replace 'nil with a sequence type specifier if it should return another sequence from the value returned by the function.
<Nilby>
Thanks. I can't believe I didn't know that.
ex_nihilo has quit [Client Quit]
ex_nihilo has joined #lisp
totoro2022 has quit [Read error: Connection reset by peer]
<phoe>
/30
<phoe>
oop
totoro2022 has joined #lisp
rgherdt has joined #lisp
<Alfr>
Nilby, I'm wondering what "in parallel" means to you, as when you only have one thread you're only going to do one computation at any given time. (Ignoring the costly variation of forking and then communicating back a result.)
<no-defun-allowed>
You would step the elements of the sequences in parallel.
<Nilby>
Alfr: Right. I just wanted to be clear about the word parallel.
<no-defun-allowed>
e.g (map 'list f a b) = (list (funcall f (elt a 0) (elt b 0)) (funcall f (elt a 1) (elt b 1)) ...)
euandreh has joined #lisp
<Alfr>
Oh, never thought of this interpretation.
<Alfr>
Thanks. :)
<Nilby>
Although I think things like let and psetq leave the possibility of concurency.
niceplace has quit [K-Lined]
<Nilby>
no-defun-allowed: I hope it doesn't really use elt on lists.
<no-defun-allowed>
The forms that provide values in LET and PSETQ could have side effects, and thus would have to be evaluated in series to obey Common Lisp semantics. But I think lparallel has some kind of `plet` which also explicates data dependencies.
<no-defun-allowed>
Nilby: No, probably not. But it is indicative of what MAP will return.
<Nilby>
Hmmm. But let and psetq can at least re-order the evaluation.
<Nilby>
maybe? I don't really know
<no-defun-allowed>
Not generally - (let ((a ...)) (let ((b (setf a ...)) (c a)) ...) although obtuse, cannot be reordered.
<no-defun-allowed>
"The form [elided] first evaluates the expressions init-form-1, init-form-2, and so on, in that order, saving the resulting values."
mrios22 has joined #lisp
<Nilby>
Hmmm. It does say "in that order". I wonder if compilers can reorder or vectorize if they know there's no side effects.
<no-defun-allowed>
I don't see why not.
<Nilby>
except for things like cache timing attacks :o
surabax has joined #lisp
pve has joined #lisp
iskander has joined #lisp
gxt has joined #lisp
theothornhill has joined #lisp
zacts has quit [Ping timeout: 256 seconds]
anticrisis has quit [Read error: Connection reset by peer]
heisig has joined #lisp
villanella has joined #lisp
hendursaga has joined #lisp
hendursa1 has quit [Ping timeout: 268 seconds]
APic has quit [Ping timeout: 240 seconds]
cosimone has joined #lisp
pve_ has joined #lisp
tassleoff has joined #lisp
pve has quit [Ping timeout: 240 seconds]
pve_ is now known as pve
APic has joined #lisp
theothor` has joined #lisp
aartaka has joined #lisp
theothor` has quit [Remote host closed the connection]
ljavorsk has joined #lisp
aartaka_d has quit [Ping timeout: 264 seconds]
tassleoff has quit [Ping timeout: 272 seconds]
ralt has joined #lisp
frodef has joined #lisp
daphnis has joined #lisp
<daphnis>
is there any nice technique for avoiding a slightly shorter first line in docstrings?
<beach>
Why would there be a shorter first line?
<beach>
I recommend you make every line not too wide.
<beach>
And you can make them look nice(r) by using #.(format nil "First line ... ~@<newline> Second line...~@...")
<beach>
That way, you can align the leftmost character of each line.
<beach>
So you get the entire docstring indented, but you have to do the indentation "manually".
<daphnis>
because it will be automatically indented
<beach>
I don't understand.
<Nilby>
daphnis: I think you just have to accept that good docstring output must be done by something that isn't just write-string. Like it depends on the width of your window too.
<daphnis>
if you use emacs auto-fill, then if a docstrings begin with more indentation than in subsequent lines, the first will be shorter
<beach>
Yes, Emacs is not doing a good job with documentation strings.
<Nilby>
I output docstrings with a thing that trys to fill paragraphs to the window width.
<heisig>
I fully agree with daphnis. Since the first line of a docstring of something like a DEFUN starts with ' "'. it is three characters shorter than each subsequent line. That is mildly annoying.
<pve>
daphnis: you could use that while waiting for a proper solution :)
Lord_of_Life has quit [Ping timeout: 246 seconds]
<Nilby>
The real problem is people write docstrings in a quirky way that sometimes could be word filled, but sometimes expects fixed-width pre-formmated spacing.
<daphnis>
mfiano: oh i see, i didn't realize you meant inside format
Lord_of_Life_ is now known as Lord_of_Life
igemnace has quit [Remote host closed the connection]
<daphnis>
but how do i get the argument to defgeneric's :documentation evaluated?
<beach>
I think I told you that.
<beach>
#.(format ...)
amk has quit [Remote host closed the connection]
<daphnis>
ah, thanks
amk has joined #lisp
<mfiano>
Also, there's #'(setf documentation)
<beach>
That doesn't solve the layout problem, but it solves the problem that the docstring is noise to the person reading the code.
<mfiano>
That is, documentation for defgeneric need not be inside defgeneric.
<beach>
And it really shouldn't be.
<beach>
And, since the docstring to the person reading the code, there is a tendency to make docstrings (too) short, which kind of defeats the purpose.
<beach>
My favorite one is from SBCL (DOCUMENTATION 'CAR 'FUNCTION)
<beach>
"Return the 1st object in a list."
<Nilby>
Sadly the ratio of missing docstrings even in the abundant sbcl, is about .44
<beach>
How did you compute that? I mean, not every function or class or whatever requires one. If the code is relevant only to the person reading it, and is not part of some protocol, there is no particular reason to write a docstring. A comment is then more relevant.
<Nilby>
I'm not talking about the implementation code, just the exported symbols from the CL package.
<beach>
OK, that's definitely relevant.
<Nilby>
I wrote a thingy to calculate it.
notzmv has quit [Remote host closed the connection]
surabax has quit [Quit: Leaving]
<Nilby>
I've been slowly working on a package to add any missing docstrings to any implementation.
<beach>
Interestingly, many such docstrings should be different from the wording of the Common Lisp HyperSpec.
Inline has quit [Quit: Leaving]
<Nilby>
Yes. Also the copyright issue is troublesome.
<beach>
Because a lot of behavior is undefined by the standard, but defined by the implementation, so the documentation should document the real behavior.
notzmv has joined #lisp
<Nilby>
I think the ratio of .44 is quite admirable as these things go.
<mfiano>
Lots of errata too, like the infamous PROG2.
<Nilby>
None of the progs have docstring in sbcl ):
<beach>
I don't think that CAR needs a docstring, since it is well defined by the standard, but if it has one, it should at least be correct, and it should probably contain information about what subtype of TYPE-ERROR is signaled.
<flip214>
beach: I think that the type-error should be seen by a SSC and returned via the derived type information
rumbler31 has joined #lisp
<beach>
AREF on the other hand has lots of undefined behavior that justifies a documentation string.
<beach>
flip214: I don't understand what that means. Could you elaborate?
ebrasca has joined #lisp
villanella has joined #lisp
tassleoff has quit [Ping timeout: 256 seconds]
<flip214>
beach: If you (defun foo (x) (1+ (round x)))
rumbler31 has quit [Ping timeout: 240 seconds]
<flip214>
then sbcl can give you Derived type: (FUNCTION (T) (VALUES INTEGER &OPTIONAL))
<beach>
flip214: What I meant was that, if someone wants to write SBCL-specific code, and that someone wants to handle the error, it should be documented that (say) SB-CAR-WAS-GIVEN-A-NON-LIST is the error signaled.
<flip214>
so the return value is automatically derived. similarly, possible errors could be seen and listed here.
<beach>
How would that look in this case?
<beach>
And what would be the form to evaluate to see it?
<flip214>
yeah, I mean that the compiler might be able to list potential conditions (or at least errors) that are signalled.
<beach>
Is that enough though?
<beach>
Different error types could be signaled in different situations.
<beach>
Then you would have to make the error type name really explicit.
<flip214>
by incorporating the information of functions called in there as well...
<beach>
Oh, for DESCRIBE?
paulj has quit [Remote host closed the connection]
<flip214>
though that might become a long list
<flip214>
yeah, is that a bad idea?
<beach>
The commercial vendors would not agree to give the function lambda expression for their code.
<flip214>
that's just because I evaluated it directly... when compiling a source location (or nothing) might be given, depending on the DEBUG quality I guess
<beach>
But that is where the information is given that you said was generated automatically.
<Nilby>
but you can't know all errors a thing might signal
<beach>
Sure, that's probably undecidable in general.
<beach>
My point is: If I want to find out what error type CAR signals when given a non-list, what form should I type to get that information.
<beach>
I argued that it should be (DOCUMENTATION 'CAR 'FUNCTION), and flip214 argued that i could write (DESCRIBE 'CAR) or something like that.
<beach>
Either way, I think that the information must be given manually.
<Nilby>
I like the documentation vs. the describe which doesn't seem very feasible. But I do like describe to figure out as much as possible.
<Alfr>
beach, I'd argue for (describe #'car); documentation should only give you that doc string.
totoro2022 has quit [Ping timeout: 246 seconds]
<beach>
Alfr: What docstring?
<Alfr>
That cryptic "Return the 1st object in a list." mentioned above.
totoro2022 has joined #lisp
<beach>
Alfr: But it's wrong!
<beach>
If given NIL, then it is not returning the first element of the list, because there is no such element.
<beach>
And if it is given a non-list, it doesn't specify what happens.
<Alfr>
beach, I mean as to /what/ (documentation 'car 'function) should return, not whether sbcl's docstring for car is correct.
pankajsg has joined #lisp
<beach>
It is an interesting question though, how the responsibility should be divided between DOCUMENTATION and DESCRIBE. I see DESCRIBE as being used mainly for objects that don't have documentation associated with them, like ordinary instances of standard classes.
<beach>
And for functions, I see no profound reason why the errors it may signal should be omitted from the documentation string.
vegansbane6963 has joined #lisp
<Alfr>
Or put it an other way, if you want additional information an implementation may provide, you should consult DESCRIBE. For example DEFUN arranges to set (documentation 'foo 'function) to documentation if it is provided.
<Alfr>
So a program may depend on them being unchanged (or unavailable).
<flip214>
beach: well, how about an (documentation 'car 'derived-conditions) or similar? could be integrated in IDEs that way.
<Nilby>
I think for most functions even the author of the function doesn't not know what errors something can signal, only what is explicitly signaled for useful purposes.
<Nilby>
s/not//
fiveop has joined #lisp
fiveop has quit [Client Quit]
fiveop has joined #lisp
<flip214>
that's why I propose that the compiler keeps track as good as possible
<mrios22>
What's the best way to upgrade to emacs27 if I'm using ubuntu? (actually mint linux?)
* flip214
grumbles "apt-get install neovim"
<mrios22>
Sorry, wrong IRC!
ukari has quit [Remote host closed the connection]
<mrios22>
should have been #emacs
ukari has joined #lisp
madage has quit [Ping timeout: 268 seconds]
gxt has joined #lisp
mrios22 has quit [Remote host closed the connection]
<phoe>
I have no idea what exactly it does, but I used cl-yesql + postmodern back in the day
<phoe>
and I liked it
<v3ga>
also would you say i'm being foolish by wanting to write sql by hand opposed to cl-sql?
<v3ga>
phoe: that will do. hugsql seems to have been inspired by yesql. I figured it was originally from CL. My entry to coding was ruby so since then i've liked getting an understanding of whats really taking place... *dealing with actual sql for one*
<phoe>
cl-yesql came from yesql which is a clojure library
<v3ga>
ahh reverse....well still cool. thats exactly what I want for now
<Nilby>
v3ga: you can write sql by hand even with clsql, but if you use lispy syntax it might even work on multiple backends
<Nilby>
with clsql i had production code that worked on oracle, ms sql server, mysql, and postgresql
KREYREEN has quit [Remote host closed the connection]
KREYREEN has joined #lisp
skye0[m] has left #lisp ["User left"]
<v3ga>
Nilby: I see...well maybe i'll give it a whirl since i'm already familiar with yesql but CLs OO system is new. I'm reading an article here...is the elephant library still used? https://common-lisp.net/project/elephant/
aartaka has joined #lisp
VincentVega has joined #lisp
<Nilby>
I'm not a fan of object-relational mapping things because I had to be very picky about performace in big databases. I did my own objects.
<v3ga>
Nilby: gotcha, that's kind of what i'm tip toeing around. Hmm, ok i'm going to toy around a bit more with it.
<jmercouris>
can I add the checking for the percentage as a specialization?
<jmercouris>
E.G. can I specify within the signature of the method that percentage should be between 0 and 100?
<no-defun-allowed>
No, but I think it should be an assertion instead.
<jmercouris>
no-defun-allowed: why?
<no-defun-allowed>
Trying to announce a percentage of -5% or 101% is an error - it makes no sense.
<jmercouris>
that's true
<jmercouris>
and so you think i should signal an error
<jmercouris>
it makes sense, yes
<jmercouris>
maybe I should make use of conditions and errors and signals more than I do
<no-defun-allowed>
But also, there aren't classes for arbitrary number ranges.
<phoe>
(check-type percentage (real 0 100)) is the best I think
<jmercouris>
no-defun-allowed: you can specify more than classes
<no-defun-allowed>
Yes, eql specializers too, but that's it.
<jmercouris>
phoe: ah, didn't think of check-type
<Alfr>
jmercouris, also you can't discriminate on types only classes.
attila_lendvai has quit [Ping timeout: 265 seconds]
<jmercouris>
I'm going to chain 100 eql statements :-D
<jackdaniel>
you may eql-specialize each number between 0 and 100
<jmercouris>
exactly
<jackdaniel>
don't forget about floats
<jackdaniel>
and ratios
<phoe>
as long as your percentages are integers, sure, I guess... but that'll slow the dispatch a bit
<phoe>
oh
<jmercouris>
it's a joke, I'm not going to do it
<Alfr>
no-defun-allowed, write once, read never?
<jmercouris>
I believe in read only memory
<phoe>
more like write once, debug forever
Anonymous_ has quit [Remote host closed the connection]
<jmercouris>
sorry I mean write only memory
<jmercouris>
WOMs in other words
cosimone has quit [Quit: cosimone]
<mfiano>
You could use filtered-functions to define your own dispatcher, but I wouldn't do that for this.
villanella has quit [Quit: villanella]
<jmercouris>
I think I'm going to go with no-defun-allowed approach
* no-defun-allowed
hopes "think" isn't used in a way that suggests one has reasons to consider eql specialisation on every real between 0 and 100.
<jmercouris>
that's exactly what I'm going to do, I'm even going to write a macro for it /s
<jmercouris>
wonder why my emacs highlights check-type in red
<jackdaniel>
to be honest I would be seriously impressed if someone had eql specialized every real between two different numbers
<phoe>
brb, let me iterate through all the doubles
<jackdaniel>
because it may signal an error?
<no-defun-allowed>
check-* does assertions, much like assert.
<jmercouris>
just about anything might signal an error
<Alfr>
jmercouris, you can't rationals are reals, thus you won't get away with finitely many eqls.
<jmercouris>
Alfr: who said anything about a finite amount of EQs?
<jmercouris>
I never claimed my program would be halting
<jmercouris>
I don't know why we always get into these absurd conversations on this channel
<Alfr>
You'll be alright then, if it never finishes generating code, faulty code will never run. :D
theothor` has joined #lisp
<jmercouris>
:-D
<no-defun-allowed>
Very funny. Now, do signal when you get silly values, and don't silently drop them, letting the caller get away with it.
theothornhill has quit [Read error: Connection reset by peer]
<Nilby>
absolute lisp power move /s
VincentVega has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Not even that, failing when the first invariant is broken would give you the best idea of what caused your problems.
<jmercouris>
sometimes we wish to silently fail
<jmercouris>
objective-c taught me that is very powerful
KREYREEN has quit [Remote host closed the connection]
KREYREEN has joined #lisp
<no-defun-allowed>
I forgot the quote by Appel from some compiler book, but it went like "and the man who murdered his parents pleaded for mercy, as he was an orphan."
<jmercouris>
a list of type specifiers anywhere?
toorevitimirp has quit [Remote host closed the connection]
madage has joined #lisp
Bike has joined #lisp
<no-defun-allowed>
One I do remember is "rather than having the software discover its own errors in a benign way, the discovery of such errors is left to the FAA or a Congressional committee."
<no-defun-allowed>
Though you have two problems if your web browser code is doing life critical stuff now.
madage has quit [Remote host closed the connection]
aindilis has quit [Ping timeout: 258 seconds]
<jmercouris>
that's a lot of responsibility for one little browser
toorevitimirp has joined #lisp
<jmercouris>
:'(
madage has joined #lisp
gxt has quit [Quit: WeeChat 3.0]
<no-defun-allowed>
Well, you get the idea. If you can't fix it, don't pretend it's okay.
luni has joined #lisp
<jmercouris>
I don't think that is an absolute rule
<jmercouris>
there are many fault-tolerant systems that must deal with failure by often ignoring it
<jmercouris>
I'm not making aerospace equipment here, I'm making a program that should stay running and DWIM without intervention as often as possible
<no-defun-allowed>
The user isn't going to be setting progress bar values though - but you could clamp to [0%, 100%] in case someone gives you a bogus value.
orivej has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
<jmercouris>
that is also achieved by the when
<no-defun-allowed>
Is it? You wouldn't update at all then.
<jmercouris>
I see
<jmercouris>
so if they give you a value of what, 200, you go to 100?
<phoe>
I'd assume so
<no-defun-allowed>
That's the best "not an error" interpretation I can think of.
imode has joined #lisp
<phoe>
optionally if the user gives you #C(70 70) then the loading bar goes upwards at a 45° angle
<jmercouris>
Ah, yes
<jmercouris>
:-D
<jmercouris>
I love those volume set competitions on programmer humor
<jackdaniel>
heretic, Y grows downward :c
<Alfr>
That's not sane, it will paper over some erroneous input and make you later hunt for errors in the wrong part of your program: The progress indicator obviously gets it right, the problem must certainly occur later ...
<Nilby>
ugh, I wrote more joke code than real code today
yonkunas has joined #lisp
caret has joined #lisp
<no-defun-allowed>
You do...write Common Lisp code, right? S isn't evaluated there.
<jmercouris>
... don't take it so seriously
<jmercouris>
for all you know, he has a reader macro that magically makes it work
no-defun-allowed has left #lisp ["User left"]
<semz>
no-defun-allowed: i'd argue that using floats (and summing them up at that, otherwise you'd stay below 100%) for that is an error in itself
<semz>
regrettably common error, but CL has rationals
<phoe>
wait til you add nans to the picture
<Nilby>
now I made it work and trashed my image after unlocking :cl
<jmercouris>
trashed your image? no, you've made a work of art
wsinatra has joined #lisp
hiroaki has quit [Ping timeout: 246 seconds]
<Nilby>
I like to play "survive this sexp"
cosimone has joined #lisp
caret_ has joined #lisp
caret has quit [Disconnected by services]
caret_ is now known as caret
hiroaki has joined #lisp
luni has quit [Quit: Connection closed]
davd33 has joined #lisp
``Erik has quit [Quit: BitchX-1.2.1 -- just do it.]
ldbeth has joined #lisp
ldbeth has quit [Remote host closed the connection]
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
attila_lendvai has joined #lisp
nij has joined #lisp
ldb has joined #lisp
<ldb>
good evening
<VincentVega>
Out of curiosity, is there a way to modify class definition w/out reevaluating the actual definition? Say, add a slot to a class, e.g. have a restart that says class slot is missing and you can just add it on the spot, would that sort of thing require a lot of trickery? I mean, what are the options besides trying to keep the original code manually?
<Bike>
you could use mop ensure-class instead, probably
<Bike>
you can get all the properties of the class out of the class itself (e.g. mop:class-direct-slots), add to them, and then reinitialize the class with the additions
<jmercouris>
Bike: that is not foolproof, there are all sorts of edge cases
<jmercouris>
believe me, I have tried
<Bike>
i did not mean to imply that this was foolproof.
<Bike>
cos it definitely ain't
<Bike>
still, i don't see why it wouldn't work in principle
<VincentVega>
Bike: Interesting.
<ldb>
why not just check statically
<VincentVega>
jmercouris: if not a bother, any off-the-bat examples of where that could fail?
<Bike>
for this particular case i guess you would just have a slot-missing method
<jmercouris>
VincentVega: I don't remember it was some SBCL specific errors
<jmercouris>
which of course extended to other implementations in unique ways..
<VincentVega>
jmercouris: alright, I see.
<VincentVega>
ldb: sorry, what do you mean?
<ldb>
it is already possible to check if an object of wrong domain has been applied to a function
<ldb>
using type system or wstatic analysis tools
wsinatra has quit [Ping timeout: 264 seconds]
Major_Biscuit has quit [Ping timeout: 240 seconds]
wsinatra has joined #lisp
<VincentVega>
ldb: Oh, I take it you were referring to a previous discussion here.
<Bike>
oh, the :direct-slots argument is supposed to be a specification rather than an actual slot definition. that's kind of inconvenient
theothor` has quit [Ping timeout: 272 seconds]
wsinatra has quit [Ping timeout: 276 seconds]
<VincentVega>
Bike: I guess could still be used to reconstruct the original class definition. Though, at that point, might as well just store the original code.
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
<Bike>
you can try e.g. (defclass foo () () (:metaclass twb-class)) (slot-value (make-instance 'foo) 'hello-world)
<Nilby>
I feel like sometimes when you might think you want to dynamically add random slots to random objects, maybe one should just have simple property lists on objects.
<Bike>
probably
VincentVega has quit [Quit: Ping timeout (120 seconds)]
aindilis has joined #lisp
galex-713 has quit [Ping timeout: 260 seconds]
galex-713 has joined #lisp
VincentVega has joined #lisp
<jmercouris>
or a dictionary
<jmercouris>
the problem is that you can't specialize on a dictionary or plist that easily
<VincentVega>
Bike: sweet : )
<jmercouris>
not without writing your own flow control code
<Nilby>
but I like Bike's correct code sketch
tassleoff has joined #lisp
Major_Biscuit has joined #lisp
<Bike>
i suppose the fancier thing would be having it signal the usual error, but offering a restart to define a new slot
<Bike>
this just assumes you want a new slot, with no accessors and an initform of nil
<jmercouris>
should allow you to pass a form that will create the new slot
<jmercouris>
so the exact same syntax that you'd use in defclass
Guest14662 has joined #lisp
pfdietz has joined #lisp
Guest14662 has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<Josh_2>
Sorry to be a pain, but Ive run into a really annoying issue where I seem to be processing the same message twice when my restart is invoked and returns t, only when the prefix is #.admin is the message processed twice and I can't figure out why https://plaster.tymoon.eu/view/2281#2281 this is the code I think is the culprit, does anything stand out as obviously wrong with the way I'm using the restarts? I hope so xD
<Bike>
Josh_2: i don't understand the flow here. you mean extract-command-and-args is called twice or what?
<Josh_2>
Yes, it seems that way, only when the prefix is #.admin, if the prefix is immediately valid then this doesn't happen
ldb has quit [Quit: leaving]
<Bike>
from this flow it looks like process-message is called exactly once on each message, and proces-smessage calls extract-command-and-args exactly once
<Bike>
i don't see any way they could be called twice unless one of the functions not in the paste calls them
<Josh_2>
this is why I'm so confused
<Josh_2>
when I trace extract-command-and-args it is getting called twice
<VincentVega>
Bike: Awesome! You know, I am thinking there's a nonzero chance I might actually be using something like that, just in case, could you, please, add a license to it?
<andreyorst>
wanted to ask a bit silly question -- how Common Lisp compares to C++ for developing stuff which typically developed in C++, like game engines, where you need to squize as much of performance as you possibly can. AFAICS Common Lisp has all stuff that is available in C++ in terms of language features, e.g. object system, compile time evaluation, templates are not needed, as CL is dynamically typed.
<andreyorst>
But CL is garbage collected and C++ uses RAII model, so this bit can be a lot of impact for high performance applications. So if anyone has experience of developing in both languages, I would like to hear thoughts on this topic. Thanks!
<Bike>
andreyorst: #lispgames might have thoughts on this
<andreyorst>
Question is not specific to game development, just an example of something what commonly written in C++
<aeth>
andreyorst: I mean, obviously C++ compilers are better because more people spend more time and money optimizing them... but there shouldn't be as much of a difference as you think because in both, you're going to preallocate nearly everything that you can, essentially avoiding the cost of allocations (which in C++ has a cost and in CL is usually 0 and sometimes a lot)
<phoe>
andreyorst: in practice, CL is gradually typed - you can add type information wherever the compiler cannot figure it out on its own, and you can have blocks that are weakly statically typed
<aeth>
andreyorst: Plus, a lot of the CL stuff in a game engine actually has to be manually memory managed because it needs to be passed to the GPU through the CFFI.
<Bike>
VincentVega: ok. but to reiterate i don't think this is actually a good idea probably.
<andreyorst>
aeth, game engine was just an example, but I see what you mean, thanks
<aeth>
andreyorst: I think the principle is going to be similar, at least if you want deterministic performance. Preallocate, and probably over-allocate. Use the preallocated.
<VincentVega>
Bike: well, just in case : D
<pve>
andreyorst: someone recently wrote a blog post about CL game engines, and I recall that the overhead associated with calling generic functions was the biggest pain point, GC not so much
<aeth>
andreyorst: And the high-performance core of anything that has to deal with arrays of numbers is going to be statically typed in CL because CL is gradually typed, as phoe said.
<pve>
please correct me if I'm remembering this wrong
choegusung has joined #lisp
<VincentVega>
Bike: thank you!
<aeth>
pve: CL's generics are runtime dispatch and can wreck a compiler's type inference, too. You don't want to use them in a hot loop, but they're fine (maybe even encouraged) in the setup part, at least ime.
choegusung has quit [Client Quit]
<aeth>
NAME is probably the best example of a good generic. Even if you're using a struct for FOO instead, you might as well define a NAME method that just calls FOO-NAME... You shouldn't really architect your code to the point where you're calling NAME in a hot loop.
toorevitimirp has quit [Remote host closed the connection]
<aeth>
pve: At least ime, it's often a good idea to use an instance of a DEFCLASS class to hold a struct instance... The DEFCLASS provides a very high-level interface to the outside world, while the DEFSTRUCT is retrieved from the generic and cached and accessed in the hot loop.
<aeth>
The hard judgement call when you need performance ime is whether to turn a DEFCLASS into a DEFSTRUCT or to do this hybrid approach.
<gendl>
Hi, in cl-who, what would be the idiomatic way to insert a newline into the output? Just `(fmt "~%")` ?
<gendl>
I thought I remembered a keyword for that or maybe that was aserve's HTMLgen.
luni has joined #lisp
<aeth>
Well, (terpri) is the function in CL so you could see if that's part of the API
<pve>
aeth: makes sense.. the idea in the game engine mentioned by the blog post was to have it super-modifiable at runtime, which could explain the heavy use of generic functions
<aeth>
pve: Imo, the real way to make a (high performance) game engine super-modifiable at runtime ime would be to replace all of its constants (there should be dozens) with parameters to a macro and just recompile a caller of that macro at runtime. But it would be very tricky to do properly.
<beach>
andreyorst: As I often say, it is impossible to write a C++ program that is both modular and fast. And I though gamers would often forget about modularity, but aeth says I am wrong about that.
zacts has joined #lisp
<contrapunctus>
Is there anything like the Smalltalk class browser for Common Lisp?
cosimone has quit [Remote host closed the connection]
<aeth>
pve: So you should go one level more meta than normal and write a meta game engine... but it's all compile time, but you can just recompile at runtime...
<phoe>
not yet, and I've recently mentioned that I'd like to have one
<tfb>
contrapunctus: there is for specific implementations
<Nilby>
andreyorst: I used to be a C++ developer. Stay away from Common Lisp. It ruined everything for me. CL is very dangerous. Once you taste it's ultimate power and freedom you might never be able to go back. Yes, some have used CL to become very rich, but do you really want to risk being forever a crazy Lisp cultist?
<contrapunctus>
phoe: hey 🙂 don't hear from you in lisp@ of late! ^^
ski has quit [Killed (Sigyn (Spam is off topic on freenode.))]
<tfb>
for instance LispWorks has one)
<contrapunctus>
tfb: oh 🤔
<contrapunctus>
I guess I might try making one.
<phoe>
contrapunctus: hey hi! lisp@? what do you mean?
<pve>
aeth: yeah, I can imagine it would require complex solutions
<contrapunctus>
phoe: the XMPP room lol
<aeth>
Nilby: were you Nullby back then?
<phoe>
oh! I totally forgot about it to be honest
* phoe
rejoins
<contrapunctus>
^^'
<aeth>
pve: Right, you'd have to simultaneously define everything to be done at compile time via macros, while at the same time not breaking the running game if the parameters were adjusted at runtime. It would be very complex.
<aeth>
(I mean, not literally everything at compile time, merely everything that can be done at compile time.)
<aeth>
And I mmean allowing the recompilation of a top-level DEFINE-GAME-ENGINE form, of course. Not crashing when the macro itself was redefined would probably be impossible in the general case.
<pve>
contrapunctus: I'm making a little smalltalk-in-lisp, and would really like to make a class browser for it at some point in the future :)
<pve>
I wonder which GUI library would be suitable..
<beach>
pve: Definitely McCLIM.
<phoe>
definitely mcclim
<pve>
beach: alrighty!
<beach>
pve: In fact, for a class browser you could probably use Clouseau, perhaps with some additional customization.
rople has joined #lisp
<pve>
beach: ok that's good to know, will definitely check it out
<contrapunctus>
Would it be preferable for such a tool to work with the definitions loaded in the Lisp image, or with those in the project's files?
<phoe>
the former will be much easier
<phoe>
the latter is going to be damn hard because you'd need to evaluate code to find out what classes are available at all
<aeth>
It would be interesting to do both and then warn you when you try to commit to git with definitions out of sync.
<aeth>
These days, I restart SLIME just to be safe before pushing code to the origin
<phoe>
the trivial cases with DEFCLASS forms are going to work fine
<aeth>
It's too easy to rename a function, but still keep one caller of that now-ghost function around.
<contrapunctus>
aeth: been bitten by that innumerable times when Elisping Q_Q
<contrapunctus>
phoe: I see, thanks 😀
<phoe>
but imagine a DEFCLASS with a #.(foo) form inside it - which is possible and also one of the easiest ways to break the assumptions that you can parse Lisp code by reading it without read-eval or compilee-eval
<pve>
contrapunctus: In smalltalk, the source code is retained in the image, so in my class browser I would do the same for Lisp to keep things consistent
rogersm has joined #lisp
<contrapunctus>
pve: would your class browser be for the Smalltalk-in-Lisp, or both? 🤔
<phoe>
I'm not even talking about crazy cases like (funcall (find-symbol (format nil "~A-~A-~A-~A" :ensure :class :using :class) :closer-mop) nil (get-class-name))
ex_nihilo has joined #lisp
theothor` has joined #lisp
<phoe>
even if morally questionable, this code is legal CL
<phoe>
try figuring our available classes from that.
<scymtym>
that said, static analysis does not have to cover every imaginable case to be useful
<phoe>
so, I'd guess, go for the classes available in the system at a given moment, and let people restart inferior lisps like aeth and I do if they want clean images
rople has quit [Quit: rople]
<phoe>
scymtym: yes, that's correct
<aeth>
phoe: Anything obfuscated like that should be a warning because it's so unclear to read that it's a potential back door insertion
rople has joined #lisp
<scymtym>
but yes, to be sure, a fresh image seems like only reliable way at the moment
* scymtym
uses a local CI-style setup for that
<phoe>
aeth: I don't say anyone should write or accept code like that; it's just that class definition can happen in obscure ways and times
<pve>
contrapunctus: I would like to be able to show smalltalk classes and their methods, but also lisp functions, special variables etc
rople has quit [Client Quit]
<pve>
contrapunctus: but I'm not sure how hard it would be to integrate everything cleanly.. probably pretty hard
charles` has joined #lisp
rople has joined #lisp
<phoe>
and a static analysis tool won't get to find all of that unless it's taught to find them
rople has quit [Client Quit]
rople has joined #lisp
<Nilby>
My dream is there is no code.
<Josh_2>
Bike: I figured out the problem
<Josh_2>
Thanks for taking a look
rogersm has quit [Quit: Leaving...]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
<Bike>
no problem
IPmonger has joined #lisp
ski has joined #lisp
Cymew has quit [Ping timeout: 276 seconds]
<Josh_2>
It was because two communities listen in the same room, so as the bot iterates through the community and processes the messages in the appropriate administration room (which is the same for both communities) it was reading the message twice. This isn't normally a problem because commands are internal to communities, but for global commands this becomes an issue
theothor` has quit [Ping timeout: 256 seconds]
waleee-cl has joined #lisp
ecm1 has joined #lisp
<Josh_2>
using a variable with dynamic scope to store the ids of messages prefixed with #.admin solves this problem
ecm1 has quit [Client Quit]
ecm1 has joined #lisp
caret has quit [Ping timeout: 276 seconds]
ecm1 has quit [Quit: WeeChat 3.0]
heisig has quit [Quit: Leaving]
tassleoff_ has joined #lisp
carkh has quit [Read error: Connection reset by peer]
iskander has quit [Ping timeout: 276 seconds]
iskander has joined #lisp
tassleoff has quit [Ping timeout: 276 seconds]
cage_ has joined #lisp
h4ck3r9696 has joined #lisp
jeosol has joined #lisp
theothor` has joined #lisp
akovalenko has joined #lisp
theothor` has quit [Ping timeout: 276 seconds]
VincentVega has quit [Ping timeout: 240 seconds]
rople has quit [Ping timeout: 240 seconds]
mmmattyx has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
charles` has quit [Ping timeout: 240 seconds]
tassleoff_ has quit [Ping timeout: 246 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
tfb has quit []
zacts has quit [Quit: leaving]
aartaka_d has quit [Ping timeout: 265 seconds]
rogersm has joined #lisp
Major_Biscuit has quit [Ping timeout: 264 seconds]
hiroaki has quit [Ping timeout: 246 seconds]
zacts has joined #lisp
recalloc has joined #lisp
dbotton has joined #lisp
<recalloc>
Hi, I'm trying to enable clsql's reader syntax, but Sly doesn't seem to cooperate. Works on a terminal, though. Anyone had a similar issue have a workaround?
akovalenko has quit [Quit: Connection closed]
cosimone has joined #lisp
<recalloc>
Specifically clsql:enable-sql-reader-syntax doesn't seem to cooperate regardless how I place it. Only thing that seems to work is clsql:file-enable-blablabla, but only when compiling entire files. No idea how I'd set it up to type SQL queries in a single defun or the REPL
mh has joined #lisp
slyrus 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
jeosol has quit [Quit: Connection closed]
dbotton has quit [Quit: Leaving]
<rogersm>
Any video on how to use slime-inspector? I have the feeling I'm not using it to its full potential.
fiveop has quit []
rogersm has quit [Quit: Leaving...]
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
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
lowryder_ has quit [Ping timeout: 256 seconds]
lowryder_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Danishman has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
ineiros has quit [Ping timeout: 264 seconds]
mmmattyx has quit [Quit: Connection closed for inactivity]
ineiros has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Nilby has quit [Ping timeout: 258 seconds]
pfdietz has quit [Quit: Ping timeout (120 seconds)]
amb007 has quit [Read error: Connection reset by peer]
cosimone has quit [Quit: cosimone]
amb007 has joined #lisp
carkh 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
davd33 has quit [Remote host closed the connection]
mh has quit [Ping timeout: 272 seconds]
madage has quit [Ping timeout: 268 seconds]
tsrt^ has quit []
madage has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
madage has quit [Ping timeout: 268 seconds]
luni has quit [Quit: Connection closed]
akoana has joined #lisp
rumbler31 has joined #lisp
carkh has quit [Remote host closed the connection]
cosimone has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<minion>
Remembered. I'll tell rogersm when he/she/it next speaks.
<carkh>
any easy way to get syntax highlight in .asdf files on emacs ? looks like sly doesn't do this out of the box
<phoe>
huh? are you in lisp-mode?
<carkh>
mhh
<carkh>
ok well =) sorry about that !
<carkh>
thanks
<phoe>
:D
rumbler31 has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` is now known as X-Scale
anticrisis has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
<aeth>
carkh: .asd is the ASDF extension which explains why .asd wasn't recognized.
<aeth>
*why .asdf wasn't recognized
<aeth>
You can force it with this on the first line: ;;;; -*- mode: common-lisp; -*-
zacts has quit [Quit: leaving]
attila_lendvai has quit [Ping timeout: 272 seconds]
sunset_NOVA has joined #lisp
<carkh>
aeth: i just noticed this. after configuring emacs to accept asdf files =)
daphnis has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
theothornhill has joined #lisp
shka_ has quit [Ping timeout: 256 seconds]
zacts has joined #lisp
galex-713 has joined #lisp
vegansbane6963 has quit [Read error: Connection reset by peer]
<hiredman>
I have a weird sbcl alien ffi issue, I am creating a c struct, and setting fields on it, and I think I am running in to some kind of alignment or padding issue
vegansbane6963 has joined #lisp
<hiredman>
the first field is 8 bits, the second and third are 16 bits
akoana has left #lisp ["Leaving"]
<hiredman>
I set all 3 fields to some values, and then read the value back out of the second field, and it comes out fine, then I send the data over the network, and it comes out as the value of the first field, the value of the third field, zero
<hiredman>
so maybe when I set the field setf is taking the number as 32bits and setting both fields or something? but that doesn't explain how reading it back before it goes out on the network is all correct
cage_ has quit [Quit: Leaving]
rumbler31 has quit [Remote host closed the connection]
narimiran has quit [Quit: leaving]
sunset_NOVA has quit [Quit: Leaving]
<hiredman>
arg, the luajit version of this I am trying to interoperate with is helpful inserting padding into the middle of its struct definition, mystery solved
carkh has quit [Remote host closed the connection]
carkh has joined #lisp
Anonymous_ has quit [Remote host closed the connection]
VincentVega has joined #lisp
VincentVega has quit [Client Quit]
C-16 has joined #lisp
C-16 has quit [Client Quit]
luni has joined #lisp
luni has quit [Client Quit]
pve has quit [Quit: leaving]
theothornhill has quit [Remote host closed the connection]
Anonymous_ has joined #lisp
h4ck3r9696 has quit [Quit: Leaving.]
Inline has quit [Ping timeout: 264 seconds]
rozenglass has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
wildlander has joined #lisp
cosimone has quit [Quit: cosimone]
rumbler31 has joined #lisp
unimog has joined #lisp
rumbler31 has quit [Ping timeout: 276 seconds]
unimog has quit [Remote host closed the connection]
unimog has joined #lisp
voidlily has quit [Remote host closed the connection]