clintm has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dale has quit [Quit: My computer has gone to sleep]
vlatkoB has joined #lisp
jeosol has joined #lisp
remexre has quit [Ping timeout: 240 seconds]
shka_ has quit [Ping timeout: 245 seconds]
remexre has joined #lisp
Lycurgus has quit [Quit: Exeunt]
manualcrank has quit [Quit: WeeChat 1.9.1]
shka_ has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
sauvin has joined #lisp
sauvin has quit [Max SendQ exceeded]
sauvin has joined #lisp
rippa has joined #lisp
krid has quit [Ping timeout: 265 seconds]
mathrick has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
Should I use (class-name (class-of <instance>)) or (type-of <instance>) to get the name of the class that <instance> is an instance of?
jmbr has quit [Ping timeout: 245 seconds]
<LdBeth>
there's no reason to avoid use type-of
<LdBeth>
since in CL the correspondence between class and type is guaranteed
<LdBeth>
unless you want to port you code to other dialects that don't have suchs a correspondence
mathrick has joined #lisp
shka_ has quit [Ping timeout: 265 seconds]
Ricchi has quit [Read error: Connection reset by peer]
<no-defun-allowed>
Should be good then.
<no-defun-allowed>
Thanks LdBeth
JohnMS_WORK has joined #lisp
wusticality has joined #lisp
GoldRin has joined #lisp
spowell has quit [Quit: ZZZzzz]
Ricchi has joined #lisp
flamebeard has joined #lisp
Duuqnd has joined #lisp
Duuqnd has quit [Remote host closed the connection]
varjag has joined #lisp
tourjin has quit [Ping timeout: 276 seconds]
Duuqnd_ has joined #lisp
Duuqnd_ has quit [Client Quit]
Duuqnd has joined #lisp
buffergn0me has quit [Quit: ERC (IRC client for Emacs 26.2)]
Duuqnd has quit [Ping timeout: 265 seconds]
varjag has quit [Ping timeout: 245 seconds]
Duuqnd has joined #lisp
wusticality has quit [Remote host closed the connection]
clintm has joined #lisp
clintm is now known as Guest31001
ltriant has quit [Quit: leaving]
tourjin has joined #lisp
vydd has joined #lisp
vydd has quit [Changing host]
vydd has joined #lisp
varjag has joined #lisp
gareppa has joined #lisp
isBEKaml has joined #lisp
tourjin has quit [Ping timeout: 250 seconds]
ggole has joined #lisp
tourjin has joined #lisp
vydd has quit [Ping timeout: 246 seconds]
libertyprime has quit [Ping timeout: 240 seconds]
raghavgururajan has quit [Remote host closed the connection]
<beach>
Posterdati: If your plotting needs are not too complex, you can try using McCLIM instead. From reading the manual for cl-plplot, I understand it is an FFI-based library, so you are vulnerable to segmentation faults and other problems that are hard to debug.
jonatack has joined #lisp
<Posterdati>
beach: mmmh, ok, I have to plot points on x-y
<beach>
(clim:draw-point* x y) then
<jackdaniel>
hm, that reminds me of polyclot which I still need to finish
<beach>
Er, stick a medium in there somwhere.
<Posterdati>
CORRUPTION WARNING in SBCL pid 467(tid 0x7f8c3a80f700):
<Posterdati>
The integrity of this image is possibly compromised.
<Posterdati>
Memory fault at 0x18 (pc=0x7f8c40025a16, fp=0x7f8c34019150, sp=0x7f8c3a80dca0) tid 0x7f8c3a80f700
<Posterdati>
Continuing with fingers crossed.
anewuser has quit [Quit: anewuser]
<Posterdati>
this is the error using (plplot-examples:example0 "xwin")
<beach>
Posterdati: Good luck.
<Posterdati>
beach: yeah, I'd like to use ecl, but gsll does not compile on it :(
fanta1 has joined #lisp
<Posterdati>
beach: the same old problem with the groveller and the compiler
tfeb has quit []
Ricchi has quit [Remote host closed the connection]
<no-defun-allowed>
I don't know if what implementation you use is relevant.
<no-defun-allowed>
From memory, McCLIM uses no C bindings so you shouldn't have groveller problems.
<Posterdati>
no-defun-allowed: I was talking about ecl + gsll
<beach>
And McCLIM is actively maintained, whereas the last comment in the README for cl-plplot was from 4 years ago, suggesting that there was a need to catch up with the latest version if plplot.
tourjin has joined #lisp
<jackdaniel>
last commit: 41 minutes ago
<beach>
... and a very reactive bunch of people working on it.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
isBEKaml has quit [Quit: leaving]
<Posterdati>
ok, thanks
akovalenko has joined #lisp
Duuqnd has quit [Ping timeout: 240 seconds]
EvW1 has joined #lisp
m00natic has joined #lisp
kaun_ has joined #lisp
kaun_ has left #lisp [#lisp]
Duuqnd has joined #lisp
prite has joined #lisp
jonatack has quit [Ping timeout: 240 seconds]
q3d has joined #lisp
jonatack has joined #lisp
ccsava has joined #lisp
gareppa has joined #lisp
tourjin has quit [Ping timeout: 240 seconds]
cc0 has joined #lisp
<cc0>
hi, i would like to create an REPL-like bot that can execute simple LISP one-liners and return the result. the interesting part is that the bot has indirect access to a lot of third-part functions (say, 1000) not known in advance.
<cc0>
i would like to find a library that schematically has this kind of API: `execute(callback, line)`, that parses and executes the LISP code line, calling on my `callback` (signature: `callback(function_name, arg0, arg1, ...)`, returns a value) when it needs to execute a function it doesnt know about
<cc0>
this way i can execute something like `(foo (bar 0 1) "baz")` and expect to be called with `callback("bar", 0, 1)` and `callback("foo", result_of_bar, "baz")`
<cc0>
does that make sense? is there any library that could help me do something like this?
ccsava has left #lisp ["Leaving"]
<pjb>
this is a 1-liner, why do you want a library for 1-liners?
<antoszka>
cc0: you might use it or grab some ideas from it (wrt sandboxing etc)
<cc0>
pjb, ah, the thing is that my bot and my functions arent written in lisp, and that i wish to use lisp only as a parser , that could also let the user define its own functions and variables etc
<cc0>
that´s why i want a library: i need a c/c++ library to use from c/c++ code, not a lisp library, and that library should be able to parse and execute lisp code, ¨asking me¨ when it wants to execute a function it doesnt know about
clothespin has quit [Ping timeout: 265 seconds]
ljavorsk_ has joined #lisp
<Shinmera>
This channel is for the Common Lisp language.
<prite>
cc0: What do you think of ECL?
dddddd has joined #lisp
jonatack has quit [Ping timeout: 276 seconds]
vydd has quit [Quit: Leaving]
<pjb>
cc0: I see, but then it's a very specific system. Why do you expect specific features to be implemented already in libraries? Libraries are for generic features.
<Posterdati>
cc0: why call lisp function from a non lisp library?
yoeljacobsen has joined #lisp
<Posterdati>
cc0: you may want to have a lisp interpreter that is able to operate on a lisp library of functions or packages
fanta1 has joined #lisp
emacsomancer has quit [Read error: Connection reset by peer]
frgo has quit []
EvW1 has quit [Ping timeout: 245 seconds]
cosimone has joined #lisp
frgo has joined #lisp
salinasc has quit [Ping timeout: 276 seconds]
fanta1 has quit [Quit: fanta1]
salinasce has joined #lisp
fivo has joined #lisp
EvW has joined #lisp
lxbarbosa has joined #lisp
lavaflow has quit [Ping timeout: 245 seconds]
GoldRin has joined #lisp
Inline__ has joined #lisp
yoeljacobsen has quit [Ping timeout: 268 seconds]
gareppa has quit [Quit: Leaving]
yoeljacobsen has joined #lisp
yoja has joined #lisp
Inline has quit [Ping timeout: 264 seconds]
Inline__ has quit [Quit: Leaving]
yoeljacobsen has quit [Ping timeout: 276 seconds]
EvW has quit [Ping timeout: 252 seconds]
cosimone has quit [Ping timeout: 264 seconds]
Inline has joined #lisp
cosimone has joined #lisp
ljavorsk_ has quit [Ping timeout: 250 seconds]
FreeBirdLjj has joined #lisp
salinasce has quit [Ping timeout: 240 seconds]
salinasce has joined #lisp
salinasce has quit [Ping timeout: 250 seconds]
krid has joined #lisp
iskander has left #lisp ["ERC (IRC client for Emacs 26.3)"]
Lycurgus has joined #lisp
EvW has joined #lisp
Duuqnd has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
<dlowe>
cc0: try integrating picolisp into your bot
hiroaki has joined #lisp
q9929t has joined #lisp
fivo has quit [Ping timeout: 245 seconds]
fivo has joined #lisp
fanta1 has joined #lisp
ironbutt has quit [Ping timeout: 245 seconds]
ironbutt has joined #lisp
lxbarbosa has quit [Read error: Connection reset by peer]
<no-defun-allowed>
Well, if you had to pick some CL implementation to call from -- hmm, good point, maybe ECL then.
<jackdaniel>
picoclasp!
<no-defun-allowed>
But in general, just write the bot in Lisp and avoid all this.
EvW has quit [Remote host closed the connection]
gareppa has quit [Quit: Leaving]
tourjin has quit [Ping timeout: 245 seconds]
isBEKaml has quit [Quit: leaving]
<loke>
WHen Quickloading a package, there is a series of periods being displayed. Some packages display a lot, others not so many. What do they actually mean? I thought at first it one one period per function definition, but that doesn't seem to be the case.
<jackdaniel>
loke: one per macroexpansion
<loke>
Oh
<jackdaniel>
I'm not thrilled to know such details but there you have it,)
<loke>
How is Quicklisp able to inject a period printing during macroexpansion? Is there a facility to add hooks to macroexpand?
<loke>
Hmm... why does macroexpand-hook sound familiar...
<loke>
Checking CLHS
<pjb>
jackdaniel: is it not toplevel macrexpansions?
<loke>
Makes me wonder though, what is the use for macroexpand-hook? I mean, what was its original urpose?
<Bike>
putting in funny semantics, maybe.
<Bike>
there used to be an *evalhook* too, but that kind of screws up very basic semantic concepts
<Bike>
i think noting macroexpansions like quicklisp does is perfectly reasonable. it's not a really progress bar, of course, but it's a nice indicator that something is occurring
Josh_2 has joined #lisp
<MichaelRaskin>
I seriously considered using *macroexpand-hook* for tracing and debugging macros, and it might be related to its original purpose…
<Bike>
oh yeah that too. it gets weird sometimes. like sbcl's "error during macroexpansion, use break on signals to intercept" or whatever
FreeBirdLjj has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
<selwyn>
in cl we have the notions of read time and compile time
<selwyn>
is it meaningful or correct to talk about a distinct macroexpansion time?
<Bike>
not really.
<Bike>
things can be macroexpanded more than once and in different ways and stuff.
<Bike>
i mean, if you execute something "at compile time" with eval-when, there will be macroexpansions, but also a normal compilation will involve macroexpansions
<MichaelRaskin>
compilation might be intertwined with macroexpansion
xkapastel has joined #lisp
<Josh_2>
Whats the difference between parametric polymorphism and ad-hoc polymorphism like in CLOS? When applied to CL?
<Josh_2>
I was looking at LIL out of curiosity. Am I right in thinking it enables you to have strong typing while keeping generic dispatch?
<Josh_2>
so you don't have to write multiple similar methods for different types?
<Bike>
in polymorphic polymorphism the function body is basically always the same, the only thing different is the typing.
<Bike>
in ad hoc polymorphism you have, well, like CLOS, a bunch of arbitrary methods
<Xach>
loke: hee hee
<Bike>
parametric polymorphism* not polymorphic
_jrjsmrtn has quit [Ping timeout: 245 seconds]
fanta1 has quit [Quit: fanta1]
<Bike>
in a language like haskell, the append function (with two arguments) has a type like "forall a. (List a) -> (List a) -> (List a)", meaning it takes two lists and returns another list, and it's parametrized over the type of the lists' elements.
<Bike>
in CL we just kind of ignore the element type
<Josh_2>
so the function 'forall ..' would have different methods for different types of 'a'?
<Josh_2>
while clos would have different methods for different classes of a?
<Bike>
forall isn't a function, it's part of the type.
<Josh_2>
o
<mfiano>
No that's called monomorphization, which is copying different implementations either by the user or the compiler.
<Josh_2>
sorry, I've never used haskell
<Bike>
it's just a logic quantifier.
<Bike>
it wouldn't really have different methods. the actual logic of the append function doesn't depend on the element type.
fanta1 has joined #lisp
doublex_ has joined #lisp
<Bike>
it's possible that at runtime there'd be a bunch of different instantiated functions, one for each element type it's used with, but that's below the level of language semantics
doublex has quit [Ping timeout: 245 seconds]
<Josh_2>
Well i'm even more confused now xD
<Bike>
We could have a function (defun dumb (array) (+ (aref array 0) (aref array 1))) that just adds the first two elements of an array.
<Bike>
In CL this is fine in itself, because aref works on any kind of array
doublex_ has quit [Ping timeout: 240 seconds]
__jrjsmrtn__ has joined #lisp
<Josh_2>
Yes
<Bike>
But we could also have (defun dumb (array) (declare (type (simple-array (unsigned-byte 32) (*)) array)) (+ (aref array 0) (aref array 1))) that would only work on arrays with an ub32 element type.
<Bike>
and you can write a similar function for any element type, obviously.
<Bike>
but the actual code, the (+ (aref array 0) (aref array 1)), isn't altered.
akoana has left #lisp ["Leaving"]
<Bike>
you can imagine having some kind of (defun dumb (array) (declare (type (simple-array element-type (*)) array)) (+ (aref array 0) (aref array 1))) that's parametrized on what the element-type is.
<Bike>
then when the compiler saw a (dumb array) call, it would figure out what to do based on the known element type.
<Bike>
but we don't necessarily have that information at compile time in lisp, so we don't have any mechanism like this.
<mfiano>
You could use specialization-store, or a couple other similar approaches, to implement something like it though.
<Josh_2>
Bike: but there is LIL which does this right?
<Josh_2>
In a roundabout way with 'interfaces'
mindCrime_ has joined #lisp
<Bike>
I don't know about LIL.
<Bike>
I think you pas the "interface" as a runtime argument though.
<Shinmera>
I wouldn't worry too much. He seems a generally toxic individual.
<jmercouris>
Yeah, that's the feeling I get too, I just wanted to know what their qualifications were
<jmercouris>
Also wondering what the security issues that they discovered are, within 5 minutes of looking at the source, I'd like to fix them
sjl has quit [Quit: WeeChat 2.2-dev]
<saturn2>
using webkit probably
<jmercouris>
saturn2: it is WebKit OR WebEngine
lavaflow has joined #lisp
<saturn2>
what's the difference?
<jmercouris>
From a user perspective? The difference is almost NIL, I'm not sure why people are so hung up about WebEngine
<jmercouris>
From a development perspective, WebEngine is developed by the hegemony at Google, and WebKit is an open source, open collaboration project
<jmercouris>
if only we could go back to the simpler days of KHTML, and get rid of JS, the world would be a brighter place
<jmercouris>
anyways, this is a bit off-topic, so I won't elaborate any further
<saturn2>
i see
khisanth_ has joined #lisp
jmercouris has quit [Remote host closed the connection]
krid has joined #lisp
hiroaki_ has joined #lisp
hiroaki has quit [Ping timeout: 246 seconds]
hiroaki_ has quit [Ping timeout: 245 seconds]
krid has quit [Ping timeout: 245 seconds]
yoja has quit [Ping timeout: 240 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
gareppa has joined #lisp
gravicappa has quit [Ping timeout: 265 seconds]
sjl has joined #lisp
cosimone has joined #lisp
jfb4`` has joined #lisp
lxbarbosa has quit [Remote host closed the connection]
jfb4` has quit [Ping timeout: 240 seconds]
krid has joined #lisp
orivej has quit [Ping timeout: 276 seconds]
sindan has quit [Ping timeout: 240 seconds]
sindan has joined #lisp
gareppa has quit [Quit: Leaving]
shka_ has quit [Ping timeout: 276 seconds]
bleepcord has joined #lisp
Ven`` has joined #lisp
mangul has joined #lisp
shangul has quit [Ping timeout: 240 seconds]
JohanP has quit [Ping timeout: 245 seconds]
doublex has joined #lisp
doublex has quit [Ping timeout: 240 seconds]
JohanP has joined #lisp
White_Flame has quit [Remote host closed the connection]