justinmcp_ has quit [Quit: No Ping reply in 180 seconds.]
cl-arthur has joined #lisp
justinmcp has joined #lisp
asarch_ has joined #lisp
pfdietz1 has joined #lisp
mejja has quit [Read error: Connection reset by peer]
pfdietz has quit [Remote host closed the connection]
asarch has quit [Read error: Connection reset by peer]
pfdietz1 is now known as pfdietz
danielxvu has quit [Ping timeout: 252 seconds]
justinmcp has quit [Client Quit]
ravndal has quit [Ping timeout: 252 seconds]
djh has quit [Ping timeout: 252 seconds]
dented42 has joined #lisp
Guest13389 has quit [Ping timeout: 252 seconds]
justinmcp has joined #lisp
slyrus has quit [Remote host closed the connection]
slyrus1 is now known as slyrus
deba5e12 has quit [Read error: Connection reset by peer]
slyrus1 has joined #lisp
fiddlerwoaroof has quit [Quit: Gone.]
deba5e12 has joined #lisp
fiddlerwoaroof has joined #lisp
Guest13389 has joined #lisp
ravndal has joined #lisp
r1b has quit [Ping timeout: 252 seconds]
<jcowan>
given the limited objectives of safe-read, I would think writing it from scratch (by which I mean read-char) would be not only safer but easier
ryan_vw has joined #lisp
<jcowan>
no readtable futzing, etc.
Kundry_Wag has joined #lisp
dented42 has quit [Ping timeout: 268 seconds]
<jcowan>
come to think of it, though, there is no string->number, is there? If not, you'd have to sanitize numbers and call read on them.
<jasom>
parse-integer exists
<jasom>
parse-float is a library and parse-number is also a library
Kundry_Wag has quit [Ping timeout: 245 seconds]
dented42 has joined #lisp
robotoad has joined #lisp
sjl has quit [Ping timeout: 244 seconds]
GoldRin has joined #lisp
<jcowan>
ah, good
dented42 has quit [Ping timeout: 252 seconds]
<jcowan>
so apparently it handles numbers, strings, and lists, and that's it.
Kundry_Wag has joined #lisp
dented42 has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
dented42 has quit [Ping timeout: 252 seconds]
didi has joined #lisp
<didi>
What should I use for the parameter `default' of function `getf' if I want to know, for certain, that an indicator is absent?
slyrus1 has quit [Remote host closed the connection]
<no-defun-allowed>
maybe MEMBER would be more appropriate if you want to test for presence
<drewc>
didi: I use a GENSYM for that if I really care, for often, :asbent, or a similar keyword that states my intention if it is vancant.
<didi>
no-defun-allowed: Hum. The values will be tested too, and I don't want that.
<didi>
drewc: Thank you.
mkolenda has quit [Ping timeout: 252 seconds]
Jachy has quit [Ping timeout: 250 seconds]
<no-defun-allowed>
i see
<didi>
I am thinking of using something like (list :absent) as default, so I can test it using `eq'.
<didi>
Maybe even a defparameter of sorts.
quazimodo has quit [Ping timeout: 252 seconds]
<jcowan>
I use (copy-seq "some string that explains what it's for")
<didi>
jcowan: Thank you.
Arcaelyx has joined #lisp
<jcowan>
The advantage of that over a pair is that it doesn't interfere with the way things are printed
quazimodo has joined #lisp
<didi>
Interesting.
Kundry_Wag has joined #lisp
<didi>
The manual mentions function `get-properties' but seems a bit overkill. Maybe it isn't.
<beach>
phoe: Could your safe reader be implemented as a bunch of specific methods for Eclector?
lagagain has joined #lisp
robotoad has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
aindilis has quit [Ping timeout: 245 seconds]
quazimodo has quit [Ping timeout: 268 seconds]
meepdeew has joined #lisp
quazimodo has joined #lisp
slightlycyborg has quit [Ping timeout: 252 seconds]
<jcowan>
Looks like overkill for something that is actually simpler than JSON
pjb has quit [Ping timeout: 252 seconds]
<jcowan>
(no maps)
meepdeew has quit [Ping timeout: 250 seconds]
<beach>
What does?
Kundry_Wag has joined #lisp
<jcowan>
Implementing safe-read with Eclector
<beach>
Are you saying that the safe-read code is simpler than the combined amount of code required to configure Eclector?
<jcowan>
no, than Eclector plus the configuration.
<beach>
Oh, but then the Eclector way is definitely preferable.
<beach>
Because then you have a separate module that is separately maintained.
<beach>
And that has several clients.
<jcowan>
Point. Does Eclector have limits on nesting depth?
<beach>
So the combined maintenance burden is less than with a specific implementation for safe-read.
<beach>
jcowan: I don't know, but I am sure scymtym would be happy to consider such an addition.
Kundry_Wag has quit [Ping timeout: 268 seconds]
* jcowan
nods
<beach>
He has been doing a fantastic job of testing and documenting Eclector. Also, uniforminzing the code so that it is understandable and maintainable.
<beach>
I am very impressed.
Jachy has joined #lisp
<beach>
And, there are at least four clients for it.
<jcowan>
(I'm not talking about phoe's impleentation specifically, but a lower-level version not involving readtables or REQD istself.
<Ober>
xb
<jcowan>
s/REQD/READ
<beach>
jcowan: OK.
<jcowan>
I suspect that such code would be easier to audit, since it is part of the security perimeter
<beach>
The current clients for Eclector are: SICL, Clasp, Second Climacs, and scymtym's experimental (and very impressive) Common Lisp development environment.
<beach>
Oh, and maybe Shinmera's documentation system as well.
<jcowan>
A general and portable CL reader is a great thing, and I'm glad it exists.
<beach>
And it's more than a reader. It can "read" the comments and other skipped material as well.
<beach>
Very useful in some applications.
<beach>
There have been portable readers in the past, but I think this is the first one that is written with heavy use of generic functions, so that it can be adapted to the needs of the client.
<jcowan>
Generic functions are the best part of OO
<beach>
Totally!
<jcowan>
I'm looking to get generic functions without classes into Scheme
patche has joined #lisp
DGASAU has joined #lisp
anewuser has quit [Quit: anewuser]
<beach>
If you have no classes, what would the methods specialize on?
Jach[m] has joined #lisp
ccl-logbot has quit [Remote host closed the connection]
sauvin has joined #lisp
estest has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
NB0X-Matt-CA has joined #lisp
patche has quit [Quit: Lost terminal]
<Petit_Dejeuner>
types?
wanz has joined #lisp
n3k0_t has joined #lisp
<jcowan>
beach, Petit_Dejeuner: arbitrary predicates supplemented by subsumption relationships between them
<beach>
So you are not going for high performance then?
Kundry_Wag has joined #lisp
<beach>
Or do you know a way to implement that for high performance?
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
<fiddlerwoaroof>
beach: is there a link to scymtym's environment?
<beach>
Eclector? The reader?
<beach>
Oh, his experiments with IDEs?
<beach>
I don't know.
<beach>
I have seen his demo videos.
ryan_vw has quit [Ping timeout: 244 seconds]
<fiddlerwoaroof>
his experiment with IDEs
no-defun-allowed has joined #lisp
<beach>
You would have to ask him. I have only seen demo videos.
<no-defun-allowed>
morning beach
Kundry_Wag has quit [Ping timeout: 252 seconds]
meepdeew has joined #lisp
<fiddlerwoaroof>
I've been thinking recently about what would make code completion for lisp nicer
<beach>
You definitely need to talk to scymtym. He is working on related ideas.
mkolenda has quit [Remote host closed the connection]
mkolenda has joined #lisp
<LdBeth>
good evening
Kundry_Wag has joined #lisp
<no-defun-allowed>
hi LdBeth
Kundry_Wag has quit [Ping timeout: 252 seconds]
<PuercoPop>
fiddlerwoaroof: I like the m-v-b<tab> approach to completion, although its main use is to save typing when I know what I want to call but am to lazy to type it
<fiddlerwoaroof>
Yeah, I'm thinking of things more like F# type providers
<fiddlerwoaroof>
So, you can advise the IDE that the first argument to a function is "normally" one of a certain set of keywords
vlatkoB has joined #lisp
<fiddlerwoaroof>
And then ways to customize the argument list things like eldoc show, so that complicated forms like LOOP can be easier to use
<PuercoPop>
fiddlerwoaroof: you could start from the arglists contrib that sl{y,ime} uses for function specific eldocs maybe?
<fiddlerwoaroof>
look at that :)
fouric has joined #lisp
<PuercoPop>
What I think we are missing from a tooling perspective is a way to declare custom indentation for forms that is well integrated with the system. The cl-indent.el 'contrib' has that functionality but the API appears to expect the user of a library to copy emacs-lisp into their init.el (or .dir-locals.el at least)
<fiddlerwoaroof>
Just skimming through that code, it looks very similar to the things I was thinking about
<PuercoPop>
I've seen some code that configures it from the CL side only if it finds slime is loaded in the image
<fiddlerwoaroof>
Yeah, and there are other things: I'd like to be able to have a single emacs buffer that contains the source for all the methods of a generic function
<fiddlerwoaroof>
But, to do that right, I'd need an implementation that made the code in the image the source of truth
<fiddlerwoaroof>
e.g. it'd be more like a smalltalk environment than like modern CL environments
<PuercoPop>
Thing is, functions don't necessarily have source code associated with them in CL
Harag has joined #lisp
<fiddlerwoaroof>
Sure, that's why I'd need implementation support
<fiddlerwoaroof>
One advantage of this would be that, it wouldn't matter _where_ I define a function: if I type it in the repl, or enter it through a buffer, the code will end up in the same place and I could extract it into a buffer using a hypothetical query language for source code
<fiddlerwoaroof>
e.g. "show me a buffer with this functions and all the functions it calls"
<PuercoPop>
But with current xref's capabilities you could create a buffer that is the 'view' current loaded methods associated with a generic functions today
<fiddlerwoaroof>
Yeah, the problem with that is that if I edit the from that buffer, I'd have to manage patching those functions back into their source files
<PuercoPop>
Except the prospect of writing complex UI controls in elisp is not an enticing one
<PuercoPop>
fiddlerwoaroof: can't you use 'indirect buffers' to take care of that for you?
<fiddlerwoaroof>
I think so, although from what I gather, combining parts of several files into one file doesn't work very reliably in emacs.
<fiddlerwoaroof>
Also, the other thing is, if the source of truth for the code is whatever is stored in the image, it might be less painful to maintain customizations of other people's code
<LdBeth>
you can use an object store
<LdBeth>
though integration to version control may be considered
<PuercoPop>
yeah, an indirect-buffers can only show content from one buffer. But you a buffer to select the method and a buffer to display its contents. Similar to how the Smalltalk Browser shows protocols and methods. Although that is mostly the same to the current xref capabilities in sl{y,ime}
pjb has joined #lisp
Harag has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
I'm actually a bit curious if it's possible to tell something like sqlite to embed a database at the end of a file
<fiddlerwoaroof>
Then, I could just concatenate my source-code database with my lisp image
makomo has joined #lisp
<oni-on-ion>
hmmm
<oni-on-ion>
i was looking at org-mode attachments for a similar purpose; to compound a given project source tree into a single org file
<fiddlerwoaroof>
(assuming that executable formats don't mind "junk" at the end)
<oni-on-ion>
lisp image source with ChangeSet-style abilities would be groovy
linack has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
shka_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
makomo has quit [Ping timeout: 250 seconds]
bpanthi1 has joined #lisp
asarch_ has quit [Quit: Leaving]
kajo has quit [Ping timeout: 252 seconds]
pjb has quit [Ping timeout: 252 seconds]
pjb has joined #lisp
bpanthi1 has quit [Quit: bpanthi1]
pjb has quit [Ping timeout: 252 seconds]
dented42 has joined #lisp
Kundry_Wag has joined #lisp
shka_ has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
JohnMS_WORK has joined #lisp
trittweiler has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
aindilis has joined #lisp
arescorpio has joined #lisp
scymtym has quit [Ping timeout: 246 seconds]
arescorpio has quit [Remote host closed the connection]
scottj has quit [Quit: leaving]
Kundry_Wag has quit [Ping timeout: 252 seconds]
robotoad has quit [Quit: robotoad]
dented42 has quit [Ping timeout: 272 seconds]
arescorpio has joined #lisp
Harag has joined #lisp
Kundry_Wag has joined #lisp
ryan_vw has joined #lisp
JohnMS has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
JohnMS_WORK has quit [Ping timeout: 252 seconds]
shrdlu68 has joined #lisp
igemnace has joined #lisp
orivej has joined #lisp
meepdeew has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
<shka_>
good morning
arescorpio has quit [Remote host closed the connection]
X-Scale has quit [Read error: Connection reset by peer]
heisig has joined #lisp
ggole has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
roshanavand has joined #lisp
apertus has quit [Read error: Connection reset by peer]
hhdave has joined #lisp
angavrilov has quit [Read error: Connection reset by peer]
hhdave has quit [Ping timeout: 252 seconds]
HDurer has joined #lisp
angavrilov has joined #lisp
lonjil has quit [Ping timeout: 252 seconds]
lonjil has joined #lisp
dented42 has joined #lisp
_whitelogger has joined #lisp
hjudt has quit [Quit: leaving]
cmatei has joined #lisp
dented42 has quit [Ping timeout: 252 seconds]
hjudt has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
cl-arthur has quit [Quit: Lost terminal]
housel has quit [Ping timeout: 264 seconds]
dddddd has joined #lisp
asymptotically has joined #lisp
steiner has joined #lisp
Kundry_Wag has joined #lisp
kajo has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 252 seconds]
sunset_NOVA has joined #lisp
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 26.1)]
cl-arthur has joined #lisp
thijso has quit [Read error: No route to host]
hhdave has joined #lisp
francogrex has joined #lisp
<francogrex>
hi is there a link that shows how to cross compile build sbcl for windows on a linux (from linux to make win64 executable sbcl)? I have problems building directly on windows (with mingw)
<ogamita>
francogrex: cross compilations are much more complications.
<ogamita>
sbcl is not built wiht mingw, but with a CL implementation, AFAIK.
<ogamita>
try building it with ccl or clisp.
anewuser has joined #lisp
Kaisyu7 has joined #lisp
<scymtym>
but in addition to that, a C compiler is needed to build the runtime
<ogamita>
ah. ok.
thijso has joined #lisp
<Shinmera>
Download an SBCL from sourceforge, then use MSYS 2's MinGW console. Works just fine
<Shinmera>
I already said as much on #sbcl but I guess that's not what he wants to hear
dented42 has joined #lisp
semz has joined #lisp
<semz>
are there differences between ANSI CL and the language as described in CLtL2?
<Shinmera>
Yes.
<shka_>
CLtL2 goes beyond the standard
<Shinmera>
It also has other differences beyond extensions
<shka_>
yes
<shka_>
still a good book though
<shrdlu68>
Indeed.
<semz>
Is there a full list of differences somewhere or would I have to crosscheck myself?
<Shinmera>
Why would one want to do that
<Shinmera>
There's no CLtL 2 implementations out there
<shka_>
... there should be ;-)
<shka_>
semz: i don't know such list
<semz>
That is why I'd like to know where it differs from the standard
<shrdlu68>
I think KCL was pre-ANSI.
<shka_>
semz: i agree that such list would be useful
<jackdaniel>
and all I had to do was to type "cltl2 ansi common lisp differences" in the search engine! :-)
Kundry_Wag has joined #lisp
<semz>
personalized searches were a mistake :(
<shka_>
i am not sure if this list is complete
<shka_>
it does not go into cltl2 extensions, like envs
<shka_>
but perhaps those are easier to identify by the reader
<jackdaniel>
careful reader would notice "ANSI deleted the functions variable-information, function-information, declaration-information, augment-environment, parse-macro, and enclose as well as the macro define-declaration. This
<jackdaniel>
even more careful reader would find in the first paragraph: "In fact, this FAQ has many known but minor omissions that are too awkward to add with pencil to CLTL2."
igemnace has quit [Quit: WeeChat 2.2]
Kundry_Wag has quit [Ping timeout: 276 seconds]
Selwyn has joined #lisp
dented42 has quit [Ping timeout: 250 seconds]
steiner has quit [Remote host closed the connection]
francogrex has quit [Remote host closed the connection]
<jackdaniel>
as I said it is supported to some extent
<jackdaniel>
I've found some problems with sbcl which I've used as a reference for testing CLtL2 api (I don't quite remember what they were, but SBCL doesn't conform in some edge cases)
dented42 has quit [Ping timeout: 276 seconds]
<no-defun-allowed>
Fair enough
Selwyn has quit [Read error: Connection reset by peer]
vlatkoB_ has joined #lisp
<scymtym>
i wonder why https://common-lisp.net/downloads mentions allegro but not lispworks. that would have been the obvious choice given that the two most popular open source implementations are listed
vlatkoB has quit [Ping timeout: 252 seconds]
<jackdaniel>
I can't see LW listed in Implementations section either
<jackdaniel>
(but allegro is listed)
jmercouris has joined #lisp
<scymtym>
clisp is missing as well
<scymtym>
i mean, i'm not saying every implementation should be listed, but those two are pretty obvious omissions
<jackdaniel>
I'll write to clo-devel and ask
<edgar-rft>
maybe they have failed to sponsor their links?
m00natic has joined #lisp
<jackdaniel>
does clisp have a grant program? ;)
<edgar-rft>
if yes, they could sponsor e.g. *me*
ramus has quit [Ping timeout: 252 seconds]
astronavt has joined #lisp
ramus has joined #lisp
trittweiler has joined #lisp
eminhi has quit [Remote host closed the connection]
jmercouris has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
mn3m has joined #lisp
mn3m has quit [Max SendQ exceeded]
zigpaw has quit [Remote host closed the connection]
zfree has joined #lisp
dented42 has joined #lisp
jmercouris has joined #lisp
jmercouris has quit [Remote host closed the connection]
wanz has quit [Quit: wanz]
<hjudt>
does anyone know this -> if i fork a project that is under apache 2 license, do i really need to add a notification to every modified file stating that it has been changed? There is actually no copyright information included in (most of) the files. Or is meta-information from vcs enough?
wanz has joined #lisp
ogamita has quit [Read error: Connection reset by peer]
sunset_NOVA has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
ogamita has joined #lisp
dented42 has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Ping timeout: 252 seconds]
<ogamita>
hjudt: 4. b) is clear: "You must cause any modified files to carry prominent notices stating that You changed the files;".
<ogamita>
hjudt: I think that "prominent notices" can be implemented in a separate file, but must not be hidden in a database such as git logs.
<ogamita>
hjudt: Of course, you can generate this PROMINENT-NOTICE.txt file from the git logs; write a script!
<hjudt>
ogamita: thanks. if i add a new section in the readme stating that the project has been forked from another project and provide the reference and download location of that will it be enough?
mkolenda has quit [Ping timeout: 252 seconds]
<hjudt>
(and give credit to the original author of course)
xuxuru has joined #lisp
<ogamita>
It depends on each license. You need to read them to know what the requirements are, when you distribute modified forks. https://www.apache.org/licenses/LICENSE-2.0
<ogamita>
In the case of the Apache v2, you have 4 requirements.
xuxuru has quit [Client Quit]
<ogamita>
Giving credit to the original author is not a requirement of the Apache v2. (but 4.d is an approximation).
Kaisyu has quit [Quit: Connection closed for inactivity]
<ogamita>
Giving the reference and download location is not a requirement either of Apache v2.
<hjudt>
ok thanks for the explanation
mkolenda has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
shifty has quit [Ping timeout: 252 seconds]
Harag1 has joined #lisp
Harag has quit [Ping timeout: 250 seconds]
Harag1 is now known as Harag
eminhi has joined #lisp
Harag1 has joined #lisp
Harag has quit [Ping timeout: 252 seconds]
Harag1 is now known as Harag
zigpaw has joined #lisp
wanz has quit [Quit: wanz]
relaxed has joined #lisp
warweasle has joined #lisp
wanz has joined #lisp
orivej has joined #lisp
frgo has quit [Ping timeout: 245 seconds]
anewuser has quit [Quit: anewuser]
wanz has quit [Client Quit]
Kundry_Wag has joined #lisp
frgo has joined #lisp
wanz has joined #lisp
Spaceman77 has joined #lisp
wanz has quit [Client Quit]
Bike has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
SenasOzys has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
foom2 has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
foom has quit [Ping timeout: 250 seconds]
scymtym has quit [Ping timeout: 252 seconds]
<jcowan>
The point of marking files as modified by you is reputational: the original author does not want to be blamed for bugs you introduced into them!
<beach>
Nor for your ugly code.
anewuser has joined #lisp
<drdo>
I don't even want to try to understand how this works in a project with several tens or hundreds of contributors
<Bike>
git blame
Kundry_Wag has joined #lisp
SenasOzys has joined #lisp
Harag has quit [Ping timeout: 276 seconds]
FreeBirdLjj has joined #lisp
steiner has quit [Ping timeout: 252 seconds]
varjagg has joined #lisp
astronavt has quit [Quit: Leaving]
anamorphic has joined #lisp
JohnMS_WORK has joined #lisp
dented42 has joined #lisp
JohnMS has quit [Ping timeout: 252 seconds]
heisig has quit [Quit: Leaving]
housel has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
elfmacs has quit [Ping timeout: 245 seconds]
edgar-rft has quit [Quit: Leaving]
dented42 has quit [Ping timeout: 245 seconds]
nsrahmad has joined #lisp
Spaceman77 has quit [Remote host closed the connection]
shrdlu68 has quit [Ping timeout: 250 seconds]
jack_rabbit has quit [Ping timeout: 252 seconds]
Gnuxie[m] has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
deba5e12_ has joined #lisp
asarch has joined #lisp
deba5e12 has quit [Read error: Connection reset by peer]
robotoad has joined #lisp
knicklux has joined #lisp
parjanya has quit [Read error: Connection reset by peer]
ogamita has quit [Ping timeout: 252 seconds]
knicklux has quit [Ping timeout: 252 seconds]
frodef has joined #lisp
knicklux has joined #lisp
iskander has quit [Quit: Quit]
JohnMS has joined #lisp
iskander has joined #lisp
JohnMS_WORK has quit [Ping timeout: 252 seconds]
Selwyn has joined #lisp
makomo has joined #lisp
rippa has joined #lisp
zfree has quit [Quit: zfree]
blackwolf has joined #lisp
knicklux has quit [Ping timeout: 252 seconds]
nsrahmad has quit [Remote host closed the connection]
funnel has quit [Remote host closed the connection]
funnel_ is now known as funnel
jmercouris has quit [Remote host closed the connection]
dented42 has joined #lisp
dale_ has joined #lisp
hhdave has quit [Ping timeout: 276 seconds]
dale_ is now known as dale
pjb has joined #lisp
PyroLagus has joined #lisp
makomo has joined #lisp
florilege has joined #lisp
cage_ has joined #lisp
glv has joined #lisp
ggole has quit [Quit: ggole]
nowhereman_ has joined #lisp
nowhere_man has quit [Read error: Connection reset by peer]
dyelar has joined #lisp
kajo has joined #lisp
anamorphic has joined #lisp
anamorphic has quit [Client Quit]
anamorphic has joined #lisp
nowhereman_ has quit [Ping timeout: 252 seconds]
<stylewarning>
(Echoing in here from #sbcl): We are running into a problem where we compile and load an entire system (a vanilla ASD), and we get some performance baseline of the application, then we do (load (compile-file X)), performance improves by about 20%, then (load (compile-file Y)), performance regresses back to normal. Y depends on X, and X precedes Y in the system definition. I looked for compiler policy leakage and that
<stylewarning>
wasn’t it.
X-Scale has joined #lisp
<stylewarning>
Could anybody offer other hypotheses as to why this might be the case?
meepdeew has quit [Remote host closed the connection]
<phoe>
beach: I think so, yes.
<phoe>
Would you like me to try?
<stylewarning>
(It might also help to know neither X nor Y were modified between compilations/loading, cache has been cleared, and X just contains structures+functions, Y just contains variables and functions)
<phoe>
beach: also, I think that Shinmera has done work that is superior to mine - he has done some work on something he calls a wire protocol that is usable for serializing data over the network into S-expressions.
<phoe>
His implementation is much better than mine and I would recommend to base any Eclector-related code on his work.
<Bike>
if you had function definitions before structure definitions and the functions use parts of the structure definitions i can imagine that on the second compile it will incorporate inline structure accessors etc that it didn't know about the first time and that could speed it up
<pfdietz>
You might try not assigning the smaller value into RES, but using a temporary? Also, what is the type of MASK-START? If it could be very negative, FIRST-LEN could be arbitrarily large.
ircbrowse has joined #lisp
<shrdlu68>
Mask-start is (nth-value 1 (truncate fixnum 62)))
<pfdietz>
(truncate -61 62) ==> 0, -61, so (- 61 mask-start) could be as large as 122, and the ASH does not give a fixnum.
<shrdlu68>
Sorry, positive fixnum.
Denommus has joined #lisp
<pfdietz>
I suggest tightening some of the ranges from FIXNUM, as allowed by correctness. Like (integer 0 61) for some of those, if that's right? Then remove declarations until it can't figure it out.
<pfdietz>
Also consider (THE ...) forms.
<pjb>
shrdlu68: don't worry, I've started writing an OCR software in Common Lisp. As soon as it's debugged, …
<sjl>
If you want modulo-62 arithmetic, consider defining arithmetic functions that do that explicitly, rather than using fixnum and hoping the compiler will let it overflow like you want.
<sjl>
that way if you run on a machine/compiler where fixnums don't happen to be 62 bits you'll get slow results instead of completely bonkers ones
vlatkoB_ has quit [Remote host closed the connection]
Denommus` has joined #lisp
Denommus has quit [Ping timeout: 244 seconds]
<warweasle>
Is there a human readable version of circular lists/graphs? I'd like something like #1=(1 2 3 . #1#) but with human names like #beginning=(1 2 3 . #beginning#)
SaganMan has quit [Read error: Connection reset by peer]
<warweasle>
Wait, I *should* be able to create my own reader macro.
Kundry_Wag has joined #lisp
orivej has joined #lisp
relaxed has quit [Quit: ⠠⠵]
<Bike>
implementing #n# completely is tricky because you need to be able to iterate over structures and stuff.
Kundry_Wag has quit [Ping timeout: 252 seconds]
dented42 has joined #lisp
<cgay>
I see there are cl-dot and cl-graphviz packages...
<warweasle>
Bike: I think I can make a macro which does something similar.
<sjl>
Could you implement your own function that kept a map of symbol -> integer and funcalled (get-dispatch-macro-character #\# #\=) to do the actual work?
<warweasle>
I'm trying to get a non-programmer to enter formatted lisp...so I can do almost nothing and looks like I'm doing work.
<Bike>
that's kind of horrible, but maybe
<sjl>
cgay: I've used cl-dot. It works pretty well.
makomo has quit [Ping timeout: 268 seconds]
glv has quit [Quit: Leaving]
p9fn has joined #lisp
Fare has joined #lisp
makomo has joined #lisp
Fare has quit [Ping timeout: 252 seconds]
angavrilov has quit [Remote host closed the connection]
nowhereman_ has joined #lisp
Kundry_Wag has joined #lisp
asymptotically has quit [Quit: Leaving]
anamorphic has quit [Quit: anamorphic]
anamorphic has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
xylef has joined #lisp
m3tti has joined #lisp
Fare has joined #lisp
m3tti has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
jack_rabbit has joined #lisp
jmercouris has joined #lisp
nowhereman_ has quit [Ping timeout: 268 seconds]
cage_ has quit [Remote host closed the connection]
kajo has joined #lisp
slyrus1 has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
eminhi has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
<stylewarning>
jackdaniel: there are generic functions in X
<anamorphic>
Would it make much of a difference at runtime if I had compiled all the ASDF systems my code depended on, along with my own code from one, large, concatenated source file?
<Ober>
asdf should dtrt
Kundry_Wag has quit [Ping timeout: 252 seconds]
dented42 has joined #lisp
<jasom>
anamorphic: the compiler is allowd to inline functions that are defined in the same source file as they are called in without an inline declaration.
<jasom>
also when you load a file, it rebinds certain dynamic variables, so it's not 100% the same if you are modifying state at load-time.
<jasom>
as an aside, ASDF can generate a single file to load (see the docs for bundle-op).
frodef has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<anamorphic>
So I've been looking at some CFFI-based projects, and sometimes the project will defined a file "reload.lisp" which includes only (define-foreign-library ...) and (use-foreign-library) calls and then in a separate file, the project will have all the CFFI (defcfun ...) forms. Is there a reason for the separate "reload.lisp" file?
Fare has quit [Ping timeout: 250 seconds]
<Bike>
i think so that if you load the project and then save image, it's easy for a restored image to dlopen the thing again.
<Shinmera>
anamorphic: I don't know, never done that on any of my projects
Roy_Fokker has joined #lisp
asymptotically has joined #lisp
dented42_ has joined #lisp
dented42 has quit [Ping timeout: 250 seconds]
jmercouris has quit [Ping timeout: 276 seconds]
heisig has quit [Quit: Leaving]
jmercouris has joined #lisp
dented42_ has quit [Ping timeout: 268 seconds]
terpri has quit [Ping timeout: 246 seconds]
dented42 has joined #lisp
<sjl>
anyone know of any tricks to have a standalone .lisp file that can be both executed as a script (via a shebang like #!/usr/local/bin/sbcl --script) and LOADed?
<sjl>
not critical, just asking mostly out of curiosity.
<sjl>
sbcl --script ignores the shebang, but trying to LOAD the file doesn't, and #! isn't a reader macro by default
<Shinmera>
It's not really possible unless you define a reader macro beforehand that causes the #! to be ignored
<sjl>
Yeah
<sjl>
and I can't do that in the file itself because the #! has to be the first two butes
<sjl>
*bytes
<Shinmera>
I've tried that sorta shenanigan for a while, and typically just end up making a shell wrapper script instead
<pjb>
sjl: the trick is to have a reader macro for #! as comment, and to use a feature in the repl, so you don't call the main function of the script. I use #-testing-script (main)
<pjb>
sjl: for the reader macro, see clasp from clisp.
<pjb>
and load ~/rc/common.lisp from all your lisp rc fiels.
<pjb>
files.
anamorphic has joined #lisp
<sjl>
Sure, if you load another file first it's trivial. Or even sbcl --eval "(set-dispatch-macro-character #\# #\! #'read-line)" --load scratch.lisp
<pjb>
Then you can write #! comments in the middle of your files :-)
<sjl>
But now it's no longer a single standalone file
<sjl>
I guess it's not really possible.
<pjb>
Also, you don't have to use #! on linux and other unices. There are kernel modules to interpret files as scripts depending on other things, such as file name or path.
<pjb>
or even file contents.
<pjb>
But since it requires a custom installation of a module or configuration, you couldn't use it for distributed files.
<sjl>
if only it was a semibang instead of a shebang
<sjl>
;!
<pjb>
or you can patch your CL implementation to add it.
<pjb>
#! I mean.
<pjb>
#! is reserved to the user, but the user will understand…
<sjl>
sure
<aeth>
I would personally just have the script .lisp file be separate from the rest
<aeth>
So the script would just call main (perhaps handling the command line argument stuff)
<sjl>
Yeah, there's lots of ways to do it. I was just hoping there was some magic trick to get it all self-contained in a single file.
<aeth>
You wouldn't want that because you want the script to call (main) and you would want the loadable file to leave calling (main) to the user.
<aeth>
So now you have two hacks, not just the #! one
<sjl>
I was planning on tackling that hack after the first one.
<aeth>
I would personally just use: sbcl --noinform --non-interactive --load foobar.lisp --eval "(foo:main)"
<aeth>
You can easily get a bilingual file with #| |#
<aeth>
bash will ignore #| as a comment, then you run sbcl (and this way the path isn't hardcoded to sbcl)
<pjb>
Yes, you can always write bash scripts that call lisp implementations to run pure lisp files.
<aeth>
So #| \n the-script \n # |# \n
<aeth>
and now your file is bilingual
<sjl>
but you can't chmod u+x and run it, you'd have to invoke it as bash bilingualfile
<pjb>
This is what I do from Makefile to generate executable images. as bash scripts: #!/bin/bash \n exec ccl --no-init --load "$0".lisp
<aeth>
I think you need something like exit or something before the CL part? And then you wouldn't need # |# and can just have |#
<pjb>
This way you don't mix languages and features in the same file.
<aeth>
pjb: Yes, much cleaner and I'd personally do that
<aeth>
pjb: One file is what requires the bilingial hack
roscoe_tw has quit [Ping timeout: 246 seconds]
<sjl>
there are twenty different ways I could do it, but I don't think any will satisfy my goals of "single standalone file", "executable on its own", "loadable with LOAD" on its own
<pjb>
sjl: why not? I gave you the solution above!
<sjl>
Not a big deal, I was just curious. I usually end up dumping binaries for these kinds of things anyway
<pjb>
your requirement is loadable with load, not loadable with load in an image that has been prevented to load its rc files.
<aeth>
sjl: Bilingual sh/lisp where the first part is sh that reloads the file as CL meets the requirement!
<sjl>
aeth: can you pastebin an example somewhere? I'm not seeing how it would work
jinkies has joined #lisp
<sjl>
pjb: "on its own" implies not loading one's rc files, I'd think
<pjb>
Yes, but "executable on its own" doesn't need a reader macro: it's interpreted by the kernel!
<pjb>
Implementations don't read their rc file when they're used as script interpreter.
<sjl>
for the script to be executable on its own, it needs "#!" as the first two bytes in the file, barring any extra kernel extensions and such, right?
<pjb>
Yes.
<sjl>
For the file to be LOADable, you need a reader macro that knows to ignore that line. But there's nowhere to *put* that reader macro aside from some other file somewhere, because the #! has to come first.
<pjb>
You put it in the rc file! this is the solutioN!
<pjb>
Your requirement wasn't that you'd load the script wihtout having loaded the rc files.
<sjl>
Yeah, the rc file is one possibility for "some other file somewhere".
<pjb>
If you change the requirements in the middle of the problem solving, then I don't play.
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth>
sjl: I have it now
<sjl>
I thought "standalone file" clearly implied "other files aren't allowed". Anything you could do with a non-rc file you could certainly stuff into an rc file instead, so disallowing only other-files-that-arent-rc-files doesn't make much sense.
<pjb>
sjl: perhaps you should use clisp for your scripts. It seems to work much better.
<sjl>
I refuse to use clisp for moral reasons -- they chose a name that confuses the heck out of new lispers.
<aeth>
sjl: That is if I'm remembering the hack properly. I saw something similar to this once
<aeth>
works for me, though
<sjl>
Failed to execute process './wat.lisp'. Reason:
<anamorphic>
meh. I never thought clisp was a confusing name
<sjl>
exec: Exec format error
<sjl>
aeth: what OS are you using? I'm on Linux
<aeth>
sjl: You need to save it as bilingual.lisp and run it as ./bilingual.lisp
<aeth>
sjl: It might not work in your shell
<aeth>
It runs in both bash and zsh, at least for me
<sjl>
same error
<sjl>
oh, it works in bash
<aeth>
sjl: did you chmod +x ?
<sjl>
what in the
<aeth>
sjl: I wouldn't recommend using it, but it is a strange hack.
<aeth>
It's incredibly fun
<sjl>
... what do I even search for online to find what this feature is called?
<aeth>
I just added "Edit: Tested in zsh and in bash. It might not work in every shell."
<Shinmera>
it's not a feature of any kind, it's just using # as a comment, reloading itself as lisp, then exiting before the |# can be read
<aeth>
hmm, I'll change that to "Note:" instead of "Edit:"
<Shinmera>
also you can change the bash part to not require hard-coding the file name
<aeth>
with $0 ?
<pjb>
hard coding of things in script is not a problem, if you have a Makefile with an install target to do the hard coding.
<aeth>
hmm, yes, works
<pjb>
Using run-time tricks such as $0 only works if you follow the imposed convention.
<aeth>
pjb: it's better to use $0 because then it gets the proper path
<sjl>
> If the execl() function fails due to an error equivalent to the [ENOEXEC] error, the shell shall execute a command equivalent to having a shell invoked with the command name as its first operand, with any remaining arguments passed to the new shell.
<sjl>
that's the "feature"
<pjb>
aeth: what if you move one and not the other?
<Shinmera>
sjl: Yes, a rather disgusting feature in my opinion
<pjb>
Shouldn't $0.lisp he stored actually in /usr/libexec ? or /usr/local/libexec ?
<sjl>
aeth: this hack is sufficiently horrible that I withdraw my question
<aeth>
sjl: idk, as someone who plays around with languages and with bilingual files, this is pretty trivial
<aeth>
It's imo the Wrong Thing™, though. The right thing is to have a separate, trivial .sh file that runs the .lisp file imo.
<aeth>
Then you can e.g. ensure that you use bash or whichever shell you want to use
<sjl>
I mean the POSIX behavior of "no shebang -> yolo, just pipe whatever this thing is to a shell" is horrifying
<aeth>
haha, definitely
<pjb>
aeth: only, scripts shall not have extensions!
<sjl>
Lisp's multiline comments and bash's comments happening to use the same # character is just a... "lucky" coincidence
<anamorphic>
How does roswell's scripting differ with cl-launch? (apart from probably finding systems and stuff)
<aeth>
sjl: Technically, you could do the reader hack in the CL part and have a #! at the top as well
<aeth>
But then it's harder to understand
<sjl>
aeth: Yeah, but if you "do the reader hack" you need a separate file for the reader macro to go in, and if you're gonna have a separate file you may as well just do this all in a more reasonable way
<aeth>
yes
<Shinmera>
sjl: No you don't. You can include the definition in the bash sbcl call.
<Shinmera>
as an eval arg
<sjl>
Shinmera: sure, I did that a while back in scrollback
FreeBirdLjj has joined #lisp
<aeth>
Shinmera: That's possible, but now you have to have a different implementation for every CL implementation
<aeth>
Shinmera: Right now, it's pretty clear what to substitute to make it run in ECL or CCL etc.
<aeth>
Once you start having to do something other than calling main it might not be as portable
<aeth>
could be wrong, though
<Shinmera>
sjl: I mean a combination of aeth's trick with a shebang at the top to make it "standard"
<Shinmera>
so #!/bin/bash \n #| \n ...
jmercouris has quit [Remote host closed the connection]
<sjl>
If you do the reader macro in the sbcl args, you don't need aeth's trick, you just use a shebang of sbcl
FreeBirdLjj has quit [Ping timeout: 276 seconds]
<Shinmera>
no, I mean aeth's trich invocation will include the reader macro in /its/ call to sbcl
<jasom>
you can do it without the args by using a here document as well; that might be able to be made portable (modulo parsing native namestrings).
<Shinmera>
so you can just run the script with ./foo
<Shinmera>
also the shebang only allows /one/ arg
<sjl>
Shinmera: but now you can't LOAD it (without also loading the reader macro somewhere)
<aeth>
sjl: You still need the block comment trick. The block comment trick is for bash, not for SBCL
<Shinmera>
sjl: Ah- true enough
<Shinmera>
ah, it's too late for me to bash this around any longer
<aeth>
Shinmera: I think what you were saying was to include the reader macro definition in the --eval ? I don't think it would work, though, because isn't that run after the load?
<aeth>
and the load will read
<Shinmera>
aeth: yea, I wasn't thinking
<aeth>
There might be a way to run something before the load but that's probably implementation-specific
<aeth>
And it would be messy to have non-trivial Lisp in a bash string in a Lisp block comment
<aeth>
sjl: but yeah, you basically have to write bilingual files by (ab)using coincidences like the #| coincidence.