kevingal has quit [Remote host closed the connection]
aindilis has joined #lisp
guav has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
<guav>
hello
<Xach>
hi guav
<guav>
Hi Xach :) man this channel seems to be quite the popular spot
<Xach>
guav: it gets a little quiet when the europeans are asleep
dhil has quit [Ping timeout: 256 seconds]
<Xach>
and the UKers and scandanavians
<guav>
Haha no I meant that sincerely, this has like 10x more connected people than the emacs channels i visited, but yeah does seem to be a little quiet rn
karlosz has quit [Quit: karlosz]
<fiddlerwoaroof>
guav: lots of lurkers here
recalloc has joined #lisp
elflng has quit [Ping timeout: 246 seconds]
corpix_ has quit [Remote host closed the connection]
corpix has joined #lisp
dbotton has joined #lisp
<White_Flame>
it's the questions that get conversations flowing, not just presence of people
_jrjsmrtn has joined #lisp
DHARMAKAYA has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 246 seconds]
Helmholtz has joined #lisp
shifty has joined #lisp
wxie has joined #lisp
<dbotton>
Xach quicklisp builds all the projects the whole month multiple times?
<Xach>
dbotton: at least once per day
shifty has quit [Ping timeout: 240 seconds]
<dbotton>
Very nice :) So my code base checked all the time
shifty has joined #lisp
<dbotton>
I guess those errors showed from a new sbcl
<Xach>
yeah
<Xach>
there are rss feeds too
<dbotton>
I'll try and look in to after get to 1.0
<dbotton>
Been super busy work wise but still moving along
<stylewarning>
is there a recommended best practice for catching no applicable method errors?
Oladon has joined #lisp
<Nilby>
stylewarning: Most library-like things I've written just let them go, but in say an image loading library, it could try load image format code. In a program with a UI, and something like a view-thing method I've popped up dialog box, and had an option to go to the debugger.
<Nilby>
Are you catching for a specific purpose?
<Nilby>
As a library user, I like to know when it happens, but sometimes, if it's say a method that one should have provided, you could wrap it with an explanitory error, like "you forgot to provide a display method" or something?
<stylewarning>
Nilby: I'm implementing a concept of "backends" or "plugins", and one such might be implemented by a generic function.
<Bike>
what kind of best practice do you mean
<stylewarning>
and if there's no method, I want to handle the condition and keep moving
<Nilby>
Sound like just signaling a warning and continuing might be fine.
<Bike>
the standard doesn't specify a condition type, so you probably need to specialize no-applicable-method to signal something you can use
<Nilby>
or maybe like a missing-plugin condition that would by default be handled
Josh_2 has joined #lisp
<MrtnDk[m]>
Oh, is this channel mostly IRC?
<Bike>
it's entirely irc.
<stylewarning>
Nilby: I was hoping to not have control over the generic functions themselves
<moon-child>
Bike: I think that this channel is bridged to a matrix channel, and MrtnDk[m] is asking how manay people are on the matrix side. Maybe?
<MrtnDk[m]>
Bike I'm not currently on IRC. You're probably talking to my puppet.
<Bike>
okay, it's entirely irc and also people have unexplained bridge bots.
<Bike>
anyway, what are you trying to do with your code here?
<MrtnDk[m]>
Bike I'm guessing it rendered absolutely terrible on the IRC side?
<Bike>
yes, you've been sending links to one-off text files.
<MrtnDk[m]>
Man, sorry
<MrtnDk[m]>
It looks ok here ... but ..
<Bike>
i really do want to know what you're going for with this code though. do you expect short-loop to exit?
<MrtnDk[m]>
It was just some code for fun. I'm kinda noob with lisp.
<Bike>
mm, that's fine. we also have... i think #clschool? for learning
<Bike>
questions are ok here tho
<MrtnDk[m]>
Bike cool
elusive has quit [Quit: Leaving]
<MrtnDk[m]>
What is my puppets nickname btw?
<MrtnDk[m]>
Eg. what do you see me as?
<Nilby>
stylewarning: I think most libraries I've seen that do generic backend things, just let the condition go, unless it's called from a frontend where you can catch it. It seems like mostly having a no-op generic fallback, or some other sensible fallback can workd.
<MrtnDk[m]>
Bike You're "@freenode_Bike:matrix.org" on the matrix side.
<Nilby>
Since if it's required, than it should be an error if it's not there, and if it's not required, a no-op is probably fine.
<stylewarning>
maybe it's a bad idea to catch such a thing anyway, because the failure of (F) might not be because F has no methods
<Bike>
MrtnDk[m]: MrtnDk[m]
<Nilby>
stylewarning: right, especially if it fails for other mistyped parameter
<MrtnDk[m]>
Bike Ah, that doesn't go through. The bot changes it into a matrix link. Thanks though.
<moon-child>
M r t n D k [ m ]
<stylewarning>
How is NO-APPLICABLE-METHOD intended to be specialized? EQL on the generic function name?
karlosz has joined #lisp
<Bike>
yeah, or if you have a custom generic function class of course.
<stylewarning>
cool
Alloc has joined #lisp
<MrtnDk[m]>
moon-child That worked, thanks. MrtnDk[m], right?
<Bike>
you could also define a general method (specialized on T) which does whatever
gaqwas has joined #lisp
<fiddlerwoaroof>
I assumed n-a-m was called with the generic function instance
<Bike>
i mean a general method on your generic function.
<Nilby>
the generic function is a class too
<fiddlerwoaroof>
All I mean is that I thought you'd specialize it like (generic-function (eql #'foo))
<Nilby>
I think I've actually seen it both ways, eql #'func and just plain gf-type
<Bike>
that's how you'd specify not-applicable-method, yes
<Bike>
i'm talking about a different possible solution that doesn't involve n-a-m
<Bike>
how you'd specialize not-applicable-method*
<fiddlerwoaroof>
Nilby: if you did the plain gf-type, you'd be defining a default for every generic function of that type
<fiddlerwoaroof>
Which would be interesting...
<Bike>
also make your code nonconforming.
<fiddlerwoaroof>
(gf (eql 'foo)) doesn't seem standard
<Bike>
you'd need to do (eql #'foo) for sure
akoana has left #lisp ["Leaving"]
prxq_ has joined #lisp
<fiddlerwoaroof>
Does that run into issues with externalizable objects?
<fiddlerwoaroof>
I feel like I've had load issues doing that
<Bike>
it doesn't need to actually externalize the function for that
<Nilby>
(eql #'foo) works fine
mrchampion has quit [Ping timeout: 245 seconds]
sm2n has quit [Read error: Connection reset by peer]
<moon-child>
why isn't (=) valid?
prxq has quit [Ping timeout: 256 seconds]
Alloc has quit [Remote host closed the connection]
sm2n has joined #lisp
<Bike>
hm, dunno.
<moon-child>
should be the same as (and), I think
<Nilby>
qtools has examples of call n-a-m with (eql #'func)
<MrtnDk[m]>
moon-child Requires an argument. (= 1) works.
<Nilby>
(= 0) Is it any wonder emoticons were invented by lispers
<moon-child>
MrtnDk[m]: yes, but the question is why. The function is variadic: (= 1 1 1) works. If we think of the definition as 'return T if, for all parameters x and y, x is mathematically equal to y; otherwise NIL', then clearly it should return T when provided with no parameters as false antecedent
<moon-child>
and you can construct a similar (even stronger, maybe) argument in terms of existence
Alloc has joined #lisp
Alloc has quit [Client Quit]
<Nilby>
perhaps it's because (=) has no use, even in reduce, and (= o) is like a shorter way to write (numberp o) as well as being an emoticon
<fiddlerwoaroof>
Doesn't that signal?
<fiddlerwoaroof>
(= "foo")
<fiddlerwoaroof>
Yeah: ; Evaluation aborted on #<TYPE-ERROR expected-type: NUMBER datum: "foo">.
<moon-child>
Nilby: does (=) have any less use than (and)? = at least has the excuse that it's a function, and so can be applied (to a list of potentially arbitrary length)
<Nilby>
Yes. (and) is a functional way to write T
<Nilby>
And has an obvious return value. equality of nothing doesn't seem well defined
<fiddlerwoaroof>
(and) macroexpands to t
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<Nilby>
It's also has lovely symmetry with (or)
contrapunctus has joined #lisp
<MrtnDk[m]>
Nilby (or (or) (and nil)) ;; has the same effect, I guess.
<Bike>
(and) is true because it's an empty product. equality is basically pairwise, so the equivalent would be testing equality of one object against a set of no objects, like (= x), which is indeed true
<Nilby>
It also answer's the profound questions: Is nothing true? => NIL, Is anything true? => T
<Bike>
if i had to justify it
<Nilby>
If nothing was true, then that would be something that was true.
aartaka has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
Alfr has quit [Killed (barjavel.freenode.net (Nickname regained by services))]
Alfr has joined #lisp
<MrtnDk[m]>
I guess = compares all arguments to see if they're equal. No arguments can't be equal, obviously. However, "and" just returns "t", unless one of its operands are false.
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
<Josh_2>
no
<Josh_2>
it evaluates to the first non nil argument
<Josh_2>
well
<Josh_2>
not that either :P
<Josh_2>
it will check all arguments arent basically, but it doesn't return t, but the last non nil, which could be t xD
<beach>
MrtnDk[m]: As the Common Lisp HyperSpec says, "If all forms but the last evaluate to true values, AND returns the results produced by evaluating the last form."
Josh_2 has quit [Ping timeout: 246 seconds]
<beach>
MrtnDk[m]: So AND does not necessarily return T.
<Nilby>
I wonder how many other things like SB-IMPL:%STUFF-HASH-TABLE there are that I don't know about.
skapata has quit [Ping timeout: 272 seconds]
<Nilby>
And that *print-readably* doens't mean readably on any other implementation.
wxie has quit [Ping timeout: 260 seconds]
ex_nihilo has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
Bike has quit [Quit: slp]
<fiddlerwoaroof>
Nilby: *print-readably* doesn't necessarily mean readably on the same implementation
<fiddlerwoaroof>
Unless you've loaded the correct readers
<fiddlerwoaroof>
e.g. local time has a timestamp syntax like @xxxx-yy-zz... and read-macros for that
<beach>
Another argument in favor of stamping out implementation-specific readers. :)
<Nilby>
My trust in *print-readably* is shattered :(
<fiddlerwoaroof>
beach: you still need to have initialized the readtable correctly
<beach>
Sure.
<fiddlerwoaroof>
unless you mean "stamping out read macros"
<beach>
I did not mean that.
<beach>
It was a lame attempt to push for Eclector.
* Nilby
is already using Eclector
<beach>
YAY!!
<Nilby>
But not for everything
<Nilby>
yet
slyrus has quit [Ping timeout: 256 seconds]
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
<Nilby>
beach: I'm very grateful for Eclector. Thanks! Otherwise I'd have to maintain implementation forks, or write my own reader.
<beach>
Oh, thank scymtym. He made it what it is. I merely wanted an implementation-independent reader, but it was very embryonic when scymtym took over.
<Nilby>
Many thanks to scymtym.
sauvin has joined #lisp
samebchase-5 is now known as samebchase-
sm2n_ has joined #lisp
sm2n has quit [Ping timeout: 260 seconds]
wxie has joined #lisp
marusich has quit [Quit: Leaving]
phossil has joined #lisp
phossil has quit [Quit: Konversation terminated!]
matryoshka has quit [Ping timeout: 265 seconds]
matryoshka has joined #lisp
Oladon has quit [Quit: Leaving.]
leb has quit []
leb has joined #lisp
asarch has joined #lisp
<asarch>
If I have: (defclass foo () ...) and then (defclass bar (foo) ...) can I create a dynamically re-sizable array of the type foo to store bars?
<asarch>
Or do I have to set :element-type 'bar explicitly?
<beach>
asarch: Objects that are instances of standard classes like that won't have any specialized array associated with them, so you are going to get an array of T either way.
<beach>
asarch: But, every object of type BAR is also an object of type FOO, so anywhere an object of type FOO is required, you can supply an object of type BAR.
<asarch>
How would you set the :initial-element argument?
<asarch>
Just T?
<beach>
You can set it to anything you want, since every Common Lisp object is an instance of the class T.
<asarch>
:adjustable t :initial-element nil :element-type 'T
<beach>
When I said T, I don't mean an object. I mean the class T.
<beach>
You can certainly do that, but you are working too hard.
<beach>
asarch: See the element-type defaults to T.
<beach>
asarch: And you can supply an initial element if you like, but the implementation will supply one for you if you don't.
<beach>
And since every object is of type T, the implementation can supply anything and it will work.
<asarch>
Thank you!
<asarch>
Thank you very much!
<beach>
asarch: Specialized arrays are about optimizing representation where possible. So an array of characters may be represented in some optimized way depending on how the implementation represents characters.
<beach>
asarch: But there is no optimization possible for standard objects, so you are always going to get an array with an element type of T.
<beach>
asarch: As I recall, an implementation is allowed to store and check the real type that you gave, independently of the representation. But I don't think implementations do that in general.
shifty has joined #lisp
<asarch>
I thought :element-type was for each type of the class inherited from foo
<beach>
For example, in SBCL, if you do (make-array 10 :element-type 'symbol) it will contain an initial element of 0.
<asarch>
And then: :element-type 'bar, :element-type 'spam, :element-type 'baz
<asarch>
I could even do :element-type 'string and still work, right?!
<beach>
Yes, I just did (defparameter *foo* (make-array 10 :element-type 'symbol)) and then (setf (aref *foo* 3) (find-package "CL")).
narimiran has joined #lisp
<beach>
... using SBCL.
<asarch>
That's great, isn't it?!
<beach>
asarch: :element-type is used when you want a specialized array, like an array of bits or characters or DOUBLE-FLOATs.
<beach>
It is not going to buy you anything for standard classes.
<beach>
I am not saying it is great. I am explaining what is happening.
aartaka has joined #lisp
<beach>
asarch: Why are you so focused on element types?
<beach>
asarch: Common Lisp is a dynamically typed language. You don't have to state the type of everything you do.
<asarch>
Well, I need a way to create HTML forms dynamically since it is quite a headache to modify thousands of template files
<beach>
OK, you just lost me when you said HTML. So I wish you good luck. Not that I understand how specifying an element type that is a standard class is going to do any good for HTML.
<asarch>
So, for my initial experiment, I: (defclass html-element () ...) and then (defclass input-text (html-element) ...) so I could add that HTML element to the form object: (let ((my-form (make-instance 'form))) (add-element my-form (make-instance 'input-text))
<asarch>
The elements are stored in a dynamically-sized array in the form object named elements
<Nilby>
There was a discussion earliar about how can you tell when an array element will survive dynamic extent, i.e. when it's boxed or not.
<White_Flame>
the methods you call on the items you fetch from the array are what will concern themselves with the type; the array doesn't have to
<asarch>
Why don't you like anything related to web development beach?
<beach>
Because it is messy, and I am busy with other things.
<asarch>
I see
* beach
goes back to something he is willing to spend time on.
<asarch>
Well, later I could (render #P"templates/form.html" (list :form (render my-form))) which it converts everything in "<form>...</form>"
<asarch>
The 98% of the web development depends actually on the programming language you choose for the controller
<asarch>
The other 2%... well, click here, click that and voilá!
johannes has joined #lisp
<White_Flame>
(loop for node across node-array (render-method node string-stream))
<White_Flame>
between outputting "<form>" and "</form>"
villanella has joined #lisp
<White_Flame>
still don't need any specialization on the array itself
<asarch>
Really? I thought since (render ...) and every HTML element is actually a string... well, you know
<White_Flame>
(also might need to add a DO before the render-method call to be proper, too)
<White_Flame>
you know what?
frost-lab has joined #lisp
<White_Flame>
the object in the array is passed to the render generic function, which then is what finds the method appropriate for the real class
<White_Flame>
and none of that really has anything to do with the array. You could have them in a list or whatever
<asarch>
I was thinking in something a la Python's modules for form generation (WTForm, ToscaWidgets, Sprox, etc)
<Jachy>
asarch: Is there a particular reason you don't want to use any of the popular libraries for html generation / framework-style templates?
<phantomics>
A different question: Is there anything inside a (let) form that can cause one of the locally-scoped variables to become unbound other than another (let) form inside it reassigning the variable at a smaller scope?
<Nilby>
Hey, it's almost to multi-CRUD, with just a little lisp code, seems legit
<phantomics>
For example (let ((abc something)) ... many forms deeper ... (lambda (x y) (+ abc x y)))
<beach>
phantomics: No, lexical variables can't be unbound.
<phantomics>
This gives an error and says abc is not defined
<phantomics>
beach: Strange, I'm running into this exact problem
<White_Flame>
are you sure it's not a nesting error, and the lambda is actually outside the let?
<beach>
Can you reduce your code to something with a reasonable size?
<phantomics>
I've reduced it as far as practical and the problem still occurs
rogersm has joined #lisp
<beach>
So either what White_Flame suggested, or someone declared it special and then made it have no value. I think White_Flame's explanation is the more likely one.
<beach>
phantomics: How about pasting the code?
<White_Flame>
it really helps to use something like paredit to keep your nesting & indentation sane, though it gets a lot of gettin gused to
<beach>
Even just indenting the code properly will make such a problem pretty obvious.
<phantomics>
There's nothing that could move the symbol outside of the (let) and cause it to be evaluated there
<beach>
I don't see any obvious problem, but then, as White_Flame points out, one would have to know what every macro does in order to figure it out.
<White_Flame>
re unicode issues, at least the pasted version seems to all be plain ascii letter |s|
<phantomics>
As an added note, there is a preexisting |s| dynamic variable inside the april-workspace-common package, and what happens is that that value overrides the internal |s| value
<phantomics>
But afaik that can't happen
<White_Flame>
depends on when the lambdas you generate are actually called
<phantomics>
Yes, it's a plain ascii s
<White_Flame>
however, a special var being unbound is not the same as the var being unknown at compile-time
<White_Flame>
what is the exact error you're getting?
<phantomics>
What the lambdas I generate are called?
<White_Flame>
ALAMBDA seems to be an analog of CL:LAMBDA?
<White_Flame>
I don't know if that's something else in APL
<phantomics>
ALAMBDA expands to a lambda with a self-referencing variable
<phantomics>
I'll explain details in a moment...
<beach>
phantomics: What does it mean that there is a preexisting variable with that name? That seems to mean that we are not really dealing with a lexical variable here.
<phantomics>
The exact error is a problem with the APL ↑ function. It tells me "too many subscripts (3) for array of rank 2". This happens because in one of April's unit tests, s is assigned as a 3-element vector, and that is its dynamic value. Inside the function, the lexical s is assigned as a 2-element vector
<White_Flame>
right, thre is only one symbol |a| in that package, and if it's declared special, then it's special everywhere
<White_Flame>
erm, |s|
<beach>
Yes, and then, what appears to be a closure closing over that variable, really isn't.
<phantomics>
Oh, the April compiler declares all dynamic variables (declared outside a function) to be special
<beach>
So when that closure is called later, the variable can very well be unbound.
<beach>
Then you don't really have a lexical variable, do you?
<phantomics>
A variable declared special cannot be defined differently in a lexical scope?
<beach>
That's correct.
<White_Flame>
or even if it's all called in the same shape that the lexical shape implies, if any of the intermediate calls create a new binding for |s|, then that one will be used, not your LET above
<phantomics>
Ok, I also tried using a different variable name instead of |s|, one which is not used in any unit test
<phantomics>
And that gave me the same problem
<phantomics>
Although the binding macro may have caused it to be declared special as well
<White_Flame>
I just hit that specialness issue recently when trying to reuse the special var named * to reference prior values :-p
<phantomics>
So the answer is to only declare variables special when they will always be used dynamically
<White_Flame>
it is a declaration on the symbol
<phantomics>
Symbol, right
<White_Flame>
all uses of that symbol in an evaluated value slot location will use that declaration
<beach>
phantomics: Well, there are some cases where it will work. I believe the Common Lisp HyperSpec has some examples.
<White_Flame>
and there's no NOT-SPECIAL declaration, unfortunately
rumbler31 has joined #lisp
<phantomics>
I tried a test with a simpler APL function and it worked that time, which was confusing
<phantomics>
Does (defvar) always cause a symbol to be declared special?
<White_Flame>
yes, that and defparameter
<beach>
Yes.
<beach>
With those, there is absolutely no way of making the variable lexical.
<phantomics>
Ok, I thought I'd used lexical symbols overriding (defvar) symbols in the past
<beach>
As the Common Lisp HyperSpec page shows, if you have only local SPECIAL declarations, sometimes you can have both lexical and special references.
<White_Flame>
however, it would need to be dynamically rebound between your LET and the up-arrow usage in order to cause your problem
<White_Flame>
or simply re-apl-assigned I guess
<phantomics>
As far as I know that doesn't happen
<phantomics>
The value it has when causing the problem is the same as the value assigned in the unit test
rumbler31 has quit [Ping timeout: 240 seconds]
<White_Flame>
print the value of |s| at various locations in this chain
aggin has joined #lisp
aggin has quit [Client Quit]
<White_Flame>
(print it from runtime, it's the only way to be sure)
aggin has joined #lisp
<phantomics>
|s| gets assigned on line 12. If I check it on line 13, it's #(24 24). If I check it inside the (alambdas) starting on lines 17 and 32, it's the dynamic value
aggin has quit [Client Quit]
<White_Flame>
it really smells like it's getting called later, after your LET has exited
<phantomics>
The (apl-compose ¨ ...) operation runs in parallel
<phantomics>
Don't suppose that could be related?
<phantomics>
Using lparallel
<White_Flame>
as in threaded?
<phantomics>
Yes
<White_Flame>
yes, those would see the global value
<White_Flame>
dynamic bindings are thread-local
<phantomics>
Ok, that makes sense then
<phantomics>
Er, lexical bindings are thread-local?
<White_Flame>
dynamic bindings are.
<White_Flame>
LET of a special variable is a dynamic binding, not a lexical one
<phantomics>
Right, but if it's not special then it's a lexical binding and thread-safe?
<White_Flame>
however, I guess lexical bindings are thread-local by nature, as they only exist on the stack (if not just in registers)
<White_Flame>
dynamic bindings are stored in the TLS areas
edgar-xyz has quit [Quit: Leaving]
edgar-rft has joined #lisp
<White_Flame>
if this were a lexical binding, then it would create a closure to hold on to that binding of |s| even across threads & after leaving the LET
pve has joined #lisp
<phantomics>
Ok, I'll curtain the special declarations and see how things work
<Nilby>
This reminds me of when I tried to emulate old non-lexical elisp's weird dynamic binding with symbol macros and packages.
<phantomics>
Implementing an elisp in CL?
<White_Flame>
with both alambdas referencing that same closure, you'd be thrashing an object in parallel if you were to mutate it
<Nilby>
something like that
<phantomics>
Only one of the two alambdas will run
<Nilby>
elisp has buffer specific variables and weird default values
<phantomics>
The two alambdas are for either a monadic or dyadic function, which one runs depends on the number of args
gioyik has quit [Quit: WeeChat 3.0]
<White_Flame>
but in a nutshell, yes if it were a non-special plain lexical variable binding, then all would be as you expected
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
<Nilby>
APL in CL has a cool terse/verbose look to it.
<White_Flame>
this is exactly why special variable names are *earmuffed*, but since this notionally isn't lisp, that gets violated
<White_Flame>
so they don't conflict with non-earmuffed lexicals
<phantomics>
Nilby: the code producing what you see in the paste is (5 5⍴1÷25) {s←24 24 ⋄ (⍳⍴⍺){s↑⍺↓⍵}¨⊂⍵} 28 28⍴⍳25
<Nilby>
*gasp*
<Nilby>
I think I like the CL/APL combo better.
<Nilby>
but maybe the APL would be better for typing on the phone
<phantomics>
You can get an idea of what APL symbols generate what closures by looking for them in the code
<phantomics>
For instance, the ↑ produces the (apl-call ↑ ...) form
admich has joined #lisp
<phantomics>
Those symbols in the compiled code are mostly just there to show you what function a closure is implementing
<White_Flame>
btw, what's your keyboard input scheme for all the apl chars?
<phantomics>
The (apl-call) macro disregards its first argument
<phantomics>
in Linux: setxkbmap us,apl -option grp:win_switch
<phantomics>
Then I hold the win key and type APL chars
<White_Flame>
I guess it shouldn't surprise me that that's built in :)
attila_lendvai_ has joined #lisp
<asarch>
There is no way to call a super function, right?
shka_ has joined #lisp
hendursa1 has joined #lisp
<isoraqathedh>
asarch: If you're asking for a way to call a less-specific method in CLOS, the local function call-next-method is what you're looking for.
orivej has joined #lisp
<isoraqathedh>
Oh wait, it's APL.
<isoraqathedh>
Sorry.
<asarch>
(defclass foo () ...) (defmethod show ((instance foo)) ...) (defclass bar (foo) ...) (defmethod show ((instance bar)) (call-next-method ...))?
<asarch>
bar's show masks foo's show, right?
<isoraqathedh>
Yes, but you can choose to get it back by calling (call-next-method).
<isoraqathedh>
Note no arguments; it automatically re-passes them to the next method.
<asarch>
Thank you!
gareppa has joined #lisp
<asarch>
Thank you very much! :-)
hendursaga has quit [Ping timeout: 268 seconds]
<isoraqathedh>
What's happening under the hood is that CLOS assembles all the methods that could conceivably apply to the particular generic function call with those arguments, and then it chooses the most specific one to run.
<isoraqathedh>
They're in an order so that there's a "next method" to run, which is what call-next-method does.
<isoraqathedh>
It's... not quite super() from other languages because multiple dispatch but it's conceptually simple enough.
<isoraqathedh>
There's a lot of things working under the hood with CLOS; this is the easiest way to understand call-next-method under the standard method combination.
shifty has quit [Ping timeout: 246 seconds]
skapate has quit [Remote host closed the connection]
<asarch>
That helps a lot
<isoraqathedh>
Also, a bit of a technical thing: in CLOS, a class (or an instance of a class) does not own a method, so it's not technically correct to say "foo's show" or "bar's show". Instead, it's "show as specialised on foo" and "show as specialised on bar". Reframing it this way helps you understand how method combinations work: it emphasises that it's essentially the method that is "orchestrating" the whole
heisig has joined #lisp
<isoraqathedh>
lot, finding out the classes of the arguments and deciding what to run.
<asarch>
Yeah, foo's show is a bad habit from C++...
<asarch>
Sorry
frost-lab has quit [Ping timeout: 264 seconds]
OlCe` has quit [Ping timeout: 260 seconds]
frost-lab has joined #lisp
Codaraxis has quit [Remote host closed the connection]
random-nick has joined #lisp
Codaraxis has joined #lisp
bryanhonof has joined #lisp
gj has joined #lisp
<gj>
Good morning, all.
<beach>
Hello gj.
<gj>
I am here to ask for something to program in lisp, a challenge of sorts. I have a bit of free time right now but am not sure of what to do.
bryanhonof has quit [Ping timeout: 264 seconds]
<beach>
gj: What kind of programming would you like to do?
<beach>
gj: I mean, if you say "web stuff" or "something with FFI", then I'll abandon right away.
<gj>
Not web stuff, or FFI, then. I don't really mind at all what sort of programming...
<beach>
gj: I have a list of suggested projects. Let me find it for you....
<beach>
gj: Feel free to ask questions about the projects listed.
<beach>
Some of the projects are being worked on already.
<gj>
Oh, thank you very much!
<gj>
An editor for music scores... That is an interesting project.
<beach>
Very. I wrote Gsharp a long time ago. The successor is called Clovetree.
<beach>
Like Rosegarden, Lilypond....
<beach>
It is a huge project though.
<gj>
Definitely, I cannot even think of where to begin with something like that.
<beach>
Heh, then pick something simpler. :)
motersen has joined #lisp
<beach>
gj: A calendar program or an email client would be doable if you use McCLIM for the GUI.
<gj>
Email client sounds good.
<beach>
Yes, it's a good project. Fairly well defined.
Codaraxis has quit [Ping timeout: 276 seconds]
hiroaki has joined #lisp
asarch_ has joined #lisp
asarch has quit [Ping timeout: 265 seconds]
anticrisis has quit [Read error: Connection reset by peer]
<beach>
gj: I strongly encourage the use of McCLIM though. McCLIM is going to be essential for the big picture of things. Think Lisp OS, as that page suggests.
frost-lab has quit [Quit: Connection closed]
<beach>
Plus, McCLIM is getting quite good lately, and it deserves more applications that use it.
karlosz has quit [Quit: karlosz]
OlCe` has joined #lisp
Lycurgus has joined #lisp
matryoshka has quit [Ping timeout: 265 seconds]
asarch_ is now known as asarch
OlCe` has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
ljavorsk has joined #lisp
tessier_ has quit [Ping timeout: 256 seconds]
frost-lab has joined #lisp
OlCe has joined #lisp
frost-lab88 has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
frost-lab has quit [Ping timeout: 260 seconds]
cchristiansen has quit [Remote host closed the connection]
<adlai>
is there a reasonably recent overview of McCLIM's pros-and-cons?
* adlai
is familiar enough with these as of a decade ago
<adlai>
... and has no idea how things have changed since then
<beach>
What do you mean cons? :)
<beach>
adlai: It has been actively improved for many years now by several devoted contributors.
<beach>
But I am unaware of such an overview.
luna_is_here has quit [Ping timeout: 256 seconds]
<adlai>
in my case, the main pain point would be how difficult it is to make interfaces that are consistent between a terminal, where you are limited to a two-dimensional grid of a finite set of characters, and the "any color you want, any pixel you want, at your refresh resolution" display
<beach>
Furthermore, the people in #clim are quite reactive, so if you have questions or problems, they are quite present.
<adlai>
I guess the easiest way to answer that this is trivial, is to simulate a terminal in the GUI
<adlai>
thank you, I'll take it to there
<beach>
I think jackdaniel has been working on a text-only backend.
<Nilby>
simulating a terminal is not trival
<beach>
There is also renewed work on a Windows backend.
ldbeth has joined #lisp
asarch has quit [Ping timeout: 240 seconds]
<beach>
Nilby: I think the people in #clim share with me the conviction that trivial things are not worth the trouble. :)
luna_is_here has joined #lisp
<ldbeth>
anyone interested in writing proof assistant in CL? :-)
<gj>
Proof assistant?
shifty has joined #lisp
<ldbeth>
Something that can aid mathematicians or logicians writing a formal proof
aartaka_d has joined #lisp
<flip214>
Kingsy: not sure I understand you here correctly. you get possible completions but they vanish by themself?
<beach>
Isn't ACL2 such a system.
<beach>
ldbeth: ↑
luna_is_here has quit [Read error: Connection reset by peer]
aartaka has quit [Ping timeout: 260 seconds]
luna_is_here has joined #lisp
OlCe has quit [Ping timeout: 245 seconds]
<ldbeth>
It is, but there are other approaches to towards a proof assistant/automated theorem prover too
aartaka has joined #lisp
<adlai>
ldbeth: my impression, from a few brief forays in that direction, is that the people who actually use such tools for their professional work, prefer libraries that are specific to each domain
<adlai>
e.g. sheafhom
<adlai>
or kenzo
aartaka_d has quit [Ping timeout: 240 seconds]
<adlai>
then they search for [counter]examples using these computational tools, rather than asking a prolog-on-steroids whether fermat's last theorem is proven
<Nilby>
Yes, a math theorem prover usually has much different requirements than an engineering theorem prover.
<ldbeth>
adlai: well, but prolog-on-steroids are probably still useful at representing how to make use of these domain specific decision procedures
* adlai
is unqualified to have any stronger opinion, at this point; e.g. has read neither the four-color map theorem's proof, nor the prover
gj has quit [Quit: Connection closed]
kevingal has joined #lisp
aggin has joined #lisp
<aggin>
How would one use CLOS to have a function like initialize-instance to change the value of a classes slots using :initarg ? I do not want to use initialize-instance as I have defined an :after method for it
<aggin>
which I don't want to run while changing the values of the slots
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #lisp
<frgo>
Hi all. I seem to be unable to understand what this tries to accomplish and if it even is a valid type declaration: (declare (type (or null (function (t) card8)) fn)) ... Can someone parse that for me?
<frgo>
Thx!
vegansbane6963 has joined #lisp
<ldbeth>
aggin: (setf (slot-value <instance> <slot-name>) <newvalue>) is this what you looking at?
oxum_ has joined #lisp
<aggin>
ldbeth: no, i want something like how initialize-instance does with :initarg
<ldbeth>
frgo: that declares the variable "fn" is either a "nil" or a function maps value of arbitrary type to a result of type "card8"
<frgo>
So it *is* actually a valid type declaration... Hrm. Thankss!
<beach>
frgo: I am not an expert, but isn't it just a variable FN that can be either NIL or a function that takes any argument and returns a CARD8?
<ldbeth>
aggin: then it looks like you are looking for REINITIALIZE-INSTANCE?
oxum has quit [Ping timeout: 246 seconds]
<aggin>
ldbeth: oh ok
<aggin>
thanks
<frgo>
Yep - that's what I assumed, too. This appears in the CLX source and causes issues on AllegroCL.
<beach>
What's the issue?
<ldbeth>
Well, AllegroCL seems has a specific implementation of CLX
<beach>
frgo: See the type-specifier argument specification.
<frgo>
Yep: "An error of type error is signaled if type-specifier is values, or a type specifier list whose first element is either function or values." . That's clear then. Thanks!!
<beach>
Pleasure.
aggin has quit [Quit: WeeChat 3.0.1]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
tessier has joined #lisp
Codaraxis has joined #lisp
aggin has joined #lisp
ldbeth has quit [Ping timeout: 264 seconds]
ski_ is now known as ski
orivej has quit [Ping timeout: 260 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
ldbeth has joined #lisp
aggin has quit [Quit: WeeChat 3.0.1]
ldbeth has quit [Ping timeout: 240 seconds]
ldbeth has joined #lisp
andreyorst_ is now known as andreyorst
oxum has joined #lisp
OlCe has joined #lisp
Nilby has quit [Ping timeout: 264 seconds]
oxum_ has quit [Ping timeout: 264 seconds]
<ldbeth>
guess no one has yet wire irc into common lisp repl
dhil has joined #lisp
aartaka_d has joined #lisp
<ldbeth>
Is it yet possible to use McCLIM based tools to develop common lisp programs, without GNU Emacs
aartaka has quit [Ping timeout: 240 seconds]
holycow has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 265 seconds]
<scymtym>
it may be technically possible with the Climacs application, but using GNU Emacs with SLIME is probably the better option for now
<edgar-rft>
I wrote Common Lisp programs using Windows Notepad, so why should that not be possible with McClim stuff?
<scymtym>
that said, swapping out pieces such as using the Clouseau inspector instead of SLIME's inspector can be an improvement already
matryoshka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
frost-lab has quit [Ping timeout: 245 seconds]
amb007 has joined #lisp
adlai has left #lisp ["Not all who wander are lost"]
amb007 has quit [Read error: Connection reset by peer]
frost-lab has joined #lisp
amb007 has joined #lisp
ldbeth has quit [Ping timeout: 260 seconds]
ldbeth has joined #lisp
ldbeth has quit [Remote host closed the connection]
ldbeth has joined #lisp
mathrick_ has quit [Ping timeout: 240 seconds]
mathrick_ has joined #lisp
shifty has joined #lisp
caret has joined #lisp
VincentVega has joined #lisp
frost-lab has quit [Quit: Ping timeout (120 seconds)]
<VincentVega>
Is there a tool to trace all function calls, which would then build a directed graph showing who calls who?
luna_is_here has quit [Ping timeout: 256 seconds]
<Xach>
VincentVega: that is approximately what a profiler can do
dale has quit [Ping timeout: 240 seconds]
<VincentVega>
Xach: Good point. Maybe I will look into some profiler then.
<ldbeth>
VincentVega: there is an old tool called xref, avaliable with SLIME
<Xach>
VincentVega: the compiler can do that at compile-time, too - that's how xref data becomes available
<Xach>
but that's a little different from tracing actual calls
notzmv has quit [Ping timeout: 256 seconds]
luna_is_here has joined #lisp
<ldbeth>
although the original name of this util is called "Who-Calls", on symbolics lisp machine :)
<VincentVega>
Oh, nice, then! I can probably do without tracing for now, this sounds sufficient. I guess I can build/draw a graph myself. Thanks, guys!
frgo_ has joined #lisp
frost-lab has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
mrchampion has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
ebrasca has joined #lisp
ldbeth has quit [Ping timeout: 240 seconds]
Sheilong has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
ldbeth has joined #lisp
warweasle has joined #lisp
scymtym has quit [Ping timeout: 258 seconds]
holycow has quit [Quit: Lost terminal]
ldbeth has quit [Ping timeout: 264 seconds]
shifty has quit [Ping timeout: 240 seconds]
ldbeth has joined #lisp
shifty has joined #lisp
OlCe has quit [Ping timeout: 256 seconds]
shifty has quit [Ping timeout: 245 seconds]
shifty has joined #lisp
IPmonger has joined #lisp
ldbeth has quit [Remote host closed the connection]
v3ga_ has quit [Ping timeout: 246 seconds]
ebrasca` has joined #lisp
glamas_ has joined #lisp
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
rigidus`` has joined #lisp
recalloc_ has joined #lisp
varjagg has joined #lisp
supercoven has joined #lisp
srji_ has joined #lisp
IPmonger has joined #lisp
Major_Bi1 has joined #lisp
VincentVega has quit [Quit: Connection closed]
luna_is_here_ has joined #lisp
shifty has quit [*.net *.split]
ukari has quit [*.net *.split]
ebrasca has quit [*.net *.split]
luna_is_here has quit [*.net *.split]
aartaka has quit [*.net *.split]
dhil has quit [*.net *.split]
varjag has quit [*.net *.split]
Major_Biscuit has quit [*.net *.split]
marusich has quit [*.net *.split]
recalloc has quit [*.net *.split]
xlei has quit [*.net *.split]
spacebat2 has quit [*.net *.split]
srji has quit [*.net *.split]
glamas has quit [*.net *.split]
phantomics has quit [*.net *.split]
rigidus` has quit [*.net *.split]
notzmv has joined #lisp
xlei has joined #lisp
amk has quit [Ping timeout: 246 seconds]
amk has joined #lisp
Bike has joined #lisp
Bike has quit [*.net *.split]
phantomics has joined #lisp
spacebat2 has joined #lisp
ukari has joined #lisp
marusich has joined #lisp
dhil has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
Bike is now known as Guest97570
cosimone has joined #lisp
phantomics has quit [Quit: Ex-Chat]
phantomics has joined #lisp
ebrasca` has quit [Remote host closed the connection]
ebrasca has joined #lisp
hvxgr has quit [Ping timeout: 265 seconds]
hvxgr has joined #lisp
aindilis has quit [Ping timeout: 264 seconds]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
oxum_ has joined #lisp
frost-lab has quit [Quit: Ping timeout (120 seconds)]
<_death>
very strange.. (loop repeat 10000 count (= least-positive-single-float (random least-positive-single-float))) => 0 as expected but (= least-positive-single-float (random least-positive-single-float)) by itself sometimes returns true (sbcl)
oxum has quit [Ping timeout: 256 seconds]
<Guest97570>
in a loop it never seems to return true, and more to the point, in `(let () ...)` to force the compiler
<Guest97570>
oh for
skapata has joined #lisp
oxum has joined #lisp
<_death>
right
oxum_ has quit [Ping timeout: 264 seconds]
skapate has joined #lisp
jrm has quit [Ping timeout: 260 seconds]
skapata has quit [Remote host closed the connection]
scymtym has joined #lisp
wsinatra has joined #lisp
luni has joined #lisp
Guest97570 is now known as Bike
IPmonger has quit [Ping timeout: 256 seconds]
jonatack_ has joined #lisp
tinhatcat has joined #lisp
IPmonger has joined #lisp
Josh_2 has joined #lisp
<Josh_2>
Good afternoon
tinhatcat has quit [Quit: Leaving]
Lycurgus has joined #lisp
<Lycurgus>
just heard in #haskell "If I run out of memory again I'm switching to Lisp"
<edgar-rft>
let's garbage-collect Haskell as a language
<semz>
Somewhat related: Is there a good resource on writing non-consing CL?
<semz>
Obviously somewhat implementation-dependent, but there seem to be some shared characteristics and it seems much more viable than in other GC'd languages
<jackdaniel>
allocate the memory once and modify it destructively (i.e don't use consing operations)
heisig has quit [Quit: Leaving]
<Josh_2>
Then cry when you can't debug it :P
wsinatra has quit [Ping timeout: 245 seconds]
<semz>
"how to walk tightrope - step 1: don't fall down"
villanella has joined #lisp
cage_ has joined #lisp
adlai has joined #lisp
scymtym has quit [Read error: Connection reset by peer]
scymtym has joined #lisp
<beach>
semz: Why do you need to avoid consing. I suspect such code will be very hard to maintain.
<semz>
I'm generally interested in dealing with low memory situations, especially recovering from them
<beach>
I see.
Lycurgus has quit [Quit: Exeunt]
<adlai>
faith in automated garbage collection is the original premature optimisation!
* adlai
rejoined #lisp wondering whether any implementations of the condition system use truly bizarre optimisations for the condition objects themselves
luni has quit [Quit: Connection closed]
<adlai>
from a quick skim of CLHS chapter nine, it seems that the natural way to implement them is either as CLOS objects, possibly with a custom metaclass; or as structs, with a short-circuit in EQUALP that does not descend into conditions
* adlai
wonders whether any implementations have explored the other options
<adlai>
e.g. a system where the values returned by accessors on condition objects are not copied out of the signalling context
dbotton has joined #lisp
<adlai>
theoretically, a condition object could be as simple as "here is the stack pointer at the time of the call to #'SIGNAL"
sjl has joined #lisp
<Josh_2>
If you are curious you could go to #sbcl and ask the sbcl devs
<adlai>
this is a CL question, not "how does that specific implementation do this"
<Bike>
a condition object can't be that simple, because there is nothing that requires them to have dynamic extent
<adlai>
where is the guarantee that a condition object given to a handler is not dynamic-extent ?
<Bike>
to have ONLY dynamic extent, i mean
<Josh_2>
Sounds to me like you are asking an implementation question tho
<Bike>
where is the guarantee that any object isn't dynamic-extent? it's the default.
<Gnuxie[m]>
>faith in GC is premature optimization
<Bike>
when something can have dynamic-extent they say so explicitly, as with environments and restarts
<Gnuxie[m]>
U wot m8
<adlai>
Josh_2: I'm asking "does any implementation do this"; if your answer was "yes, SBCL does", then I misunderstood you.
<Bike>
it's also pretty useful in practice to let conditions escape handlers, as with logging systems
<adlai>
Bike: that's what I generally understand as well, although conditions are one area where I would not be surprised to see that default changed
<Bike>
contrast this with restarts, where it says "An implementation is free to implement a restart in whatever manner is most convenient; a restart has only dynamic extent relative to the scope of the binding form which establishes it. "
<Bike>
also at least one built in operator lets conditions escape the dynamic extent of a SIGNAL call, now that i'm thinking about it - IGNORE-ERRORS
* adlai
is fairly certain HANDLER-CASE does too?
<Bike>
true
<Bike>
that said, there are some optimizations that can be done elsewhere
<Bike>
some implementations will store (lambda (condition) (typep condition type-specifier)) instead of just the type-specifier, for handler-bind and handler-case
<Bike>
which lets the type test be compiled
toorevitimirp has quit [Remote host closed the connection]
<adlai>
the trivial case for such an optimisation is numerical routines where you hit various conditions at a frequency comparable to your floating point processor's clock rate, and don't want to cons and collect entire condition objects that often
<adlai>
and "don't use floating point numbers for those computations" is just stupid
<adlai>
if the floating point processor behaves deterministically, there's no fundamental reason to pretend it doesn't exist.
<Bike>
does any floating point work people actually do involve hitting FP exceptions a billion times a second?
<adlai>
nah
<adlai>
computers are only used for talking on IRC anyway
<Bike>
that was a genuine question, i wouldn't know
<adlai>
and comparisons are impossible across different engineering multiples
<adlai>
joking aside, my guess is that they don't, because nobody ever tries doing interesting things with floating point numbers
<adlai>
they write routines that avoid the errors in advance.
* adlai
on the other hand has plenty of bad ideas, and wonders whether they are even possible before starting to implement them
OlCe has joined #lisp
<aeth>
You wrap the floating point calculations in float-features:with-float-traps-masked and then potentially error once, at the very end of the computation.
v3ga has joined #lisp
<Bike>
traps are optional in 754 and using them has been a bit harrowing in my experience
<adlai>
aeth: thank you, I'll have to read about that library at some point
<adlai>
is it one of the 'trivial' bordeaux-threads-like compatibility layers, or something more complex?
<Bike>
more on the trivial end of things
<Bike>
it's mostly one file
<Bike>
it exposes infinities, NaNs, with-float-traps-masked, and float-from/to-IEEE-representation stuff
<adlai>
fwiw, I only got into this mental debugging session thanks to
<adlai>
"it would not be permissible for two distinct asynchronous keyboard events to signal identical condition objects at the same time for different situations"
<Bike>
boy, that's specific.
<aeth>
async existed back then?
<Bike>
obviously
<adlai>
async has existed ever since there was more than one chip on a circuit board, regardless of what they tell you about lisp machines.
<Bike>
reality is asynchronous
<adlai>
it is definitely fun to pretend it isn't!
<adlai>
I suppose some edge cases of a badly-implemented graphics algorithm could cause a lot of floating point errors, by accident.
<aeth>
usually those are obvious because some or all of the vertices are now at infinity and you can't see them
<aeth>
although I guess those are hard to distinguish from a camera looking in the wrong direction, too
varjagg has quit [Quit: ERC (IRC client for Emacs 26.3)]
<adlai>
anything that uses distances as denominators can run into problems when vertices get too close
<adlai>
dimensionality reduction is not premature optimisation, although not every algorithm has every optimisation!
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
cosimone has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
OlCe has quit [Ping timeout: 240 seconds]
<copec>
I usually play in CL with math things, but I want to write something to do the http/xml api requests to webserver control panels that I manage. What http client library is probably the most popular?
<Xach>
copec: drakma probably, dexador seems to be another option
<copec>
Thanks
luni has joined #lisp
<Josh_2>
I personally use dexador
<adlai>
does the CLIM spec live anywhere other than "machine located in Hamburg and hooked to the internet via VDSL" ?
<beach>
adlai: As _death says, we were given the permission to include it in the repository. It is just that the online version is so much more convenient to use on a daily basis.
<adlai>
excellent, thank you both
<_death>
beach: yeah, it has annotations.. maybe it should also be backed via a git repo or something
<beach>
Maybe so. You would have to ask gilberth to do that.
<adlai>
fwiw it's not only in the mcclim repo, but also the quicklisp archive!
OlCe has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<_death>
now why is :vk-enter not interpreted as :newline gesture :/
jonatack_ has quit [Read error: Connection reset by peer]
luni has quit [Ping timeout: 240 seconds]
<_death>
I mean :kp-enter
ex_nihilo has quit [Quit: Leaving]
<shka_>
what is the best heuristic to check if the lisp is running under slime?
<_death>
dunno about best.. I've some #+swank
<_death>
or do you mean whether there is an active connection?
<_death>
swank:connection-info should likely be modified so it returns NIL if there's no connection..
<_death>
well, I misinterpreted what it means.. it's connection-info from slime's pov, not from swank's
aartaka has joined #lisp
<shka_>
_death: hmmm
<shka_>
i guess i will ignore this
<shka_>
it is not big deal
dbotton has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
Klopsch has quit [Remote host closed the connection]
amb007 has joined #lisp
Klopsch has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
dbotton has quit [Quit: Leaving]
amb007 has joined #lisp
karlosz has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
kevingal has quit [Remote host closed the connection]
amb007 has joined #lisp
caret has quit [Read error: Connection reset by peer]
<Shinmera>
scymtym: By the way, the latest dev version of kandria has a lot more content in it, so might be more interesting for your CLOS benchmarks. It also has a bunch of editor improvements that your kid might find cool to play with ;)
gitgoood has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
<scymtym>
Shinmera: i didn't really have time to work on the dispatch stuff, but i can probably try how things perform. is the current version still available from the same repositories (mainly kandria and trial i think)?
<Shinmera>
since we ran into github's lfs limit. Everything else should be in the same place though.
v3ga has quit [Ping timeout: 240 seconds]
<scymtym>
i see, thanks. i'll let you know how it goes
dbotton has joined #lisp
<Shinmera>
Sure, no rush at all!
v3ga has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<dbotton>
If I passed to a function a function symbol say #'my-func to get the symbol 'my-func?
amb007 has quit [Read error: Connection reset by peer]
<Bike>
you could use function-lambda-expression, but it is not always possible.
amb007 has joined #lisp
<Bike>
the implementation doesn't have to save the names of functions.
<dbotton>
Thanks
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
varjag has joined #lisp
dale has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
gitgood has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<dbotton>
Is there a down side to using symbol-function and just passing the symbol?
<beach>
Performance, and you can use only globally defined functions.
<beach>
Also, I recommend you treat SYMBOL-FUNCTION as obsolete and use FDEFINITION instead.
<dbotton>
Thanks
<beach>
Pleasure.
<beach>
Performance is not an issue in most "modern" Common Lisp implementations, since they probably store the function in a slot in the symbol.
pankajsg has quit [Ping timeout: 264 seconds]
eddof13 has joined #lisp
wsinatra has joined #lisp
jonatack_ has joined #lisp
Klopsch has quit [Remote host closed the connection]
Klopsch has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 26.1]
hiroaki has quit [Ping timeout: 244 seconds]
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
karlosz has quit [Quit: karlosz]
midre has quit [Ping timeout: 264 seconds]
aartaka_d has joined #lisp
<Xach>
beach: i recently ran into a situation where (funcall 'string= a b) was 2.5x slower than (funcall #'string= a b) on an implementation. This puzzles me since 11.1.2.1.2 seems to me to justify turning the slower into the faster unconditionally.
aartaka has quit [Ping timeout: 256 seconds]
sauvin has quit [Remote host closed the connection]
midre has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
sernamar has joined #lisp
midre has quit [Ping timeout: 265 seconds]
midre has joined #lisp
motersen has quit [Quit: rcirc on GNU Emacs 27.1]
luni has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Codaraxis has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Codaraxis has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
motersen has joined #lisp
motersen has quit [Read error: Connection reset by peer]
motersen has joined #lisp
wsinatra_ has joined #lisp
dbotton has joined #lisp
wsinatra has quit [Ping timeout: 246 seconds]
wsinatra_ has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
wsinatra has joined #lisp
dbotton has quit [Client Quit]
Klopsch has quit [Remote host closed the connection]
Klopsch has joined #lisp
eddof13 has quit [Ping timeout: 245 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Bike>
the implementation could just not do that optimization. (funcall 'a-constant-symbol ...) is probably kind of rare, so it might not seem worth it unless you have actual constant propagation, and that's more work
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
jrm2 has joined #lisp
sernamar has quit [Remote host closed the connection]
<Xach>
this case happened to be the result of macroexpansion
<Xach>
something like (foo-macro (:test 'string=) clause*)
<Xach>
could the macro be smarter? yes! but the performance difference surprised me a bit.
<pranavats>
Hello, I'd like for some code to be executed before components of a system are loaded via asdf. Is there any way to extend asdf to do that?
<Xach>
pranavats: there's an :around-compile option documented in the manual. perhaps that would work.
<pranavats>
Thank you
Oladon has joined #lisp
jrm2 is now known as jrm
Major_Bi1 has quit [Quit: WeeChat 3.0.1]
swampfsck has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
karlosz has joined #lisp
Lord_of_Life has joined #lisp
random-nick has quit [Quit: quit]
kevingal has joined #lisp
random-nick has joined #lisp
trubi has joined #lisp
anticrisis has joined #lisp
jonatack_ has quit [Remote host closed the connection]
jonatack_ has joined #lisp
Inline has joined #lisp
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
jonatack__ has joined #lisp
admich` has joined #lisp
admich has quit [Ping timeout: 246 seconds]
jonatack_ has quit [Ping timeout: 256 seconds]
motersen has quit [Read error: Connection reset by peer]
epony has quit [Remote host closed the connection]
epony has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai_ has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 265 seconds]
dbotton has joined #lisp
Inline has joined #lisp
narimiran has quit [Ping timeout: 240 seconds]
dbotton has quit [Quit: Leaving]
Codaraxis has quit [Remote host closed the connection]
Codaraxis has joined #lisp
shka_ has quit [Ping timeout: 265 seconds]
dbotton has joined #lisp
admich` has quit [Quit: ERC (IRC client for Emacs 27.1)]
wsinatra has quit [Quit: WeeChat 3.1]
jonatack__ has quit [Quit: jonatack__]
rogersm has quit [Quit: Leaving...]
jonatack has joined #lisp
aindilis has joined #lisp
mathrick_ has quit [Ping timeout: 246 seconds]
Oladon has quit [Quit: Leaving.]
mathrick has joined #lisp
karlosz has quit [Quit: karlosz]
supercoven has quit [Ping timeout: 240 seconds]
trubi has quit [Ping timeout: 240 seconds]
semz has quit [Remote host closed the connection]
karlosz has joined #lisp
adlai has quit [Quit: irc is harmful to adlai]
jonatack has quit [Ping timeout: 240 seconds]
ukari has quit [Ping timeout: 276 seconds]
villanella has quit [Ping timeout: 265 seconds]
Noisytoot is now known as NOISYTOOT
cage_ has quit [Quit: Leaving]
Josh_2 has quit [Ping timeout: 260 seconds]
NOISYTOOT is now known as VERYNOISYTOOT
Krystof has quit [Ping timeout: 260 seconds]
VERYNOISYTOOT is now known as Noisytoot
trubi has joined #lisp
Inline has quit [Ping timeout: 265 seconds]
cosimone has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
jonatack has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
anticrisis_ has joined #lisp
gpiero_ has joined #lisp
edgar-xyz has joined #lisp
mseddon6 has joined #lisp
IPmonger_ has joined #lisp
edgar-rft has quit [Write error: Connection reset by peer]
gpiero has quit [Read error: Connection reset by peer]
zigpaw107 has quit [Read error: Connection reset by peer]
mseddon has quit [Read error: Connection reset by peer]
fitzsim has quit [Write error: Connection reset by peer]
Ankhers has quit [Ping timeout: 264 seconds]
HiRE has quit [Ping timeout: 264 seconds]
mseddon6 is now known as mseddon
zupss_ has joined #lisp
save-lisp-or-die has quit [Read error: Connection reset by peer]
docl_ has joined #lisp
zigpaw1076 has joined #lisp
IPmonger has quit [Ping timeout: 246 seconds]
docl has quit [Read error: Connection reset by peer]
hhdave has joined #lisp
zupss has quit [Ping timeout: 246 seconds]
kbtr has quit [Ping timeout: 246 seconds]
luni has quit [Quit: Ping timeout (120 seconds)]
Ankhers has joined #lisp
HiRE has joined #lisp
kbtr_ has joined #lisp
fitzsim` has joined #lisp
Mandus has quit [Ping timeout: 264 seconds]
Mandus has joined #lisp
anticrisis has quit [Ping timeout: 264 seconds]
OlCe has quit [Ping timeout: 264 seconds]
hhdave_ has quit [Ping timeout: 264 seconds]
fitzsim` is now known as fitzsim
me_at_drewc_ca has quit [Ping timeout: 264 seconds]