Copenhagen_Bram has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 256 seconds]
makomo has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
Copenhagen_Bram has joined #lisp
fikka has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
iridioid has quit [Ping timeout: 240 seconds]
pierpal has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
<PuercoPop>
stylewarning: Stas is the maintainer of edi-ware afaik
Fare has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 260 seconds]
nowhere_man has joined #lisp
fikka has joined #lisp
housel has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 248 seconds]
X-Scale has joined #lisp
asdf123 has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
emacsomancer has joined #lisp
<adlai>
gendl: just be sure to stick a "this is not an officially supported AGPL exception" at the bottom of the readme?
<adlai>
it's unclear to me why corporations like google release such code under their official auspices, then slip in such a finely printed disclaimer. literally one line, not even a different font, and the house card-house collapses. but the rest of the readme is well-rendered! i wish i had the near-future potential to follow up your challenge.
fikka has quit [Ping timeout: 240 seconds]
<LdBeth>
makomo: slime provides who-calls analysis I believe
Pixel_Outlaw has joined #lisp
Fare has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
jack_rabbit has joined #lisp
nanthil___ has joined #lisp
<nanthil___>
is it accurate to say that (defgeneric ...) merely defines the interface, but that (defmethod ...) is the implementation?
fikka has joined #lisp
<nanthil___>
or can defgeneric be used for a default implementation?
<no-defun-allowed>
i thought defgeneric did the default implementation
<Bike>
only with the :method option
JuanDaugherty has quit [Quit: Exeunt]
<nanthil___>
so defgeneric can function as an interface method or an abstract method in Java/C++ terms?
<nanthil___>
and defmethod functions as an override?
light2yellow has quit [Quit: light2yellow]
<Bike>
if you like, i suppose.
fikka has quit [Ping timeout: 248 seconds]
<adlai>
nanthil___: either can do both
<nanthil___>
adlai: now you've lost me
Kundry_Wag has joined #lisp
<adlai>
you can define both the interface, and the implementation, using either toplevel form; but if you want maximal similarity to static languages, use a declaration.
<nanthil___>
I want to understand the LISP way of doing things]
<nanthil___>
i was making the comparison simply to verify understanding
<nanthil___>
and now you're telling me its less clear than that, and I don't understand any of the reading I've been doing now
<adlai>
good! so i offer a humble recommendation that you define both interface and implementation in a defgeneric form, unless some of the implementations are either large enough, or too context-specific, to clutter up the single toplevel form.
<adlai>
also, the LISP way is to use M-expressions, but that's where i'd lose myself.
<nanthil___>
so generally stick to defgeneric with the method flag unless some other use is necessary?
<adlai>
yes, we have communicated well enough.
<Bike>
it's pretty common to d efine methods outside of defgenerics
Kundry_Wag has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
<nanthil___>
what sort of lisp patterns are there outside of the closure, lambda, etc.... obviously gang of four patterns aren't super necessary, so then is the CLOS typically used simply for organzing structs with typed general dispatch?
<eschatologist>
The best way to learn Lisp patterns is work in Lisp codebases.
<nanthil___>
oh good... the end of times is coming
cmack has joined #lisp
<nanthil___>
;P
<eschatologist>
The Lisp world didn’t do a whole lot of “let’s all write a million blog posts and white papers” thing around extremely common designs like the C++ and later the Java/.NET world did.
fikka has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
lol
<nanthil___>
I think it'd done LISP a favor, and the rest of the world, beause people would be reading about why lisp is amaze-balls and why its better than java and C++
<nanthil___>
instead of leaving the rest of us to rot with JAVA
<nanthil___>
so am I to take it that general functional patterns are the most common? and that object oriented patterns are a bit silly?
<nanthil___>
what with macros, I don't see a factory being all that useful
<no-defun-allowed>
can i test if a stream is ready to be read from?
<no-defun-allowed>
i think FP is most natural for most lisp problems
<cmack>
I'm trying to play with ulubis for the first time but I'm having trouble with an error about INIT-EGL-WAYLAND not found in the egl package during the build-ulubis command. Has anyone seen this and know how to solve?
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
quipa has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
robotoad has quit [Quit: robotoad]
dwrngr has joined #lisp
housel has joined #lisp
robotoad has joined #lisp
renzhi has joined #lisp
pierpal has joined #lisp
Khisanth has quit [Ping timeout: 240 seconds]
Khisanth has joined #lisp
cmack has quit [Remote host closed the connection]
nanthil___ has quit [Quit: Page closed]
Arcaelyx has joined #lisp
Khisanth has quit [Ping timeout: 248 seconds]
Khisanth has joined #lisp
pierpa has quit [Quit: Page closed]
nowhere_man has quit [Ping timeout: 260 seconds]
<LdBeth>
#'no-defun-allowed: a stream is always ready, do you mean to test if it’s empty?
<no-defun-allowed>
to see if reading a line would make me wait
<no-defun-allowed>
i decided to use two threads and a queue instead
anewuser has joined #lisp
<no-defun-allowed>
i'm doing an asynchronous decentralised thing where i want to push out as much stuff over a socket while reading requests for new data
<LdBeth>
#'no-defun-allowed: you might have to define you own gray streams
<no-defun-allowed>
yeah, actually let's not
<no-defun-allowed>
using one input and one output thread works better
<clhsgang[m]>
beach: it's some weird subreddit with really stupid claims and pepe memes mostly
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<Shinmera>
no-defun-allowed: You can use peek-char-no-hang, but that's not a good idea usually. If you're dealing with sockets, usocket has wait-for-input and socket-state.
<clhsgang[m]>
i see
<clhsgang[m]>
both ends are expected to be async so i decided it'd be simpler to just put one listener and one responder thread. i want it to work with any stream so usocket specifics aren't the ideal solution
<Shinmera>
well, the stream concept does not include the idea of knowing if input is there. You can only consume it.
<Shinmera>
So you need to make case-by-case distinctions.
blackadder has joined #lisp
SaganMan has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
<clhsgang[m]>
that is true
Pixel_Outlaw has quit [Quit: Leaving]
meepdeew has quit [Remote host closed the connection]
johnnymacs has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
lavaflow has quit [Read error: Connection reset by peer]
lavaflow has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
<phoe>
Shinmera: hah, peek-char-no-hang
robotoad has joined #lisp
void_pointer has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
zxcvz has quit [Quit: zxcvz]
zxcvz has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
shka_ has joined #lisp
nika has joined #lisp
Oladon has quit [Quit: Leaving.]
varjag has joined #lisp
varjag has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
drewes has joined #lisp
vlatkoB has joined #lisp
josemanuel has joined #lisp
varjag has joined #lisp
varjag has quit [Client Quit]
varjag has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
beach has quit [Ping timeout: 256 seconds]
igemnace has quit [Quit: WeeChat 2.2]
drewes has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
cage_ has joined #lisp
<mgsk>
Should (describe #'some-func) show the documentation as set by (setf (documentation #'some-func 'function) "the documentation")? I would expect so, but doesn't seem to be the case
mgsk has left #lisp ["Using Circe, the loveliest of all IRC clients"]
mgsk has joined #lisp
mgsk has left #lisp ["Using Circe, the loveliest of all IRC clients"]
mgsk has joined #lisp
<mgsk>
Oops
<mgsk>
Hopefully didn't miss a reply while my irc was going bezerk
<Shinmera>
"In all cases, however, the nature and format of the output of describe is implementation-dependent."
<void_pointer>
mgsk: looking at the draft of the CL ANSI standard, it says that what describe and describe-object show are implementation dependent
<mgsk>
Fair enough. Ty Shinmera void_pointer
<Shinmera>
For instance, SBCL will print the docstring if it is known.
<Shinmera>
If it does not, you might be able to add it yourself with something like (defmethod describe-object :after ((function function) stream) (format stream "~@[~&~%Documentation:~% ~a~]" (documentation function T)))
<Shinmera>
Doing so is not conformant, I believe, but since we're already in implementation-specific territory anyway it doesn't really matter.
<Shinmera>
*If it => If your implementation
loke has left #lisp ["ERC (IRC client for Emacs 25.2.1)"]
loke has joined #lisp
JuanDaugherty has joined #lisp
<mgsk>
Shinmera: If I setf the documentation, SCBL's DESCRIBE doesn't show the doc, but DOCUMENTATION does. So it both knows and doesn't know the doc string.
<Shinmera>
Ah- that's probably because function objects have a specific documentation slot so you can document functions that are not top-level definitions.
<phoe>
mgsk: sounds like a bug. You might want to mention it on #sbcl.
<Shinmera>
Hmm actually looks like the describe method for function objects is doing something weird
orivej has joined #lisp
<Shinmera>
(documentation (lambda () "Foo" NIL) T) ;=> "Foo", and (let ((a (lambda ()))) (setf (documentation a T) "Foo") (documentation a T)) ; => "Foo" as well
<Shinmera>
But in both cases describe shows "Documentation: T" for the object.
<mgsk>
Weird eh
mn3m has joined #lisp
<loke>
I think you can minimise the test case to: (describe (lambda () "foo" nil))
gravicappa has joined #lisp
<edgar-rft>
AFAIK the doc-string is wired into the DEFUN macro, but not into LAMBDA
<phoe>
well, at least it's logical
<phoe>
user: "does it have documentation"
<phoe>
SBCL: "yep"
<phoe>
user: "awesome, thanks"
<mgsk>
phoe: lol
<Shinmera>
phoe: it does print the actual docstrings for standard functions though.
<Shinmera>
edgar-rft: lambda includes the ability to include a docstring.
<edgar-rft>
just looked, the CLHS says LAMBDA has a doc-string, too
<phoe>
Shinmera: I know. I was joking.
<edgar-rft>
*Shinmear was faster than me
<Shinmera>
Well I didn't need to look
<edgar-rft>
that's why :-)
<phoe>
then it's a bug in SBCL, it seems
cage_ has quit [Quit: Leaving]
nowhere_man has joined #lisp
razzy has joined #lisp
quipa has joined #lisp
DataLinkDroid has quit [Ping timeout: 240 seconds]
mn3m has quit [Quit: mn3m]
makomo has joined #lisp
jmercouris has joined #lisp
Kundry_Wag has joined #lisp
random-nick has joined #lisp
DataLinkDroid has joined #lisp
Demosthenex has joined #lisp
<Demosthenex>
hey, i thought i read somewhere someone recommended common lisp for math/data analysis instead of R. R's hell to search for, anyone know of something similar? running math and interactive simple plots in CL?
<jmercouris>
Demosthenex: there are some interfaces to plot software in CL
<jmercouris>
anyway, CL is better than R, and there are more than enough libraries in CL to do what you want
<jmercouris>
I would say, give it a try, and if you encounter too much friction, you can always drop back to R
Kundry_Wag has quit [Ping timeout: 240 seconds]
Fare has joined #lisp
jack_rabbit has quit [Ping timeout: 264 seconds]
JuanDaugherty has quit [Quit: Exeunt]
<Shinmera>
Maxima also has plotting capabilities, if I remember correctly
jack_rabbit has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
sjl has quit [Ping timeout: 248 seconds]
Bike has joined #lisp
sjl has joined #lisp
sjl has quit [Client Quit]
gigetoo has quit [Ping timeout: 240 seconds]
rpg has joined #lisp
orivej has joined #lisp
<gendl>
adlai: I'm not sure what is the current state of the art for CL to C++ interfacing. We have a longstanding integration with a body of commercial C++ code with hand-written C wrappers. I'm sure there are better ways to do it these days.
<Shinmera>
Not really if you want it to run on many implementations.
gigetoo has joined #lisp
pjb has joined #lisp
<p_l>
I'd say interfacing with C++ is ... problematic outside Windows and *possibly* AIX (if you have source code)
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
<p_l>
Clasp technically can do better but that's non-trivial as well
<p_l>
on Windows you have the benefit that you can make a COM wrapper around the C++ library and use COM from CL
<p_l>
Don't recall if you need to do something special to be able to run it in IPC mode, but if you do that then you get isolation from C++ messing with your runtime
<p_l>
AIX has SOM ABI option for C++, but that's rarely used (gives similar ABI to Objective-C, iirc)
troydm has joined #lisp
makomo has quit [Ping timeout: 264 seconds]
orivej has quit [Ping timeout: 260 seconds]
easye has joined #lisp
light2yellow has joined #lisp
cage_ has joined #lisp
eMBee has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
makomo has joined #lisp
svillemot has quit [Ping timeout: 256 seconds]
pjb has quit [Read error: Connection reset by peer]
svillemot has joined #lisp
xristos has quit [Ping timeout: 256 seconds]
beach has joined #lisp
pjb has joined #lisp
Kundry_Wag has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
lnostdal__ is now known as lnostdal
Kundry_Wag has quit [Ping timeout: 264 seconds]
quipa_ has joined #lisp
quipa_ has quit [Remote host closed the connection]
quipa has quit [Ping timeout: 240 seconds]
quipa_ has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
rozenglass has quit [Ping timeout: 264 seconds]
jack_rabbit has quit [Ping timeout: 264 seconds]
<gendl>
p_l: what ever happened to swig?
<p_l>
gendl: it fights the uneven battle, uphills in snow both ways
<Demosthenex>
p_l: oooh! aix! i like that stuff. but yes, dev stuff is hard to come by
<p_l>
Demosthenex: XLc supports using SOM ABI for C++ classes
<Demosthenex>
yep, but if it's the paid XLC most customers don't have it
<Demosthenex>
many admins try to make do with gcc
<p_l>
ah
<p_l>
my only contacts with AIX development were very tangential and involved XLc for Plan9
<Demosthenex>
the stdlib for c++ isn't even in the standard install as i recall. you have to install the libstdc++ packages
<Demosthenex>
if you install something compiled from it
<gendl>
it seems like the best way to interface with anything these days is to demand a web API and interact with that.
<gendl>
assuming one is in the position of "demanding."
<p_l>
gendl: or at least wrapping it around in one
<Demosthenex>
i must admit, between emacs restclient mode and postgres' json handling, web apis are really simple now
<p_l>
even SWIG has to do so when dealing with C++, as it generates a C wrapper
<Demosthenex>
i still long for a useful TUI library
<p_l>
jackdaniel made a demo of using CLIM on ncurses
<shka_>
what the heck
<shka_>
CLIM on ncurses?
<Demosthenex>
i have a variety of small forms based crud apps i'd make in a heartbeat if i didn't have to reinvent the TUI wheel completely :P
<shka_>
crazy
<Demosthenex>
right now i lean on org-mode because it does really simple tables.