themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
dale has quit [Quit: dale]
ktp has left #lisp [#lisp]
karlosz has quit [Quit: karlosz]
caltelt_ has quit [Ping timeout: 246 seconds]
nullheroes has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 252 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Fare has joined #lisp
chipolux has quit [Ping timeout: 250 seconds]
chipolux has joined #lisp
lumm has quit [Quit: lumm]
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #lisp
jmercouris has quit [Remote host closed the connection]
nullheroes has quit [Quit: WeeChat 2.3]
rozenglass has quit [Ping timeout: 255 seconds]
ktp has joined #lisp
ktp is now known as ktp[A]
ktp[A] is now known as ktp
ktp has left #lisp [#lisp]
marusich has joined #lisp
Aruseus has joined #lisp
nullheroes has joined #lisp
Essadon has quit [Quit: Qutting]
Fare has quit [Ping timeout: 246 seconds]
<White_Flame>
are there any pseudo standards on make-* vs create-* for function names?
<White_Flame>
I realize our older codebase has both, and that's slightly annoying
Kaisyu7 has quit [Ping timeout: 240 seconds]
<Bike>
id' stick with one, but otherwise i'm not aware of any standard
nullheroes has quit [Quit: WeeChat 2.3]
ktp has joined #lisp
nullheroes has joined #lisp
<aeth>
White_Flame: make-foo seems to be more common and standard at least ime
techquila has joined #lisp
<aeth>
standard in the sense that it's in the standard, while there's no create-TAB tab completions for me
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
<ktp>
/part
ktp has quit [Quit: I cna ytpe 300 wrods pre mniuet!!!]
techquila has quit [Max SendQ exceeded]
grewal has left #lisp [#lisp]
techquila has joined #lisp
techquila has quit [Max SendQ exceeded]
techquila has joined #lisp
techquila has quit [Max SendQ exceeded]
techquila has joined #lisp
akater has quit [Quit: WeeChat 2.3]
gigetoo has quit [Ping timeout: 268 seconds]
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
robdog has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
akater has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
robdog has joined #lisp
jeosol has quit [Ping timeout: 256 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
nullheroes has quit [Quit: WeeChat 2.3]
robdog has quit [Ping timeout: 250 seconds]
nullheroes has joined #lisp
robdog has joined #lisp
nullheroes has quit [Quit: WeeChat 2.3]
robdog has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
nullheroes has joined #lisp
nullheroes has quit [Read error: Connection reset by peer]
nullheroes has joined #lisp
Fare has joined #lisp
ym555 has quit [Ping timeout: 255 seconds]
anewuser has quit [Ping timeout: 250 seconds]
<pjb>
White_Flame: in the CL package, there's no function name prefixed by create-, but there are prefixed by make-.
caltelt has joined #lisp
gigetoo has joined #lisp
dddddd has quit [Read error: Connection reset by peer]
jeosol_ has joined #lisp
_whitelogger has joined #lisp
ktp has joined #lisp
varjag has joined #lisp
ktp has quit [Quit: It's a dud! It's a dud! It's a du...]
elderK has joined #lisp
varjag has quit [Ping timeout: 250 seconds]
pjb has quit [Write error: Connection reset by peer]
pjb has joined #lisp
Bike has quit [Quit: Lost terminal]
ebrasca has quit [Remote host closed the connection]
<PuercoPop>
jasom: are you asking about SICL because you want to compile to JS? I remember you tried to get Eclipse CL to compile under ecmascripten
sauvin has joined #lisp
pankajgodbole has joined #lisp
vibs29 has quit [Ping timeout: 250 seconds]
mejja has quit [Quit: mejja]
ebrasca has joined #lisp
vibs29 has joined #lisp
ktp has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
PuercoPope has joined #lisp
keep_learning_M has quit [Ping timeout: 250 seconds]
|3b|` is now known as |3b|
arescorpio has joined #lisp
keep_learning_M has joined #lisp
caltelt_ has joined #lisp
ktp has quit [Quit: Light travels faster then sound, which is why some people appear bright, until you hear them speak]
rippa has joined #lisp
<beach>
Good morning everyone!
polezaivsani has quit [Remote host closed the connection]
gravicappa has joined #lisp
<beach>
jasom: As Bike said, you can translate HIR to basically any language. But you need a Common Lisp runtime to run it.
karlosz has quit [Quit: karlosz]
nalkri has joined #lisp
fouric has quit [Ping timeout: 268 seconds]
<ebrasca>
beach: Hi
xws has joined #lisp
wxie has quit [Ping timeout: 250 seconds]
xws is now known as wxie
<beach>
jasom: The HIR to Common Lisp translator uses only a small subset of Common Lisp as its target language, because HIR is such low level. The full Common Lisp language is still available as source in order to generate the HIR.
<PuercoPope>
beach: where can I find out which subset it depends on?
robdog has joined #lisp
<beach>
I am not sure how to answer that.
Guest29409 has joined #lisp
<Guest29409>
hello, Lisp!
<beach>
Hello Guest29409.
<jeosol_>
morning
robdog has quit [Ping timeout: 250 seconds]
<beach>
PuercoPope: I could use the full language if I had to, because I execute the HIR code inside a host Common Lisp system. However, the HIR instructions have a kind of natural translation to a small subset of Common Lisp. At the top level, there is a big TAGBODY where each label represents the start of a basic block.
<beach>
PuercoPope: So it's not that it has to be a subset, which is why I never bothered to define it precisely.
Fare has quit [Ping timeout: 246 seconds]
Guest29409 has quit [Ping timeout: 255 seconds]
aru_ has joined #lisp
aru_ has quit [Remote host closed the connection]
Aruseus has quit [Ping timeout: 255 seconds]
arescorpio has quit [Quit: Leaving.]
karlosz has joined #lisp
<PuercoPope>
beach: More than the operators the datatypes could be troublesome. CL supports for example bit-vectors, which I would think one would want to avoid having to implement in the target language
PuercoPope has quit [Remote host closed the connection]
<beach>
PuercoPop: I really haven't given it any thought since the purpose of SICL is not to have a target language other than native machine code.
<beach>
I had assumed you programmed in Common Lisp.
Fare has joined #lisp
didi has joined #lisp
karlosz has quit [Quit: karlosz]
JohnMS_WORK has joined #lisp
pankajgodbole has quit [Ping timeout: 250 seconds]
<didi>
So I'm wondering: I have a function (FN) that consumes a static object (made of ordinary lisp objects) to produce an object. As it consumes a static object, this computation can be made during compilation. I see 3 ways of doing it: 1. define a macro that returns a computed object (defmacro mfn (x) (fn x)); 2. define a dispatch macro character that do the same thing as the macro; and 3. use #. to compute the object in read time #.(fn
<didi>
x). Which option sounds the better?
techquila has joined #lisp
techquila has quit [Max SendQ exceeded]
shka_ has joined #lisp
techquila has joined #lisp
techquila has quit [Max SendQ exceeded]
techquila has joined #lisp
<gilberth>
didi: When that is a function and should be function, I would consider a compiler macro.
<didi>
gilberth: Thank you.
<didi>
I guess this isn't the time I'll finally use a dispatch macro.
<didi>
Well, define one.
dale has joined #lisp
<gilberth>
Well, that would be strange solution IMHO.
<didi>
gilberth: I got the idea from languages (like Python and Racket) that define a special syntax for regular expressions.
<gilberth>
I have no idea of the nature of the arguments passed to your FN function. But a compiler macro also could bail out and say "Sorry, compiler I cannot do this at compile time, seek to invoke the function at runtime, please."
<didi>
gilberth: Strings, keywords and lists.
<didi>
I'll read about compiler macros. I'm unfamiliar with those. Thank you again.
<gilberth>
As I said, I have no idea, what your function does. When it turns an external representation into some internal representation though, a reader macro would be fine. Like I used #u"http://foo.com/blah" in my URL library or #/a and #"foo" in my runes library.
<gilberth>
Or like #p"..." is used in CL itself.
Ukari has quit [Remote host closed the connection]
<didi>
gilberth: Indeed. There is no need for secrecy. It reads a regular expression representation and returns an object that is used for matching, just list PPCRE's parse-tree.
Ukari has joined #lisp
<didi>
So in PPCRE parlance, (create-scanner :everything), for example.
<gilberth>
didi: OK.
<gilberth>
Then it is a matter of taste, if you ask me.
<didi>
gilberth: If pressed, what would you choose?
<gilberth>
I always hesitate to define new syntax. Because it easily conflicts with other libraries and you hae issues, that you need to ensure that the read table is set up correctly for files using the stuff. These days. I was fond of reader macros 20 years ago, though.
<didi>
I see. Thank you, gilberth.
<gilberth>
IMHO a macro like (foo (fancy-iteration (or "a" "b"))) would be fine. For completeness you could also have a FOO*, which evaluates the argument. Or: You define a FOO function, which then needs the argument quoted and go with a compiler compiler macro and ask for CONSTANTPness and bail out otherwise by returning the &whole form.
<didi>
gilberth: Uh, interesting. I'll think about these ideas. Thank you.
<gilberth>
Not having the option to build a FOO with an evaluated argument would be bad though. See parenscript for instance. We recently had that discussion right here.
<didi>
gilberth: Agreed. The function exists and I won't get rid of it. Like I said, I remembered the special syntax for regular expressions and thought it would be a neat optimization for constant regexps.
<gilberth>
Minor point: What you construct must be loadable though. See: MAKE-LOAD-FORM
<didi>
gilberth: I will. Thank you.
* gilberth
scratches his head.
<gilberth>
Heh, this will go in circles. :-)
Fare has quit [Ping timeout: 250 seconds]
nowhere_man has joined #lisp
<gilberth>
didi: Also see LOAD-TIME-VALUE.
<didi>
gilberth: I will.
robdog has joined #lisp
<gilberth>
It could be as simple as (define-compiler-macro fn (x &whole w) (if (constantp x) `(load-time-value (fn ,x)) w))
<gilberth>
IMHO, if I am not mistaken now.
marusich has quit [Ping timeout: 246 seconds]
ym has quit [Ping timeout: 255 seconds]
techquila has quit [Ping timeout: 246 seconds]
ym has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
<didi>
Heh, my ignorance of load time vs. compile time vs. run time has finally showed its ugly head.
robdog_ has quit [Ping timeout: 250 seconds]
<gilberth>
didi: :-(
<gilberth>
didi: It will not be as easy as outlined, I justed tried it. My compiler macro goes into an infinite loop at compile time.
<didi>
Nah, no worries. I'll brawl with it alright.
<gilberth>
didi: Well, I guess I gave you the right pointers. You sure will figure it out.
<didi>
gilberth: Thank you.
marusich has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
nalkri has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
robdog has quit [Ping timeout: 250 seconds]
dale has quit [Quit: dale]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
marusich has quit [Remote host closed the connection]
trafaret1 has quit [Read error: Connection reset by peer]
elazul has quit [Ping timeout: 272 seconds]
klltkr has joined #lisp
nanoz has joined #lisp
Achylles has quit [Remote host closed the connection]
vibs29 has quit [Ping timeout: 272 seconds]
vibs29 has joined #lisp
smasta has joined #lisp
cmack has quit [Read error: Connection reset by peer]
smasta has quit [Ping timeout: 272 seconds]
ym555 has quit [Ping timeout: 246 seconds]
smasta has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
smasta has quit [Ping timeout: 246 seconds]
lucasb has joined #lisp
FreeBirdLjj has quit [Ping timeout: 250 seconds]
<akater>
Is there a way to ediff Lisp code in emacs ignoring differences like #:G40 vs #:G125 and #<OBJECT {42}> vs #<OBJECT {BEEF}>? I'm asking here because this looks fairly CL-specific. I know there's ediff-diff-options but maybe there is an estabilished solution already.
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
Essadon has joined #lisp
<phoe>
akater: unreadable objects shouldn't be present in Lisp code
<phoe>
mostly because the Lisp reader will choke when trying to read the file
<phoe>
same with gensyms like #:G40 - they are useless when they are in Lisp code because they stop having their only reason to live, equality
<phoe>
so the question I'd ask is: why did you end up with code that has unreadable objects or uninterned symbols?
<spacedbat>
diffing two macroexpansions sounds useful
<akater>
phoe: I have lots of functions that generate code (that is never meant to be read, of course). Want to compare the output before and after modifications to said functions are made.
<phoe>
akater: I see. In that case, you might want to rebind *GENSYM-COUNTER* so the gensyms are printed in a similar (hopefully) manner.
<phoe>
As for unreadable objects, macroexpansions should not contain them as a matter of style and copypasting macroexpansions as text.
<phoe>
"should", as in, programmers should design their macros that way.
<akater>
phoe: I actually use my own counters. Conflating symbols' representations would clearly be a mere short-term solution in my case. Many different symbols will only differ in counters.
alecigne has joined #lisp
alecigne has left #lisp [#lisp]
<phoe>
In that case, I have no idea. I wonder if some CL code could be written to walk the resulting tree and properly highlight the differences.
<makomo>
i was wondering the same thing myself a couple of days ago
<makomo>
one especially annoying thing when working with CL and Git are the usual line-based diffs which pick up all the whitespace/indentation changes that were made. removing a single form could result in a whole lot of whitespace change
<makomo>
you can tell Git to ignore whitespace differences, but it's not bulletproof
<makomo>
the diffs still look crappy
<makomo>
the conclusion was that a proper tree-based diffing tool would be awesome, but i have no idea how it would work
smasta has quit [Ping timeout: 272 seconds]
<makomo>
you could just check the structure of the tree of course, but i wonder if there are cases where you'd like something "smarter"
FreeBirdLjj has joined #lisp
<akater>
makomo: Yes, the same sexp being on a different line triggers a diff, that's a bummer.
<makomo>
once that's solved, i suppose it wouldn't be too hard to treat gensyms as always equal, etc.
<akater>
I had a nice graphical diff in Mathematica. It would show common part of the tree unchanged and diffs marked in red in the appropriate tree nodes.
<akater>
This requires a graphical front-end, of course.
<pjb>
This is the closest to what you want, already implemented.
<pjb>
Notice how you need to unify the gensyms, to deal correctly with the repeatitions and circularities.
<pjb>
Also, tree-difference only walks conses. gensyms can be inserted into vectors and possibly other literal objects with macros, so you would have to walk inside them too.
<pjb>
It's a very specific question.
FreeBirdLjj has quit [Remote host closed the connection]
nowhere_man has joined #lisp
klltkr has quit [Remote host closed the connection]
robdog has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
pankajgodbole has quit [Ping timeout: 250 seconds]
pierpal has joined #lisp
smasta has joined #lisp
FreeBirdLjj has joined #lisp
<makomo>
is there a way to force ASDF to recompile all dependencies of a system as well? (asdf:load-system :something :force t) only forces the recompilation of the system :something
<makomo>
it will recompile dependencies only if a change is detected, but not unconditionally
<makomo>
(while the recompilation of :something is done unconditionally)
robdog has quit [Ping timeout: 250 seconds]
<pjb>
makomo: rm -rf ~/.cache/common-lisp/*
<makomo>
well yeah, aside from that
smasta has quit [Ping timeout: 250 seconds]
<pjb>
I don't know. Check the asdf user manual (which exists and is nice).
<phoe>
makomo: is there a way to get a list of all dependencies, direct and indirect, of a system?
<makomo>
phoe: hm, i guess there ought to be a function within asdf that can do that
<makomo>
pjb: i did check it before but haven't found a solution to this problem yet
<phoe>
makomo: you could perhaps do that by calling #'asdf:system-depends-on and #'asdf:find-system over and over
<phoe>
hold on, let me write a function for that real quick
<makomo>
ah, you mean compute the deps myself and then load them one after another?
FreeBirdLjj has quit [Remote host closed the connection]
<phoe>
sure
<pjb>
Re-implement asdf?
<makomo>
i guess that would work, but it's not pretty :(
<phoe>
I have no idea if ASDF actually has anything that force-recompiles a system along with all dependencies
<makomo>
oh wait, i forgot that the :force kwarg can take on various values
<makomo>
"If force is :all, then all systems are forced to be recompiled even if not modified since last compilation."
<makomo>
pjb: thanks ;-)
<phoe>
oooh
<phoe>
TIL
<phoe>
thanks!
<Jachy>
phoe: Swank has a swank-asdf.lisp file with slime bindings, though it wasn't working for me so I changed it a bit and bound it to another slime xref type. https://pastebin.com/qM3yLbeW
<makomo>
guess my memory was faulty. good thing i was told to check the manual :-)
<makomo>
phoe: :-)
FreeBirdLjj has joined #lisp
moei has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
lumm has joined #lisp
<akater>
pjb: A
<akater>
pjb: tree-difference is great, thank you.
<pjb>
B
<pjb>
:-)
<pjb>
akater: at first, I would have suggested a pattern matcher, for the unifying of the gensyms. But any existing function will have to be patched to do exactly what you need.
<selwyn>
in that case: what does 'ANSI-compliant Common Lisp' mean in everyday language
<phoe>
selwyn: exactly what it means, something that complies to the ANSI standard
<phoe>
minus some places that are mistakes and/or oversights and/or no longer apply
<selwyn>
ok
<phoe>
for instance, most implementations prefer to implement Unicode rather than implement the part of standard that ensures that there is a 1-to-1 mapping between all lowercase and uppercase characters
<phoe>
that's a part I'd call that "no longer applies"
<selwyn>
yes i see
<phoe>
also in most implementations prog2 returns the value of its second form
<phoe>
that's what I'd call an oversight
<phoe>
because the CLHS says, "prog2 evaluates first-form, then second-form, and then forms, yielding as its only value the primary value yielded by first-form. "
<selwyn>
ah :)
<dtw>
Are there not enough interest (or money?) to fix the specification?
<phoe>
dtw: and the current spec is good enough
<phoe>
and the license of CLHS does not allow it to be modified
<phoe>
and no one so far cared enough to put the money on the table or to do it themselves
<beach>
dtw: You could "fix" the dpANS, which is freely available, but what would you do with the result?
vlatkoB_ has quit [Remote host closed the connection]
<beach>
dtw: I have a planned project for creating a new language, called WSCL (for Well-Specified Common Lisp) based on the dpANS. The new language will be like Common Lisp, but without the mistakes in the Common Lisp HyperSpec, and with more situations specified than what is the case for the Common Lisp HyperSpec.
<beach>
Step 1 is to parse the dpANS into a single LaTeX document (in several files) as opposed to the dpANS which is a TeX document for each chapter.
Fare has joined #lisp
<beach>
I may succeed in convincing gilberth to try to do the parsing.
<selwyn>
does there exist communication between Common Lisp implementors concerning common approaches with which to resolve the known inconsistencies in the standard?
<Fare>
Mostly, no.
<beach>
No?
<Fare>
I mean, occasionally, someone who cares about a particular aspect sends bug reports to lots of implementations, but that's all.
<Fare>
Pcos did a lot of work on getting MOP bugs fixed.
<beach>
Bugs are different from inconsistencies in the standard.
<Fare>
While developing ASDF3, I did lots of work getting pathname bugs fixed, some CLOS bugs related to class redefinition, or readtable issues.
<Fare>
beach: are they?
<dtw>
beach: WSCL is an interesting project. Thanks.
<Fare>
my readtable issues can be seen as inconsistencies in the standard.
<beach>
Fare: I think of a bug as a failure to respect the standard, which is different from the inconsistencies of the standard itself.
<Fare>
which led to a few implementations adopting read-only readtables for the standard readtable, for instance
<Fare>
The standard is far from perfect, but some worship it as a sacred text rather than a work in arrested progress.
<Fare>
Common Lispers are radical conservatives.
<selwyn>
fare: i have noticed :)
<Fare>
I hope people never worship ASDF 3 as perfect :-)
<Fare>
hell, I have a TODO file describing many imperfections.
<MichaelRaskin>
Comparing CLtL2 with standard shows imperfections of the standard, but still
<MichaelRaskin>
That TODO is an integral part of ASDF3 perfection!
<pjb>
Fare: (copy-readtable nil) returns a new standard readtable. So why would we need read-only readtables?
<makomo>
Fare: not sure if you've seen my ping from a week or two ago, but i'd like to let you know that i've opened a PR for fare-quasiquote (not a bug, don't worry :-))
<makomo>
(on gitlab)
themsay has quit [Ping timeout: 250 seconds]
FreeBirdLjj has joined #lisp
themsay has joined #lisp
<Fare>
pjb: see the discussion a few years back on asdf-devel. The standard somewhere (in the glossary?) describes the standard table as read-only
<Fare>
not from copy-readtable, but from with-standard-readtable
<Fare>
makomo, I didn't see it, sorry, let me grep my mailbox
<beach>
So that's not an inconsistency in the standard.
<Fare>
makomo, I didn't see it. Where did you make this PR? On Github?
FreeBirdLjj has quit [Ping timeout: 250 seconds]
<Fare>
I see it in gitlab.common-lisp.net
<Fare>
interestingly, the website didn't configure email notifications for me. Sigh.
techquila has joined #lisp
jmercouris has joined #lisp
<jmercouris>
when you guys are adding docstrings to a function and it spans multiple lines, do you indent it to be inline with the first line?
<jmercouris>
or do you let any lines after the first go to the 0th column?
<phoe>
I do the latter
<jmercouris>
doesn't it annoy you?
<edgar-rft>
jmercouris: looks shitty in the code but looks much better when read via (documentation ...)
robdog has joined #lisp
<jmercouris>
I get that, because indenting adds all those random spaces
<jmercouris>
I feel like that is a problem of the documentation generator/parser though
<jmercouris>
trying to decide which strategy to pursue
<jmercouris>
so far I have been doing things to the 0th column, but it pains me every time
<jackdaniel>
don't wrap lines and allow pretty printer to do that for you
<jmercouris>
I have wrap lines disabled
<jmercouris>
in emacs...
<jmercouris>
not sure if you meant something else
<jackdaniel>
that's not what I mean
<jackdaniel>
I meant: do not put newlines in docstring unless you separate paragraphs
<jmercouris>
so your docstrings will be something like 80 or 200 columns wide?
<jackdaniel>
to be honest I do put newlines in them myself, but I think it is a wrong thing to do - it is the printer responsibility to wrap by word at chosen column
<jmercouris>
I see
<jmercouris>
so you mean the lisp printer
<phoe>
there's also the trick with #.(format nil "...")
<phoe>
and using ~Newline in the formatted string
<jackdaniel>
not necessarily lisp printer, it may be other tool which takes docstring
<jackdaniel>
as its input
<jmercouris>
I agree with you almost
<jmercouris>
I think it should be the other tool
<jmercouris>
however I think the other tool should allow and understand newlines in the source code
robdog has quit [Ping timeout: 250 seconds]
<jmercouris>
as far as I understand it, if you want a new paragraph, you sould have two new lines
<jmercouris>
and docstrings are supposed to be full sentences, not ascii diagrams
<jackdaniel>
if you put newline there is no way any tool could infere it is something what is a soft newline
<jackdaniel>
(i.e you can't distinguish it from hard line break)
<jmercouris>
unless by special character or convention
<jmercouris>
anyways, I will stick to 0th column for now, as much as it pains me
<jackdaniel>
just do #.(format nil "foo bar ~@
<jackdaniel>
xyz")
<jackdaniel>
it will eat unnecessary white characters
<jackdaniel>
(given you do not care about newlines)
<jmercouris>
I don't know what I care about... :D
smasta has joined #lisp
themsay has quit [Ping timeout: 250 seconds]
themsay has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
smasta has joined #lisp
<pjb>
Fare: ok. Thanks. (It's with-standard-io-syntax).
<pjb>
jmercouris: I may type " RET blah RET blah RET " RET
<jmercouris>
pjb: and what kind of problems does it cause?
<pjb>
jmercouris: In any case, I assume that a tool that extracts the docstring and use it will reformat it according to some rule, so you can do as you wish. The only problem is that we have sevearl markup syntax of possible formats for docstring…
<pjb>
jmercouris: in CL not much. In emacs lisp, emacs assumes the first line of the docstring contains a summary.
<pjb>
jmercouris: the point is that it depends on the tools that interpret the contents of the docstring. Some people use HTML!
<pjb>
other use doxygen.
<Fare>
makomo, the first bullet point still doesn't display properly. Thanks for the magic quoting.
nowhere_man has quit [Ping timeout: 250 seconds]
<pjb>
You see the problem…
<jmercouris>
I see the problem
<jmercouris>
if only this was part of the spec!
<phoe>
it can't be
<phoe>
any string is valid as a documentation string
<pjb>
jmercouris: you could use #.(my-doc-string-format "…") and generate different strings depending on the circumstances.
<phoe>
what is inside that string is a matter of style
<jmercouris>
either way, I don't use generated docstring, I only care about how emacs interprets
<makomo>
Fare: yay. hm, let me take a look
<Fare>
MichaelRaskin, lol
<pjb>
If the text is read to generate html documentation, my-doc-string-format would convert to html, if it's read to compile, it would convert to a simple ascii docstring, etc.
smasta has quit [Ping timeout: 250 seconds]
<pjb>
And it may be an additionnal argument to separate docstrings from the sources.
<pjb>
Another one is the localization. Some times, you want to have different language versions (French, English, Russian, etc)
<jackdaniel>
in London I'm using output records for documentation, so it may contain arbitrary content with specialized rendering method
<jackdaniel>
so documentation output-record is not limited to text and is disjoint from the source function definition
cyraxjoe has quit [Ping timeout: 272 seconds]
MightyJoe has joined #lisp
dale has joined #lisp
<makomo>
Fare: PR updated :-)
zotan has quit [Ping timeout: 252 seconds]
zotan has joined #lisp
smasta has joined #lisp
cage_ has joined #lisp
tharugrim has joined #lisp
tharugrim has quit [Client Quit]
tharugrim has joined #lisp
asdf_asdf_asdf has joined #lisp
smasta has quit [Ping timeout: 245 seconds]
<asdf_asdf_asdf>
Hi. [SBCL] How return nothing instead NIL?
wxie has quit [Ping timeout: 250 seconds]
<Fare>
makomo, thanks!
<Fare>
asdf_asdf_asdf, are you the embodiment of ASDF3 ?
<Josh_2>
xD
<Fare>
asdf_asdf_asdf, you mean (values) ?
<Josh_2>
asdf_asdf_asdf: Just return (values)
<makomo>
Fare: cool! :-)
<Fare>
note that the primary value of (values) is still NIL :-)
<Josh_2>
so like (progn (print "abc") (values))
<makomo>
LOL
random-nick has quit [Read error: error:1408F10B:SSL routines:ssl3_get_record:wrong version number]
<asdf_asdf_asdf>
OK, thanks - works. But how do the same on the map - my example above. Instead NIL print "nothing"?
<jackdaniel>
map collects result for each element, if there is no result NIL is returned instead
<jackdaniel>
(collecting (evens) (map nil (lambda (elt) (when (evenp elt) (evens elt))) col) (evens)) ; collecting is a macro which has numerous variants, i.e there is implementation of it in cl-collectors (or something named like that)
teej has quit [Quit: Connection closed for inactivity]
themsay has joined #lisp
rumbler31 has joined #lisp
smasta has quit [Ping timeout: 268 seconds]
cage_ has quit [Remote host closed the connection]
Inline has joined #lisp
gravicappa has quit [Ping timeout: 255 seconds]
<phoe>
jackdaniel: dtw: thanks
robdog has joined #lisp
nalkri has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 240 seconds]
nanoz has quit [Quit: Leaving]
gxt has quit [Quit: WeeChat 2.4]
Fare has quit [Ping timeout: 246 seconds]
verisimilitude has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
hiroaki has quit [Ping timeout: 240 seconds]
Inline has quit [Quit: Leaving]
vibs29 has quit [Ping timeout: 246 seconds]
vibs29 has joined #lisp
didi has joined #lisp
Fare has joined #lisp
sz0 has joined #lisp
smasta has joined #lisp
smasta has quit [Ping timeout: 272 seconds]
smasta has joined #lisp
Inline has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
teej has joined #lisp
Inline has quit [Remote host closed the connection]
Oladon has joined #lisp
ciaranb has joined #lisp
<didi>
Hum. Why (constantp (quote 42)) => t, but (constantp '(42)) => nil? Shouldn't ' be identical to quote?
<didi>
OK, I see now.
<didi>
Never mind.
<LdBeth>
'42
<didi>
Right.
<didi>
Silly me.
rumbler31 has quit [Remote host closed the connection]
<pjb>
42 always evaluates to 42. (42) signals an error (and each time a different condition is created anyways), so in no way can it be considered a constant expression.
<didi>
Related, SBCL describes CONSTANTP with "True of any FORM that has a constant value: self-evaluating objects, keywords, defined constants, quote forms.". Isn't (quote (42)) a "quote form"?
<pjb>
(quote (42)) IS a quote form, but it DOES NOT EVALUATE TO a quote form.
<pjb>
It evaluates to a 42 form, which is meaningless in CL.
<didi>
Hum. Thanks.
<pjb>
didi: be careful, people are sloppy, and then say IS when they mean EVALUATES TO. I can't fathom how they can do that.
<pjb>
s/then say/they say/
rumbler31 has joined #lisp
smasta has joined #lisp
<makomo>
pjb: the same idiom/construct appears in the context of arguments to macros, docstrings, etc.
<makomo>
for example, if a macro M takes an argument A and produces an expansion which arranges for A to be evaluated at runtime, people usually write "M evaluates A"
<makomo>
one could interpret that to mean evaluate at macroexpansion-time, but that's rarely the case so for such behavior it is usually explicitly clarified that macroexpansion-time is meant
<makomo>
another thing that comes to mind is saying "the variable M" when what you really mean is "the variable named by (the symbol) M"
<makomo>
sometimes it's good to clarify what you mean, but sometimes the description just gets overly verbose, hard to read and annoying to write
<makomo>
so blurring the line between an object and the name for that object (or similarly (but not completely, i guess) between an expression and the value of that expression) comes in handy :-)
_whitelogger has joined #lisp
robdog has joined #lisp
rumbler31 has quit [Remote host closed the connection]
klltkr has joined #lisp
caltelt_ has joined #lisp
klltkr has quit [Remote host closed the connection]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
nowhere_man has joined #lisp
tharu has quit [Quit: WeeChat 2.4]
robdog_ has quit [Ping timeout: 250 seconds]
karlosz has quit [Quit: karlosz]
robdog has joined #lisp
<phoe>
How do I get a list of symbols exported from a package?
<phoe>
There was some ASDF option that specified the relative pathname under which all source files are available. What was that?
techquila has quit [Ping timeout: 250 seconds]
<phoe>
Say, I have /foo/foo.asd and /foo/src/bar.lisp - I want to have a component (:file "bar") for it.
<phoe>
There's some ASDF:DEFSYSTEM keyword arg for that but I forgot what it was.
<Fare>
:pathname ?
robdog has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
Fare has quit [Quit: Leaving]
<phoe>
:pathname - yes, thanks.
<phoe>
For some reason I was grepping the manual for "source".
robdog has joined #lisp
robdog_ has quit [Ping timeout: 250 seconds]
moei has quit [Quit: Leaving...]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
<phoe>
I'
<phoe>
I'm becoming a better lisper every day - I've never used this ASDF option until today, even though I've created multiple systems that have their files separated like that
<phoe>
time to backtrack and fix my ASD files
robdog has joined #lisp
robdog_ has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 250 seconds]
grewal has quit [Quit: Lost terminal]
tharugrim has joined #lisp
robdog has joined #lisp
karlosz has joined #lisp
caltelt_ has quit [Ping timeout: 255 seconds]
<pjb>
phoe: (subseq (com.informatimago.common-lisp.cesarum.package:package-exports :cl) 0 10) #| --> (fboundp some end-of-file caadr *read-eval* member symbol-function array-element-type terpri nil) |#
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
random-nick has quit [Read error: Connection reset by peer]