<earl-ducaine>
i.e. it seems that when a prefix *is* supplied the counter *is* incremented.
<pierpa>
why this bother you?
kozy has joined #lisp
<earl-ducaine>
The way that it's working in SBCL is what I would expect. But my experience is that whenever I think there's an error in the clhs it's because there's something that I'm missing.
<earl-ducaine>
I'm assuming that's the case here, that somehow I'm misinterpretting this passage.
<LdBeth>
dorothyw: nope. those assembler are only for internal use
pierpa has quit [Quit: Page closed]
fikka has quit [Ping timeout: 264 seconds]
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
pyericz_ has quit [Quit: This computer has gone to sleep]
pyericz_ has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
<aeth>
CL is getting better and better for low level programming
equwal has joined #lisp
schoppenhauer has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 264 seconds]
schoppenhauer has joined #lisp
pierpa has joined #lisp
equwal has quit [Read error: Connection reset by peer]
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
pierpa has quit [Ping timeout: 260 seconds]
pierpa_ has joined #lisp
kozy has quit [Remote host closed the connection]
kozy has joined #lisp
jason_m has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
kozy has quit [Remote host closed the connection]
kozy has joined #lisp
<beach>
Good morning everyone!
__main__ has quit [Remote host closed the connection]
<Bike>
or (funcall #'(setf accessor) ...), probably
<elderK>
Well, instead of actually writing (setf (class-slot instance) value)
<elderK>
I'd pass into a function the accessor for some slot, the instnace and the value.
<elderK>
And the function would do the actual setting.
<Bike>
(funcall #'(setf accessor) value instance) that is
<beach>
elderK: There is not a single function that plays the role of an accessor. There is a reader function and a writer function.
Kevslinger has quit [Quit: Connection closed for inactivity]
<elderK>
Ah, okay. So class-slot would be the reader. Would the setf specialization be the writer?
smokeink has joined #lisp
<beach>
elderK: If you wrote :ACCESSOR BLA, then the reader is called BLA and the writer is called (SETF BLA).
<elderK>
beach: See, I'm trying to figure out if a trick I apply in the C world works here and if it does, if it looks decent.
<elderK>
May I tell you guys what I'm doing, maybe you can suggest better alternatives :)
<Bike>
sure, but it sounds ominous so far
<elderK>
heh.
<elderK>
I'm just writing a simple binary search tree. In the C world, I can avoid having to write symmetric code. You know, go down this direction if value < node, go down this direction if value > node, etc.
bkst_ has quit [Ping timeout: 255 seconds]
<elderK>
The C way I do is basically: You have a pointer-to-a-pointer-to-a-node. You set that pointer to the address of the pointer pointing to whatever node.
<elderK>
As you go down the tree, you update that pointer to point at whatever node link you are on.
<elderK>
If the node link is zero, you know you're on a child and can directly patch the link to the new node.
<Bike>
wait, you're just searching a binary tree? not editing it?
<elderK>
No - editing. Destructively modifying.
<elderK>
Search is no big deal. Ideally, you can factor out the searching code so that you can reuse it when implementing insertion or deletion.
<elderK>
I.e. %search would return something that denotes a link to a node. If what the link references is nil, you know the value you are searching for isn't in the tree and can patch the link to reference the new node.
<elderK>
If the link references something, you know the value is in the tree.
<elderK>
:P My first "attempt" at implementing BST in CL had a lot of duplication, you see. And I'm trying to figure out how to cut it down in a nice way :)
<beach>
elderK: As I recall, PAIP has some hints for how to deal with stuff like that.
smokeink has quit [Ping timeout: 264 seconds]
<elderK>
Thanks beach.
myrkraverk has quit [Ping timeout: 276 seconds]
<LdBeth>
elderK: CLWEB has a impl of BST, following the one from CWEB
<LdBeth>
elderK: so you might be able to make a compare between them
Bike has quit [Quit: Lost terminal]
arescorpio has quit [Quit: Leaving.]
<elderK>
I really should just sit down and read PAIP.
bkst has joined #lisp
<elderK>
LdBeth: Thanks for the suggestion. I was thinking do could be used to do it iteratively.
JenElizabeth has joined #lisp
<elderK>
Here's a link to the code, in case someone in the future is curious: ramming system for Common ...
<elderK>
LdBeth: The only issue is that they're repeating the LESSP check when attaching a new node.
Jen has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 265 seconds]
energizer has quit [Remote host closed the connection]
Fare has quit [Ping timeout: 264 seconds]
energizer has joined #lisp
energizer has quit [Remote host closed the connection]
<LdBeth>
elderK: I guess it avoids rebalancing the tree, since there are no needs for deletion nodes in this program.
fikka has joined #lisp
python476 has joined #lisp
<elderK>
LdBeth: Eh? It's a simple BST, no rebalancing is done?
* elderK
grabs a coffee, starts reading through PAIP.
<LdBeth>
elderK: okay, but I don’t see why LESSP is an issue
<elderK>
LdBeth: Well, in the general case, it's probably not an issue. It's just, the code already knows which side to attach a new node. It knew that when it breaks the loop, just that knowledge isn't captured. This is why, when the code attaches a new node, it has to repeat the comparison that it knows which child link to update.
<elderK>
If the keys are expensive to compare - you want to avoid that. Comparing integers or say, symbols, is probably cheap. But comparing strings is probably more expensive. So, you'd want to avoid doing that if at all possible.
<elderK>
In the greater scheme of things though, it doesn't matter. Insertion would already be considered expensive in that case. So, taking a tiny bit longer isn't going to mean anything :P
<LdBeth>
elderK: I see, what you mean is something like continuations
<elderK>
LdBeth: No. You don't need continuations for this.
Pixel_Outlaw has joined #lisp
paul0 has quit [Quit: Leaving]
<LdBeth>
But continuations definitely could help
<elderK>
I don't see how. Unless you want to say, call some continuation to recover some state.
<elderK>
But that would be overkill for this, I think.
<elderK>
All you need to do, is remember how to update a node link. That's it.
BlueRavenGT has quit [Ping timeout: 260 seconds]
<elderK>
If you're on the tree root, then you need to call say, (setf tree-root) to update the root link.
<elderK>
Otherwise, (setf node-left) or (setf node-right).
<elderK>
As long as you remembered which "setter" to call, you could avoid repeating the lessp.
pyericz_ has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
<LdBeth>
By keeping a updated reference to the last search result?
<elderK>
:) I don't think I'm explaining myself all that well.
<elderK>
I'll show you when I write what I mean :)
<elderK>
For now, PAIP! :)
<LdBeth>
Ok
<LdBeth>
Have fun
smokeink has joined #lisp
<elderK>
:) Thank oyu
python476 has quit [Ping timeout: 240 seconds]
Naergon has joined #lisp
fikka has joined #lisp
energizer has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
igemnace has joined #lisp
quazimodo has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
<drmeister>
Are there any maxima users online? Is there an equivalent to Head[x] in mathematica?
joh11 has joined #lisp
fikka has joined #lisp
myrkraverk has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Oladon has quit [Quit: Leaving.]
SenasOzys has quit [Remote host closed the connection]
<phoe>
and first(expr) seems to be a generic function for fetching the first element of a list/row of matrix/term of sum
joh11 has quit [Ping timeout: 260 seconds]
rotty has quit [Ping timeout: 256 seconds]
igemnace has quit [Read error: Connection reset by peer]
fikka has joined #lisp
rotty has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
rumbler31 has joined #lisp
fikka has joined #lisp
energizer has quit [Quit: Leaving]
Pixel_Outlaw has quit [Quit: Leaving]
rumbler31 has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 240 seconds]
7GHAAIVKN has quit [Quit: Leaving]
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
fikka has joined #lisp
vaporatorius has quit [Remote host closed the connection]
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
pyericz_ has quit [Quit: This computer has gone to sleep]
wigust has joined #lisp
siraben has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<kqr>
elderK, ah, thanks for the mention of testing frameworks. I also just discovered fiasco which I think looks cooltoo. i'll have to just pick one and play with it a bit :)
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
fikka has joined #lisp
jello_pudding has joined #lisp
JenElizabeth has quit [Quit: Leaving]
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
vap1 has joined #lisp
JenElizabeth has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
lnostdal has joined #lisp
<elderK>
Wow. I wish I started reading PAIP years ago when I first heard of it.
<elderK>
Curse you, procrastination!
f32ff has joined #lisp
JenElizabeth has quit [Read error: Connection reset by peer]
fikka has joined #lisp
quazimodo has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 256 seconds]
catern has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
JenElizabeth has joined #lisp
dmiles has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 255 seconds]
vlatkoB has joined #lisp
catern has joined #lisp
fikka has joined #lisp
tkhoa2711 has joined #lisp
tkhoa2711 has quit [Client Quit]
<elderK>
kqr: I've just decided I'm going to stick with parachute. It's an arbitrary choice - but it seems good.
<elderK>
kqr: I'll consider prove as a fallback. But, I don't anticipate needing it :)
<elderK>
It will be awhile before I continue with my usual programs. I will work through PAIP.
<elderK>
So far I've skipped doing several exercizes. That's bad. I will have to go back and do them.
<kqr>
exercises are great. i wish I ever had time to do them :(
fikka has quit [Ping timeout: 264 seconds]
jello_pudding has quit [Quit: Leaving]
d4ryus1 is now known as d4ryus
dmiles has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
rumbler31 has joined #lisp
chens has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
<elderK>
kqr: Me too. But I'm going to force myself :P
rumbler31 has joined #lisp
<elderK>
kqr: The first PAIP exercize is interesting - about handling last-names properly in the case of something like John Doe, MD
<elderK>
I guess I could simplify it to handle things like John Joe MD or John Joe Jr
<elderK>
Stripping the , would be an annoying step.
<elderK>
But probably easy too.
<elderK>
*exercise
rumbler31 has quit [Ping timeout: 240 seconds]
<ecraven>
how would I read a 16 or 32 bit signed integer from an input stream in common lisp? is there any part of the hyperspec dealing with "binary i/o"?
<phoe>
ecraven: fast-io
fikka has joined #lisp
<phoe>
it has a thing called a buffer that builds on top of streams, and then has functions readu32-be and readu32-le that operate on buffers
<elderK>
ecraven: Phoe's answer is good. But, if you want to do things manually, look up read-byte and read-sequence. They are covered in Practical Common Lisp.
<elderK>
If you do it manually, be aware that you will need to read from a binary stream.
joh11 has joined #lisp
fourier has joined #lisp
kozy has quit [Remote host closed the connection]
<ecraven>
thanks!
<elderK>
np :)
<ecraven>
is read128-* actually relevant?
fikka has quit [Ping timeout: 240 seconds]
<ecraven>
I mean, do other languages use 128 bit integers?
<phoe>
ecraven: I have no idea, but this one reads it and gives it to you
<phoe>
It most likely is a bignum, but the issue here is not about if your processor has a big enough word size to handle it
<elderK>
ecraven: I imagine it could potentially be useful.
<phoe>
But rather if your data actually contains 128-bit integers, which is possible.
* elderK
makes a note to investigate fast-io's internals someday.
makomo has joined #lisp
SenasOzys has quit [Remote host closed the connection]
SenasOzys has joined #lisp
varjag has joined #lisp
pyericz_ has joined #lisp
<beach>
In case someone feels like checking out my slides for the incremental-parsing talk, here is a preliminary version: http://metamodular.com/incremental-parsing-talk.pdf It should be viewed in "presentation" mode so that the "animations" can be fully appreciated.
DataLinkDroid has joined #lisp
figurehe4d has joined #lisp
fourier has quit [Read error: Connection reset by peer]
<beach>
I have more time than usual (around 30 minutes) in case someone thinks it might be too long.
<phoe>
beach: page 7, where is it incorrect? the declare form is indented the same way as everything else?
<beach>
phoe: It is really another binding.
<beach>
Count the parentheses.
<phoe>
GAH
<phoe>
You tricked me!
<beach>
On purpose.
<phoe>
Note: some people, including me, use emacs's aggressive-indent plugin. It mitigates what you describe there by automatically hoisting the binding to its proper indentation and making it impossible to indent it any other way.
<phoe>
Which, in 90% cases, is correct, and some other cases, is pretty annoying.
<beach>
Yeah, I can imagine both those. :)
<phoe>
You might want to include that in your paper or in your talk.
<beach>
I'll think about that. Thanks for mentioning it.
<phoe>
No problem. The fact I use aggressive-indent is exactly why I fell for your trap.
<beach>
I understand.
<makomo>
beach: what is that diagram on page 12? the cache?
<beach>
Yes.
<phoe>
Yep, the diagram doesn't look all that clear.
<beach>
I'll explain that when I show the slide.
<makomo>
ah
<beach>
The text is not self contained.
<phoe>
beach: as much as I understand your work, the rectangles map to some bits and pieces of text in the buffer.
<makomo>
mhm. and now i also see that there are more diagrams after that
<beach>
Yes, those rectangles are nested parse results. The top-most ones correspond to top-level expressions and other material in the buffer.
<makomo>
which makes it a bit clearer about what's going on
<phoe>
I'd create such an example buffer with some bits of Lisp code, and draw arrows from the diagram to the text, so people can map these two better in their imaginations.
<phoe>
Possibly even mark the different parse results with colors, and mark their matching rectangles respectively.
<beach>
Tempting, but might be too complicated.
<phoe>
I wouldn't say so. Let me do a quick example in my graphics editor.
<elderK>
Hey, cool. I didn't know symbols had properties :D
<elderK>
It would be interesting to benchmark the performance of hash vs alist vs plist.
<beach>
elderK: Don't use that feature.
<elderK>
I won't.
<elderK>
But I'd still be interested in determining the threshold for where a list is good enough.
<elderK>
or a a-list.
<elderK>
I guess it would really depend on the key's type, too.
<elderK>
:)
<elderK>
beach: Thank you for prompting me to read PAIP. I wish I did it years ago.
<elderK>
I am going to learn a ton from this book :)
<aeth>
elderK: The threshold is implementation-dependent, but probably lower than you think.
<beach>
elderK: It is quite good actually. Glad I could be of help.
<elderK>
I like how he gives stylistic advice, too.
<elderK>
aeth: My current view is "If you are ever going to be looking up a lot of things, use a proper ADT."
<beach>
Sound advice.
<elderK>
:P Make use of LUTs where possible.
<elderK>
These days, I pretty much ignore linear lookup of stuff.
<aeth>
elderK: My current style is to basically just use plists when they're intended to be used with alexandria:doplist
<beach>
elderK: Once you have a good protocol for it, you can optimize later (without changing the protocol) should it turn out to be necessary.
<elderK>
True.
fikka has quit [Ping timeout: 265 seconds]
<beach>
elderK: So I often start by designing the protocol, possibly having some sophisticated data structure in mind. Then I implement a simple version of it.
kerrhau has quit [Ping timeout: 276 seconds]
<beach>
If I decide to implement the sophisticated data structure later, I use the simple version as comparison for random testing.
<elderK>
What is random testing?
<beach>
I emit the same random sequence of operations to both implementation and I compare that the results are the same.
<beach>
I can emit millions of such operations automatically, which makes it unnecessary for me to manually enumerate a potentially very large number of cases.
Lord_Nightmare has joined #lisp
<elderK>
Sounds useful.
<elderK>
No need to manually write zillions of unit tests.
<elderK>
Is there a library that allows this?
<elderK>
I would be interested.
<elderK>
Same with a fuzzer that works from a generative grammar.
<elderK>
Although PAIP has already taught me how to make a fuzzer if necessary :D
<elderK>
(I'm very thankful that the contents of the book - along with other stuff I'm doing at Uni - align.)
<elderK>
beach: I'd definitely be interesting in learning more about random testing. It would be very useful outside of Lisp, too.
<beach>
elderK: I have not found a library that supports this kind of testing, and I don't know what the features of such a library would be.
<beach>
elderK: You may want to study my Cluffer library then.
<phoe>
That's how I imagine your cache works. I might be wrong, but the style of graphical representation is what I am thinking of.
<beach>
elderK: It contains two implementations of a protocol for editor buffers.
<makomo>
phoe: now do it in TikZ :D
<phoe>
That code does not even have to be correct since it's the forms that actually matter.
<phoe>
makomo: what is TikZ
<elderK>
beach: I'll note that for later study. :)
<phoe>
oh geez
<makomo>
a LaTeX package which i assume beach used to make those diagrams
<makomo>
but maybe not
<beach>
phoe: Correct. And since you could imagine it, so can very likely the audience when I explain it. But I'll submit your proposal to my favorite coauthor and we will see what she says.
<phoe>
Okay! No problem.
<phoe>
I just react very well to colors, but that's just one of my personal oddities. And a reason why I use rainbow-parens to write Lisp.
<phoe>
That's more or less how backquotes work - they allow you to selectively quote parts of your expression and insert values from outside the backquote whenever you want them to.
<phoe>
or rather, wherever you want them to.
gigetoo has quit [Ping timeout: 240 seconds]
gigetoo has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
lnostdal has joined #lisp
<Shinmera>
(set-macro-character #\， (lambda (s c) (values))) '(a， b， c) ;=> (A B C)
<Shinmera>
:^)
<makomo>
uh oh
<phoe>
Shinmera: well
fikka has joined #lisp
ft has quit [Ping timeout: 268 seconds]
chens has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
chens has joined #lisp
raynold has joined #lisp
margeas has joined #lisp
<kqr>
phoe, oh dear god I missed the initial backquote!
smokeink has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
pyericz_ has joined #lisp
ft has joined #lisp
dddddd has joined #lisp
kozy has joined #lisp
kozy has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 264 seconds]
DataLinkDroid has quit [Quit: Ex-Chat]
<elderK>
Goodnight all :)
<elderK>
Uni starts back tomorrow. Early morning start is going to be brutal.
<phoe>
elderK: good luck
<elderK>
:P See you sometime tomorrow probably.
<elderK>
thanks :D
<elderK>
I'll need it :P
* elderK
puts alarm clock as far from self as possible.
elderK has quit [Quit: Seeya!]
kozy has joined #lisp
<phoe>
After I makunbound a special-proclaimed symbol and intern a new one with the same name, the special proclamation no longer is in effect, correct?
<phoe>
Since the proclamation is bound to the symbol and not its name AFAIU.
DataLinkDroid has joined #lisp
<spacebat1>
I recall running into proclamation related issues in sbcl when redefining structs recently
<spacebat1>
I thought that I even uninterned the symbols but the problem persisted - maybe I'm misremembering
k-stz has quit [Remote host closed the connection]
wxie has joined #lisp
fikka has joined #lisp
eSVG has quit [Quit: Leaving]
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
<Shinmera>
phoe: the special declaration has nothing to do with whether the symbol is bound or not
<Shinmera>
Consider (defvar *foo*)
<Shinmera>
This is unbound, but it is special.
<Shinmera>
Also, you don't intern variables, you intern symbols.
<Shinmera>
If you removed the symbol from the package, and then interned a new one with the same name, it should no longer be special.
<Shinmera>
since it is a new symbol altogether.
<phoe>
Shinmera: i didn't say I intern a variable.
<Shinmera>
Ah, I misread, my bad.
<phoe>
Oh wait. I see what you mean.
<phoe>
s/makunbound/unintern/
<Shinmera>
But makunbound is still for bindings, not symbols.
fikka has quit [Ping timeout: 245 seconds]
<phoe>
Right, thanks for the correction.
zaquest has quit [Quit: Leaving]
python476 has joined #lisp
heisig has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
janivaltteri has joined #lisp
pyericz_ has quit [Quit: This computer has gone to sleep]
wxie has quit [Quit: Bye.]
schjetne has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
Bike has joined #lisp
lnostdal has quit [Ping timeout: 256 seconds]
zaquest has joined #lisp
fortitude_ has quit [Read error: Connection reset by peer]
<phoe>
Hummmmmm... I've come far enough in my Lisp writing to start wondering what exactly happens when.
damke_ has joined #lisp
random-nick has joined #lisp
<Shinmera>
?
<phoe>
I need an instance to be created before macroexpansion time, so that instance can then be used for outputting the macro expansion.
<Shinmera>
Stuff it in an (eval-when (:compile-toplevel :load-toplevel :execute) (defvar *my-instance* ..))
<phoe>
But that instance depends on other instances that have been created before.
damke has quit [Ping timeout: 264 seconds]
<Shinmera>
And?
<phoe>
Like, I create instance A, and instance B which depends on A.
<Shinmera>
Yes, so?
Karl_Dscc has joined #lisp
<phoe>
Right now when I DEFUN a function that creates two instances in a row, the first gets created normally, but the second one cannot see the first.
<phoe>
So there's some side effect that does not get executed - possibly a SETF GETHASH since I store them in a hashtable.
<Shinmera>
I don't understand. What does it mean for a function to create "two instances in a row"?
<phoe>
where MAKE-MY-THING creates an instance named A and stores it in a hashtable.
<Shinmera>
Okey.
<phoe>
Then the other tries to make an instance named B that depends on the instance named A (I forgot to write that one).
<phoe>
But it can't find it.
<Shinmera>
That has nothing to do with compilation.
<Shinmera>
Your code is going wrong somewhere else.
<phoe>
Ooooh. The instance gets created at macroexpansion-time but the push to hash-table is deferred until runtime.
<Shinmera>
The obvious fix is to make the dependencies explicit, meaning you pass the instance returned from the first call to the second call.
<phoe>
That is why B can't find A, because A was not yet pushed to the hashtable.
<Bike>
so, make-my-thing actually doesn't store it in the table?
<Colleen>
Bike: jackdaniel said 2 hours, 33 minutes ago: nevermind last message, that problem is related to clos::*clos-booted* being T
<Colleen>
Bike: jackdaniel said 3 hours, 47 minutes ago: basically forward-class-references doesn't work, i.e in the same file: (defclass foo (bar) ()) (defclass bar () ())
<Colleen>
Bike: jackdaniel said 3 hours, 48 minutes ago: I think I've found a regression caused by change in update-dependants – when I figure out the fix I'll make a PR to clasp as well
<Colleen>
Bike: drmeister said 5 hours, 1 minute ago: - I relearned the lesson - don't use ANYTHING from an llvm::Module after it's passed to the ORC JIT engine. Not functions, not globals, not nuthin'. It all goes *poof* as soon as it's JITted.
<Bike>
holy geez
<Shinmera>
Looks like you're popular ;)
kozy has joined #lisp
myrkraverk has quit [Ping timeout: 240 seconds]
k-stz has joined #lisp
disumu has joined #lisp
<phoe>
Bike: make-my-thing is a macro. It instantiates the thing at compile-time and expands to code that pushes it into the table *and* into code that is based on this value..
<phoe>
Now that I read what I typed up above it seems it's a mess.
<Bike>
so you're not actually calling foo at compile time
<phoe>
No, it's a mess. I'll take a step back and try to figure out what goes where and when.
Chream_ has joined #lisp
hiroaki has joined #lisp
sword`` has joined #lisp
sword` has quit [Read error: Connection reset by peer]
<phoe>
I need to figure out when I want to create the instances and when I want to check for dependencies.
lagagain has quit [Quit: Connection closed for inactivity]
<phoe>
If I create B, and B depends on A, then A must already be created, and the check must be done after A's creation but before B completes its initialization.
<phoe>
That is my current logic.
chens has quit [Remote host closed the connection]
<phoe>
I think I need two stores for these values. One of them must be compile-time, and the other must be run-time.
<phoe>
Because when I compile such a form, I don't want the instance to pollute my runtime environment, but I nonetheless want to keep track of it.
<phoe>
And when I actually run that code, I want the instance to be recorded in my run-time store.
fikka has quit [Ping timeout: 264 seconds]
<Bike>
do you need this store for other things?
<phoe>
Bike: the compile-time store, no. the run-time store, yes - it is the main way of accessing these instances.
<phoe>
I am tempted to try using (eval-when (:compile-toplevel) ...) despite Fare having mentioned that it is dangerous for sanity...
<Bike>
ok i really don't understand your architecture. but if you just put a literal object in your code, and it has another object in a slot, the implementation will work out dependencies
<makomo>
can i symlink a directory which contains one directory for every project (with an asd file) into quicklisp's local-projects?
<makomo>
or am i supposed to symlink individual project directories
<phoe>
makomo: symlink it whole, I do that
<makomo>
i did that before, but then sometimes quickload wouldn't be able to find the system
<phoe>
I don't have literal objects there, only symbols that name the other objects. I do that indirection to be able to redefine the other objects later.
<spacebat1>
phoe: it is dangerous to use eval-when without specifying all 3 evaluation phases
<makomo>
am i supposed to run (ql:register-local-projects) manually?
<Bike>
i definitely don't understand.
<phoe>
spacebat1: I know, I've read Fare's text about it.
<Bike>
makomo: when you change the contents, yes.
<phoe>
Bike: okay. Let me write that down.
<makomo>
Bike: changing the contents being "adding or removing project directories"?
<Bike>
yeah.
<makomo>
hmm ok
<Bike>
what quicklisp does is maintain a list of asds in local projects.
<Bike>
the list is created by register-local-projects.
<spacebat1>
makomo: look at qlot
<Bike>
that's what the system-index.txt is.
<spacebat1>
phoe: I've seen code that does this compile time recording of declarations for use later at runtime, a sort of registry
<spacebat1>
it works well enough so long as the code documents the side effects of the macros clearly
<spacebat1>
are you sure you're not overcomplicating things?
milanj has joined #lisp
<phoe>
spacebat1: hmm
<phoe>
I will finish real life stuff and then sit down to think of it
<phoe>
brb for now
fikka has joined #lisp
<makomo>
what would be a good way to output a string like "<symbol-name>: <symbol-value>", given just a symbol
<makomo>
for example, i would like a FORMAT formatter ~something that would do that for me, but FORMAT is a function so the symbol names are lost after evaluation
<phoe>
makomo: this will only work for special variables
<phoe>
and not for lexical ones
<makomo>
for example, (format t "~{~name~^~%~}" '(v1 v2 v3)) and this would print "v1: <value-of-v1>\n..."
<makomo>
hm, yeah
<phoe>
to do this properly you need a macro, (defmacro symbol-print (symbol) `(format t "~S: ~S" ',symbol ,symbol))
<makomo>
so it would have to be a macro for this to work
<makomo>
which format is not
<makomo>
yes :^/
<makomo>
but then i'm "hardcoding" what i can print
<phoe>
(symbol-print foo) ;=> (format t "~S: ~S" 'foo foo)
<makomo>
i.e. symbol-print can only print symbols like that
<makomo>
ideally i would just like a custom FORMAT formatter
<phoe>
makomo: you can't do that
<makomo>
i know it's impossible, but are there any such solutions?
<makomo>
i.e. other than FORMAT
<phoe>
no function can do that.
<makomo>
yes, i mean in general, a library or something
<makomo>
which provides a macro version of FORMAT where such a thing would be possible
<Bike>
if you're talking about lexical variables it's impossible
<Bike>
semantically, at runtime there's no need for a link between a variable and its name
<Bike>
and compilers tend to remove it except for debugging purposes
<makomo>
yeah, i understand that it's impossible to do with lexical variables if FORMAT is a function
joh11 has quit [Ping timeout: 240 seconds]
<makomo>
i've written a small macro that does it, but it's quite limited
<Bike>
i mean it's impossible if you want to provide a list of symbols that isn't hardcoded
<makomo>
it will be, it's just syntactic sugar really
<Shinmera>
Why do you want this to be some general operator? I don't see this situation being very frequent.
<Bike>
or did you mean you want the format string to be non hardcoded
<makomo>
Shinmera: just some yak shaving tbh, because i want to save 5 characters of typing :D
<Bike>
alright i'm done caring then
<makomo>
Bike: the format string itself
<phoe>
makomo: write something more advanced that expands to a FORMAT, (powerformat foo t "~A ~A ~A~%" :symbol 2 :value) ;=> (format t "~A ~A ~A~%" 'foo 2 foo)
<phoe>
where it replaces :symbol with the quoted thing you supplied it and :value with unquoted symbol you supplied
<makomo>
yup, something like that is what i wrote. hm ok, interesting to think about it at least
<makomo>
even if it's practically not really useful
<Shinmera>
(defmacro varformat (o s &rest v) `(format ,o ,s ,@(loop for i in v collect `',i collect i))) ; (let ((a 0) (b "b") (c :c)) (varformat NIL "~@{~&<~a>: ~a~}" a b c))
<phoe>
Shinmera: geez
<makomo>
Shinmera: literally what i did
<makomo>
noice
<phoe>
that format string made me stop for a while
<makomo>
Shinmera: ohh, the ~@ is what i was needing
<makomo>
so it collects the rest of the args as a list
<Shinmera>
It's actually ~{, just with the @ modifier.
<makomo>
yeah, i understand that
<phoe>
oh wait, right
<makomo>
lol
<phoe>
I was bamboozled for a moment
quazimodo has joined #lisp
<phoe>
I think I figured my thing out. I basically need two stores for my instances - one being a compile-time store to which *all* compiled instances register, and the other being a run-time store which registers only instances for which the code which they macroexpand into is called.
<Shinmera>
I still have no idea what you're doing
<phoe>
And the macroexpansion code is like (setf (gethash (name instance) *run-time-store*) instance) where INSTANCE is some literal object.
<Shinmera>
but good you found a solution I guess
<phoe>
Shinmera: working on my library for implementing protocols.
<phoe>
A protocol is an object that has definition for some protocol classes, functions, variables and so on.
DataLinkDroid has quit [Quit: Ex-Chat]
<phoe>
I instantiate it from a set of forms that describe what the resulting protocol looks like.
<phoe>
And from these forms, I compute code that calls DEFCLASS, DEFGENERIC, DEFVAR nd so on.
<phoe>
So first I need to grab the forms, then create an instance based on them.
<phoe>
Then I need to grab the instance and use it to output Lisp code.
<phoe>
Then I need to put that code in the macroexpansion.
<Shinmera>
Just do it in two steps
<phoe>
Yep, that's what I figured out. The first step is creating that instance and registering it in the compile-time store, so other instances that depend on it can find their dependency in the compile-time store.
<phoe>
Then, when the instance is actually "applied" to the image, the macroexpanded code is evaluated, and the instance is added to the run-time store.
pierpa_ has quit [Ping timeout: 260 seconds]
EvW1 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<phoe>
ahhh, compile-time computing~
fikka has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
joh11 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
heisig has quit [Quit: Leaving]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
<phoe>
This approach means that the contents of the compile-time store will *not* be transferred over to the FASLs.
<phoe>
Which is good, because I do not need it there.
<phoe>
If I understand it correctly, the instances will be dumped into the FASL though, because the generated code will issue SETF GETHASH with the literal object as an argument.
<phoe>
since I tried to dump a standard-object which, with the default method, is an error.
<phoe>
Luckily my instances are dumb enough to be dumpable using make-load-form-saving-slots.
nowhere_man has quit [Read error: Connection reset by peer]
nowhereman_ has joined #lisp
Kevslinger has joined #lisp
Folkol has joined #lisp
wigust- has joined #lisp
semz has quit [Quit: Leaving]
Chream_ has quit [Ping timeout: 245 seconds]
pioneer42 has joined #lisp
SenasOzys has quit [Read error: Connection reset by peer]
wigust has quit [Ping timeout: 260 seconds]
SenasOzys has joined #lisp
pierpa has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 255 seconds]
pierpa has joined #lisp
fikka has joined #lisp
pioneer42 has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 260 seconds]
eschatologist has quit [Ping timeout: 264 seconds]
eschatologist has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
EvW1 has quit [Ping timeout: 255 seconds]
figurehe4d has quit [Ping timeout: 245 seconds]
jason_m has joined #lisp
fikka has joined #lisp
jason_m has quit [Client Quit]
jason_m has joined #lisp
EvW has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
Chream_ has joined #lisp
sellout- has quit [Ping timeout: 240 seconds]
raynold has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
myrkraverk has joined #lisp
sellout- has joined #lisp
gabiruh has quit [Ping timeout: 264 seconds]
gabiruh has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
milanj has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
dieggsy has joined #lisp
yeticry has quit [Ping timeout: 256 seconds]
yeticry has joined #lisp
quazimodo has quit [Ping timeout: 260 seconds]
Nouv has joined #lisp
frgo has quit [Ping timeout: 240 seconds]
nika has joined #lisp
Fare has joined #lisp
smokeink has joined #lisp
Bronsa` has joined #lisp
makomo has quit [Quit: WeeChat 2.0.1]
janivaltteri has quit [Quit: leaving]
makomo has joined #lisp
khisanth_ has quit [Ping timeout: 268 seconds]
milanj has quit [Quit: This computer has gone to sleep]
Phil_the_Beard has joined #lisp
Phil_the_Beard has quit [Client Quit]
khisanth_ has joined #lisp
Chream_ has quit [Ping timeout: 260 seconds]
Patternmaster has quit [Ping timeout: 276 seconds]
on_ion has quit [Quit: WeeChat 1.9.1]
Patternmaster has joined #lisp
dieggsy has quit [Remote host closed the connection]
frgo has joined #lisp
dieggsy has joined #lisp
jason_m has quit [Ping timeout: 245 seconds]
lnostdal has joined #lisp
pierpa has quit [Ping timeout: 260 seconds]
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
pierpa has joined #lisp
dieggsy has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
SaganMan has joined #lisp
yeticry has quit [Ping timeout: 260 seconds]
ckonstanski has joined #lisp
yeticry has joined #lisp
smokeink has quit [Ping timeout: 256 seconds]
jealousmonk has joined #lisp
<ckonstanski>
CLSQL vs Postmodern: has anyone switched from the former to the latter and been very happy about it?
<ckonstanski>
I have a new requirement to store bytea data. Investigating postmodern to see if it handles this.
<ckonstanski>
I could convert to base64 and store in a text field with clsql, but I'd rather let the database driver manage it.
<ckonstanski>
Clojure and JDBC interop is an option if one is willing to sell one's soul.
<Xach>
I like postmodern because it does less, but happens to do exactly what I need.
<Xach>
clsql did more than i needed and the complexity confused me at times
<Xach>
I don't think clsql is "bad", but for my purposes, postmodern is better
Chream_ has joined #lisp
<ckonstanski>
pg-dot-lisp also looks promising. I actually don't want to convert all my SQL strings to postmodern lispy syntax. I already invested a lot of effort into writing an entity framework that converts objects to SQL.
rixard has joined #lisp
josemanuel has joined #lisp
rixard has quit [Client Quit]
pierpa has quit [Ping timeout: 260 seconds]
siraben has quit [Ping timeout: 265 seconds]
FreeBirdLjj has joined #lisp
Guest69087 has joined #lisp
Guest69087 has quit [Remote host closed the connection]
<dim>
ckonstanski: s-sql is but an option, you don't need to use it
<dim>
Postmodern is quite good really
ebrasca has left #lisp ["ERC (IRC client for Emacs 25.2.1)"]
<Shinmera>
postmodern supports sql strings just fine
<dim>
and I think you can just using vectors of '(unsigned-byte 8) for bytea
lnostdal has quit [Ping timeout: 260 seconds]
joh11 has quit [Ping timeout: 265 seconds]
lnostdal_ has joined #lisp
libreman has quit [Ping timeout: 255 seconds]
asarch has joined #lisp
<ckonstanski>
This is encouraging.
try_ has joined #lisp
try_ has quit [Client Quit]
try_ has joined #lisp
libreman has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
try_ has quit [Client Quit]
Oladon has joined #lisp
janivaltteri has joined #lisp
lnostdal_ has quit [Ping timeout: 264 seconds]
<Fare>
more fixes to asdf tests on Windows. Portability is horrible.
Arcaelyx has quit [Ping timeout: 268 seconds]
<Fare>
And corner case behaviors of asdf that even I don't fully understand.
<Fare>
(At least without going deep in the code, which I probably could do, unlike newcomers to the code base)
EvW1 has joined #lisp
Arcaelyx has joined #lisp
jealousmonk has quit [Quit: Leaving]
pierpa has joined #lisp
<bjorkintosh>
Well, given how much M$ is embracing linux these days, it might no longer be necessary to port a linux program to windows anymore!
<bjorkintosh>
just install the required system and run it from there.
Fare has quit [Ping timeout: 256 seconds]
zooey has quit [Remote host closed the connection]
drunkencoder has quit [Remote host closed the connection]
drunkencoder has joined #lisp
zooey has joined #lisp
drunkencoder has quit [Excess Flood]
drunkencoder has joined #lisp
drunkencoder has quit [Excess Flood]
detectiveaoi has joined #lisp
drunkencoder has joined #lisp
drunkencoder has quit [Excess Flood]
drunkencoder has joined #lisp
fourier has joined #lisp
drunkencoder has quit [Excess Flood]
drunkencoder has joined #lisp
drunkencoder has quit [Excess Flood]
drunkencoder has joined #lisp
pierpa has quit [Ping timeout: 260 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
nmajo has quit [Remote host closed the connection]
karswell has quit [Remote host closed the connection]
nmajo has joined #lisp
pierpa has joined #lisp
MasouDa has joined #lisp
EvW1 has quit [Ping timeout: 255 seconds]
MasouDa has quit [Quit: leaving]
makomo has quit [Ping timeout: 260 seconds]
pierpa has quit [Ping timeout: 260 seconds]
dessm has joined #lisp
Patzy has quit [Ping timeout: 276 seconds]
milanj has joined #lisp
makomo has joined #lisp
damke_ has joined #lisp
lemonpepper24 has quit [Ping timeout: 260 seconds]
nmajo has quit [Ping timeout: 276 seconds]
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
cmecca has quit [Ping timeout: 256 seconds]
nmajo has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
cmecca has joined #lisp
cmecca is now known as Guest15392
myrkraverk has quit [Ping timeout: 276 seconds]
myrkraverk_ has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
lemonpepper24 has joined #lisp
<Shinmera>
As previously announced, I'll be streaming me putting together my ELS talk tonight. In case you're interested in hanging out on a Sunday evening, you're more than welcome to join me. https://stream.shinmera.com/
damke has joined #lisp
dieggsy has quit [Ping timeout: 260 seconds]
mflem has joined #lisp
haz has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
Chream_ has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
nmajo has quit [Ping timeout: 256 seconds]
<flip214>
Shinmera: no fun without sound ;)
Chream_ has quit [Read error: Connection reset by peer]
<Shinmera>
? there is sound
larsen has quit [Ping timeout: 260 seconds]
damke has quit [Read error: Connection reset by peer]
larsen has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
kerrhau has joined #lisp
Chream_ has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
Patternmaster has quit [Remote host closed the connection]
Chream_ has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
<flip214>
hmm, had none.
<flip214>
and made sure to unmute.
<flip214>
but never mind.
nmajo has joined #lisp
kerrhau- has joined #lisp
Chream_ has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
karswell has joined #lisp
Pixel_Outlaw has joined #lisp
kerrhau has quit [Ping timeout: 256 seconds]
Chream_ has joined #lisp
<phoe>
ckonstanski: I have just been doing bytea handling in postmodern
Chream_ has quit [Read error: Connection reset by peer]
zooey has quit [Ping timeout: 268 seconds]
Chream_ has joined #lisp
yoel has joined #lisp
<phoe>
https://pastebin.com/uTpjNtHG <- this contains a snippet of my cl-yesql/postmodern code and the matching Lisp function
zooey has joined #lisp
<phoe>
the function derive-key returns two hex strings, hash and salt
fourier has quit [Ping timeout: 256 seconds]
Satou has joined #lisp
<phoe>
when I write them to a bytea field (which is pass_hash and pass_salt) then they get written correctly; when I select back from that column, I get u8 vectors.
Chream_ has quit [Read error: Connection reset by peer]
<phoe>
I have no idea how to do it in a more optimized way, without converting it to a hex string first. It might be required to add this to postmodern .
Chream_ has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
detectiveaoi has quit [Remote host closed the connection]
detectiveaoi has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
fourier has joined #lisp
detectiveaoi has quit [Remote host closed the connection]
Chream_ has quit [Read error: Connection reset by peer]
detectiveaoi has joined #lisp
Chream_ has joined #lisp
detectiveaoi has quit [Remote host closed the connection]
haz has quit [Quit: Leaving]
Satou has quit [Quit: Cya soon guys!]
pierpa has joined #lisp
fikka has joined #lisp
fourier has quit [Remote host closed the connection]
Chream_ has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
vlatkoB has quit [Remote host closed the connection]
vlatkoB has joined #lisp
nika has quit [Quit: Leaving...]
yoel has quit []
lnostdal has joined #lisp
fourier has joined #lisp
kozy has quit [Remote host closed the connection]
kozy has joined #lisp
CodeOrangutan has joined #lisp
damke has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
joh11 has joined #lisp
nulquen has quit [Remote host closed the connection]
nulquen has joined #lisp
k-stz has quit [Remote host closed the connection]
damke_ has joined #lisp
python476 has quit [Ping timeout: 240 seconds]
nulquen has quit [Changing host]
nulquen has joined #lisp
damke has quit [Ping timeout: 264 seconds]
rumbler31 has joined #lisp
damke has joined #lisp
python476 has joined #lisp
fikka has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
damke_ has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
<pierpa>
beach: slide 8: froms -> forms, methinks
mejja has joined #lisp
fikka has joined #lisp
josemanuel has quit [Quit: leaving]
raynold has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
CodeOrangutan has quit [Ping timeout: 260 seconds]
wigust- has quit [Ping timeout: 240 seconds]
zotan has quit [Quit: ZNC 1.6.5+deb1 - http://znc.in]
<makomo>
if the error happens i just want to write the message and quit
<phoe>
makomo: handler-case
fikka has joined #lisp
<makomo>
i've looked at it, but how exactly would i use it in this case
<phoe>
(defun main () (let* ((line (read-line))) (handler-case (mapcar #'parse-integer (ppcre:split "," line)) (parse-error () (format t "Invalid input!~%")))))
<makomo>
yes, but i want to quit main, as more stuff will follow when the input is actually valid
<makomo>
i want to bail early
<phoe>
this will quit main
<phoe>
HANDLER-CASE first performs a non-local transfer of control to the handler body, evaluates its forms, and then control goes out of HANDLER-CASE
damke has quit [Ping timeout: 264 seconds]
<phoe>
so this will quit right after evaluating FORMAT
<makomo>
phoe: right, but it will quit by return from the handler-case
<makomo>
what i will have next is some code after the handler-case
<makomo>
i don't want that to execute unless input was valid
jason_m has joined #lisp
<makomo>
returning*
<Bike>
you could have your handler return-from main
<phoe>
(parse-error () (format t "Invalid input!~%") (return-from main))
<phoe>
modify the clause so it contains a return-from after the format
<makomo>
so pretty much what i already had with the handler-bind
<phoe>
yes
<makomo>
the behavior is exactly the same, but i guess handler-case has nicer syntax
<phoe>
except rewritten into a handler-case for a bit more of brevi--- yes
<makomo>
i'm basically avoiding handler-case's transfer of contorl
<makomo>
by using return-from main
lemonpepper24 has quit [Ping timeout: 256 seconds]
fiddlerwoaroof has quit [Ping timeout: 256 seconds]
<makomo>
alright, it'll do
<phoe>
except you already transfer the control from the parse-integer which signals parse-error
<phoe>
but in the end it doesn't matter because control leaves the function anyway
<makomo>
yeah
Nouv has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 260 seconds]
fiddlerwoaroof has joined #lisp
fikka has joined #lisp
damke has joined #lisp
Chream_ has quit [Read error: Connection reset by peer]
Chream_ has joined #lisp
<LdBeth>
Is ADVISE implemented in most Common Lisps?
<Bike>
i don't think so.
<oleo>
nope
<Xach>
It used to be.
<rme>
ccl has it
<LdBeth>
Yes I’m reading CCL’s manual
<LdBeth>
I wonder should I use ADVISE as debug method in my own program, while portability is desired but not necessary
<phoe>
LdBeth: what are you trying to debug?
<phoe>
TRACE works for me in most cases
Oladon has quit [Quit: Leaving.]
vlatkoB has quit [Remote host closed the connection]
<LdBeth>
phoe: Generally, an assembler function examines if it is called with valid arguments
<LdBeth>
Like oversized opcodes
lnostdal has quit [Ping timeout: 260 seconds]
<phoe>
LdBeth: why not implement these checks explicitly as functions?
Xach has quit [Ping timeout: 264 seconds]
<LdBeth>
phoe: good idea.
damke_ has joined #lisp
janivaltteri has quit [Quit: leaving]
<phoe>
LdBeth: if they are so important that you want to preserve them in general, then make them explicit.
Xach has joined #lisp
<phoe>
If you want to disable them later for some kind of non-debug production deployment, you can do that as well via some magic switch or via recompiling the code
Karl_Dscc has quit [Remote host closed the connection]
chris-done has joined #lisp
aoeu has joined #lisp
<chris-done>
been away from lisp for years, just loading up quicklisp. ql:quickload on clx runs successfully: * (ql:quickload "clx") => To load "clx": Load 1 ASDF system: clx ; Loading "clx" ("clx")
mlf|2 has joined #lisp
<chris-done>
how do i use-package clx now?
mflem has quit [Ping timeout: 246 seconds]
<chris-done>
i want to run for example (clx:open-display ...) in the repl
<Bike>
you can just do that
<Bike>
well, it might not work since clx is weird, i dunno
<Bike>
but there won't be any problems with the symbol
<chris-done>
that says this: * (use-package 'clx) debugger invoked on a SB-KERNEL:SIMPLE-PACKAGE-ERROR in thread #<THREAD "main thread" RUNNING {100294EAD3}>: The name CLX does not designate any package.
<chris-done>
i tried use-package on "clx" too. i'm rather confused
<chris-done>
do i have to invoke some ASDF incantations separately to quicklisp?
<Bike>
nope
<Bike>
ah, i see. the package is actually called xlib.
<Bike>
(xlib:open-display ....)
<chris-done>
ohhh. well that explains it!
<chris-done>
thanks
<chris-done>
by the way, how did you discover that?
<Bike>
looked up the source on github.
<makomo>
chris-done: the convetional file that defines packages would be "package.lisp" so look for those
<makomo>
conventional*
<chris-done>
ah, thanks
<Shinmera>
Well three ways: 1) quicklisp prints the package names it loads 2) (list-all-packages) 3) (apropos "open-display")
<Xach>
sorry to be away, but the clx/xlib thing comes up a lot (at least once per year)
<Shinmera>
Apropos is pretty nifty, but a lot of people forget it exists
<Shinmera>
myself included
<chris-done>
the package works spiffingly. thanks everybody!
sucks has joined #lisp
sucks has quit [Max SendQ exceeded]
<fourier>
I feel 'apropos as well as 'documentation should better be a part of an IDE, not a language. why they are even there
<Bike>
so that an ide can call them
<Xach>
fourier: an interactive tradition.
<Shinmera>
I for one am really glad docstrings are part of the implementation.
<fourier>
yep but ide can call them without having them as part of the standard. besides documentation is not even full, one cant document slots for instance
<Shinmera>
Or rather, part of the guaranteed environment.
<Bike>
? you can document slots.
<fourier>
.. and rather minimalistic one. not terribly a lot of people are doing CL without IDE
<Shinmera>
Bike: But the standard doesn't say how to retrieve them with DOCUMENTATION
<Bike>
yeah, you need mop i guess.
<Shinmera>
Having your editor have to crawl all source files to get docstrings sounds real shit to me
<Shinmera>
Same with source info. Better to let the implementation track that.
<chris-done>
putting it in the standard means every implementation has to expose a bare minimum of documentation and discoverability
<chris-done>
haskell is my bread and butter and it doesn't have that, as a result even in 2017 there is no standard way to get docs from a compiled package
<chris-done>
sorry, we're in 2018 now. still the same
<fourier>
is there a doxygen/javadoc for haskell?
<Xach>
I learned about it from Philip Greenspun's greenspunning of tcl, by adding proc_doc so he could have his familiar docstrings available and browsable.
<fourier>
haskell docs on hackage looks neat
hiroaki has quit [Ping timeout: 245 seconds]
damke_ has joined #lisp
Chream_ has joined #lisp
elderK has joined #lisp
elderK has quit [Changing host]
elderK has joined #lisp
elderK has quit [Client Quit]
schoppenhauer has quit [Ping timeout: 264 seconds]
<LdBeth>
fourier: once it was popular to have self contained develop environment
Pixel_Outlaw has quit [Quit: Leaving]
Pixel_Outlaw has joined #lisp
<LdBeth>
For Haskell, since it has only one de facto implementation, they can always implement features as packages
<LdBeth>
Or do anything they want
<fourier>
is hugs still alive then or everyone uses ghc?
<dTal>
LdBeth: I would probably never have learned to program if not for QBasic
<dTal>
"self contained development environments" are awesome
<LdBeth>
Seems everyone uses GHC now
<LdBeth>
dTal: I agree, I started programming from GNU/Emacs.
Patzy has joined #lisp
Patzy has quit [Client Quit]
Patzy has joined #lisp
schoppenhauer has joined #lisp
<LdBeth>
And I appreciate its interactive lisp mode.
eSVG has joined #lisp
Naergon has quit [Ping timeout: 276 seconds]
damke has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
damke_ has quit [Ping timeout: 264 seconds]
rumbler31 has quit [Remote host closed the connection]
fourier has quit [Ping timeout: 260 seconds]
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
rumbler31 has joined #lisp
aoeu has quit [Ping timeout: 260 seconds]
margeas has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 256 seconds]
aoeu has joined #lisp
Kaisyu has joined #lisp
chris-done has quit [Ping timeout: 260 seconds]
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
Kaisyu7 has joined #lisp
dessm has quit [Remote host closed the connection]
disumu has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
rumbler31 has quit [Remote host closed the connection]