karlosz has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
theothornhill has quit [Remote host closed the connection]
theothornhill has joined #lisp
aartaka_d has joined #lisp
Stanley00 has joined #lisp
aartaka has quit [Ping timeout: 252 seconds]
zeroish has quit [Ping timeout: 252 seconds]
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
Stanley00 has quit [Ping timeout: 240 seconds]
gitgood has quit [Quit: Probably away to do something really awesome]
anticrisis has quit [Read error: Connection reset by peer]
zaquest has quit [Quit: Leaving]
yoonkn has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
hjudt has joined #lisp
zaquest has joined #lisp
srji_ has quit [Quit: leaving]
yoonkn has joined #lisp
GZJ0X_ has joined #lisp
GZJ0X_ has quit [Client Quit]
srji has joined #lisp
hypercube has joined #lisp
<splittist>
have text with various fonts and colors (sic) displaying with CLIME. Now to do it properly and tidy up (:
madrik has joined #lisp
hypercube has quit [Ping timeout: 276 seconds]
Stanley00 has quit [Ping timeout: 265 seconds]
Stanley00 has joined #lisp
nicktick has quit [Ping timeout: 246 seconds]
jibanes has quit [Ping timeout: 260 seconds]
nij has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
__jrjsmrtn__ has quit [Quit: Bye !]
theothornhill has quit [Remote host closed the connection]
__jrjsmrtn__ has joined #lisp
<lukego>
splittist: wow !
<lukego>
splittist: any major gotchas? I was scared to try it :)
SN has joined #lisp
red-dot has quit [Ping timeout: 240 seconds]
SN is now known as red-dot
<lukego>
next thing I'm going to hack is ACCEPT by clicking on a presentation. probably on monday though. the big question I'm wondering is if we can avoid the (with-output-to-emacs (s) ...) business e.g. could (draw-rectangle ...) automatically initialize the CLIM state without needing that macro? I think it would be invoked on *standard-input* which would be a slime-input-stream. dunno. maybe wrong idea.
<lukego>
s/input/output/g
jibanes has joined #lisp
dhil has joined #lisp
lotuseater has joined #lisp
<easye>
Could someone point me to the irc channel where shinmera et. al. hangout (#shinkuma or something?)
<jmercouris>
shirakumo
<jmercouris>
I think
<easye>
jmercouris: thanks
<jmercouris>
no problem
hypercube has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gzj has quit [Ping timeout: 265 seconds]
hypercube has quit [Ping timeout: 250 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
saganman has joined #lisp
saganman has quit [Changing host]
saganman has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<nij>
Hello, why doesn't the following work? (typep 2 '(satisfies (lambda (x) t)))
amb007 has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
yoonkn has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<beach>
nij: Did you watch the panel discussion of ELS2021? Kevin Layer from Franz inc said something quite good. He said something like, it is easy for individual users to have wishes for this or that feature to be added, but we (i.e. the creators of implementations) are responsible for ALL our users.
amb007 has quit [Read error: Connection reset by peer]
<beach>
Plus, users typically don't understand the implications of their wishes on the rest of the system, and it is more likely than not, especially if they are not experienced implementors, to suggest something that would be catastrophic for the overall system, in particular for performance.
<beach>
Not a direct quote. More my memory of it.
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<nij>
Yeah, that makes sense.
amb007 has joined #lisp
<nij>
I threw that comment out just to see if someone can offer a reason why that's not the case.
<beach>
nij: So, as a creator or maintainer of a Common Lisp implementation, I feel that it gets really boring to listen to wishes from individual users with no knowledge of language design or compiler design.
<beach>
Yes, it is well documented somewhere. But I don't remember where.
orivej has joined #lisp
<splittist>
lukego: major gotchas my ignorance and incompetence, as usual. (:
<lukego>
screenshot or it didn't happen btw :)
<nij>
As a creator of a CL implementation, do you see why not allowing lambdas in (satisfies..)?
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<beach>
nij: The people who created the standard are probably all individually both smarter and more experienced than I am, and collectively they are totally awesome. I would have to look up the reason just as you would because I can't keep everything in my head. But you can count on nearly every decision of the standard to be well motivated.
<no-defun-allowed>
As someone who is vaguely maintainer-shaped, I have to wonder how you would interpret a (SATISFIES (LAMBDA ...)) form.
Codaraxis__ has joined #lisp
<splittist>
CLIM/McCLIM question - what is the height of an empty string? Different backends seem to have different answers: 0 or line height. (I guess this is the same as: what is the height of #\Newline?)
<no-defun-allowed>
Or rather, how to interpret the LAMBDA form in the type specifier.
<nij>
beach: I believe so! That's why I'm curious.
amb007 has quit [Read error: Connection reset by peer]
<nij>
Can learn something out of this. that's why I threw out the comment.
<no-defun-allowed>
Would it be as if the name was COERCEd to a function, possibly invoking COMPILE?
<nij>
no-defun-allowed: well, the lambda should take one input, and yes just compile that function.
amb007 has joined #lisp
<nij>
When typep is invoked, test if x satisfies that compiled function.
<beach>
nij: I much prefer such curiosity to be expressed as questions, rather than: "It'd be nice if I can put a lambda there." which sounds more like a request from a user with no experience in language design or compiler design.
amb007 has quit [Read error: Connection reset by peer]
<nij>
Common' we all know CLHS is the standard.. there's no way to change it. And there are many ways to invoke a question.. but sure I can make it a more proper question next time..
<beach>
Thanks.
amb007 has joined #lisp
Codaraxis_ has quit [Ping timeout: 260 seconds]
<beach>
You probably haven't (yet) seen all request similar to that one that we get all the time here, so you might not realize how tired one gets of trying to respond to them.
amb007 has quit [Read error: Connection reset by peer]
<no-defun-allowed>
Would it be compiled every time we call (typep foo '(satisfies (lambda ...))), making it bog slow to run in a loop, or could it be cached (or compiled with the rest of the code or ...)?
amb007 has joined #lisp
<nij>
beach: that makes sense. I will be more careful.
<beach>
"I would like nested packages", "I would like for generic functions to be able to dispatch on arbitrary types", "I would like for EVAL to have access to the lexical environment".
<no-defun-allowed>
Suppose we are terrible users and include a macro which does side effects as part of macroexpansion. In the latter case, should we specify that the function may only be compiled once? What if we don't use a constant lambda expression?
<no-defun-allowed>
Then how would you define when it is okay to cache? I suppose the most appropriate move would be to say it is undefined how many times that function is compiled.
amb007 has quit [Read error: Connection reset by peer]
<nij>
edgar-rft: i was guessing that too.. but cannot see an explicit problem.
amb007 has joined #lisp
<beach>
nij: I can't see it either. Often, you see these problems only when you are about to type the code in the compiler for handling a particular case.
<edgar-rft>
nij: you might have to ask the creators of the ANSI spec :-)
<nij>
That's what get me excited - to see one example :)
<nij>
:-) no.. I will just keep this in mind. Maybe one day I'd know.
<nij>
It says it as if using a symbol for a function doesn't have scoping problem.
<White_Flame>
no-defun-allowed: no, the user should ensure their side effects are idempotent
<edgar-rft>
nij: It might have been a problem with some specific compiler at that time or maybe it's a problem that I don't see or understand.
agumonkey has joined #lisp
<nij>
no-defun-allowed: I'd say to cache or not to cache is a general problem of lambdas without a name? That's not particular here.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<_death>
it is the reason why satisfies is not that useful to the compiler
amb007 has quit [Read error: Connection reset by peer]
<_death>
well, one reason..
amb007 has joined #lisp
<_death>
cl-su-ai also contains text saying SATISFIES comes from Interlisp, and that it took a form there.. but I don't see anything like it in the Interlisp manual.. Interlisp's TYPEP took an integer for typespec.. the various types had integers associated with them
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
igemnace has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<nij>
_death: Do you understand Guy Steele's concern?
<_death>
nij: well, the lambda has to either be interpreted, or compiled each time the function is called..
amb007 has quit [Read error: Connection reset by peer]
<_death>
(not compiled, a closure created)
amb007 has joined #lisp
<_death>
if it is interpreted, the environment must be available for interpretation
monolithic has joined #lisp
<_death>
it looks like Maclisp also had a TYPEP, but it's more analogous to CL's TYPE-OF (so badly named..)
<nij>
_death: so..? Is the env available not available in some circumstances?
<jdz>
nij: I can imagine compiler being able to reason about type checks with symbols as predicates (for instance, when a compiler can prove a value does not change between multiple such tests). With a lambda, you cannot compare the tests (variable names may differ, lexical environment must be proven to be equal, etc.). But I just conjure this use case up on the spot.
<_death>
nij: declarations are a compile-time thing, so if a closure has to be created during runtime it's kinda weird
<_death>
nij: and the end result isn't useful anyway..
<jackdaniel>
making the compiler handle things like this usually ends with kludges that make it harder to get things right
<_death>
nij: when you want "lambda in satisfies" in a useful situation, you can often generate a global function with a name (say generated by make-symbol) and use that
<jackdaniel>
(and, ultimately, modify it in the future without introducing a regression)
<jackdaniel>
and the type system in common lisp is quite elaborate already for better or worse
Nilby has quit [Ping timeout: 245 seconds]
retropikzel has quit [Ping timeout: 250 seconds]
karlosz has quit [Quit: karlosz]
v88m has quit [Ping timeout: 260 seconds]
vegansbane6963 has joined #lisp
zeroish has joined #lisp
niflce has joined #lisp
<agumonkey>
do you guys use threading macros (-> ...) a lot ?
silasfox has quit [Ping timeout: 276 seconds]
<contrapunctus>
agumonkey: I used to love them, but then I realized that it's basically a let* without local variable names acting as "comments" of sorts...so sometimes they just obfuscate code.
<agumonkey>
contrapunctus: aight
<agumonkey>
i guess my love of concise pointfree/forth-like code is showing
<nij>
x is still not available at compile-time, yes?
<contrapunctus>
Other times I can't be bothered with naming everything so I use an arrow 🙃
<phoe>
EQ 1 is undefined
<phoe>
use EQL instead
<phoe>
but other than that, (declare (type (eql 1) x))
zeroish has quit [Ping timeout: 252 seconds]
<jmercouris>
I'm looking for advice about common lisp documentation
<jmercouris>
so, typically we just have a :documentation that is some string
<jmercouris>
does anyone know of any successful systems that allow for some sort of intelligent markup?
<jmercouris>
e.g. I can reference a symbol in my documentation, and then some documentation export tool does something intelligent with it
<jmercouris>
examples include CLOD and cl-org-sampler
<jmercouris>
if nobody knows of any succesful usages of this markup, I am also interested in why that might be, and suggestions for some sort of markup
<edgar-rft>
_death: thank you for the pointers to the original discussions and historical background information :-)
<Gnuxie[m]>
jmercouris: using markup won't be portable and you have to be considerate for what it will look like when someone calls #'documentation
<no-defun-allowed>
The jmercourtis had a problem making nice-looking documentation, and thought "Oh, I'll use a documentation generator!" Then he had two problems.
* no-defun-allowed
wonders why she keeps writing jmercourtis.
<Gnuxie[m]>
that being said, it would be possible to have a macro like Shinmera's documentation utils and figure out how to offer both
<no-defun-allowed>
jmercouris, when confronted with a documentation-making problem, thought to himself, "I know, I'll use a documentation generator." Now he has two problems.
<jmercouris>
no-defun-allowed: what's your experience with this?
<no-defun-allowed>
jmercouris: My experience is that instead I wrote my own documentation in Markdown, then because I wanted a nice book, I ported to TeX. Then that made for a poor website, so I ported to Scribble.
<jmercouris>
I see
<jmercouris>
am I correct in thinking that you are from Australia, or am I confusing you with some one else?
<contrapunctus>
jmercouris, no-defun-allowed: how about making a literate program using Org?
<no-defun-allowed>
That is true, yes.
<jmercouris>
Right, and you just graduated university?
<no-defun-allowed>
contrapunctus: The problem for me has consistently been that introducing the protocol and the code feel like they should be done in different orders.
<Shinmera>
Gnuxie[m]: indeed. I think shka_ (or someone else) already did exactly this.
<no-defun-allowed>
jmercouris: No, I transferred and I'm in a weird superposition which is mostly in first year. Let's say I have 7/8 of a year down though.
<jmercouris>
OK, I will take your advice with a grain of salt
<jmercouris>
Gnuxie[m]: that is a good point!
<no-defun-allowed>
contrapunctus: Also in my very specific sitation, I want to write my implementation with a restrictive license, but the specification with a permissive one. So tangling the two would get legally tangled too.
<jmercouris>
You can use a 'licenses' directory which specifies what is licensed under what, but intermingling licenses in the same file is indeed messsy
<jmercouris>
it works pretty well, I will grant you that
<jmercouris>
I would like a single point of truth though... I don't want to make discrete sources
<no-defun-allowed>
You also have the case that a documentation string lies about what the code it documents does.
<contrapunctus>
jmercouris: I use literate-elisp for Elisp, and there's literate-lisp for CL
<no-defun-allowed>
If there is a discrepancy, I look at what I wrote down in the book, a documentation string if present, and the implementation, and decide which I meant to write. Usually it's what's in the book, and that is usually because it makes the most sense.
<contrapunctus>
jmercouris: so no tangling necessary, load the Org file as code directly.
<jmercouris>
contrapunctus: indeed
<no-defun-allowed>
That is to say that intentionally accidentally forgetting implementation details leads to documentation which convinces you to remove the painful details.
VincentVega has joined #lisp
<nij>
Wait.. people really use org to write codes?
<nij>
literate-lisp......?!
<no-defun-allowed>
Yes, literate programming is a thing people do, and you can do it with org-mode.
<gendl>
jackdaniel: perfect, thanks! I was on a fascinating journey through slime-repl.el and got as far as swank-repl:listener-eval and was trying to unwind what slime-rex is doing...
jurov has quit [Ping timeout: 260 seconds]
<gendl>
you've presented me with a wormhole to the exit
rumbler31 has quit [Remote host closed the connection]
<lowIQflatearther>
fgpa is like some kind of customizable computer?
rumbler31 has joined #lisp
<gendl>
and that printshop is running on CCL with portableallegroserve
<White_Flame>
lowIQflatearther: it's basically software-defined digital circuits
<lowIQflatearther>
so you made a lisp website but it is not a busy OLTP app?
<lowIQflatearther>
how long have you known lisp? how long to learn tools?
saganman has left #lisp ["WeeChat 2.3"]
<gendl>
well it's doing online transaction processing if by that you mean credit card etc.
<gendl>
I'm not sure your definition of busy.
<lowIQflatearther>
cool I meant something with 1,000s of user same time
<gendl>
I would tall this a proof-of-concept at this juncture.
<lowIQflatearther>
was the credit card processing part hard to setup?
<gendl>
well the scaling would be a matter of a certain amount of engineering
<gendl>
the credit card part is using Stripe and in principle is not hard to set up.
jurov has joined #lisp
<gendl>
I've known lisp for a long time but this is done with a framework which I would hope wouldn't take so long to learn.
<gendl>
as part of making that printshop I've also been cleaning up and fixing bugs in the framework along the way.
whosit has joined #lisp
<gendl>
the printshop code itself is MIT licensed but not quite released to the public yet. The framework is called Gendl and that is AGPL licensed.
<gendl>
I've worked on other CL-based systems which do handle hundreds of hits per second so I would expect the same scaling techniques could be used with this if needed.
kpoeck has joined #lisp
<gendl>
lowIQflatearther: what is your background with Lisp? what drew you to ask this question?
rumbler31 has quit [Remote host closed the connection]
long4mud has joined #lisp
rumbler31 has joined #lisp
Inline has quit [Ping timeout: 260 seconds]
notzmv has quit [Ping timeout: 252 seconds]
vms14 has joined #lisp
<lowIQflatearther>
I have slightly played with lisp....
<lowIQflatearther>
I have looked around at lisp web tools and lisp seems powerful...
<lowIQflatearther>
gendl: what is the best way to learn lisp?
<lowIQflatearther>
The goal is to make money
<lowIQflatearther>
While replacing java and .net which I hate
<lowIQflatearther>
I also hate salesforce
<lowIQflatearther>
:(
<lowIQflatearther>
Maybe I waste too much energy is disliek and hate...
<lotuseater>
no hate against Java and .net is ok :D
<gendl>
well I'm very likely biased but I would advise learning a higher level framework such as https://common-lisp.net/gendl/gendl but some may opine that it would be better to learn raw CL first.
<gendl>
but gendl still doesn't have a really smooth onboarding story - so my advice is more in principle than maybe practical at this junction
<lotuseater>
yes, lowIQflatearther there are much less books but those are way better
<gendl>
that clog looks super interesting but I think it's not really for "web" development -- it's for making full-blown GUIs and letting them be rendered in a web browser.
<gendl>
with gendl you get dependency-tracking in the server side which works with Ajax to keep track of the html page state and which sections need to be refreshed when things are changed. so you can do react-like stuff but without any client-side programming .
<lowIQflatearther>
react meaning the javascript lib where it has like popup input menu
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
<gendl>
like when you choose a number of prints on that printshop, the data entry form appears on the page -- that's using Ajax behind the scenes but the CL code on the server side is just a declarative conditional which computes the data entry section of the page -- something like `(data-entry-section (when <the number of prints is greater than zero> <the data-entry-section lhtml rendering>))
<gendl>
`(data-entry-section (when <the number of prints is greater than zero> <the data-entry-section lhtml rendering>))`
<gendl>
react meaning when the user changes one control on the page, the rest of the page updates accordingly without any explicit procedural code telling it to do so.
<gendl>
react is a framework which lets you set up those relationships declaratively (in Javascript)
<lowIQflatearther>
pjb: looks hard core
gitgood has joined #lisp
<gendl>
what looks hard core
<lowIQflatearther>
gendl: so the single page node app thing is not just hype? like devops and agile? I hate offshoreing programing too I say ban that crap and boot foriegners liek h1bvisa
<lowIQflatearther>
but Im low iq flat earther
<lowIQflatearther>
declaratively what is good about declaring?
<irc_user>
SPAs are cool. I've been looking for some good lisp options but there aren't that many.
pfdietz has quit [Quit: Connection closed]
<gendl>
some folks feel that declarative programming is simpler and easier to debug than procedural programming.
<gendl>
what is a SPA
<irc_user>
single page application
<lowIQflatearther>
another acornym curse the gods
<irc_user>
something the typical react user would make.
<gendl>
ok SPA - I guess that is what I do mostly although I don't think of it as anything special really
<lowIQflatearther>
how about instead of javascript we just use server side lisp
<gendl>
that's what I'm saying exactly!
zeroish has quit [Ping timeout: 246 seconds]
<Jachy>
There's exactly one Lisp SPA framework I heard about a while back that seemed to be getting close to replicate where ClojureScript was in 2014 with Figwheel (which is still ahead of modern JS stacks, many of which have gone the opposite way from interactive development and towards Typescript)
<gendl>
yesterday I got lectured by a frontend developer that m server-side approach is "wrong" and this kind of thing "should" be done client side with js.
<gendl>
Jachy: are you taking about client-side?
<Jachy>
Yes
<irc_user>
that's odd because server side rendering was/is a hot topic for react
<irc_user>
they were calling it isomorphic/universal or whatever
<irc_user>
it's all just words lol
<gendl>
well I guess I'm making assumptions about what react actually is. I admit I've never looked at it in detail.
<irc_user>
ClojureScript + Reagent + Reframe is really the only thing I found for client side lisp apps
<gendl>
Jacy: I'm talking about server side and so is lowIQflatearther, I believe.
<lowIQflatearther>
my idea is this 1 seelct things to act on 2 choose actions maybe many 3 choose list of targets for example I hate how in gmail I get 40 recrutier emails, I would love to 1 choose all recrutiers who emailed me, 2 choose a resume and write a littel somethign to them 3 send but in other scenaritos it would be like 1 choose 50 role playign game fiel 2 choose to email them and save them in
<lowIQflatearther>
new flder 3 choose liist of people to email the fiels and send
<Jachy>
server-side rendering == sending mostly baked HTML down the wire, just like we all did before modern JS frameworks.
<Jachy>
isomorphic == they can re-use some of the same JS code on the front-end as on the backend (e.g. Node server)
<lowIQflatearther>
:)
<gendl>
lowIQflatearther: I think that's getting a bit specific for this discussion.
<lowIQflatearther>
soorry go on
<gendl>
server-side rendering is entirely sending baked HTML down the wire. But with Ajax it can be done in a fine-grained manner.
<gendl>
and a declarative Lisp based framework such as Gendl can help a lot to keep track of which bits need to be sent and which not.
monolithic has quit [Ping timeout: 265 seconds]
<gendl>
yes, it's harkening back to the olden times when web was mainly a server-side tech.
<gendl>
I suppose I'm old-school in that sense. I've watched the web from its inception and watched the client-side ecosystem metastasize into the monster it is today.
ft has joined #lisp
<lowIQflatearther>
I don't get why client side was ever seen as good. Gimmick to sell more stuff? and half those javascript windows fail in flaky way and have to be reponed which slows user down
<lowIQflatearther>
flaky as a phone app
<lowIQflatearther>
I think client side helps big places track you
<lowIQflatearther>
is whats going on
<gendl>
that too.
<lowIQflatearther>
surveillence
<gendl>
you're not wrong.
<lowIQflatearther>
;)
<lowIQflatearther>
I love the few times in my life someone tell me that
<lowIQflatearther>
99% with my family n friend I am wronnnnnnnnggg
<lowIQflatearther>
lol
<lowIQflatearther>
of course I think they are taseless and wrong
<pjb>
lowIQflatearther: there are commercial web site implemented in Common Lisp. On of them was ViaWeb, bought by Yahoo! re-implemented in C++.
<lowIQflatearther>
ok so is your web framework making money and helping people with awesome web gui?
<pjb>
lowIQflatearther: there are other examples, but I don't know if they're high load.
<lowIQflatearther>
oow that reminds me of a paul graham thing I read one time....yeah!!! no SQL db neede wither jsut files! AWESOME
<pjb>
lowIQflatearther: this IS Paul Graham's thing!
<Jachy>
_why quote: "When you don't create things, you become defined by your tastes rather than ability. Your tastes only narrow & exclude people. So create."
<lowIQflatearther>
I think they sidestepped scaling by simply have sets of customers on a new box and got cheap freebsd box
<lowIQflatearther>
when he said the app forked a lisp interpreter that then had a conversation with the client I was like damn this guy jsut solved concurrency by cheating in wily way SO AWESOME
<lowIQflatearther>
he said eh fked continuations with closures
<lowIQflatearther>
I felt rEALLY dumb reading it
<lowIQflatearther>
but i gave me hope
<lowIQflatearther>
same feeling when I watch chuck moore of forth fame
<lowIQflatearther>
its like get input break into pieces aissign to variable put in lisp or hash then write queries to get what want
<lowIQflatearther>
I can imagine being able to do it.
<lowIQflatearther>
esp since HTML forms are part of HTML eh
gitgood has quit [Quit: Probably away to do something really awesome]
<lowIQflatearther>
the thing like a file manager where you can select all by holding shift key then hold CTL to uncheck a few of say the 40 things THATS what I want to know is it part of HTML
<lowIQflatearther>
like chooce top item hold shift choose bttom item so all chosen
<lowIQflatearther>
then hold ctl and get rid fo say item 14
<lowIQflatearther>
then copy move to new fodler paste
<lowIQflatearther>
but then instead of jsut copy maybe email or do other things
<lowIQflatearther>
did he ever open source the orig lisp viaweb?
<lowIQflatearther>
would be interesting
<lowIQflatearther>
cl-prevayler turned me on too
yoonkn has quit [Read error: Connection reset by peer]
<irc_user>
Sounds like you want a client-side SPA :P
<lowIQflatearther>
well in php I could do that on some php site I was on in like long ago times
<lowIQflatearther>
gogole drive not even yet to that level
<lowIQflatearther>
its like we get new buzzword the the ability to indicate what I want on web is regressing liek dumbing people down on phone apps
<lowIQflatearther>
barf
<gendl>
client-side has its place.
<lowIQflatearther>
radio button I think was term
<lowIQflatearther>
checkbox is what I always thought
<gendl>
but when you start talking about "one framework to rule them all" then client-side becomes a swamp in my opionion.
<irc_user>
Correct me if I'm wrong but to highlight HTML elements dynamically you need javascript running client-side.
<lotuseater>
yes i thought it is for not having to ask and wait for the server to do something
Sheilong has joined #lisp
<irc_user>
Well, CSS if you don't actually want the functionality of what he's saying.
<lowIQflatearther>
doesnt HTML itself have radio button then choose then click send and it all goes back to server gets read at data and BOOM
<nij>
Any example of a macro that'd not be great if it were written in a function?
<beach>
"in" a function?
<lotuseater>
nij, if the macro isn't well written ^^ eg not using gensyms
<beach>
nij: You mean a macro that would be great only if used outside any function?
<nij>
s/in/as/
<lowIQflatearther>
What is a gensym?
<beach>
nij: COND.
<beach>
nij: WHEN
<beach>
nij: UNLESS, OR, AND
<lotuseater>
lowIQflatearther: it's a way to not have symbol name clashing
<Jachy>
What lowIQflatearther is asking for either has to be done in JS or implemented by the browser. HTML doesn't and shouldn't specify such high level interactive behavior... But fun fact, classic HTML tables do support something like this. You can ctrl+click a cell, ctrl+click another cell, ctrl+click and drag to select multiple cells/rows, ctrl+click a selected one to deselect, and ctrl+c to copy the cell data of selected cells.
<Jachy>
(But you don't specify that behavior, it just comes for free with the browser's implementation of HTML tables. If you didn't have it, you could add it with external JS.)
<lotuseater>
nij: PUSH, POP, ... :D or DEFUN itself
<nij>
Why can't you write cond in a function?
<beach>
nij: Try it.
<nij>
as a function
<phoe>
nij: same reason why you can't write IF as a function
<beach>
First of all, the clause syntax would be illegal as arguments.
<phoe>
plus additional syntax requirements, as beach mentioned
andreyorst[m] has quit [Ping timeout: 252 seconds]
<lotuseater>
and a function evaluates its given arguments before doing something else
<phoe>
nij: remember (my-if x (print 42) (print 24))?
andreyorst[m] has joined #lisp
jimka2001 has joined #lisp
<nij>
I'm actually looking for an example to showcase why lisp macro is better than macros in other langs.
<Jachy>
Just link to loop
<nij>
Writing my-cond as a function would requires many quotes (my-cond '(c1 a1) '(c2 a2) '(c3 a3)...)
<phoe>
nij: also it wouldn't work when quoted
<nij>
And its uglier. But this is something that's specific for lisp.
<nij>
Wezl: It implements set comprehension using macros.. but why can't it be implemented using functions?
<lotuseater>
if people argue with CPP macros, that's just dumb text replacement
<beach>
nij: I think we have been through this.
<nij>
beach: we've been through "IF"
<nij>
But if is a special operator.
<phoe>
nij: COND and IF are equivalent
remby has joined #lisp
aeth has joined #lisp
<nij>
Given IF, can you write COND as a function?
<beach>
nij: Try something simpler than COND. Try OR.
<nij>
(if ugly quotes are allowed)
<phoe>
nij: as I mentioned above, quotes WON'T work
<phoe>
if you want to check, try it.
andreyorst[m] has quit [Ping timeout: 240 seconds]
<phoe>
if you are willing to wrap everything in closures, you can write IF and COND as functions
<beach>
nij: Write OR as a function, and we will show you how it fails.
<phoe>
but most of the time it isn't worth the hassle
<phoe>
and if you don't wrap everything in closures, it's not going to work.
andreyorst[m] has joined #lisp
<nij>
(defun my-or (x y) (if x x (if y y nil)))
<Wezl>
challenge: write lambda as a function :)
<phoe>
nij: (my-or (print 42) (print 24))
<beach>
nij: (my-or t (error "hello"))
<beach>
nij: Compare with (or t (error "hello"))
<phoe>
beach's version is better because it has more fireworks
<beach>
Heh.
<phoe>
and fireworks might be required in this case
<nij>
What if I use non-local jump?
<Wezl>
my-or a b = if a then a else b , except that doesn't work because haskell is statically typed (ugh) and doesn't allow kebab-case (ugh)
<phoe>
how?
<stylewarning>
To be clear, which I think some people lose in these discussions, it is perfectly OK and natural to have *an* OR-like operator that is a function.
<beach>
nij: YOU CAN'T AVOID THAT (ERROR "HELLO") IS BEING EVALUATED IF OR IS A FUNCTION.
<Bike>
it's pretty simple, nij. When you write (my-or x y), if my-or is a function, the x and y forms will be evaluated before the function is called. So nothing in the body of my-or can possibly help.
<nij>
yes..
<Wezl>
but lazy evaluation is pretty nice
Inline has joined #lisp
<stylewarning>
I think (defun MY-WHEN (if-this do-that) ...) is a better example myself
<Wezl>
then you can write it as a function and still get the benefits
<beach>
nij: That's how function-call semantics works.
<beach>
nij: It is built into the language.
fourier has quit [Ping timeout: 240 seconds]
<nij>
I see.
<nij>
I bet other langs (without lazy eval) also have their OR implemented this way.. by using macro.
cage_ has quit [Quit: Leaving]
<beach>
nij: And macros are needed when you don't want function-call semantics. Period. If you can live with function-call semantics, then you don't need macros.
<phoe>
hell no
<phoe>
they have their ORs built into the language most of the time
<nij>
phoe: oh dear..
<phoe>
imagine C's x || y sort of stuff
<phoe>
|| is a builtin operator
<nij>
In that way, they must have MANY primitive operators..
<beach>
They do.
<nij>
So the true power of () is that normal users can extend lisp as a language easily?
<beach>
`while', `repeat', `switch', `,', ...
<phoe>
nij: more like extend Lisp syntax easily
<phoe>
that's what macros are for
<phoe>
if you don't want to treat everything as function arguments, then a macro can help you
<Wezl>
syntax is everything :)
<phoe>
if you can treat everything as function arguments, then what beach and Bike said
<loli>
or as a function makes sense if your language has a way to get lazy semantics for function calls
indathrone has left #lisp ["Leaving"]
<beach>
That works for many, but not all, cases.
<Wezl>
you can write C macros that allocate a closure, or define a function, or evaluate as lisp, but you lose your speed and elegance
<stylewarning>
loli: OR as a function makes sense period
<nij>
So no wonder it's quite hard to attach another lang that doesn't have ().
<beach>
If you want to introduce new syntax, you still need syntactic extensions.
<pjb>
nij: You can have some kind of lazy evaluation with thunks, ie. closures: https://termbin.com/3d4x
<phoe>
nij: what do you mean, attach
<Jachy>
nij: Yeah. If Lisp's designers forgot to include OR, or made it a non-short-circuiting one (there's no law that says or must stop evaluating expressions after something hits true, it's just very common behavior across all languages), you could easily write your own short-circuiting one with a macro.
<nij>
They can always protect themselves by saying "Oh I never need to extend the syntax.. why would you do so?"
<stylewarning>
loli: it’s usually defined at its most primitive level as a Boolean circuit as just a functional relation
<nij>
s/attach/attack/
<loli>
in the case of match, macros are very nice, as you can extend existing forms if the macro is made right.
<stylewarning>
The fact OR turned into this short circuiting thing seems like a curious artifact of history
<nij>
I cannot type today. Soarry.
Lord_Nightmare has joined #lisp
<loli>
is it a twist of history?
<loli>
it makes sense like how cons should not evaluate its arguments
<pjb>
There is already a OR function in CL: SOME (SOME 'identity '(nil nil nil t t nil)) #| --> t |# (SOME 'identity '(nil nil nil nil)) #| --> nil |#
saganman has joined #lisp
saganman has quit [Changing host]
saganman has joined #lisp
<beach>
nij: Fortran programmers used to say "I don't need functions". C programmers say "I don't need classes".
<phoe>
loli: wait a second, that's getting weird
<_death>
you could write (defun my-or (&rest args) (some #'funcall args)) .. then (my-or (lambda () t) (lambda () (loop))) will work
<phoe>
(cons x y) should give me a (X . Y) in return?
<saganman>
loli?
<loli>
phoe: which part the extending pattern matching or the cons one?
<pjb>
OR -> SOME, AND -> EVERY
<nij>
beach: XD good point
<phoe>
"how cons should not evaluate its arguments"
<Wezl>
(it's not actually called make-thunk , it's built into the syntax)
<loli>
from lambda alone I can define all the numbers in the world, no specific number reader for me!
<lotuseater>
you mean as church numerals?
<loli>
if you want them as church numerals then sure
<Wezl>
there are numbers, it's aiming for a scheme-level amount of primitives, not like unlambda :P
<loli>
you can do many encodings though
<loli>
like you can do scott encoding, or even mendler if you feel like going out there
CL-ASHOK` has joined #lisp
<lotuseater>
there are papers by Guy Steele with "lambda the ultimate declarative/imperative"
kpoeck has quit [Ping timeout: 240 seconds]
<loli>
yeah those are a classic
CL-ASHOK has quit [Ping timeout: 265 seconds]
<lotuseater>
or in a funny talk "no, calling lambda universal is too restrictive. it is omniversal"
<CL-ASHOK`>
Nice
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
saganman has quit [Quit: WeeChat 2.3]
remby has quit [Quit: Ping timeout (120 seconds)]
<_death>
lambada, the ultimate festivity
remby has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
CrazyPython has quit [Read error: Connection reset by peer]
andreyorst[m] has quit [Ping timeout: 260 seconds]
motersen has quit [Remote host closed the connection]
motersen has joined #lisp
andreyorst[m] has joined #lisp
<CL-ASHOK`>
What's everyone working on atm?
<phoe>
a new Lisp book
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<CL-ASHOK`>
topic?
<phoe>
Lisp
<beach>
minion: Please tell CL-ASHOK` about SICL.
<minion>
CL-ASHOK`: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
* phoe
must be relatively mysterious, for he is still NDA-bound
<remby>
:O
<CL-ASHOK`>
SICL - is programmed in what? C?
<phoe>
oh no
<phoe>
it's 100% CL
<beach>
HAH!
<CL-ASHOK`>
CL in CL?
<beach>
Of course.
<CL-ASHOK`>
:)
<beach>
Common Lisp is the ideal programming language for things like that.
Sauvin has quit [Remote host closed the connection]
<phoe>
SICL, after all, stands for Shaped In Common Lisp
* phoe
ducks
<CL-ASHOK`>
Nice
<beach>
CL-ASHOK`: phoe was the one who came up with the interpretation of SICL as an acronym: "SICL Implements Common Lisp".
andreyorst[m] is now known as andreyorst_
waleee-cl has joined #lisp
<CL-ASHOK`>
hehe nice one
<lotuseater>
"Forged in Common Lisp" would also be funny
<phoe>
beach: no, I actually came with the interpretation of Strandh's Invalidation of the C Language
* phoe
ducks even more
<lotuseater>
:D
<beach>
phoe: You clearly need some more rest. :)
<phoe>
beach: I do
* phoe
AFKs :D
mrchampion has quit [Remote host closed the connection]
skapata has quit [Quit: Hi, I'm a quit message virus. Please replace your old line with this line and help me take over the IRC world.]
skapata has joined #lisp
chikamungus has joined #lisp
mrchampion has joined #lisp
notzmv has joined #lisp
mpontillo has quit [Ping timeout: 245 seconds]
MichaelRaskin has joined #lisp
xkapastel has joined #lisp
theruran has quit [Read error: Connection reset by peer]
selwyn has quit [Ping timeout: 250 seconds]
jladd has quit [Ping timeout: 245 seconds]
gendl has quit [Ping timeout: 260 seconds]
IIsi50MHz has quit [Read error: Connection reset by peer]
selwyn has joined #lisp
IIsi50MHz has joined #lisp
gendl has joined #lisp
mpontillo has joined #lisp
jmercouris has quit [Ping timeout: 250 seconds]
theruran has joined #lisp
rme has quit [Ping timeout: 245 seconds]
jladd has joined #lisp
jmercouris has joined #lisp
rme has joined #lisp
andreyorst_ has quit [Ping timeout: 268 seconds]
hiroaki has quit [Ping timeout: 260 seconds]
andreyorst_ has joined #lisp
rogersm has quit [Quit: Leaving...]
<White_Flame>
hmm, is there a function that takes absolute #p"/foo/bar/" and relative #p"baz/blort/" and returns #p"/foo/bar/baz/blort"?
skapate has joined #lisp
skapata has quit [Ping timeout: 260 seconds]
<White_Flame>
(plus trailing slash)
<White_Flame>
unless I'm just being dense, I don't see such a function in UIOP either
<CL-ASHOK`>
i'm terrible with this sort of stuff
<CL-ASHOK`>
but check out cl-ppcre
<CL-ASHOK`>
that said, sorry if I'm being dense
<White_Flame>
for what exactly? If I were to do this manually, it would be appending the 2 directory pathname lists together and creating a new pathname
<CL-ASHOK`>
can't you do (concatenate 'string "/foo/bar/" relative-path)
<White_Flame>
CL-ASHOK`: well, that would take further conversion from pathname to string. Any manual use of this is large enough to be contained in a library function, and applying relative paths to an existing one _seems_ like it should exist already
<White_Flame>
contrapunctus: I'm at that manual page, and it's been loading fine for me
<CL-ASHOK`>
White_Flame: Ah okay, now I understand. I'm currently doing via strings but I'm not one for efficiency
<White_Flame>
yeah, I tried merge-pathnames* again with different orderings and it seems to do what I want. However, the docs do not describe this behavior
<White_Flame>
hmm, yeah, I think the proper conclusion here is that yes, I was being quite dense
<pjb>
Note that a directory pathname could contain a version! If you use it as :defaults to make-pathname or with merge-pathnames with a file pathname, you could get a file pathname with a version…
<pjb>
So NIL.
andrei-n has quit [Quit: Leaving]
<CL-ASHOK`>
How do you guys manage large codebases?
<CL-ASHOK`>
I have 8 lisp files, and things are starting to get unwieldy, I forget parts of the code I wrote before
gigetoo has quit [Ping timeout: 252 seconds]
zeroish has joined #lisp
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
irc_user has quit [Quit: Connection closed for inactivity]
orivej has quit [Ping timeout: 240 seconds]
cer-0 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
fox_ has joined #lisp
hiredman has quit [Ping timeout: 240 seconds]
silasfox has quit [Ping timeout: 260 seconds]
anticrisis has joined #lisp
contrapunctus has joined #lisp
<Bike>
well defined specifications mostly
<Bike>
since it's easier to remember "X function does Y" than the whole source text of X
cer-0 has quit [Ping timeout: 246 seconds]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
<CL-ASHOK`>
that's true
cosimone has joined #lisp
<pjb>
CL-ASHOK`: 8 files is not large :-)
<White_Flame>
M-. is your friend
shka_ has quit [Ping timeout: 240 seconds]
<White_Flame>
and you are using an .asd file, right?
<CL-ASHOK`>
pjb: :-) I know....but for beginners its hard because I have some bad habits ;) Like storing functions in the wrong files cause I'm lazy to think which is the best place to put them :D
<pjb>
CL-ASHOK`: even 323 files, 152529 LOC is not really large, it's just a normal-sized application.
<pjb>
CL-ASHOK`: nowadays, there's little reason to use a lot of small files.
<White_Flame>
it's easier to have multiple files open than the same file in different places, htough
<pjb>
CL-ASHOK`: our computers have large RAM, and fast SSD, so you can have a small number of large files.
<White_Flame>
smaller files are definitely for humans, not machines anymore
<pjb>
CL-ASHOK`: the only thing is that in lisp, some definitions need to happen at compilation-time, so it is easier to have them in separate files, to be compiled and loaded, before we compile the rest. eg. defpackage, defmacro, defconstant.
<CL-ASHOK`>
White_Flame: How to use? Looks really interesting. I tried it and then typed psql::function-name (stored in package psql), but it didn't give me the doc string
<White_Flame>
M-. jumps to the definition of the symbol that your cursor is on
<White_Flame>
and so for your code, you can navigate pretty easily using that
<White_Flame>
regardless of files
<pjb>
now the grouping of definitions in logical units should be helped by tools such as emacs. We can use ^L in emacs buffers. But it would be nice to have something better. Like the Smalltalk Browser (systems|classes|categories|methods) and stuff like that.
<CL-ASHOK`>
White_Flame: Mind *Blown*. Is there a way to go back to the original spot?
<White_Flame>
M-,
<pjb>
In emacs, we could tag toplevel forms (this would be mostsly done automatically from the context, but we could add or change tags explicitely) and then emacs would provide a tag browser.
<CL-ASHOK`>
pjb: I do like smaller files since Emacs has terrible scroll...
<pjb>
CL-ASHOK`: ok.
<pjb>
CL-ASHOK`: you can use registers to jump back.
<CL-ASHOK`>
White_Flame: Thanks! Owe you a beer for that
<CL-ASHOK`>
pjb: Interesting, I will check that out now