slaterr has quit [Quit: CGI:IRC (Session timeout)]
dddddd has quit [Remote host closed the connection]
<Josh_2>
O ironclad has a sha512 function bu
myrkraverk has joined #lisp
rumbler31 has quit [Remote host closed the connection]
robdog has joined #lisp
bluemuse has joined #lisp
rumbler31 has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
torbo has joined #lisp
myrkraverk has quit [Ping timeout: 245 seconds]
ym555 has quit [Quit: leaving...]
Lord_of_Life_ has joined #lisp
Achylles has joined #lisp
robdog has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
robdog has quit [Ping timeout: 264 seconds]
buffergn0me has quit [Remote host closed the connection]
robdog has joined #lisp
rumbler31 has quit [Remote host closed the connection]
trocado has quit [Ping timeout: 245 seconds]
<slyrus_>
Ugh... My xml-foo is rusty. Are there any libraries for dealing with XML schemas (besides cxml-rng -- I want old school XML schemas not RNG schemas -- I think).
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
myrkraverk has joined #lisp
robdog has joined #lisp
robdog_ has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
robdog has quit [Ping timeout: 250 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
lumm has quit [Quit: lumm]
wigust- has joined #lisp
robdog has joined #lisp
wigust has quit [Ping timeout: 250 seconds]
Essadon has quit [Quit: Qutting]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
<Josh_2>
Something about if I'm using eval I'm doing something wrong Q_Q https://plaster.tymoon.eu/view/1230#1230 can someone please help me fix this.. it works but it doesn't seem right to do it this way
<Josh_2>
damn I forgot an example
edgar-rft has joined #lisp
robdog_ has quit [Read error: Connection reset by peer]
robdog has joined #lisp
<Josh_2>
Theres an example now
<Josh_2>
I used eval and that makes me think I'm doing something wrong xD
asarch has joined #lisp
<Josh_2>
for now it will do I suppose xD
<gilberth>
Hmm?! Why EVAL at all? Just delete it.
<Josh_2>
It wasn't working without eval Q_Q
<Bike>
it looks like replacing (eval `(ps-to-stream ,stream ,x)) with (ps-to-stream stream x) should be fine
<Bike>
oh, wait, ps-to-stream is a macro
<Josh_2>
Nope
<Josh_2>
ps-to-stream is a parenscript macro
<gilberth>
Which is strange already. Funny API.
<Josh_2>
MY-SITE> (ps (hello))
<Josh_2>
"hello();"
<Bike>
i guess youw ant ps-to-stream*, except it doesn't seem to exist
<Bike>
you can instead do ps* while *PARENSCRIPT-STREAM* is bound, according to the manual
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
charh_ has joined #lisp
myrkraverk has quit [Ping timeout: 245 seconds]
jb____ has joined #lisp
<Josh_2>
Bike: that worked and I don't have to use a macro anymore :D
<Josh_2>
Thanks
charh has quit [Ping timeout: 255 seconds]
robdog has joined #lisp
jb__ has quit [Ping timeout: 255 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
Achylles has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
are there any tutorials on using CFFI-grovel?
buffergn0me has joined #lisp
robdog has joined #lisp
myrkraverk has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
igemnace has joined #lisp
myrkraverk has quit [Ping timeout: 255 seconds]
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
myrkraverk has joined #lisp
rumbler31 has quit [Ping timeout: 268 seconds]
robdog has joined #lisp
robdog_ has quit [Ping timeout: 258 seconds]
robdog has quit [Ping timeout: 250 seconds]
myrkraverk has quit [Ping timeout: 245 seconds]
robdog has joined #lisp
rtypo has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
wanz has joined #lisp
myrkraverk has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
dale has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
<Josh_2>
I can't have inline cl with hunchentoot can I, I have to generate my code dynamically using a library like cl-who and then output that with whatever modifications I want based on variables like cookies or post values??
<Josh_2>
if so that means I gotta convert my current html to cl-who :O
<no-defun-allowed>
you can have inline CL, using FORMAT or the like, hunchentoot just wants a string
<no-defun-allowed>
but use CL-WHO cause it's really good and lets you use CL macros for templating
nalkri has joined #lisp
<gilberth>
Heh, same problem! APIs that tried to be clever by offering macros instead of functions :-)
<Josh_2>
what do you mean with using format?
<Josh_2>
I can't put a format statement in a html file
<Josh_2>
thonk perhaps I should go sleep xD
<no-defun-allowed>
(define-easy-handler ... (format nil contents-of-file . args) or even just (define-easy-handler ... contents-of-file)
<Josh_2>
O
<Josh_2>
I was thinking about that
<no-defun-allowed>
gilberth: CL-WHO tries (and succeeds) to be clever because it generates calls to WRITE-STRING to emit the HTML
<gilberth>
I know.
<no-defun-allowed>
and it has a very convenient DSL which lets you jump between s-exp HTML and CL so it has to do that, unless you want quasiquotation and effectively an "interpreter" of the DSL
<gilberth>
It sure is clever, but I still do not like that.
bobby has quit [Ping timeout: 255 seconds]
<gilberth>
I like a more functional approach better: build some internal representation of the HTML and then dump that.
robdog has joined #lisp
bobby has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
<Josh_2>
guess I'll be converting to cl-who
<Josh_2>
I've not written all that much HTML so should be good
robdog has joined #lisp
<Josh_2>
gonna have a few drinks and hit the sack gn all :)
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
robdog has quit [Ping timeout: 264 seconds]
charh_ is now known as charh
robdog has joined #lisp
gravicappa has joined #lisp
travv0 has left #lisp [#lisp]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
bobby has quit [Remote host closed the connection]
robdog has joined #lisp
bobby has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
<pillton>
Josh_2: It is often better to write functions to generate the code you want first. Once you are happy with the result, define the macro function to invoke those functions.
<beach>
Good morning everyone!
adip has quit [Ping timeout: 245 seconds]
<pillton>
Good morning beach.
robdog has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
<gilberth>
Good morning! I am not here though, since I follow Josh's example.
<beach>
I am not so much here either actually. I am traveling with a dinky laptop. Very small and very slow. So it's not comfortable at all.
torbo has quit [Remote host closed the connection]
<gilberth>
Heh, but at least it seems to have a keyboard. So it is better than a smart phone for typing :-)
<beach>
Indeed.
robdog_ has quit [Ping timeout: 252 seconds]
myrkraverk has quit [Ping timeout: 245 seconds]
rumbler31 has joined #lisp
robdog has joined #lisp
Bike has quit [Quit: Lost terminal]
rumbler31 has quit [Ping timeout: 244 seconds]
robdog has quit [Ping timeout: 252 seconds]
myrkraverk has joined #lisp
robdog has joined #lisp
asarch has quit [Quit: Leaving]
robdog has quit [Ping timeout: 258 seconds]
quazimodo has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
quazimod1 has quit [Ping timeout: 245 seconds]
myrkraverk has quit [Ping timeout: 250 seconds]
marvin2 has quit [Ping timeout: 246 seconds]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog_ has quit [Ping timeout: 264 seconds]
robdog_ has joined #lisp
Oladon has joined #lisp
jack_rabbit has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
robdog_ has quit [Ping timeout: 264 seconds]
libertyprime has quit [Ping timeout: 245 seconds]
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
xkapastel has joined #lisp
robdog has joined #lisp
myrkraverk has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
Ukari has quit [Remote host closed the connection]
<fiddlerwoaroof>
where the wrapping stream would peek-char to see if there was an underscore waiting and, if so, not pass it along
<gilberth>
slyrus_: Sorry, I don't. Althrough I am the original author of cxml, I left it last century. Sorry about that.
rumbler31 has joined #lisp
<slyrus_>
Ok, thanks!
<gilberth>
fiddlerwoaroof: *Sigh*
<gilberth>
fiddlerwoaroof: You still want to be able --- in theory --- to read symbols like "foo_bar"?
<fiddlerwoaroof>
Not necessarily
<gilberth>
Bad.
<fiddlerwoaroof>
Even then, you could have a little state machine that detects <whitespace><number> and then activates underscore-ignoring mode
<fiddlerwoaroof>
And deactivates it when it sees whitespace
<gilberth>
fiddlerwoaroof: Red hering.
<gilberth>
If you do that, you could as well reimplement the token reader.
<fiddlerwoaroof>
Yeah
<lieven>
why not make a custom reader macro for these kind of numbers and write #N100_000?
<gilberth>
lieven: Sure, would be easier. And less state machine to hack.
rumbler31 has quit [Ping timeout: 240 seconds]
robdog has quit [Ping timeout: 252 seconds]
<gilberth>
I even would add a numerical argument. Like #16nFFFF_FFFF
<fiddlerwoaroof>
While, the reason I'm asking is that I'm interested in thinking about the various sorts of incremental changes that can be made to the lisp reader
<gilberth>
fiddlerwoaroof: Well, do not get me started to discuss the Lisp reader.
<fiddlerwoaroof>
And I happened to see a post about how Haskell has a language extension that lets it accept the Swift/Ruby style numbers with _ as a separator
<lieven>
good luck. I've always found the chapter about the reader with its constituent and non constituent characters etc one of the scariest in the spec
<gilberth>
Why doesn't #x#(AF FE) work?
<fiddlerwoaroof>
lieven: interesting, I haven't written any really complex reader macros, but I've never found them particularly difficult to implement
<gilberth>
Or #x#(DE AD CA FE) for that matter?
<gilberth>
On the lisp machine the package prefix was a prefix. You could say FOO:(BAR BAZ QUUX)
<fiddlerwoaroof>
Well, for the first one, couldn't you copy-readtable and get a readtable that that worked for?
<fiddlerwoaroof>
the second one would be more work
<lieven>
the lisp machine also had an extension for file syntax IIRC. where you could put Syntax: into the first line and it would load the syntax/readtable stuff for you
<gilberth>
OK. What you are up to? Do you want to serious experiment with new syntax, or do you just want 1_000_000 to work?
<gilberth>
lieven: Yes, also I believe that "Package:" had some meaning.
<fiddlerwoaroof>
I want to understand the limitations of the readtable system :)
<gilberth>
IIRC "1_000_000" is a potential number in the sense of the spec.
<fiddlerwoaroof>
what sorts of syntax changes it makes easy, which ones it doesn't help with and which it makes hard
<fiddlerwoaroof>
(or one possible interpretation of it)
<gilberth>
We can redefine a single character as reader macro easily, like, say, to read "?X" as "(? X)". What you want to do is to dig into the token reader, which is not accessible through the read table.
<gilberth>
fiddlerwoaroof: Indeed.
<gilberth>
This is like I would have prefered CL would have been specified.
<fiddlerwoaroof>
Yeah, I don't mind this sort of problem all that much, though, because it's easy to fix (at the cost of some amount of mis-communication)
<fiddlerwoaroof>
Things like logical pathnames having an extremely limited character set are harder to work-around
<gilberth>
Anyhow. Your "_" business cannot be solved by the read table alone.
<fiddlerwoaroof>
yeah
<gilberth>
Heh, show me one CL implementation, which handles logical pathnames in any sane way anyway.
<fiddlerwoaroof>
I was hoping I was overlooking something in the spec :)
<gilberth>
No, you didn't.
<fiddlerwoaroof>
sbcl isn't too bad, as long as you don't need dots in filenames
<gilberth>
If you want the "_" business: Rewrite the token reader. That is not hard only tendious.
<gilberth>
BTW, I'd love to be able to write my numbers that way.
shka_ has joined #lisp
<fiddlerwoaroof>
Me too :)
<gilberth>
Install it to all the constien..., constent.., --- you know what I mean --- characters.
<fiddlerwoaroof>
That would be the interesting part...
<fiddlerwoaroof>
You could probably get away with redefining (
<ggole>
Write them 1-000-000 and transform them to numbers with a macro :I
<gilberth>
Try it. It is fun. I once did that. Better than sex, if you ask me.
<ggole>
No, wait, that's the same problem.
<gilberth>
fiddlerwoaroof: Take the hard tour. Rewrite the token reader. You only need to get the escaping rules right. You could pass everything, that is not a number to the default reader and be set.
<gilberth>
fiddlerwoaroof: I'd grok "\" and
<gilberth>
"|" and assemble a string. I'd check that for a potential number, strip the "_" and pass it along.
<gilberth>
Damn "|" and <RET> are just side by side. :(
<fiddlerwoaroof>
I just broke my lisp :)
<fiddlerwoaroof>
I tried redefining ( and passed a function that throws errors
<gilberth>
That is the fun part.
<gilberth>
Why "("?
<fiddlerwoaroof>
Because I'm cheating: I just map over the list and check for any symbols like 1_000_000 and re-read them without the underscores
<fiddlerwoaroof>
this should work on sbcl
<fiddlerwoaroof>
(at least)
<gilberth>
You cheat! Take the hard tour, you will not regret that.
<fiddlerwoaroof>
I guess it won't catch toplevel numbers
<gilberth>
See.
<fiddlerwoaroof>
The hard tour sounds like a job for sometime when I'm not about to go to sleep :)
<gilberth>
Trust me. Take the hard tour.
varjag has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
<gilberth>
That is fine. But: As I said, you only need to get the "\" and "|" escaping rules right. That is not that hard. Assemble a string, check for it being a number, strip "_" if needed and pass the token to the default reader, perhaps by READ-FROM-STRING.
<fiddlerwoaroof>
What I don't understand is how I'd "activate" the new READ: bind it to all the constituent characters?
<gilberth>
You do.
xkapastel has quit [Quit: Connection closed for inactivity]
<gilberth>
I'd test it with just entering the new syntax with some random prefix character like "@" or "$", so you will not blow up the whole Lisp until you're set.
varjag has quit [Ping timeout: 245 seconds]
moldybits has joined #lisp
nowhereman has quit [Ping timeout: 258 seconds]
scymtym has quit [Ping timeout: 250 seconds]
amerlyq has joined #lisp
<gilberth>
Oh, and when you delegate, don't forget to install the default read table before calling say READ-FROM-STRING.
<splittist>
Good morning
<gilberth>
Good night
<gilberth>
Sorry, I am a bit passive aggressive right know. Let me correct that: Good morging, splittist. Sorry about that.
<gilberth>
now, even. Damn.
gxt has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 257 seconds]
varjag has joined #lisp
elderK has joined #lisp
robdog has joined #lisp
neosloth has quit [Remote host closed the connection]
<Ukari>
the first line code is correct while the second line is wrong
<Ukari>
oh, its my mistake
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
lumm has joined #lisp
robdog has joined #lisp
q9929t has joined #lisp
robdog_ has joined #lisp
lumm has quit [Client Quit]
Lord_of_Life_ has joined #lisp
lumm has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
robdog_ has quit [Ping timeout: 258 seconds]
lumm has quit [Client Quit]
lumm has joined #lisp
robdog has joined #lisp
gxt has joined #lisp
gareppa has joined #lisp
im0nde has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
milanj has joined #lisp
jjkola has quit [Quit: Ex-Chat]
robdog has joined #lisp
q9929t has quit [Quit: q9929t]
milanj has quit [Read error: Connection reset by peer]
lumm has quit [Quit: lumm]
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
lucasb has joined #lisp
robdog_ has joined #lisp
lumm has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
gareppa has quit [Quit: Leaving]
robdog_ has quit [Ping timeout: 258 seconds]
lumm has quit [Quit: lumm]
lumm has joined #lisp
ebrasca has joined #lisp
robdog has joined #lisp
Zaab1t has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
eschulte has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
robdog has quit [Ping timeout: 240 seconds]
CCDelivery has joined #lisp
plugd has quit [Ping timeout: 245 seconds]
Bike has joined #lisp
Achylles has joined #lisp
amerlyq has quit [Ping timeout: 245 seconds]
nsrahmad has joined #lisp
marvin2 has joined #lisp
amerlyq has joined #lisp
DGASAU has joined #lisp
plugd has joined #lisp
nsrahmad has quit [Read error: Connection reset by peer]
jjkola has joined #lisp
<jjkola>
hi
<shka_>
jjkola: hi
<jjkola>
my quicklisp update became partially borked and now some of the package are still using the old version even though the latest is available and installed
<jjkola>
if I try to update dists then it says that the distributes are up to date
<Xach>
jjkola: what one is still using the old version?
<jjkola>
at least slime
<Xach>
jjkola: how can you tell?
<jjkola>
when I connect to slime it says the version is 2.20, and also when I connect to other instance where the dists version is latest, slime complains that swank is 2.23 while the currently used is 2.20
<Xach>
jjkola: what do you get from (ql:where-is-system "swank")?
<Xach>
jjkola: does the problem remain if you start a new emacs process?
<jjkola>
yes
<Xach>
jjkola: it seems to me like emacs is loading an old slime through some other means. where does emacs think the function slime-connect is defined?
<jjkola>
how do I check that?
jb__ has quit [Ping timeout: 245 seconds]
<Xach>
jjkola: i'm not sure of the best way, but i do it by doing C-h f slime-connect RET
<Xach>
And then go to the underlined slime.el in the help buffer and hit RET
<Xach>
or click it
<Xach>
Then you will be in slime.el and can check the path to the file with C-x C-f for example
<polezaivsani>
Hi! Does anybody have tips on what reference (or else) material is good for getting up to speed with subj for somebody having a basic grasp of scheme? I'm thinking to scratch an itch with sbcl planning to learn as i go/fall.
<Bike>
sbcl is not an implementation of scheme.
<Bike>
or maybe i misunderstood you.
<Bike>
what is subj?
<Xach>
polezaivsani: first, forget everything you know about scheme when trying to learn how to use CL and SBCL effectively. second, there are many good books on the topic. i like practical common lisp and paradigms of ai programming.
<polezaivsani>
Bike, thanks i know that. i mentioned scheme to let you know that i have some relevant exp
<Bike>
right, sorry.
<Xach>
i found scheme experience to be harmful rather than helpful, but your experience may vary
<Bike>
i don't think you have to forget _everything_, but it's definitely a distinct language
<Bike>
i don't think there are any resources specifically oriented for this situation
<jjkola>
Xach: it is at /dists/quicklisp/software/slime-2.20/slime.el
<Xach>
jjkola: hmm! the swank.txt file should point quicklisp-slime-helper to the 2.23 version. i don't know why it is not.
<polezaivsani>
Oh, i didn't thought of scm experience to pose an issue - i'll keep an eye out for it!
Oladon has joined #lisp
CCDelivery has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
<Bike>
they treat things differently. the namespace issue is probably the main one?
<jjkola>
sorry, it seems that I had forgotten to restart emacs after updating dists :(
<Bike>
in lisp the same symbol can name multiple different objects in the same scope, unlike in scheme
<lieven>
Bike: relying on tail recursion will blow up in quite a few implementations
<Bike>
oh yeah, that too.
<jjkola>
Xach: I had only restarted the slime, but not emacs
<polezaivsani>
i too worry mostly about recursion, namespaces doesn't seem that big of a deal to me
<polezaivsani>
thanks for the hints fellows! i heard good praises about PCL and will prob stick with it for now
<Bike>
well none of it is really a big deal, they're just common points of confusion.
<Bike>
the tail recursion thing does imply actual restructuring of program logic more, though.
<jjkola>
Xach: thanks for the help
jjkola has quit [Quit: Ex-Chat]
<jackdaniel>
when I buffer unfinished lines (from stream-write-string which has a string, start and end parameters) what would be better: storing (list string start end) in internal collection or maybe rather copying the appropriate part of the string to an internal "buffer" string?
amerlyq has quit [Quit: amerlyq]
<scymtym>
jackdaniel: i think you have to copy since the string could change later
<jackdaniel>
the first approach seems dumb, but otoh it avoids unnecessary copying so it might actually pay off...
<jackdaniel>
good point, thank you. also when I spoke it aloud I now think I'm in a microptimization tarpit (in a passage which is not a bottleneck)
<shka_>
jackdaniel: i actually suspect that for short strings copying may be even faster and require less memory
dale_ has joined #lisp
dale_ is now known as dale
<jackdaniel>
that may be very well true, thanks
shrdlu68 has quit [Quit: WeeChat 2.3]
rippa has joined #lisp
pfdietz_ has joined #lisp
wanz has quit [Quit: wanz]
<jcowan>
I think in practice there is only one implementation that does not do tail recursion, and a few more that don't do arbitrary tail calling. However, it's not CL style to depend on this.
rumbler31 has joined #lisp
<jcowan>
One problem with storing "fat pointers" into strings is memory leaks: if you read a 1 MB string from a file and then save a "fat pointer" to just five characters of it, the rest of the 1 MB is basically a memory leak
<lieven>
jcowan: yes, but things like unwind-protect and similar even in macros may make code that looks tail calling not actually be tail calling
<jcowan>
Sure. Dynamic variables, too.
<lieven>
it took the Scheme people some 20 odd years to correctly define what is meant by tail calls so it's a rather hard problem
<jcowan>
(I must say that I did not find my knowledge of CL to pose a difficulty in learning Scheme. Although if CL had been my first language, or even my first Lisp, things would probably have been otherwise.)
rumbler31 has quit [Ping timeout: 250 seconds]
<lieven>
the main problem is some people insisting in writing one language in the syntax of another language instead of using a language idiomatically
<jcowan>
"A Real Programmer can write Fortran in any language."
<lieven>
yeah I was thinking about that one
<lieven>
(PROG TAG1 (IF (= X 0) (GO TAG2) ....)
eschulte has quit [Quit: leaving]
sunwukong has joined #lisp
heisig has quit [Quit: Leaving]
<Bike>
nooooo
Oladon has quit [Ping timeout: 245 seconds]
<gendl>
shall we extend the doubling on the asdf fundraiser for another couple weeks?
<gendl>
i think i can get the seed donors to go along, if we think it will help get closer to the matching target..
easye has quit [Read error: Connection reset by peer]
pankajgodbole has quit [Remote host closed the connection]
rtypo has joined #lisp
robdog has joined #lisp
random-nick has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
glv has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 250 seconds]
shka_ has joined #lisp
robdog has joined #lisp
pfdietz_ has quit [Ping timeout: 256 seconds]
robdog has quit [Ping timeout: 264 seconds]
Josh_2 has joined #lisp
ebrasca has quit [Remote host closed the connection]
Ukari has quit [Ping timeout: 245 seconds]
frodef has joined #lisp
FreeBirdLjj has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
<glv>
Hi. Does anyone know if there is an example somewhere showing how to make a text-field gadget act as a password field in a McCLIM GUI (showing '*' instead of characters)?
Ukari has joined #lisp
borodust has quit [Quit: Leavin']
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
orivej has joined #lisp
rpg has joined #lisp
<djeis[m]>
glv: You might have better luck asking that question on #clim, although I'm not entirely sure that the text field gadget supports that kind of operation given only the CLIM 2 specification.
rpg has quit [Client Quit]
rpg has joined #lisp
jjkola has joined #lisp
<jjkola>
hi
<Josh_2>
hi
robdog has joined #lisp
gareppa has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
nowhereman has joined #lisp
nalkri has quit [Ping timeout: 245 seconds]
gareppa has quit [Quit: Leaving]
moei has joined #lisp
izh_ has joined #lisp
sunwukong has quit [Quit: leaving]
robdog has joined #lisp
cage_ has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
hr0m has quit [Remote host closed the connection]
Achylles has quit [Ping timeout: 258 seconds]
hhdave has quit [Ping timeout: 250 seconds]
Inline has quit [Quit: Leaving]
orivej has quit [Ping timeout: 250 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<ThomasLewis[m]>
It stays blank until `accept` is called, then changes to *s.
<ThomasLewis[m]>
That’s the closest thing I’ve found.
milanj has joined #lisp
milivoj has joined #lisp
<glv>
ThomasLewis: Thanks. I saw a similar piece of code in the CLIM 2 user guide, but I have not yet managed to make it have any effect on my text-field gadget.
borodust has joined #lisp
Inline has joined #lisp
nowhereman has quit [Ping timeout: 246 seconds]
Essadon has joined #lisp
marcoecc has joined #lisp
gxt has quit [Ping timeout: 268 seconds]
random-nick has quit [Read error: Connection reset by peer]
frodef has quit [Ping timeout: 250 seconds]
rpg has joined #lisp
nowhereman has joined #lisp
frodef has joined #lisp
karlosz has joined #lisp
nalkri has joined #lisp
Denommus has joined #lisp
jb__ has joined #lisp
karlosz has quit [Quit: karlosz]
nalkri has quit [Read error: Connection reset by peer]
gravicappa has quit [Ping timeout: 255 seconds]
nalkri has joined #lisp
robdog has joined #lisp
robdog has quit [Read error: Connection reset by peer]
<ThomasLewis[m]>
(Inside a call to accepting-values)
robdog has quit [Ping timeout: 264 seconds]
Inline has quit [Read error: Connection reset by peer]
robdog has joined #lisp
Inline has joined #lisp
shka_ has quit [Ping timeout: 245 seconds]
nckx has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
cl-arthur has left #lisp ["ERC (IRC client for Emacs 24.5.1)"]
cl-arthur has joined #lisp
igemnace has quit [Ping timeout: 250 seconds]
<glv>
Ok, thanks.
robdog has quit [Ping timeout: 258 seconds]
robdog has joined #lisp
pfdietz_ has joined #lisp
marcoecc has quit [Ping timeout: 240 seconds]
<pfdietz_>
jcowan: I don't think there's a need to preserve the entirety of an array if something is displaced into it.
cage_ has quit [Remote host closed the connection]
<jcowan>
Eh?
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
<pfdietz_>
Referencing your earlier comment: "One problem with storing "fat pointers" into strings is memory leaks: if you read a 1 MB string from a file and then save a "fat pointer" to just five characters of it, the rest of the 1 MB is basically a memory leak"
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<pfdietz_>
The CL displacement mechanism for arrays is essentially an immutable offset into a subsection of another array. A sufficiently smart garbage collector could free up the parts of the target array that are no longer reachable.
robdog_ has joined #lisp
rpg has joined #lisp
<Xach>
pfdietz_: what about cl:array-displacement
<pfdietz_>
Ah, never mind.
robdog has quit [Ping timeout: 240 seconds]
robdog_ has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
polezaivsani has quit [Ping timeout: 255 seconds]
xkapastel has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
q3d has quit [Ping timeout: 256 seconds]
comborico1611 has joined #lisp
q3d has joined #lisp
robdog has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
robdog has quit [Ping timeout: 240 seconds]
rk[ghost] has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
Inline has quit [Read error: Connection reset by peer]
robdog has joined #lisp
<comborico1611>
Anyone have a good binding for SLIME-RESTART-INFERIOR-LISP?
<pjb>
C-A-.
<pjb>
or C-A-suppr
robdog has quit [Ping timeout: 240 seconds]
<pjb>
Type C-h k and the key chord you want.
<pjb>
C-M-delete
hyero has joined #lisp
ggole has quit [Quit: Leaving]
<comborico1611>
What is A and suppr?
<comborico1611>
Why would I want to type the chord instead of just do it?
comborico1611 has quit [Remote host closed the connection]
vlatkoB has quit [Remote host closed the connection]
<_death>
, rest RET
zooey has joined #lisp
akoana has joined #lisp
comborico1611 has joined #lisp
<comborico1611>
Ctrl-alt-delete got me. lol
<White_Flame>
M-f4
robdog has joined #lisp
<pjb>
comborico1611: A- is alt.
<comborico1611>
I see. I forget Alt and Meta are different.
Inline has joined #lisp
<pjb>
s-C-H-A-M-S-
<pjb>
super control hyper alt meta shift
<Inline>
pjb: why do some package like clml.lapack require that much heap ?
robdog has quit [Ping timeout: 240 seconds]
<Inline>
it exceeds 3Gb
<pjb>
How would I know. I'd hope they have a good reason for it.
<Inline>
oh man
<Inline>
i couldn't compile it here over
<Inline>
it always threw me into ldbg or some such
anewuser has joined #lisp
q3d has quit [Ping timeout: 256 seconds]
<comborico1611>
pjb: Ahh! That is useful acrostic.
<comborico1611>
I see now how C-h k and C-h w are very useful.
dyelar has joined #lisp
Josh_2 has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<comborico1611>
pjb: How does the "windows" key fall into s-C-H-A-M-S?
didi has joined #lisp
<comborico1611>
Or Macintosh's "option".
<pjb>
It doesn't. There's no windows in X :-)
<pjb>
option is alt actually.
<pjb>
But the point is that you map the keycodes to keysyms with xmodmap, and there's no windows keysym.
<comborico1611>
Do you have a system as to what type of things get Alt or Meta, etc?
<pjb>
See /usr/include/X11/keysymdef.h
<comborico1611>
Or is there a established tradition?
<pjb>
emacs uses C- M- and S- and combinations. So we're free to do whatever we want with choards including s- H- and A-.
hiroaki_ has quit [Ping timeout: 252 seconds]
<didi>
Idea: In REDUCE, if I say `:FROM-END t', then :START means end and :END means start. Why? Because then I can say `:FROM-END t :START 1' to avoid the last element and not have to say `:FROM-END t :END (1- (length seq))'.
<Bike>
didi: it would probably still do that computation internally.
<didi>
Bike: Hum.
<didi>
Oh well.
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
robdog has joined #lisp
<jjkola>
night
ravenousmoose has joined #lisp
milanj has joined #lisp
jjkola has quit [Quit: Ex-Chat]
robdog has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
hyero has quit [Remote host closed the connection]
q3d has joined #lisp
<Grue`>
would be nice if :start and :end supported negative indexes
mathrick has quit [Ping timeout: 264 seconds]
karlosz has joined #lisp
<comborico1611>
So if I run a compiled file in a REPL, it is pretty consistent with how the program would run outside of a REPL? -- specifically concerning the order of defining variables and functions.
robdog has joined #lisp
<comborico1611>
The context I'm discussing is pretty expressed here: "REPLs tend to work a little differently, because they are usually used interactively, so don't take their warnings as good normal practice. I'm not familiar with your REPL, but most of them have a paste mode or a compile mode that will work more like a regular compile environment."
<Grue`>
if it's not a fresh REPL, the previously executed code might affect the newly loaded code
<comborico1611>
But otherwise, it should be consistent with "a regular compile environment"?
milivoj has quit [Quit: milivoj]
zooey has quit [Remote host closed the connection]
<didi>
Grue`: Agreed.
zooey has joined #lisp
<Grue`>
i never run programs outside of a repl anyway :)
robdog has quit [Ping timeout: 240 seconds]
<Grue`>
or if I do, they launch a swank-server which I can connect to
glv has quit [Quit: Leaving]
mathrick has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
trocado has joined #lisp
<comborico1611>
Anyone have recommendations for an article on the subject of order of definitions in Lisp?
<fiddlerwoaroof>
comborico1611: in what sense?
Aruseus has quit [Remote host closed the connection]
<comborico1611>
In the sense how Lisp differs from most programming languages in that you can't call a function before you define it. (I think -- I'm pretty confused.)
<fiddlerwoaroof>
? the compiler will complain if a function hasn't been defined yet, but as long as you define the function before your code executes, it should work
<fiddlerwoaroof>
It gets complicated when you try to use a macro in the same file as its definition
<fiddlerwoaroof>
Because, the functions a macro calls have to be defined when the macro is expanded.
karlosz has quit [Quit: karlosz]
<Bike>
how could you possibly call a function before you define it?
<comborico1611>
fiddlerwoaroof: Hmm. What about if defining a paramater which contains a structure defined lower in code?
<Grue`>
ok, this is dumb. If I use package.lisp to define all my packages, I can't use :import-from to import from a package defined in the same file, because the symbol doesn't exist in the target package because package.lisp is the first file to be loaded
<Bike>
you can compile code including function calls to unknown functions, though.
<Bike>
i mean, (defun foo () (bar)) (defun bar () ...) is okay.
<Grue`>
maybe people who define each package in their own file were right after all...
<Bike>
you might get a warning in the repl but it's not an actual problem.
<fiddlerwoaroof>
Grue`: hmm, I'm pretty sure I've done that before
<Bike>
Grue`: you can just use symbol names instead of actual symbols, right?
<comborico1611>
I must be missing something. I will take a break now. Thanks for the inputs.
<fiddlerwoaroof>
Bike: yeah, the problem is macroexpansion
comborico1611 has quit [Quit: Konnection terminated!]
<Grue`>
Bike: I'm using keywords
<fiddlerwoaroof>
(:import-from :other-package :foo) should work
<Grue`>
it doesn't matter, defpackage still checks that symbol exists
emaczen has joined #lisp
<fiddlerwoaroof>
Grue`: is the symbol you're trying to import exported from the other package?
ltriant has joined #lisp
<fiddlerwoaroof>
If it is, it works, otherwise I think you have to refer to it at least once to intern it
<Grue`>
no, in fact I'm also using the same package
<fiddlerwoaroof>
e.g. (defpackage :a) 'a::sym (defpackage :b (:import-from :a :sym))
<fiddlerwoaroof>
it's ugly, but it works :)
<Grue`>
so I wouldn't need to import-from if it was exported
<Grue`>
hm
<fiddlerwoaroof>
Well, it depends. I don't like :use, so I'll import-from if I want to avoid typing out the package name
<fiddlerwoaroof>
if not, you can always just use the double colon
<Grue`>
that's what I want to avoid
nalkri has quit [Ping timeout: 268 seconds]
<fiddlerwoaroof>
you could also do (defpackage second (:import-from :first first::symbol))
<Grue`>
on a hunch I replaced defpackage with uiop:define-package and now it works!
<fiddlerwoaroof>
I don't know if that's conforming, but it works in sbcl
<pfdietz_>
"Note that top level forms are processed in the order in which they textually appear in the file and that each top level form read by the compiler is processed before the next is read."
<pfdietz_>
So if you put a DEFPACKAGE form at the top level in a file, that package is available to the reader in reading subsequent forms.
<pfdietz_>
A somewhat common approach is to put a defpackage at the top of each file, unique for that file. Properly structured, these can be used to infer dependencies between files ("package inferred system").
<pfdietz_>
Some people think this is too darn many packages, though.
robdog has joined #lisp
ebrasca has joined #lisp
trocado has quit [Ping timeout: 246 seconds]
libertyprime has joined #lisp
rpg has quit [Ping timeout: 240 seconds]
CCDelivery has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
<fiddlerwoaroof>
I like using packages to group things "logically" so I don't have to think about the file-structure as much
Denommus has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 240 seconds]
alandipert has quit [Quit: Ping timeout (120 seconds)]
<didi>
I've changed my style. Now I only define one package and organize my files.
gareppa has joined #lisp
<jasom>
honestly my style is "define one package and don't organize the files at all"
<jasom>
I don't recommend that though
<didi>
:-)
<pfdietz_>
I am old school and put defpackages and defmacros off in their own files, to live with lisps that didn't implement things right. I think those have mostly been fixed or died off, though.
<didi>
pfdietz_: Macros and structs are challenging. Ideally they are defined first, but that means putting them away from where they logically belong, along with their auxiliary functions.
robdog has joined #lisp
moei has quit [Read error: Connection reset by peer]
moei has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
emaczen has quit [Ping timeout: 240 seconds]
Lord_of_Life has quit [Ping timeout: 268 seconds]
gareppa has quit [Quit: Leaving]
Lord_of_Life has joined #lisp
Kevslinger has joined #lisp
robdog has joined #lisp
<fiddlerwoaroof>
I usually define a macro like DEFUN-CT that wraps DEFUN with an appropriate EVAL-WHEN
<fiddlerwoaroof>
For macro helpers
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
robdog has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
cl-arthur has quit [Remote host closed the connection]
libertyprime has quit [Ping timeout: 246 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
CCDelivery has quit [Remote host closed the connection]
CCDelivery has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
izh_ has left #lisp [#lisp]
marcoecc has joined #lisp
<pfdietz_>
The DEF- forms in CL should not need EVAL-WHENs, if the implementation is conforming.
<pfdietz_>
(and if they are at the top level)
moei has quit [Quit: Leaving...]
monokrom has quit [Remote host closed the connection]
<gilberth>
pfdietz_: Auxiliary functions to macros still need EVAL-WHEN as fiddlerwoaroof pointed out already.
<gilberth>
Otherwise those functions are not available at compile time.
trocado has joined #lisp
cl-arthur has joined #lisp
<didi>
I'm yet to play with EVAL-WHEN.
LiamH has quit [Quit: Leaving.]
Bike has quit []
q3d has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
<jasom>
I (ab)used eval-when to get asdf to autogenerate javascript from parenscript
<jasom>
:compile-toplevel generated the javascript and :load-toplevel would run postprocessing on the javascript
frodef has quit [Ping timeout: 240 seconds]
wxie has quit [Ping timeout: 240 seconds]
<cl-arthur>
I've recently read On Lisp and am looking to consolidate macro-learning by doing some semi-complex projects. Any suggestions? (My own first ideas of making an rdbms (*many* other unknowns, complexer) or a linear program solver (would need to learn linear algebra first, which is a future project) seem poorly suited to the macrology consolidation goal.)