jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <https://irclog.tymoon.eu/freenode/%23lisp> <https://irclog.whitequark.org/lisp> <http://ccl.clozure.com/irc-logs/lisp/> | offtopic --> #lispcafe
<pjb> (let ((list '()) (cell '())) (declare (dynamic-extend cell)) (loop repeat 10 do (setf cell (cons 'a list)) (setf list cell)) (prin1 list) (values)) #| (a a a a a a a a a a) |#
<pjb> assuming of course, that prin1 doesn't store the list somewhere for later (this would be dragons out of the nose).
<kagevf> pjb: wouldn't asdf:load-system recompile any defuns anyway even if they're in the same file as the defmacros they are using? and even if the macros are in a different system, wouldn't that still be the case? if what I just said is wrong, I'd be very interested in knowing, since that might explain some things I've observed and don't fully understand ...
tophullyte has quit [Remote host closed the connection]
Inline has quit [Ping timeout: 260 seconds]
notzmv has joined #lisp
mindCrime_ has quit [Ping timeout: 265 seconds]
<White_Flame> pjb: that CONS call in there heap allocates
<White_Flame> (at least in SBCL, with optimizations on)
notzmv has quit [Remote host closed the connection]
zefram22 has quit [Ping timeout: 260 seconds]
srhm has quit [Quit: Konversation terminated!]
DHARMAKAYA has joined #lisp
igemnace has joined #lisp
<White_Flame> but, (let ((cell (cons ...))) (declare (dynamic-extent cell)) (push cell list)) might do it, it just leaves the scope of the LET which might make it immediately invalid depending on the compiler
djuber has quit [Ping timeout: 240 seconds]
<White_Flame> which is the weirdness I hit in terms of dynamically consing up stuff on the stack (which may or may not be possible based on the stack discipline of the compiler as well)
notzmv has joined #lisp
nicktick has joined #lisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
srandon111 has joined #lisp
srandon111 has left #lisp [#lisp]
Guest80223 is now known as CrazEd
CrazEd is now known as Guest50620
notzmv has quit [Ping timeout: 240 seconds]
hjudt has joined #lisp
djuber has joined #lisp
monolithic has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 240 seconds]
housel has quit [Read error: Connection reset by peer]
frost-lab has joined #lisp
zefram22 has joined #lisp
bilegeek has quit [Quit: Leaving]
djuber has quit [Ping timeout: 276 seconds]
elderK has joined #lisp
gusmv has joined #lisp
wxie has quit [Read error: Connection reset by peer]
<pjb> kagevf: in the same file yes, but not in other files, if they don't depend on the file where the macros are defined.
<pjb> kagevf: if you modify a system and reload it, this doesn't make asdf reload the systems that depend on it! You need to load a leaf system to have all the dependencies recompiled and reloaded. So if you have N systems in a project, you could define an artifical N+1 bottom system that would depend on all the N system, and that you could reload when you modify any of the N system, to have it and all its dependents be reloaded.
Sauvin has quit [Ping timeout: 265 seconds]
<pjb> White_Flame: well, dynamic-extend doesn't imply stack. An implemented could use a separate heap, managed similarly to the old Pascal heap, which is basically a parallel, data stack, instead of a garbage collected heap.
<White_Flame> still, my example exits the lexical scope the var is defined in, while it still keeps it alive, be it the process stack or not
<pjb> White_Flame: upon entry in a function the function records the size of this dynamic-extend heap; dynamic-extend objects are allocated there (simply incrementing the size of the heap), and when the function returns, it resets the size of the heap to the saved value.
<pjb> White_Flame: of course, that doesn't work for closures.
<White_Flame> and yours might allocate outside the dynamic-extent
Oladon has quit [Quit: Leaving.]
<pjb> Indeed, if you break the dynamic-extend, dragons out of the nose.
<pjb> It's not a weidness, it's a dire non-conformity.
<pjb> +r
hjudt has quit [Ping timeout: 252 seconds]
Guest50620 is now known as CrazEd
<saturn2> my impression was that in sbcl, dynamic-extent doesn't affect setf assignments at all
<pjb> White_Flame: and remember all declarations but special declarations can be ignored by the implementation.
CrazEd is now known as Guest66658
<White_Flame> sure, but the actual expressibility is in question
<saturn2> you have to do some sort of continuation-passing kind of thing if you want to build a dynamic-extent list a little at a time
<White_Flame> but with CPS, dynamic-extend prevents tail-calling :)
<White_Flame> *extent
<pjb> saturn2: not needed. Any new object that is stored in the declared variable is dynamic-extend, you say to the compiler. What you do with this object later is not the problem of the compiler anymore. It's your problem. My code is conforming and produce in list, a variable not declared, a list of cons cells that are dynamic-extent.
<White_Flame> (now, it doesn't have to, but at least SBCL doesn't include the stack magic to dynamic-extent + tco)
<White_Flame> pjb: the stack says that the declaration declares that the values become inaccessible outside the form
<pjb> White_Flame: for an object to be dynamic-extend doesn't imply anything!!! It's up to the implementation to allocate it wherever it wants, and to free it sooner than later!
<White_Flame> *the spec says
<saturn2> White_Flame: yeah, it's not ideal either way
<pjb> Which is indeed all that conforming programs need to know: the fuck don't access the fucking objects outside of the form!
<White_Flame> inaccesible is not "don't", it's "can't"
<pjb> Not only don't access, but don't keep a reference.
<pjb> White_Flame: yes, because the implementation can ignore dynamic extent so it is possible that we may!
<pjb> But we must not!
gusmv has quit [Quit: Leaving]
<White_Flame> when I said "expressibility", that is creating the assertions for this situation. The declarations assert things which may or may not be checked or used by the implementation
<White_Flame> it's hard for me to see how to even express this using the declarations
<White_Flame> however, dynamic-extent does say "for each value ... that vari takes on", which is quite broader
<White_Flame> especially since data that has a larger extent than the current form might be placed in there, too, without practical issue
<White_Flame> but I guess inaccessibility covers that
<White_Flame> so really, this does get into "sufficiently advanced compiler" territory
<White_Flame> in terms of fully taking advantage of it
wxie has joined #lisp
mindCrime_ has joined #lisp
shifty has joined #lisp
cer0 has joined #lisp
theothornhill has joined #lisp
theothornhill has quit [Remote host closed the connection]
hjudt has joined #lisp
notzmv has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
hjudt has quit [Ping timeout: 268 seconds]
Sauvin has joined #lisp
cer0 has quit [Quit: leaving]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jrm has quit [Quit: ciao]
rumbler31 has joined #lisp
Guest66658 is now known as CrazEd
CrazEd is now known as Guest6968
rumpelszn has joined #lisp
slyrus has joined #lisp
Sheilong has quit []
jrm has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
jrm has quit [Client Quit]
hypercube has joined #lisp
slyrus has quit [Ping timeout: 252 seconds]
cer-0 has joined #lisp
jrm has joined #lisp
jrm has quit [Client Quit]
ebrasca has quit [Remote host closed the connection]
jrm has joined #lisp
Bike has quit [Quit: Lost terminal]
hypercube has quit [Quit: WeeChat 3.1]
cer-0 has quit [Quit: leaving]
Oladon has joined #lisp
<beach> Good morning everyone!
rumpelszn has quit [Quit: ZNC 1.6.6+deb1ubuntu0.2 - http://znc.in]
<kagevf> good morning, beach
rumpelszn has joined #lisp
<kagevf> pjb: what you described is pretty much how I expected asdf:loadsystem to work
White_Flame has quit [Ping timeout: 240 seconds]
cer-0 has joined #lisp
zefram22 has quit [Ping timeout: 268 seconds]
semz has quit [Ping timeout: 250 seconds]
jello_pudding has quit [Ping timeout: 245 seconds]
White_Flame has joined #lisp
red-dot has joined #lisp
jello_pudding has joined #lisp
edgar-rft is now known as everyone
everyone is now known as edgar-rft
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
Guest6968 is now known as CrazEd
CrazEd is now known as Guest33656
<pjb> kagevf: yes. Just remmember to write the right dependencies in the asd file.
slyrus has joined #lisp
Lycurgus has joined #lisp
<edgar-rft> sure, there should be no dependencies left :-)
simendsjo has joined #lisp
rumbler31 has quit [Remote host closed the connection]
slyrus has quit [Remote host closed the connection]
simendsjo has quit [Remote host closed the connection]
Khisanth has quit [Ping timeout: 252 seconds]
Nilby has joined #lisp
hjudt has joined #lisp
Khisanth has joined #lisp
Oladon has quit [Quit: Leaving.]
slyrus has joined #lisp
mindCrime_ has quit [Ping timeout: 276 seconds]
kmeow has joined #lisp
mindCrime_ has joined #lisp
slyrus has quit [Ping timeout: 265 seconds]
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
Guest33656 is now known as CrazEd
CrazEd is now known as Guest13483
kmeow has quit [Remote host closed the connection]
mindCrime_ has quit [Ping timeout: 265 seconds]
theothor` has joined #lisp
cer-0 has quit [Quit: leaving]
hjudt has quit [Ping timeout: 252 seconds]
theothor` has quit [Ping timeout: 276 seconds]
hjudt has joined #lisp
narimiran has joined #lisp
akoana has quit [Quit: leaving]
<kagevf> pjb: for sure
hjudt has quit [Ping timeout: 276 seconds]
hjudt has joined #lisp
mrchampion has quit [Ping timeout: 260 seconds]
zefram22 has joined #lisp
shka_ has joined #lisp
mrchampion has joined #lisp
<dieggsy> is there a standard way to "dispatch" on platform? like (os-dispatch (linux do-this) (macos do-that))
theothor` has joined #lisp
theothor` has quit [Remote host closed the connection]
theothor` has joined #lisp
<moon-child> #+linux do-this #+macos do-that #+(not (or macos linux)) something-else
<moon-child> (except I think 'macos' is called something else; check *features*)
<moon-child> err, can replace last with #-(or macos linux) something-else
<White_Flame> needs #+case((linux ...) (macos ...) (otherwise ...))
<White_Flame> that's always bothered me
<moon-child> yeah, me too
theothor` has quit [Remote host closed the connection]
<moon-child> I mean, you can face it without too much trouble, but still
theothor` has joined #lisp
<moon-child> *fake
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<lukego> I'm feeling the urge to make a github fork of every dependency so that I can easily read/write them somewhere other than my own home directory. this way I could fix things and send changes upstream instead of just quietly working-around locally. does anyone do this? any workflow tips?
<dieggsy> moon-child: ah, thanks
<beach> lukego: Isn't that the standard way of preparing pull requests?
tophullyte has joined #lisp
<lukego> beach: yes, once you have a fork already established, but I don't have that and in the moment it's always too much hassle to create one. Ideally I'd preemptively fork everything and also keep my forks up to date e.g. with latest quicklisp versions.
<beach> I see.
<lukego> maintaining one repo containing patch files might be easier but can't send pull requests from that
notzmv has quit [Ping timeout: 246 seconds]
<Nilby> lukego: I just fork, clone, and link into ~/quicklisp/local-projects. Then I can swtich back and forth between the local hacked one and the quicklisp one, by adding and removing the link. It's convenient to have a command to it for you.
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<lukego> Nilby: hard to install your application on another computer if it depends on the contents of ~/quicklisp/local-projects though?
<kagevf> I tried to do touch ./new-directory/new-sub-directory/new-directory but bash complained because the parent directories didn't exist, so I just wrapped ensure-directories-exist in a very tiny app with sb-ext:save-lisp-and-die since it did what I wanted ...
<Nilby> You can just copy your local repo directory and have a command to populate the links.
<dieggsy> Woah - cl-tui seems really nice
Guest13483 is now known as CrazEd
<Nilby> Or just have a list of your patched dependencies and re-create the fork directory from github, then have it populate local-projects.
<splittist> lukego: would a separate lukego-forks github account do what you want?
CrazEd is now known as Guest8267
<lukego> splittist: I think so and what I'd need is a script that syncs it from quicklisp so that it doesn't go stale
slyrus has joined #lisp
<splittist> how many of your ql dependencies don't come from gh anyway?
<lukego> few to none
<lukego> Nilby: sounds messy for me, going to bite me if I want to e.g. hook up a CI that tests the same code as I'm developing, etc.
<Nilby> Yes. I agree. I guess another alternative is to have your own quicklisp dist.
slyrus has quit [Ping timeout: 252 seconds]
<lukego> hm, thanks, have to think about that option
<Nilby> It seems only the most industrious people like Shinmera have to go that far.
<Nilby> But I guess some Lisp companies do that too.
hjudt has quit [Ping timeout: 246 seconds]
Guru has joined #lisp
<Nilby> Also there's ultralisp and CLPM but I haven't tried them.
phossil has joined #lisp
tophullyte has quit [Ping timeout: 240 seconds]
theothor` has quit [Ping timeout: 252 seconds]
hjudt has joined #lisp
<White_Flame> I always end up M-.'ing into QL dependencies to tweak stuff and then stare at it wondering what to do with that :-P
<White_Flame> *with those changes
waleee-cl has quit [Quit: Connection closed for inactivity]
rumbler31 has joined #lisp
Guru has quit [Quit: Connection closed]
phossil_ has joined #lisp
<Nilby> I find it helpful to have a command to _potentially_ git clone a quicklisp system.
rumbler31 has quit [Ping timeout: 240 seconds]
phossil has quit [Ping timeout: 240 seconds]
thomasb06 has joined #lisp
orivej has joined #lisp
phossil_ has quit [Quit: Leaving]
phossil_ has joined #lisp
phossil_ has quit [Remote host closed the connection]
tophullyte has joined #lisp
tempest_nox has quit [Read error: Connection reset by peer]
bjorkintosh has quit [Ping timeout: 250 seconds]
<splittist> a quickpr command would be nice
zzappie has joined #lisp
Jesin has quit [Ping timeout: 252 seconds]
attila_lendvai has quit [Ping timeout: 245 seconds]
zefram22 has quit [Ping timeout: 276 seconds]
zap1 has joined #lisp
zzappie has quit [Ping timeout: 240 seconds]
<saturn2> kagevf: that's a good solution but there's also mkdir -p
monolithic has joined #lisp
<lukego> splittist: Yeah PRs are a whole other dimension. In the olden days of patch files you could manage your sources any way you wanted but nowadays you really need to maintain a whole github repo to participate in code sharing
charles` has quit [Ping timeout: 276 seconds]
<lukego> borodust also does a quicklisp distro for the gaming stuff and that seems to work well
pankajsg has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
gaqwas has quit [Ping timeout: 265 seconds]
DHARMAKAYA has joined #lisp
<easye> Mornin' all.
<beach> Hello easye.
<easye> What would be the mimimal-non-CL dependencies way of styling org files under Hunchentoot?
* easye nods to beach.
<easye> I suppose I could just script Emacs org-export elisp executions...
* easye wonders about executing elisp in semi-portable ANSI CL for the second time this week.
* splittist notes the gh cli has `gh pr create`
charles` has joined #lisp
hjudt has quit [Ping timeout: 240 seconds]
hjudt has joined #lisp
Guest8267 is now known as CrazEd
attila_lendvai has quit [Ping timeout: 265 seconds]
CrazEd is now known as Guest73518
Lycurgus has quit [Quit: Exeunt]
orivej has quit [Ping timeout: 252 seconds]
elderK has quit [Quit: WeeChat 3.1]
theothor` has joined #lisp
theothor` has quit [Remote host closed the connection]
<kagevf> saturn2: I know about mkdir -p, but I have a list of file names from which I want to generate the directories ... if I use mkdir -p, it will turn the entire file path into a directory ... if I try to turn that into a file bash displays an error
saganman has joined #lisp
<kagevf> if I do mkdir -p directory/filename.txt even filename.txt becomes a directory, and I can't do echo "abc123" > directory/filename.txt
<kagevf> maybe I could have done something with awk, but just wrapping ensure-directories-exist into a mini-app was faster
frgo has quit []
dickbarends has joined #lisp
theothornhill has joined #lisp
hjudt has quit [Ping timeout: 240 seconds]
andrei-n has joined #lisp
ljavorsk has joined #lisp
hjudt has joined #lisp
cosimone has joined #lisp
leo_song has quit [Ping timeout: 268 seconds]
slyrus has joined #lisp
remby has joined #lisp
slyrus has quit [Ping timeout: 268 seconds]
hiroaki has quit [Ping timeout: 260 seconds]
jladd has joined #lisp
varjag has joined #lisp
bjorkintosh has joined #lisp
surabax has joined #lisp
skapata has quit [Remote host closed the connection]
Odin- has quit [Quit: ZNC 1.8.2+deb2+b1 - https://znc.in]
hiroaki has joined #lisp
Guest73518 is now known as CrazEd
CrazEd is now known as Guest10524
lottaquestions_ has joined #lisp
lottaquestions has quit [Ping timeout: 240 seconds]
pve has joined #lisp
gum has quit [Quit: ZNC 1.7.4+deb0+bionic0 - https://znc.in]
lottaquestions_ has quit [Client Quit]
lottaquestions_ has joined #lisp
Odin- has joined #lisp
leeren_ has quit [Quit: leeren_]
leeren has joined #lisp
nij has joined #lisp
gpiero has quit [Quit: https://quassel-irc.org - Chat comfortably. Anywhere.]
Odin- has quit [Ping timeout: 245 seconds]
Odin-FOO has joined #lisp
Odin-FOO has quit [Read error: Connection reset by peer]
remby has quit [Quit: remby]
<loke[m]> kagevf: You might want to do `mkdir -p \`dirname "$filenamewithpath\``.
<loke[m]> * kagevf: You might want to do `mkdir -p $(dirname "$filenamewithpath)`.
<loke[m]> * kagevf: You might want to do `mkdir -p $(dirname "$name_with_path)`.
<loke[m]> * kagevf: You might want to do `mkdir -p $(dirname "$name_with_path")`.
<saturn2> unix is so cool
gpiero has joined #lisp
<loke[m]> * kagevf: You might want to do mkdir -p $(dirname "$name_with_path")
<loke[m]> * kagevf: You might want to do: mkdir -p $(dirname "$name_with_path")
<loke[m]> Sorry, I didn't notice that I'm on an IRC-backed channel. This must have looked horrible in an IRC client.
<loke[m]> I'll pay more attention next time.
* Nilby doesn't like unix, which makes crazytown more crazy (let ((file "~/tmp/gralt/baz/moo.txt")) (!= "mkdir" "-p" (nos:dirname file)) (! "echo foo > " file))
<nij> Did anyone (intend to) annotate CLHS and make it more friendly, say, with more examples?
<contrapunctus> nij: I think phoe was working on something like that
kini has quit [Ping timeout: 258 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
<nij> \o/ any link?
skapata has joined #lisp
<beach> nij: The Common Lisp HyperSpec can not be annotated as is. It has a very restrictive copyright.
<nij> Ah.. but can we annotate separately, and point it to specific pages of CLHS?
<nij> (When will its copyright expire? I won't die before then.)
<beach> I may not be remembering this right, but I think the ANSI standards document can not be legally copied, but the dpANS can. And I think the Common Lisp HyperSpec was created from the dpANS. However, the HTML markup is also protected by copyright. I may be wrong, and ANSI may have given permission to LispWorks to create the Common Lisp HyperSpec from the standards document.
<beach> I think it is 75 years after the death of the creator, or something like that.
Odin- has joined #lisp
<beach> It tends to follow the age of Mickey Mouse.
gitgood has quit [Remote host closed the connection]
<beach> nij: I think the right solution is to create a new document from dpANS, and I am pretty sure that is what phoe did.
<nij> :-( I'll probably be dead then. Anyway.
<nij> phoe: is it released?!
<beach> What we do need is a version of the dpANS in the form of one single LaTeX document, rather than as one TeX document per chapter.
<TMA> it depends on the jurisdiction of the birth/citizenship/residence/death of the creator at the time of the work being first published, of the publisher if posthumously and it is generally at least 70 years after the event, even 100 in some cases
<ChoHag> beach: cat(1).
kini has joined #lisp
<beach> TMA: Thanks.
<beach> ChoHag: Nope, won't work.
hendursaga has quit [Ping timeout: 240 seconds]
bjorkintosh has quit [Remote host closed the connection]
<Nilby> If I didn't dislike both HTML and TeX so much I would try to do it. I've been fixing a a texinfo copy for years and it's still messed up.
Duuqnd has joined #lisp
hendursaga has joined #lisp
Odin- has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
bjorkintosh has joined #lisp
Odin- has joined #lisp
<phoe> nij: is what released?
<beach> CLUS.
<phoe> not officially, it's in a very unfinished state
<theothornhill> How unfinished, and is there any way we can help?
bjorkintosh has quit [Ping timeout: 245 seconds]
Odin- has quit [Ping timeout: 245 seconds]
karlosz has quit [Ping timeout: 240 seconds]
<nij> yeah maybe people can help
<theothornhill> I'll volunteer to help out, if I could be pointed somewhere to look
<beach> Again, I think the best thing to do would be to create a single LaTeX document (with multiple files obviously) from the per-chapter TeX files of the dpANS.
kreyren has joined #lisp
kreyren has quit [Changing host]
kreyren has joined #lisp
<beach> Then we could use it for the Common Lisp UltraSpec, but also as a basis for a Common Lisp reference manual, and for the WSCL specification.
anticrisis has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
<scymtym> beach: is there more information on this idea of reformatting the dpANS sources anywhere? like previous attempts, necessary steps, expected outcome, etc?
<Nilby> Unless I've missed something it doesn't seem like LaTeX is an adequate format.
<beach> scymtym: Not really. I tried doing it semi-manually, but it was a disaster.
<beach> Nilby: If it is correctly structured, it could be parsed. But that's not the case for the dpANS.
<beach> Nilby: The dpANS is pure TeX with lots of custom macros, many of which are for aesthetic purposes only.
<Nilby> Yes. That's one reason I wish it were in a more abstract format.
<beach> Nilby: I totally agree, but that's just making the task even more complicated up front.
<White_Flame> need Common Lisp Spexpr
<White_Flame> one day I'll do it
<White_Flame> just blast through it monk-copy style
<scymtym> beach: i see. i meant information that would be useful for making another attempt. that would also include how to get the sources and an explanation of the legal situation, i guess
<Nilby> I actually have some fondness for sexp formats like ccldoc.
<beach> scymtym: I remember it was tricky to find the sources. But I have them, so in the worst case, I can make them available.
<beach> scymtym: We *think* it is free for everyone to use.
<beach> Nilby: Sure, if you want to try that, that would be fantastic.
Odin- has joined #lisp
<scymtym> beach: that's good to hear
pbgc has joined #lisp
ThaEwat has quit [Quit: Bridge terminating on SIGTERM]
ms[m] has quit [Quit: Bridge terminating on SIGTERM]
katco has quit [Quit: Bridge terminating on SIGTERM]
infra_red[m] has quit [Quit: Bridge terminating on SIGTERM]
MrtnDk[m] has quit [Quit: Bridge terminating on SIGTERM]
no-defun-allowed has quit [Quit: Bridge terminating on SIGTERM]
loke[m] has quit [Quit: Bridge terminating on SIGTERM]
quanta[m] has quit [Quit: Bridge terminating on SIGTERM]
rodentrabies has quit [Quit: Bridge terminating on SIGTERM]
susam has quit [Quit: Bridge terminating on SIGTERM]
dnjp[m] has quit [Quit: Bridge terminating on SIGTERM]
Gnuxie[m]1 has quit [Quit: Bridge terminating on SIGTERM]
dmiles[m] has quit [Quit: Bridge terminating on SIGTERM]
hegz has quit [Quit: Bridge terminating on SIGTERM]
tweet[m] has quit [Quit: Bridge terminating on SIGTERM]
arcontethegreat[ has quit [Quit: Bridge terminating on SIGTERM]
dieggsy has quit [Quit: Bridge terminating on SIGTERM]
agam_b[m] has quit [Quit: Bridge terminating on SIGTERM]
etimmons has quit [Quit: Bridge terminating on SIGTERM]
<theothornhill> beach: But if it's mostly hindered by the hassle of manually doing things, more hands would surely help?
theo[m] has quit [Quit: Bridge terminating on SIGTERM]
santiagopim[m]1 has quit [Quit: Bridge terminating on SIGTERM]
heretical_crypte has quit [Quit: Bridge terminating on SIGTERM]
kreyren has quit [Quit: Bridge terminating on SIGTERM]
e[m]1 has quit [Quit: Bridge terminating on SIGTERM]
imode has quit [Ping timeout: 252 seconds]
<beach> theothornhill: Absolutely!
<scymtym> i think making the sources available along with a little explanation of the situation would make the project more approachable if that makes sense
<beach> theothornhill: All we need then is someone to organize the effort.
<beach> scymtym: Don't you think we also need some kind of action plan?
<beach> I was aiming for LaTeX to avoid having to translate all the macros, and so that we could use cross references, bibliography references, etc.
pbgc has quit [Max SendQ exceeded]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<beach> I wish gilberth were here. He is the expert in recycling stuff like this. He created the "annotatable" CLIM spec from the LaTeX source.
<scymtym> beach: not sure. people chipping away at the problem in private and a coordinated effort don't seem to be mutually exclusive since
Odin- has quit [Ping timeout: 276 seconds]
<theothornhill> phoe: Is your effort available somewhere? If not, could you make it available? Otherwise I can try to set up something
<White_Flame> beach: poke him in lispcafe if you want
<scymtym> beach: yeah, seeing the CLIM spec "parser", i wondered how different the CLHS and CLIM are in that regard
<beach> scymtym: Fair enough.
<Nilby> Profusion of macros seems like what you get when you have super-lisp-hackers writing in TeX.
<beach> White_Flame: Aww! Another channel! *sigh*
Odin- has joined #lisp
<White_Flame> or PM I guess?
<beach> Nilby: I tend to agree.
<beach> Nilby: Yes, that's better.
<Duuqnd> It would be nice if there was a free software clone of Symbolics Concordia and the document examiner. Not sure if it would be at all useful for this though.
agam_b[m] has joined #lisp
<Nilby> Concordia was resting on quite a highly evolved stack of things that I don't think we have free versions of yet.
<Duuqnd> Concordia itself can't be salvaged, I was more thinking something like a clone written on CLIM or something.
no-defun-allowed has joined #lisp
<no-defun-allowed> I could swear I saw a portable version of Joshua still.
<Duuqnd> Joshua seems like it would be easier to make portable
<beach> Duuqnd: I think jackdaniel is working on some kind of CLIM-based documentation system.
<no-defun-allowed> Best case would be that you replace dw: with clim: and call if a day.
<no-defun-allowed> *it a day
tophullyte has quit [Ping timeout: 252 seconds]
<beach> I honestly think the best action would be for each person to take a section or a chapter, whipping up the PDF of the standards document, and then copy-paste from dpANS into a LaTeX document or some other kind of document.
<beach> I am convinced that any attempt at automating the translation would be much harder.
loke[m] has joined #lisp
<loke[m]> beach: I believe any transformation of the spec should be made into some kind of machine-readable form. LaTeX is fine, as long as the content is parseable without LaTeX itself. Storing the information in sexp form would be ideal.
<loke[m]> That way you can render it any way you want.
<beach> loke[m]: Oh, yes, absolutely.
<phoe> theothornhill: https://phoe.tymoon.eu/clus/doku.php and on github
<phoe> but I'll need to restart this from scratch someday because my methodology sucked at the time
ukari has quit [Remote host closed the connection]
<phoe> if I ever restart CLUS, I'll want to do it in a reproducible way that starts with dpANS sources and mechanically and reproducibly converts them into whatever format is required
ukari has joined #lisp
<phoe> the most important is *reproducible* because the standard really needs to be copied verbatim, as all holy scriptures must be
<beach> loke[m]: But then we have the eternal problem of choosing a format. We never seem to be able to agree upon such a thing.
<beach> loke[m]: The reason is simple. There are so many formats to choose from, each one is going to have only a small minority of proponents.
<loke[m]> If it's in some sexp form, transforming it to HTML, LaTeX, org-mode or whatever would be trivial.
nostoi has joined #lisp
<beach> loke[m]: But "sexp form" is not specific enough.
skapata has quit [Remote host closed the connection]
<beach> How does a table look? An itemized list? Code vs text?
<loke[m]> Well, the details doesn't matter. It could be something like '("Some text " (:bold "bold text here"))
<Duuqnd> The details do matter
<splittist> a specified clos form. let N input and M output formats bloom.
<beach> loke[m]: And that's enough to create a failure of consensus.
<loke[m]> I dunno, point is that I don't think most people would complain, since it's not any specific format, and every proponent of some other format knows they can easily convert it to their favourite style.
<beach> loke[m]: But if we need to collaborate on this effort, then we can't have each person choose a different format.
<no-defun-allowed> Frob it, just make the format #<CLHS {12345678}> - no one will know what it is without a nice print-object method and thus no one can complain.
<loke[m]> True. But you'll have the dictator choose the base sexp format. My example above is what I use for my transformed version of the Maxima documentation, and it works fine.
<loke[m]> I have written a documentation browser as part of Climaxima that displays the content in a much nicer way than the official HTML docs, and has better search, so I think it's a success.
<splittist> But :bold is an output specification, not a semantic signifier
<loke[m]> splittist: sure, it was an example.
<loke[m]> The Climaxima format contains both visual and semantic specifications.
<Nilby> The trouble is, we can see how well separation of semantics from presentaion is going for the web.
<loke[m]> You'll just take the specifiers directly from the LaTeX dpans source,
<loke[m]> I was working on an automatic converter for the dpand documents that created precisely this.
<nij> I wonder why PG doesn't fund common lisp.
<loke[m]> Nilby: My apologies for making assumptions, but did you take a look at the dpans source? It already contains that information directly in the LaTeX source.
<nij> Maybe it's a good idea to ask him for some.
arcontethegreat[ has joined #lisp
e[m]1 has joined #lisp
dieggsy has joined #lisp
dnjp[m] has joined #lisp
hegz has joined #lisp
heretical_crypte has joined #lisp
Gnuxie[m] has joined #lisp
etimmons has joined #lisp
kreyren has joined #lisp
dmiles[m] has joined #lisp
infra_red[m] has joined #lisp
katco has joined #lisp
MrtnDk[m] has joined #lisp
santiagopim[m] has joined #lisp
rodentrabies has joined #lisp
quanta[m] has joined #lisp
ms[m] has joined #lisp
ThaEwat has joined #lisp
susam has joined #lisp
tweet[m] has joined #lisp
theo[m] has joined #lisp
<Nilby> loke[m]: Yes, and I know they did a pretty good job with TeX, but it's certainly not perfect, and they we're exactly focusing on the hyperspec aspects.
<Nilby> s/we're/weren't/
<TMA> Nilby: https://github.com/xach/dpans if you hadn't found the dpANS sources already
<TMA> ah, you have, I reckon
<Nilby> TMA: Thanks. I think I started with one from GCL, but Xach's is probably in better shape.
<no-defun-allowed> nij: I would prefer to not be funded by Paul Graham honestly.
<no-defun-allowed> If you can stomach him, sure why not, but that's not my cup of tea. I dunno.
nicktick has quit [Ping timeout: 260 seconds]
<Nilby> nij: PG want to replace CL with his thing, so he probably doesn't want to fund us.
long4mud has quit [Quit: WeeChat 3.0.1]
<no-defun-allowed> For one not borderline "political" example, his two hundred (thousand?) year languages are very terse, but I write verbose code, because that is what I can read.
<nij> Nilby: Oh really :-( ?
* splittist would be wary of anything funded, as funding implies official, and constitutional conventions are unpredictable see e.g. French revolution, Russian revolution etc. (:
<nij> But it's also how CLHS was written, no?
lotuseater has joined #lisp
<beach> nij: Why did you bring up Paul Graham?
<White_Flame> funding was also why CLHS wasn't completed to the desired state
<nij> beach: Because he did seem to like CL and might be able to help out.
<nij> White_Flame: That's right.
attila_lendvai_ has joined #lisp
<beach> nij: Like I said, the Common Lisp HyperSpec was created either from the dpANS or perhaps from the standards document with special permission. I forget who did it. Maybe Kent Pitman?
<no-defun-allowed> Yes, Pitman put it together.
<beach> nij: How did you think it was created?
<no-defun-allowed> What I would do is start a venture commune to get common property for any CL work. This has the pleasant side effect of competing with PG.
attila_lendvai has quit [Ping timeout: 240 seconds]
<nij> beach: damn I didn't know what dpANS was, and now it makes sense.
<nij> I thought someone wrote CLHS by his/her own.
zefram22 has joined #lisp
<beach> nij: Not at all, it was derived from the standardization documents. And those documents took dozens of people to create.
<nij> So with dpANS, we don't have to write CLUS from scratch?
<beach> That's the idea, yes.
<beach> nij: But, if you followed the discussion the dpANS is in a format that is not easy to exploit.
<nij> Now xach has a copy on github. Is there any compiled version (in pdf, say)?
<Nilby> Funny that arc people started using sbcl, https://github.com/arclanguage/Clamp
<nij> Nilby: he has a new lang spec recently too
<theothornhill> beach: what would be the best format, then? Markdown?
<no-defun-allowed> Great, now I know what libraries to avoid.
<beach> theothornhill: I am not going to attempt to answer that, because, like I said, any particular format would be defended by only a small minority of us.
zap1 is now known as zzappie
<beach> theothornhill: And, as I often say, I would like for the entire thing to be encoded as standard objects, with a well defined protocol.
<beach> That way, we can't possibly disagree on some surface syntax, because the surface syntax would not be what defines the format.
<theothornhill> beach: yeah, but now it looks pretty gnarly, so maybe converting it to a cleaner (as in human readable) format first could be a smart first step?
<Nilby> beach: I quite agree with a standard object encoding.
<contrapunctus> beach: I remember CommonDoc being brought up as such a protocol, last time
<beach> Yes, and I have suggested creating a single coherent LaTeX document.
<beach> theothornhill: ^
<beach> contrapunctus: Let me check the logs for that...
contrapunctus has left #lisp ["Disconnected: closed"]
<Nilby> I also agree with phoe, that it would be good for it to be reproducible to go rom dpANS to an object encoding.
<beach> contrapunctus: I must have completely forgotten about this. Who wrote that?
<beach> Aha! It slowly comes back.
<beach> I forget the IRC handle of Fernando Borretti.
contrapunctus has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
<beach> contrapunctus: Thanks for reminding me. Then CommonDoc might be the best recommendation. Let me see how it can be used.
kevingal has joined #lisp
<splittist> The problem is that documents (for human consumption) are not trees. At least, not at any reasonable level of abstraction.
bjorkintosh has joined #lisp
<nij> splittist: why would that be a problem?
<beach> splittist: That's why I would like to see documentation split into (say) "chunks" where each "chunk" has a unique label and can be inserted into documents in different ways.
<nij> yes yes
<contrapunctus> splittist: reeeeaaally? o.O HTML, XML, and anything that targets them like Org, Markdown, etc, as well as XML schemas like ODF...aren't they all trees?
<Nilby> I don't know specificlly about CommonDoc, but an object representation is really a graph, and can have circularity, etc.
<beach> CommonDoc seems to do that already.
<splittist> contrapunctus: yes. and a tiny subset of documents.
<splittist> There's a reason wordprocessing formats are insanely complicated.
<Nilby> XML things are only textually a tree, but in objects a node graph e.g. SVG.
zefram22 has quit [Quit: zefram22]
zefram22 has joined #lisp
<beach> It looks like CommonDoc may be an excellent starting point.
<splittist> headers, footers, footnotes, endnotes, call-outs, tables, pictures; sections of text that don't map to textual content, but to its presentation; annotations that span units of text; styles that do - or don't - compose.
nostoi has quit [Quit: Verlassend]
<nij> beach: sounds like it
<nij> But I wonder why don't it uses s-exprs as formats
<splittist> title pages, front matter, colophons, appendices, schedules, annexes, indexes, tables of contents, tables of authorities, bibliographies, watermarks, borders for paragraphs, borders for pages, ...
<Nilby> splittist <- this person documents :)
<nij> So instead of @begin(enum) @item(This is the first item) @item(And this the second) @end(enum), we can just write
<nij> (enum "This is the first item" "And this is the second")
<beach> nij: Because, again, the main idea is to have the internal CLOS protocol be the main definition of the format. Not the surface syntax.
zefram22 has quit [Ping timeout: 252 seconds]
<nij> Yeah.. that's the point.
<nij> I'm just obsessed with using s-exprs as formats of everything.
<Duuqnd> I like them too but it's important to know when not to use them
<nij> It seems to be perfectly fine when it comes to latex-like stuff..
<nij> (eqn "line1" "line2" "line3"), instead of lots of begin.. end.. and indentation
<nij> with emacs you get helpers for indenting as well
<nij> But anyway, that's not really the point here, as beach said.
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
<splittist> CommonDoc seems to be basically the markdown subset of html with nestable sections
attila_lendvai_ has quit [Quit: Leaving]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<nij> I do I make file of this (https://github.com/xach/dpans) and get a readable pdf file?
<nij> s/I do I/ How do I/
<TMA> nij: I have had success with running: for i in chap-{1..26}.tex chap-a.tex ; do pdftex $i ; done
<TMA> nij: chap-0 contains table of contents, index, list of figures and also some problems that prevent it from finishing pdftex chap-0 successfully without modification
<theothornhill> TMA: thanks :)
vegansbane6963 has quit [Quit: The Lounge - https://thelounge.chat]
<nij> Wow indeed, thanks TMA!
<nij> beach , did CLHS add/remove things from dpANS?
<TMA> for the table of contents: replace ".tc" with ".toc" in chap-0.tex ; for the index: run: sort -t: -k2 chap-*.idx > index.idx
<beach> nij: No, it should be a very faithful HTML-ized version of it.
<TMA> and then pdftex chap-0 finishes successfully
<White_Flame> nij: CLHS added formatting & links to what might have been plain text in the tex
<nij> What makes it hard to convert dpans into a commondoc?
<edgar-rft> nij: the code examples in the CLHS and the "issues" pages were added by Kent Pitman, they are not part of the dPANS Tex version.
<beach> nij: All the TeX macros they used.
aindilis` has joined #lisp
aindilis has quit [Ping timeout: 252 seconds]
<Duuqnd> The \input stuff there reminds me a bit of how in Concordia most records were just links to other records. (screenshot for reference: https://i.imgur.com/J9ZWbrC.png)
<Nilby> nij: TeX is hard to convert by anything that isn't TeX or TeX-based. PDF and DVI are pre-rendered formats that lose much of semantic content. And all of those formats are designed to be smushed onto dead trees, not clicky-pixels.
<Nilby> Of course one of the cool things about Concordia is it's kind of a Zmacs mode and have live objects in it.
<Duuqnd> Just like most things in Genera
<Duuqnd> I should probably stop playing around with it because it's making me dislike Unix-likes and Windows more than I already did.
<Nilby> Duuqnd: Yup. I've been stuck like that ever since using a Lisp machine.
zzappie has quit [Remote host closed the connection]
paul0 has quit [Remote host closed the connection]
paul0 has joined #lisp
zzappie has joined #lisp
<Nilby> That specific screenshot shows org-mode-ish and non-tree-like features.
<Duuqnd> There also this stuff which I think is really cool: https://i.imgur.com/SUpdoQn.png
zefram22 has joined #lisp
zefram22 has quit [Remote host closed the connection]
zefram22 has joined #lisp
<pjb> dieggsy: have a look at: (com.informatimago.tools.manifest:distribution) https://github.com/informatimago/lisp/blob/master/tools/manifest.lisp#L144 ; of course, totally ad-hoc.
<Nilby> At least that CLIM can do now :)
igemnace has quit [Remote host closed the connection]
<Duuqnd> Being able to click on an example and having it run is also pretty neat: https://i.imgur.com/h1pAQI1.png
<nij> I envy this. Dunno if there's any easy way to start.
<pjb> nij: I guess PG doesn't fund Common Lisp, because he wasn't billionaires after selling viaweb. So instead he founded Y-combinator VC to fund startups to make him eventually a billionaire. Note that if you can pitch a good startup with y-combinator (and use Common Lisp to implement it), then PG would fund CL, indirectly.
<nij> pjb that sounds like a good plan ;)
<pjb> nij: oh, you meant a standization process? But once your startup will have made it, you will be able to do that yourself, which would be logical, since you will have used CL to build your products!
<pjb> PG sold viaweb to yahoo! who hurried to rewrite it in C++… So there's some lost interst in CL there.
<pjb> PG was a 2-comma, not a 3-comma from it ;-)
<Nilby> I think foundational Lisp is thing that's above the normal economy, like other technologies say, e.g. GPS, you can't just throw money to make it happen, and it doesn't produce profit directly, but it's super useful and enables whole classes of other profitable endeavors.
<no-defun-allowed> Not the case for any programming language?
<nij> and gps is based on gr, which is based on Riemannian geometry
<nij> no-defun-allowed: dunno. I a noob believe that CL is superior.
<Nilby> Maybe some. It seems like programming languages can't be sold now.
<no-defun-allowed> It does not transcend reality. No other programming languages make money on their own, other than creating a net loss for everyone dumb enough to use some.
<no-defun-allowed> But after all, we're only ordinary men...
zefram22 has quit [Quit: zefram22]
zefram22 has joined #lisp
vegansbane6963 has joined #lisp
zefram22 has quit [Ping timeout: 265 seconds]
mindCrime_ has joined #lisp
flazh has quit [Quit: flazh]
daphnis has joined #lisp
<daphnis> to remove the end of a string, is there something more straightforward than (subseq str 0 (1- (length str))) ?
<Nilby> That's pretty strightforward, but if you know it was specific characters you could use trim.
flazh has joined #lisp
mindCrime_ has quit [Ping timeout: 252 seconds]
<daphnis> yeah, i suppose it is
<jackdaniel> if your string has a fill pointer, then you may decrement it
<jackdaniel> but this will be an operation that affects the string itself
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
frost-lab has quit [Quit: Connection closed]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Bike has joined #lisp
jibanes_ is now known as jibanes
xkapastel has joined #lisp
luckless has quit [Remote host closed the connection]
luckless has joined #lisp
<pjb> daphnis: if you took the precaution of storing your string in a vector with a fill-pointer: (decf (fill-pointer str))
<pjb> (let ((str (make-array 32 :element-type 'character :fill-pointer t)) (src "Hello World")) (replace str src) (setf (fill-pointer str) (length src)) (print str) (decf (fill-pointer str)) str) #| "Hello World" --> "Hello Worl" |#
<pjb> daphnis: now, if your string is a tad long, you may want to avoid copying it: (let ((str "Hello World")) (make-array (1- (length str)) :displaced-to str)) #| --> "Hello Worl" |#
<pjb> daphnis: have a look at com.informatimago.common-lisp.cesarum.utility:nsubseq
<pjb> daphnis: note, for most strings (length < 24 or 32), subseq will be more efficient, on 64-bit hardware.
<daphnis> pjb: thanks!
Duuqnd has quit [Remote host closed the connection]
duuqnd_ has joined #lisp
shifty has quit [Ping timeout: 252 seconds]
shifty has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
daphnis has quit [Quit: leaving]
amb007 has quit [Read error: Connection reset by peer]
daphnis has joined #lisp
amb007 has joined #lisp
shifty has quit [Ping timeout: 268 seconds]
amb007 has quit [Read error: Connection reset by peer]
daphnis has quit [Client Quit]
shifty has joined #lisp
daphnis has joined #lisp
amb007 has joined #lisp
ljavorsk has quit [Ping timeout: 268 seconds]
amb007 has quit [Ping timeout: 252 seconds]
cage_ has joined #lisp
amb007 has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 268 seconds]
<beach> AHA! The handle of Fernando Borretti is eudoxia, who apparently was here last around 5 years ago.
<Shinmera> Yeah, he's still alive, but hasn't been doing any lisp in years.
<Shinmera> I chat to him occasionally on streams.
<beach> Right.
<beach> Oh, OK.
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
rumbler31 has joined #lisp
<flip214> https://github.com/eudoxia0?tab=overview shows still alive and kicking
rumbler31 has quit [Ping timeout: 252 seconds]
shifty has quit [Ping timeout: 265 seconds]
wsinatra has joined #lisp
cer-0 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
zacts has joined #lisp
theothornhill has quit [Read error: Connection reset by peer]
<dieggsy> pjb: oh cool, thanks. is the or there encompassing the os cases really necessary
<pjb> dieggsy: note that: (or) #| --> nil |# So it serves two purposes; 1- protection in case we miss a case; 2- ease of editing the bunch of #+ in a single form.
<pjb> dieggsy: with paredit, you can easily manipulate list sexps, so sometimes adding a PROGN, AND or OR can help editing.
<dieggsy> oh, fair
<dieggsy> i was just talking about how i gave up parens editing frameworks in favor of manual editing because they all felt like they got in my way lol
<dieggsy> but i'll try them out again, it's been like a couple years
lonjil has quit [Quit: No Ping reply in 180 seconds.]
<pjb> Oh, and in the case #+(or unix) it's entirely useless, probably a left over from copy-pasting; but also a hint that we'd like to get a future feature to or unix with for nextstep. note that OpenStep worked on unices (sunos and hp/ux), Mach-OS, and Windows-NT.
<pjb> dieggsy: I like paredit.
<dieggsy> pjb: i think part of the fuss is i'm also using evil-mode and none of them quite click with that, you have to use some kind of sub-par adapter package
<pjb> Yes, that may mess things up.
lonjil has joined #lisp
Sheilong has joined #lisp
Inline has joined #lisp
hjudt has quit [Ping timeout: 252 seconds]
duuqnd_ is now known as duuqnd
srhm has joined #lisp
hjudt has joined #lisp
djuber has joined #lisp
Iolo has quit [Ping timeout: 240 seconds]
Iolo has joined #lisp
notzmv has joined #lisp
hjudt has quit [Ping timeout: 252 seconds]
waleee-cl has joined #lisp
klltkr has joined #lisp
djuber has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
djuber has joined #lisp
charles` has quit [Ping timeout: 276 seconds]
<pyc> While typing code into a .lisp file, is there a way to autocomplete known symbols? For example, form<key-sequence> should autocomplete it to format. Is it available? I tried <tab> but it does not seem to autcomplete. I have SLIME running in Emacs.
<beach> C-c TAB or C-c C-i.
<pyc> thanks beach
<beach> Pleasure.
<jfb4> thanks beach
<pyc> M-TAB also seems to work for autocompletion.
<beach> jfb4: What did I help you with?
<jfb4> beach: useful answer on autocompletion
<beach> Oh, OK.
<beach> pyc: I almost never use the Meta key, so I would have to type C-[ C-i instead, and the [ and the i are on the same hand, so slower to type.
<jfb4> beach:curious why not use meta key, eg C-M-x
<splittist> ESC Tab
<beach> jfb4: Because it is in an awkward position.
* beach also never uses the ESC key for that reason.
<jfb4> ok but you can remap in a line super-meta-control the way of the Lisp machine keyboards
<splittist> It is useful if you are using a terminal in a browser that eats lots of M-... chords
<beach> I would need one of those Japanese keyboards with a very narrow space key.
<pyc> (sort '("foo" "bar" "baz" "qux") 'string-lessp) or (sort '("foo" "bar" "baz" "qux") #'string-lessp)? Does it matter if I use 'string-lessp or #'string-lessp? Is one better style than the other?
<beach> For standard functions, I recommend you always use #'
<pyc> beach: Would you please elaborate the reason behind your recommendation? Trying to understand why one is better than the other.
<beach> SORT will then be called with a function object, so no further indirection needs to be resolved, whereas if you call it with a symbol, some kind of lookup is required.
orivej has joined #lisp
<pyc> beach: thanks.
<beach> I occasionally use a symbol for the :DISPLAY-FUNCTION pane option in CLIM, so that when the function is redefined, I don't have to re-evaluate my DEFINE-APPLICATION-FRAME form.
<pyc> Is #' a result of Lisp-2 languages? Do Lisp-1 languages also have the #' syntax?
<edgar-rft> pyc: 'string-lessp doesn't work with FLETs or LABELs, it will *always* use the global function even if a lexical local function exists
<beach> pyc: The former. It is a way to take a value in the function namespace and turn it into a value in the variable namespace.
<Bike> in racket #' actually means something completely different! isn't that exciting?
<pyc> Okay. Thanks.
<beach> Bike: Oh, wow.
<edgar-rft> may I come up with "Scheme is no Lisp"? :-)
<pyc> (sort (directory "*.txt") #'string-lessp) ; This fails with: The value #P"/Users/pyc/learning/a.txt" is not of type (OR (VECTOR CHARACTER) BASE-STRING SYMBOL CHARACTER) when binding SB-IMPL:STRING1. I understand the error. I am passing a list of pathnames to sort but using a predicate meant for string. What is the right way to solve this problem?
<Bike> do you want to sort by the entire pathname, or the filename, or what
josemanuel has quit [Quit: leaving]
djuber has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
<Bike> you can pass a :key to sort, e.g. #'namestring
<edgar-rft> pyc: there's NAMESTRING to convert pathnames into strings
<pyc> Bike: In my case, I will get the same result whether I sort by entire pathname or only by the filename because all my pathnames would start with #P"/Users/pyc/learning/" I am looking for files in a single directory only.
djuber has joined #lisp
<pyc> Bike, edgar-rft: Thanks. let me try that
<edgar-rft> alternatively you could write PATHNAME-LESSP :-)
hjudt has joined #lisp
<pyc> (sort (directory "*.txt") #'string-lessp :key #'namestring) ; This worked fine. Really enjoyed learning about this. The CLHS document also describes the sort arguments very nicely. Thank you all for your help.
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
daphnis has quit [Ping timeout: 260 seconds]
daphnis has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
thomasb06 has quit [Remote host closed the connection]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
aindilis` has quit [Remote host closed the connection]
<Josh_2> Hello
<beach> Hello Josh_2.
daphnis has quit [Ping timeout: 240 seconds]
ebrasca has joined #lisp
remby has joined #lisp
hjudt has quit [Ping timeout: 265 seconds]
hjudt has joined #lisp
theothornhill has joined #lisp
skapata has joined #lisp
hypercube has joined #lisp
klltkr has quit [Quit: Textual IRC Client: www.textualapp.com]
<pjb> pyc: the funny thing however, is that directory returns truenames.
<pjb> pyc: ie. it resolves symlinks.
gum has joined #lisp
<pjb> pyc: (sort '("foo" "bar" "baz" "qux") 'string-lessp) cannot work, because SORT is destructive, and '("foo" "bar" "baz" "qux") is immutable.
<pjb> pyc: what do you think happens when infinite force meets infinite innertia?
<pjb> pyc: dragons out of the nose!
<pjb> pyc: try: (sort (copy-list '("foo" "bar" "baz" "qux")) 'string-lessp) #| --> ("bar" "baz" "foo" "qux") |#
hjudt has quit [Ping timeout: 240 seconds]
<pyc> pjb: With SBCL, (sort '("foo" "bar" "baz" "qux") 'string-lessp) returns me ("bar" "baz" "foo" "qux"). Seems to do the right thing.
<pyc> pjb: but you are right, CLHS spec says sort is destructive. so is my code undefined behavior?
<dieggsy> i was just gonna say, works with SBCL
drbluefall has joined #lisp
<dieggsy> pyc: it *is* destructive though, it's modifying the actual list. if you store it in a variable, you can see the original list order is changed
<dieggsy> as opposed to just returning a new list
drbluefall has quit [Remote host closed the connection]
bilegeek has joined #lisp
drbluefall has joined #lisp
mindCrime_ has joined #lisp
kiwichap has joined #lisp
<kiwichap> hello
hjudt has joined #lisp
<pjb> dieggsy: (let ((list '("foo" "bar" "baz" "qux"))) (print (sort list 'string-lessp)) list) #| ("bar" "baz" "foo" "qux") --> ("foo" "qux") |# does it really work?
<pjb> s/dieggsy/pyc/
<beach> Hello kiwichap.
<dieggsy> pjb: it warns "Destructive function SORT called on constant data: ("foo" "bar" "baz" "qux")" but it does work
<kiwichap> how are you beach?
<beach> Very well thank you. You?
<pjb> dieggsy: are you familiar with the concept of nasal daemons?
<beach> kiwichap: Are you new here? I don't recognize your nick.
<kiwichap> yes I am new
<beach> Great! Welcome! What brings you to #lisp?
<dieggsy> pjb: lol, saves everyone time to say "undefined behavior"
<dieggsy> but yes, i'm familiar
<pjb> should we assume kiwichap lives in the antipodes?
<kiwichap> I was interested in making a website or developing computer equipment and was told that LISP is the best for that
<pjb> dieggsy: undefined behavior is not frightening enough.
<beach> pjb: .de suggests otherwise, but who knows.
<pjb> kiwichap: well, at least one guy earned 8-digits selling a web program written in Common Lisp, so it's possible.
<beach> kiwichap: Yeah, well, sort of. For one thing, we haven't written in LISP for decades, so if you use LISP, we think you are using decades-old dialects.
<duuqnd> We usually write it "Lisp" these days
<beach> kiwichap: Furthermore, this channel is dedicated to Common Lisp, which is probably fine for what you want.
<pjb> probably the best choice for that indeed.
<beach> kiwichap: Then, Common Lisp is the best choice for lots of stuff, you websites would represent no exception. :)
<kiwichap> sounds good
<kiwichap> I don't really want to use ubuntu even though I set it up
<kiwichap> is freebsd good?
<duuqnd> You can write Common Lisp code in just about any modern OS
<duuqnd> I've used both Linux and Windows so BSD should work fine
<beach> kiwichap: When you use a Common Lisp system, you work more inside the system itself than in the host operating system, so you won't notice much difference.
<kiwichap> ok sounds good, I am using FreeBSD, Debian and Open Suse for my websites at the moment
sauvin_ has joined #lisp
<dieggsy> kiwichap: define "good" - for a server ?
<dieggsy> BSDs are excellent for servers. for daily use, much worse hardware support than Linux IME
<dieggsy> or just general maturity i guess
<kiwichap> yes, I prefer to write my own hardware drivers I guess
<dieggsy> lol, that's one way to go about it
gitgood has joined #lisp
Sauvin has quit [Ping timeout: 245 seconds]
<dieggsy> dunno if i'd call it practical for productive use, but if you have the time, absolutely. contribute them upstream, even
Sheilong has quit []
<kagevf> loke[m]: thank you - I didn't know about dirname ... yes, that would have done what I wanted ...
<pjb> kiwichap: a lot of lisper use macOS to write lisp code on (even if deploying on MS-Windows or Linux).
<kiwichap> interesting
<dieggsy> pjb: why would lispers prefer macOS over e.g. Linux ?
<kiwichap> why would they get a mac for that?
<jackdaniel> there is some historical overlap between lisp and early osx
<kiwichap> interesting
<dieggsy> jackdaniel: ok, what about current day though
<jackdaniel> plenty of lispers lived then and live now :)
<dieggsy> is there anything that makes macOS better fit for lisp nowadays or is it just... historical vestiges kind o f
<jackdaniel> I can't say much about osx, but I'm sure that historical vestiges play a role in some lispers preferring macos over linux
zefram22 has joined #lisp
<jackdaniel> also osx application market is bigger than linux's (if you want to sell software)
<dieggsy> i mean surer, but that's getting at preferring macos over linux in general as opposed to for lisp specifically
<kiwichap> makes sense but you need to own a mac to develop with a mac
<kiwichap> I have IoS devices but I don't own a mac
<jackdaniel> kiwichap: sure; I don't own a mac so I don't develop with a mac ,)
<pjb> dieggsy: I don't know, but there are some pictures of lisp conference assistance where there's about 90% mac laptops vs 10% PC laptops which probably run 90% Linux and 10% Windows.
<jackdaniel> dieggsy: if some person prefers macos over linux and they happen to be a lisper, what do you think they will prefer for lisp?
<Josh_2> Is there a library that makes storing data in files easier? Basically I'm thinking something like subclass of one class would store in one directory, subclasses of that in a directory inside of that. Not sure
<kiwichap> they aren't necessarily well designed and they are expensive
<pjb> kiwichap: it's iOS. IoS would be Internet of Service
<Josh_2> with a way of customizing serialization obv
<kiwichap> interesting
<kiwichap> I was more referring to the mac like I prefer my cpu to be water cooled
<dieggsy> jackdaniel: my question was, is there a particular reason to prefer macos over linux *for lisp*
<jackdaniel> either way this drifts toward offtopic, so as a moderator I feel obligued to moderate you :)
<pjb> dieggsy: AFAIK, nope.
<kiwichap> thank you , sorry, I am tempted for a mac for IoS development and was interesting to realize Internet of Service
<jackdaniel> Josh_2: this sounds like an orm with extra steps
<pjb> dieggsy: the only thing you have on macOS you don't have on Linux, is Clozure CL.app with a nice Hemlock editor, if you don't want to use emacs/slime.
<Josh_2> jackdaniel: sure but I dont want to use a database
<dieggsy> jackdaniel: fair , though i didn't start the conversation heh
<kiwichap> I paid for a 1 month subscription of a rent a mac service also
<pjb> dieggsy: on Linux you can run a PortableHemlock with a X11 backend, but it's not as nice.
<Josh_2> I'm trying to avoid using something like postgres
<kiwichap> this month that is
<pjb> kiwichap: try iOS instead.
<dieggsy> pjb: ah, well, i live and die by emacs so
<jackdaniel> kiwichap: this channel is known for strict on-topicness rules, discussing other topic unrelated to common lisp is allowed on #lispcafe
<pjb> dieggsy: but indeed, linux\X11\ratpoison\emacs is great.
<jackdaniel> Josh_2: consider sqlite
<jackdaniel> there is a library with bindings cl-sqlite
<pjb> the keyboard is more responsive on Linux\X11 than on macOS (and on Windows it's horrible).
<jackdaniel> pjb: this also applies to you, please move with this to #lispcafe
<pjb> and you've got more keys and modifiers in X11 than in macOS, which is nice for lisp or emacs.
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
<kiwichap> I am using Windows Professional desktop and Windows 10 regular laptop
<kiwichap> and have emulation software running
<dieggsy> oof
<Josh_2> databases suck
<Josh_2> They are anti lisp imo
<jackdaniel> I've heard many good things about allegrograph which is a common lisp database
<kiwichap> the gnu clisp is good?
<dieggsy> Josh_2: they kinda suck to work with, but they can be mighty fast compared to other storage methods.
<jackdaniel> kiwichap: it has very slow pace of development
<Josh_2> dieggsy: like what? the filesystem is speeeeeedy
<dieggsy> kiwichap: some people here swear by it, others dislike it, i don't have enough info
<jackdaniel> people usually recommend sbcl and then ccl
<jackdaniel> (for specific needs also ecl [c embedding] and abcl [jvm embedding])
<dieggsy> Josh_2: you're not wrong, but then you get into things like disk space and compression i suppose. TBH i'm no expert on the subject
mindCrime_ has quit [Ping timeout: 246 seconds]
tophullyte has joined #lisp
nature has joined #lisp
phossil has joined #lisp
phossil has quit [Client Quit]
<kiwichap> I installed all 3 now
phossil has joined #lisp
phossil has quit [Remote host closed the connection]
phossil has joined #lisp
tophullyte has quit [Ping timeout: 240 seconds]
zaquest has quit [Quit: Leaving]
liberliver has joined #lisp
zefram22 has quit [Ping timeout: 252 seconds]
liberliver has quit [Client Quit]
lotuseater has quit [Ping timeout: 245 seconds]
lotuseater has joined #lisp
theothornhill has quit [Remote host closed the connection]
theothornhill has joined #lisp
<kiwichap> thank you
theothornhill has quit [Ping timeout: 252 seconds]
srhm has quit [Quit: Konversation terminated!]
zaquest has joined #lisp
zacts has quit [Quit: bbl]
karlosz has joined #lisp
imode has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
CrashTestDummy2 has joined #lisp
cosimone has quit [Remote host closed the connection]
CrashTestDummy has quit [Ping timeout: 240 seconds]
cage_ has quit [Quit: Leaving]
cage_ has joined #lisp
saganman has quit [Ping timeout: 276 seconds]
<shka_> fun fact: you can embed two ways with ECL
<shka_> depending on your need
theothornhill has joined #lisp
theothornhill has quit [Remote host closed the connection]
mindCrime_ has joined #lisp
sauvin_ is now known as Sauvin
nij has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
bilegeek has quit [Quit: Leaving]
mindCrime_ has quit [Ping timeout: 240 seconds]
kevingal has quit [Remote host closed the connection]
<stylewarning> I really wish there was a tiny no frills Common Lisp implementation
<stylewarning> kind of like the no frills Schemes out there
<stylewarning> But I guess it’s such an investment to build an implementation you might as well do fun stuff too
<_death> you can take an implementation and start removing stuff
<stylewarning> I think that’s possible but there’s also a certain way people write minimal software
<stylewarning> namely a very direct style of coding without hooks, lots of indirection, etc
<Josh_2> Why write minimal software when you can write software that works?
raeda_ has joined #lisp
<Josh_2> CL is basically the opposite of the unix philosophy
<_death> I remember lisp500 had an impressive .lisp file along with it.. although with some prettification the .c file was some 2kloc after all?
raeda has quit [Ping timeout: 268 seconds]
<Josh_2> I read 'The rise of Worse is Better' in The Unix Haters Handbook very recently, interesting stuff and relevant to what you said stylewarning
koolkat332 has joined #lisp
ntr has joined #lisp
<pyc> http://clhs.lisp.se/Body/f_search.htm says this: "For example, when start-end is true, the ..." but I don't see start-end specified anywhere else on this page. what is start-end referring to here?
<_death> heh, trying to compile lisp500.c makes my gcc segfault :D
theothor` has joined #lisp
<Bike> pyc: typo for from-end.
<pyc> Bike: _death: thanks
<nij> what's no-frills @_@?
hjudt has quit [Ping timeout: 260 seconds]
hjudt has joined #lisp
kiwichap has quit [Ping timeout: 265 seconds]
<stylewarning> nij: a compiler, author’s personal things
<stylewarning> (those are frills)
ordoflammae has joined #lisp
<stylewarning> Josh_2: I’m not suggesting hyper-minimalism. I’m just saying that I think there’s room for a Common Lisp implementation that is small and straightforward, and especially easy for a reader to understand
theothor` has quit [Ping timeout: 252 seconds]
theothor` has joined #lisp
karlosz has quit [Quit: karlosz]
<remby> stylewarning: scheme? :P
<shka_> well, CL is not a minimalistc language to begin with
<Josh_2> Yeh, sounds like a scheme to me
<stylewarning> How does this sound like a scheme
<stylewarning> I’m talking about an implementation approach
<stylewarning> Not a language design
<shka_> i understand
<_death> there is also ThinLisp
<shka_> problem is, that standard conforming CL is supposed to have shitload of features
<shka_> including MOP
<shka_> and a debugger
<stylewarning> shka_: so that just puts a lower bound on what can be achieved
<jackdaniel> stripping away interrupt handling, threads, sticking to bytecode compiler (without linking sheningans) and bolting first "standard library" then "clos" should bring you 3/4 way there
<stylewarning> But the point is to sit close to that lower bound
<stylewarning> not to have some fabled 100 line C file implementing CL
<stylewarning> jackdaniel: agreed
<jackdaniel> another things that could be shaved are tcp, sse and posix funcionalities
<jackdaniel> unicode is another possible victim
<jackdaniel> s/possible/plausible/
<jackdaniel> one could go a few steps further and: implement non-conforming format and non-conforming loop which cover >98% of use cases
<jackdaniel> unix file system interface could be stubbed with a silly vfs
<jackdaniel> minimal ffi utilities could be retained to be able to do anything useful
luckless has quit [Quit: luckless]
<jackdaniel> that would give you an ad hoc, bug-ridden, slow implementation of 100% of common lisp :)
luckless has joined #lisp
<stylewarning> :)))
<shka_> jackdaniel: that would be few step backwards, not further :D
<shka_> honestly though, i think that for educational purposes some other lisp implementation makes more sense to study
<jackdaniel> smaller modules are easier to maintain ;) but sure, given that we have a standard that would be a regression
<shka_> perhaps even the lisp1.5 with few extensions
<shka_> like the lexical variables
<stylewarning> shka_: disagree
<stylewarning> Scheme-ish is fine to study the structure of EVAL and APPLY
<shka_> well then scheme
<shka_> it is much nicer language for the education
<stylewarning> Depends what you’re educating on
<stylewarning> It doesn’t educate you about much of Common Lisp
<shka_> yeah, i agree
<stylewarning> It just educates you about the *gestures broadly toward the sky* “Lisp”
<dieggsy> lol, i think they meant more abstractly like algorithms and shit. i might disagree wit that too though. I dunno, I love scheme and I love CL. you can learn from either and make great practical use of either
<shka_> i guess SICL is the cleanest lisp implementation i know
ukari has quit [Remote host closed the connection]
<shka_> but still, it is not that easy to understand
<shka_> and certainly not "basic"
<stylewarning> dieggsy: but learning either doesn’t really provide insight into implementation
ukari has joined #lisp
<dieggsy> stylewarning: not at all, agreed
<stylewarning> dieggsy: and currently in Common Lisp it’s hard to answer the question “what if Common Lisp had XYZ?”
bitmapper has joined #lisp
<dieggsy> stylewarning: what do you mean by that
<stylewarning> For instance I would love to know what a computed goto special operator would be like in Lisp
<stylewarning> Unless you’re a genius compiler hacker like Paul K, you can’t just simply add this to something like SBCL
luckless has quit [Quit: luckless]
<stylewarning> If we had a COMPUTED-GO special operator, then we could hack something like cheap coroutines in Lisp
<stylewarning> Or fast interpreters
<stylewarning> That would be fun to play with, but necessitates a substrate for easily modifying a CL implementation
luckless has joined #lisp
<raeda_> On that topic, I've been playing with Graal/Truffle lately, which is a compiler toolkit. If there was a Truffle based CL, it would be easy to modify it for experiments
<raeda_> The downside is that you have to write it in Java :p
aartaka_d has quit [Ping timeout: 240 seconds]
<stylewarning> As discussed, a COMPUTED-GO, or even simpler, a jump table, are not something you can implement in CL as a macro without huge caveats
<stylewarning> (As discussed ad nauseum in the past)
hiroaki has quit [Ping timeout: 260 seconds]
<Bike> can't you? if the implementation optimizes CASE (as sbcl does for example) it doesn't seem to me like you'd be doing much worse than direct support
karlosz has joined #lisp
<stylewarning> Bike: well if an implementation supports CASE as a jump table then of course we are Golden
<stylewarning> But SBCL has had that for like 2 weeks now
<stylewarning> (I’m exaggerating, but it’s super recent)
<_death> so are you just talking about performance? or something else?
<Bike> i don't understand how the simple implementation helps here, if you want to worry about performance
<stylewarning> Bike: I gave an example of a control structure that is difficult to implement; maybe there are better examples than what I provided
aindilis has joined #lisp
<pyc> Pastebin link please for this channel? I forgot it. Someone should add the pastebin link to the topic.
<pyc> ,paste
<Bike> i don't think we have a specific pastebin any more
<stylewarning> Optimized CASE still doesn’t give computed goto; tags would need be able to appear anywhere in the lexical scope
<stylewarning> AFAIK tags have to show up only in the immediate body of a TAGBODY
<Bike> not sure what you mean. do you want to jump into the middle of an IF or something?
aindilis has quit [Remote host closed the connection]
karlosz has quit [Ping timeout: 252 seconds]
<Bike> C can do that but it makes the semantics pretty messy
<stylewarning> Bike: sure, that would be what you want if you wanted to implement coroutines
<_death> the next step after macros is a walker..
<stylewarning> Coroutines as a static variable (aka L-T-V + mutable cell) + computed goto
aindilis has joined #lisp
<Bike> for a coroutine wouldn't you have to jump "into" a tagbody, essentially? tagbody only has dynamic extent so you can't do that
<Bike> if i wanted to implement coroutines i'd probably start with continuations and go from there
luckless has quit [Quit: luckless]
<stylewarning> I think the DEFUN would be something like: LET jump-point = LTV(mutable-cell); (TAGBODY (go jump-point) ...)
luckless has joined #lisp
<Bike> well, i mean, so you'd have the tagbody in the coroutine, and when you yield you communicate the jump point back to the caller, right?
hiroaki has joined #lisp
<Bike> but then you're exiting the tagbody, and you can't re-enter it.
<stylewarning> I wasn’t even thinking about yielding from called functions
<Bike> that's not what i mean
<Bike> just yielding from the coroutine is what i'm talking about
<stylewarning> (Yield x) = (setf jump-point (incf next-number)) (return x) (tag next-number)
<stylewarning> something like that
<Bike> right, but you can't do that
<stylewarning> Why not
<Bike> once you return, you've exited the extent of the tagbody
aindilis has quit [Remote host closed the connection]
<stylewarning> Okay, and when you enter the function, the TAGBODY is entered again
<Bike> lisp doesn't let you do that. if you want to do that, you'd have to take care of things like storing the stack frame to put it back when you enter
<Bike> e.g. if you had some dynamic-extent thing in play at the yield point, you'd need to be able to put that back when you resume
<Bike> it's not impossible, but it would be pretty involved
<stylewarning> Where am I proposing re-entering an exited tagbody?
anticrisis has joined #lisp
<Bike> the (return x) is the yield, right?
<Bike> where are you returning to? outside the tagbody, right?
<stylewarning> RETURN is a normal RETURN-FROM, a DEFUN
<jcowan> stylewarning: CLHS 1.7 http://www.lispworks.com/documentation/HyperSpec/Body/01_g.htm tells you what the requirements are to call your implementation "a subset of CL".
<Bike> yeah, and your body is something like (defun coroutine ... (tagbody ...)) and you're doing (return-from coroutine), yeah?
<stylewarning> (defun f () (let ((cell ...)) (tagbody (go cell) ... (setf cell 1) (return-from f x) (tag 1) ...)))
<Bike> so when you return-from f, you're exiting the tagbody
<stylewarning> Yes
<stylewarning> I’m never jumping “back in” the exited tagbody
Inline has quit [Ping timeout: 260 seconds]
<Bike> okay, so your cell doesn't just have the jump point, it also has the entire stack frame?
<Bike> or at least anything that's used after the 1 tag
<stylewarning> In this case it just has the jump point; which isn’t 100% what’s required for a full “Just Works” coroutine with previously established lexical scope
<stylewarning> (ie restoring the frame as you mentioned)
<Bike> are there uses for coroutines with no state besides the control point? i've never really usd them but i assumed the state was a large part of the appeal
<stylewarning> But that’s a deficiency in our definition of computed goto, not necessarily in what we are trying to do with coroutines
<stylewarning> If you have a computed goto, you’ll have to decide what lexical variables mean if you’re jumping into a lexical context
<_death> there are also the "off the beaten path" CL implementations like Corman, Eclipse, Scieneer..
<stylewarning> And hence why it would be nice to have a simplistic implementation that removes barriers to trying these things out
heisig has joined #lisp
<Bike> i don't know how much a simple implementation would help with that. like you could do a fairly small interpreter-based one, but then adding this kind of extension would be pretty involved
<Bike> and implementing this with an interpreter would be vastly different from doing it with a compiler to the extent it would be hard to transfer what you'd learned
<stylewarning> But I would contend it’s likely an order of magnitude less involved than trying to hack it into SBCL
<Bike> (source: i wrote up a scheme with delimited continuations once. when i tried to write a compiler problems happened)
<stylewarning> Yes interpreter vs compiler vs bytecode vs .... are real implementation issues and written about extensively
<Bike> i guess the other thing i'd do is use sicl, which isn't exactly "simple", but it's modular enough to let you swap some stuff out
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
saganman has joined #lisp
saganman has joined #lisp
saganman has left #lisp [#lisp]
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
<Bike> i just don't understand what you'd do with the simple prototype exactly. you couldn't use it with production code sicne it's not efficient. you couldn't use it as much of a jumping off point for modding a more efficient lisp.
mindCrime_ has joined #lisp
heisig has quit [Ping timeout: 246 seconds]
<stylewarning> Do any lisp implementations survive that use green threads?
<Bike> i think ecl was gonna add them back
<stylewarning> I implemented this but it would be cooler with green threads https://github.com/stylewarning/lisp-random/blob/master/generators.lisp#L62
<stylewarning> easy to hit the OS limit on # threads
<stylewarning> But it’s a cool thing to have in Lisp (generators)
<Bike> coroutines are neat
<theothor`> FWIW, https://dlmf.nist.gov/LaTeXML/ can parse the dpans repos with some tweaks. Returns xml, and can parse directly to html. It struggles with the table macros, but I think workarounds are possible. The xml could be parsed to a clos thing also, I guess?
ntqz has quit [Remote host closed the connection]
<_death> I used that in a many-turtled logo thing
srhm has joined #lisp
<stylewarning> _death: it’s cool but to me it’s a toy only in the sense that it doesn’t provide an orthogonal feature
<stylewarning> IOW you need to write Lisp differently if you want this kind of feature using that technique
<stylewarning> Same issue with CL-CONT-based continuations, where it can’t CPS the standard library like MAPCAR
<stylewarning> (This is the CL-CONT version of coroutines: https://github.com/stylewarning/lisp-random/blob/master/coroutine.lisp )
<stylewarning> (It appears like it’s a nice orthogonal feature but it doesn’t work in certain circumstances, whereas the thread version does)
<_death> yeah, I have some snippets for coroutines using arnesi.. at one time I switched to cl-cont, but decided I liked arnesi better
srhm has quit [Quit: Konversation terminated!]
<stylewarning> I haven’t tried it
cage_ has quit [Quit: Leaving]
gareppa has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
mindCrime_ has quit [Ping timeout: 252 seconds]
gareppa has quit [Quit: Leaving]
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
<pjb> stylewarning: IIRC, CMUCL is the only one that still has green threads.
ntr has quit [Quit: ZNC - https://znc.in]
<stylewarning> I see
ntr has joined #lisp
ntr has quit [Remote host closed the connection]
orivej has joined #lisp
andrei-n has quit [Quit: Leaving]
heisig has joined #lisp
<pjb> stylewarning: you can check it in the sources https://gitlab.common-lisp.net/cmucl/cmucl search for process-yield and idle-loop
DHARMAKAYA has joined #lisp
bgardner has joined #lisp
bgardner has quit [Changing host]
bgardner has joined #lisp
bgardner has left #lisp [#lisp]
karlosz has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ has joined #lisp
<phoe> theothor`: TIL, thank you
Lord_of_Life_ is now known as Lord_of_Life
ntr has joined #lisp
shka_ has quit [Ping timeout: 276 seconds]
theothor` has quit [Remote host closed the connection]
theothor` has joined #lisp
dyelar has joined #lisp
Iolo has left #lisp ["WeeChat 3.0.1"]
DHARMAKAYA has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
akoana has joined #lisp
wsinatra has quit [Quit: WeeChat 3.1]
narimiran has quit [Ping timeout: 252 seconds]
kevingal has joined #lisp
Nilby has quit [Ping timeout: 245 seconds]
daphnis has joined #lisp
drbluefall has quit [Ping timeout: 252 seconds]
daphnis has quit [Ping timeout: 260 seconds]
kevingal has quit [Remote host closed the connection]
irc_user has joined #lisp
heisig has quit [Quit: Leaving]
random-nick has quit [Ping timeout: 240 seconds]
gaqwas has quit [Ping timeout: 240 seconds]
MrFantastik has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
remby has quit [Quit: remby]
remby has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
daphnis has joined #lisp
<opcode> i need some help understanding car and cdr: why does (append (cdr '(1 2 3 4)) (car '(a b c d))) return (2 3 4 . A) and not (2 3 4 A)?
attila_lendvai has quit [Ping timeout: 252 seconds]
duuqnd has quit [Remote host closed the connection]
<edgar-rft> try (append '(2 3 4 . A) nil)
<opcode> ah.
<opcode> is there an easier way than reversing a list and using (push)?
<moon-child> (append '(1 2 3 4) (list 'a)) ; -> (1 2 3 4 A)
theothor` has quit [Ping timeout: 240 seconds]
nature has quit [Ping timeout: 252 seconds]
ukari has quit [Remote host closed the connection]
<edgar-rft> APPENDing elements at the end of a list is not fast in Lisp, if you must add several elements one after the other it's often faster to PUSH to the reversed list and reverse again if finished. Alternatively you can keep a pointer to the last cell in a variable, but this only makes sense if you have really *many* of those APPEND operations on the same list.
ukari has joined #lisp
daphnis has quit [Ping timeout: 240 seconds]
<saturn2> you can simplify the latter approach with a macro such as uiop:while-collecting
<moon-child> alternately you can use arrays
shifty has joined #lisp
terpri has quit [Remote host closed the connection]
pankajsg has quit [Ping timeout: 276 seconds]
<phoe> sure, as long as you can avoid reallocating them often
varjag has quit [Ping timeout: 246 seconds]
surabax has quit [Quit: Leaving]
chewbranca has joined #lisp
chewbranca has quit [Changing host]
theothor` has joined #lisp
random-nick has quit [Ping timeout: 252 seconds]
theothor` has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 240 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
akoana has left #lisp ["Leaving"]
terpri has joined #lisp
hjudt has quit [Ping timeout: 265 seconds]
djuber has quit [Ping timeout: 252 seconds]
pve has quit [Quit: leaving]
slyrus has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
tempest_nox has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
mindCrime_ has joined #lisp
gumman has quit [Read error: Connection reset by peer]
gumman has joined #lisp
skapata has quit [Ping timeout: 260 seconds]
skapata has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
luna_is_here has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Ping timeout: 240 seconds]
scymtym_ has joined #lisp
luna_is_here has joined #lisp
hjudt has joined #lisp
edgar-rft has joined #lisp
hjudt has quit [Ping timeout: 240 seconds]
scymtym_ has quit [Remote host closed the connection]
scymtym has joined #lisp
igemnace has joined #lisp
<irc_user> Is it easy to call external binaries such as `ffmpeg` in common lisp?
<moon-child> (uiop:wait-process (uiop:launch-program "ffmpeg whatever whatever"))
<irc_user> thank you :)
<moon-child> wait-process returns an exit code. I think launch-program might also do something if it can't start the command
<irc_user> Got it, thank you. I haven't actually downloaded lisp yet but it looked interesting so I wanted to try rewriting some scripts in it. Looks like UOIP comes with it and isn't a separate lib?
<moon-child> uiop is a general portability library. It is not part of common lisp, but many implementations ship an implementation of it
<irc_user> Oh okay, I understand, thank you!
cer-0 has quit [Quit: leaving]
slyrus has quit [Remote host closed the connection]
slyrus has joined #lisp