Oddity has quit [Remote host closed the connection]
galex-713 has quit [Ping timeout: 246 seconds]
Oddity has joined #lisp
wsinatra_ has quit [Quit: WeeChat 2.9]
galex-713 has joined #lisp
mangoicedtea has quit [Remote host closed the connection]
space_otter has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 246 seconds]
EvW has quit [Ping timeout: 244 seconds]
Alfr has joined #lisp
Alfr_ has quit [Read error: Connection reset by peer]
Inline has quit [Ping timeout: 246 seconds]
_whitelogger has joined #lisp
Oladon has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
iAmDecim has joined #lisp
karlosz has joined #lisp
dddddd_ has joined #lisp
dddddd has quit [Ping timeout: 260 seconds]
mathrick has quit [Remote host closed the connection]
mathrick has joined #lisp
montxero has quit [Remote host closed the connection]
d4ryus has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
d4ryus has joined #lisp
<Oladon>
In case anyone was/is curious, I finally figured out the issue I was having with Server-Sent Events and Hunchentoot -- namely, Hunchentoot uses HTTP/1.1 chunking by default, and SSE has undefined behavior when the response is chunked. Disabling chunking seems to fix the issues I was experiencing.
jesse1010 has quit [Ping timeout: 246 seconds]
d4ryus has quit [Ping timeout: 246 seconds]
Bike has quit [Quit: Lost terminal]
Alfr_ has joined #lisp
space_otter has quit [Ping timeout: 240 seconds]
aaaaaa has quit [Ping timeout: 258 seconds]
Alfr has quit [Ping timeout: 260 seconds]
<beach>
Good morning everyone!
<Oladon>
Morning, beach!
aaaaaa has joined #lisp
aaaaaa has quit [Client Quit]
progfun has joined #lisp
jprajzne has quit [Quit: jprajzne]
d4ryus has joined #lisp
space_otter has joined #lisp
jprajzne has joined #lisp
iAmDecim has quit [Ping timeout: 240 seconds]
saitousama has quit [Quit: WeeChat 2.3]
jonatack has quit [Ping timeout: 260 seconds]
iAmDecim has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
Alloc has joined #lisp
jonatack has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 244 seconds]
Alloc has quit [Ping timeout: 260 seconds]
Alloc has joined #lisp
iAmDecim has quit [Ping timeout: 256 seconds]
mindCrime_ has quit [Ping timeout: 244 seconds]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
torbo has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
torbo has quit [Remote host closed the connection]
terpri_ has quit [Remote host closed the connection]
terpri__ has joined #lisp
Alloc has quit [Ping timeout: 264 seconds]
gravicappa has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
galex-713 has quit [Ping timeout: 246 seconds]
Oladon has quit [Quit: Leaving.]
Alloc has joined #lisp
terpri__ is now known as terpri
progfun has quit [Ping timeout: 240 seconds]
_jrjsmrtn has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
progfun has joined #lisp
jprajzne has quit [Quit: jprajzne]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
aartaka has joined #lisp
jprajzne has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has quit [Read error: Connection reset by peer]
bocaneri has joined #lisp
jprajzne has quit [Quit: jprajzne]
Oladon has joined #lisp
narimiran has joined #lisp
progfun has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
davepdotorg has joined #lisp
lemoinem has quit [Ping timeout: 256 seconds]
ukari has joined #lisp
davepdotorg has quit [Ping timeout: 272 seconds]
Alloc has quit [Ping timeout: 258 seconds]
Kundry_Wag has quit [Remote host closed the connection]
ggole has joined #lisp
bsd4me has quit [Quit: Leaving]
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
__jrjsmrtn__ has joined #lisp
progfun has joined #lisp
_whitelogger has joined #lisp
ljavorsk has joined #lisp
yonkunas has quit [Quit: Connection closed for inactivity]
gravicappa has quit [Read error: No route to host]
Bourne has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 258 seconds]
Cymew has joined #lisp
Alloc has joined #lisp
Oladon has quit [Quit: Leaving.]
mathrick has quit [Ping timeout: 265 seconds]
aartaka has quit [Read error: Connection reset by peer]
Harag has joined #lisp
Harag has left #lisp [#lisp]
shka_ has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
Alloc has quit [Ping timeout: 244 seconds]
Alloc has joined #lisp
montxero has joined #lisp
pve has joined #lisp
bilegeek has quit [Quit: Leaving]
Alloc has quit [Ping timeout: 256 seconds]
scymtym has joined #lisp
iAmDecim has joined #lisp
treflip has joined #lisp
aartaka has joined #lisp
mathrick has joined #lisp
iAmDecim has quit [Ping timeout: 240 seconds]
<montxero>
I'm having trouble installing gsll from quicklisp. Can anyone else confirm similar issues having.
<montxero>
lol... having similar issues?
Bourne has joined #lisp
progfun has quit [Ping timeout: 258 seconds]
<phoe>
montxero: what are the issues in particular? could you paste some traces on https://plaster.tymoon.eu/?
<treflip>
montexero: I had some troubles installing it a year ago. IIRC, manual installation of non lisp dependencies solved all my problems.
* phoe
tries a naïve (ql:quickload :gsll)
* phoe
performs `apt install libgsl-dev`
<phoe>
it loaded
kaftejiman has joined #lisp
hendursa1 has joined #lisp
hendursa1 has quit [Remote host closed the connection]
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
jw4 has quit [Read error: Connection reset by peer]
<phoe>
"equalp descends hash-tables by first comparing the count of entries and the :test function; if those are the same, it compares the keys of the tables using the :test function and then the values of the matching keys using equalp recursively."
gravicappa has joined #lisp
<flip214>
well, sounds good enough for now
<phoe>
if you don't want equalp for the final "leaves" of your tree, then you'll need to write a custom test function.
<flip214>
I can ignore case, that's just for a test that ensures that only the expected keys are in the result
<flip214>
thank you!
Necktwi has quit [Ping timeout: 265 seconds]
jonatack has joined #lisp
aartaka has quit [Ping timeout: 258 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
rgherdt has joined #lisp
wxie has joined #lisp
gravicappa has quit [Ping timeout: 240 seconds]
Necktwi has joined #lisp
gravicappa has joined #lisp
_whitelogger has joined #lisp
cods has quit [Ping timeout: 256 seconds]
_whitelogger has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
notzmv has quit [Read error: Connection reset by peer]
Alloc has quit [Ping timeout: 246 seconds]
notzmv has joined #lisp
notzmv is now known as Guest32337
wxie has quit [Ping timeout: 246 seconds]
iamFIREcracker has joined #lisp
iamFIREc1 has quit [Ping timeout: 264 seconds]
jonatack has quit [Ping timeout: 258 seconds]
markoong has joined #lisp
shka_ has quit [Remote host closed the connection]
madage has quit [Ping timeout: 240 seconds]
kreyren_ has joined #lisp
<kreyren_>
So i just figured out the hard way that posix sh is not portable enough based on the way that it's written in GNU Emacs.. is Common Lisp more portable where the concern are a system that were created in 1978 that are non-ASCII and stuff ?
<phoe>
you mean that you are trying to run CL code on systems that are from 1978?
<phoe>
or would like to?
<kreyren_>
phoe, i think? Basically all systems that are capable of running GNU Emacs now and/or theoretically
<kreyren_>
where ideally i want to make my scripts to work everywhere and shell is apparently not portable enough
<phoe>
that's way too broad of a question
<phoe>
which operating systems are you thinking of?
madage has joined #lisp
<kreyren_>
phoe, minix, unix, linux, something that someone made, etc..
<White_Flame>
cl abstracts away the notion of a character encoding, as well as has more filesystem/pathname options than the standard directories/file/extension
<kreyren_>
yes too broad of a question which is what GNU Emacs is compatible with..
<phoe>
you will need to port a Common Lisp implementation for each exotic OS that you encounter
davepdotorg has quit [Remote host closed the connection]
<phoe>
which might mean porting ECL or CLISP there
<kreyren_>
like apparently emacs-lisp works on these systems is that ported this way?
<phoe>
(unless they've already been ported there, which is possible)
<phoe>
emacs is a VM written in C that executes elisp code, no real big difference here other than the fact that emacs also bundles a ton of editor stuff along
<kreyren_>
x.x
<kreyren_>
So let me ask differently.. If someone makes their own system can i make CL to run on it even though i might not know how it is constructed today?
<kreyren_>
basically expecting CL to not be the limiting factor in portability
<phoe>
how what is constructed? the system?
<kreyren_>
phoe, yes the system i.e some CS student making their own quantum computer
<White_Flame>
this breaks down into a turing tarpit
<phoe>
you can port a CL implementation there if the target has a C compiler, see ECL or CLISP
<kreyren_>
can't find ECL not strong enough of an index on ddg
<phoe>
if it doesn't have a C compiler, you can either implement a C compiler or write a CL implementation from scratch, e.g. see Mezzano that runs CL on bare metal
<phoe>
ECL = Embeddable Common Lisp
<kreyren_>
ah
<phoe>
but basically, what White_Flame said
<phoe>
if it is Turing-complete then you can implement CL on it
<kreyren_>
and if it is not?
<kreyren_>
then it's probably not a computer right
<White_Flame>
then is it a computer as we know it?
<phoe>
then you can't have a Turing complete language there
<phoe>
and you have much bigger problems to think of
<White_Flame>
and you won't have emacs on it either
theBlackDragon has quit [Ping timeout: 240 seconds]
<kreyren_>
good enough then!
<kreyren_>
unless there is something better then CL ?
<kreyren_>
for this scenario
<phoe>
yes
<kreyren_>
o.o
<phoe>
get a normal computer
<White_Flame>
you define the scenario, so...
<phoe>
and run CL on it
<kreyren_>
phoe, not an option to consider normal computer
theBlackDragon has joined #lisp
<phoe>
then IMO your question is too theoretical for a sane answer
<phoe>
we're now talking about some abnormal computers that are not well-defined
<phoe>
no definition, no answers
<kreyren_>
but considering portability beyond turing-complete system seems insane and even if someone made such thing then it would probably be a scientific break-through and langs adapted for it right
<phoe>
that's so futuristic that not a #lisp topic anymore :D
<White_Flame>
and if the main thrust is just recompiling something like CLISP or ECL onto it, then it's more a question about what its C support is like, rather than anything about CL
<White_Flame>
(other implementations concern themselves much more with native machine code generation rather than running CL in or on C)
<kreyren_>
true, considering sufficient then ^-^ .. So i would have to make everything in CLISP or ECL for this kind of compatibility ?
<phoe>
not really, just write portable CL
<phoe>
ECL and CLISP both implement Common Lisp, meaning that all portable Common Lisp code will run on ECL and CLISP
<kreyren_>
how do i write portable CL
<kreyren_>
ah i see O.o
<phoe>
and on SBCL, and on CL, and on Clasp, and on ABCL, and on LispWorks or Allegro Common Lisp
<TMA>
provided that the limits of the system are big enough, not being turing-complete is not an obstacle. real systems are not turing-complete anyway (they are of finite size)
<phoe>
minion: tell kreyren_ about pcl
<minion>
kreyren_: please look at pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<White_Flame>
portable CL = don't use implementation-specific CL extensions
<White_Flame>
(which also encompasses threads, networking, etc)
<phoe>
(or use portability libraries with wide enough coverage that implement those extensions)
<White_Flame>
well, for a new unsupported target, yo'ure going to have to implement those extensions anew
* kreyren_
has dyslexia and is unable to learn from books~
<kreyren_>
so implementation-specific CL extensions are basically functions that are running a code designed to run specifically on the target system?
<phoe>
nope
<kreyren_>
i.e something that calls directly linux specific function and breaks on non-linux?
<kreyren_>
eh? o.o
<phoe>
they're Lisp functions and macros and variables just like everything else, they just provide functionality that is not described in the standard
<kreyren_>
is there any linting tool that would warn me about these?
<phoe>
such as POSIX interfaces, multiprocessing, networking, custom stream classes, interfacing with the inner workings of the object system, garbage collection, atomic operations, etc..
<kreyren_>
or what is the sane approach to check these
<White_Flame>
like, networking isn't in the CL spec. so implementations provide their own networking API in CL. portability libraries abstract those into a single API
<phoe>
the basic approach is: if you use networking, use usocket or iolib; if you use threads, use bordeaux-threads; if you use the metaobject protocol, use closer-mop; if you want to interface with the GC, use trivial-garbage; etc..
Necktwi has quit [Ping timeout: 256 seconds]
<phoe>
and if you don't really know if there's a portability library for this particular thing you're working on, feel free to ask around
<phoe>
or just search for "common lisp X portability library"
<kreyren_>
what if i am writing something that is supposed to work on "singlethreating" and use multithreading on systems that are supporting multithreading ?
<phoe>
I'd do compile-time flags, implemented by reader conditionals
<kreyren_>
where i don't expect the CL to be limiting the runtime efficiency
<kreyren_>
o.o
<White_Flame>
there's a variable called *FEATURES* that's intended to hold keywords indicating capabilities like that, for such compile-time testing
<phoe>
these cause code to get compiled differently based on whether the target--- yes
<White_Flame>
and there's even reader syntax for it, in #+ and #-
<phoe>
that's #clschool material though
space_otter has quit [Remote host closed the connection]
<White_Flame>
ah, we're in #lisp proper
<phoe>
and from the practical point of view, you're *not* going to work on environments that do not support multithreading, unless you explicitly grab such an environment yourself
<kreyren_>
phoe, i want my software to work on as many systems as possible so these environments are a concern
gravicappa has quit [Ping timeout: 256 seconds]
ukari has quit [Remote host closed the connection]
<White_Flame>
and to be honest, learning CL by porting it to an antiquated platform from decades before the CL spec is not going to be that easy of a learning curve
<phoe>
then write Common Lisp code an use CL running on ECL
<phoe>
then write Common Lisp code and run your code on ECL*
ukari has joined #lisp
<kreyren_>
i already know basics of CL, but i don't know which functions and how to use them to make them this portable
<White_Flame>
there's really nothing platform-specific in CL
<phoe>
listen to some Baggers stuff that I linked then, that's the best non-book learning material that I am aware of
<White_Flame>
unless you dig into stuff that the implementation says it provides itself
<phoe>
and ask tons of questions on #clschool once you have these.
<kreyren_>
ah ok O.o thanks for info appreciated ^-^
<phoe>
also, regardless of what you are thinking at the moment, your code is going to be executed on Linux, Windows, and macOS, and maybe some BSD flavors if you are lucky
gravicappa has joined #lisp
<phoe>
and maybe on Mezzano if you decide to stay a while and write Lisp.
<no-defun-allowed>
It would be very, very impressive if you were the first to run sequential code on a quantum computer.
<kreyren_>
I though common lisp can be run on quantum computer?
<kreyren_>
i.e those that are available for free from IBM
<phoe>
hell no
<kreyren_>
well not for free.. to run and develop code for them for free
<White_Flame>
I think CL runs the computer that manages the quantum chip
<phoe>
no real modern programming language can be run *on* a quantum computer
<Odin->
Quantum computers are just plain bizarre.
<phoe>
what White_Flame said, it can be used to implement software that emulates or manages quantum computers, as Rigetti has proven
<no-defun-allowed>
I probably shouldn't comment on the capabilities of quantum computers, but in my mind they are fancier analog computers, which can't do sequential programs and I/O as such.
<kreyren_>
i was told that C is going to be implemented to run on QC ?
<Odin->
And realistically will never be other than co-processors.
<phoe>
that's already #lispcafe material
<kreyren_>
o.o
<phoe>
#lispcafe is the part of #lisp where non-Lisp chat ends up
<White_Flame>
this channel is fairly strictly held on-topic
<phoe>
and I guess that quantum computing, in general, is one of those
* kreyren_
moved that QC question in ##lispcafe then
<kreyren_>
*#lispcafe
shka_ has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
dmiles has quit [Ping timeout: 258 seconds]
dmiles has joined #lisp
madage has quit [Ping timeout: 240 seconds]
progfun has joined #lisp
markoong has quit [Quit: Konversation terminated!]
bitmapper has quit [Ping timeout: 265 seconds]
aartaka has joined #lisp
madage has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
Inline has joined #lisp
madage has quit [Ping timeout: 240 seconds]
madage has joined #lisp
progfun has quit [Ping timeout: 264 seconds]
gravicappa has quit [Ping timeout: 260 seconds]
gravicappa has joined #lisp
Necktwi has joined #lisp
aartaka has joined #lisp
Alloc has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
jesse1010 has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
Alloc has quit [Ping timeout: 244 seconds]
Alloc has joined #lisp
toorevitimirp has joined #lisp
wxie has joined #lisp
Alloc has quit [Ping timeout: 260 seconds]
Alloc has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
aartaka has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
kaftejiman has quit [Remote host closed the connection]
_whitelogger has joined #lisp
Josh_2 has joined #lisp
<Josh_2>
afternoon
sm2n has quit [Quit: Leaving]
yitzi has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
Alloc has joined #lisp
galex-713 has joined #lisp
Lycurgus has joined #lisp
lottaquestions_ has quit [Quit: Konversation terminated!]
wsinatra has joined #lisp
sonologico has quit [Remote host closed the connection]
Guest323` has joined #lisp
cods has joined #lisp
cods has quit [Changing host]
cods has joined #lisp
Guest32337 has quit [Ping timeout: 265 seconds]
micro has quit [Ping timeout: 258 seconds]
Guest323` has quit [Ping timeout: 265 seconds]
micro has joined #lisp
jonatack has joined #lisp
Bourne has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
Codaraxis__ has joined #lisp
<Inline>
sup
Guest323` has joined #lisp
Guest323` is now known as notzmv
frgo_ has quit [Remote host closed the connection]
notzmv has quit [Changing host]
notzmv has joined #lisp
Codaraxis_ has quit [Ping timeout: 260 seconds]
random-nick has joined #lisp
Bike has joined #lisp
Blukunfando has quit [Ping timeout: 258 seconds]
sm2n has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
_jrjsmrtn has joined #lisp
notzmv` has joined #lisp
Alloc has quit [Ping timeout: 244 seconds]
Alloc has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 246 seconds]
notzmv has quit [Ping timeout: 240 seconds]
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
cosimone has joined #lisp
<drmeister>
Hi - in ESRAP - does anyone know how to recognize any character? Whitespace, non-whitespace - everything.
wsinatra has quit [Ping timeout: 256 seconds]
<drmeister>
I looked in parser.common-rules under comments but it's eluding me.
<phoe>
"The wild terminal symbol CHARACTER always succeeds, consuming and producing a single character."
<phoe>
chapter 1, Parsing Expressions
<phoe>
is that the thing?
<drmeister>
Oh wait 'character'?
<phoe>
the symbol CHARACTER, yes
<drmeister>
Sheesh - it's right in front of me. I was looking for 'wild' 'any' - gah - thanks.
<drmeister>
Ugh stupid - thanks.
<drmeister>
That was it.
<phoe>
perfect
wsinatra has joined #lisp
<phoe>
I remember reading about this a long while ago
ebrasca has joined #lisp
Lycurgus has quit [Quit: Exeunt]
Kundry_Wag has quit []
wxie has quit [Ping timeout: 256 seconds]
Blukunfando has joined #lisp
jonatack has quit [Quit: jonatack]
galex-713 has quit [Ping timeout: 272 seconds]
davepdotorg has joined #lisp
orivej has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
<Inline>
i unpacked mcclim-0.9.7-imbolc outside of the quicklisp tree, and when there it works (albeit, the new changes concernings fonts etc are not reflected there)
<Inline>
but however i deleted all stuff in quicklisp/dists/quicklisp/software/mcclim-20200715-git/ and replaced it with contents of the imbolc version, and when i start my repl and run climacs i get the error about "there's no applicable method for the standard-generic-function drei:drei-instance-of when called with arguments climacs-gui:climacs
Inline has left #lisp ["Leaving"]
Inline has joined #lisp
Inline has left #lisp ["Leaving"]
Inline has joined #lisp
aeth has quit [Ping timeout: 265 seconds]
<Inline>
so the same source outside of quicklisp tree works and inside of quicklisp tree errors
<Inline>
what gives ?
aeth has joined #lisp
notzmv` is now known as notzmv
notzmv has quit [Changing host]
notzmv has joined #lisp
<Inline>
i don't get that
EvW1 has quit [Ping timeout: 244 seconds]
cmack has joined #lisp
aeth has quit [Ping timeout: 256 seconds]
galex-713 has joined #lisp
jonatack has joined #lisp
madage has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
treflip has quit [Quit: WeeChat 2.6]
mindCrime_ has joined #lisp
edgar-rft has quit [Quit: Leaving]
Alloc has quit [Ping timeout: 240 seconds]
kerosin has joined #lisp
davepdotorg has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
<Xach>
Inline: I'm not sure, but I would strongly recommend against putting things anywhere in dists/quicklisp/.
davepdotorg has quit [Ping timeout: 260 seconds]
<Xach>
Inline: those directories are specially indexed
<Xach>
Inline: if it works outside of the quicklisp tree, what is the motivation to put it inside?
<Xach>
If it's to make it loadable, it's better to put it somewhere like quicklisp/local-projects/, where it will override anything quicklisp provides
<Inline>
now i reinstalled the quicklisp version via quicklisp and moved it afterwards outside the quicklisp tree to see if that makes any changes
<Inline>
now pressing any key does not error, and also loading files into the editor from clim-listener works
<Inline>
but when i try to copy lines from the file via M-w key, the error comes back slightly differently
<Inline>
so the only version of climacs working with all copy/cut lines via M-w and C-w keys is the imbolc version of mcclim here over
clothespin has quit [Ping timeout: 256 seconds]
<Inline>
and that only when it is outside the quicklisp tree
sjl_ has joined #lisp
sjl_ has quit [Client Quit]
<Xach>
the experiment with putting it "in the quicklisp tree" isn't a good one, and you shouldn't draw conclusions from it
<Xach>
that's not how you would ever attempt to load something
bsd4me has joined #lisp
<jackdaniel>
Inline: climacs runs here without problems with upstream version
<jackdaniel>
so it must be something with your setup
<jackdaniel>
s/must be/probably is/
AmatureProgramme has joined #lisp
treflip has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
gko_ has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
aeth has joined #lisp
rogersm has joined #lisp
phantomics has joined #lisp
Gerula has quit [Read error: Connection reset by peer]
<Inline>
jackdaniel: i don't do any fancy stuff, standard installation of a quicklisp repo with mcclim and climacs in it, and climacs does not work
<Inline>
jackdaniel: so i'm not sure how that should be a setup issue
rumbler31 has joined #lisp
vsync has quit [Ping timeout: 264 seconds]
madage has joined #lisp
<Inline>
jackdaniel: if you don't mind me, how exactly do you load your systems and run clim-listener and climacs together ?
aartaka has joined #lisp
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
bsd4me has quit [Quit: Leaving]
<jackdaniel>
I have master branches of climacs and mcclim in my local-projects directory and do (ql:quickload '(clim-listener climacs)) and then (clim-listener:run-listener :new-process t) and (climacs:climacs) ; or something like this
<beach>
What should happen in this case: (let ((x 2)) (declare (special x)) (makunbound 'x) (boundp 'x)) ?
<beach>
The question is, does MAKUNBOUND influence dynamic bindings of the variable? And if so, how should that be implemented?
<jasom>
I always read the spec as meaning makunbound only affects dynamic bindings, not lexical bindings
vsync has joined #lisp
<jackdaniel>
fmakunbound affects only a global environment (not the lexical one)
<jasom>
beach: Basic Combined Programming Language which was a simple language for bootstrapping other languages. A stripped-down version called "B" was the basis for an obscure language used in a telephony company called "C"
<jackdaniel>
and makunbound talks about a value cell of symbol
<jackdaniel>
so should the dynamic binding be affected at all?
<jasom>
jackdaniel: symbol-value accesses the dynamic binding; the dynamic binding affects the value cell for the dynamic extent of the binding
<jasom>
oh but boundp specifically mentions the global environment, not the dynamic environment. Are "Notes" normative?
yitzi has quit [Quit: yitzi]
<jasom>
a strict reading of boundp would mean (progn (defvar *foo*) (let (*foo) (boundp *foo*))) ; => nil
<jasom>
well typo in the let, but you get the idea
<beach>
jasom: Yes, I was joking. I kind of know about BCPL.
<beach>
jasom: Notes are not normative, and the example contradicts the note.
<beach>
jasom: Since there is no "value cell", it is unclear whether that terminology refers to the dynamic binding.
<beach>
jackdaniel: Yes, that's a good question.
<jasom>
well examples are also not normative
<aap>
i think what it says is that the global environment holds the dynamic bindings
<jasom>
aap: no, the dynamic environment holds the dynamic bindings
<beach>
aap: So that means that the standard has opinions on how we implement dynamic binding!!!
<beach>
jasom: Good point.
<aap>
<- not a language lawyer
<jasom>
aap: the global environment specifically refers to things with unlimited extent
<beach>
Oh, and I think the note is bogus. It contrasts the global environment and lexical bindings.
<beach>
But it says nothing about the dynamic environment.
<jasom>
beach: I agree it should be global and/or dynamic environment
<jasom>
perhaps the note predates the spec making a distinction? It seems likely that implementations of the day would implement dynamic bindings with unwind-protect and global bindings
<beach>
Yeah. That's what I meant by the standard having opinions about implementation details.
<beach>
jasom: You mean "shallow binding".
<jasom>
beach: I stand corrected
<beach>
So it seems reasonable that MAKUNBOUND followed by BOUNDP in the same dynamic environment would return false.
<beach>
But what about my second example?
<jasom>
I meant unwind-protect and mutating the global environment
davepdotorg has joined #lisp
<beach>
jasom: Yes, that's the very definition of shallow binding.
davepdotorg has quit [Read error: Connection reset by peer]
toorevitimirp has joined #lisp
<beach>
Should MAKUNBOUND influence every binding in the dynamic environment, or just the innermost one?
<jasom>
IMO the only sane definition of makunbound is to affect the innermost dynamic binding, but proper behavior need not follow my opinions on sanity
<Bike>
it's a common idiom to rebind dynamic variables to isolate things, like doing (let ((*x* *x*)) ...) and then a lot of PUSH or whatnot in the ellipsis. if makunbound was able to remove just the most recent binding the idiom would get weird sometimes
<beach>
jasom: So you agree with SBCL. OK.
<jasom>
I also think that an implementation that performed either way would be conforming as the spec is ambiguous here
<froggey>
consider (progv '(x) '() (boundp 'x)) too, this "binds" X to be unbound
<Bike>
that's its own weird question
<jasom>
I think SBCL does it *right* I think that affecting all dynamic bindings would still be *conforming*
<beach>
froggey: Interesting.
<jasom>
or at least there is a strong argument that affecting all dynamic bindings would be conforming.
<jackdaniel>
maybe my intuition is naive, but I would find it the most natural for makunbound to affect only the variable value in the global environment, ignoring dynamic bindings
<jackdaniel>
as in (defvar *xxx* 42) (let ((*xxx* 13)) (makunbound '*xxx*) *xxx*) ;-> 13 ; *xxx* ;-> #<unbound>
<jasom>
I also think I'm above my paygrade talking about conformance when unlike 3 other people here, I don't work on one
<Bike>
eh, it's not like we're certified
<beach>
I think froggey's example supports SBCL's behavior. Because it means that a variable can be unbound in the innermost dynamic environment only.
<jackdaniel>
and that would have at least superfluous similarity to fmakunbound
<Bike>
and i think of it was working like jackdaniel
<jasom>
Bike: it's not about certified, it's about being forced to think about these things to get other stuff accomplished. It's a lot more abstract when you aren't "in the trenches"
toorevitimirp has quit [Remote host closed the connection]
<beach>
jackdaniel: That's an interesting point of view.
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
<beach>
Note to self: In WSCL, improve specification of the interaction between dynamic bindings, BOUNDP, and MAKUNBOUND.
<jasom>
jackdaniel: 1) I don't think you can dynamically bind functions 2) that *also* seems like it would conform to the specification though.
<jasom>
and the progv example froggey gives works as expected in SBCL in terms of "masking" a previously bound symbol
<beach>
I think this is the first issue that would have to be voted on, and only after a long reflection period by several implementation maintainers, including the commercial ones.
<jackdaniel>
jasom: that's why I've said, that the similarity will be only superfluous, more like an analogy than a mechanism
<jasom>
beach: it would be nice to have a table of what each implementation does for each permutation of boundp/progv/let/makunmound
kerosin has quit [Remote host closed the connection]
<beach>
jasom: Absolutely! I am looking forward to seeing some volunteers.
<jasom>
John Regehr wrote a "undefined behavior" test suite for C implementations that documents what compilers do with varoius undefined behaviors
<beach>
Would he do the same for Common Lisp? :)
<jasom>
I guess I just volunteered to start one for lisp
<beach>
Excellent!
<jackdaniel>
call it cl-autoconf ,p
<beach>
Heh!
<jasom>
somewhere lying around I have a tool to run 6 different implementations of lisp on linux. I hope implementations don't differ between windows/linux/os X for non-syscall affecting things but I wouldn't put it past them
<jackdaniel>
cl-launch also allows running things
<jackdaniel>
I have a half-baked lisp-driver to run various lisp implementations with cl-bench / ansi-test
<jackdaniel>
(but not on this computer)
<jasom>
I was working on a portable way of accessing errno, but had to abort and start from scratch when I discovered one of the commercial implementations clears errno before every foreign call
<jackdaniel>
and it is different from cl-launch by that it is full implemented in lisp (i.e you invoke other implementations from working lisp environment)
galex-713 has quit [Ping timeout: 272 seconds]
<beach>
So in the case of SBCL's behavior, for shallow binding, the implementation would be simple. If the variable has a dynamic binding, then just set the thread-specific value cell to `unbound', and if not, set the value cell in the global environment to `unbound'.
<beach>
In the case of deep binding, If there is a dynamic binding, then set the cell of that dynamic binding to `unbound', and if not, set the global value cell to `unbound'.
Alloc has joined #lisp
toorevitimirp has joined #lisp
<kreyren_>
So everything in lisp is an object, does that mean that it's object oriented language?
<beach>
kreyren_: Not everything in Lisp is an object. We had a long discussion about that the other day.
<jasom>
kreyren_: that's a Rorschach test for what you think "object oriented" means
<beach>
kreyren_: But yes, object orientation is one of the paradigms that Common Lisp allows.
<kreyren_>
beach, i would think so for said reasoning?
<kreyren_>
jasom, thanks!
<jasom>
kreyren_: Well maybe everything reified is an object, which then boils down to every object is an object. I'll read backlogs too to not retread this...
<beach>
kreyren_: When you eliminate all the cases like that, you are left with "every Lisp datum is an object", which is a tautology, because the glossary defines "object" as "any Lisp datum".
<kreyren_>
why not call that datum then
<beach>
Who cares?
<beach>
It is just a name.
<beach>
You can use datum if you like. They are the same.
<kreyren_>
i see O.o that actually told me what i needed to know thanku ^-^
<beach>
Anytime.
Alloc has quit [Ping timeout: 260 seconds]
Alloc has joined #lisp
<jasom>
While I'm hesitant to quote paul graham, as doing so in a lisp discussion is a bit on-the-nose, he didn't actually write this, so http://www.paulgraham.com/reesoo.html
sjl_ has joined #lisp
toorevitimirp has quit [Quit: Konversation terminated!]
<jasom>
kreyren_: the TL;DR answer is "yes, but not always in a single-pass, so you have to be careful in some cases"
<beach>
kreyren_: It uses "innermost evaluation" or "call by value" like most implementations.
galex-713 has joined #lisp
<jasom>
oh, I read kreyren_'s question to be about top-level forms
kerosin has joined #lisp
<beach>
kreyren_: But the values are (semantically speaking) references to objects.
Alloc has quit [Ping timeout: 265 seconds]
<jasom>
(foo (bar (baz))) is evaluated insde-out, just like foo(bar(baz())) would be in a c-like syntax language
<beach>
kreyren_: So nothing is every implicitly copied in Common Lisp. I call this type of semantics "uniform reference semantics".
<beach>
kreyren_: As it turns out, it's the only sane semantics if you want to stay sane as a programmer. Which is why I don't touch languages such as C++.
<kreyren_>
jasom, so it's avaluated as baz->bar->foo
<kreyren_>
?
<jasom>
kreyren_: right
<beach>
kreyren_: yes, that's what "innermost evaluation" means.
<kreyren_>
beach, i am already insane! no need for sane :p but i like my code sane
<kreyren_>
jasom, beach, makes sense thanks
<jasom>
I think C++ has every call-by method except "name" at this point...
<kreyren_>
but (foo)\n(bar) then the foo is evaluated first right?
<beach>
jasom: You may very well be right.
<beach>
kreyren_: Yes, evaluation is left-to-right.
<beach>
Unless you break it by writing a bad macro.
<jasom>
kreyren_: that goes back to my first answer. "yes with a but" and you don't need to worry about the but until you write macros
<kreyren_>
i see O.o
<kreyren_>
is there any nice reference to data-types?
* kreyren_
is confused by variable vs symbol in lisp
<beach>
kreyren_: Symbols are first-class objects that can be names of variables.
<beach>
kreyren_: But symbols can be used for many other things as well.
<jasom>
pcl is a good overview if you already have programming experience
<jasom>
minion: tell kreyren_ about pcl
<minion>
kreyren_: direct your attention towards pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<beach>
kreyren_: What languages do you already know?
* kreyren_
is experienced programmer, but he sees elisp as a mindfuck.. lisp so far makes sense ^-^
<kreyren_>
beach, basically all languages including C and Rustlang
<kreyren_>
where i like rustlang the most atm~
<tychoish>
I feel like elisp and cl are like... more alike than they're different
<kreyren_>
tychoish, ye but i hate the forced indentation standard by emacs~
<kreyren_>
using custom made indentation it's quite pleasent
<beach>
kreyren_: I think you will find that the underlying principles of Common Lisp are much simpler than those of languages without automatic memory management.
<kreyren_>
minion, i have dyslexia so learning from a book is not doing it for me..
<minion>
kreyren_: i agree - you have dyslexia so learning from a book is not doing it
<kreyren_>
ah my bad~
<kreyren_>
(he is a bot right)
lottaquestions has joined #lisp
<beach>
kreyren_: If you want to expose your Common Lisp code here for feedback, you should definitely comply with the indentation rules that the conventions dictate. Or you won't get much help.
<kreyren_>
ahw >.<
<beach>
kreyren_: Common Lisp programmers understand code by the indentation, and not by counting parentheses. It is very rude to demand that the person reading your code count parentheses.
<beach>
kreyren_: I for one stop reading the code when I can't rely on the indentation being correct.
<beach>
kreyren_: So you will get a lot less help if you invent your own indentation rules.
<kreyren_>
Is emacs going to auto-indent the expected indentation for common-lisp?
<jasom>
kreyren_: yup
<kreyren_>
good~
<beach>
kreyren_: Specifically, I recommend you use the slime-indentation contribution, which I understand is now the default for SLIME.
bitmapper has joined #lisp
<kreyren_>
what's slime?
<kreyren_>
`( + 1 2 )` is this valid?
<kreyren_>
or does it have to be (+ 1 2)
* kreyren_
is not sure if `(+` is special thing
<jasom>
kreyren_: whitespace is fine between those
<kreyren_>
thanks
<kelamir[m]>
SLIME allows you to interact with Lisp from Emacs. You can run the above command (+ 1 2) with SLIME.
<jasom>
kreyren_: other than driving people reading it insane :)
Bourne has joined #lisp
<kreyren_>
kelamir[m], is SLIME present in Emacs by default or do i have to add it ?
<kelamir[m]>
kreyren_: if you prefer video format, you could check out this channel https://www.youtube.com/channel/UC1J47RqBfY6VgLUZ5YSYkqw I find the vids nice, Neil Munro explains how to set things up and shows how things are done well.
<kreyren_>
kelamir[m], thanku will check!
rgherdt has quit [Quit: Leaving]
treflip has quit [Quit: WeeChat 2.6]
kerosin has quit [Ping timeout: 245 seconds]
bsd4me has joined #lisp
<xristos>
kreyren_: hope you're better behaved here
dra_ has joined #lisp
<kreyren_>
xristos, eh?
dra_ is now known as dra
<xristos>
fyi, kreyren has been banned from #emacs for "support vampiring, learned helplessness, and needless antagonism"
<dra>
Hello!
<kreyren_>
xristos, i am same everywhere~ ##emacs doesn't like me asking too much questions in their channel though O.o
<kelamir[m]>
Hello, Dra! How's Lisping going? I didn't answer last time, I was doing well 😇
<kreyren_>
which i don't need to do in terms of lisp that much anyway
<dra>
kelamir[m]: No worries. ;) Doing fine!
<kelamir[m]>
What are you working on?
<dra>
It it possible to FTYPE-declare a function to return an exact number of values?
johnjay has quit [Ping timeout: 256 seconds]
<kreyren_>
xristos, also #lisp people seems to provide the information needed quicker and more accurately.. #emacs likes to confuse things from my experience
<dra>
kelamir[m]: Working through Anatomy of Lisp. Fun read!
<kelamir[m]>
Sounds interesting. What do you find fun about it, dra?
<kelamir[m]>
*that sounds more like a medicine title*
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
gko_ has quit [Ping timeout: 265 seconds]
<dra>
kelamir[m]: It develops a theoretical understanding of Lisp. It does so assuming that you know very little about Lisp while at the same time expecting you to think along.
iamFIREcracker has quit [Ping timeout: 256 seconds]
skapata has joined #lisp
cosimone has quit [Quit: Quit.]
<kelamir[m]>
That must be fun 🙂
iamFIREcracker has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
ukari has quit [Remote host closed the connection]
iamFIREcracker has quit [Ping timeout: 256 seconds]
cosimone has joined #lisp
cosimone has quit [Client Quit]
Inline has quit [Ping timeout: 272 seconds]
skapata has quit [Ping timeout: 244 seconds]
aartaka has quit [Read error: Connection reset by peer]
Inline has joined #lisp
<dra>
kelamir[m]: It is. Though I have read that some parts are outdated. But I haven't arrived at those parts yet.
kreyren_ has quit [Remote host closed the connection]
yitzi has joined #lisp
dra has quit [Quit: Leaving]
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
wwolf[m] has joined #lisp
iamFIREcracker has joined #lisp
iamFIREcracker has quit [Ping timeout: 264 seconds]
rippa has joined #lisp
yitzi has quit [Read error: Connection reset by peer]
mindCrime_ has quit [Ping timeout: 244 seconds]
mrcom has joined #lisp
aartaka has joined #lisp
rogersm has quit [Quit: Leaving...]
johnjay has joined #lisp
asarch has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
Alloc has joined #lisp
rogersm has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
gravicappa has quit [Ping timeout: 260 seconds]
gravicappa has joined #lisp
Adamclisi has quit [Quit: leaving]
rpg has joined #lisp
<rpg>
Has anyone there been able to load an OWL ontology into a CL program? I have found wilbur, but it is poorly documented, and I was wondering if anyone has tried anything different.
cosimone has joined #lisp
yonkunas has joined #lisp
Adamclisi has joined #lisp
kaftejiman has joined #lisp
edgar-rft has joined #lisp
akoana has joined #lisp
iamFIREcracker has joined #lisp
iamFIREcracker has quit [Ping timeout: 256 seconds]
<asarch>
ObjectWindow Library?
<rpg>
asarch: Thanks, but.... this would be for Linux, and MacOS, and I think that's windows only?
<asarch>
Take a look at cl-cffi-gtk
rogersm has quit [Quit: Leaving...]
<asarch>
You can easily reuse all your Glade templates from other programming languages
yitzi has joined #lisp
karlosz has joined #lisp
narimiran has quit [Ping timeout: 256 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
aaaaaa has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
vgmind has joined #lisp
iamFIREcracker has joined #lisp
aaaaaa has left #lisp [#lisp]
iamFIREcracker has quit [Ping timeout: 240 seconds]
ggole has quit [Quit: Leaving]
notzmv` has joined #lisp
random-nick has quit [Ping timeout: 246 seconds]
notzmv has quit [Ping timeout: 265 seconds]
Smolengrad has joined #lisp
<Smolengrad>
lisp is annoying.
<phoe>
wait, why, how
<phoe>
which part exactly
<Smolengrad>
its not user friendly
<phoe>
what exactly do you mean by a lack of user friendliness
<White_Flame>
it really increases my annoyance with other languages
<Smolengrad>
take an example from pithon2.7
<Smolengrad>
its nice a friendly to use
<aeth>
it's also a dead language
<Smolengrad>
no its not
johnjay has quit [Ping timeout: 260 seconds]
<Smolengrad>
its very active
<aeth>
This isn't a channel for roasting other languages, but Python's lambda syntax is so awful it might as well not have a lambda. Python is very opinionated toward iterative programming and barely has any functional programming functionality. It's competing in a different space than Lisps are. In some Lisps, almost everything's ultimately a lambda.
<White_Flame>
and yeah, 2.7 is dead
<Smolengrad>
but at least it has a favicon.
<White_Flame>
any activity can be attributed to lingering shamblers ;)
<phoe>
if this is a trolling attempt, then this is a poor trolling attempt
<Smolengrad>
do you use snort to detect trolling alertz ?
notzmv`` has joined #lisp
<phoe>
no, I use my own eyes; you came here as a new face and start posting flamebait from the very start instead of adding something constructive.
<phoe>
I would suggest #lispcafe for such instead of #lisp
<Smolengrad>
no
<Smolengrad>
you go there
<Smolengrad>
i am staying here
scymtym has joined #lisp
<Smolengrad>
Phoebe ;)
Smolengrad was banned on #lisp by phoe [*!*sid461327@gateway/web/irccloud.com/x-ufubplczlididaoy]
Smolengrad was kicked from #lisp by phoe [(progn (trivial-garbage:gc :full t) (print "no, you're not") nil)]
<aeth>
If you go into Python expecting to write code like in CL or Scheme, you're going to have a bad time because of the limited FP/lambda/etc. And in Python 3, the output from stuff like map can only be used once, too, which is incredibly surprising.
<aeth>
And assuming you're not just trolling, it looks like you came into Lisp expecting to write Python, and similarly had a bad time, but that doesn't make either Lisp or Python a bad language, just different languages with different expectations.
Smolengrad has joined #lisp
<phoe>
aeth: sorry
<Smolengrad>
pussy hole
<phoe>
they've already left
<Smolengrad>
;)
<Smolengrad>
Phoebe
<Smolengrad>
!!!!!!!!!
Smolengrad was kicked from #lisp by phoe [(progn (trivial-garbage:gc :full t) (print "no, you're not") nil)]
Smolengrad has joined #lisp
<Smolengrad>
fail
<Smolengrad>
fail
<phoe>
oh shit they came prepared
<Smolengrad>
Phoebe
<White_Flame>
tons of irc clients reconnect. kicking has no usefulness nowadays
<phoe>
well yes but a +b should work
<aeth>
wrong +b syntax, I'm guessing
<Smolengrad>
well this proves how LISP shit is ...
<Smolengrad>
lisp is for virgins really.
<aeth>
phoe: redo your +b but replace sid461327 with *
notzmv` has quit [Ping timeout: 240 seconds]
<aeth>
phoe: that's the only difference
<Smolengrad>
Phoebe
<Smolengrad>
call her Phoebe
mindCrime_ has joined #lisp
Smolengrad was banned on #lisp by phoe [*!*@gateway/web/irccloud.com/x-ufubplczlididaoy]
Smolengrad was kicked from #lisp by phoe [Smolengrad]
Smolengrad has joined #lisp
<Smolengrad>
o hai
<Smolengrad>
how are you fellers doing tonight
<Smolengrad>
hi Phoebe
<phoe>
well that is interesting
<aeth>
I'm surprised that people under 12 still use IRC.
<aeth>
Smolengrad: If you keep trolling like this, I'm going to have to talk to your parents.
<Smolengrad>
no
<Smolengrad>
i think Phoe aka Phoebe are in need of a good spanking !
<Smolengrad>
💩
<Josh_2>
xD
<Smolengrad>
i got leather belts, chains, whips
<rpg>
asarch: Ah, I see -- we were talking at cross-purposes! The OWL I was referring to was the "Web Ontology Language" not the OpenWindows Library!
<asarch>
D'oh!
<asarch>
Ok
<Smolengrad>
yes OWL
<Smolengrad>
SUPER BOWL
<Smolengrad>
phoe
<Smolengrad>
can i contribute to list ?
<Smolengrad>
lisp ?
* rpg
was just thinking about how he hadn't used the IGNORE command for a while...
<Smolengrad>
let me ignore you first pal
<Smolengrad>
it works both ways
karlosz has quit [Quit: karlosz]
Smolengrad was kicked from #lisp by phoe [Smolengrad]
karlosz has joined #lisp
<aeth>
rpg: This is off-topic, but with a nick like that, you really are the chosen one. You have to write an RPG RPG RPG RPG, i.e. a role-playing game (RPG) in IBM Report Program Generator (RPG) centered around rocket propelled grenades (RPG) written by rpg
<rpg>
aeth: That (well really because of Richard P. Gabriel) is why I'm NotThatRpg...
wsinatra has quit [Quit: WeeChat 2.9]
<phoe>
FYI: #lisp had a ban exeption set on *!*@gateway/web/irccloud.com/*
<phoe>
this is no longer the case.
bilegeek has joined #lisp
<aeth>
ah
<phoe>
in case this (somehow?) breaks someone's workflow: please let me know.
<White_Flame>
well, nobody else has been immediately swept up, so it's probably okay
<White_Flame>
does the current +b just contain their sid?
<Alfr_>
LESS-FAMOUS is too long, may I use local nicknames?
<phoe>
WHO?::RPG
iamFIREcracker has joined #lisp
<Alfr_>
<F:RPG is nice, I think.
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
iamFIREcracker has quit [Ping timeout: 265 seconds]
<aeth>
Yeah, but the most famous "RPG" is probably WoW (computers) or D&D (overall)... so you still get a name collision issue if you're just talking about a less famous use of the letters "RPG"
snowyfox has joined #lisp
<aeth>
If you want a unique identifier, you're going to have to be more creative.
<markasoftware>
i should've known this wasn't a new idea!
<markasoftware>
But I still like my `with-places` function, which makes it much more transparent, no longer requiring explicit dereferencing and writing. And that's the part of my code I'm worried may have subtle bugs.
<markasoftware>
s/function/macro
torbo has joined #lisp
notzmv`` is now known as notzmv
notzmv has quit [Changing host]
notzmv has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
iamFIREcracker has joined #lisp
iamFIREcracker has quit [Ping timeout: 256 seconds]
karlosz has quit [Ping timeout: 265 seconds]
karlosz has joined #lisp
pve has joined #lisp
cosimone has quit [Ping timeout: 244 seconds]
uenochan has joined #lisp
rumbler31 has quit [Ping timeout: 258 seconds]
Oladon has joined #lisp
Bourne has quit [Ping timeout: 258 seconds]
karlosz has quit [Ping timeout: 240 seconds]
pve has quit [Quit: leaving]
Inline has quit [Ping timeout: 260 seconds]
clothespin has joined #lisp
mangoicedtea has joined #lisp
iamFIREcracker has joined #lisp
orivej has joined #lisp
iamFIREcracker has quit [Ping timeout: 240 seconds]
hargettp has joined #lisp
uenochan has quit [Quit: WeeChat 2.3]
hargettp has quit [Ping timeout: 240 seconds]
madage has quit [Ping timeout: 240 seconds]
madage has joined #lisp
madage has quit [Remote host closed the connection]