SGASAU has quit [Remote host closed the connection]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
SGASAU has joined #lisp
SGASAU has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 265 seconds]
<pfdietz>
Yay! What is breaking?
judson_ has joined #lisp
<Xach>
nothing, i'm testing with 2.0.5, a good SBCL
<Xach>
after the release i will test with the latest, again, and report some more bugs.
judson_ has quit [Client Quit]
* Xach
has time for release now that he has been killed unexpectedly by jubilex
sz0 has quit [Ping timeout: 272 seconds]
kilimanjaro has quit [Ping timeout: 272 seconds]
mgsk has quit [Read error: Connection reset by peer]
buoy49 has quit [Ping timeout: 256 seconds]
jerme_ has quit [Ping timeout: 272 seconds]
gendl has quit [Ping timeout: 272 seconds]
jerme_ has joined #lisp
ffwacom has quit [Ping timeout: 260 seconds]
alanz has quit [Ping timeout: 260 seconds]
physpi has quit [Ping timeout: 260 seconds]
Vultyre has quit [Ping timeout: 265 seconds]
selwyn has quit [Ping timeout: 264 seconds]
mgsk has joined #lisp
alanz has joined #lisp
banjiewen_ has quit [Ping timeout: 272 seconds]
banjiewen__ has joined #lisp
buoy49 has joined #lisp
selwyn has joined #lisp
hnOsmium0001 has quit [Ping timeout: 265 seconds]
Vultyre has joined #lisp
physpi has joined #lisp
sz0 has joined #lisp
kilimanjaro has joined #lisp
gendl has joined #lisp
ffwacom has joined #lisp
hnOsmium0001 has joined #lisp
judson_ has joined #lisp
charles` has joined #lisp
<dbotton>
Xach what time is/was the cut off? (I just checked in the last major feature)
<Xach>
dbotton: a few hours ago.
<Xach>
maybe 6?
<dbotton>
Oh well what is is, thanks
<Xach>
que serapeum serapeum
<dbotton>
At least got a bunch of docs in there
<dbotton>
Videos and sound next time
gaqwas has quit [Ping timeout: 264 seconds]
<charles`>
cut off for quicklisp release?
ealfonso has quit [Ping timeout: 260 seconds]
<dbotton>
ya
<charles`>
So I there is a bug fix, it won't be readily available until the next release?
X-Scale` has joined #lisp
<Xach>
charles`: through quicklisp, usually that's how it works. if you want intermediate updates you have to fetch it yourself, like with a git checkout or similar.
X-Scale has quit [Ping timeout: 240 seconds]
<charles`>
or ultralisp ;)
X-Scale` is now known as X-Scale
<charles`>
congratulations X-Scale !
<Xach>
yeah, that dist uses a different release cadence and criteria
<charles`>
If a library is on ultralisp and quicklisp how does quicklisp decide which one to get? most recent?
<Xach>
charles`: you can get pretty fine-grained, but the default ordering is which dist was more recently installed
<Xach>
you can change the priority at the dist, project, and system level
zyz has joined #lisp
nij has joined #lisp
nij has left #lisp [#lisp]
<Xach>
if you check out a project somewhere known to asdf it will always take priority over a dist-provided system
<Xach>
"always", but you can always change the asdf system search function ordering if you really want to.
<Xach>
it's programs all the way down!
<charles`>
truly amazing. So quicklisp will update a project even if the ASDF version number didn't change?
scymtym has joined #lisp
<Xach>
it will update a project if the code changes, the asdf version number does not factor in
<Xach>
actually not the code - if the project's sources change, which includes non-code files too.
luni has quit [Quit: Connection closed]
asarch has quit [Quit: Leaving]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
theothornhill has joined #lisp
wxie has joined #lisp
theothornhill has quit [Ping timeout: 256 seconds]
nullman has quit [Ping timeout: 264 seconds]
nullman has joined #lisp
deltab has quit [Ping timeout: 240 seconds]
summerisle has quit [Quit: In my vision, I was on the veranda of a vast estate, a palazzo of some fantastic proportion.]
summerisle has joined #lisp
skapata has quit [Remote host closed the connection]
judson_ has joined #lisp
deltab has joined #lisp
torbo has quit [Remote host closed the connection]
mmmattyx has quit [Quit: Connection closed for inactivity]
perrier-jouet has quit [Quit: WeeChat 3.0]
perrier-jouet has joined #lisp
CEnnis91 has quit [Quit: Connection closed for inactivity]
ealfonso has joined #lisp
<ealfonso>
Can anyone help me understand this error? "Lock on package ALEXANDRIA.1.0.0 violated when defining ALEXANDRIA.1.0.0:WHEN-LET as a macro while in package HUNCHENTOOT." It only started happening after installing (ql-dist:install-dist "http://dist.ultralisp.org/")
<White_Flame>
something's trying to define WHEN-LET in two places
<White_Flame>
and the 2nd one is doing so when alexandria's one is already imported/used
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
bilegeek_ has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
bilegeek has quit [Ping timeout: 244 seconds]
orivej_ has quit [Ping timeout: 246 seconds]
bilegeek_ is now known as bilegeek
<ey[m]1>
what would be the fastest way to iterate from 1 to 1 billion in common lisp ?
<White_Flame>
declare fixnum
<White_Flame>
all reasonable styles should compile down to the same register increment
<White_Flame>
(assuming you have your optimization declarations as well)
dbotton has quit [Quit: Leaving]
renzhi has quit [Ping timeout: 244 seconds]
<ey[m]1>
and how would I have a list or an array of 1 billion elements ?
<Bike>
how? you can make them with make-list or make-array
<White_Flame>
just do your type & optimization declarations and use the standard stuff
<White_Flame>
also, use DISASSEMBLE to verify your assumptions
<White_Flame>
any time there's an unexpected function call to some CL internal, you haven't found optimality yet
<White_Flame>
also, this is assuming SBCL, which is quite good (sans the triggering lack of peephole optimizer ;) ))
<ey[m]1>
something like (make-array 1000000000) exhausts the heap
<White_Flame>
give it a bigger heap then, as a cmdline option
<ey[m]1>
I gave it 4 gb, it still couldn't do it
zacts has joined #lisp
<White_Flame>
default is like 1GB, you're allocating like 8
<White_Flame>
so give it 12 or something
<White_Flame>
assuming a 64-bit system, that's 8 bytes per entry
<White_Flame>
also, if you're iterating that size of memory, your memory bandwidth could easily dominate performance, if you're just doing simple work per entry
bilegeek has quit [Quit: Leaving]
<White_Flame>
oh, and be aware that you're allocating a million-dimension array ;)
<White_Flame>
*billion
<saturn2>
you could use a bit vector if you want to save memory
<White_Flame>
(hmm, not sure about dimensionality, but still.)
<White_Flame>
(nope, you're right. A number there is a designator for a list of 1 number)
abhixec has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 264 seconds]
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
galex-713 has joined #lisp
<mfiano>
Having a hard time trying to figure out what such a large dataset of known values ahead of time would be used for
<White_Flame>
well, brute force techniques might call for that, now that memory is much more available
<White_Flame>
but those usually aren't used for a straight iterative streaming, but a massive lookup table
aeth has quit [Ping timeout: 264 seconds]
aeth has joined #lisp
Alfr_ has joined #lisp
<beach>
Good morning everyone!
Codaraxis has quit [Read error: Connection reset by peer]
judson_ has joined #lisp
Alfr has quit [Ping timeout: 264 seconds]
<mfiano>
Then use an array of '(unsigned-byte 32), not a list of fixnums.
<mfiano>
On sbcl64, that'd be 4,000,000,016B
<White_Flame>
obviously depends on the data. If he's just using bytes, then cut that in half by 4 again
<White_Flame>
-in half
Bike has quit [Quit: Lost terminal]
<mfiano>
Oh I read the question as a list of values from 1 to 1 billion. Ignore me
ealfonso has quit [Ping timeout: 264 seconds]
ebrasca has joined #lisp
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 260 seconds]
Codaraxis has joined #lisp
<jrm>
For our clx OS package, any suggestions on whether we should stick with the latest release (0.7.5) or do what quicklisp does and keep up with the master branch of https://github.com/sharplispers/clx ?
<beach>
Are there any releases at all? I would do the sharplispers version. As I recall, the good people in #clim also fix issues in CLX when they find them. But you can check with them.
Nilby has joined #lisp
ex_nihilo has quit [Quit: Leaving]
<jrm>
beach: Yeah, they (github.com/sharplispers) released 0.7.5 back in Feb. 2018.
<beach>
Oh, OK.
orivej has joined #lisp
andreyorst[m] has quit [Read error: Connection reset by peer]
wxie has quit [Ping timeout: 272 seconds]
ebrasca has quit [Remote host closed the connection]
wxie has joined #lisp
lowryder has quit [Ping timeout: 272 seconds]
lowryder has joined #lisp
narimiran has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
easye has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
theothornhill has joined #lisp
judson_ has joined #lisp
theothornhill has quit [Ping timeout: 256 seconds]
Anonymous_ has joined #lisp
andreyorst has joined #lisp
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 260 seconds]
pfdietz has quit [Quit: Ping timeout (120 seconds)]
theothornhill has joined #lisp
zacts has quit [Quit: leaving]
wxie has quit [Ping timeout: 240 seconds]
theothornhill has quit [Ping timeout: 240 seconds]
iskander has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
iskander- has quit [Ping timeout: 256 seconds]
Stanley00 has joined #lisp
zacts has joined #lisp
jumping_sloth has joined #lisp
_whitelogger has joined #lisp
froggey has quit [Ping timeout: 246 seconds]
froggey has joined #lisp
jprajzne has joined #lisp
andreyorst` has joined #lisp
akoana has left #lisp ["Leaving"]
wxie has joined #lisp
andreyorst has quit [Ping timeout: 256 seconds]
daphnis has joined #lisp
shka_ has joined #lisp
attila_lendvai has joined #lisp
enzuru has joined #lisp
enzuru has quit [Client Quit]
enzuru has joined #lisp
ebrasca has joined #lisp
rogersm has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nij has joined #lisp
<nij>
Why are lisp compiled files SO LARGE?
<nij>
hello.exe => 42MB
<beach>
You mean executables?
<beach>
Because the compiler must be present for it to be Common Lisp.
<beach>
But that's not "compiled files". A compiled file would be more like a FASL.
<nij>
oh..
<nij>
beach: can't we use dynamical linking to call the compiler?
<beach>
Sure, some Common Lisp systems can have many things in a shared object file. I think ECL does that.
<beach>
nij: But I assume you are not looking at ECL.
<nij>
Oh.. I'm using sbcl. :-(
<beach>
nij: Unix-like operating systems are a very bad fit for Common Lisp. Imagine instead that the Common Lisp REPL is the shell, and FASLs are your executable files.
<nij>
I see.
<beach>
On the other hand, 42MB of RAM (assuming that everything has to be in RAM which is not true if you have demand paging) cost how much these days? A few cents?
<nij>
Having 50 of them is .. 2GB.
<nij>
I mean.. I don't see why SBCL can't make it link to compiler dynamically.
<beach>
nij: So as it turns out, the maintainers of SBCL did not bother to make the Unix executable files small. I fully understand their priorities.
<nij>
I see!
* Nilby
is living in that imagination.
<flip214>
nij: you can produce an image with all of the shared libraries, and use that image to load the app-specific FASLs.
<nij>
flip214: How much in size can be reduced @@?
<flip214>
nij: as long as the base image is uncompressed and can so be mmap()ed into memory directly, all of the running processes should share the common libs.
<beach>
nij: You would have 42MB for the 50 applications.
<flip214>
nij: do you want to save space _on_disk_ or _in_ram_ (when using 50 different applications)?
<beach>
A bit more perhaps.
<nij>
oh oh oh see
<nij>
yeah this is how people handle their cl scripts
<flip214>
_on_disk_ you can reduce space demands by writing a compressed image.
<nij>
it's still weird to me though.
<nij>
I can understand their priorities too.
theothornhill has joined #lisp
<beach>
nij: Seriously though, forget about the defective Unix model and just use the Common Lisp REPL.
<nij>
beach that's the plan
<flip214>
nij: just add up all the libstdc++, libgcc, gcc, ld, .h, and other files required for the same task, and _the_ compare again ;)
<nij>
i don't even have to make executables right?
aindilis has quit [Ping timeout: 265 seconds]
<flip214>
depends on your needs.
<nij>
flip214: yep yep xD
<beach>
I never make executables myself.
<nij>
But it's nice to have a keybind in my window manager, that executes something right away.
<flip214>
an image that comes up with the HTTP port 18msec after starting is quite nice... but if you reload all the libs first it takes longer
<pranavats>
There was a tutorial on replacing unix shell with Clisp.
<nij>
pranavats: Give it to MEEE xDD
aartaka has joined #lisp
<beach>
pranavats: That would not solve the problem.
<nij>
How do I send signals to a stand-by sbcl repl, for it to evaluate some expressions?
<aeth>
nij: CL is basically in the same situation JVM is, as White_Flame said. It's just... installed by default on far fewer machines.
<White_Flame>
nij: the server end of SLIME does that (called swank)
<aeth>
Bundling the (large) runtime executable with each executable seems more appealing when you're distributing it to someone who doesn't have it, even if it's wasteful.
<White_Flame>
you can have a running lisp process, then make a new slime connection to it from emacs and have a full repl. Disconnect, and the lisp process stil runs
<nij>
White_Flame: I see. I will look for an equivalent of SLY. Thanks!
<White_Flame>
useful for debugging deployments
<White_Flame>
does sly use the same swank backend?
<nij>
SHCL doesn't seem to be running in the sbcl repl :-(
<nij>
Ah it's called slynk.
gxt has joined #lisp
aeth has quit [Ping timeout: 272 seconds]
aeth has joined #lisp
<beach>
nij: While it is possible (as ECL shows) to put a lot of system code in a shared object file, it would not be appropriate for Common Lisp to use the kludge that Unix calls "dynamic linking".
<nij>
not appropriate in what sense?
<beach>
It just makes too many assumptions about how functions are called, etc.
<beach>
And those assumptions are appropriate for C.
<nij>
Oh @@
<beach>
I suppose it would be possible for a Common Lisp system to use Unix dynamic linking, but it would be a lot of work to adapt the system implementation that way, or to special case some functions like the compiler.
amb007 has quit [Read error: Connection reset by peer]
<nij>
I see.
<nij>
Can imagine the loads of nuances..
amb007 has joined #lisp
<beach>
If I were to split a Common Lisp system into a shared object and an executable, I would probably put just executable code in the shared object, and mmap it to some known location at system start-up.
<beach>
But that might not work in the future. Because the Unix model is so broken, they add hacks to kludges that make it more and more difficult to do things like that. ASLR is a case in point.
<nij>
:-(
<nij>
I will forget about making executables for now and just stick with the repl.
<beach>
... all so that they can continue to use unsafe languages on an unsafe operating system also written in an unsafe language.
<nij>
sigh
<nij>
speaking of safety
<nij>
what kind of database would you choose?
<White_Flame>
postgres is popular
<nij>
I'm thinking of why shouldn't I use lisp code to replace csv.
<beach>
Me? None!
<White_Flame>
sexpr data files are already way better than csv
<beach>
Indeed.
<White_Flame>
in terms of the read-all, dump-all case
<nij>
And it's more transparent.
<nij>
I find it hard to read a fullfledged database.
<flip214>
well, json at least keeps number/string types intact, and compatible to other systems as well
<White_Flame>
but if you actually need a database as in RDBMS, then go postgres
<White_Flame>
if single-user, then sqlite
<pranavats>
There are also object stores like manardb (https://www.cliki.net/manardb). I haven't tried using them, however.
<nij>
heard this advice many times. i will do that White_Flame
<White_Flame>
postgres has strong support. I haven't used sqlite from cl before, but libs are there,t oo
hjudt has joined #lisp
<nij>
pranavats: how easy is it to read the content of a manardb?!
<pranavats>
nij: I'm yet to explore object stores as well, to be honest.
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
anticrisis has quit [Read error: Connection reset by peer]
nij has quit [Ping timeout: 244 seconds]
gaqwas has joined #lisp
theothornhill has joined #lisp
liberliver has joined #lisp
theothornhill has quit [Ping timeout: 246 seconds]
heisig has joined #lisp
johnjay has quit [Ping timeout: 246 seconds]
theothornhill has joined #lisp
daphnis has quit [Ping timeout: 264 seconds]
surabax has joined #lisp
theothornhill has quit [Ping timeout: 272 seconds]
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
malaclyps_ has quit [Quit: Idle for 30+ days]
cairn has quit [Quit: Idle for 30+ days]
zyz_ has joined #lisp
zyz has quit [Ping timeout: 265 seconds]
hendursaga has joined #lisp
mrios22 has joined #lisp
hendursa1 has quit [Ping timeout: 268 seconds]
rgherdt has joined #lisp
daphnis has joined #lisp
pve has joined #lisp
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
varjag has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
tassleoff has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
galex-713 has quit [Remote host closed the connection]
galex-713 has joined #lisp
jumping_sloth has quit [Quit: Leaving]
theothornhill has joined #lisp
jumping_sloth has joined #lisp
theothornhill has quit [Ping timeout: 265 seconds]
<jackdaniel>
or, if you want to work with locatives: (defvar *place* (assoc "b" …)) and then (setf (cdr *place*) 9)
<jackdaniel>
the problem is that *place* is not a name, it is a variable
<jackdaniel>
and when you bind it to 8, the immediate object is associated with that variable
<jackdaniel>
not the address of it
<nij>
this is complicated, wow
<nij>
but lemme try and get used to it
<jackdaniel>
when you define *place* as you did above, you simply assign to it a result of the operation, that is a number 8
<jackdaniel>
how updating the variable from number 8 to 9 could influence the association list? *place* has no knowledge about that structure
<nij>
Indeed!
<nij>
I got it now :D thanks :D :D
<jackdaniel>
on the other hand, when you bind a certain cons to the variable *place*, then you may manipulate this cons freely (and assuming that it is part of the assoc list, modifying the cons will be reflected in the association list)
<jackdaniel>
common lisp features something called a symbol macro which would allow saying (setf *place* 9), but don't get distracted by that, it is a syntactic noise
<flip214>
when printing compound objects, floats in there are written with too many digits; can I bind some variable (like *PRINT-LENGTH*) to change the format of floats within a block?
<phoe>
how are they printed in there? prin1?
<phoe>
the only way I can imagine is using FORMAT with a format control argument passed via a dynamic variable
theothornhill has quit [Remote host closed the connection]
<ldb>
maybe it's a good idea to specialize your printer
nicktick has joined #lisp
hiroaki has joined #lisp
ldb has quit [Remote host closed the connection]
ldb has joined #lisp
aeth has quit [Ping timeout: 264 seconds]
<[d]>
<jackdaniel#0000> eql seems to be more sensible, but I don't see the appropriate entry on the assoc page (neither for eq or eql)
<[d]>
<jackdaniel#0000> [edit]:
<[d]>
<amigojapan#0000> nice
<[d]>
<amigojapan#0000> [edit]:
<[d]>
<jackdaniel#0000> maybe it is settled in some normative statement for default test values
<[d]>
<jackdaniel#0000> [edit]:
<[d]>
<arryana#0000> nods
<[d]>
<arryana#0000> [edit]:
theothornhill has joined #lisp
aeth has joined #lisp
<beach>
[d]: What are you doing?
<andreyorst`>
probably some IRC bridge stuff
<beach>
Mystery to me. But thanks.
caret has joined #lisp
<andreyorst`>
their client supports message edits, which are simply sended to IRC as new messages with [edit] mark
<jackdaniel>
of course you should replace (format stream …) with your own stuff
hnOsmium0001 has joined #lisp
<nij>
I feed a long string to it..
<nij>
Error: Invalid index 24039 for (SIMPLE-VECTOR 256), should be a non-negative integer below 256.
ldb has quit [Remote host closed the connection]
ldb has joined #lisp
<jackdaniel>
could you show me the code?
rumbler31_ has joined #lisp
<nij>
jackdaniel: Ah! It's because I have some non-english character inside.
<nij>
inside the string
<phoe>
gasp
<phoe>
could clim-pdf assume that all char-codes are of type (mod 256)?
<phoe>
or is there something else going on in there
<nij>
perhaps @@
<jackdaniel>
it is a matter of font metrics (so yes, clim-pdf issue)
<nij>
Or I can just use my old way.
<nij>
aka use vim
judson_ has joined #lisp
<nij>
$ vim test.txt -c ":\!paps < % > ~/test.pdf"
<nij>
Just have to insert this into cl..
surabax_ has joined #lisp
daphnis has quit [Ping timeout: 264 seconds]
judson_ has quit [Client Quit]
surabax has quit [Ping timeout: 246 seconds]
cer0 has quit [Quit: leaving]
nicktick has quit [Ping timeout: 260 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
ldb has quit [Remote host closed the connection]
thatpythonboy has joined #lisp
nicktick has joined #lisp
<thatpythonboy>
hey
<phoe>
helloooo
<beach>
Hello thatpythonboy. Are you new here? I don't recognize your nick.
rozenglass has joined #lisp
<nij>
Hello :D
<nij>
I heard that (>>>>> (size-of python-lib) (size-of cl-lib))..
<nij>
How do cl folks deal with this :'( ?
<beach>
"deal with"?
<phoe>
nij: wait, what do you mean
<nij>
The size of python library is much larger than that of CL..
<nij>
I
<mfiano>
and?
<phoe>
oh, you mean, the number of available libraries?
<beach>
So?
<aeth>
nij: There are three different ways to interface with Python
<aeth>
At least.
<jackdaniel>
immesaurable amounts of whisky help
<phoe>
sure, there's fewer, but it doesn't mean there's few
<phoe>
CFFI also makes things easier for when there are foreign libraries available.
[d] has quit [Excess Flood]
<dim>
yeah also if you target the JVM that's where you will find the greatest number of already available libs to integrate with everything that exists, I believe
[d] has joined #lisp
<dim>
at least on the JVM you can then use ABCL or Clojure
<jackdaniel>
what is more bothering is that python libraries tend to work longer - that means that the joy of computing lasts longer
<nij>
work longer?
<beach>
Heh.
<jackdaniel>
I'm joking that python performance is poor due to some specification choices
<nij>
mfiano: beach: .. Well we certainly don't want to write libs when it's needed as an auxialiry tools, right?
<nij>
he he he
<beach>
nij: Seriously, what kind of question is that?
<pranavats>
nij: We deal with it by staying focused on our needs, (for which CL libraries are often enough), rather than what's fashionable.
bitmapper has quit [Quit: Connection closed for inactivity]
<jackdaniel>
it was hello, but then I had it aligned so I couldn't verify, that the flipping ink works in the middle of the single letter
<beach>
I like this better.
<nij>
lol
dbotton has joined #lisp
<nij>
Speaking of this.. why doesn't "hell\no" give "hell
<jackdaniel>
notice i.e a letter "N" in the second row
<nij>
o" ?
<phoe>
nij: because of how the #\" reader macro works
<phoe>
see CL-INTERPOL for the behavior you seek
<jackdaniel>
nij: \n is printf's control character for writing a new line
<nij>
How to I achieve an equivalent here in CL?
<jackdaniel>
try: (format nil "hell~%o")
<jackdaniel>
or simply break the line before o
<nij>
yeah im aware of that
<nij>
just wishing a way to express the string with plain '""' and escapes.
ebrasca has quit [Read error: Connection reset by peer]
<jackdaniel>
then follow phoe's advice
ebrasca has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
<nij>
OH cool.
karlosz has joined #lisp
<beach>
phoe: CL-INTERPOL? You mean we have libraries for Common Lisp?
renzhi has joined #lisp
<nij>
XD
<beach>
Though, I am sure there is a library for Python to modify the python reader.
<beach>
No, wait, Python is not homoiconic, is it, so the code is not read by READ.
<nij>
It must be read by some other read @@
wsinatra_ has joined #lisp
<nij>
I bet someone can re-write a python implementation (in particular, its "read") in python.
<phoe>
beach: :D
<nij>
That makes it possible to alter the reader in the lang python.
lowryder has quit [Ping timeout: 260 seconds]
wsinatra has quit [Ping timeout: 260 seconds]
<nij>
Why, then, is Lisp homoiconicity superior (if it is)?
<nij>
(I believe it is :P)
<White_Flame>
metaprogramming
<shka_>
nij: macros without homoiconicity turn out to be a real mess
<White_Flame>
as in code that "programs" as in transforms or generates new code for you
<White_Flame>
not the python "metaprogramming" of just putting hooks on methods
<shka_>
nij: take a look at the scala macros to understand the problem
lowryder has joined #lisp
<nij>
took a quick look
<shka_>
scary huh?
<nij>
codes without parentheses now hurt my eyes
<nij>
however, codes with parentheses appear to have no parentheses any more o.0
<nij>
scary indeed
<shka_>
anyway, homoiconicity is handy because lisp meta-programing is just lisp programming
<shka_>
nothing unusual here, just work with lists
thatpythonboy has quit [Ping timeout: 256 seconds]
<aeth>
I'm probably going to implement Python at some point
<shka_>
aeth: good luck
<nij>
lol
<shka_>
noo, i really wish aeth good luck
<aeth>
shka_: I mean, it's not going to be a complete Python 3, and even if it is, it's not going to run any meaningful library like Tensorflow, which expects Python's particular way of calling into C/C++/Fortran
<shka_>
right
<aeth>
But you should be able to turn e.g. print("Hello world") into (python:print "Hello world")
<aeth>
And the latter is the interesting part, because now you'd be able to write a real s-expressioned Python, rather than e.g. Hy
<nij>
aeth: could you do it in a way that first translates py codes into lisp?
<nij>
YES
<nij>
What's the problem with hy?
<nij>
(I really like its name, by the way.)
<aeth>
nij: It would parse print("Hello world") into (python:print "Hello world") rather than directly translating it into the equivalent CL-native print/write/format because then you could use macros on the intermediate language
<shka_>
nij: other then the lack of a use case?
<nij>
OH! hy translates print("Hello world") into what?
<shka_>
if you wanna lisp that can interoop with some platform, pick clojure
Josh_2 has joined #lisp
aartaka has joined #lisp
<shka_>
it is not perfect, far from it, but it is actually quite enjoyable language
<aeth>
I think Hy might work on the AST of Python, but that's a low-level interpreter-specific AST used for internals
<aeth>
My hypothetical would just be full CL
<nij>
yes hy works on python asts
<nij>
But.. doesn't it translate the ast of print("Hello!") into "(python:print "Hello!")" ?
<aeth>
well, I don't quite know how it works, but in my experience, the various Lisp-like languages for non-Lisps don't really... do Lisp.
<aeth>
Python-on-CL would just... be Python on CL, essentially librarifying it.
<nij>
:-( i see
<aeth>
Although this is a lot less than you think it is because (1) Python has a GIL so there are implicit, undiscovered race conditions in the code meaning you can't multithread libraries and (2) Python is slow so there's a lot of FFI, which wouldn't be compatible
<nij>
It seems that all the problem can be solved if there's a textual translator.
arora has joined #lisp
notzmv has joined #lisp
renzhi has quit [Ping timeout: 240 seconds]
andreyorst has joined #lisp
<nij>
Namely, a translator between code as text, prior to any eval or internalization.
charles` has joined #lisp
<aeth>
The way I'm going to implement non-s-expression languages (I currently only have a partial Scheme) is to essentially write an s-expression language that preserves the semantics of the language.
<beach>
nij: You mean like READ and PRINT?
judson_ has joined #lisp
<aeth>
Lispy languages that compile to other languages like Lua or Python tend to do either (lisp-like-language -> source-code) or (lisp-like-language -> exposed-interpreter-AST), but you're still restricted by the semantics of the target
<Josh_2>
how do I convert a symbol like 'LIMIT to :|limit| ?
judson_ has quit [Client Quit]
<Josh_2>
Basically Im trying to check if a bunch of symbols are boundp as they correspond to variable names
<beach>
Josh_2: Wow, there are so many strange ideas in that question.
<Josh_2>
sorry lul
<aeth>
nij: What I'll be attempting is (foreign-source-code -> lisp-like-language -> Common-Lisp) which means it will have the performance characteristics of, say, SBCL and you will be able to use all of SBCL in both the compiler stage and the actual runtime.
judson_ has joined #lisp
<Josh_2>
You can probably tell me a more optimal way to solve my problem
<aeth>
nij: I'll do it on Lua, not Python, though. Lua's much, much smaller. If it works I might do Python and/or JS at some later time.
<beach>
Josh_2: So you have a symbol named "LIMIT" yes?
<beach>
... in some package.
<beach>
Josh_2: And you want to convert it to a keyword symbol named "limit"?
judson_ has quit [Client Quit]
<beach>
But what's the variable part?
<aeth>
Josh_2: step one is (symbol-name 'LIMIT) to get "LIMIT"
<aeth>
Josh_2: it should be obvious from there
judson_ has joined #lisp
<nij>
aeth: so do you mean to write a textual translator that first translates "print("hi")" to "[print "hi"]" and then to "(print "hi")"?
<nij>
aeth: (By the way, I wonder where you can find the very definition of the lang python.)
<Josh_2>
Basically I need to construct a large plist with many key values pairs however all of the keys are optional and I want to construct the list using the &key option in λ lists
<shka_>
Josh_2: and what is the default?
<shka_>
if it is optional
<aeth>
nij: no, it would go from print("hi") to (whatever-language:print "hi") with the caveat that various "-related syntax would be part of the reader, so e.g. "hi\nworld" would already turn the \n into a newline by the s-expression step, although a reader macro could be used to get the desired foreign behavior of " for literally writing the s-expressions
<nij>
beach: not read and print. But a function #'py->lisp with signature string->string.
<Josh_2>
I don't want to go through and check which are bound manually, I just want to construct my list from the bound variables
<Josh_2>
shka_: well unbound in this case, but I can provide a default
<shka_>
Josh_2: anyway, you want to construct keyword?
<shka_>
correct
<aeth>
nij: you absolutely don't want to go string to string
<aeth>
at least, not directly
<aeth>
You could go, say, Markdown string -> HTML string, but you better have a bunch of s-expressions in the intermediate or you lose the advantages of using CL
<Josh_2>
Say I have the symbol 'limit, which may or may not be bound, I need to construct a list like '("limit" <value of limit> ... )
<nij>
aeth: right, to rescue the structures.
<beach>
Josh_2: What's the ' about?
<shka_>
ok
<beach>
Josh_2: That's not part of a symbol.
<mfiano>
Josh_2: one way is (alexandria:format-symbol :keyword "~(~a~)" 'limit)
<White_Flame>
Josh_2: what do you mean by "bound" in this context?
<mfiano>
another is: (alexandria:make-keyword (string-downcase (symbol-name 'limit)))
<shka_>
Josh_2: so first of, symbol-name
<mfiano>
or just (intern ... :keyword)
<Josh_2>
(&key limit ..) It's parsed as an argument to the function right
<Josh_2>
I can maintain a list of corresponding symbols like (let ((args '(limit .. )))) and use those to check if my arguments are bound
<White_Flame>
if the keyword is not given in the function, the parameter is bound to the default, which is by default NIL
<White_Flame>
so it'll always be bound in the body of the functino
<White_Flame>
so you have a lot of control over detecting & defaulting things
<Josh_2>
right
<Josh_2>
this isn't my problem though, im trying to avoid having to write something like this
<aeth>
mfiano: eh... the thing is, alexandria:make-keyword is correct, but this sort of thing should probably be inline and alexandria's isn't, so it's justifiable to reinvent the wheel here imo
<Josh_2>
(when (boundp <var>) (setf mylist (append (list <mysymbolasstring> <symbol-value>)))) about 10 times
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
<White_Flame>
btw, you can just append your optional changes to the head of the default plist
<White_Flame>
eg, if defaults are (:a 1 :b 2), and you prepend your change so you end up with (:b 3 :a 1 :b 2), then :a = 1 and :b = 3. the later value is overridden by the earlier value
<Josh_2>
the default is not bound
<White_Flame>
just like alists
<Josh_2>
If there is no value I don't want it included in my plist
<White_Flame>
then I think you just want to capture the &rest list of parameters?
<Josh_2>
yes I thought about that but It's less explicit
<White_Flame>
(defun foo (&rest all &key a b c) ...)
<White_Flame>
that still specifies & limits the parameters to just those keys
<Josh_2>
so how do I use all in this case?
<White_Flame>
it's just a variable that contains a list of the parameters from that point on
<White_Flame>
if the body is (values a b all), then (foo :a 1) => 1 nil (:a 1)
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<White_Flame>
note no :b in the ALL list
<White_Flame>
but still bound individual values for A and B
<White_Flame>
(1 and NIL respectively)
aindilis has joined #lisp
<Josh_2>
thats perfect
<Josh_2>
thanks White_Flame
<White_Flame>
np, I'm glad the question was understood ;)
<Josh_2>
I didn't know I could do that
Cymew has quit [Ping timeout: 240 seconds]
<White_Flame>
I've seen it around, don't think I've ever used it myself
judson_ has joined #lisp
<Josh_2>
In this case It's part of an API where you don't have to provide defaults, you just dont send the values
<jrm>
jackdaniel: Whatever you prefer. It's also not difficult for us to package the latest from master. If you could just share your plans, I'll adapt. I just wanted to make sure we were offering what you (authors) felt was best for users.
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai has joined #lisp
[d] has quit [Excess Flood]
[d] has joined #lisp
pfdietz has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
nij has joined #lisp
<nij>
After (slynk:create-server :port 1234 :dont-close t), how do I send code '(+ 1 1)' from my terminal to the repl? __ The DOC seems to be addressing how to connect the repl with a *remote* machine, which is even harder than my use-case. https://joaotavora.github.io/sly/#Connecting-to-a-remote-Lisp
<nij>
I'm hoping for something like emacs' `$ emacsclient -e '(kill-emacs)'`
<nij>
If you are familiar with slime, I'm glad to know how too. Thanks :)
ukari has quit [Remote host closed the connection]
<White_Flame>
the client to that socket is sly in emacs
ukari has joined #lisp
<pranavats>
nij: Start emacs with sly loaded in your terminal. Run the command `sly-connect` and enter the correct port number.
ebrasca has quit [Remote host closed the connection]
<nij>
But I want to interact only with the terminal..
<nij>
that's possible?
daphnis has joined #lisp
<White_Flame>
that might be a question better suited for #emacs
<White_Flame>
since you're basically asking how to run elisp code from the terminal
<nij>
It seems that I must first go through emacs in order to touch sly right?
<White_Flame>
or, you'd have to figure out the raw socket protocol and reimplement it outside of elisp
<White_Flame>
sly runs in emacs, so yes
<nij>
AH..
theothornhill has joined #lisp
<nij>
Then I should have just asked for interaction with the SBCL repl @@
<nij>
No wonder I couldn't find the answer.
<pranavats>
nij, Do you just want to run a lisp repl in a terminal locally?
<nij>
I want to have a lisp repl running in the background, and be able to send expressions to it from another terminal.
<pranavats>
Okay
bcachefs-newbie is now known as walex
<White_Flame>
could just do netcat to a plain socket listener, and EVAL :-P
<nij>
I don't know what those are @_@ ..
<White_Flame>
but if you want to run full sly, then you need emacs running
<nij>
Right. So s/sly/sbcl/
<nij>
I didn't mean sly.
<White_Flame>
netcat = shell piping to a network socket
cage_ has joined #lisp
theothornhill has quit [Ping timeout: 256 seconds]
judson_ has joined #lisp
theothornhill has joined #lisp
charles` has quit [Ping timeout: 240 seconds]
iskander has quit [Ping timeout: 246 seconds]
theothornhill has quit [Ping timeout: 246 seconds]
puchacz has quit [Quit: Ping timeout (120 seconds)]
puchacz has joined #lisp
cyraxjoe has quit [Quit: No Ping reply in 180 seconds.]
cyraxjoe has joined #lisp
iskander has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
enzuru has quit [Ping timeout: 260 seconds]
pfdietz has quit [Quit: Connection closed]
cantstanya has quit [*.net *.split]
hendursaga has quit [*.net *.split]
gxt has quit [*.net *.split]
Aurora_v_kosmose has quit [*.net *.split]
luckless has quit [*.net *.split]
madage has quit [*.net *.split]
arora has quit [Ping timeout: 246 seconds]
<[d]>
<amigojapan#0000> and my son were both born by sessarian section, I wonder if it coudl be cause both me and my dad are big people and our wifes were small
<[d]>
<amigojapan#0000> [edit]:
varjag has joined #lisp
Codaraxis has joined #lisp
varjag has quit [Ping timeout: 260 seconds]
<flip214>
nij: use the swank listener... that'll give you a frontend automatically
charles` has joined #lisp
hiroaki has quit [Ping timeout: 260 seconds]
anticrisis has joined #lisp
<nij>
flip214: does that rely on emacs?
<nij>
Or can I use an external terminal to control?
arora has joined #lisp
aartaka_d has joined #lisp
kpoeck has joined #lisp
CEnnis91 has joined #lisp
aartaka has quit [Ping timeout: 265 seconds]
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
aorst has joined #lisp
aorst is now known as andreyorst[m]
<flip214>
nij: swank is supported by emacs (with slime), vim (vlime or slimv), and a few other editors.
<flip214>
it's a whole protocol, though; if you want a telnet/readline style input, a simple socket might be better.
<flip214>
or, if you have an HTTP server (hunchentoot), why not make some easy-handler for that?
<nij>
:( I need to really learn this kinda networking thing well.
<nij>
I don't know what sockets, servers, telnet.. etc really are @@ Maybe that's why I cannot understand what I got.
<nij>
(Well.. I get a bit of taste of them. But I don't know what they *are*.)
sauvin has quit [Read error: Connection reset by peer]
daphnis has quit [Ping timeout: 256 seconds]
<White_Flame>
yeah, emacs launches sbcl, tells sbcl to listen on a network socket, then connects to that to control it. 2 separate process connected via networking
<White_Flame>
the comms on that socket is the slime/swank protocol
<flip214>
or sbcl just runs somewhere and opens a socket in case someone wants to talk to it
andreyorst has quit [Ping timeout: 260 seconds]
<White_Flame>
right
<nij>
flip214: I think I want this.
<White_Flame>
I'm sure there are examples out there of having a network-based plain text repl
<nij>
How to let sbcl opens a socket for some one to talk to it?
<flip214>
via swank is the preferred solution ;) but that's not a plain-text protocol, but RPC.
<Xach>
nij: man 7 tcp and man 7 udp have some reference material about the underlying functinos. SBCL exposes functions by the same names to enable networking.
<White_Flame>
but there are compatibility libs that are more often used that wrap implementation specifics
<Xach>
functions, rather.
<White_Flame>
nij: what is your overall use case, just testing stuff?
aartaka has quit [Read error: Connection reset by peer]
theothor` has quit [Remote host closed the connection]
theothornhill has quit [Remote host closed the connection]
matryoshka has joined #lisp
arora has quit [Ping timeout: 264 seconds]
<nij>
White_Flame: To launch cl scripts by pressing keybindings through WM.
<nij>
(without making them into executables)
<nij>
White_Flame: Oh! The thing I was looking for is called Networking!
<nij>
I thought that only applies to me connecting to the internet.
<nij>
(or to some other computers)
<nij>
Xach thank you! Lemme try to read them :)
hiroaki has joined #lisp
<White_Flame>
uh, just have your keybindings launch sbcl to run .lisp files?
<White_Flame>
it has a few cmdline options for running literal forms, or .lisp files
<nij>
White_Flame: Hopefully sbcl can be running all the time, waiting for my command @@
<White_Flame>
why?
<White_Flame>
I guess if you need to retain state
<nij>
yeah. retain state, start time.. etc
<nij>
For some script I even want them to be checking every 5 seconds.
<White_Flame>
a valid but lamer approach that avoids learning networking (it's complex if you've never done it, in any language) would be for the daemon lisp to just scan for some file, and read/eval it if one appears
<White_Flame>
with your keybindings writing a small trigger file containing what you want to run
<Xach>
i've used that kind of approach before and it is nice and simple.
logand has joined #lisp
<nij>
How does the keybinding affect the daemon?
<nij>
OH
<nij>
I see.
<nij>
I will do that if I fail learning networking.
aartaka has joined #lisp
puchacz has quit [Quit: Connection closed]
<Xach>
You won't fail! It just might take a while. And there are other options that might get you somewhere interesting quickly while still leaving time to learn more things.
Anonymous_ has quit [Ping timeout: 264 seconds]
<nij>
Xach: I really appreatiate your encouragement :-)
Krystof has quit [Ping timeout: 272 seconds]
<White_Flame>
the biggest thing that messes people up when doing TCP (the stream form of networking, most common), is that when you receive bytes from the stream, it may not be an entire message at once, but some overlapping part
Anonymous_ has joined #lisp
<White_Flame>
other than that, it's just getting the listeners & per-connection stuff organized
<Xach>
i think "overlapping" is a little unfortunate wording there? maybe "partial"?
<Xach>
you will never get the same data more than once
<White_Flame>
I think that usocket is one of the more popular libraries for running the networking for you, and has examples
<White_Flame>
I mean the packet could overlap between 2 messages that the other side sent from its code perspective
<Xach>
if the remote end sends "ABC", you may get "A" or "AB" or "ABC", but not "AABC" or "AB" "BC"
<White_Flame>
the packet overlaps the individual message data chunks you sent per output call on the other side
<White_Flame>
nij: "trivial-sockets is a trivial networking library for undemanding Internet applications (for example "scripting" and interactive use)."
rogersm has quit [Quit: Leaving...]
<nij>
I understand that there are four things to be considered: server's addr+port and client's addr+port.
<nij>
But what I'm aiming for here has only one machine..
<nij>
Ah! On one machine there can be many servers!
<nij>
So I should check if I can get a list of running servers on my arch laptop.
pfdietz has joined #lisp
Krystof has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
<White_Flame>
machine is 127.0.0.1
luckless has joined #lisp
galex-713 has joined #lisp
<ralt>
_death: do you remember if unix FD passing was implemented in dbus?
puchacz has joined #lisp
<nij>
White_Flame: I'm trying trivial-sockets. Currently running the loop: https://bpa.st/VLBUE provided in the example usage.
<nij>
Does this mean that my sbcl repl has opened a socket that awaits any message from the outside?
<nij>
If so, how to send message from the outside to the repl?
<White_Flame>
from the shell, `netcat localhost 8913` and start typing stuff
<White_Flame>
that opens up a socket and connects it to stdin/stdout from there
Aurora_v_kosmose has joined #lisp
madage has joined #lisp
<nij>
Moly! It works.
<White_Flame>
note that that example doesn't do anything with the read-line return value, so your shell typing is ignored, besides the fact that there's a line
<nij>
Right.
<nij>
netcat also closes itself after one interaction
<nij>
but that's good enough
<nij>
I only have to let sbcl know what I typed from the netcat side!
<White_Flame>
there's no loop in the example. once it exits the with-open-stream scope, that closes it from teh lisp side
hendursaga has joined #lisp
<nij>
Indeed <3 I changed (format c ..) to (loop (format c ..)) and now it loops <3
<White_Flame>
(format t "Result: ~s~%" (eval (read-line c)))
<White_Flame>
(eval (read (read-line c)))
<White_Flame>
need an ignore-errors in there somewhere, too
<White_Flame>
eh, (eval (read c)). ;; haven't done this in a while ;)
cantstanya has joined #lisp
<jackdaniel>
(loop (print (eval (read c))))
<nij>
<3 <3 <3 <3
<nij>
finally.
<White_Flame>
the fact that the example had a string in its current form muddled it slightly :)
<nij>
White_Flame: Yeah. I find the logic behind it finally.
<nij>
Seeing it works is always the best way to learn.
dvdmuckle has quit [Quit: Bouncer Surgery]
wsinatra_ has quit [Ping timeout: 260 seconds]
dvdmuckle has joined #lisp
kpoeck has quit [Quit: Connection closed]
shka_ has quit [Ping timeout: 265 seconds]
<nij>
Thanks White_Flame jackdaniel <3
<White_Flame>
np, enjoy!
<jackdaniel>
I want to note, that I was only addressing what White_Flame wrote (I did not try to answer any question)
<jackdaniel>
but I'm glad you've found that remark helpful
<White_Flame>
but nice output formatting, and capturing errors, and lots of other things quickly get away from a small literal (l(p(e(r str)))) body
<nij>
jackdaniel: yeah that remark definitely completes it xD
<nij>
White_Flame: yeah i'm aware of that!
<nij>
I can move forward finally at least, after seeing it works.
mindCrime has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
caret has quit [Quit: Leaving]
kpoeck has joined #lisp
gargaml has joined #lisp
gargaml has quit [Client Quit]
<[d]>
<arryana#0000> ahhaahh, they;re tribbles
<[d]>
<arryana#0000> [edit]:
<phoe>
okay - where is [d] bridged to and how do I contact their moderation team?
<Bike>
ircname: discord. well, alright
zacts has quit [Quit: leaving]
zacts has joined #lisp
<phoe>
yes, this tells me nothing
<phoe>
I've seen it burp out unrelated lines three times now, each time with that spammy edit line right afterwards
<phoe>
I think this warrants muting it because of misconfiguration for the time being.
rumbler31_ has quit [Ping timeout: 260 seconds]
rumbler31_ has joined #lisp
drl has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
enzuru has joined #lisp
puchacz has quit [Quit: Connection closed]
Aurora_v_kosmose has quit [Remote host closed the connection]
puchacz has joined #lisp
Aurora_v_kosmose has joined #lisp
narimiran has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
luckless has quit [Quit: luckless]
luckless has joined #lisp
luckless has quit [Client Quit]
luckless has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
hiroaki has quit [Ping timeout: 240 seconds]
rpg has joined #lisp
hiroaki has joined #lisp
cage__ has joined #lisp
cage_ has quit [Ping timeout: 265 seconds]
mgsk has quit [Read error: Connection reset by peer]
kilimanjaro has quit [Read error: Connection reset by peer]
mjl_ has joined #lisp
kilimanjaro has joined #lisp
alanz has quit [Ping timeout: 265 seconds]
splittist has quit [Ping timeout: 264 seconds]
splittist_ has joined #lisp
mjl has quit [Ping timeout: 264 seconds]
mjl_ is now known as mjl
jerme_ has quit [Ping timeout: 265 seconds]
mgsk has joined #lisp
yonkunas has quit [Ping timeout: 264 seconds]
yonkunas_ has joined #lisp
yonkunas_ is now known as yonkunas
alanz has joined #lisp
jerme_ has joined #lisp
theothornhill has joined #lisp
zacts has quit [Quit: leaving]
vutral_ has joined #lisp
vutral_ has joined #lisp
vutral_ has quit [Changing host]
gxt has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
[d] has quit [Excess Flood]
[d] has joined #lisp
cage__ has quit [Quit: Leaving]
pve has quit [Quit: leaving]
rumbler31_ has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 244 seconds]
notzmv has quit [Ping timeout: 260 seconds]
zacts has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
theothornhill has quit [Ping timeout: 260 seconds]
dbotton has quit [Quit: This computer has gone to sleep]
<brandflake11>
Hey all, can you move your ~/quicklisp and ~/.sbclrc to another computer and it work seamlessly?
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
daphnis has joined #lisp
Nilby has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<phoe>
I guess so, yes
<Xach>
brandflake11: quicklisp sure, .sbclrc who knows? depends what's in it.
<Xach>
if .sbclrc just loads quicklisp/setup.lisp, then sure.
<Xach>
also, if quicklisp/ has symlinks somewhere, they won't come along without work.
judson_ has joined #lisp
judson_ has quit [Ping timeout: 240 seconds]
<waleee-cl>
do the instructions from http://joaotavora.github.io/sly/#Loading-Slynk-faster (specifically for the "slynk core") work? I've tried having the core in both implicit paths and specifiying an absolute path, but I get polling errors when starting sly either way
aartaka_d has quit [Ping timeout: 240 seconds]
mbomba has joined #lisp
<waleee-cl>
ah. Not absolute enough in the path apparently
quazimodo has joined #lisp
mindCrime has joined #lisp
dbotton has joined #lisp
theothornhill has joined #lisp
Posterdati has quit [Ping timeout: 265 seconds]
theothornhill has quit [Ping timeout: 240 seconds]
Codaraxis_ has joined #lisp
Codaraxis has quit [Read error: Connection reset by peer]
puchacz has quit [Quit: Connection closed]
mbomba has quit [Quit: WeeChat 3.0]
<charles`>
Is there a way to get a list of super types for a given type?
<Bike>
there are infinitely many supertypes
<Bike>
if you have a _class_, though, you can get the class precedence list of superclasses
sjl has quit [Ping timeout: 260 seconds]
<brandflake11>
phoe: Xach: Thanks for the help with my question! I appreciate it!
ljavorsk has joined #lisp
ljavorsk has quit [Remote host closed the connection]
kpoeck has quit [Quit: Connection closed]
<charles`>
how is there infinitely many? Do types (not classes) not actually use inheritance?
dbotton has quit [Quit: Leaving]
<Bike>
types just represent sets. (member 4 5 6) is the type of numbers that are 4 or 5 or 6. you can always augment a type with OR and MEMBER and stuff. so no, they don't involve inheritance per se.
ljavorsk has joined #lisp
hjudt has quit [Ping timeout: 272 seconds]
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 260 seconds]
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
enzuru has quit [Ping timeout: 260 seconds]
daphnis has quit [Ping timeout: 260 seconds]
<charles`>
I see, then how would I get a list of super-classes (of a class) in a portable way?
<phoe>
mopu:superclasses
<phoe>
from moptilities
ljavorsk has quit [Ping timeout: 265 seconds]
<alandipert>
typep seems like the ultimate method specializer, i wonder why there's only eql. perf?
<alandipert>
hm, i suppose also the infinitude of the type relationships might make method selection too ambiguous
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
<charles`>
nice, thanks phoe
mindCrime has quit [Remote host closed the connection]
nicktick has quit [Ping timeout: 240 seconds]
theothornhill has joined #lisp
mindCrime has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
<Bike>
alandipert: that's the problem, yes. classes are linearly ordered into class precedence lists, so it's easy to see which methods are more specialized than others.
<Bike>
for example if you had a method specialized on (member :a :b) and another on (member :b :c) and you called it with :b it would not be obvious what is called.
<alandipert>
hm, wouldn't that particular case be true of two eql :b methods though?
theothornhill has quit [Ping timeout: 264 seconds]
enzuru has joined #lisp
<Bike>
i don't understand what you mean.
rgherdt has quit [Ping timeout: 244 seconds]
<Bike>
you can't have two distinct methods that have the same qualifiers and the same specializers.
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
pfdietz has quit [Quit: Ping timeout (120 seconds)]
<alandipert>
oh sorry, and yes, that's the part i was missing. thanks
rgherdt has joined #lisp
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
theothornhill has joined #lisp
andreyorst[m] has quit [Remote host closed the connection]
theothornhill has quit [Ping timeout: 272 seconds]
anticrisis has quit [Read error: Connection reset by peer]