jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <http://cliki.net/> <https://irclog.whitequark.org/lisp> <http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.4.5, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
Kundry_Wag has joined #lisp
robotoad has quit [Quit: robotoad]
Kundry_Wag has quit [Ping timeout: 250 seconds]
Bike_ has joined #lisp
notzmv has quit [Ping timeout: 250 seconds]
notzmv has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
elfmacs has joined #lisp
resttime has joined #lisp
<no-defun-allowed> alright, thanks
<no-defun-allowed> i'm looking for something harder to emulate that isn't risc-v or "lol write a ps4 emulator" though
<verisimilitude> Oh, so you are interested in seeing what I've been working on that relates to this?
specbot has quit [Remote host closed the connection]
specbot has joined #lisp
<no-defun-allowed> sorry, not really
<verisimilitude> Alright; I was just checking.
<verisimilitude> You mentioned compiling unconditional CHIP-8 segments earlier; do you have a proper mechanism for when such code is modified or what?
Kundry_Wag has joined #lisp
<no-defun-allowed> nope, it just dies unfortunately
Mr-Potter has quit [Quit: Leaving]
<no-defun-allowed> in future, i'll add a write barrier which checks for that and removes the compiled code
Kundry_Wag has quit [Ping timeout: 240 seconds]
<verisimilitude> How does it die instead of giving incorrect results?
<no-defun-allowed> well, it does give incorrect results
<no-defun-allowed> somewhat informal and inaccurate description of what happens actually
<no-defun-allowed> i don't think i have tested any programs that use self modifying code though
shifty has joined #lisp
elderK has quit [Ping timeout: 240 seconds]
<verisimilitude> I strive to write small CHIP-8 games and I want to make use of self-modification, but the awkward memory access instructions get in the way of that, usually, although it's not for lack of looking for opportunities.
atgreen has joined #lisp
<verisimilitude> I haven't looked through a large enough selection of such games to know how common it is, though.
<dlowe> verisimilitude: there's an active #lispgames channel, btw
ealfonso has joined #lisp
<dlowe> This CHIP-8 thing is wild
<dlowe> I wanna just hack up an emulator now.
<verisimilitude> I'm aware, but CHIP-8 isn't intimately related to Lisp.
<dlowe> doesn't have to be *intimately* related. reading the CHIP-8 in common lisp
<dlowe> posts now
<verisimilitude> Well, I suppose if it's fine, I'll drone on about what I've been doing with CHIP-8 there.
<dlowe> using CL?
<verisimilitude> Technically, yes.
<dlowe> :)
hectorhonn has joined #lisp
xristos has joined #lisp
<hectorhonn> how do i use read-from-string to get the "form"? e.g. "(+ 1 2)" should give the list (+ 1 2), not 3. (does that make sense?)
<no-defun-allowed> that's exactly what it'll do
<dlowe> did you enter at the repl: (read-from-string "(+ 1 2)")
<dlowe> (it'll also tell you how much it read in a second value)
<verisimilitude> That's what READ-FROM-STRING does, yes, hectorhonn; you can also give it the usual :start and :end keyword arguments.
<hectorhonn> i entered in the repl, but it gave two lines, (+ 1 2) and 7
<hectorhonn> oh
<hectorhonn> 7 is how much it read
<hectorhonn> my bad, i thought that was the result of 1 + 2
<no-defun-allowed> that would be 3
<hectorhonn> still not awake
<hectorhonn> haha
<hectorhonn> groggy friday
<verisimilitude> Now do this, hectorhonn: (read-from-string "#.(+ 1 2)")
<verisimilitude> It's very important to set *READ-EVAL* properly if you're going to be using the READ functions in a program.
<hectorhonn> 3
<hectorhonn> 9
<hectorhonn> i see
<verisimilitude> Yes; the #. is a reader macro that evaluates the form and acts as if it read in the result, instead.
<hectorhonn> i can set it globally right? (setf *read-eval* nil)
<verisimilitude> Yes.
<verisimilitude> That's because it's a special variable.
<verisimilitude> This also means you can temporarily bind it, such as with a LET, and it will use the bound value while executing the body of the LET.
<verisimilitude> That is, even if you're calling unrelated functions.
dale has quit [Quit: dale]
<hectorhonn> wait, if i setf it to nil in my package, then if another package calls read-from-string without let, which value will it see?
<verisimilitude> If you set *READ-EVAL* to NIL, it will remain NIL unless something changes it.
<hectorhonn> even if i put in-package before that?
<verisimilitude> Rephrase your question.
sjl has quit [Ping timeout: 250 seconds]
<hectorhonn> (in-package "my-package")
<hectorhonn> (setf *read-eval* nil)
<hectorhonn> (another-package:function-that-calls-read-from-string "....")
<hectorhonn> erm
<verisimilitude> Assuming *READ-EVAL* here is the same symbol in the COMMON-LISP package, then that will be a global assignment, hectorhonn.
<verisimilitude> So, it doesn't matter which package you set it from.
<hectorhonn> ohh
<hectorhonn> right, i get it now
<hectorhonn> thanks verisimilitude!
<verisimilitude> It's no issue, hectorhonn.
<verisimilitude> If you're interested, I can point you towards a forum where you can ask more Lisp questions of any kind; it may be more convenient than IRC, since you can ask a question and then check for answers days or weeks later.
<verisimilitude> Would you be interested in knowing where this is?
marvin2 has quit []
<hectorhonn> yeah sure
<hectorhonn> reddit?
<verisimilitude> Oh, no.
<verisimilitude> Are you familiar with imageboards, hectorhonn?
<hectorhonn> wow, what's this
<hectorhonn> no, what are they?
gigetoo has quit [Ping timeout: 246 seconds]
<verisimilitude> Imageboards are a rather nice type of forum; you don't need to register an account or anything; in fact, there are no accounts whatsoever.
<hectorhonn> i see
<verisimilitude> In this imageboard, you simply get a random name with a post, unless you write a name explicitly. The idea is you can post in threads, not unlike an IRC channel, and the posts appear in those threads; you can attach images or other files to posts. You can also start your own threads, although I don't recommend it if you're new.
<verisimilitude> As you can see, these have some advantages over the IRC model.
<hectorhonn> being able to post an image is nice
<verisimilitude> If you'd like to learn more, I'll continue in a PM, so I don't glut this channel with unnecessary messages.
<hectorhonn> ah, its ok, let me explore it on my own
<verisimilitude> Also, I may as well let you know that I'm the fellow behind that particular thread; it's a series of threads that have been going on four almost five years now.
<hectorhonn> thanks again for the resource :)
_whitelogger has joined #lisp
Essadon has quit [Quit: Qutting]
<_death> verisimilitude: hi, have you tried acute-terminal-control with urxvt?
gigetoo has joined #lisp
<verisimilitude> I don't believe I have, _death.
<verisimilitude> I can tell you that READ-EVENT still has some issues I've yet to correct.
smokeink has joined #lisp
<verisimilitude> This issue doesn't matter unless you want the escape character itself to be a distinct event, however.
<verisimilitude> It's not a large issue; I've merely yet to correct it.
<verisimilitude> Is there any particular reason you asked, _death?
terpri has quit [Quit: Leaving]
<_death> ok.. there are some other symptoms, like mouse events and extended keys
igemnace has joined #lisp
<verisimilitude> Those would be the issues, yes.
<verisimilitude> From what I've seen, xterm and its ilk have multiple incompatible encodings for the function keys; I've only implemented one of these.
FreeBirdLjj has joined #lisp
<verisimilitude> Would you go into more detail about any of these particular issues, _death?
<_death> verisimilitude: well, I started using it for some tui library ( see https://adeht.org/casts/tui.html ) but holidays were over and other stuff got my time..
<verisimilitude> It's very interesting to see someone else using my libraries.
<verisimilitude> Can I see the source to this anywhere?
FreeBirdLjj has quit [Ping timeout: 250 seconds]
<_death> ugh, not yet :)
<verisimilitude> Alright.
<verisimilitude> I have made some recent changes, so you will want to download the latest version and take a look at the updated documentation.
<_death> cool
elderK has joined #lisp
dacoda has quit [Remote host closed the connection]
<_death> oh well, it's sleepytime
<verisimilitude> Good night, then.
dacoda has joined #lisp
atgreen has quit [Ping timeout: 240 seconds]
notzmv has quit [Ping timeout: 250 seconds]
resttime has quit [Ping timeout: 250 seconds]
dale has joined #lisp
notzmv has joined #lisp
robotoad has joined #lisp
Kundry_Wag has joined #lisp
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
dacoda has quit [Ping timeout: 250 seconds]
easye has quit [Ping timeout: 246 seconds]
graphene has quit [Remote host closed the connection]
fe[nl]ix has quit [Ping timeout: 252 seconds]
Blkt has quit [Ping timeout: 252 seconds]
graphene has joined #lisp
arescorpio has joined #lisp
specbot has quit [Ping timeout: 246 seconds]
<fouric> jasom: ty, i wrote that down for reference
minion has quit [Ping timeout: 246 seconds]
<fouric> question: if i'm using symbols for "communication" between code in different packages
<fouric> for instance, i have a library that opens a file descriptor and gets input from the keyboard, represented as a list of symbols
<fouric> ...should i (1) intern the symbols in the package of the called library (2) intern the packages in the keyword package (3) intern the symbols in the common-lisp-user package (4) not use symbols for that or something else?
<fouric> s/packages/symbols in (2)
Blkt has joined #lisp
fe[nl]ix has joined #lisp
<verisimilitude> Interning in the KEYWORD package isn't suggested unless it's a finite set and using CL-USER for this is poor, since you're not guaranteed its particular contents.
<verisimilitude> I'd recommend you avoid using symbols for this, but more detail as to what you're doing would help.
<fouric> i have a small library that takes keyup and keydown events and returns chords like ((C M) . s) would be ctrl + meta + s
<fouric> well, that's what it's doing now
<fouric> ...it translates keyup and keydown events into chords, and i need to find a good representation
<verisimilitude> Well, using KEYWORDS for that doesn't seem bad, then.
<verisimilitude> You'd just have a few symbols you'd need.
<fouric> right, because there's a relatively small number of keys that could be pressed...
<fouric> so in this case it's ok?
<verisimilitude> I'd write so, yes.
<fouric> alright, i'll give it a shot
<fouric> ty
<verisimilitude> It's no issue.
wigust has joined #lisp
specbot has joined #lisp
minion has joined #lisp
atgreen has joined #lisp
thekolb has quit [Ping timeout: 252 seconds]
ioa has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
<aeth> I use keywords for keys.
Kundry_Wag has quit [Ping timeout: 250 seconds]
atgreen has quit [Ping timeout: 240 seconds]
Bike_ has quit [Quit: Lost terminal]
dddddd has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<Xach> aeth: what do you use for words?
permagreen has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<aeth> Xach: architecture-specific, but generally (unsigned-byte 64)
Kundry_Wag has quit [Ping timeout: 272 seconds]
ggole has joined #lisp
<beach> Good morning everyone!
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
rnmhdn has joined #lisp
<hectorhonn> morning beach
<aeth> A more elaborate version of this could be used for words: '#.`(unsigned-byte ,(if (find :64-bit *features*) 64 32))
<aeth> (or more realistically, with deftype)
<verisimilitude> Hello, beach.
<verisimilitude> I usually just use (UNSIGNED-BYTE 8) and handle it with that.
buffergn0me has quit [Remote host closed the connection]
buffergn0me has joined #lisp
arescorpio has quit [Remote host closed the connection]
whartung has quit [Ping timeout: 252 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Kundry_Wag has joined #lisp
whartung has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
smokeink has quit [Ping timeout: 250 seconds]
sauvin has joined #lisp
impulse has quit [Quit: leaving]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
smokeink has joined #lisp
Kundry_Wag has joined #lisp
hectorhonn has quit [Quit: Page closed]
mrcom has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
mrcom has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
notzmv has quit [Ping timeout: 246 seconds]
impulse has joined #lisp
notzmv has joined #lisp
vlatkoB has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
resttime has joined #lisp
smokeink has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
CrazyEddy has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
makomo has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
panji has joined #lisp
bjorkintosh has quit [Read error: Connection reset by peer]
mingus has quit [Remote host closed the connection]
ggole has quit [Ping timeout: 252 seconds]
notzmv has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
ggole has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
ggole has quit [Ping timeout: 264 seconds]
notzmv has joined #lisp
Kundry_Wag has joined #lisp
smokeink has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
ggole has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
ggole has quit [Ping timeout: 250 seconds]
notzmv has quit [Ping timeout: 250 seconds]
notzmv has joined #lisp
rumbler31 has joined #lisp
Inline has quit [Quit: Leaving]
yvy has joined #lisp
impulse has quit [Quit: Lost terminal]
mrcom has quit [Read error: Connection reset by peer]
ggole has joined #lisp
varjag has joined #lisp
rumbler31 has quit [Remote host closed the connection]
yvy has quit [Ping timeout: 250 seconds]
mrcom has joined #lisp
crsc has quit [Quit: leaving]
Kundry_Wag has joined #lisp
crsc has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
panji has left #lisp [#lisp]
<splittist> hello
Kundry_Wag has quit [Ping timeout: 272 seconds]
<crsc> hi
<verisimilitude> Hello, splittist.
smokeink has quit [Remote host closed the connection]
equequwal has joined #lisp
resttime has quit [Quit: resttime]
smokeink has joined #lisp
robotoad has quit [Quit: robotoad]
hectorhonn has joined #lisp
notzmv has quit [Ping timeout: 272 seconds]
notzmv has joined #lisp
orivej has joined #lisp
Kundry_Wag has joined #lisp
akoana has joined #lisp
equequwal has quit [Ping timeout: 250 seconds]
kajo has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Ping timeout: 250 seconds]
orivej has quit [Ping timeout: 250 seconds]
robdog has quit [Read error: Connection reset by peer]
akoana has quit [Quit: Leaving]
akoana has joined #lisp
megalography has quit [Quit: Leaving.]
megalography has joined #lisp
megalography has quit [Client Quit]
nowhere_man has joined #lisp
akoana has quit [Quit: Leaving]
varjag has joined #lisp
kdridi has joined #lisp
kdridi has quit [Client Quit]
kayront has joined #lisp
hhdave has joined #lisp
robdog has joined #lisp
adam4567 has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 268 seconds]
hhdave_ is now known as hhdave
wigust- has joined #lisp
wigust has quit [Ping timeout: 250 seconds]
frgo_ has quit [Remote host closed the connection]
lavaflow has quit [Ping timeout: 250 seconds]
frgo has joined #lisp
adam4567 has quit [Remote host closed the connection]
verisimilitude has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
kajo has joined #lisp
frgo has quit [Ping timeout: 246 seconds]
<loke> Does alexandria (or another library) have a good implementation of a tree/list search?
<loke> Something that can search lists of lists where the lists may be improper.
Kundry_Wag has joined #lisp
easye has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
<ogamita> (block found (nsubst-if nil (lambda (item) (if (eql item 42) (return-from found 42)) nil) '((1 . 2) (3 . 42) 4))) #| --> 42 |#
nsrahmad has joined #lisp
<ogamita> loke: ^
<lieven> that's for dotted lists. does the solution need to cater for circular ones as well?
<loke> I don't care about circular
<loke> but I need to collact all sublists that starts with a given keyword
<loke> So if the kw is :A
<loke> '((foo bar 1 (:a THIS) (bar 2 . 3) ((inner . (:a test)))))
<loke> that one should return :a this, and :a test
<ogamita> loke: then it's easier to write it yourself, but you may have a look at: http://groups.google.com/group/comp.lang.lisp/msg/0c66e597e08be90d
<loke> got it. thanks
<ogamita> You have more considerations: depth, width of the tree (so can you use a recursive function or should you derecursive it), and you want to collect the finds.
<loke> Thanks.
<loke> I figured out an easier solution. It didn't need to be as gneral.
lavaflow has joined #lisp
frgo has joined #lisp
JohnMS_WORK has joined #lisp
JohnMS has joined #lisp
JohnMS has quit [Client Quit]
lavaflow has quit [Ping timeout: 250 seconds]
norserob has joined #lisp
razzy has joined #lisp
robdog_ has joined #lisp
Kundry_Wag has joined #lisp
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
elfmacs has quit [Ping timeout: 272 seconds]
shifty has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 244 seconds]
<norserob> Hi, I'm trying to write a JSN string to a UNIX domain socket, to control the mpv player. It works fine from the command line, but not from ccl. Here is a small example to pause the mpv player: https://gist.github.com/rfolland/6458fcce83c73c4645cf8793771e1d75
<norserob> s/JSN/JSON/
igemnace has quit [Quit: WeeChat 2.3]
Lycurgus has joined #lisp
orivej has joined #lisp
<loke> norserob: I've never use CCL's own socket functions
<loke> Also, you never explained what problems you're seeing.
<loke> “it doesn't work” is not a very helpful way of describing your issues.
<scymtym> norserob: if CCL's sockets are streams, try FORCE-OUTPUT
<loke> scymtym: I'd assume W-O-S to close the socket, implying it being closed.
<loke> flushed
<scymtym> loke: right
<ogamita> norserob: did you flush?
<ogamita> nope. No flush, no send. Well, since you close, it should flush automatically, but since the close comes just after receiving the command, it's possible the problem is at the receiving end.
<ogamita> norserob: what do you see in tcpdump?
<ogamita> forget tcpdump, since you're on a unix socket.
meepdeew has quit [Remote host closed the connection]
<ogamita> norserob: also, in lisp you didn't write a newline.
<norserob> Tried a forec-output now, did not help. It is not a TCP socket, just a UNIX file socket
<ogamita> About newlines, you should know how the protocol encodes them? LF, CR, CR-LF?
<ogamita> norserob: add ~%
<loke> JSON doesn't require nelines.
<ogamita> But a program reading lines do.
<norserob> YESS! A newline did it. ~& in the format string. Thank you!
<ogamita> The newline may be not JSON, but record separator.
<norserob> I appreciate the help, I've spent some time on this today. Now I can move on. Thanks again.
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
pjb has quit [Remote host closed the connection]
lavaflow has joined #lisp
pjb has joined #lisp
lavaflow has quit [Ping timeout: 246 seconds]
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
kooga has quit [Quit: :]
frgo has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 250 seconds]
frgo has joined #lisp
nsrahmad has quit [Read error: Connection reset by peer]
frgo has quit [Read error: Connection reset by peer]
rnmhdn has quit [Read error: Connection reset by peer]
frgo has joined #lisp
notzmv has joined #lisp
rnmhdn has joined #lisp
atgreen has joined #lisp
kammd[m] has joined #lisp
lavaflow has joined #lisp
lavaflow has quit [Ping timeout: 246 seconds]
hectorhonn has quit [Quit: Page closed]
Selwyn has joined #lisp
Kundry_Wag has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
robdog_ has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 250 seconds]
robdog_ has joined #lisp
nsrahmad has joined #lisp
lavaflow has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
gxt has joined #lisp
lavaflow has quit [Ping timeout: 250 seconds]
pjb has joined #lisp
lavaflow has joined #lisp
lavaflow has quit [Ping timeout: 250 seconds]
heisig has joined #lisp
pjb has quit [Remote host closed the connection]
gxt has quit [Ping timeout: 246 seconds]
pjb has joined #lisp
atgreen has quit [Ping timeout: 250 seconds]
lavaflow has joined #lisp
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
lavaflow has quit [Ping timeout: 250 seconds]
robdog_ has quit [Remote host closed the connection]
pjb has quit [Ping timeout: 250 seconds]
lavaflow has joined #lisp
orivej has quit [Ping timeout: 244 seconds]
lavaflow has quit [Ping timeout: 246 seconds]
Bronsa has quit [Remote host closed the connection]
nsrahmad has quit [Remote host closed the connection]
orivej has joined #lisp
hectorhonn has joined #lisp
pjb has joined #lisp
pjb has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
hectorhonn has quit [Ping timeout: 256 seconds]
pjb has joined #lisp
hectorhonn has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
pjb has quit [Ping timeout: 252 seconds]
Selwyn has quit [Ping timeout: 246 seconds]
lavaflow has joined #lisp
hectorhonn has quit [Quit: Page closed]
gxt has joined #lisp
frgo has quit [Remote host closed the connection]
lavaflow has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
phax has quit [Remote host closed the connection]
norserob has quit [Quit: leaving]
neirac has joined #lisp
frgo has joined #lisp
<_death> hmm, last night.. surprised that the machine actually took my rubbish and produced a right result.. but the lisp trick (compare ENCODE and ENCODING) may be of note, used it many times for stuff like this.. https://gist.github.com/death/e330b4a48c87104de341ba3a11ff5836
frgo has quit [Ping timeout: 246 seconds]
Lycurgus has quit [Quit: Exeunt]
lavaflow has joined #lisp
<neirac> I'm kind of lost creating a package. if my package has dependencies that are met using quicklisp how do I specify them using defpackage ?
rippa has joined #lisp
<jdz> neirac: Common Lisp packages are orthogonal to QuickLisp packages.
<jdz> The things in QuickLisp could be called "projects".
lavaflow has quit [Ping timeout: 246 seconds]
<neirac> jdz thanks
razzy has quit [Ping timeout: 250 seconds]
<Xach> and inside the projects are systems
<Xach> loading a system usually creates one or more packages in the cl environment
notzmv has quit [Ping timeout: 240 seconds]
<dlowe> that's reinforced by the existence of the "quickproject" project
<Xach> reinforced?
<dlowe> the terminology is reinforced
<dlowe> made more convincingly authoritative
notzmv has joined #lisp
<Xach> oh, re project, gotcha
<Xach> quicklisp also has another concept in between project and system -- "release" -- which is a snapshot of a project at some point in time taken in some way
<Xach> anyway, for relationship management, it is normal to define a system via a system file
<Xach> lots of examples to follow
<dlowe> I foresee a "project" file in the future
<dlowe> and all these asdf fields that aren't about building systems fall into disuse
lavaflow has joined #lisp
m00natic has joined #lisp
dale has quit [Quit: dale]
<neirac> I'm trying to implement a rest service is there any recommended packages to use ? I was looking at caveman2 at this point
lavaflow has quit [Ping timeout: 250 seconds]
<Xach> I like to use hunchentoot, which is lower-level so that might not be the best option available these days.
Essadon has joined #lisp
ogamita has quit [Read error: Connection reset by peer]
ogamita has joined #lisp
heisig has quit [Quit: Leaving]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
Inline has joined #lisp
smokeink has quit [Ping timeout: 245 seconds]
random-nick has joined #lisp
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
LiamH has joined #lisp
jochens has joined #lisp
frgo_ has joined #lisp
frgo has quit [Ping timeout: 250 seconds]
<neirac> I'm reading this https://leanpub.com/fullstacklisp/read#leanpub-auto-the-web-stack it's good for beginners like me.
lavaflow has joined #lisp
jmercouris has joined #lisp
<Xach> cool!
<jmercouris> can someone explain why these two structs are not considered equal: https://pastebin.com/LAsELupe ?
<jmercouris> (equal (list "S") (list "S")) --> T
<jmercouris> (equal "t" "t") --> T
<beach> clhs equal
<Xach> jmercouris: that's not how equal works.
<Xach> equalp is different
<beach> "equal does not descend any objects other than the ones explicitly specified above."
<jmercouris> ah damn, I didn't see that
<jmercouris> so it does not traverse the struct
<beach> "structure uses eq"
<pfdietz> The problem is there is no such thing as a generally applicable equality function. It's inherently context specific. Baker had a paper on this, if I recall correctly.
<pfdietz> It ties closely to why there's no general purpose hash function, and no general purpose copy function.
neirac has quit [Quit: Leaving]
<Xach> pfdietz: pitman is often cited
<jmercouris> beach: here's the interesting thing, shouldn't it still be passing with eq? or is the issue the list of strings?
<Xach> equal rights and wrongs, i think?
<jmercouris> the list of strings is the issue I guess, if modifiers was purely a string, of all of the string elements concatenated, it would work, no?
elfmacs has joined #lisp
<pfdietz> Now that you mention it, Pitman sounds like what I was thinking of.
<beach> jmercouris: Why would it be EQ?
<beach> jmercouris: EQ is identity.
<lieven> eq checks whether they're at the same address
<Xach> jmercouris: EQ is only for the exact same identical object. an existing object will never be EQ to something that comes from MAKE-whatever (unless MAKE-whatever isn't really making)
<jmercouris> damnit, I meant to say eql
lavaflow has quit [Ping timeout: 246 seconds]
<beach> clhs eql
<pfdietz> EQ and numbers do not play well together.
<jmercouris> however that still wouldn't work because struct will use eq
<beach> jmercouris: You need to read that page then.
<jmercouris> as you have said above
<jmercouris> Yes, I see my mistake
<jmercouris> only characters, not strings
<pfdietz> My rule of thumb is to always use EQL instead of EQ, and let the compiler optimization to EQ if it can determine that's safe.
<Xach> CL supports many characters, some of them colorful
<jmercouris> well, I see no solution then to using a hash-table with structs as keys, without using equalp, that's the only logical path
<pfdietz> optimize to
<jmercouris> otherwise, what's the point of a hash-table if I have to maintain a reference to every struct?
<pfdietz> There's a need for a better hash facility in CL.
<pfdietz> Could be library based, except perhaps for weakness support.
<jmercouris> my original problem was distinguishing between: https://pastebin.com/qf408e0h as keys for a hash table
<jmercouris> however, I see now that I will have to use something other than a lowercase/uppercase to distinguish
<Xach> Really? It was't for mapping key input to some activity?
<jmercouris> Xach: that's the ultimate goal yes, but I was using lower case "s" as a modifier for shift and upper case "S" as a modifier for super
<jmercouris> however, if equalp cannot distinguish between the two I gave above, and equal will simply not work for my hash table, then I must change from using upper and lowercase "s" to some other letter in the alphabet entirely
<Xach> jmercouris: i think one common trick is to have an integer where some bits represent modifiers and the rest of the bits represent the code. that is a good hash key.
<jmercouris> that's usually what people do, or something where they make a mask
mingus has joined #lisp
<jmercouris> however, I wanted the key-chord struct to be obvious to understand and read
<Xach> it is possible to do both
<jdz> jmercouris: I'd use :super and :shift instead of "S" and "s"...
<jmercouris> e.g. the printable representation of a key-chord struct makes it obvious what keys were being pressed at that time without reading documentation
JohnMS_WORK has quit [Quit: KVIrc 4.2.0 Equilibrium http://www.kvirc.net/]
<jmercouris> jdz: interesting idea
<jmercouris> I will then need to change how the actual keymaps are made, but that can be done
<jmercouris> Xach: how might I do both?
<Xach> jmercouris: keep your struct, but have a function to produce a hash key from it. use the struct everywhere, but don't use it directly for looking things up in the table.
<Xach> it's a Bad key.
<jdz> The Bad key is next to Any key.
<jmercouris> so you are suggesting I write my own hash function?
<jmercouris> also what do you mean by a "Bad" key? is there a reason you capitalized "Bad"? is there some proper noun I should know about?
<jmercouris> some programmer joke I haven't yet learned perhaps :D?
Lycurgus has joined #lisp
<_death> make-hash-table could have a :key-key parameter
<ogamita> jmercouris: "To continue, press any key." Now look at your keyboard, where is the Any key?
<jmercouris> I know the any key one for sure, never heard of the bad key one though
<ogamita> It's basic logic: when you must press the Any key, if you press the key next to it, it will be the Bad key.
<ogamita> Any key that is not the Any key is the Bad key.
<jmercouris> lol, sure
lavaflow has joined #lisp
slyrus2 has joined #lisp
dddddd has joined #lisp
lavaflow has quit [Ping timeout: 250 seconds]
lagagain has joined #lisp
lagagain has left #lisp [#lisp]
hectorhonn has joined #lisp
<Xach> jmercouris: integers are Good keys and lists and structs are Bad
<Xach> big compound objects are not Good for keys
<hectorhonn> i just realized, dynamic variables are just like c functions that take arguments by copy. right?
<jmercouris> what about strings
<Xach> compound objects that might get mutated are Very Bad and actually Right Out
<jmercouris> are strings okay keys?
<Xach> jmercouris: medium. just don't mutate.
<jmercouris> Ok, I will consider serializing the struct to some string representation then
<jmercouris> either that or just changing shift to be "SH" instead of just "s"
<Xach> It seems odd to care so much about if someone is looking at the keys of a table
<Xach> If they are looking that deep surely they should be aware of context?
<jmercouris> I will be looking at the keys of a table
<jmercouris> for example, as the user is typing, I want to echo the keys they've typed
<Xach> So write a function that instantly shows you the chord of a table key
<jmercouris> I have a stack of key-chords
<jmercouris> and I want to just print them to the echo to show the user
<jdz> hectorhonn: There is nothing in C that is like dynamic variables. Except maybe passing a pointer to a stack-allocated location down the call chain.
<jmercouris> so I will either have to transform them as you've suggested, or just change to SH
<jmercouris> because otherwise I would find myself writing serialize and deserialize functions for mys truct
<Xach> i can tell from the "just" you have decided what is better
<jmercouris> s/truct/struct
<jmercouris> I haven't decided
<jmercouris> I am actually sending an email to ambrevar to get his opinion
<Xach> "just" says otherwise
<jmercouris> I have mentally decided yes, but I do not make all the decisions, I try to get input from everyone on the project
<Xach> maybe your heart has decided
<jmercouris> if someone strongly disagrees with me, I frequently go with their decision
notzmv has quit [Quit: WeeChat 2.3]
<Xach> anyway, everything is a tradeoff, and one of the tradeoffs is performance, and sometimes that is valued too highly in favor of things that seem like the machine can do quickly, even if the other way is fast enough
<jmercouris> everything is a trade, and I am well aware that I am incompetent in many respects, and competent in others, I do not trust myself fully to make all engineering decisions, however I do have an opinion, however unqualified it may be
<jmercouris> woah, we almost said the same thing :D jinx!
<Xach> it is just exciting sometimes to think about how fast an integer can be compared to another integer! so fast!
<jackdaniel> in theory when you have nice and clean interface whose 3 of 8 values are what you look for you should use it
<Xach> jmercouris: are key chord structs de facto unchangeable?
<jackdaniel> in practice it is usually 8x slower as a general api and if it is a bottleneck you need to opencode the same computation
<jmercouris> Xach: what do you mean? unchangeable?
<Xach> jmercouris: would someone with a key chord struct make changes to it? modify or mutate its parts?
<jmercouris> Xach no
<jmercouris> unless they were a sadist, it is meant to be basically a way to store a key-chord event
<Xach> oh, then you can get fancy and use an eq hash table and make sure that the same arguments produce the same (eq) key chord
<jmercouris> Xach: how can I do that?
<Xach> but, probably not worth the trouble until it proves to be too slow for real life
<jmercouris> ok
<jmercouris> I will wait then
<jmercouris> so far it is doing very few comparisons, and I see no noticable decrease in speed
<Xach> the machine can compare integers SO quickly
<_death> Xach: I think that's a good solution not just because of the hash table keys
<jmercouris> at one point I had several million entries in the hash table and I could still not physically distinguish the delay
<jmercouris> however, I am interested in learning about what you are suggestin
<jmercouris> would you please expand upon it?
<Xach> Sorry, I have to walk to work and maybe get a breakfast burrito from the side of a van along the way now
<jmercouris> ok, guten appetit!
<jmercouris> _death: You seem to understand what he means, can you please explain?
<_death> jmercouris: do you know of the function INTERN? well, you could intern key chords.. the problem is that it can be a bit circular, as you may need a mapping there too
<jmercouris> I do know of the function INTERN, yes
<jmercouris> I'm still not understanding exactly how you would do this though
lavaflow has joined #lisp
<hectorhonn> jdz: ok, maybe not entirely alike for c function that affects globals. what i meant was when a c function exits, whatever change that was made to the copy arguments get discarded. in that sense it is like the dynamic variables. CL on the other hand always takes function arguments by reference, never copy, unless let is used..?
<ogamita> hectorhonn: lisp has exactly the same argument passing as C.
<jmercouris> I would somehow turn the key-chord into a symbol???
<jackdaniel> why not? (alexandria:symbolicate "M-" "x")
<ogamita> (defun f (x) (setf x 42)) #| --> f |# (let ((y 33)) (f y) y) #| --> 33 |#
<jdz> ogamita: As far as I know in C parameters are passed by value.
<ogamita> jdz: exactly like in lisp1
<ogamita> !
<jdz> No.
<ogamita> (defun f (x) (setf x 42)) #| --> f |# (let ((y 33)) (f y) y) #| --> 33 |#
<jdz> Pass a struct.
<jackdaniel> jdz: if you think about this, in lisp you pass them by value as well, but all values which programmer may put their fingers on is a pointer
<jackdaniel> are pointers*
quipa has joined #lisp
<_death> jmercouris: the idea is to have a single object instead of multiple equivalent objects
<jackdaniel> with exception for immediates
<jdz> Terminology can be confusing here. I'm using the C one, where the different modes are "pass by value" and "pass by reference".
<ogamita> struct pt { int x,y; }; void f(struct pt* p){ p=malloc(sizeof(*p)); } main(){ struct pt q={1,2}; f(&q); printf("%d %d\n",q.x,q.y); return 0; }
<jdz> ogamita: You passed a pointer to struct, not the struct itself.
<ogamita> jdz: in lisp a lot of values are references, just like in C you have to use pointers, because a lot of values are not firs class objects.
<jmercouris> _death: I get that, but I don't understand how you could say (make-key-chord ...) and get the same object back
lavaflow has quit [Ping timeout: 268 seconds]
<ogamita> jdz: a structure is not a first class object in C:you cannot pass it as parameter ("by value") to a function.
<pfdietz> Numbers and characters are weird in Common Lisp. An implementation is allowed to copy them (as in, change how they behave with respect to EQ) at any time. So it's only good to use them in a way that call-by-reference and call-by-value are indistinguishable.
<jdz> I might have been thinking about C++ then.
<jmercouris> _death: wouldn't you have to wrap it in some function or something that returns the key-chord as a symbol?
<_death> jmercouris: so you have a hash table keyed by say an integer representation of the key-chord that maps to the structure objects, and whenever you want to return a key chord, you get it from that table.. you wouldn't say make-key-chord, but lookup-key-chord
<jmercouris> Ok, I'm going to need to read that a few times
<jmercouris> how do I get this integer representation of the key-chord?
<jmercouris> I would need to write a serialization operation, no?
<ogamita> jmercouris: encoding.
<_death> jmercouris: I am not talking about symbols.. I mentioned INTERN for the concept of having an atomic object
<ogamita> jmercouris: yes.
<jmercouris> hmmm
<jmercouris> it is an interesting solution
<jmercouris> and the efficiency is there...
<ogamita> (dpb (char-to-int chord) (bytes 8 21) (modifier-to-int chord))
<ogamita> jmercouris: or look at how emacs does it, and for compatibility choose the same encoding.
<hectorhonn> jdz: ah yes. c++, not c. my bad
<hectorhonn> jdz: wait, but c does have pass by copy
<jdz> It's besides the point.
elfmacs has quit [Ping timeout: 244 seconds]
<jdz> The only similarity might be that yes, dynamic bindings are unset when stack-unwinding.
Bronsa has joined #lisp
hectorhonn_ has joined #lisp
hectorhonn has quit [Ping timeout: 256 seconds]
<jdz> Not sure how that interacts with values allocated on stack in the presence of setjmp/longjmp (especially if pointers to such values are stored somewhere).
<jdz> That's probably why I'm not programming in C.
<jdz> CL dynamic variable bindings work as expected in the presence of non-local transfer of control.
<hectorhonn_> jdz: haha, all right
hectorhonn has joined #lisp
<ogamita> This is a recent addition to C compilers, even if it has been standardized at least in c89, IIRC.
<ogamita> And it doesn't make a deep copy, so if the struct contains pointers, you are sharing data anyways.
<hectorhonn> ogamita: (nod nod)
hectorhonn_ has quit [Ping timeout: 256 seconds]
<hectorhonn> good night everyone
<hectorhonn> !
hectorhonn has quit [Quit: Page closed]
<beach> It is interesting that some people have difficulties understanding what I call "uniform reference semantics". I mean, it's a very simple model compared to what C or C++ do.
atgreen has joined #lisp
<pfdietz> It's perhaps closer to Java, except for the latter's primitive types.
<beach> That's true.
<Bike> i know in my case i started out learning (an oversimplified version of) what C++ does and expected lisp to be similarly confusing
<beach> Heh.
<beach> Oh, the disappointment!
<_death> Lisp, C, and Java are pass-by-value
<_death> C++ also supports pass by reference
<ogamita> Pascal, Modula-2, Modula-3, C++ have pass-by-value and pass-by-reference.
* pfdietz was just reading about C++ move semantics and rvalue referenecs.
<ogamita> f(VAR by_refererence:type;by_value:type);
<_death> interesting that even Visual Basic had that ByVal/ByRef..
warweasle has joined #lisp
cage_ has joined #lisp
verisimilitude has joined #lisp
ggole has quit [Ping timeout: 252 seconds]
<_death> to further confuse people, you can also claim that Lisp has pass-by-name with macros :)
<ogamita> or even with functions: (defun f (x) (set x 42)) (defvar *x* 33) (progn (f '*x*) *x*) #| --> 42 |#
<_death> SET is often useful after DEFVAR ;)
<dlowe> How is lisp not pass by reference?
scymtym has quit [Ping timeout: 246 seconds]
<_death> dlowe: (defun swap (a b) (rotatef a b)) (let ((x 1) (y 2)) (swap x y) (list x y)) => (1 2)
<dlowe> if you pass an object to a function, they get an object that is EQ to the object passed, and mutating that object mutates it in all contexts
<ogamita> (defun swap (a b) (rotatef (symbol-value a) (symbol-value b))) (let ((x 1) (y 2)) (declare (special x y)) (swap 'x 'y) (list x y)) #| --> (2 1) |#
<jackdaniel> unless it is an immediate object, then it may be copied
<_death> dlowe: when you pass an object to a function, a new binding is created (the reference to the object is copied)
<dlowe> okay, I see what you mean
<_death> dlowe: compare C++ void swap(int & a, int & b) { std::swap(a, b); }
shifty has joined #lisp
ggole has joined #lisp
jinkies has joined #lisp
<_death> ogamita: just use PROGV next time ;)
<ogamita> Right.
jmercouris has quit [Ping timeout: 250 seconds]
scymtym has joined #lisp
kuwze has joined #lisp
lavaflow has joined #lisp
m00natic has quit [Remote host closed the connection]
lavaflow has quit [Ping timeout: 250 seconds]
slyrus2 has quit [Ping timeout: 240 seconds]
rnmhdn has quit [Read error: Connection reset by peer]
rnmhdn has joined #lisp
Kundry_Wag has joined #lisp
lavaflow has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
robotoad has joined #lisp
lavaflow has quit [Ping timeout: 250 seconds]
slyrus1 has joined #lisp
jochens has quit [Remote host closed the connection]
jochens has joined #lisp
shka_ has joined #lisp
jochens has quit [Ping timeout: 240 seconds]
atgreen has quit [Ping timeout: 268 seconds]
emaczen has joined #lisp
kuwze_ has joined #lisp
kuwze has quit [Ping timeout: 256 seconds]
lavaflow has joined #lisp
slyrus1 has quit [Ping timeout: 250 seconds]
jack_rabbit has joined #lisp
nowhere_man has joined #lisp
sjl has joined #lisp
hhdave has quit [Ping timeout: 244 seconds]
<sjl> Is there some way to do something like (:module "problems" :components ((:files "*.lisp"))) in ASDF, rather than listing out every file by hand?
verisimilitude has quit [Ping timeout: 252 seconds]
<sjl> Usually I don't mind the listing, but for stuff like Project Euler, Rosalind, Avent of Code, adding every problem file to the .asd file by hand is tedious.
Mr-Potter has joined #lisp
Selwyn has joined #lisp
<fortitude> you could use a #. reader-macro to do it
verisimilitude has joined #lisp
<fortitude> #.(mapcar (lambda (f) (list :file (namestring f))) (uiop:directory-files #P"src/")) or similar
atgreen has joined #lisp
jack_rabbit has quit [Ping timeout: 250 seconds]
<fortitude> looks like UIOP:DIRECTORY-FILES returns absolute paths, so that won't quite work as-is
<sjl> Yeah, I considered that, but was worried I'd need to do some magic to make sure the current directory at .asd read time is the same one as it's gonna be loading the components from
* sjl hasn't fully thought it through yet
<fortitude> that could be a problem, but for something you don't plan to distribute you might not have to care
<jdz> There's asdf:system-relative-pathname.
<sjl> true
<sjl> jdz: hmm, that might be helpful
<verisimilitude> What are you doing, fortitude?
<jdz> I wonder if there's a way to override/implement some EQL method (specialised to particular system) that would generate the components...
<fortitude> verisimilitude: hm?
<sjl> jdz: although, that takes a system as an argument, and I'd need to use it as I was READing the system... so the system can't really exist yet
<fortitude> sjl: you could also write some code to create the file list and paste it into your system file, if the list isn't going to change much
<jdz> sjl: No, that method would not be added at read time.
<jdz> In the same file as the system definition, after the system definition.
<jackdaniel> I'd define a new component type subclassing module, for instance harvesting-module and work from that
<jdz> Or maybe you'd create a class AUTO-POPULATED-SYTSEM, and make your system inherit from that.
<verisimilitude> What's being done with files?
<sjl> jackdaniel: that's probably the correct way to do it, though ASDF's use of CLOS frightens me
<jackdaniel> sjl: that one will be easy
<jackdaniel> give me 10m to brew a coffee and I'll take a look if you want
<sjl> jackdaniel: I mean, it's just for silly code problem websites, so I'm not super concerned
<jackdaniel> (I wouldn't suggest help if I haven't found it also interesting)
<fortitude> verisimilitude: sjl wanted to dynamically include a list of :file components in an asdf system
<verisimilitude> Oh; well, #. would be the way to go for that then, yes.
<fortitude> or extending asdf, as jackdaniel suggests -- I made a build system for another language that way once; was a lot of work, but it's certainly possible
<sjl> I could just #.(loop :for f :in (uiop:run-program "cd src/problems && ls *.lisp
<sjl> | cut -d. -f1" :output :lines) :collect `(:file ,f))
igemnace has joined #lisp
<sjl> lol
igemnace has quit [Client Quit]
<sjl> But yeah, I'd imagine making a :greedy-module component is probably the Right Way to do it
igemnace has joined #lisp
<fortitude> sjl: that might also be useful for other people (but it's a lot harder than the other hacks, if you're just concerned about convenience in your own projects)
<jdz> Ugh, run-program!
<fortitude> s/harder/more work/
<jdz> (directory #p"src/problems/*.lisp")
Lycurgus has quit [Quit: Exeunt]
<jdz> Also, ENOUGH-NAMESTRING is a thing.
<sjl> yeah (loop :for f :in (uiop:run-program "cd src/problems && ls *.lisp
<sjl> ugh
<sjl> (mapcar #'pathname-name (directory #p"src/problems/*.lisp")) is probably cleaner
<jdz> Totally.
<sjl> But hey, if jackdaniel wants to write me a :greedy-module over coffee I'll use it
<pfdietz> I had a problem once with uiop:run-program not working properly with a certain shell. Had to wrap the shell command being executed in parens.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
quipa has quit [Remote host closed the connection]
<jackdaniel> "sjl-module-files" is a directory name relative to the sjl-module.lisp file
<jackdaniel> poor indentation in mapcar (apologies)
ggole has quit [Quit: ggole]
phoe has joined #lisp
<sjl> jackdaniel: neat. So to package this up, I'd make a (very small) asdf-auto-module system, then have :defsystem-depends-on (:asdf-auto-module) and then (:components (:auto-module "problems")) would Just Work?
<jackdaniel> I suppose so, yes
<Xach> rpw has written about a living system with which he would register the files he's working on and provides some terse repl commands to reload things in progress
<Xach> i like that kind of thing but have never done it
<jackdaniel> if you want to specify other pathname, module takes :pathname argument
graphene has quit [Remote host closed the connection]
gxt has quit [Ping timeout: 245 seconds]
graphene has joined #lisp
<jackdaniel> Xach: I don't understand, how is this different from (say) binding (asdf:load-system 'living-modules) to a symbol-macro |R|?
<Xach> jackdaniel: registering things implicitly through noticing patterns at the repl
<Xach> like noticing that you're loading a new file and remembering to load it again later
<jackdaniel> uhm, thanks for explanation. I don't see much value in that, but maybe I lack some context/examples or it doesn't match my workflow
<Xach> jackdaniel: he uses vi and a separate repl so he has incentives to make the repl more supportive and intelligent. that's one of the ways.
<Xach> i don't always enjoy the asdf-as-recipe model where you write a system definition and then use asdf to do a ton of sometimes-opaque work and at the end you get a working system, except when you don't and you have to go back to fiddling with recipes.
<Xach> i sometimes like the incremental and sometimes vague way of doing things
Jesin has quit [Quit: Leaving]
<jackdaniel> I think that dribble is an embryonic attempt for this kind of development
<Xach> i think dribble is the vestige of a more powerful, supportive system that could not be wedged into CL
Jesin has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
slac-in-the-box has joined #lisp
meepdeew has joined #lisp
Jesin has quit [Quit: Leaving]
khisanth_ has joined #lisp
atgreen has quit [Ping timeout: 250 seconds]
Jesin has joined #lisp
Khisanth has quit [Ping timeout: 250 seconds]
Oddity has quit [Ping timeout: 250 seconds]
slac-in-the-box has quit [Quit: Lost terminal]
razzy has joined #lisp
<jasom> FWIW when I used vi and only used slime as a debugger/repl, asdf:reload-system was my friend.
<jasom> though then it was more something like (asdf:oos 'asdf:reload-op ...) or something
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
rnmhdn has quit [Ping timeout: 272 seconds]
<Xach> (apply 'asdf:oos (list 'asdf:reload-op ...))
Kundry_Wag has joined #lisp
razzy has quit [Ping timeout: 245 seconds]
vlatkoB has quit [Remote host closed the connection]
<aeth> Hmm, it looks like one part of this one loop needs a really complicated GOTO for performance reasons so 8 things can share one implementation. Oh wait, I can just use a local function closure. Thanks, Sussman and Steele.
mrcom has quit [Read error: Connection reset by peer]
<pfdietz> And you should pronouce flet "flay", as I hope they do in Paris.
<aeth> Paris? Everyone knows the capital of Lisp in France is Bordeaux because that's where they make the Lisp threads that they then export to the rest of the world.
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<no-defun-allowed> Also, bordeaux-fft. Finally a name you can trust for signal processing
<no-defun-allowed> "You know Bordeaux always makes good stuff."
<aeth> Fun fact: they picked Bordeaux because it's a port city so it's easier to export the libraries that way.
<aeth> Imagine having to export if you're not on the ocean.
<no-defun-allowed> Haha
atgreen has joined #lisp
<aeth> Of course, the largest port city is Trivial.
pjb has joined #lisp
<no-defun-allowed> "I can't live without it, I just love it! Oh my gosh I don't even buy pipes with other SBCL instances anymore. If you're gonna create your threads or any mutexes, you'll be out of your mind not to own one of these. All I can say is Bordeaux! Threads!" ~Vince Offer on bt
<_death> an Alexandria contains ancient wisdom
<_death> *and
<no-defun-allowed> aeth: Closer-to has the most mirrors, I hear.
<no-defun-allowed> I thought of another optimization to speed up CL-as-an-emulator-translator too, you could try to lift registers out of the register array and hopefully they'd go into machine registers.
mrcom has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
angavrilov has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 250 seconds]
ealfonso has quit [Disconnected by services]
ealfonso has joined #lisp
atgreen has quit [Ping timeout: 245 seconds]
jmercouris has joined #lisp
jmercouris has quit [Remote host closed the connection]
milanj has joined #lisp
cage_ has quit [Remote host closed the connection]
terpri has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Kundry_Wag has quit [Read error: Connection reset by peer]
verisimilitude has quit [Remote host closed the connection]
jinkies has left #lisp ["ERC (IRC client for Emacs 25.1.1)"]
emaczen has quit [Ping timeout: 250 seconds]
Lycurgus has joined #lisp
dacoda has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
pjb has joined #lisp
sarkic has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 246 seconds]
scymtym has quit [Ping timeout: 260 seconds]
newbie1 has joined #lisp
<newbie1> hi all, Given that use-foldr consumes a (listof Nat): (define (use-foldr L) (foldr myfun "some-str" L)) What is the contract for myfun ? What is the contract for use-foldr ? can someone guide me?
pjb has quit [Ping timeout: 250 seconds]
<no-defun-allowed> -> #scheme or #racket
pjb has joined #lisp
graphene has quit [Remote host closed the connection]
jfb4 has joined #lisp
Bike has quit []
graphene has joined #lisp
newbie1 has quit [Ping timeout: 256 seconds]
griddle has joined #lisp
Lycurgus has quit [Quit: Exeunt]
orivej has quit [Ping timeout: 240 seconds]
nchambers has joined #lisp
scymtym has joined #lisp
notzmv has joined #lisp
orivej has joined #lisp
atgreen has joined #lisp
esper0s has joined #lisp
groovy2shoes has quit [Quit: moritura te salutat]
LiamH has quit [Quit: Leaving.]
verisimilitude has joined #lisp
zmt00 has quit [Ping timeout: 252 seconds]
zmt00 has joined #lisp
esper0s has quit [Ping timeout: 240 seconds]
emaczen has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
nchambers has quit [Quit: WeeChat 2.2]
lose has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
jack_rabbit has joined #lisp
Kundry_Wag has joined #lisp
Bike has joined #lisp
gxt has joined #lisp
kajo has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
lose has quit [Ping timeout: 272 seconds]
kajo has quit [Ping timeout: 250 seconds]
kajo has joined #lisp
robotoad has quit [Quit: robotoad]