mrcom has quit [Read error: Connection reset by peer]
shifty has quit [Ping timeout: 250 seconds]
iovec has quit [Quit: Connection closed for inactivity]
robdog_ has joined #lisp
mrcom has joined #lisp
robdog_ has quit [Ping timeout: 268 seconds]
parjanya has joined #lisp
robdog_ has joined #lisp
robotoad has joined #lisp
Kundry_Wag has joined #lisp
Bike has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
themsay has quit [Ping timeout: 240 seconds]
robdog_ has quit [Ping timeout: 250 seconds]
<Xach>
hjudt: during the build if the foreign library is not installed the build will fail
<Xach>
hjudt: so i install the libraries to make things work
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
dale has quit [Quit: dale]
serichsen has quit [Ping timeout: 252 seconds]
permagreen has quit [Remote host closed the connection]
iovec has joined #lisp
verisimilitude has joined #lisp
X-Scale has quit [Ping timeout: 245 seconds]
robotoad has quit [Read error: Connection reset by peer]
robotoad has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
hectorhonn has joined #lisp
Kundry_Wag has joined #lisp
X-Scale has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
milanj has quit [Quit: This computer has gone to sleep]
<hectorhonn>
morning everyone
bexx has quit [Ping timeout: 246 seconds]
anamorphic has joined #lisp
<eubarbosa>
o/
anewuser has quit [Disconnected by services]
anewuser_ has joined #lisp
robotoad has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
mathrick has quit [Ping timeout: 250 seconds]
robotoad has joined #lisp
robdog_ has joined #lisp
bexx has joined #lisp
eubarbosa has left #lisp ["ERC (IRC client for Emacs 26.1)"]
robdog_ has quit [Ping timeout: 260 seconds]
mathrick has joined #lisp
metallicus has quit [Quit: WeeChat 2.3]
bexx has quit [Quit: Quit]
bexx has joined #lisp
robdog_ has joined #lisp
_whitelogger has joined #lisp
<hectorhonn>
how to execute some common lisp code at slime startup? such as setting optimization level
<verisimilitude>
You could place it in the implementation's init file, assuming it uses one.
bexx has quit [Read error: Connection reset by peer]
<verisimilitude>
A cursory glance with C-h v shows a slime-connected-hook you may be interested in.
bexx has joined #lisp
<aeth>
If it's common initialization code between multiple implementations and multiple methods of starting Lisps (not just SLIME) you could put it in a quicklisp system in ~/quicklisp/local-projects/ and then do (ql:quickload :foo :silent t) at the start
<aeth>
Just make sure it comes after the quicklisp initialization stuff
dale has joined #lisp
robdog_ has quit [Ping timeout: 264 seconds]
khisanth_ has quit [Ping timeout: 258 seconds]
<hectorhonn>
verisimilitude: i thought of putting it in sbclrc, but that would affect non-slime sessions. i think slime-connected-hook run elisp instead of cl?
<verisimilitude>
You can tell that to run Common Lisp, hectorhonn.
<verisimilitude>
That is, you can have the elisp tell slime to run Common Lisp, understand?
<hectorhonn>
aeth: erm, that works? does that mean any other quicklisp package can declaim things and it will affect my package as well?
<aeth>
hectorhonn: Afaik, yes, but they shouldn't.
<aeth>
besides declaim inline which is very common
<aeth>
(declaim ftype is also possible)
<aeth>
Those are both tied to a function name which is hopefully local to a package that the system created, though.
<hectorhonn>
verisimilitude: i see. i was hoping for a lazy man solution, haha
<verisimilitude>
You can always tell slime to place, say, :SLIME in *FEATURES* and then do the further distinguishing in your initialization file.
<hectorhonn>
aeth: i see
<hectorhonn>
verisimilitude: hmm, let me read that up
<hectorhonn>
thanks guys!
khisanth_ has joined #lisp
ebrasca has quit [Remote host closed the connection]
<verisimilitude>
It's no issue.
torbo has joined #lisp
bexx has quit [Read error: Connection reset by peer]
bexx has joined #lisp
ebrasca has joined #lisp
undiscovered has quit [Remote host closed the connection]
esrse has joined #lisp
<verisimilitude>
I'm going through the logs and noticed four days ago there was discussion of Weboob and CL programs for scraping websites.
<anamorphic>
When CCL gives me "Exception on foreign stack", and drops into the low-level debugger and prints out the CPU's registers, how would I go about getting the foreign stack address? (i.e. to plug into GDB after attaching the CCL process so I can find where it came from)
<verisimilitude>
Those of you concerned may find it interesting that I've been doing some work related to this, mostly concerning the ``booru'' style of website; I can see my efforts leading to the creation of at least two libraries.
zmt00 has quit [Read error: Connection reset by peer]
zmt00 has joined #lisp
<anamorphic>
%rbp, %rsp? maybe?
<verisimilitude>
I was using DRAKMA:HTTP-REQUEST for a time, but I've unfortunately been using GNU wget lately, since I've yet to have DRAKMA:HTTP-REQUEST properly continue downloads when interrupted and all of that.
<verisimilitude>
Isn't the usual method to simply start the program in GDB, anamorphic?
torbo has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
akoana has joined #lisp
bexx has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 245 seconds]
orivej_ has quit [Ping timeout: 250 seconds]
bexx has joined #lisp
space_otter has joined #lisp
bexx has quit [Read error: Connection reset by peer]
bexx has joined #lisp
bexx has quit [Read error: Connection reset by peer]
robotoad has quit [Quit: robotoad]
bexx has joined #lisp
<sindan>
verisimilitude: i was interested in weboob/scraping without much pain
ebrasca has quit [Read error: Connection reset by peer]
<sindan>
i've tried many things, basically scraping the html, but lately the one thing that works is selenium driver + scraping the DOM after the js has built it
ebrasca has joined #lisp
robotoad has joined #lisp
permagreen has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
megalography has quit [Quit: Leaving.]
wrycode has joined #lisp
Kundry_Wag has joined #lisp
ahungry has joined #lisp
<verisimilitude>
What website is this, sindan?
mrcom has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 268 seconds]
<Josh_2>
sindan: plump?
Essadon has quit [Quit: Qutting]
<sindan>
verisimilitude any that is js-rendered, is that what you are asking?
<verisimilitude>
I thought you had a particular website in mind.
<sindan>
ah no
<verisimilitude>
I was referring to scraping websites that may have tricks involving JavaScript or cookies, but nothing to that extent, no.
<sindan>
the first couple of times i got cross-eyed looking at obfuscated js i abandoned my 90s era trick of trying to dig the html in any way.
<sindan>
have you used the weboob thing?
<verisimilitude>
I've only come across a few websites comprised almost entirely of JavaScript and not one was worth scraping.
<verisimilitude>
No, I don't, sindan.
<verisimilitude>
I simply noticed the conversation and noted how I've been interested in writing Common Lisp clients of sorts for a few websites or types of websites.
<verisimilitude>
I'm glad I didn't bother researching into how tumblr works, considering that would've been a waste.
<sindan>
I've come across a few, specially if they try to make it hard to copy. Libraries, for one. I wrote a python client to download books.
<sindan>
from two libraries, one spanish, one norwegian. Piece of cake with selenium and the python wrapper for it.
<sindan>
verisimilitude where do you look for the logs from several days ago?
<verisimilitude>
I use the whitequark logger mentioned in the topic of this channel.
bexx has quit [Read error: Connection reset by peer]
bexx has joined #lisp
robdog_ has joined #lisp
froggey_ has joined #lisp
chip has joined #lisp
notzmv has joined #lisp
xrash has quit [Ping timeout: 245 seconds]
bexx has quit [Read error: Connection reset by peer]
azrazalea_ has joined #lisp
robdog_ has quit [Ping timeout: 250 seconds]
datajerk_ has joined #lisp
bexx has joined #lisp
ahungry has quit [*.net *.split]
akoana has quit [*.net *.split]
X-Scale has quit [*.net *.split]
Bike has quit [*.net *.split]
zmv has quit [*.net *.split]
moei has quit [*.net *.split]
datajerk has quit [*.net *.split]
chipolux has quit [*.net *.split]
four has quit [*.net *.split]
froggey has quit [*.net *.split]
Jesin has quit [*.net *.split]
azrazalea has quit [*.net *.split]
X-Scale` is now known as X-Scale
Kundry_Wag has joined #lisp
Bike has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
Jesin has joined #lisp
akoana has joined #lisp
lemoinem has quit [Killed (adams.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
hectorhonn has quit [Quit: Page closed]
akoana has left #lisp ["Leaving"]
iovec has joined #lisp
robdog_ has joined #lisp
Kaisyu has joined #lisp
Bike has quit [Quit: Lost terminal]
Kundry_Wag has joined #lisp
<krwq>
Hey, does anyone know if there are any circumstances where this code: https://pastebin.com/gnqUAwdZ can fail (assuming 123 is not constant)
robdog_ has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
printer base maybe? i'll check
<no-defun-allowed>
yep, printer base affects ~a
<krwq>
i mean more like extra characters - not related to the 123
<no-defun-allowed>
however, ~d will ignore printer base
<krwq>
i had one test-case which i put as an assert and i had an extra character in there
yoonkn has joined #lisp
<krwq>
i converted it to not use *standard-output* and it never failed again but I'm curious if I'm missing something or is it like a sbcl bug
<krwq>
im almost sure the extra character was the '.' coming from quicklisp which was loading my system
Kundry_Wag has quit [Ping timeout: 252 seconds]
<krwq>
when it prints dots when it loads stuff
<krwq>
but im not sure how is that possible
Inline has quit [Quit: Leaving]
<krwq>
the code was working for a while and then i started updating various systems and it suddenly started failing
<krwq>
and then when i used one of the restarts with 'recompile' in the name it loaded everything fine
<krwq>
it was super weird but it would be nice to track this down is it might bite me or someone else in the future (assuming im not missing something)
jstypo has quit [Ping timeout: 250 seconds]
<krwq>
beach: any chance you might have some clues? :)
atgreen has quit [Ping timeout: 240 seconds]
jstypo has joined #lisp
robdog_ has joined #lisp
<no-defun-allowed>
could you try binding the stream with a different name?
<no-defun-allowed>
you'd also have to change the FORMAT target to that stream instead of T as well
anewuser_ has quit [Quit: anewuser_]
robdog_ has quit [Ping timeout: 250 seconds]
<thrig>
stdout is shared between processes but usually that doesn't cause problems
<krwq>
so I'm not sure I'll be able to repro right now, when i don't touch *standard-output* everything works fine
<krwq>
thrig: but when i do with-output-to-string it technically is not using the same *standard-output*
<krwq>
I'll try to repro right now
<krwq>
without clearing .cache/common-lisp no repro, after clearing (that's when it happened the first time) i got repro
<krwq>
yep, consistent repro
<krwq>
i replaced t with *standard-output* and still repros
<krwq>
this is the weirdest issue to me, i can't explain it in any way
<krwq>
hopefully beach comes back from his break soon and explains that to or at least say that's a bug in sbcl or something - it bothers me since weekend and can't find the answer :P
<edgar-rft>
krwq: *standard-output* might be buffered. Try FORCE-OUTPUT and/or FINISH-OUTPUT before and after printing to *standard-output*
<krwq>
edgar-rft: sec, let me get back to repro state first, that's a solid theory
<krwq>
btw what's the different between those 2?
<edgar-rft>
remaining dots from quicklisp looks like a buffering issue
<krwq>
but if this is a threading issue then it might also change the timing :P
Kundry_Wag has joined #lisp
<krwq>
and also even if that is in fact buffering issue it technically should buffer different stream, shouldn't it?
<beach>
krwq: Don't know, sorry.
<krwq>
still got repro after putting finish-output before that assert
Kundry_Wag has quit [Ping timeout: 250 seconds]
<krwq>
the extra '.' seems to be before my output so i presume putting it after won't make a difference
<krwq>
i guess the dynamic variables and threads are kinda sketchy
<krwq>
i mean combined
robdog_ has joined #lisp
robdog_ has quit [Read error: Connection reset by peer]
robdog_ has joined #lisp
hiroaki has quit [Ping timeout: 260 seconds]
robdog_ has quit [Remote host closed the connection]
mrcom has quit [Read error: Connection reset by peer]
<buffergn0me>
FINISH-OUTPUT is supposed to wait until buffered output is flushed before returning. FORCE-OUTPUT can issue an async flush and return right away
Kundry_Wag has joined #lisp
mrcom has joined #lisp
robdog_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
themsay has joined #lisp
orivej has joined #lisp
shrdlu68 has joined #lisp
themsay has quit [Ping timeout: 240 seconds]
themsay has joined #lisp
Kundry_Wag has joined #lisp
rozenglass has quit [Ping timeout: 272 seconds]
robotoad has quit [Quit: robotoad]
Kundry_Wag has quit [Ping timeout: 252 seconds]
buhman has joined #lisp
robotoad has joined #lisp
amerlyq has joined #lisp
yvy has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
Kundry_Wag has joined #lisp
shifty has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
robotoad has quit [Ping timeout: 252 seconds]
yvy has quit [Read error: Connection reset by peer]
<splittist>
good morning
angavrilov has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
<shrdlu68>
morning splittist
Kundry_Wag has joined #lisp
orivej has joined #lisp
asarch has quit [Quit: Leaving]
Lycurgus has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
scymtym has joined #lisp
flamebeard has joined #lisp
gravicappa has quit [Ping timeout: 250 seconds]
xkapastel has joined #lisp
themsay has quit [Ping timeout: 246 seconds]
<zigpaw>
morning :)
krwq has quit [Remote host closed the connection]
schweers has joined #lisp
<beach>
Hello splittist. Hello zigpaw.
nowhere_man has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
jack_rabbit has joined #lisp
<hjudt>
Xach: is there a way to get a list of foreign libs needed for the ql dist?
nowhere_man has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
hhdave has joined #lisp
varjag has joined #lisp
robdog_ has quit [Remote host closed the connection]
space_otter has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
<LdBeth>
good evening
<shka__>
LdBeth: hi!
pierpal has quit [Ping timeout: 246 seconds]
pierpal has joined #lisp
yoonkn has quit [Remote host closed the connection]
amerlyq has quit [Quit: amerlyq]
Josh_2 has joined #lisp
amerlyq has joined #lisp
amerlyq has quit [Quit: amerlyq]
amerlyq has joined #lisp
amerlyq has quit [Client Quit]
amerlyq has joined #lisp
pierpal has quit [Ping timeout: 246 seconds]
Kundry_Wag has joined #lisp
Lycurgus has quit [Quit: Exeunt]
shrdlu68 has quit [Ping timeout: 272 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
pierpal has joined #lisp
bexx has quit [Ping timeout: 240 seconds]
bexx has joined #lisp
pierpal has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Ping timeout: 244 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
amerlyq has quit [Quit: amerlyq]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
amerlyq has joined #lisp
undiscovered has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
amerlyq has quit [Quit: amerlyq]
amerlyq has joined #lisp
atgreen has joined #lisp
pierpal has joined #lisp
amerlyq has quit [Quit: amerlyq]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
spoeplau has joined #lisp
Kundry_Wag has joined #lisp
amerlyq has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
m00natic has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Kundry_Wag has joined #lisp
Josh_2 has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 245 seconds]
mrcom has quit [Read error: Connection reset by peer]
mrcom has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
nanoz has joined #lisp
esrse has quit [Quit: 좋은 밤~]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Essadon has joined #lisp
shifty has quit [Ping timeout: 272 seconds]
janders223 has joined #lisp
milanj has joined #lisp
glv has joined #lisp
undiscovered has quit [Remote host closed the connection]
jochens has joined #lisp
undiscovered has joined #lisp
themsay has joined #lisp
<margaritamike>
Any python people here know if Python's macropy is about as good as Common Lisp's macro system? https://github.com/lihaoyi/macropy
vms14 has joined #lisp
<beach>
margaritamike: If the answer is yes, what would you do with it? Leave #lisp and go program in Python instead?
<beach>
I mean, that's a very strange question.
<margaritamike>
Well just wondering about python's ability to make programs that write programs in python
<margaritamike>
its metaness i guess? (did i say that right?)
<margaritamike>
i'm guessing that requires a good macro system
<margaritamike>
or does the language have to be homoiconic? is python?
<beach>
Again, why do you care about Pythons ability of you program in Common Lisp?
<dlowe>
You're wondering if that makes Python a lisp?
<beach>
Again, it's a very strange question for #lisp.
<dlowe>
This is a good topic for ##lisp which is more about the lisp family and lispy languages
<margaritamike>
Because I want to use Common Lisp to experiement with some things from some cool papers that use lisp from back in the day, but only if the meta abstraction properties lisp provides can't be found elsewhere
<margaritamike>
didn't know ##lisp was a thing
xrash has joined #lisp
<schweers>
margaritamike: why would you only want to use lisp if you can’t find these things in lesser^Wother languages?
* schweers
ducks and hides
<White_Flame>
margaritamike: this is just a turing tarpit question
<White_Flame>
any language can do anything, with unlimited hoops to jump through as a tradeoff
<White_Flame>
lisp macros are basically the easiest-to-accomplish full macro system in popular use
<White_Flame>
the python docs for that look quite involved, with restrictions on when it can run (not in the main class), dealing with AST nodes, and a ton of tools to try to help
themsay has quit [Ping timeout: 272 seconds]
<margaritamike>
White_Flame: so if python can do that, what the heck is left for it to be on par with lisp
<White_Flame>
any language can do that
<White_Flame>
and it doesn't do it well or in an integrated manner, from its reading
<White_Flame>
("any language can do that" obviously assuming infinite tolerance for verbosity, multiple build layers, etc)
<margaritamike>
what does 'well' and 'integrated manner' mean o.o
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
<White_Flame>
did you ever use either macropy or lisp macros?
<beach>
margaritamike: Those don't have precise definitions, which is why it is futile to try to compare languages.
<beach>
margaritamike: And that is probably also why people can get away with suboptimal choices of languages for important projects.
<margaritamike>
White_Flame: no still learning :(((
<White_Flame>
then you really don't have any context to know what options are "better" than another, so simply learn stuff
<beach>
margaritamike: As White_Flame pointed out, it's the Turing tarpit.
<White_Flame>
once you know how to do something, then you can compare it to other languages and see if it looks better and addresses pain points you had along the way
<White_Flame>
but without knowing either, "which is better?" "is it good enough?" etc has no context to answer into
<White_Flame>
"better integrated" however probably is more precise, as lisp uses its natural data structures and list operations to deal with macro transforms, while python needs ast node classes and its whole set of methods on those
<White_Flame>
plus, I'm not sure that Python has well-defined boundaries of compile-/load-/run-time and what is defined when, for situations like this where python code runs during compilation time
Bike has joined #lisp
dddddd_ has joined #lisp
kajo has joined #lisp
dddddd_ is now known as dddddd
sabrac has quit [Ping timeout: 250 seconds]
vms14 has quit [Quit: meh...]
dddddd has quit [Read error: Connection reset by peer]
<schweers>
Why this question whether or not it is on par with lisp? I understand if you want to know it in order to have better mental context. But otherwise ... just use lisp?
<jackdaniel>
I agree with schweers. Putting aside communities, ecosystem, performance, verbosity and personal taste lisp is as good/bad as python or practically any other programming language because there is not much more space for comparison
<jackdaniel>
except maybe retrohat, if you program in LISP you are retrohat compliant
dddddd has joined #lisp
Kundry_Wag has joined #lisp
<dlowe>
he explained earlier that he wants to experiment with metaprogramming
<schweers>
Sorry if I sounded mean. I get that one wants to compare how different approaches are, and maybe find out whether these weird lisp people really have valid claims.
<schweers>
I just wonder why some languages supposedly evolve closer and closer to lisp. If lisp is what you want, just use it.
Kundry_Wag has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
anamorphic_ has joined #lisp
<shka__>
putting aside everything, everything is equal
anamorphic_ has quit [Client Quit]
jochens has quit [Ping timeout: 268 seconds]
anamorphic_ has joined #lisp
flamebeard has quit []
Inline has joined #lisp
sjl_ has joined #lisp
dansa has joined #lisp
<dansa>
I've been `processing' the literature (since the 80s and 90s to present time) on DSL and trying to understand the state-of-the-art of building and applying DLS to problems-in-general and I'm surprised to see how little Lisp languages are mentioned. I haven't found yet a single mention of PLT Scheme and more interestingly no mention of Racket at all. (I have read various papers from the first
<dansa>
decade of the current century.) In contrast, Haskell is mentioned all the time and I find that very surprising. Are even researchers ignoring Lisp?
makomo has joined #lisp
<dlowe>
researchers are subject to fads and social dynamics just like everyone esle
<dlowe>
particularly on the "will this get funded" path
dale has joined #lisp
<dansa>
I think any DSL research today should always be compared to the way Lisp deals with the problem because Lisp seems to be *the* language for DSL --- along with Haskell, I could concede. Racket seems the forefront of DSL today. I'm not aware of any well-known DSL-building problem that's not properly solved by Racket.
<schweers>
I’m not in academia, but I do get the impression that static typing is still all the rage in some circles. So lisp may be ignored on those grounds alone.
<dlowe>
If the discussion is going to involve cross-lisp comparison, we should take it to ##lisp
<dansa>
schweers: I get the same impression... Good to hear that from someone else.
<White_Flame>
however, I think DSLs have more to do with language design and representing problem-space abstractions well
LiamH has joined #lisp
rippa has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
xrash has quit [Ping timeout: 250 seconds]
xrash has joined #lisp
powerbit has quit [Remote host closed the connection]
Bike_ has joined #lisp
Bike has quit [Ping timeout: 256 seconds]
scymtym has quit [Ping timeout: 260 seconds]
pjb has quit [Ping timeout: 252 seconds]
Bike_ is now known as Bike
Lord_of_Life_ has joined #lisp
Lycurgus has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
amerlyq has quit [Ping timeout: 250 seconds]
FreeBirdLjj has joined #lisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
katco has joined #lisp
blackwolf has joined #lisp
karlosz has joined #lisp
kajo has quit [Ping timeout: 260 seconds]
amerlyq has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
jxy has quit [Ping timeout: 240 seconds]
jxy has joined #lisp
Selwyn has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
FreeBirdLjj has joined #lisp
dansa has quit [Ping timeout: 268 seconds]
pjb has joined #lisp
fortitude_ has joined #lisp
Bike_ has joined #lisp
Bike has quit [Ping timeout: 256 seconds]
robotoad has joined #lisp
bexx has quit [Quit: Quit]
bexx has joined #lisp
varjag has joined #lisp
metallicus has joined #lisp
nowhere_man has joined #lisp
kajo has joined #lisp
snits has quit [Ping timeout: 250 seconds]
snits has joined #lisp
undiscovered has quit [Ping timeout: 256 seconds]
holycow has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
anamorphic_ has quit [Quit: anamorphic_]
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
janders223 has quit [Ping timeout: 246 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
m00natic has quit [Read error: Connection reset by peer]
m00natic has joined #lisp
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
m00natic has quit [Ping timeout: 252 seconds]
wglb has joined #lisp
m00natic has joined #lisp
schweers has quit [Ping timeout: 260 seconds]
nowhere_man has quit [Ping timeout: 252 seconds]
irdr has quit [Ping timeout: 252 seconds]
akoana has joined #lisp
JetJej has joined #lisp
katco has quit [Ping timeout: 250 seconds]
<verisimilitude>
Homoiconicity is a requirement for good metaprogramming, margaritamike.
<thrig>
man picture likeness?
<holycow>
what the hell am i reading?
<holycow>
:)
<thrig>
Homo Iconus soon learned the use of tapping on colorful changing glass screens
janders223 has joined #lisp
<verisimilitude>
I recall reading some email archive from around thirty years ago on how Guido van Rossum was unwilling to make some changes to Python that would make it quality as equivalent to Scheme, I suppose because he wanted to maintain more control over his pathetic and horribly-designed language.
akoana has left #lisp ["Leaving"]
hhdave has quit [Ping timeout: 244 seconds]
Lycurgus has quit [Quit: Exeunt]
holycow has quit [Quit: leaving]
pjb has joined #lisp
spoeplau has quit [Ping timeout: 245 seconds]
jack_rabbit has quit [Ping timeout: 260 seconds]
m00natic has quit [Remote host closed the connection]
<dim>
I'm not sure why buildapp / Quicklisp are giving me a hard time these days ;; loading system "pgloader" Fatal MISSING-DEPENDENCY: Component #:CL-LOG not found, required by #<SYSTEM "pgloader">
anamorphic_ has joined #lisp
<dim>
it's like my Makefile arrangements are not loading/downloading QL systems from/to the right place, actually
<dim>
was there a change recently in Quicklisp in where to look for systems? it looks like my used-to-be self-contained quicklisp installation is happy to find systems in my user's quicklisp directory
<housel>
quicklisp-client hasn't changed since last May
<dim>
so that must be my doing then, thanks
amerlyq has quit [Quit: amerlyq]
equwal has quit [Ping timeout: 245 seconds]
<glv>
dim: I got the same kind of problem recently when trying to quickload the mgl library
<glv>
quicklisp complained about a missing dependency (mgl-pax-test if I recall correctly)
<glv>
The problem came from the fact that the systems.txt file of the quicklisp distribution was missing some systems/packages/dependencies
<glv>
I added the missing stuff by hand and everything loaded well after that.
rumbler31 has joined #lisp
<glv>
I don't know if this file is generated locally or if it is shipped as-is with the quicklisp distribution...
bexx has quit [Quit: ups]
bexx has joined #lisp
akoana has joined #lisp
scymtym has joined #lisp
milanj has quit [Read error: Connection reset by peer]
Zaab1t has joined #lisp
nanoz has quit [Quit: Leaving]
nanoz has joined #lisp
anamorphic_ has quit [Quit: anamorphic_]
akoana has quit [Quit: leaving]
anamorphic_ has joined #lisp
irdr has joined #lisp
undiscovered has joined #lisp
jxy has quit [Ping timeout: 250 seconds]
jxy has joined #lisp
jstypo has quit [Read error: Connection reset by peer]
jstypo has joined #lisp
akoana has joined #lisp
anamorphic_ has quit [Quit: anamorphic_]
rozenglass has joined #lisp
Selwyn has quit [Remote host closed the connection]
bexx has quit [Read error: Connection reset by peer]
bexx has joined #lisp
Bike_ is now known as Bike
rozenglass has quit [Read error: Connection reset by peer]
Josh_2 has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
anewuser has joined #lisp
atgreen has quit [Ping timeout: 244 seconds]
jack_rabbit has joined #lisp
janders223 has quit [Ping timeout: 250 seconds]
pierpal has joined #lisp
Oladon has quit [Ping timeout: 246 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
pierpal has quit [Read error: Connection reset by peer]
nanoz has quit [Ping timeout: 245 seconds]
X-Scale has quit [Ping timeout: 240 seconds]
anamorphic_ has joined #lisp
X-Scale has joined #lisp
varjag has joined #lisp
orivej has quit [Remote host closed the connection]
orivej has joined #lisp
janders223 has joined #lisp
rjid has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
<luis>
Hi! I've created a #slime channel for discussion about SLIME.
rjid has left #lisp [#lisp]
anamorphic_ has quit [Quit: anamorphic_]
atgreen has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
katco has joined #lisp
froggey_ is now known as froggey
orivej has quit [Remote host closed the connection]
lemoinem is now known as Guest5232
Guest5232 has quit [Killed (asimov.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
orivej has joined #lisp
powerbit has joined #lisp
anamorphic_ has joined #lisp
makomo has quit [Ping timeout: 240 seconds]
LiamH has quit [Quit: Leaving.]
funnel has quit [Ping timeout: 246 seconds]
funnel has joined #lisp
metallicus has quit [Quit: WeeChat 2.3]
metallicus has joined #lisp
Kundry_Wag has joined #lisp
serichsen has joined #lisp
rumbler31 has quit [Remote host closed the connection]
varjag has quit [Remote host closed the connection]
akoana has left #lisp ["Leaving"]
glv has quit [Quit: Leaving]
rumbler31 has joined #lisp
<serichsen>
good evening
angavrilov has quit [Remote host closed the connection]
metallicus has quit [Quit: WeeChat 2.3]
kajo has quit [Ping timeout: 268 seconds]
shka_ has quit [Ping timeout: 245 seconds]
metallicus has joined #lisp
<wglb>
Good evening
dale has quit [Quit: dale]
Kundry_Wag has quit [Remote host closed the connection]
<wglb>
It works for me almost all the time but if I ask it to parse http://www.databaseanswers.org/data_models/, it runs out of stack. It is trying to parse what looks like mis-classified content type.
<anamorphic_>
Oh interesting
<wglb>
If you can give it a try if you still have it available at your fingertips, just do a dex:get on that.
<anamorphic_>
OK
<hjudt>
wglb: works here
Josh_2 has quit [Ping timeout: 250 seconds]
<anamorphic_>
Same.
<anamorphic_>
wglb: I tried it on Linux w/ CCL 64-bit
metallicus has joined #lisp
metallicus has quit [Client Quit]
<hjudt>
sbcl x64-64. though the content it gets has strange characters between every character. perhaps ms-iis encoding problem?
<hjudt>
same with drakma though
solrize has joined #lisp
<solrize>
"Common Lisp's FORMAT function is--along with the extended LOOP macro--one of the two Common Lisp features that inspires a strong emotional response in a lot of Common Lisp users. Some love it; others hate it.1" -- Peter Seibel. question: what if anything is there to use instead?
xrash has quit [Ping timeout: 250 seconds]
rumbler31 has quit [Remote host closed the connection]
<aeth>
solrize: DO, DO*, DOTIMES, DOLIST, MAP, MAPCAR, REDUCE, etc., can be used as alternatives to LOOP.
<sjl_>
for FORMAT, there's all the write-* print-* stuff built in, or cl-interpol, or that one macro from that one guy's utility lib
kajo has joined #lisp
<aeth>
solrize: FORMAT is the highest level of printing, but you can also use PRINC, PRINT, PPRINT, PRIN1, WRITE, TERPRI, WRITE-CHAR, WRITE-LINE, WRITE-SEQUENCE, etc.
anamorphic_ has quit [Quit: anamorphic_]
<aeth>
Of course, you can mix and match printing because format writes to a stream, so anything other than FORMAT NIL (which writes to a string instead) can mix and match with multiple different ways to write/print to a stream.
<aeth>
If you have to generate a string with more than just FORMAT NIL you can use with-output-to-string
xrash has joined #lisp
<aeth>
Notably missing is a format equivalent for *reading* from a stream afaik.
<wglb>
anamorphic: Hmmm. I abaondoned drakma because it gave me some issue that maintainer could not reproduce. I guess I should go try it on my freebsd system.
<wglb>
hjudt: I get total binary--strings on the resultant file shows nothing. Sounds like something is borked about this system I am running it on. Otherwise, it works well enough to parse on the order of a million other pages with no problem.
jxy has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<solrize>
aeth thanks but what if you want to format a float or something like that? also what do you use instead of LOOP, other than e.g. LABELS ?
<solrize>
there is no guaranteed tail recursion
<hjudt>
wglb: i have not encountered any such difficulties with dexador yet, it usually selects the proper methods according to the content type. drakma however often required to do conversions with flexi-stream
shifty has joined #lisp
<aeth>
< aeth> solrize: DO, DO*, DOTIMES, DOLIST, MAP, MAPCAR, REDUCE, etc., can be used as alternatives to LOOP.
Bike has quit [Ping timeout: 256 seconds]
jxy has joined #lisp
<aeth>
solrize: If you want to use something that only format can do (without building your own function from scratch), you can still mix and match format with other things and just e.g. (format stream "~G" float) while using prints/writes everywhere else.
<aeth>
solrize: e.g. (let ((stream *standard-output*)) (write-string "Hello, user " stream) (format stream "~F" 42d0) (write-char #\! stream) (terpri stream))
Kundry_Wag has quit [Ping timeout: 240 seconds]
<aeth>
Obviously they default to standard output so that was unnecessary to get that particular example to run. Imagine it in a function instead, though.
<solrize>
aeth i guess FORMAT isn't so bad if you use it like printf i.e. without too much programming inside the format string. but i didn't see a simple way to write a "while" loop with e.g. DOTIMES
<aeth>
solrize: You have to use DO for that, or manually write your own macro on top of TAGBODY and GO (which essentially gives you a goto limited to be inside of one form).
<solrize>
yeah, maybe i confused labels with that
<solrize>
is it considered uncouth to just use tail recursion and assume the compiler does the right thing? i'm using sbcl
<aeth>
Iirc, DO is basically an until loop (not while, but you just negate the terminating condition) with a LET at the top, with an optional increment-every-time step added to the end of each LET binding. DO* is the same, but with LET* instead of LET.
<sjl>
something like (defmacro while (condition &body body) `(do () ((not ,condition)) ,@body))
<solrize>
ah ok
<aeth>
Tail recursion depends on the implementation and on the optimization levels in the implementation. Iirc, you can't expect it with (debug 3) in SBCL. It's a bit of a shame that there isn't finer control over whether to turn on and off a feature afaik.
<sjl>
or just (loop :while condition :do ...)
<solrize>
yeah that's what i did, saw a loop example and followed it (though i used (loop while ... do) without :while
<solrize>
it stlil worked
<sjl>
yeah keyword/normal symbols doesn't matter
<sjl>
I use keyword symbols because they stand out more to me visually, but a lot of other folks use normal ones
<aeth>
I use keywords because keywords are highlighted by the editor without requiring the editor to have a special syntax highlighting mode that parses each LOOP.
bexx2 has joined #lisp
<aeth>
Another advantage of keywords is that you use :=, which clearly distinguishes it from =, which usually means equality in Common Lisp.
<aeth>
The final, and probably smallest, advantage is that you don't "pollute" the symbols in your package by creating a bunch of symbols that are only used for that LOOP.
<solrize>
yeah there was a thing like that about LOOP
<sjl>
There's ITERATE, which is the same idea (a lispier syntax). I use iterate a lot.
<aeth>
LOOP is a lot more necessary than FORMAT. There is no equally-concise way to do something like a conditional collect/append outside of LOOP built into the language. You can use a library, but then you're using a library.
<sjl>
some people like it, others don't
<sjl>
All my libraries just use vanilla LOOP though, to avoid an extra dep
<solrize>
iterate is another library, not built into cl? hmm
<sjl>
yeah
<solrize>
probably less confusing to figure out how to use loop then
<sjl>
just stick with loop at the beginning
<aeth>
Oh, and it's harder to mix and match things with LOOP than it is with FORMAT (where you can just use it like any other print/write function). You really can't, except when you have inner/outer loops, which obviously can be something other than a loop that uses LOOP.
<aeth>
My main problem with ITERATE (besides how it handles symbols for its forms) is that it's not compatible enough with LOOP, possibly because it was probably written before LOOP "won".
<solrize>
ah that's another reason to not use it
<aeth>
I want something Lispier, but I literally just want a DO-LOOP that is LOOP with s-expressions around its forms so I can say something like (do-loop ((:for foo :in bar)) ...) or (do-loop (:for foo :in bar) ...) depending on how the actual API details work
<aeth>
Of course, this probably would require writing a from-scratch portable implementation of the LOOP macro because LOOP itself isn't extensible so the naive just-compile-it-down-to-LOOP approach would cause issues.
<solrize>
does COLLECT typically build the list backwards then nreverse, i.e. just wallpaper over that idiom?
Kundry_Wag has quit [Ping timeout: 272 seconds]
<White_Flame>
I would assume that mature implementations tack on a new cons cell to the tail of the list, for performance
<sjl>
especially since you have to make the list available in the right order during iteration if the user binds it to a var anyway, right?
<solrize>
yeah i guess that would be a bit faster, it overwrites the same amount of cdr's but avoids some memory hits
<sjl>
e.g. (loop :for i :from 1 :below 10 :collect i :into l :do (print l)) would have to nreverse twice on every iteration or something
<solrize>
oh yowch yeah if you use the collect target inside the loop
<solrize>
didn't realize you could do that
undiscovered has quit [Remote host closed the connection]
<White_Flame>
I'm not sure you can. " If into is used, the construct does not provide a default return value; however, the variable is available for use in any finally clause. "
<solrize>
aha they are ahead of us ;)
undiscovered has joined #lisp
<sjl>
I guess you can read that as "ONLY available for use in any finally clause", yeah. yet another reason I use iterate more, hah
<_death>
no, you should not insert "ONLY" there..
<sjl>
Is there somewhere it's explicit about that?
<sjl>
oh, > During each iteration, the constructs collect and collecting collect the value of the supplied form into a list. When iteration terminates, the list is returned. The argument var is set to the list of collected values; if var is supplied, the loop does not return the final list automatically.
<_death>
not that I can see, but it does say you can accumulate multiple times into the same destination
<White_Flame>
right, but what's the readable scope of that variable? only finally is mentioned, but as you note it's not exclusively worded
<_death>
if you can, then it's interesting that you can create a circular list that way.. (loop repeat 2 collect foo into foo finally (return foo))
<sjl>
> The var argument is bound as if by the construct with.
<White_Flame>
huh
<solrize>
does this look ok?
<solrize>
(defun collatz (n)
<solrize>
(setf n (cond
<solrize>
(loop :while (/= n 1) :collect n :into r :finally (return r) do
<solrize>
((oddp n) (+ (* n 3) 1))
<solrize>
(t (floor n 2))))))
<solrize>
i mean it works but is that decent loop style
<White_Flame>
hmm, (loop for x from 1 to 10 collect (list x y) into y) just returns NIL for me, no error
<sjl>
yeah, when you use :into it doesn't return the list automatically any more
<solrize>
i think you need :finally (return y) ?
<White_Flame>
I mean to use Y during the iterations
<White_Flame>
to see if it's visible in scope
<White_Flame>
but it seems to mung up the whole thing
pierpal has quit [Ping timeout: 245 seconds]
<sjl>
... sure? It's fine, you're just seeing nil because you haven't returned it
<White_Flame>
oh duh
<White_Flame>
hmm, that then blows the control stack
<solrize>
*** - Lisp stack overflow. RESET
<solrize>
yeah
<sjl>
(setf *print-circle* t)
<sjl>
it's the printing that's killing you
<sjl>
(loop for x from 1 to 10 collect (list x y) into y finally (return y))
<White_Flame>
collect (x (length y)) into y does show increasing lengths
<solrize>
yeah it's still a surprising result
<White_Flame>
collect (list x (length y)) into y does show increasing lengths
<White_Flame>
so I guess yeah, it's standardly visible
<sjl>
Doesn't seem super surprising... it's collecting into a list. Each iteration, it adds a two-element list onto the end of the list. That two-element list happens to contain the original list in this case.
<sjl>
yeah after reading 6.1.3 I'm 90% sure it has to work like I originally thought to be compliant
<sjl>
The var has to be in scope because it says it has to be bound as if by WITH
zotan has quit [Ping timeout: 252 seconds]
blackwolf has quit [Remote host closed the connection]
zotan has joined #lisp
<White_Flame>
the original question I was looking at is if it would be able to push & nreverse, but I think this would make that too heavyweight and basically forces appending to the tail
Kundry_Wag has joined #lisp
<_death>
solrize: (defun collatz (n) (loop for k = n then (if (oddp k) (1+ (* k 3)) (floor k 2)) and prev = 0 then k until (= prev 1) collect k))