White_Flame has quit [Remote host closed the connection]
White_Flame has joined #commonlisp
MetaYan has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
psycomic has quit [Remote host closed the connection]
psycomic has joined #commonlisp
Guest93 has joined #commonlisp
lottaquestions has quit [Quit: Konversation terminated!]
lottaquestions has joined #commonlisp
waleee has quit [Ping timeout: 240 seconds]
psycomic has quit [Ping timeout: 240 seconds]
Yehowshua has joined #commonlisp
<Yehowshua>
in scheme you could have (begin list-of-actions). Is there anything like that in lisp? This could be useful if I want to do multiple things in an if statement
<moon-child>
progn
<moon-child>
cl progn is the same as scheme begin
<Yehowshua>
thanks
tyson2 has quit [Remote host closed the connection]
<Yehowshua>
it seems you have to use apply with `#'` before the function name
<Yehowshua>
is that correct?
<Yehowshua>
feels a little odd coming from scheme
<Bike>
yes, lisp has a separate function namespace
<Bike>
"#'foo" is short for "(function foo)"
<Yehowshua>
ah
<moon-child>
not in all cases, of course. (let ((f (lambda (x) (* 2 x)))) (apply f '(3)))
<Bike>
which just looks up the variable as a function binding, rather than a regular value binding like you'd get from foo by itself
<Bike>
and yeah, you can still bind names to functions normally if you want
<moon-child>
in that case f is bound in the variable namespace, so you do not use #'
<lotuseater>
Yehowshua: I see why this seems odd to you :)
<Bike>
but we more often bind functions with the flet and labels special operators, which bind as functions
<Yehowshua>
yeah - was gonna stick with scheme - but i really needed smp threads - so common lisp it is
<Yehowshua>
well, specifically sbcl
Guest93 has quit [Ping timeout: 256 seconds]
<Yehowshua>
why does `(let ((f (lambda (x) (* 2 x)))) (apply f '(3)))` not need `#'` ?
<Bike>
because let just binds as a value
<Bike>
you can think of there being two environments, the "value" environment and the "function" environment
<Bike>
you bind in the value environment with let or let* or lambda abstraction, and access it with variable names; it's the same as scheme
<Bike>
names in the "function" environment are instead bound by flet or labels, and accessed with the FUNCTION operator i mentioned
kulernil has joined #commonlisp
<Bike>
the fact that the value you're binding with let happens to be a function doesn't mean let binds in the function environment instead
<Bike>
by flet or labels or macrolet*, now that i'm thinking about it
<Bike>
that's an asterisk like "i forgot to say something", not part of the operator name "macrolet"
<Yehowshua>
gonna take a moment to digest
<lotuseater>
take all the time you need :)
Yehowshua has quit [Quit: Client closed]
<Bike>
well, ok.
Yehowshua has joined #commonlisp
<Yehowshua>
I think I'll stick with (function myfunc) instead of #'myfunc
<Yehowshua>
less obscure
<Yehowshua>
also, `format` code is not super readable
<Bike>
as you like.
<moon-child>
nothing is readable if you do not know how to read it
<Bike>
pretty much all format operations can be done long form.
<Bike>
if you want.
<lotuseater>
moon-child: good point :D
<Bike>
like as macro forms and function calls and stuff i mean.
kulernil has quit [Remote host closed the connection]
<lotuseater>
Yehowshua: and the difference between FLET and LABELS is, with the former you define closures that are not aware of each other and with the latter some that are and can call each other recursively
<Bike>
it's let versus letrec.
kulernil has joined #commonlisp
kulernil has quit [Remote host closed the connection]
<Bike>
hm, what can you do with format that you can't do with another function call... print roman numerals, maybe
<beach>
Good morning everyone!
Yehowshua has quit [Ping timeout: 256 seconds]
Oladon has quit [Quit: Leaving.]
prxq has quit [Ping timeout: 240 seconds]
prxq has joined #commonlisp
<lotuseater>
Hello beach :)
Oladon has joined #commonlisp
semz has quit [Ping timeout: 250 seconds]
hafat has quit [Ping timeout: 240 seconds]
semz has joined #commonlisp
perrierjouet has joined #commonlisp
kakuhen has quit [Read error: Connection reset by peer]
kakuhen has joined #commonlisp
srhm has quit [Quit: Konversation terminated!]
Oladon has quit [Quit: Leaving.]
hafat has joined #commonlisp
hafat has quit [Ping timeout: 250 seconds]
taiju has quit [Ping timeout: 240 seconds]
taiju has joined #commonlisp
rain3 has joined #commonlisp
Bike has quit [Quit: Connection closed]
retropikzel has joined #commonlisp
<susam>
Good morning, beach, lotuseater! Good morning, everyone!
CrashTestDummy2 has joined #commonlisp
cross has quit [Ping timeout: 240 seconds]
cross has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
<beach>
Hello susam.
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 250 seconds]
selwyn has joined #commonlisp
retropikzel has quit [Ping timeout: 250 seconds]
retropikzel has joined #commonlisp
Lycurgus has joined #commonlisp
selwyn has quit [Quit: Leaving]
hafat has joined #commonlisp
vats has joined #commonlisp
retropikzel has quit [Ping timeout: 252 seconds]
retropikzel has joined #commonlisp
akoana has left #commonlisp [#commonlisp]
hendursa1 has joined #commonlisp
pve has joined #commonlisp
retropikzel has quit [Ping timeout: 250 seconds]
hendursaga has quit [Ping timeout: 276 seconds]
Lycurgus has quit [Quit: Exeunt]
gaqwas has joined #commonlisp
makomo has joined #commonlisp
akoana has joined #commonlisp
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 252 seconds]
retropikzel has joined #commonlisp
asarch has joined #commonlisp
retropikzel has quit [Ping timeout: 250 seconds]
cosimone has joined #commonlisp
gxt_ is now known as gxt
asarch has quit [Quit: Leaving]
cage has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
CrashTestDummy2 has quit [Ping timeout: 248 seconds]
hafat has quit [Ping timeout: 250 seconds]
psycomic has joined #commonlisp
cosimone has quit [Ping timeout: 250 seconds]
attila_lendvai has joined #commonlisp
waleee has joined #commonlisp
tyson2 has joined #commonlisp
frgo has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 248 seconds]
frgo has joined #commonlisp
amb007 has joined #commonlisp
dra has joined #commonlisp
cosimone has joined #commonlisp
esb has quit [Ping timeout: 240 seconds]
igemnace has quit [Quit: WeeChat 3.2]
dra has quit [Ping timeout: 240 seconds]
hafat has joined #commonlisp
hafat has quit [Client Quit]
Qwnavery has joined #commonlisp
cosimone has quit [Ping timeout: 240 seconds]
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
kakuhen has quit [Quit: Leaving...]
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #commonlisp
taiju has quit [Ping timeout: 240 seconds]
taiju has joined #commonlisp
random-nick has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.2]
perrierjouet has joined #commonlisp
vats has quit [Ping timeout: 240 seconds]
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
amb007 has quit [Read error: Connection reset by peer]
Qwnavery has quit [Ping timeout: 248 seconds]
amb007 has joined #commonlisp
selwyn has joined #commonlisp
Qwnavery has joined #commonlisp
Qwnavery has quit [Client Quit]
shka has joined #commonlisp
PinealGlandOptic has joined #commonlisp
taiju has quit [Ping timeout: 250 seconds]
taiju has joined #commonlisp
<lotuseater>
How is your opinion to using DO, DOLIST and friends?
<mfiano>
Is there a format directive for numeric ordinals instead of words?
<beach>
I decided early on to use LOOP exclusively for SICL, because I think it is much more readable than the others.
<beach>
lotuseater: ↑
yitzi has joined #commonlisp
<beach>
lotuseater: That is also why LOOP was one of the first SICL modules I implemented.
<lotuseater>
beach: okay I thought something like that :)
<beach>
lotuseater: I don't really understand the argument that LOOP is not "Lispy". I mean, that sounds like the essence of Lisp is about parentheses, which is a bit simplistic.
<mfiano>
It appears not.
<lotuseater>
I like LOOP, too. And must admit I got into touch with it before really getting how to use DO, DOLIST correctly.
<lotuseater>
And it's good the keywords can be given as real keywords. :)
<lotuseater>
mfiano: Could you explain (for me) a bit more the numeric ordinals and words? Just that I get it right.
* mfiano
rolls his ownfirst vs 1st, 2nd vs second, etc
<mfiano>
i roleld my own
<mfiano>
sorry, i'm, all over the keyboard today :/
<lotuseater>
cool
<lotuseater>
ah no problem :)
<semz>
mfiano: ~:R
<mfiano>
That is for ordinal words
<lotuseater>
there is still much of FORMAT I'm not well aware of (or have not yet practiced enough)
<semz>
oh I see
<lotuseater>
ah that
<mfiano>
(let ((x 1051)) (format nil "~d~:[~[th~;st~;nd~;rd~:;th~]~;th~]" x (< (mod (- x 10) 100) 10) (mod x 10)))
<semz>
ow
<mfiano>
i guess you could unroll the loop and lexically bind each step, or use LOOP but the power of the concise format DSL wins for this
<lotuseater>
maybe in an extensible FORMAT this could support other languages :)
<semz>
beach: I think it's not so much about parentheses as it's about the way LOOP clauses are not a single form and the lack of extensibility.
attila_lendvai_ has joined #commonlisp
<beach>
DO is extensible?
<semz>
DO doesn't have any arbitrary restrictions as far as I can tell
<semz>
(at a price however)
<semz>
as much as I've come to like LOOP over time, ":when condition :collect expr :else :do thing" still looks out of place to me
<mfiano>
Then use the synonym :if
<semz>
:if has the same issue
<mfiano>
I don't see the issue
<lotuseater>
it's an issue?
<semz>
"issue", it's purely a bikeshed^W style question
<akater[m]>
lotuseater: `dolist` is simple. OTOH, I still don't know how to use or read `do`. I read and write a considerable amount of Elisp, and I encounter `do` extremely infrequently, unlike `loop` or `dolist`.
<mfiano>
The only issue I have with loop is it's horizontal space wastage 3 dimensional iterations.
<semz>
but with (if _ _ _), everything related to the if is a subform, whereas in LOOP everything is just randomly strewn across the LOOP form itself
<lotuseater>
akater[m]: yes okay that is the simple one
* mfiano
waits for the inevitable Iterate discussion, where he will go back to code
<mfiano>
LOOP is one of the most Lispy things we have.
alendvai__ has joined #commonlisp
<beach>
There is an argument in favor of DOLIST when it is applicable, namely that it is the most specific construct that will get the job done when it is applicable.
<lotuseater>
and i saw via macroexpansion a difference between SBCL and CCL LOOP: when defining an iterator with ":for i" the former states (declare (type real i)), the latter (declare (type number i))
<beach>
lotuseater: Don't they both use MIT LOOP? I wonder why that declaration is even necessary given the type inference.
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<lotuseater>
I don't know. SBCL has its SB-LOOP module.
attila_lendvai has quit [Ping timeout: 250 seconds]
<beach>
Yes, but I think it is a slightly modified version of MIT LOOP.
<beach>
I must have written something about that in my early paper on SICL LOOP.
<lotuseater>
I had it already saved with the other in my CommonLisp/SICL folder.
gaqwas has quit [Ping timeout: 248 seconds]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
alendvai__ has quit [Quit: Leaving]
attila_lendvai has joined #commonlisp
attila_lendvai has quit [Quit: Leaving]
attila_lendvai has joined #commonlisp
lisp123 has joined #commonlisp
<lisp123>
A puzzle for you
<lisp123>
Write a macro (without using any reader macros) such that any expression of the form abcd.slot is converted to (obj-type-of-abcd-slot abcd)
<lisp123>
Can it be done?
<lisp123>
(and don't shoot me for suggesting it ;)!)
<beach>
Why would you want such a thing in the first place? Slots are implementation details that should be used only in class definitions.
<lisp123>
Not something I suggest, but just curious if its possible (also I prefaced not to shoot the messenger ;))
<mfiano>
It wouldn't be Lisp
<lisp123>
But can it be done (its a puzzle)
<mfiano>
( is a reader macro dispatch character
<beach>
In fact, I can see only two reasons why slots have names in the first place. One is when a DEFCLASS form is re-evaluated, it must mention the same slot as before, and another one is that to mention the same slot in a subclass, it also has to be the same name.
<beach>
<mfiano>
beach: And it greatly annoys me that SBCL warns about slot name package variance
<beach>
Ah, yes, I can see why.
<beach>
... why it annoys you, I mean.
<mfiano>
You get a style warning if 2 slots have the same SYMBOL-NAME. Uhh, isn't that what packages are for?
<beach>
Exactly, I totally agree.
<mfiano>
I used to use uninterned symbols for classes, and i stopped when SBCL filled my compile log up
<mfiano>
class slots*
<mfiano>
because they are, as you put it, implementation details
<beach>
Heh, interesting, I thought about using uninterned symbols for slot names, but that's when I realized the two reasons I mentioned.
<lisp123>
Is that because the symbol associated with :accessor for a slot is relevant?
<lisp123>
(that's why the slot name is not relevant)?
<mfiano>
Not :accessor, but any accessor
<lisp123>
mfiano: Gotcha
<mfiano>
There are reader and writer accessors as well, and a lot does not need to have just 1 accessor. it may have 0 or more
<mfiano>
s/lot/slot/
<lisp123>
Okay to clarify my puzzle (I was trying to obscure the references to other languages ;)), if I some code such as this.slot -> can it be converted to (accessor this)
<beach>
lisp123: Sort of. It's because accessors generate methods that are part of the protocol for a module, so they can be removed as accessors, and implemented differently without changing client code.
<mfiano>
Infact it really gets on my nerves when people use symbol names for slot names that have been exported, usually the same name as their accessors.
<beach>
lisp123: But once you use a slot, you have committed to an implementation detail.
<mfiano>
This is a big hole in your user API
<lisp123>
beach: Ah yes, that makes perfect sense
<lisp123>
mfiano: I tend to do classname-slotname for accessors
<mfiano>
lisp123: Sure just use ppcre or something. symbols have a string representation to manipulate any way you please, and construct whatever secondary data structure you want from that information
<mfiano>
Please stop
<mfiano>
Use packages
<mfiano>
That conflicts with a well-designed generic function protocol
<beach>
lisp123: I agree with mfiano.
<lisp123>
Oh I thought it was recommended practice (forgot where I read it)
<beach>
lisp123: It is used on older Common Lisp code, and I am guessing that the package system wasn't very well developed at the time, or at least not used so much. Why, I don't know.
<lisp123>
I see, thanks
<mfiano>
People new to Lisp get confused about packages and why they are so useful. Not too many other languages have anything like it.
<lisp123>
Yes, I remember getting confused for a while
<beach>
lisp123: Conventions evolve (slowly), but they do evolve. Often, it is impossibly to find the reason for a convention, and there may not be a rational reason for some conventions.
elf_fortrez has joined #commonlisp
<lisp123>
beach: Agreed. Its a combination of good ideas and also widely accepted practice which is too much to change (for not enough benefit)
<beach>
It's the same in natural languages. There is no particular reason for using "tooth brush" and "dental floss" over "dental brush" and "tooth floss".
<mfiano>
With package-local nicknames being a defacto standard now, there's really no reason to create verbose calling conventions or other hacks that languages without real packages have.
<lotuseater>
lisp123: and note the reader can't read "backwards". correct me please if I'm wrong but someone very capable made this clear to me some weeks ago
<beach>
lisp123: I know you excluded reader macros, but if you really want to translate code in a different language, you might consider using Eclector which has configuration hooks for how tokens are interpreted.
<mfiano>
beach told me about a parser of his that keeps a look-behind buffer or some such.
<mfiano>
I don't recall the details
<beach>
lisp123: Heh, thank you I guess.
<lisp123>
I increased my usage of cond a lot since reading it :)
<lisp123>
lotuseater: That's my understanding too
<lisp123>
So with the puzzle, it would require runtime reading of what type of obj "this" is - can this be done by a macro?
<lotuseater>
lisp123: I meant if some construct is finally and successfully read in and expanded in the normal case the information is not accessible anymore how exactly it came into existence.
<beach>
lisp123: I guess the link is owned by one of my former students. One of the few in his group who understood the value of Common Lisp.
<beach>
lisp123: I mean, I hope you realize that I am the author of that document.
<lisp123>
beach: Yes of course :)
amb007 has quit [Ping timeout: 252 seconds]
<mfiano>
and speaking of packages, and having been forced to work with blub languages lately, I have really come to appreciate them more. The cognitive break caused by file-level namespaces and imports is a chore when hopping around codebases, especially by people with no convention in place, and often the same objects are referenced with different prefices or even names in different files. It's insane.
<lotuseater>
lisp123: did we already talk sometime about SYMBOL-MACROLET?
<lotuseater>
even in Haskell this is weird, it goes by file names and paths or must be as a package by one of the management systems
<lisp123>
lotuseater: I don't recall, but I just had a look. Looks cool
<lotuseater>
lisp123: it saves you sometimes too much repetition and a headache
retropikzel has joined #commonlisp
<lisp123>
lotuseater: yes it seems like a nice and easy way to write less code, will play around with it
<mfiano>
Ah, the old problem with the Internet that anyone can try to be an authoratative source. No wonder I never heard of that "style guide".
<lisp123>
(p.s. I do try and keep my code as standard as possible, despite what may be implied here ;)
<lisp123>
semz
VincentVega has joined #commonlisp
<mfiano>
I just read that "style guide" anyway, and I would definitely not recommend following it for several reasons.
<semz>
lisp123: hm?
raeda_ has joined #commonlisp
raeda has quit [Remote host closed the connection]
selwyn has quit [Read error: Connection reset by peer]
<lotuseater>
even Google has a style guide for CL
dekks has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
<pjb>
beach: lotuseater: it's not that LOOP is not lispy. It's that it's harder to parse (correctly), and to infer its semantics (correctly and conformingly; there are also enoug implementation specific parts in LOOP). On the other hand, DO, DO*, DOTIMES, DOLIST have very simple syntax and semantics, so they can be processed automatically (in macros or tools) more easily.
<pjb>
So I would say, that yes, they're more lispy than loop, because you can more easily process correctly them using simple lisp list-processing functions.
srhm has joined #commonlisp
<mfiano>
I disagree.
<pjb>
But LOOP is convenient. Also, loop with let you eat the surrounding LET forms.
<pjb>
LOOP WITH lets you…
selwyn has joined #commonlisp
dekks is now known as _brummie
<loke[m]>
mfiano: It
<mfiano>
There are few other notable exemplary pieces of software that highlights the macro extensibility of the language. not to mention, built it, and loved or hated by everyone that uses the language.
<loke[m]>
mfiano: That style guide is very short, and mostly contains non-controversial things like "use WHEN instead of IF when you don't have an else part"
<loke[m]>
mfiano: Only controversial part is the "use one file per package". That one is just stupid. Anyway, it's a waste of time.
Cymew has joined #commonlisp
<mfiano>
It also contradicts itself, and the brevity does not do itself very well when suggesting IMPORT-FROM over USE, rather than well agreed upon alternatives.
yitzi has quit [Quit: Leaving]
<VincentVega>
It's how 'x₀ 'x0 are eql. Same for the superscript. I know about case-insensetivity, but this looks somewhat different, doesn't it? I am wondering if I can expect this behavior everywhere else besides SBCL (well, where unicode is supported anyhow). The reason I am asking is I am making a lambda reader macro, like the #` in LOL, except I was going to be using subscripts, because symbols like x0 are just ugly af.
<mfiano>
That is an SBCL feature. You can turn it off if you want.
<mfiano>
You cannot expect it everywhere.
<VincentVega>
mfiano: fr, any idea what's it called?
cross has quit [Quit: leaving]
<mfiano>
See 7.1.2 of the manual
cross has joined #commonlisp
<VincentVega>
mfiano: thanks!
lisp123_ has joined #commonlisp
elf-fortrez has joined #commonlisp
tyson2 has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
Guest40 has joined #commonlisp
<borodust>
MetaYan: :drawin should be fixed now across borodust projects
<VincentVega>
So, why does SBCL need symbol normalization? When is it useful exactly? Nice to have for visually equivalent characters, but what else? SBCL uses NFKC, and I want to disable it to use subscripts, but I am not sure what I might be losing here.
gaqwas has joined #commonlisp
_brummie has quit [Quit: WeeChat 3.0]
srhm has quit [Read error: Connection reset by peer]
srhm has joined #commonlisp
khrbt has quit [Ping timeout: 248 seconds]
PinealGlandOptic is now known as Everyone
<mfiano>
Mostly for unambiguous reading of text. Us Lisp programmers prefr to write out descriptive names for things, except those using April perhaps :)
<mfiano>
Also stream safety is another reason
Everyone is now known as Everything
Everything has quit [Quit: leaving]
<VincentVega>
mfiano: stream safety? Sorry, I feel a bit lost here.
Everything has joined #commonlisp
<lotuseater>
mfiano: haha ^^
<jcowan>
VincentVega: I'm not sure why you would want x0 and x sub 0 to be distinct: surely the first is a typographically imperfect use of the second. I could see it if you also wanted to use superscripts.
<VincentVega>
jcowan: only to enforce the same usage project-wise, subscripts being created by a lambda-creating reader macro, but other than that I do agree with you.
<VincentVega>
jcowan: otherwise it's on the maintainer, which maybe isn't a big a deal
<VincentVega>
of course, a decent alternative is to hack emacs to show x0 as x sub 0, doesn't sound so bad in fact...
<VincentVega>
actually, I think I'mma go with the the emacs way, thanks all
recordgroovy has quit [Ping timeout: 248 seconds]
<lisp123_>
VincentVega: How would you go about doin gthat?
<lisp123_>
I could only guess you would have to change the font characters being pointed to, but I am genuinely curious on how you would do that as I assume any change to the actual text would then feed through? Unless you are going to write a parser in Emacs that reads the input before sending it to SLIME/SWANK
<lisp123_>
(which doesn't sound that easy once you start working with compiled files)
<VincentVega>
lisp123_: with faces, it should actually be pretty simple
<VincentVega>
lisp123_: it doesn't modify files, just the appearance of text
<lisp123_>
VincentVega: Would love to see the code once you are done with it, if you don't mind :)
<lisp123_>
I didn't know you could replace character maps with font-lock-face
<semz>
buffer-display-table is also nice for that, I use Xah Lee's thing to render ^L (form feed) as a long line for instance
<VincentVega>
lisp123_: no prob, I am working on it now, will share it once working.
<VincentVega>
semz: sounds interesting, will check it out now
<lisp123_>
semz: Nice one, looks pretty useful
<lisp123_>
VincentVega: Thanks :)
attila_lendvai has quit [Quit: Leaving]
Guest40 has quit [Quit: Client closed]
selwyn has quit [Read error: Connection reset by peer]
retropikzel has quit [Ping timeout: 250 seconds]
sjl has joined #commonlisp
khrbt has joined #commonlisp
aeth has quit [Ping timeout: 250 seconds]
notzmv has quit [Ping timeout: 240 seconds]
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
aeth has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
elf-fortrez has quit [Quit: Client closed]
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
attila_lendvai_ has quit [Quit: Leaving]
attila_lendvai has joined #commonlisp
Lycurgus has joined #commonlisp
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
notzmv has joined #commonlisp
peterhil has quit [Ping timeout: 252 seconds]
<jmercouris>
mfiano: i looked in the manual but couldn’t find what you meant
<jmercouris>
I want to profile a single call
<jmercouris>
And all of the things it calls
<jmercouris>
Anyone know of a way to do that in sbcl?
<jmercouris>
Flame graph doesn’t work in recent SBCLs
<jmercouris>
Maybe I’ll ask on #sbcl
Duuqnd has joined #commonlisp
<VincentVega>
Well, here's what I got so far: https://pastebin.com/HsDS4Vm4. You are probably right about it not being possible to do text replacement with font faces, not unless one loads a custom font, I think, where the 0 is replaced with ₀. Well, maybe. However, I thought that since the text lenght doesn't change, it should have been easy to do, as a special case. buffer-display-table seems to be only for characters, which would work
<VincentVega>
if it could account for context, which I don't think it can. The obvious other option is overlays and that's what the link does, but it's annoying in several ways, which I think may be fixed however...
<VincentVega>
lisp123_: ^
rinwa has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
psycomic has quit [Remote host closed the connection]
psycomic has joined #commonlisp
cosimone has joined #commonlisp
karlosz has joined #commonlisp
karlosz has quit [Read error: Connection reset by peer]
karlosz_ has joined #commonlisp
cosimone has quit [Ping timeout: 250 seconds]
akoana has left #commonlisp [#commonlisp]
rain3 has quit [Remote host closed the connection]
rain3 has joined #commonlisp
Everything is now known as Everyone
Everyone has quit [Quit: leaving]
rain3 has quit [Ping timeout: 240 seconds]
karlosz_ has quit [Quit: karlosz_]
notzmv has quit [Ping timeout: 240 seconds]
<lisp123_>
VincentVega: Cheers!
<lisp123_>
VincentVega: I will experiment as well and let you know if I find something elegant
selwyn has joined #commonlisp
selwyn has quit [Remote host closed the connection]
<lisp123_>
I was looking at org mode, since they do something similar too
<lisp123_>
org pretty entities or something. Also perhaps worth seeing if one can create a custom face and use subscript face in these cases (where a number is at the end of a word)
<lisp123_>
Is there a way to extract which file a function is defined in from a live image?
<lisp123_>
I guess one could do it by leveraging slime, but wonder if its something that can be done more generally by an implementation - is the file information passed into the image
<moon-child>
what if the function was not defined in a file?
<lisp123_>
Then it could return nil or something
<lotuseater>
in SBCL if you define and compile/load a function from a file, then call DESCRIBE on it it gives you also the path of the file where it lives
<lisp123_>
lotuseater: Great!
perrierjouet has joined #commonlisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #commonlisp
<pjb>
lisp123_: in general, functions are not defined in files. functions are defined by evaluating a lambda expression. Usually those lambda expressions are produced by a macro, such as defun, defgeneric, defmethod, defmacro, and others.
<pjb>
lisp123_: those macros expressions are often read from files, but they can also very often be generated by other macros.
<moon-child>
pjb: sure, but we may associate a 'location' with such a lambda expression
<moon-child>
this location is used for error reporting, for instance
<moon-child>
in which respect I think it is meaningful to speak of a function's being 'defined' in a file
perrierjouet has quit [Quit: WeeChat 3.2]
<pjb>
lisp123_: There's nothing standard about that. There may be implementation specific APIs to do some approximation of that.
<lisp123_>
pjb: Thanks
perrierjouet has joined #commonlisp
psycomic has quit [Read error: Connection reset by peer]
dra has joined #commonlisp
gaqwas has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 250 seconds]
VincentV` has joined #commonlisp
VincentVega has quit [Ping timeout: 252 seconds]
shka has quit [Ping timeout: 250 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
tyson2 has joined #commonlisp
Oladon has joined #commonlisp
khrbt has quit [Ping timeout: 250 seconds]
<lotuseater>
lisp123_: "So what is this Common Lisp you speak of?" ^^
edgar-rft is now known as world
khrbt has joined #commonlisp
world is now known as edgar-rft
asarch has joined #commonlisp
pve has quit [Quit: leaving]
Duuqnd has quit [Quit: Leaving]
VincentV` has quit [Remote host closed the connection]
VincentV` has joined #commonlisp
lisp123_ has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123_ has joined #commonlisp
lisp123 has quit [Ping timeout: 250 seconds]
srhm has quit [Quit: Konversation terminated!]
srhm has joined #commonlisp
srhm has quit [Read error: Connection reset by peer]
srhm has joined #commonlisp
asarch_ has joined #commonlisp
asarch has quit [Ping timeout: 250 seconds]
asarch_ is now known as asarch
lisp123_ has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
xlei has quit [Read error: Connection reset by peer]
<VincentV`>
lisp123: I did it : )
taiju has quit [Ping timeout: 240 seconds]
taiju has joined #commonlisp
lisp123 has quit [Read error: Connection reset by peer]
kevingal has joined #commonlisp
xlei has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
dra has quit [Quit: Leaving]
taiju has quit [Ping timeout: 250 seconds]
VincentV` has quit [Remote host closed the connection]
taiju has joined #commonlisp
VincentV` has joined #commonlisp
selwyn has quit [Quit: Leaving]
cjb has joined #commonlisp
lisp123 has joined #commonlisp
asarch_ has joined #commonlisp
asarch has quit [Ping timeout: 240 seconds]
sander has quit [Ping timeout: 240 seconds]
sander has joined #commonlisp
kagevf has quit [Ping timeout: 240 seconds]
Noisytoot has quit [Ping timeout: 240 seconds]
kagevf has joined #commonlisp
asarch_ has quit [Ping timeout: 240 seconds]
Noisytoot has joined #commonlisp
<MetaYan>
borodust: Great!
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
jgkamat has quit [Ping timeout: 240 seconds]
jgkamat has joined #commonlisp
jgkamat has quit [Remote host closed the connection]
jgkamat has joined #commonlisp
lisp123 has quit [Ping timeout: 250 seconds]
attila_lendvai has quit [Ping timeout: 252 seconds]
yitzi has joined #commonlisp
kevingal has quit [Remote host closed the connection]