<pmc_>
Is member guarenteed to work with a test keyword argument of 'equal as opposed to #'equal? Like (member '(a) '((a) (b)) :test 'equal) instead of #'equal?
<Bike>
sure, it takes a function deisgnator
<fiddlerwoaroof>
pmc_: yeah, it should work with any semi-predicate
<fiddlerwoaroof>
s/semi-//
karlosz has joined #lisp
xkapastel has joined #lisp
<pmc_>
cool, thanks!
pmc_ has quit [Quit: Leaving]
skidd0 has quit [Quit: WeeChat 2.3]
pmc_ has joined #lisp
Essadon has quit [Quit: Qutting]
akoana has left #lisp ["Leaving"]
<LdBeth>
If I have a package export a custom ERROR function for other packages to use, how do I avoid conflict to CL package
<LdBeth>
actually I want something like :CLIM-LISP, but trying to avoid write out every symbol of ANSI COMMON-LISP package
<pmc_>
Is Common Lisp Recipes a recommended book for a beginner?
<LdBeth>
well, why not just read it
<LdBeth>
there's only a few CL books, so no matter how u'll read them
<pmc_>
Good point. I have read ANSI Common Lisp. I will give it a go.
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
<aeth>
pmc_: If you're referring to https://www.apress.com/us/book/9781484211779 then what I'd say is that it's basically a collection of commonly recommended libraries, which agrees with the general consensus around here (with the exception that the author recommends his own cl-fad over uiop for pathname stuff).
Vilivikhorith has quit [Quit: rcirc on GNU Emacs 26.1]
<loke>
I think it's best to simply say that the author doesn't just limit himself to the features of the CL standard.
<loke>
I'm pretty sure it's significantly less than ½, but that's about it.
<aeth>
Any advanced book is going to either be implementation-specific or use libraries like CFFI and bordeaux-threads (and even things like cl-ppcre).
<aeth>
But I guess the point isn't libraries, it's advanced stuff. Well, advanced non-GUI stuff. It touches GUIs but that's really a subject for another book, ideally after that part of the ecosystem matures more.
wxie has joined #lisp
pmc_ has quit [Quit: Leaving]
_whitelogger has joined #lisp
bendersteed has quit [Remote host closed the connection]
nowhereman has quit [Remote host closed the connection]
<dlowe>
Xach: a thought occurs to me that they are using a continuous integration system that scripts a rebuild of the entire container after every commit
sjl has quit [Ping timeout: 250 seconds]
markoong has quit [Quit: Konversation terminated!]
markoong has joined #lisp
kdas_ is now known as kushal
markoong has quit [Ping timeout: 245 seconds]
X-Scale` has joined #lisp
anewuser has joined #lisp
X-Scale has quit [Ping timeout: 272 seconds]
X-Scale` is now known as X-Scale
FreeBirdLjj has joined #lisp
pierpal has quit [Remote host closed the connection]
mathpacka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
esrse has joined #lisp
bkst has joined #lisp
_whitelogger has joined #lisp
marvin2 has quit []
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
ebrasca has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
<pillton>
Xach: Have you thought of using ipfs?
xkapastel has quit [Quit: Connection closed for inactivity]
karlosz has quit [Quit: karlosz]
figurehe4d has joined #lisp
wusticality has joined #lisp
wusticality has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
mrcom has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
iovec has joined #lisp
volkov has joined #lisp
Autolycus has quit []
mrcom has joined #lisp
<beach>
Good morning everyone!
<loke>
hello beach!
mrcom has quit [Ping timeout: 272 seconds]
rozenglass has joined #lisp
mrcom has joined #lisp
<beach>
It doesn't make much sense to declare the type of a constant variable, does it? I mean, it is exactly of the type that the value indicates.
<verisimilitude>
It could cause an error if it doesn't adhere somehow, which is valuable.
<beach>
Sure. I didn't express myself very well though. I meant, whether it makes sense for the compiler to actually store type information with the constant variable when it encounters a type declaration for it.
<beach>
... which I am hypothesizing it does not.
<verisimilitude>
I'd think doing so would avoid special cases, considering most everything else would be typed by value normally.
Oladon has quit [Quit: Leaving.]
<beach>
Maybe that's true for other compilers, but Cleavir handles constant variables separately anyway.
jlarocco has quit [Remote host closed the connection]
mrcom has quit [Read error: Connection reset by peer]
<beach>
Next question: The things that the compiler can find in a variable position are: lexical variables, special variables, constant variables, global symbol macros, and local symbol macros. The last two have a natural common name, namely "symbol macros". What would be a natural common name for the first two? I kind of don't like "variable variables".
<aeth>
beach: I think CLtL2 features (via introspect-environment) need to work on type declarations, e.g. the inline dispatch in specialization-store... So (foo 42) won't inline dispatch, but (foo (the (unsigned-byte 32) 42)) might
<aeth>
That's the only time I've seen declarations/the for constants make a difference.
mrcom has joined #lisp
<beach>
A similar situation happens for functions. There can be global functions, local functions, special operators, global macros, and local macros. The last two have a natural common name, but what about the first two?
<verisimilitude>
Using ``normal'' and ``special'' seems fairly clear to me.
<beach>
aeth: I don't understand. It seems you are suggesting that specialization-store is part of CLtL2?
<verisimilitude>
I don't see why ``lexical variable'' and ``special variable'' don't have a common name of ``variable''.
<beach>
verisimilitude: Because then "constant variable" would not be a variable, and, even though symbol macros are found in a variable position, they would be excluded too. So then I have to find a common name for "variable" and "symbol macro". Currently, I am using "variable" for that.
<beach>
<aeth>
beach: CLtL2 features are required by a feature in specialization-store to do its inline generic dispatch, and its variable information is strictly DECLARE/THE-based, not inferred.
sword has quit [Quit: ERC (IRC client for Emacs 26.1)]
<aeth>
beach: So (foo (the (unsigned-byte 32) 42)) can actually be faster than (foo 42) if foo uses that
<beach>
aeth: I see. Let me check CLtL2.
<beach>
aeth: I am still confused. I don't see an introspect-environment in CLtL2.
<aeth>
I think introspect-environment is a portability library
<beach>
I'll check that with Bike. I am not in the business of being compatible with existing implementations, nor with CLtL2. In fact, I am deliberately trying to do something better.
wusticality has joined #lisp
pierpal has quit [Remote host closed the connection]
wusticality has quit [Ping timeout: 240 seconds]
Arcaelyx has joined #lisp
irdr_ has quit [Remote host closed the connection]
irdr has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
jprajzne has joined #lisp
figurehe4d has quit [Remote host closed the connection]
<pillton>
There are things in introspect-environment which aren't in CLtL2 though. I think typexpand is an example.
<pillton>
Which is a glaring omission from the CL standard.
Posterdati has joined #lisp
<beach>
pillton: Yes, I am aware of that section, and I am trying to create something that is more complete, extensible, etc.
<beach>
In fact, it's a good thing that that particular protocol did not make it into the standard.
<beach>
But I agree that having (a better version of) such a protocol would be a good thing.
<pillton>
I'd have to think about the declaring the type of a constant. One can already use constantp.
<pillton>
Introspect environment has the function CONSTANT-FORM-VALUE though which is for forms like (sqrt 2) I think.
<beach>
I see.
<pillton>
beach: Why was it good that it didn't make it in to the standard?
<beach>
Because it is not complete and it is not extensible.
<beach>
Suppose I want to know the name of the method class of a generic function. I can't get that information using the protocol, and I can't extend it to return an additional value without breaking the protocol.
<pillton>
That isn't a question of the environment though.
<beach>
And does not contain information about blocks and tags. And I can't extend augment-environment to allow such information.
abhixec has quit [Ping timeout: 244 seconds]
<beach>
Oh, it is.
<pillton>
Only if you have local generic functions which aren't allowed.
<beach>
If you have (defgeneric foo (...) (:method-class bar)) then the file compiler does not create the generic-function metaobject.
<beach>
So if you have a (defmethod foo (...) ..) following it, then the compiler needs to know that BAR is the method class.
<pillton>
Really? That makes no sense.
<beach>
OK.
<beach>
Surely, the CLtL2 protocol returns information for global functions as well as local ones? No?
<beach>
OK, let's take a different example. What if I want to know the lambda list of a function, so that I can check calls to it?
<pillton>
It does. Function-information returns multiple values.
<beach>
Oh, FTYPE. Fine, you are right.
<beach>
My example of generic functions is directly taken from the paper by Costanza and Herzeel.
<pillton>
Sorry. My previous reply was to the global versus local.
<pillton>
The generic function case is surprising.
<beach>
My point is that the implementation might want additional information from the environment, and this protocol does not allow extensions.
<pillton>
I'd probably change that to "the user might want additional information from the environment".
<beach>
If you like.
<beach>
Again, my point is that if you are writing a compiler, you need to query the environment and augment it.
<beach>
And this protocol is inadequate for that purpose.
<pillton>
Sure. It would probably stop people abusing symbol-macrolet too.
<pillton>
Which I have done to inject stuff in to the environment. :)
<holycow>
i am curious what the typical usecase is for something like this. i presume static websites where you need to "template" the layout but not deploy a framework server side?
<no-defun-allowed>
the pretty printers for HTML are nicer than cl-who, but i usually use that
nowhere_man has quit [Ping timeout: 252 seconds]
<holycow>
aha
<holycow>
just looking at the cl-whosite, that doesn't look that bad to be honest.
<holycow>
have you been building static websites with "templated" layout ... say perhaps templated only as far as having the menu system autogenerated on each page or the like?
iovec has quit [Quit: Connection closed for inactivity]
ggole has joined #lisp
<no-defun-allowed>
i do generate "live" content with cl-who, which is templated
<splittist>
beach: as you no doubt know, the CLHS uses 'non-constant variable' for lexical and constant variables. What is a 'global symbol macro' (as opposed to a 'local symbol macro')?
wigust has joined #lisp
<splittist>
...'for lexical and dynamic variable', I mean
Posterdati has joined #lisp
<splittist>
variable/s/. Me stop typing now.
<beach>
Heh. Thanks.
<beach>
A global symbol macro is one that is defined in the global environment.
<beach>
The thing here is that the CLtL2 uses the name VARIABLE-INFO for anything in a variable position, so that includes symbol macros as well.
<beach>
So non-constant variable may or may not include symbol macros.
scymtym has joined #lisp
<splittist>
Hmm. There's also 'global variable' for 'dynamic variable + constant variable'. Binding a symbol defined as a 'global variable' with a symbol-macrolet is obviously a program error, hence my confusion.
<splittist>
I don't think it's possible to line up CLtL2 with CLHS on this stuff.
<beach>
I think you are right.
<splittist>
Is there more than one global environment?
DGASAU has joined #lisp
varjag has joined #lisp
space_otter has quit [Remote host closed the connection]
anewuser has quit [Quit: anewuser]
volkov has quit [Quit: volkov]
zmv has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
<splittist>
(silly question - not quite what I meant, and now I've forgotten what I meant to ask)
<no-defun-allowed>
(not outside SICL, to my knowledge)
<no-defun-allowed>
yeah he was raised as a tankie, then the tanks rolled in to Czechoslovakia during a holiday
<no-defun-allowed>
presentation sounds pretty corny, too
<shka__>
how to document arguments that are used as booleans?
<shka__>
if NIL do that if not NIL do that?
<beach>
shka__: The Common Lisp HyperSpec uses "True" and "False".
<shka__>
hm, ok
<splittist>
I do wonder how lisp will fare in the coming, third, AI winter
<shka__>
splittist: it is always our fault
<shka__>
also, THIRD?
<varjag>
everyone will blame python this time
<beach>
It won't be affected by the one coming up, because Common Lisp is no longer used in AI.
<shka__>
varjag: good, it deserves that… somehow ;-)
wusticality has quit [Ping timeout: 245 seconds]
q3d has quit [Ping timeout: 256 seconds]
<varjag>
shka__: it is slow and has too much whitespace
<aeth>
not enough whitespace.
<aeth>
"x+y" shouldn't be legal in a language. "x + y" should be required, for clarity, and to permit kebab-case
<aeth>
Of course, if you have (x + y) * z you might as well go one step further and do (* (+ x y) z) and get macros
<no-defun-allowed>
Hah.
<no-defun-allowed>
Hopefully the deep learning meme will be the big loser in the next AI winter.
<isoraqathedh>
What was the Big Deal Technology in the first AI winter?
<no-defun-allowed>
Symbolic AI drove most AI work until the 90s, I'd say.
zmt01 has joined #lisp
<isoraqathedh>
And the winter is sometime between 2000 ~ 10 then.
zmt00 has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
So, old terms like expert systems or rule engines might have been said by your grandpa when he was reciting his job as an AI programmer.
<no-defun-allowed>
No, more like the late 80s to early 90s.
<isoraqathedh>
The whole neural network/pile of linear algebra AI seems to only really pick up at or around 2015.
amerlyq has joined #lisp
<isoraqathedh>
Ah okay.
esrse has quit [Ping timeout: 250 seconds]
<no-defun-allowed>
There was an overlap, there's a koan about an artificial neural network on a PDP10 and Symbolics also had an ANN implementation.
<isoraqathedh>
I have to admit, my first brush with AI is typically when it is labelled "CPU" and found in video games.
<no-defun-allowed>
The whole "neural networks will solve world famine, just help me with my activation function" thing was definitely less pushy then though.
<no-defun-allowed>
(Sorry, PDP6.)
<isoraqathedh>
I don't think it's the fault of the technology for neural networks. It's more the attitude toward technology and similar things. That a thing must change the world or disrupt an industry or whatever, or it's completely pointless and worthless.
<no-defun-allowed>
That's entirely possible too.
longshi has joined #lisp
<isoraqathedh>
That said, I can't really see the end of this neural network craze, although at the same time I predicting that it would never end is foolish.
beach has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Well, the training data suggests it won't end (:
beach has joined #lisp
<no-defun-allowed>
Hey, welcome back beach
<beach>
Thanks.
<no-defun-allowed>
Oh, quick question. For a school assignment this year, I have to design and implement a program for a "client", and I think the total timeframe is around three months or so.
<beach>
That's a decent duration.
<beach>
Who is the client?
<no-defun-allowed>
Does anyone have any programs or libraries they want written? I also have to report on it, get design advice, blahblah, the usual work stuff.
<no-defun-allowed>
beach: That's what I'm looking for now. My teacher asked me to start looking and asking around, as the complexity of the program is probably the limit on what grade I will get.
<varjag>
no-defun-allowed: http/3
<varjag>
;)
<beach>
no-defun-allowed: I have tons, but you will likely prefer other suggestions. That said, I can be of assistance when it comes to the report, documentation, design, prsentation, etc.
<beach>
... because it's part of my job description.
<no-defun-allowed>
Well, I did look at the list on your website, and honestly I think only the accounting program and maybe a very dull editor would be doable right now.
<no-defun-allowed>
varjag: in my dreams.
<beach>
no-defun-allowed: In that case, the accountant program is probably preferable, because you can get a useful program done in a very short period of time.
<no-defun-allowed>
I didn't expect it to be very big.
<beach>
The interesting part would be improving the GUI, both the looks and the functionality.
<beach>
Oh, and there are all the reports and stuff to generate.
<no-defun-allowed>
I'll have to ask if I can do that, I felt the task was to create a new application, but that does sound important.
<beach>
The existing code is so small that it might as well be a new application.
<beach>
You can consider it to be a "proof of concept".
<no-defun-allowed>
Yes, it does sound like a very large change to do.
<beach>
So I mean, you can consider your work to be a complete rewrite from scratch of a skeleton proof-of-concept program.
<no-defun-allowed>
Sure.
<splittist>
no-defun-allowed: how about something that extracts text - including style information - from PDFs? Not OCRing the picture, but the actual text inside the page description.
<no-defun-allowed>
I'll ask my teacher tommorow, since this is an intriguing project.
<beach>
Anyway, I'll let you think about it. When do you have to decide?
<no-defun-allowed>
I have quite a while, I think the planning stage starts some time around April to my knowledge.
<beach>
OK, no rush then.
<no-defun-allowed>
splittist: that sounds either "quite trivial" if you just want string literals, or "nigh impossible" if PDF is anything like PostScript and strings can go wherever in computation
<no-defun-allowed>
For the latter, I would need a (non-graphical) PDF engine which just logged text drawing commands.
JamesDabron has joined #lisp
<splittist>
no-defun-allowed: there are lots of open source PDF display engines in other languages; there is a (rudimentary?) parser in CL-PDF; and an 80% PDF-scraper would make vast amounts of the world's information available in sexps ...
<splittist>
You could tell beach you were doing a PDF backend for McClim (:
JamesDabron has quit [Client Quit]
JamesDabron has joined #lisp
<no-defun-allowed>
The accounting program sounds like something I would have designed, then working in three months though.
<beach>
You can play around with the existing code and try to improve it sooner. That way, you will have a good idea about it to help you decide.
<no-defun-allowed>
Right. Thank you very much for the advice.
<no-defun-allowed>
I'll be headed to bed now. Good night everyone.
<beach>
'night no-defun-allowed.
random-nick has joined #lisp
iovec has joined #lisp
nowhere_man has joined #lisp
frodef has quit [Ping timeout: 244 seconds]
milivoj has joined #lisp
nowhere_man has quit [Ping timeout: 240 seconds]
gxt has quit [Ping timeout: 268 seconds]
JamesDabron has quit [Ping timeout: 240 seconds]
ebrasca has joined #lisp
JamesDabron has joined #lisp
dale has quit [Read error: Connection timed out]
dale has joined #lisp
Necktwi has quit [Ping timeout: 245 seconds]
q9929t has joined #lisp
Lord_of_Life_ has joined #lisp
<akater>
Does anyone believe (aand it) should be equivalent to (and)? Definition I use (which probably came from pg) considers (aand it) an error.
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
markoong has joined #lisp
wusticality has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
wusticality has quit [Ping timeout: 244 seconds]
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
zmv has joined #lisp
zmv is now known as notzmv
hjudt has quit [Quit: leaving]
hjudt has joined #lisp
FreeBirdLjj has joined #lisp
<_death>
akater: it does make sense
notzmv has quit [Ping timeout: 268 seconds]
longshi has quit [Quit: WeeChat 2.3]
xkapastel has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
ebrasca has quit [Read error: No route to host]
Bike has joined #lisp
zmv has joined #lisp
zmv is now known as notzmv
dddddd has joined #lisp
q9929t has quit [Remote host closed the connection]
iovec has quit [Quit: Connection closed for inactivity]
FreeBirdLjj has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 246 seconds]
FreeBirdLjj has joined #lisp
gxt has quit [Ping timeout: 272 seconds]
FreeBirdLjj has quit [Ping timeout: 245 seconds]
schjetne has joined #lisp
<schjetne>
Who went to the whole <Programming> conf two years ago? I'm trying to decide whether it's worth doing the whole thing or just ELS.
scymtym has joined #lisp
<schjetne>
I'm looking at the list of accepted papers, a lot of it seems really interesting
wusticality has joined #lisp
smokeink has quit [Ping timeout: 268 seconds]
wusticality has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
FreeBirdLjj has joined #lisp
gxt has joined #lisp
Josh_2 has joined #lisp
jprajzne has quit [Quit: Leaving.]
nowhere_man has joined #lisp
iovec has joined #lisp
nowhere_man has quit [Ping timeout: 246 seconds]
<verisimilitude>
From that earlier discussion, it would be too nice if some languages, such as Python, were killed by the next AI Winter.
<verisimilitude>
AI for enemies in games is proof that recognition and whatnot are the actual hard problems.
<verisimilitude>
What I find most disconcerting is how the focus isn't on building something that always works, but merely usually works better than a far below average human.
status402 has joined #lisp
rippa has joined #lisp
<nirved>
basic python is too easy to learn, so it won't die
<nirved>
the current "AI" stuff is just glorified statistics
zigpaw has quit [Remote host closed the connection]
ntbre has joined #lisp
ggole has quit [Ping timeout: 240 seconds]
akater has quit [Remote host closed the connection]
akater has joined #lisp
cage_ has joined #lisp
<jackdaniel>
instead of wishing another community to fall into obsolescence we should wish our own community to proliferate
<Josh_2>
^
ggole has joined #lisp
troydm has quit [Ping timeout: 250 seconds]
troydm has joined #lisp
volkov has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
igemnace has joined #lisp
<verisimilitude>
You can have both, jackdaniel.
<phoe>
I don't wish any programming community to die
<verisimilitude>
Not even C++ or PHP, phoe?
<phoe>
there is already enough hostility in the world
<phoe>
and I don't want somebody from another community to make deathwishes towards Lisp in retaliation
<phoe>
so, yes
<jackdaniel>
verisimilitude: wishing others to fail makes you look bad and I think that our community has a well deserved bad opinion among potential members thanks to such hateful stuff. My point is: I don't want both.
<phoe>
"lispers, these people who want other languages to die"
<phoe>
"because, as they say, their language has the biggest #<error printing object>"
<phoe>
I don't really case if it's deathwishes like yours or spiritual messianistic elitism like what Paul Graham posted now and then; I consider them equally bad for the language and its community.
<verisimilitude>
I don't think what I originally wrote was quite as strong as the latter language used, but whatever; as for hostilitiy, I was drawn by what I've read from Erik Naggum and it's not like we're in uniform.
<splittist>
There are probably more lispers than there have ever been. That there are vastly more Python, PHP and ECMAScript programmers than lispers is just evidence of growth potential. I'm not convinced the comparative popularity of other languages causes particular harm to lisp - whatever that might mean.
<splittist>
verisimilitude: you are correct that the lack of a 'lisp community' cuts both ways
<phoe>
I've already seen too many people making fun of Lisp due to the "stereotypical Lisper" attitude, and several people who have been drawn in by the Magical World of Magic® picture drawn by Graham who have come to see if Lisp is really the magical silver bullet for everything®, saw just another Turing-complete programming language with some interesting concepts, and turned back in disappointment and anger. And,
<phoe>
in my opinion, they were right.
volkov has quit [Remote host closed the connection]
<schjetne>
Isn't it rather to wish the community to receive better tools than to wish it to die?
<verisimilitude>
Lisp Machines were basically killed by inferior tools proliferating, schjetne.
<phoe>
"hey, they killed lisp machines, let's fuck them and their languages"
<phoe>
I find this kind of thinking primitive and condescending
matijja has quit [Ping timeout: 240 seconds]
<shka__>
LET THE IT BURN!
<verisimilitude>
All I originally wrote earlier was I thought it would be nice if the current fad resulted in a culling of these silly languages.
<phoe>
Yes, and I explained why I consider that idea to be silly.
<verisimilitude>
Now however, to paraphrase Erik Naggum, there are some languages that effectively make it impossible to write correct programs and the world would be better off without them.
<phoe>
I could make the same argument by replacing a few words, "There are some Lispers that effectively make it impossible to maintain a friendly and constructive community and the world would be better off without them.".
<phoe>
And it would be equally silly to me.
status402 has quit [Quit: status402]
<verisimilitude>
We just disagree, although I still feel my words were blown out of proportion; anyway, what have you been working on lately, phoe; I've been lightly working out a Lisp implementation of a format I've designed.
<phoe>
Hacking a game of my own.
<phoe>
And hacking CCL in meantime.
<phoe>
I have little time for both though, since employment is taking most of it.
<verisimilitude>
Are you employed writing Lisp?
<phoe>
(Back in 90mins, I need to run and do a thing.)
<phoe>
Sadly, no. It's corporate Java.
<Duns_Scrotus>
is setf on subseqs of arrays guaranteed to work like memmove
<phoe>
you mean #'(setf subseq)?
<phoe>
the standard makes no such guarantees, mostly because it doesn't know of a concept called memmove
<Duns_Scrotus>
I mean, will (setf (subseq v 0) (subseq v n)) be equivalent to making a copy of (subseq v n) and then overwriting the start of v with it
<jackdaniel>
Duns_Scrotus: yes
<jackdaniel>
subseq is guaranteed to make a copy of the sequence
<Duns_Scrotus>
so the second subseq is a genuine call to subseq
<Duns_Scrotus>
and the first is, uh, something to do with how places and setf work that I don't understand yet
<jackdaniel>
yes, setf assigns values to places, second argument is a value
<jackdaniel>
(and value is produced by the form being evaluated)
hiroaki has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
wusticality has joined #lisp
warweasle has joined #lisp
wusticality has quit [Ping timeout: 246 seconds]
schjetne has quit [Ping timeout: 264 seconds]
Josh_2 has joined #lisp
hiroaki has joined #lisp
prite has quit [Ping timeout: 250 seconds]
<beach>
Duns_Scrotus: Maybe you want REPLACE instead?
<beach>
For what it's worth, I agree with jackdaniel and phoe. I don't think it is a good idea to wish the death of other programming languages. It is much better to concentrate on our own prosperity.
<Duns_Scrotus>
why yes i did thank you
<beach>
Sure.
<verisimilitude>
There's also FILL, for when you want just a single value, to keep in mind, Duns_Scrotus.
svillemot has quit [Ping timeout: 245 seconds]
ntbre has quit [Quit: ntbre]
svillemot has joined #lisp
markoong has quit [Quit: Konversation terminated!]
markoong has joined #lisp
markoong has quit [Client Quit]
markoong has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
ntbre has joined #lisp
<aeth>
People aren't allowed to have fun programming except by programming in the ways that I find fun! /s
jlarocco has joined #lisp
nowhere_man has joined #lisp
LiamH has joined #lisp
nowhere_man has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<aeth>
As for lispms.... Lisp machines, and all other novel platforms of the era, were killed by hardware/software configurations (mostly x86/C) that afaik (1) were cheaper, (2) were faster, (3) used less memory, and (4) had more libraries/tools. And it was in the 90s when #3 was probably the largest factor (and #3 is almost entirely irrelevant today).
<aeth>
Sure C programming's not as fun, but from a 90's perspective (or embedded today) there's a lot of good arguments for it.
<aeth>
It's not like C programmers killed Lisp machines. The economics of the 1990s did.
<dlowe>
C programming is fun on a different axis :)
FreeBirdLjj has quit [Remote host closed the connection]
DGASAU has quit [Ping timeout: 240 seconds]
<aeth>
Imo, C programming is fun like making works of art (or computers!) in Minecraft is fun. It's hard and impressive that anything can get done.
<chumphries>
I do feel like now-a-days there is more experimentation and new ideas are being put to production systems, there may be room for lisp machines again, who knows really. If you told me 20 years ago a billion dollar company would be running public facing systems on a javascript engine and architecture I'd have thought you were crazy
<chumphries>
C and unix kernel programming are pretty awesome, really like idea of being simple and to the point (mostly)
DGASAU has joined #lisp
sjl has joined #lisp
<nirved>
current programming is kinda craftsmanship, always describing little details, reinventing wheels, etc.
<dlowe>
well, you could always swoosh terabytes of data around with linear algebra and hope something cool pops out
<chumphries>
"data swoosher" should be a title
<chumphries>
"Sr. Data Swoosher"
<nirved>
i came to the conclusion, that for AI the computer needs to "know thyself", of course this doesn't bring human-like intelligence
<Duns_Scrotus>
does a defun look up values from the global environment when the defun is evaluated or when the function is called
<dlowe>
Duns_Scrotus: when the function is called
<Bike>
what do you mean "look up values"? could you give an example?
<dlowe>
(you're probably thinking of the function's dynamic environment, which is by definition when the function is called)
abhixec has joined #lisp
<chumphries>
I started a new years resolution to learn common lisp to get excited about programming again and learn from folks that built stuff before me. Slacking so far, but starting this week. Never got around to fully learning common lisp even though been using emacs forever. Using Peter Seibel's Practical Common Lisp book.
krwq has joined #lisp
<Duns_Scrotus>
specifically if you re-evaluate a defun in slime, do existing functions call the old oe or the new one
<Duns_Scrotus>
the new version, ok
<Bike>
generally the new one, but there are some tricky points
<Bike>
for example, if you have (defun foo ...), then (defvar *bar* #'foo), (defun bar () (funcall *bar* ...)), and then (defun foo ...) again, bar will still call the old one
<Duns_Scrotus>
that makes total sense
hhdave has quit [Ping timeout: 246 seconds]
igemnace has quit [Quit: WeeChat 2.3]
<Bike>
also, functions in the same file as an existing function may not be updated, but in practice i think you'll only really hit that with functions that are inlined
<Bike>
(why inlining and redefinition don't work together should be obvious)
<Duns_Scrotus>
this language looks more and more like c
Zaab1t has joined #lisp
ntbre has quit [Quit: ntbre]
varjag has joined #lisp
<Bike>
yeah you know. htose crazy C rules about redefining functions
<Duns_Scrotus>
it has lvalues and rvalues, and inlining is user-visible
<Duns_Scrotus>
:)
<Bike>
as long as we don't branch out into xvalues and glvalues and stuff i think it's alright
<LdBeth>
morning ebery on
<LdBeth>
In ML languages and Clojure they just hold the old definition forever
<Bike>
does ML even have redefinition semantics? lisp is the only language i've used that does, since it was built for lisp machiens and all
<Bike>
i don't think scheme does either
<Bike>
C and C++ hae stuff about definitions in multiple modules but that's a little different
ckonstanski has quit [Read error: Connection reset by peer]
ntbre has joined #lisp
<LdBeth>
many schemes do refine, though the language report doesn't require
<ggole>
ML doesn't have redefinition at all
<LdBeth>
Yes, otherwise if you can't introduce new functions of the same name with different type
ntbre has quit [Client Quit]
iovec has quit [Quit: Connection closed for inactivity]
<phoe>
fe[nl]ix: Is the current form of my PR okay? Or should I spend some time and split it into more commits?
gxt has quit [Ping timeout: 250 seconds]
Jesin has quit [Quit: Leaving]
<verisimilitude>
If you want simplicity, look at Forth, chumphries. UNIX and C are what I brand-name simplicity that tries to take credit for existing concepts and those it adds or results in aren't actually simple whatsoever.
<verisimilitude>
Also, do you have anything in mind after PCL, chumphries?
<Duns_Scrotus>
C is not simple
<verisimilitude>
That is are what I call brand-name simplicity.
<cage_>
is there a way to check if a compiler supports utf8 encoding (checking *features* for example)?
<cage_>
non portable solution are ok :)
<verisimilitude>
Yes, cage.
<verisimilitude>
Usually, you can check for :UNICODE in *FEATURES*, but SBCL is super special and unique and cool and uses :SB-UNICODE instead just for your enjoyment.
<Duns_Scrotus>
why didn't i know that exists before
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 250 seconds]
X-Scale` is now known as X-Scale
meepdeew has joined #lisp
<phoe>
Duns_Scrotus: it is what RETURN expands into
<phoe>
BLOCK and RETURN-FROM are related concepts
xkapastel has joined #lisp
gravicappa has joined #lisp
nikkal has joined #lisp
Achylles has joined #lisp
<verisimilitude>
You may also want to look at TAGBODY, GO, CATCH, and THROW, if you haven't already, Duns_Scrotus.
<verisimilitude>
Out of these six, only CATCH and THROW are dynamic.
<Duns_Scrotus>
gotos, what a cool language
<Bike>
obviously you don't usually use goto yourself, but higher level constructs like dolist and loop are built in tagbody
<Bike>
built on*
<Duns_Scrotus>
when you want to go somewhere, goto is the best way to get there
<phoe>
Duns_Scrotus: GO is a language primitive and you don't usually use it yourself
<Duns_Scrotus>
maybe YOU don't
<phoe>
well, let me reword that
<phoe>
it generally isn't used by programmers in code directly
<phoe>
but it does allow people to write extended iteration constructs, like standard DO/LOOP or non-standard FOR and ITERATE
ggole has quit [Quit: Leaving]
<LdBeth>
MIGHT be useful for auto generating code
shka_ has joined #lisp
gxt has joined #lisp
karlosz has quit [Quit: karlosz]
Zaab1t has quit [Quit: bye bye friends]
Arcaelyx has joined #lisp
<_death>
to kill other languages, we can define an operator for each, that provides appropriate semantics. for example, we'd have a GO operator that disables the condition system, or a PYTHON operator that provides limited support for anonymous functions, or a HASKELL operator that provides a type system and a kleenex
<_death>
since Lisp will subsume these languages, and since Lisp is already dead, these languages will also be dead
themsay has quit [Ping timeout: 268 seconds]
gravicappa has quit [Ping timeout: 244 seconds]
<phoe>
clever
<sjl>
I've used tagbody and go to write simple state-machine-defining macros. But yeah, generally not used much in day-to-day code.
<shka_>
_death: you will be assimilated, resistance is futile :D
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<verisimilitude>
I'm reasonably fond of PROG and PROG*, chumphries; you may want to give this macro that combines LET or LET*, TAGBODY, and BLOCK.
<verisimilitude>
Give it a look, that is.
q9929t has joined #lisp
abhixec has quit [Ping timeout: 250 seconds]
<verisimilitude>
When something doesn't fit well with a MAP, DOTIMES, DOLIST, LOOP, et al., I generally turn to PROG or PROG*.
milanj has joined #lisp
meepdeew has quit [Remote host closed the connection]
matijja has joined #lisp
matijja has quit [Remote host closed the connection]
matijja has joined #lisp
q9929t has quit [Quit: q9929t]
sauvin has quit [Remote host closed the connection]
nikkal has quit [Ping timeout: 268 seconds]
zmt01 is now known as zmt00
Inline has joined #lisp
cage_ has quit [Remote host closed the connection]
matijja has quit [Ping timeout: 240 seconds]
dale has quit [Read error: Connection reset by peer]
dale_ has joined #lisp
dale_ is now known as dale
<borodust>
yo/
<borodust>
i need help testing a hidpi support of lib on retina mac
<borodust>
does anyone has this hardware and a will to help fellow lisper? ;p
<borodust>
no malware included
<borodust>
win+/-hidpi, linux+/-hidpi and mac w/o hidpi display is known to work, but i don't know anyone with retina mac that can invoke a couple of quicklisp commands :/
<borodust>
actually, Xach might have one around...
<sjl>
I have one at home, but I'm traveling for another week or so.
<borodust>
sjl: yay! you might be my last hope ;p it's nothing urgent - i'm gladly accept your kindness in a couple of weeks :)
<borodust>
thank you
<sjl>
Hah, no worries
nikkal has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
milivoj has joined #lisp
nikkal has quit [Ping timeout: 272 seconds]
drolax has joined #lisp
themsay has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
dvdl has joined #lisp
drolax has quit [Read error: Connection reset by peer]
<borodust>
i'm going afk till tomorrow, but if someone feels like trying out the software i mentioned, here's lil' guide: https://github.com/borodust/bodge-ui-window#install. thank you kind stranger in advance and plz, lemme know the results (pm is fine) :)
iovec has quit [Quit: Connection closed for inactivity]
<LdBeth>
well I have a 2015 model, and I’m having lunch outside
buffergn0me has quit [Remote host closed the connection]
matijja has joined #lisp
buffergn0me has joined #lisp
random-nick has joined #lisp
Achylles has quit [Remote host closed the connection]
meepdeew has joined #lisp
<fiddlerwoaroof>
borodust: working on it...
<fiddlerwoaroof>
borodust: works on my machine
<fiddlerwoaroof>
one sec, that was the external monitor :)
<fiddlerwoaroof>
I think you might not need to detect HiDPI on macs, because the display system is specified in terms of logical units, not physical ones
<fiddlerwoaroof>
At least, that's what that screenshot suggests to me :)
<borodust>
dayum
<borodust>
fiddlerwoaroof: thanks much for taking a look!
schjetne has joined #lisp
<LdBeth>
borodust: actually on my machine it's a little different
<LdBeth>
I would prefer the old school looking of motif
scymtym has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
Yeah
<fiddlerwoaroof>
motif for me :)
<fiddlerwoaroof>
borodust: I think in LdBeth's image illustrates the same problem, though, that dialog looks ~2x as big as it does on a non-retina display
<LdBeth>
Not excatly, I changed the :width and :height paramerter
<LdBeth>
So is it supposed to adapt itself to fit the window size?
dale_ has joined #lisp
dale has quit [Disconnected by services]
matijja has quit [Ping timeout: 250 seconds]
shka_ has quit [Ping timeout: 272 seconds]
rumbler31 has joined #lisp
dvdl has quit [Ping timeout: 246 seconds]
rumbler31 has quit [Ping timeout: 272 seconds]
cantstanya has quit [Remote host closed the connection]
schjetne has quit [Ping timeout: 245 seconds]
keep_learning has quit [Quit: Ping timeout (120 seconds)]
pillton has quit [Read error: Connection reset by peer]
jfb4 has joined #lisp
<aeth>
_death: Nice try, but the presence of BORDEAUX-THREADS makes implementing an accurate PYTHON impossible.
matijja has joined #lisp
Bike has quit []
cantstanya has joined #lisp
phoe has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
aeth: not really, Python's threading is an implementation detail
<fiddlerwoaroof>
of course, you'll discover all the concurrency bugs that people have hiding in their code, like people did when they switched to jruby
<aeth>
fiddlerwoaroof: Yes.
<fiddlerwoaroof>
There are GIL-less implementations, like Jython and Ironpython, however the 2->3 transition seems to have killed some of them
orivej has quit [Ping timeout: 246 seconds]
<aeth>
fiddlerwoaroof: The main alternative seems to be PyPy, which makes sense. JIT and implemented in the language itself.
orivej has joined #lisp
FoxyBoxes has joined #lisp
<fiddlerwoaroof>
That's the one that gets the most press, https://jython.github.io is older and has had some commercial uptake
<aeth>
Right, interoperability is a good thing.
scymtym has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
<aeth>
One thing CL needs is a "language platform". Yeah, there are already (obscure) foo-on-cl (including Python), but I'm talking about one level more abstract so there's better interoperability
pillton has joined #lisp
<jackdaniel>
I think there is a vaporware entry on cliki about clvm or something like that
<jackdaniel>
with an annotation, that jvm already meets all practical purposes such clvm would serve, and supporting jvm would require as much effort as supporting said clvm from existing implementations
<jackdaniel>
(minus the effort required to implement it)
<aeth>
Languages that would be interesting to integrate with CL (imo): Prolog, Scheme, Emacs Lisp, Forth, Smalltalk, an array programming language, and popular scripting languages (especially Python and JS)
<aeth>
jackdaniel: I disagree about that because a JVM language is good at Java<->Foo interoperability, with no guarantees that ABCL<->Foo interoperability is as flawless
<aeth>
A platform does tend to have a "main" language.
<jackdaniel>
I have no opinion about that, just providing the reference
<LdBeth>
MOP is essentially Smalltalk
orivej_ has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
<jackdaniel>
fwiw ecl has clr support (common language runtime), it is documented in an article about ecolisp from '94
<LdBeth>
and I don't see the neccecity of incorprate syntax
<jackdaniel>
being able to expose lisp libraries to other languages would help gaining bigger mindshare by implementing popular and secure libraries
<jackdaniel>
(in fact ecl does that in form of shared objects though it could give better performance for heavy closified code - gf dispatch is slow on ecl atm)
<LdBeth>
before CLR there was VMS's Common Language Environment, which takes a multi language ABI approch
<aeth>
jackdaniel: You could expose Lisp libraries with Foo-on-CL, though. e.g. Quicklisp has about 4,000 libraries, which isn't a lot but it isn't a tiny amount, either. Racket has about 1,200. So a perfectly-wrapped Scheme-on-CL with full QL support for every library (not possible in practice because there are code-walking macros) would overnight become the Scheme with the most libraries.
<aeth>
I haven't looked into the libraries available for Forth or Smalltalk, but I wouldn't be surprised if it's a similar situation there.
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
<jackdaniel>
sure, I like the idea of cl-python, cl-javascript and such
zotan has quit [Ping timeout: 268 seconds]
metallicus has joined #lisp
zotan has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
metallicus has quit [Client Quit]
<fiddlerwoaroof>
aeth: JVM has great language<->language compatibility
<fiddlerwoaroof>
At least for the big-name languages: Java, Kotlin, Scala, Clojure, Groovy, etc.
<fiddlerwoaroof>
The only issue is when you're using things that are language-specific features, rather than things designed to be used from Java
<fiddlerwoaroof>
But, usually, libraries have a Java API that you can use like any other Java library
charh has quit [Read error: Connection reset by peer]