<gigamonkey>
Yeah, in my dream Lisp there might be a *formatter* special variable that would get passed the format string and would return a function that generates the output. So if you wanted you could do (let ((*formatter* #'my-funky-dsl-parser)) (format t "whatever you want here" stuff more-stuff))
<gigamonkey>
Thought that's more about extensibility than readabiliy.
<no-defun-allowed>
You can use any function which acts like one returned from FORMATTER as format control.
xsperry has quit [Remote host closed the connection]
<gigamonkey>
Yeah, that's similar.
<no-defun-allowed>
That makes it (format t (dsl-parser "some notation") stuff more-stuff)
<gigamonkey>
And I guess with a read macro or two you're most of the way there.
mparlaktuna has joined #lisp
<gigamonkey>
Or maybe a *format-table* that maps chars to functions so you can add characters that have meaning after a ~
mindCrime_ has joined #lisp
<pjb>
So something like: (defvar *formatter* (function formatter)) (format t (funcall *formatter* "whatever you want here") stuff more-stuff)
<pjb>
but you would not want to see the (funcall *formatter* ?
<pjb>
(format t (funcall *formatter* "whatever with my ~escapes here") stuff more-stuff)
<gigamonkey>
So (format t "I love UNIX %f%%" 100.0)
<gigamonkey>
Where the format string was obviously processed by a different parser than the default CL format string parser.
<pjb>
or directly: (format t (unix-formatter "I love UNIX %f%%") 100)
<gigamonkey>
Yup. That would get the same effect.
<pjb>
gigamonkey: format control n. a format string, or a function that obeys the argument conventions for a function returned by the formatter macro. See Section 22.2.1.3 (Compiling Format Strings).
<gigamonkey>
Though I like my *format-table* idea better, now. Because then I could implement the lost ~U directive without having to rewrite everything else.
<pjb>
Possibly you could hide your formatter function in a reader macro.
<gigamonkey>
Yes, as I said above.
slyrus_ has quit [Remote host closed the connection]
<jcowan>
166 does have explicit extension: see "Higher Order Formatters and State"
<pjb>
and of course you can go thru all the indirections and tables you want!
<pjb>
format has enough extensibility as it is!
<jcowan>
Having a format-table is reasonable for stringly formatters
<gigamonkey>
the extensibility is kinda gross though due to the package issue.
hjudt has quit [Ping timeout: 240 seconds]
<gigamonkey>
imo
lmm014 has quit [Ping timeout: 240 seconds]
hypercube has quit [Quit: WeeChat 3.1]
hjudt has joined #lisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
shifty has joined #lisp
mparlaktuna has quit [Remote host closed the connection]
rumbler31 has joined #lisp
slyrus_ has joined #lisp
hiroaki has quit [Ping timeout: 248 seconds]
monolithic has quit [Remote host closed the connection]
slyrus_ has quit [Ping timeout: 268 seconds]
nij has quit [Ping timeout: 276 seconds]
yottabyte has quit [Quit: Connection closed for inactivity]
shifty has quit [Ping timeout: 252 seconds]
shifty has joined #lisp
<jcowan>
Unlike readtables, format tables would typically not matter at compile time.
pbaille has joined #lisp
pbaille has quit [Ping timeout: 252 seconds]
hjudt has quit [Ping timeout: 268 seconds]
theothornhill has joined #lisp
theothornhill has quit [Remote host closed the connection]
undvrainbowvita8 is now known as swamps
jeosol has quit [Quit: Connection closed]
ryanbw has quit [Quit: I'll be back.]
ryanbw has joined #lisp
Sheilong has quit []
marusich has quit [Quit: Leaving]
terpri_ has joined #lisp
terpri has quit [Remote host closed the connection]
<White_Flame>
jcowan: format is often used to create symbol names in macros
raeda has quit [Remote host closed the connection]
<no-defun-allowed>
If you say "clhs Erik Naggum" in the mirror three times at midnight...
<fiddlerwoaroof>
I know Erik Naggum was involved in the SGML standardization efforts, are there any reasonably complete lisp implementations of SGML?
hjudt has quit [Ping timeout: 240 seconds]
lmm014 has joined #lisp
lmm014 has quit [Ping timeout: 240 seconds]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
CrazyPython has quit [Read error: Connection reset by peer]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<waleee-cl>
emacs has some sgml stuff in a menu somewhere at least
Oladon has joined #lisp
Volt_ has quit [Quit: ]
notzmv has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
pbaille has joined #lisp
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
pbaille has quit [Ping timeout: 240 seconds]
sauvin_ is now known as Sauvin
notzmv has joined #lisp
<beach>
Good morning everyone!
xkapastel has quit [Quit: Connection closed for inactivity]
hjudt has joined #lisp
<fiddlerwoaroof>
morning, beach!
<beach>
nij: With respect to CommonDoc, I see some design decisions that I would have done differently.
<beach>
nij: For parsing the dpANS, I really haven't thought about it. But I guess it's moot, since it seems to be done now.
<White_Flame>
where is the latest on that parse?
<beach>
Looks like theothornhill did it.
johnjay has quit [Ping timeout: 252 seconds]
<dieggsy>
re: my earlier question about a hunchentoot server that does block, you can just (make-instance 'hunchentoot:easy-acceptor :taskmaster (make-instance 'hunchentoot:single-threaded-taskmaster) ...)
<no-defun-allowed>
Yes, then a. it is single threaded and b. how are you supposed to stop it properly?
White_Flame has quit [Ping timeout: 252 seconds]
White_Flame has joined #lisp
<dieggsy>
*no-defun-allowed*: i'm storing the acceptor in a variable and defining an easy handler that stops it, since all i need is a server that handles a single request
<dieggsy>
it seems to work
<dieggsy>
so the handler takes the request, does something with the info, then stops the acceptor
VincentVega has joined #lisp
johnjay has joined #lisp
VincentVega has quit [Client Quit]
vsync has quit [Read error: Connection reset by peer]
vsync has joined #lisp
pbaille has joined #lisp
semz has quit [Ping timeout: 250 seconds]
pbaille has quit [Ping timeout: 252 seconds]
charles` has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
drl has joined #lisp
VincentVega has joined #lisp
hjudt has quit [Ping timeout: 246 seconds]
hjudt has joined #lisp
elderK has joined #lisp
jeosol has joined #lisp
pbaille has joined #lisp
pbaille has quit [Ping timeout: 260 seconds]
drl has quit [Quit: Leaving]
johnjay has quit [Ping timeout: 252 seconds]
elderK has quit [Quit: WeeChat 3.1]
johnjay has joined #lisp
skapate has joined #lisp
hjudt has quit [Ping timeout: 260 seconds]
skapata has quit [Ping timeout: 260 seconds]
pbaille has joined #lisp
akoana has left #lisp ["Leaving"]
pbaille has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 252 seconds]
natter has quit [Read error: Connection reset by peer]
VincentVega has quit [Quit: Connection closed]
jlarocco has quit [Remote host closed the connection]
<beach>
Suppose we had a documentation system based on (say) "chunks", and each chunk is a standard object that can be read and written using READ and PRINT perhaps with one or two additional reader macros. Suppose further that each chunk has a unique identifier based on Common Lisp universal time plus some random number.
<beach>
In other words, chunk identifiers can be created by the person creating the chunk and we are reasonably sure it is going to be unique. Also, suppose these chunks can either be inlined into other chunks or referred to from other chunks. We could even go so far as to have each individual words be a separate chunk.
<beach>
Such word chunks could then be used in other applications such as spell checkers and grammar checkers. So far so good. However, I would like some input on the process of creating the "database" of chunks. First of all, we can't assume that every word in English (let's start with English) has been turned into a chunk. So we probably need to allow for a Common Lisp string to replace a word chunk.
<beach>
I can see an interactive (CLIM-based?) editor that would allow people to create chunks, and perhaps also taking strings and substituting word chunks in the data base. This process could be "manual" but supported by the tool. For example, a string that has a word chunk in the data base could be highlighted, and the user could examine the possible chunks and select one.
<beach>
But here is where I need a discussion: How do we maintain the "database" of chunks? Individual users will create chunks and store them locally, but how do we merge individual "databases"? Also, we might want to merge updates to a chunk from different users. Should we then create a tool that checks for conflicts and such? And who is in charge of the merge?
* beach
will probably regret having started this thread.
hjudt has quit [Read error: Connection reset by peer]
slyrus_ has joined #lisp
xsperry has joined #lisp
<beach>
Maybe I am exaggerating the problem? Maybe each chunk would belong to some "library" that would be managed just like code libraries are, i.e., there will be one or more maintainers for a GIT repository and people will submit pull requests.
saganman has joined #lisp
notzmv has quit [Ping timeout: 246 seconds]
lmm014 has joined #lisp
<beach>
I should perhaps give some examples of chunk types, so that the idea becomes more clear. The lowest level chunks would be morpheme chunks, word chunks, phrase chunks, sentence chunks, paragraph chunks. Then there would be inline chunks, reference chunks for inserting or referring to other chunks.
<beach>
There would be bibliography chunks, figure chunks, math formula chunks, etc. And there would be specific chunks for documenting code, like chunks corresponding to the different DOCUMENTATION methods, chunks for referring to names in programs like class names, function names, etc. I don't have a complete list of chunk types yet, of course.
DHARMAKAYA has joined #lisp
ebrasca has quit [Remote host closed the connection]
hjudt has joined #lisp
hjudt has quit [Ping timeout: 252 seconds]
tessier has quit [Ping timeout: 260 seconds]
elflng has quit [Ping timeout: 268 seconds]
slyrus_ has quit [Remote host closed the connection]
<fe[nl]ix>
beach: this sounds like RDF ontologies
waleee-cl has quit [Quit: Connection closed for inactivity]
* easye
perks up at the mention of RDF ontologies.
* easye
waves to fe[nl]ix
* easye
nods morning to beach.
skapate has quit [Remote host closed the connection]
<fiddlerwoaroof>
That's another thing I've never been able to find a practical use for
<easye>
Strictly speaking, RDF only has the simplest possible scaffolding for ontologies. One usually layers in something like OWL2 for any real ontological reasoning. OWL2 happens to have an RDF serialization, which might confuse things.
<fiddlerwoaroof>
And/or lisp tools with decent documentation
<easye>
One can get pretty far with abcl by using W3C RDF stacks which tend to have a JVM implementation.
<beach>
fe[nl]ix: I don't see any ontology in there at all.
hjudt has joined #lisp
<easye>
We will be having an ELS2021 dress rehearsal today sometime after 1000 UTC in which we could use people to help smoke test the participatory a/v infrastructure we have been preparing. Join #elsconf for details if you are interested.
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
<fe[nl]ix>
beach: "morpheme chunks, word chunks, phrase chunks, sentence chunks, paragraph chunks" <- those are ontologies
<beach>
Fair enough.
<fe[nl]ix>
beach: the problem I see there is that most people who write documentation don't want to accurately annotate what they're writing
<fe[nl]ix>
it's much more convenient to just write text and rely on the readers to figure out the context
<beach>
And they won't have to because of the strings.
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
asarch has joined #lisp
<phoe>
/21
<phoe>
oops
frost-lab has joined #lisp
slyrus_ has joined #lisp
slyrus_ has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 252 seconds]
slyrus_ has joined #lisp
maxwilliamson has joined #lisp
lmm014 has quit [Remote host closed the connection]
slyrus_ has quit [Ping timeout: 240 seconds]
andreyorst[m] has joined #lisp
lmm014 has joined #lisp
<splittist>
beach: I'm missing the point of having a shared database of chunks. Is this for collaborating on public documentation, or ... ?
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
notzmv has joined #lisp
zaquest has quit [Read error: Connection reset by peer]
<beach>
splittist: It would be good if low-level chunks such as words, bibliography entries, etc. were shared.
<beach>
splittist: But I guess that's not terribly important.
<beach>
splittist: Also, for the purpose of cross references, like if the documentation for one system would like to refer to the documentation of another system.
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
nij has joined #lisp
<saganman>
Morning beach
<saganman>
Morning #lisp
<beach>
Hello saganman.
<saganman>
Happy Weekend!
<beach>
nij: See the logs for ideas on the kind of documentation system I might want to see. As you can see, CommonDoc is not quite it. Also, don't expect me to be present between 19:00 and 05:00. And, try to avoid private messages for subjects that are interesting to more than you and me.
hjudt has quit [Ping timeout: 240 seconds]
hjudt has joined #lisp
<beach>
I guess I would have to create some kind of demo of the "chunk" system to see whether it is technically feasible.
Oladon has quit [Quit: Leaving.]
Inline has joined #lisp
lmm014 has quit [Remote host closed the connection]
lmm014 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
lmm014 has quit [Ping timeout: 252 seconds]
<splittist>
beach: OK. I keep thinking about #<chunk "Very secret stuff" #xABCD> and #<chunk "Personally identifiable information, imposing obligations on everyone who has a copy" #xFACE> etc.
zaquest has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
imode has quit [Ping timeout: 268 seconds]
hjudt has quit [Quit: leaving]
lmm014 has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
<beach>
splittist: Sharing would not be an obligation, if that's what you think.
<jdz>
There's also the #<chunk "I thought this is OK to share, but then got fired. #xDEADBEEF>.
<jdz>
Heh, "zippered lists" sound much cooler than "chunks."
<jdz>
At least in this channel.
hendursaga has joined #lisp
Inline has quit [Quit: Leaving]
asarch has quit [Quit: Leaving]
Inline has joined #lisp
notzmv has quit [Ping timeout: 240 seconds]
lmm014 has quit [Ping timeout: 265 seconds]
jeosol has quit [Quit: Connection closed]
varjag has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
lmm014 has joined #lisp
mindCrime_ has quit [Ping timeout: 252 seconds]
cognemo has quit [Quit: cognemo]
cognemo has joined #lisp
aartaka has joined #lisp
lmm014 has quit [Ping timeout: 268 seconds]
supercoven has joined #lisp
notzmv has joined #lisp
RED971 has joined #lisp
notzmv is now known as Guest96063
RED971 has left #lisp [#lisp]
theothornhill has joined #lisp
lmm014 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
surabax has joined #lisp
amb007 has joined #lisp
lmm014 has quit [Ping timeout: 260 seconds]
heisig has joined #lisp
theothornhill has quit [Read error: Connection reset by peer]
theothornhill has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
nij has quit [Ping timeout: 276 seconds]
lmm014 has joined #lisp
pve has joined #lisp
lmm014 has quit [Remote host closed the connection]
lmm014 has joined #lisp
<theothornhill>
I mailed Kent Pitman about the dpANS to see if he knows the status with regards to copyrights for the hyperspec and the dpans. Hopefully he knows something about it and is willing to share
<beach>
Good idea!
<theothornhill>
Worth a try, at least
<beach>
Absolutely.
aartaka has quit [Read error: Connection reset by peer]
<theothornhill>
beach: as for the document, how do you envision I handle the macros? I can expand everything now using this perl script, but I lose a lot of semantics doing that
<beach>
Good question. I haven't given it enough thought.
<theothornhill>
I think it might be better to expand all the "\input foo" and concatenate everything and use the macros as parsable items
<beach>
I take your word for it.
lmm014 has quit [Remote host closed the connection]
<beach>
We could also contact ANSI. They do not seem to make any money from this particular standard.
<theothornhill>
Now it is simple to grab the two \displaythree{Foo}{Bar}, rather than 75 lines of tex primitives
lmm014 has joined #lisp
lmm014 has quit [Ping timeout: 268 seconds]
Guest96063 has quit [Remote host closed the connection]
notzmv- has joined #lisp
<theothornhill>
beach: I'll pop a mail to a few of them :P
theothornhill has quit [Ping timeout: 268 seconds]
<phoe>
"We, as a community, expect to continue to own the spec." is the particular quote I am interested in
<phoe>
in this context, I can infer that the specification is public domain but a standard that's based on it to the point of being identical is ANSI-copyrighted
<phoe>
and ANSI copyrights the fact that it has "the standard", along with the graphical rendition of it
<phoe>
but it can't copyright the sources behind it, which is dpANS3, the result of X3J13
<Wikipedia[m]>
*X3J13* is the name of a technical committee which was part of the International Committee for Information Technology Standards (INCITS, then named X3 ). The X3J13 committee was formed in 1986 to draw up an American National Standards Institute (ANSI) Common Lisp standard based on the first edition of the book Common Lisp the Language (also termed CLtL , or CLtL1 ), by Guy L. Steele Jr., which was formerly a de facto
<Wikipedia[m]>
standard for the language. The primary output of X3J13 was an American National Standard for programming language Common Lisp (X3.226/1994), approved December 8, 1994. X3J13 later worked with International Organization for Standardization (ISO) working group SC22/WG16 on an internationally standardised dialect of Lisp named ISLISP.
<Wikipedia[m]>
The original chair of the committee was Doctor Robert Mathis of Ohio State University, with Mary van Deusen as secretary. Guy L. Steele Jr. was originally the vice-chair. In later years, Mathis stepped down as chair and Steele a...
<phoe>
nice
theothornhill has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
Thankyou for taking a bot to #lisp. Though if it makes okay output on IRC it'd be nice.
<Inline>
ah sorry
<no-defun-allowed>
Okay, so the bot says nothing on IRC and Mrtn Dk looks like they are talking to the wind.
<MrtnDk[m]>
Oh, this is the IRC-lisp room. Sorry.
<phoe>
no-defun-allowed: I actually can't see the bot output in the tymoon log, which is decent
<phoe>
but I see the output in my IRC client
<no-defun-allowed>
Just "<foo> sent a long message" or something else?
<phoe>
a whole big snippet of the article; I'll send a screenshot on query
<no-defun-allowed>
Does that bother you? Don't read it as if I'm saying it should, I'm just wondering.
<no-defun-allowed>
Suppose saying "nice" suggests it doesn't. I'll be more awake in 46 hours surely.
<phoe>
doesn't bother me
<phoe>
if it was used multiple times a day it probably would but it's the first time I ever saw it here, so nah
<_death>
I don't think bots should generate multiple messages given a single command
blackadder has quit [Quit: WeeChat 2.3]
<_death>
even if there are other means of rate control, it's just clutter and I'll likely /ignore it
<phoe>
that too
notzmv- has quit [Remote host closed the connection]
notzmv has joined #lisp
<MrtnDk[m]>
I guess if an @ on IRC side kicks the bot, it will be kicked on the matrix side as well. fe[nl]ix
lotuseater has quit [Ping timeout: 276 seconds]
kevingal has joined #lisp
<jeosol>
phoe: I realized you are one of the contributors listed on cl:yesql. Is it possible to somehow issue multiple commands, e.g., a create extension command, then a CREATE table command, and possible an index later on. See this paste: https://pastebin.ubuntu.com/p/BZfhCVMGMC/
<jeosol>
So far, i get errors that "cannot insert multipe commands into a prepared statement".
<jeosol>
I am doing small tests, the issues i sometimes get with ORM's makes me want to explore the alternative and write the sql queries. So I started looking at alternatives
<phoe>
that's a postgres limitation, not a yesql one
<jeosol>
Thanks. for clearning that up. When I split the command into separate function calls, it works. Closed
<phoe>
perfect
lotuseater has joined #lisp
<jeosol>
so what's your take and experience on the ORM use
<phoe>
I actually found cl-yesql really useful to be able to avoid ORMs in general
<phoe>
(since that's my take, and a bit of experience)
<jeosol>
Yeah, I agree with that, which is why I started learning it
<phoe>
it's a really really nice wrapper that allows me to treat SQL statements as Lisp functions
<phoe>
and it just works™ - I only had trouble with the initial setup and overlord/vernacular when combo'd with some EVAL-ALWAYS situations, but afterwards, it works
<jeosol>
I am no postmodern or mito expert, but sometimes, the lack of transparency and need for more complex operations, I start having problems
<jeosol>
I understand SQL more so using the queries directly seems to present less issues. And then you get the statement as functions.
<jeosol>
Yes, I did benefit from those examples to get the initial setup to work
<phoe>
and you get to write unit tests in Lisp for those that treat these functions as API
<phoe>
I really like this
<jeosol>
phoe: I do agree. cent pourcent
theBlackDragon has quit [Ping timeout: 265 seconds]
<jeosol>
I haven't been here much; have some abstracts that are due and trying to finish some of the work; crazy days
<phoe>
yes
<phoe>
and here I'm busy with #.*dayjob* and ELS prep work
<phoe>
things are looking good for the latter and not very good for the former, but that's business as usual
lmm014 has quit [Remote host closed the connection]
<jeosol>
Regarding ELS, do you guys accept paper about application, e.g., describing the use of CL to build an application?
lmm014 has joined #lisp
<jeosol>
great work by the way. I'll get to support you guys soon. My task is coming to an end, once I get the web thingy going
<phoe>
jeosol: I think we generally accept those, yes
<phoe>
heisig will be able to confirm
<phoe>
(though I personally think it would be a welcome submission next year)
<jeosol>
I'll like to contribute something along those lines. I know it's closed for this year
<heisig>
jeosol: Yes, ELS accepts both classical academic papers of up to eight pages, and software demonstrations of up to four pages.
<phoe>
jeosol: please do, then!
lmm014 has quit [Ping timeout: 260 seconds]
<jeosol>
phoe, heisig: Thanks for confirmation; I like to contribute something.
<jeosol>
I benefitted a lot from the answers to my earlier questions here. Great job guys
<phoe>
:D
theBlackDragon has joined #lisp
lmm014 has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
klltkr has joined #lisp
lmm014 has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
cage_ has joined #lisp
seok has joined #lisp
<seok>
anyone experience latency using libraries which use winhttp?
oxum has joined #lisp
oxum has quit [Client Quit]
<seok>
I often get timeout error on dexador from winhttp, and is also quite slow
<seok>
When I run the same piece of code on a linux machine on the same network it's blazingly fast, no problem
lmm014 has joined #lisp
theothornhill has joined #lisp
lmm014 has quit [Ping timeout: 252 seconds]
theothornhill has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 260 seconds]
Inline has joined #lisp
shifty has quit [Ping timeout: 268 seconds]
shifty has joined #lisp
shifty has quit [Ping timeout: 252 seconds]
shifty has joined #lisp
theothor` has joined #lisp
theothor` has quit [Remote host closed the connection]
lmm014 has joined #lisp
lmm014 has quit [Ping timeout: 240 seconds]
pbaille has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 252 seconds]
raeda_ has quit [Remote host closed the connection]
<lotuseater>
why does the disassemble of functions with TAGBODY gets so big? ^^
flip214 has quit [Read error: Connection reset by peer]
<loke[m]>
lotuseater: Do they?
<loke[m]>
Which Lisp impementation?
flip214 has joined #lisp
<lotuseater>
on SBCL
<lotuseater>
yeah i wondered too
<loke[m]>
Do you have a specific example?
<lotuseater>
i have here a TAGBODY with four labels and it gets 1100 bytes big
<lotuseater>
yes an algorithm from TAOCP volume 4
CrazyPython has joined #lisp
<loke[m]>
I just did this, and I don't think it's any bigger than you'd expect:
<loke[m]>
(disassemble #'(lambda (x) (tagbody a (print 1) (go c) b (print 2) (go d) c (print 3) (go b) d (print 4))))
<loke[m]>
All I can tell from that is that there seems to be nothing special about TAGBODY. You'll have to come up with an example we can run so we have something to analyse.
<beach>
Like for instance: (let (... perms) ...) means "I am not initializing perms explicitly because I intend to assign to it before it is used" But then you use it before you assign to it.
<lotuseater>
ah hm this part is for prototyping, it's an empty list at the beginning
<beach>
And (= j 0) is better expressed as (zerop j). There is a general rule in programming that you should use the most specific construct that will do the work.
<beach>
lotuseater: Semantically, it's an empty list, but it is not an empty list in the message that you send to the person reading your code.
<lotuseater>
yes you're right of course :)
<lotuseater>
yes
lmm014 has quit [Ping timeout: 252 seconds]
pbaille has joined #lisp
ssbnxx has quit [Quit: Connection closed for inactivity]
hypercube has joined #lisp
vms14 has joined #lisp
<dieggsy>
beach: wait, so what's the difference between (let ((this) ...) ...) and (let (this ...) ...))
Sheilong has joined #lisp
<lotuseater>
hm the former wouldn't work in this form, will it?
<lotuseater>
the latter initializes with NIL
slyrus_ has joined #lisp
<TMA>
dieggsy: just stylistic
<TMA>
lotuseater: both will bind this to nil
<beach>
dieggsy: Semantically, there is no difference, but I see no use for (let ((this)
<beach>
TMA: "just"?
<lotuseater>
ah okay
<dieggsy>
lotuseater: the former is actually what i use lol, only because i didn't realize (let (this ...) ...) is alllowed
<lotuseater>
haha and for me vice versa :)
<beach>
If you write a compiler for Common Lisp, you will have to know all the variants. :)
<TMA>
beach: I have written a (part of a) compiler, I am prone to dismiss differences that have no effect on the resulting code.
<vms14>
must be hard to write a common lisp compiler
<beach>
TMA: I am sorry to hear that. You are giving your maintainer a hard time.
<lotuseater>
but with this now I even once more get the feeling I can become at anything and that makes me sad, but it's too offtopic
<vms14>
don't even know how abcl devs wanted to use java for writing a lisp compiler
<vms14>
that must be a real pain
<lotuseater>
*good
<vms14>
I suppose the way is to write minimal stuff in the "host language" and much as possible in your lisp implementation
<lotuseater>
yeah but after a certain point you can write most stuff in lisp
orivej has joined #lisp
<dieggsy>
beach: which compiler did you write ?
<beach>
vms14: Is ABCL written in Java? I am asking because there is no particular reason to do that.
<TMA>
beach: I am my own maintainer, mostly (the rest of my work no longer maintained). But I do have rather strong style preferences. I just resigned trying to enforce them on others or explaining them.
<beach>
TMA: I see. I find that even if I am the maintainer of my own code, I have to be very disciplined, or else I won't forget it some weeks later.
<beach>
minion: Please tell dieggsy about SICL.
<minion>
dieggsy: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<beach>
minion: Please tell dieggsy about Cleavir.
<minion>
dieggsy: Cleavir: A project to create an implementation-independent compilation framework for Common Lisp. Currently Cleavir is part of SICL, but that might change in the future
<lotuseater>
hehe
<lotuseater>
and then the new McCLIM
<beach>
vms14: There is no particular reason to use any "host language" at all, as the SICL bootstrapping technique shows.
<TMA>
beach: I do have quite consistent style, I think. I use it when not under undue time pressure. In the other case anything goes. It makes me sad, though less sad than missed deadline.
<vms14>
my technique is to use s7 scheme, which is a .h and a .c file and you can just add your own stuff in it, but it's scheme not cl, which meh. I really prefer cl, I guess just because it's the lisp I used
<beach>
TMA: I see, yes.
<beach>
dieggsy: The compiler framework is in use production in Clasp, and the SICL compiler is of course based on it too.
<TMA>
Consistent and sensible style is very good otherwise.
<vms14>
and don't like that define is also defun
<beach>
dieggsy: Oh, and I should add that, even though I started it, Bike and karlosz have done a lot of work on Cleavir lately.
<beach>
vms14: So it is hard to write a Common Lisp compiler, but it is an order of magnitude harder to write an implementation-independent compiler framework. :)
* lotuseater
has high respect for things like that and asks how he can ever catch up to this expertise
<vms14>
to write lisp you first write lisp so it helps you writing lisp
<beach>
lotuseater: It has taken me the better part of a lifetime, because I am not particularly smart; just stubborn.
<lotuseater>
haha ok, so also training :) and good advises by the wise people
<vms14>
lispers are so used to recursion that they use recursion in they whole design
<vms14>
their*
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
lmm014 has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
lmm014 has quit [Ping timeout: 265 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
White_Flame has quit [Ping timeout: 240 seconds]
<ecraven>
thanks for pointing out cl-yesql, this finally seems like a sane approach to "sql as a dsl"
mrchampion has quit [Ping timeout: 265 seconds]
mrchampion has joined #lisp
White_Flame has joined #lisp
lmm014 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
nij has joined #lisp
lmm014 has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
seok has quit [Quit: Connection closed]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<engblom>
When building up a plist, is it ok to first push value and then push key? Or could I push both at the same time?
<nij>
How are you going to build a plist?
amb007 has joined #lisp
<vms14>
engblom: for symbol property lists I always used (set) for any property
<vms14>
even made a macro named setp
<vms14>
(defun setp (symbol property value)
<vms14>
(setf (get symbol property) value))
<engblom>
nij: It will be something like (:key1 :value1 :key2 :value2 :key3 :value3 ...) and I will begin with an empty list, and then adding one pair at the time
amb007 has quit [Read error: Connection reset by peer]
<beach>
engblom: You can push the value and then the key, provided you don't use the list between the two operations.
amb007 has joined #lisp
<beach>
engblom: Why would it not be OK?
Jesin has joined #lisp
<engblom>
beach: Thanks, then I will do so. I am just asking if it is OK, as I am still very new to lisp and somtimes there are better ways to do things that what I know about.
<pjb>
engblom: of course, list* can be used for any number of new elements.
<nij>
_death: but it's less flexible :-(
lmm014 has joined #lisp
<nij>
Btw, is there a de facto way to help access to places deeply nested? Something like
<pjb>
vms14: there are always exceptions and circumstances. If the set of fields is fixed, it may be better to use structures than plists. If the set of keys is variable and you want to accept keys not known at compilation-time, then plists are better.
<pjb>
nij: tiling let's you prevent a certain class of cockpit error: the case where something is displayed in a window, but you cannot see it because that window is hidden behind another window.
<pjb>
nij: therefore tiling is important on control panel applications where you want to be sure that the information is visible to the operator.
<_death>
nij: anyway, check out cl-eval-bot
rumbler31 has quit [Ping timeout: 252 seconds]
<semz>
Is there a way to get access to an internal function (generally but in CCL is fine too) as an object? DISASSEMBLE will only give me the outer function's code and pulling it out would be rather annoying.
<pjb>
nij: it's simply not specified how and when the loop variables are bound. Even (let ((fs '())) (dotimes (i 6) (push (lambda () i) fs)) (mapcar (function funcall) fs)) is not conforming. So mutating the variable i is even conforming.
<pjb>
Instead, you can write either: (let ((fs '())) (let (k) (dotimes (i 6) (setf k i) (push (lambda () k) fs)) (mapcar (function funcall) fs))) #| --> (5 5 5 5 5 5) |#
<pjb>
to receive conforming results.
<pjb>
and of course, if you want to modify your loop variable: (loop with i = 0 while (< i 10) collect i do (incf i (1+ (random 3)))) #| --> (0 3 5 6 8) |#
thrashdin has joined #lisp
thrashdin is now known as aun
<nij>
got it :)
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
slyrus_ has quit [Remote host closed the connection]
skapata has joined #lisp
theothornhill has joined #lisp
<theothornhill>
beach: So Kent Pitman came back to me, with an enthusiastic reply. Nice! He says that the dpANS is the way to go, and a suit is unlikely. He'd _not_ recommend making a CLHS 2.0, and would rather focus on creating a "WikiSpec" starting from the dpANS, allowing the spec to be alive, without requiring to go through a committee for every typo, not to mention real bigger changes
<minion>
theothornhill, memo from nij: I've read the log and am glad to know if there's any news back from the people you mail.
<phoe>
:D
<theothornhill>
nij: I think this sounds smart. We could then start by displaying the spec as it is, then work incrementally on creating a live, documented and annotated spec that caters to more modern needs
slyrus_ has joined #lisp
<theothornhill>
(If we allow a feature to disable every annotation we'd avoid the need to go through some uncoordinated committee, since the real, trusted spec is only one click away)
<theothornhill>
His reply is way too long to post here, so I'll ask him if I could publish some or all of it for posterity.
<phoe>
this is like the UltraSpec except done correctly this time
slyrus_ has quit [Ping timeout: 240 seconds]
<theothornhill>
phoe: I say we try. I'll start work on htmlizing the spec this evening. I also have done some initial work on making the transition from dpANS to something else reproducible, so we don't have to worry about keeping things verbatim, which would be super important as a first step should this work
ym has joined #lisp
ym has quit [Client Quit]
<vms14>
can minion save a memo for itself?
<vms14>
minion: memo for minion: :O
<minion>
Buzz off.
<vms14>
meh
slyrus_ has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
slyrus_ has joined #lisp
<phoe>
theothornhill: any method that turns dpANS into something lispy is going to work
<phoe>
I was ogling AsTeR as a TeX parser written in Lisp - I told you about that, right?
<theothornhill>
phoe: no, but you did now :) I'll look into that
<phoe>
OK
<phoe>
basically, AsTeR solves a different problem
<phoe>
tvraman is not capable of seeing, so he wanted a way to translate TeX papers into audio
vms14 has quit [Remote host closed the connection]
<theothornhill>
wild
<phoe>
and he did that by parsing TeX into Lisp and then serializing Lisp objects into commands sent to a TTS device
<phoe>
I think we'd be interested in that first part
slyrus_ has quit [Ping timeout: 268 seconds]
<phoe>
it seems that this code mostly loads and works even on modern lisp implementations, though it needs to get some overall polishing
<theothornhill>
Do you know if he's open to PRs and maintaining AsTeR?
<theothornhill>
In getting it into quicklisp etc
<phoe>
yes
<phoe>
I mailed him and he's open to that
<theothornhill>
Nice
<phoe>
there is a C module in there called "lex" that should be rewritten in Lisp
<phoe>
oh wait, not a C module - it's a C program, a lexer
<theothornhill>
Pitman also told me to be sure to organize such an effort with other people, to make sure we don't double the work, considering it's a small community
White_Flame has quit [Remote host closed the connection]
White_Flame has joined #lisp
slyrus_ has joined #lisp
mindCrime_ has joined #lisp
slyrus_ has quit [Ping timeout: 252 seconds]
jeosol has quit [Quit: Connection closed]
jeosol has joined #lisp
rumbler31 has joined #lisp
cosimone has joined #lisp
gourdhen has joined #lisp
theothornhill has quit [Remote host closed the connection]
theothornhill has joined #lisp
cosimone has quit [Client Quit]
White_Flame has quit [Ping timeout: 252 seconds]
cosimone has joined #lisp
DHARMAKAYA has joined #lisp
mindCrime_ has quit [Ping timeout: 252 seconds]
Bike has quit [Quit: Connection closed]
White_Flame has joined #lisp
oxum has joined #lisp
oxum has quit [Client Quit]
raeda has joined #lisp
indathrone has joined #lisp
slyrus_ has joined #lisp
<phoe>
yes
slyrus_ has quit [Ping timeout: 240 seconds]
<engblom>
I did my first try with a macro, but failed: I tried to put both the macro and some kind of explanation of what I want here: https://pastebin.com/snBdwRdE
<flip214>
engblom: first thing, you'll want to learn backquote.
<theothornhill>
engblom: ^ this
<phoe>
engblom: second thing, what do you want the resulting, macroexpanded code to look like?
<flip214>
second, there are some things missing... some declarations (what is set-on-change?), and the problem you have.
<flip214>
do you get an error, a warning, does it do something unexpected, ...?
<engblom>
It compiles, but when I run it I end up in debugger with:
<engblom>
There is no applicable method for the generic function #<STANDARD-GENERIC-FUNCTION CLOG:VALUE (3)>
<engblom>
when called with arguments (NIL).
<engblom>
(set-on-change ...) is a function from clog library and service-type is a clog object
<engblom>
Is it OK that set-service-paramaters is a local function made with label?
<_death>
engblom: I suggest to replace "defmacro" with "defun" and try to get (custom-set 'set-service-parameters 'p) to result in the form you want
waleee-cl has joined #lisp
notzmv has quit [Ping timeout: 260 seconds]
<_death>
oh, I missed the problem description.. the issue you may have is one discussed today in this channel..
<_death>
where a binding is changed in a loop.. perhaps an expansion like (let ((p-var p)) (lambda (obj) (declare (ignore obj)) (set-service-parameters p-var))) will work (note that I use "p-var" but in your macro you should generate a symbol each time, say using GENSYM)
<engblom>
_death: So I have a loop that creates a lot of clog objects, and each clog object needs its own function that should be run when they are changed. In this case the only difference that should be in the function is the argument to set-service-parameters. The p binding is changed in the loop, so I tried to use a macro to generate the function.
<_death>
well, you can just use a function to generate the function.. you'll pass #'set-service-parameters to it instead
<engblom>
_death: I do not understand how. The problem is that the clog obj will always be passed to whatever I give (set-on-change ...)
<_death>
engblom: do you understand (defun foo (x) (lambda (y) (+ x y))) ?
<engblom>
_death: Yes, I think so
<_death>
engblom: good, so what would be the analogous form in your case?
<engblom>
I do not what you mean with "analogous form"
<_death>
you need a function that takes f and x, and returns a function that takes an obj (and ignores it) and calls f with x
theothornhill has quit [Ping timeout: 240 seconds]
theothornhill has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<_death>
so that for example (funcall (custom-set #'- 123) 42) => -123
<engblom>
_death: I got it to work now!
<engblom>
_death: Thank you very much!
<_death>
so you write that function?
contrapunctus has joined #lisp
<_death>
*wrote
<engblom>
_death: Yes, I wrote the function
kiwichap has joined #lisp
<kiwichap>
hello
<_death>
so now you can change the name to a more general name, say ALWAYS and have it take &rest parameters instead of just (f x) or (obj).. or you could call it say ALWAYS-FN and have an ALWAYS macro that expands to `(always-fn (function ,function-name) ,@args)
<kiwichap>
how hard is it going to be to learn lisp?
<_death>
so that you can write (always (set-service-parameters p)) ;; inner parentheses are stylistic
slyrus_ has joined #lisp
<kiwichap>
basically I want to write a website that can access a database
<kiwichap>
so like there's certain parts involved like authentication, session, different users
<kiwichap>
is lisp the right language? first off or I should be using something else?
<theothornhill>
kiwichap: lisp can do that for sure. I guess it depends on what you'd be interested in focusing on. If just getting that app up and running, I'm sure some python, ruby og js frameworks will be quicker
slyrus_ has quit [Ping timeout: 252 seconds]
<kiwichap>
I never did any of them and haven't done all the much programming but I somehow got a degree in it if that makes sense
Bike has joined #lisp
<Xach>
Yeah, there are other environments where tasks like that are a matter of filling in some blanks. Common Lisp isn't one of them, mostly.
<kiwichap>
I don't even know where to start really
<kiwichap>
I did a little bit of Java in school , so much complications there, then I did some php on my own, I did my first cgi scripts and a hello world or 2 in lisp
<theothornhill>
If you are motivated, lisp is super fun though
ft has quit [Ping timeout: 260 seconds]
<kiwichap>
thanks
<kiwichap>
I'll give it a go my friend's father used to program lisp when he worked for Bell
cage_ has quit [Quit: Leaving]
slyrus_ has joined #lisp
Spawns_Carpeting has quit [Ping timeout: 260 seconds]
Spawns_Carpeting has joined #lisp
jonatack has quit [Ping timeout: 265 seconds]
<rumbler31>
phoe: I'm looking at running your ansi-tests branch of ccl. I'd like to reproduce your results. How did you go about building that branch?
jonatack has joined #lisp
<phoe>
rumbler31: that is a very bad time to ask this question
<phoe>
I will be able to help you build that on Thursday or later - right now I'm 100% in ELS-local-chairing mindset
<phoe>
please leave an issue on the repo and I will try to come back to you
<rumbler31>
oh right that's coming up
<phoe>
if I don't, please mercilessly remind me that I allowed you to mercilessly remind me
<rumbler31>
lol will do
gitgood has quit [Quit: Probably away to do something really awesome]
<jcowan>
ABCL is partly written in Java
slyrus_ has quit [Ping timeout: 252 seconds]
<phoe>
rumbler31: "that's coming up" is a pretty neutral way to put it
CrashTestDummy3 has joined #lisp
<rumbler31>
yea I bet. I'm disappointed because I was looking forward to watching it live, but this is the week I have to go into the office and I won't be able to watch
aindilis has joined #lisp
CrashTestDummy2 has quit [Ping timeout: 240 seconds]
<ebrasca>
I have see it, it does not show how to get the file data.
<ebrasca>
I get this (#P"/tmp/hunchentoot/hunchentoot-6" "tmp.html" "text/html")
notzmv has joined #lisp
<LispSporks>
Yeah you can take the CAR of that to get the file name
<ebrasca>
I get it , hunchentoot did save the file to the first place.
anticrisis has joined #lisp
<ebrasca>
couldn't rename a to b Invalid cross-device link
<LispSporks>
Probably means where it saved it and where you tried to rename it too, are on different filesystems. Try a file copy instead.
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
orivej has joined #lisp
nature has quit [Ping timeout: 260 seconds]
Bike has joined #lisp
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
<ebrasca>
It does work , thanks!
elderK has joined #lisp
seok has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
<engblom>
How would you loop over a plist where you want each pair?
igemnace has joined #lisp
<Bike>
(loop for (key val) on plist by #'cddr ...)
slyrus_ has quit [Remote host closed the connection]
<engblom>
Bike: Thanks!
<phoe>
sleep time for me
<phoe>
see you tomorrow at the symposium
pbaille has quit [Remote host closed the connection]
LispSporks has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<engblom>
phoe: Good night!
slyrus_ has joined #lisp
jeosol has quit [Quit: Connection closed]
Krystof has quit [Ping timeout: 260 seconds]
<pjb>
Does anybody know how to use Nathan Froyd's diff system?
<pjb>
There doesn't seem to be any example, and the reference doc is useless.
slyrus_ has quit [Ping timeout: 265 seconds]
karlosz has joined #lisp
igemnace has quit [Ping timeout: 248 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
jeosol has joined #lisp
* |3b|
wonders if slime's receive-if (on sbcl) should bind *break-on-signals* to NIL, since it seems to get confused if condition-wait SIGNALs a deadline, causing it to try to run a debugger-loop inside the with-mutex, which does receive-if, which gets recursive lock error in with-mutex, which runs debugger, etc
<|3b|>
or if there is some better way to handle things, or if that isn't what's happening in the first place
pve_ has joined #lisp
koolkat332 has joined #lisp
pbaille has joined #lisp
pve has quit [Ping timeout: 240 seconds]
kiwichap has quit [Ping timeout: 252 seconds]
varjag has quit [Ping timeout: 265 seconds]
luna_is_here has quit [Quit: luna_is_here]
luna_is_here has joined #lisp
pbaille has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
karlosz has quit [Quit: karlosz]
pbaille has joined #lisp
Inline has quit [Ping timeout: 260 seconds]
<|3b|>
or alternately, if force-output on slime-output-stream shouldn't use deadlines in the first place
aun has quit [Quit: Connection closed]
pbaille has quit [Ping timeout: 252 seconds]
<|3b|>
(let ((*break-on-signals* t)) (loop repeat 10000 do (format t "~c" (code-char (random 1000000))) (force-output))) seems to reproduce it reliably (random characters so emacs has to go digging for fonts slowing it down enough to trigger the 0.1 sec deadline)
<|3b|>
and rebinding *break-on-signals* around connection-wait seems to fix it
<mister_m>
is there a way to check for the presence of a value of a slot in an object without tripping an UNBOUND-SLOT condition? I was using (slot-value ...) when I ran into this, thinking I could test with (null ...)