<recordgroovy>
Hi, I'm looking into CFFI, and I see examples where shared objects are loaded, but not C source files. Is there a way to go about doing this?
montxero has quit [Read error: Connection reset by peer]
montxero has joined #commonlisp
z3t0 has joined #commonlisp
<pillton>
recordgroovy: With CFFI, you need to produce a shared library from your C source file and use the CFFI API to access functions/symbols in the shared library.
<Bike>
your lisp compiler probably isn't also a C compiler, so it can't do much with source code
<recordgroovy>
So, I'm always going to need to compile as an intermediate step? Is it possible to do this automatically when my program is required?
<recordgroovy>
er, when my system is loaded?
<pillton>
recordgroovy: Alternatively, you can use the SFFI API which is specific to ECL. See Chapter 3.3.5 of the ECL Manual.
<Bike>
you could call an external C compiler program, or distribute shared objects with your source
<Bike>
if by "wrap this snippet" you mean you want registry_handle_global, you could write it in lisp, and call out to the wayland library your user presumably already has
<recordgroovy>
I meant allocate_shm_file. I suppose alternatively I could reimplement it, loading shm_open() & friends directly instea.
<recordgroovy>
instead*.
SystemFFan has quit [Remote host closed the connection]
<Bike>
that's what i meant, yeah. it would be less a full "reimplementation" and more translating this C code into lisp code. cffi lets you do things that C can do like allocate automatic variables and etc.
<recordgroovy>
Aight, I got a roadmap, thanks
borodust has quit [Ping timeout: 252 seconds]
borodust has joined #commonlisp
zephyr has joined #commonlisp
<saltrocklamp[m]>
if you're distributing the application, i assume you'd either 1) require it as an external dependency, or 2) bundle it with your application. maybe there's a way to do 1 and fall back to 2, i'm not really sure how all that stuff works at the system level (and i assume it's all different between mac/windows/linux/bsd anyway)
<saltrocklamp[m]>
my package manager just does the right thing! but i really should learn how that all works..
<saltrocklamp[m]>
i think for the most part it's a matter of making sure you have the right shared library in a particular location on the system, right?
pillton` has joined #commonlisp
pillton has quit [Ping timeout: 260 seconds]
Alfr has quit [Remote host closed the connection]
Alfr has joined #commonlisp
Oladon has joined #commonlisp
pillton` has quit [Quit: ERC (IRC client for Emacs 27.2)]
waleee has quit [Ping timeout: 256 seconds]
<beach>
Good morning everyone!
srhm has quit [Quit: Konversation terminated!]
semz has quit [Ping timeout: 250 seconds]
semz has joined #commonlisp
Alfr has quit [Quit: Leaving]
Oladon has quit [Quit: Leaving.]
khrbt has quit [Ping timeout: 244 seconds]
lisp123 has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
khrbt has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 240 seconds]
NeoCron has joined #commonlisp
lisp123_ has joined #commonlisp
lisp123 has quit [Ping timeout: 244 seconds]
NeoCron has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
khrbt has quit [Ping timeout: 252 seconds]
khrbt has joined #commonlisp
lisp123_ has quit [Read error: Connection reset by peer]
peterhil has quit [Ping timeout: 252 seconds]
lisp123_ has joined #commonlisp
pve has joined #commonlisp
<mfiano>
Could anyone tell me the correct incantation of #'find-method to retrieve an :after initialize-instance method? I am not sure what I am getting wrong here...
CrashTestDummy3 has joined #commonlisp
<mfiano>
Rubber ducked my way out of it, thanks anyway
<mfiano>
Note to self. Make sure you pass a generic function object, and not a designator.
<moon-child>
you are welcome
gaqwas has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
attila_lendvai has joined #commonlisp
Spawns_Carpeting has quit [Ping timeout: 252 seconds]
Spawns_Carpeting has joined #commonlisp
rain3 has joined #commonlisp
Spawns_Carpetin- has joined #commonlisp
Spawns_Carpeting has quit [Ping timeout: 244 seconds]
heisig has joined #commonlisp
shka has joined #commonlisp
Spawns_Carpetin- has quit [Ping timeout: 252 seconds]
Spawns_Carpeting has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
lotuseater has joined #commonlisp
Cymew has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
amb007 has quit [Ping timeout: 252 seconds]
<White_Flame>
hmm, swank needs the length of strings to fit in 24 bits, blows up slime otherwise
amb007 has joined #commonlisp
<White_Flame>
and I think that's the rendering of the massive data object that's being printed, not a single string in my data of that size
<moon-child>
woh, fun
<moon-child>
why?
pranavats has left #commonlisp [#commonlisp]
gaqwas has quit [Ping timeout: 252 seconds]
pranavats has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Spawns_Carpeting has quit [Ping timeout: 252 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Spawns_Carpeting has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
hendursaga has joined #commonlisp
hendursa1 has quit [Ping timeout: 276 seconds]
selwyn has joined #commonlisp
Spawns_Carpeting has quit [Ping timeout: 252 seconds]
Spawns_Carpeting has joined #commonlisp
VincentVega has joined #commonlisp
Spawns_Carpetin- has joined #commonlisp
scymtym has joined #commonlisp
Spawns_Carpeting has quit [Ping timeout: 244 seconds]
<scymtym>
recordgroovy: thanks for the wayland book link. it looks very useful
Spawns_Carpeting has joined #commonlisp
Spawns_Carpetin- has quit [Ping timeout: 244 seconds]
hayley has joined #commonlisp
<hayley>
Which Common Lisp compiler should I use if I want to gather statistics about the instructions generated?
<hayley>
Usually I would use SICL, but it does not have many optimizations applied in the compiler, so the code generated is not representative of much. I guess Clasp also uses Cleavir, come to think of it.
<White_Flame>
moon-child: as for the 'why', it would be encoding across the socket, though that seems arbitrarily limited compared to 32-bit length strings
<scymtym>
hayley: SBCL has (probably as in "can be compiled with") src/code/dyncount.lisp, but: 1) i'm not sure whether it does what you need 2) i'm not sure whether it still works
<hayley>
scymtym: Right, thanks. In short, I'm looking to see how frequently needed read barriers would actually be, which requires checking some instructions after load instructions too.
<scymtym>
hayley: i see. vop statistics are probably too coarse, then
<hayley>
(Specifically, I have a hunch that checking for type tests which confirm that some value is immediate, and checking if the value is loaded from immediately after, would eliminate some barriers, but without numbers it is just a hunch.)
<hayley>
Well, Clasp isn't an option until I rebuild it, as some shared library was updated without it. sigh
Spawns_Carpeting has quit [Ping timeout: 252 seconds]
Spawns_Carpetin- has joined #commonlisp
scymtym has quit [Ping timeout: 245 seconds]
elf_fortrez has joined #commonlisp
scymtym has joined #commonlisp
lisposite has joined #commonlisp
scymtym has quit [Remote host closed the connection]
cosimone has joined #commonlisp
scymtym has joined #commonlisp
khoa has quit [Quit: leaving]
khoa has joined #commonlisp
kakuhen has quit [Quit: Leaving...]
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
silasfox has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
random-nick has joined #commonlisp
lisp123_ has quit [Quit: Leaving...]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Krystof has joined #commonlisp
Spawns_Carpetin- has quit [Ping timeout: 244 seconds]
Spawns_Carpeting has joined #commonlisp
tyson2 has joined #commonlisp
elf_fortrez has quit [Ping timeout: 256 seconds]
cosimone has quit [Read error: Connection reset by peer]
yitzi has joined #commonlisp
tfeb has joined #commonlisp
waleee has joined #commonlisp
lisposite has quit [Quit: WeeChat 2.8]
tfeb has quit [Quit: died]
cosimone has joined #commonlisp
Bike has joined #commonlisp
jeosol has quit [Ping timeout: 252 seconds]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
hendursaga has quit [Quit: hendursaga]
hendursaga has joined #commonlisp
Skyfire has quit [Ping timeout: 240 seconds]
tyson2 has joined #commonlisp
Cymew has quit [Ping timeout: 252 seconds]
scymtym has quit [Ping timeout: 245 seconds]
scymtym has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
lisp123 has joined #commonlisp
ec_ has joined #commonlisp
ec_ has quit [Client Quit]
ec_ has joined #commonlisp
Everything has joined #commonlisp
waleee has quit [Ping timeout: 245 seconds]
waleee has joined #commonlisp
<lotuseater>
waleee: I think I've seen earlier something from this J guy you linked me. He seems very capable and can explain well too imo.
ec_ has quit [Ping timeout: 276 seconds]
srhm has joined #commonlisp
srhm has quit [Read error: Connection reset by peer]
Inline_ has quit [Quit: Leaving]
VincentVega has quit [Read error: Connection reset by peer]
srhm has joined #commonlisp
ec_ has joined #commonlisp
srhm has quit [Read error: Connection reset by peer]
srhm has joined #commonlisp
yitzi has quit [Quit: Leaving]
cage has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<markthom_>
I can't load rutils into lispworks. "Error: Unknown module :RUTILS" it says.
<markthom_>
I've loaded it with quicklisp, and.. I don't know what else is necessary.
amb007 has joined #commonlisp
<beach>
How did you "load it with quicklisp"?
<markthom_>
(ql:quickload "rutils")
<lotuseater>
with SBCL? which version?
<Bike>
and you did that in lispworks?
<markthom_>
I should've mentioned, this is in the context of loading it as part of an asdf system
<lotuseater>
oh sry!
<lotuseater>
i overread the lispworks part in your first sentence
<beach>
markthom_: That should be enough. What did you do to prompt the error message?
<markthom_>
I ran (asdf:load-system "psoatransrun") in the listener and everything went fine until the message.
<markthom_>
I have #:rutils as a dependency in that system.
<_death>
system names should be strings
<beach>
_death: Uninterned symbols are fine.
<saltrocklamp[m]>
why do some people use strings and some people use uninterned symbols?
<_death>
beach: hmm, you're right.. I do have systems that use them as such
<ahlk>
What's the difference between #:something and :something ?
<_death>
beach: at some point I switched to strings.. I feel that there was something more to it than style, but maybe not
<markthom_>
what about in require? am I also limited to use either strings or uninterned symbols there?
<beach>
markthom_: REQUIRE should not be, erm, required here.
<beach>
ahlk: #:something is turned into an uninterned symbol named SOMETHING by READ, whereas :something is turned into a symbol in the keyword package named SOMETHING.
<ahlk>
beach: thanks!
<beach>
Sure.
<markthom_>
I think I will ask on the lispworks mailing list. I can send a link to the project github repo there.
<markthom_>
thanks
<_death>
markthom: the error message is suspect, because it uses the term "module"..
<beach>
Yes, so likely REQUIRE is involved here. Which it shouldn't be.
<markthom_>
I am using a require directive in one place with the ":rutils" keyword symbol
<beach>
You shouldn't.
ec_ has quit [Ping timeout: 276 seconds]
silasfox has quit [Quit: silasfox]
<beach>
Quickload or asdf:load-system should be enough.
srhm has quit [Ping timeout: 252 seconds]
<Bike>
you probably don't want to use require, except maybe to load implementation specific modules in an implementation specific way. or asdf, probably
ec_ has joined #commonlisp
<Bike>
what require actually does when given one argument is implementation dependent. it may use asdf or may not, and it probably won't use quicklisp.
<markthom_>
I've never properly understood require.
<markthom_>
yes, that got rid of the error
<markthom_>
thank you!
<beach>
Pleasure.
selwyn has quit [Read error: Connection reset by peer]
seok has joined #commonlisp
<seok>
#(97 98 99) does not seem to be the same as the octet vector for "abc"
<seok>
How do I create octet vectors ?
<mfiano>
(make-array n :element-type '(unsigned-byte 8))
<seok>
ah thank you
<seok>
is there no shorthand version ?
<beach>
seok: The subtype of the vector is not determined by its contents, but by how it was created.
<mfiano>
There are utilities for converting to octet vectors in both ironclad and babel
<seok>
ahh i see
<seok>
ok
<seok>
thank you
<lotuseater>
seok: the normal #( creates a simple-vector for you, so one with element-type T
heisig has quit [Quit: Leaving]
selwyn has joined #commonlisp
Devon has joined #commonlisp
<lotuseater>
hm how was that in ironclad again? they changed the #( so that you create (unsigned-byte n) vectors with #n( ? I'm not sure at the moment if that or with #{ or #[ .
<lotuseater>
oh right, it's #@
lisp123 has quit [Quit: Leaving...]
CrashTestDummy3 has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
<lotuseater>
cl21 changes #( so that the read symbols are evaluated, not so cool
<lotuseater>
but surely from time to time well usable too
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
CrashTestDummy has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
ec_ has quit [Ping timeout: 276 seconds]
Oladon has joined #commonlisp
selwyn has joined #commonlisp
ec_ has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
Inline has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
CrashTestDummy has quit [Ping timeout: 252 seconds]
silasfox has joined #commonlisp
<semz>
what's the point of that? might as well use `vector' then
<beach>
The point of what?
<semz>
evaluating the symbols in #(
<beach>
Right.
<semz>
it's not going to be a read-time constant that way
<lotuseater>
ask the dudes from the cl21 project ^^
<lotuseater>
beach: I can imagine your opinion to that. :)
<beach>
lotuseater: And I am not alone.
<saltrocklamp[m]>
i assume this is meant to be something like an alternative standard library? so you `:use "cl21"` alongside or in addition to `:use "cl"`?
<saltrocklamp[m]>
* "cl21"` alongside of or in
<saltrocklamp[m]>
the examples shown on the homepage mostly look like a collection of useful helper macros
<lotuseater>
Yes I know, and that is great.
<lotuseater>
beach: ↑
<saltrocklamp[m]>
definitely seems like a controversial (deliberately) way to advertise it
aeth has quit [Ping timeout: 244 seconds]
<saltrocklamp[m]>
as opposed to "an extension of the common lisp standard library, to make common lisp friendlier for 21st century programmers" or something
<lotuseater>
so what do they do in the next century? or millennium?
makomo has joined #commonlisp
<saltrocklamp[m]>
they benefit from a few extra decades of hindsight and the changing preferences and needs of developers
aeth has joined #commonlisp
karlosz has joined #commonlisp
<beach>
saltrocklamp[m]: Developers of application programs are typically notoriously incapable of language design, and giving in to their "preferences", might destroy a language completely, in that it might make it very hard to then write good optimizing compilers for it.
<beach>
saltrocklamp[m]: I think Python is a good example of how not to design a language.
<saltrocklamp[m]>
hah
<lotuseater>
There are many examples for this phenomena. :)
<saltrocklamp[m]>
i know that lisp in particular was supposedly very carefully designed to balance performance and ergonomics, at least given the constraints of computers at the time it was developed
<lotuseater>
but one learns also from negative examples
<lotuseater>
saltrocklamp[m]: Common Lisp
<saltrocklamp[m]>
that's what i meant, yes
<saltrocklamp[m]>
python was very conspicuously not designed to do anything but be comfortable for guido van rossum to use
<saltrocklamp[m]>
that said, most of what i see in this cl21 repo seems very innocuous
<beach>
Yes, and the result is that, to make it useful, you really have to writer yoru code in C.
<saltrocklamp[m]>
i would argue that most python code is useful without writing C extensions
<lotuseater>
beach: "When you listen to a UNIX shell, can you hear the C?"
<beach>
saltrocklamp[m]: Except that it is 50x slower than it should be.
<lotuseater>
saltrocklamp[m]: and how long useful? till new inconsistencies break it
karlosz has quit [Client Quit]
<beach>
saltrocklamp[m]: Introducing more syntax as cl21 does make it harder to reason about macro expanders. Because now you need to know the underlying S-expression version of each new syntax construct.
karlosz has joined #commonlisp
<saltrocklamp[m]>
the only thing i'll say about python is that it's clearly "useful" enough to have become one of the world's top programming languages. much like java, it's a local maximum of usefulness, not a global one.
karlosz has quit [Client Quit]
<beach>
saltrocklamp[m]: But what it really is, is acting as a glue between C modules.
<saltrocklamp[m]>
as for cl21, that's fair, although personally i already use `cl-interpol` and these other macros seem pretty intuitive to me
<saltrocklamp[m]>
i am consistently impressed with the discipline of lisp programmers. i've seen much more horrifying metaprogramming in much less-metaprogrammable languages.
<saltrocklamp[m]>
acting as glue between C modules i think is a very very valid and useful thing
<saltrocklamp[m]>
yes, lisp can also act as glue between C modules
<beach>
saltrocklamp[m]: Sure, if all you have is a bunch of C modules, glue is very useful.
<beach>
saltrocklamp[m]: But if you are forced to debug application code using multiple languages, one of which is an unsafe one, it is much less fun.
<saltrocklamp[m]>
i would bet that 90+% of python programmers never write a single line of C in their python work
<lotuseater>
maybe there's no (de)fun allowed ^^
<lotuseater>
saltrocklamp[m]: because they rely heavily on the work of others who did it before
<beach>
saltrocklamp[m]: Then they are probably not writing very sophisticated applications. And that's probably true for 90% of programmers, no matter what language they use.
<saltrocklamp[m]>
well yeah, web servers are usually pretty simple
<saltrocklamp[m]>
data processing scripts, kiosk applications, twiddling bits on an arduino, etc
<semz>
A lot of these CL21 changes just look like minor quirks the author personally disliked. I mean, to each his own, the language supports changing those parts after all, but the whole spiel about how this is the reason CL is not popular and it Must Be Modernized in a way that casually breaks three decades of compatibility rubs me the wrong way.
<saltrocklamp[m]>
and "sophisticated" i think is orthogonal to "needs high performance that comes with eliminating python's high runtime overhead"
<saltrocklamp[m]>
i have a laundry list of reasons why CL isn't "popular" in my head and notes, and the standard library is a minor footnote at the bottom, given how a lot of these "modernizations" are only a `ql:quickload` away from being at your fingertips
<beach>
semz: Yes, that's totally misguided. Everyone seems to "know" why Common Lisp is not as popular as it deserves and how to fix it.
<saltrocklamp[m]>
i personally do use `cl-interpol`, but i'm not about to claim that lack of shell-style string interpolation is what's keeping common lisp from being #1 on tiobe
<saltrocklamp[m]>
i think this library needs to be rebranded as "an opinionated extension to the common lisp standard library"
<lotuseater>
yes for those who like unix style naming
Cymew has joined #commonlisp
srhm has joined #commonlisp
<saltrocklamp[m]>
overriding `#()` i think is not great
<saltrocklamp[m]>
it could have been `#V()` by analogy with `#H()`
<lotuseater>
"oh right, the 'db' stands for destructuring-bind"
<lotuseater>
yes maybe
<saltrocklamp[m]>
is there any reason why you couldn't write `let` to automatically destructure if it detects that the left-hand side of the binding isn't a standalone symbol?
ec_ has quit [Ping timeout: 276 seconds]
<saltrocklamp[m]>
* couldn't write a wrapper around `let` to
<saltrocklamp[m]>
that's what i would personally want, in my own little opinionated kingdom
<lotuseater>
it's a special operator
<lotuseater>
or explain more how you mean it
<semz>
you could shadow let and define your own let macro that expands to cl:let
<saltrocklamp[m]>
i'd call it a different name because shadowing is bad imo, but that ^
<lotuseater>
no it's not bad at all, ask beach about it :)
keir has joined #commonlisp
<beach>
I am no longer participating.
<beach>
Dinner is imminent anyway.
<saltrocklamp[m]>
hah, sorry to scare you off
<beach>
Don't worry about it.
<lotuseater>
Okay see you tomorrow maybe.
<saltrocklamp[m]>
for what it's worth, i highly value the opinion of someone who is reimplementing common lisp in common lisp
<beach>
Oh, that's flattering! Thank you!
<saltrocklamp[m]>
i certainly didn't mean to offend. enjoy your dinner!
<beach>
No, no, I was not offended. I just quit listening because I had nothing more to offer.
<_death>
saltrocklamp[m]: you can do that, and people have (e.g., metabang-bind).. but CL already provides constructs for ordinary programming, so maybe instead it's better to expend effort with more domain specific abstractions, and not head in the "private language" direction
<lotuseater>
saltrocklamp[m]: "featuring 100% less C" ^^
<saltrocklamp[m]>
i will look up metabang-bind, thanks :P
<saltrocklamp[m]>
i agree, 99% of the "fun" code i write usually gets refactored to "boring" code by the time it starts getting serious use. but i enjoy exploring programming language design quite a lot
<_death>
saltrocklamp[m]: sure, I think every lisper goes through these stages :)
SystemFFan has joined #commonlisp
ec_ has joined #commonlisp
<_death>
(although not everyone calls his library "cl21" ;)
<saltrocklamp[m]>
i am admittedly not a lisp lifer, although i do enjoy using it for my little ad-hoc scripts
selwyn has joined #commonlisp
selwyn has quit [Remote host closed the connection]
qhong has quit [Remote host closed the connection]
markthom_ has quit [Quit: Client closed]
markthom_ has joined #commonlisp
qhong has joined #commonlisp
ec_ has quit [Ping timeout: 276 seconds]
srhm has quit [Read error: Connection reset by peer]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
gaqwas has joined #commonlisp
ec_ has joined #commonlisp
karlosz has joined #commonlisp
rain3 has quit [Ping timeout: 252 seconds]
qhong has quit [Remote host closed the connection]
attila_lendvai has quit [Ping timeout: 252 seconds]
Lycurgus has joined #commonlisp
yitzi has joined #commonlisp
pve has quit [Quit: leaving]
azimut_ has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
keir has quit [Quit: keir]
elf_fortrez has joined #commonlisp
elf_fortrez has quit [Client Quit]
azimut has quit [Ping timeout: 276 seconds]
karlosz has quit [Quit: karlosz]
Cymew has quit [Ping timeout: 245 seconds]
ec_ has quit [Ping timeout: 276 seconds]
qhong has joined #commonlisp
karlosz has joined #commonlisp
ec_ has joined #commonlisp
qhong has quit [Ping timeout: 252 seconds]
keir has joined #commonlisp
cosimone has joined #commonlisp
silasfox has quit [Ping timeout: 244 seconds]
shka has quit [Ping timeout: 252 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
karlosz has quit [Quit: karlosz]
silasfox has joined #commonlisp
ec_ has quit [Ping timeout: 276 seconds]
khoa has left #commonlisp [#commonlisp]
Oladon has quit [Quit: Leaving.]
scymtym_ has quit [Ping timeout: 245 seconds]
ec_ has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
SystemFFan has quit [Remote host closed the connection]
SystemFFan has joined #commonlisp
keir has quit [Quit: keir]
scymtym_ has joined #commonlisp
rgherdt has quit [Ping timeout: 256 seconds]
scymtym_ has quit [Client Quit]
scymtym has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
ec_ has quit [Ping timeout: 276 seconds]
selwyn has quit [Read error: Connection reset by peer]
ec_ has joined #commonlisp
specbot has quit [Remote host closed the connection]
minion has quit [Remote host closed the connection]
specbot has joined #commonlisp
minion has joined #commonlisp
Everything has quit [Quit: leaving]
<hayley>
All I need to know about CL21 is they removed ROOM because it was "useless".
<hayley>
No, actually I like opening another program to watch the heap usage of my program. And I'm fine without statistics on object counts and sizes.
ec_ has quit [Ping timeout: 276 seconds]
ec_ has joined #commonlisp
* aeth
can't wait for CL22 next year
frgo has quit [Read error: Connection reset by peer]
* hayley
thought it was for the 21st century.
frgo has joined #commonlisp
<hayley>
I wonder how they got by in the 00's with no CL21 then.
Oladon has joined #commonlisp
markthom_ has quit [Quit: Client closed]
markthom_ has joined #commonlisp
ec_ has quit [Ping timeout: 276 seconds]
<akater[m]>
salt rock lamp: There are plenty of destructuring macros. See `trivia` and other pattern-matching libraries. Elisp has `pcase-let`.
<White_Flame>
I thought it was supposed to mean Common Lisp v2.1
akoana has quit [Quit: leaving]
<moon-child>
hmm, if we had cltl1 and cltl2, then does that mean dpans is ~cltl3? So cl21 is actually out of date
<hayley>
CLtL 2 Episode 1
Yehowshua has joined #commonlisp
<Yehowshua>
I'm trying to build a loop that runs a certain function and breaks if that function returns true.
<hayley>
RETURN TOKEN probably should be in parentheses, i.e. (IF TOKEN (RETURN TOKEN))
<moon-child>
you can do that much mroe directly though
<Yehowshua>
more directly?
<moon-child>
(loop for tokenizer in tokenizers thereis (funcall tokenizer string-seq cursor))
<Yehowshua>
how?
<Yehowshua>
thx
Yehowshua has quit [Quit: Client closed]
icer has joined #commonlisp
cosimone has quit [Ping timeout: 252 seconds]
icer has quit [Ping timeout: 244 seconds]
icer has joined #commonlisp
<dieggsy>
thereis. i continue to learn new loop clauses
CrashTestDummy2 has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
<dieggsy>
could you just use find-if for that too?
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
<saltrocklamp[m]>
<akater[m]> "salt rock lamp: There are plenty..." <- thanks i forgot about trivia
<moon-child>
dieggsy: you could 'just' use lambda and funcall, for everything
montxero has quit [Read error: Connection reset by peer]
montxero has joined #commonlisp
* moon-child
idly wonders if #n=/#n# is turing-complete
VincentVega has quit [Ping timeout: 252 seconds]
Oladon has quit [Quit: Leaving.]
igemnace has quit [Ping timeout: 245 seconds]
lad has joined #commonlisp
srhm has joined #commonlisp
icer has quit [Ping timeout: 252 seconds]
srhm has quit [Quit: Konversation terminated!]
<lad>
My SLIME/Emacs integration seems wonky. I seem to get this message more often that I'd like: cond: Error: DEFINITION-SOURCE of function SOME-FUNCTION did not contain meaningful information.
random-nick has quit [Ping timeout: 252 seconds]
<lad>
this is when I Use M-. to jump to a function definition
<lad>
sometimes it works, and then it ends up not. Also, it doesn't seem to work with definitions in the current file. le sigh