<jasom>
There are enough "dimensions" to equality that it seems like an entire library could be written just devoted to equality (depth to descend, which structures to descend into, and which comparison operators for comparing terminals)
<phoe>
the famous kent paper describes this
<phoe>
minion: tell phoe about equality
<minion>
equality: I can't be expected to work when CLiki doesn't respond to me, can I?
<phoe>
(animal-farm-p x y :descend-into '(:darkness))
fengshaun has joined #lisp
theothor` has joined #lisp
<jasom>
(animal-farm-p x y :depth 3 (terminal-test (rassoc #'animal-farm-p :descend-into '(:vector :structure :hash-table) :terminal-test #'compare-alist-or-equal)) ;; <-- there we go "treat the first 3 levels of lists as lists, and any deeper lists as alists...
<jasom>
s/rassoc/rcurry
<_death>
(compare x y '((number =) (string equal) (vector element >) (hash-table :test equal) (my-class slot x eq slot y equal)))
fengshaun_ has joined #lisp
<_death>
maybe (compare x and y using ...) to satisfy the kneejerks
Lord_of_Life has quit [Ping timeout: 246 seconds]
theothor` has quit [Ping timeout: 264 seconds]
fengshaun has quit [Ping timeout: 265 seconds]
<phoe>
_death: oh no
<_death>
what, you don't like (compare p1 and p2 using key native-namestring and test equal when type-error return 'maybe) ?
<_death>
add quotes/hashquotes as necessary
<phoe>
how would you describe a predicate for threefold nested lists, the outermost compared via EQUALP, the middle via EQUAL, the innermost via EQL?
Anonymous_ has quit [Remote host closed the connection]
<_death>
seems you want an "except on type" clause
andreyorst has quit [Ping timeout: 240 seconds]
gjnoonan has left #lisp ["WeeChat 3.0.1"]
theothor` has joined #lisp
andreyorst has joined #lisp
theothor` has quit [Ping timeout: 240 seconds]
Veera11 has joined #lisp
Veera11 is now known as Vee_ra
Vee_ra has quit [Client Quit]
Veera has joined #lisp
Veera has quit [Client Quit]
theothor` has joined #lisp
Veera has joined #lisp
theothor` has quit [Ping timeout: 256 seconds]
carkh has quit [Remote host closed the connection]
johnjay has quit [Ping timeout: 256 seconds]
theothor` has joined #lisp
johnjay has joined #lisp
ukari has quit [Remote host closed the connection]
theothor` has quit [Ping timeout: 256 seconds]
attila_lendvai_ has quit [Ping timeout: 240 seconds]
theothor` has joined #lisp
abhixec has quit [Quit: leaving]
theothor` has quit [Ping timeout: 240 seconds]
renzhi has joined #lisp
iskander has quit [Ping timeout: 272 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
<gj>
but would one still be able to write it as (- n 1) ?
<mfiano>
Yes, +1 and -1 is such a common thing that it is it's own function
johnjay has joined #lisp
<mfiano>
Yes
<gj>
oh that is interesting, thanks
<beach>
gj: Yes, but there is a very general rule in programming, namely that one should use the most specific construct that will do the trick.
<ey[m]>
1+ is a function that does the same thing as (+ n 1)
<ey[m]>
1- the same thing
adam4567 has joined #lisp
opcode has joined #lisp
<theothornhill>
It may be obvious, but it wasn't to me when I first learned CL: (1+ x) is not the same as (incf x) bit be a couple of times
drot has joined #lisp
<beach>
gj: Imagine (- <very-long-expression> 1) vs (1- <very-long-expression>) In the first case, the person reading your code will have to wait until after <very-long-expression> to understand what is subtracted. In the second case, that person will know immediately from reading the operator.
adam4567 has left #lisp [#lisp]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<gj>
that makes sense, thank you
frodef`` has quit [Remote host closed the connection]
cosimone has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
frodef`` has joined #lisp
shka_ has quit [Ping timeout: 256 seconds]
jonatack_ has quit [Read error: Connection reset by peer]
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
imode has quit [Ping timeout: 256 seconds]
frodef`` has quit [Remote host closed the connection]
gj has quit [Quit: Connection closed]
frodef`` has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
shka_ has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
equwal has joined #lisp
nydel has quit [Ping timeout: 265 seconds]
attila_lendvai_ has joined #lisp
nydel has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
davd33 has quit [Ping timeout: 265 seconds]
toorevitimirp has quit [Remote host closed the connection]
<nij>
comparing to writing python codes using the python lang itself.
galex-713 has joined #lisp
<jmercouris>
nij: many
<jmercouris>
installing python is going to be far fewer steps for one
<equwal>
I've seen so many projects like this. They all seem like a half-baked bad idea to me.
<jmercouris>
secondly, syntax highlighting...
<jmercouris>
they are all a half baked idea
<jmercouris>
if you really must use some Python library, you will want to write a wrapper for it, using it directly is oft too painful
<nij>
jmercouris: yeah i really want to know why it's half-baked.
<jmercouris>
even CCL's famed objective-c bridge is difficult to use
<jmercouris>
I got quite into it, and had my fair share of issues
<nij>
is this theoretically improvable?
<nij>
or it's just a thing the be dealt with while talking foreign
<jmercouris>
foreign languages have different concepts that don't necessarily map well to lisp
<nij>
taking in a foreign lang*
<jmercouris>
there is always some impedance mismatch, hence so many problems
<equwal>
The only one I might be able to get behind is the APL one. Embedded APL seems potentially really good, for very specific kinds of programming. To convince me, show that the embedded language provides an actual benefit
<jmercouris>
CFFI which is a 'solved' foreign interface is not exactly fun, pleasant, or easy ot use
<jmercouris>
s/ot/to
<nij>
hmm.. would you plz give an example of python? Like, what python concept maps badly to lisp?
<jmercouris>
well, it is easy
<jmercouris>
but not fun or pleasant
narimiran has joined #lisp
<jmercouris>
here's a concept, python uses lightweight threads
<jmercouris>
what if you had multiple bordeaux threads running calling python
<jmercouris>
would they each be calling a different process? the same one?
<equwal>
The problem is: why do you need this complication? It is a high cost, what is the offsetting benefit? I see none yet.
<jmercouris>
how do they share any state/
<jmercouris>
usually it is a crutch for people who are familiar with some language or library
<jmercouris>
and they want to keep using it
<nij>
equwal: writing in lisp is much funnnnner than in py
phantomics has joined #lisp
<equwal>
I don't buy that. To take a line from the Rust community 'Write it in <LISP>!'
<jmercouris>
lol, we should get some NIH here
<nij>
equwal: <LISP>?
<equwal>
If it is more fun, then just do it then.
<jmercouris>
<LISP> IS MEMORY SAFE, we must rewrite all C programs in Lisp
toorevitimirp has quit [Remote host closed the connection]
<jmercouris>
let's rewrite CURL in Lisp
<equwal>
There are all these carbon-copy programs in Rust, it is kind of their thing, to make ripoffs.
<jmercouris>
I wonder why
<jmercouris>
I've come so close several times to learning rust
<equwal>
The subtle hint here is that I think this is stupid. If it is a little program written in C, leave it alone
toorevitimirp has joined #lisp
<nij>
jmercouris: hm. So, but in this example why can't we just specify which process the bordeaux thread should be poointing at?
<jmercouris>
nij: I don't know, CAN YOU?
<jmercouris>
does py4cl give you a easy way to do that?
<equwal>
nij: If you need something from threads, you can write in in Lisp.
<nij>
yeah..
<nij>
I want to do it cuz the py-community obviously has a larger library
<nij>
if we can steal that without penalty, i'd be more than glad to do it
vegansbane6963 has joined #lisp
<equwal>
I can get behind a carefully considered decision to use CFFI or April's APL
<equwal>
APL's original purpose was for handwriting computations in Linear Algebra in front of Iverson's class, and anything close to that is exteremely well-fitted to APL, otherwise APL can be useless for that problem.
<equwal>
nij's idea to use Python in Lisp makes little sense comparatively, since Python hardly provides any additional value and isn't anything like a DSL.
<phantomics>
I'll be the first to tell you that APL isn't a general-purpose language, it's special purpose, if your problem fits it it can give a huge performance boost, if not then use Lisp
jurov has quit [Ping timeout: 240 seconds]
<equwal>
phantomics: Exactly which is why I mentioned your project. Are you aware of the niche project where APL is used as a GPU-only compiler?
<phantomics>
Productivity boost, I should say
<phantomics>
Yes, you mean co-dfns?
jurov has joined #lisp
jurov_ has quit [Ping timeout: 272 seconds]
<nij>
equwal: how about the libraries the python community has created?
<equwal>
nij: I can't get behind the fad of having a confusing 'stack' of 'technologies'. It makes sense to use C libraries from lisp; C is a kind of portable ASM upgrade. Why does it make sense to use python libraries from Lisp? Too complicated. fail.
<equwal>
Anyway this paper was really convincing to me. Every time I have shown it to someone familiar with Statistics 101 I get a very particular reaction.
<phantomics>
That's a more valid reason to use python integration, if there's a library you need for something and don't have time to implement it in Lisp, py4cl can get you there faster
<phantomics>
Thanks for the paper equwal, reading it
<lukego>
Hey what's a good parser library for extracting fragments of text from mostly unstructured data? (Specifically for skimming out a couple of tables from a document that's been converted from PDF to text.)
<phantomics>
lukego: have you looked at MaxPC?
<equwal>
Well, if you are engaging in cheap hacks that are obviously bad, then fine, but don't expect anyone to say 'wow that is a great idea'
<phantomics>
It's always preferable to implement something in straight Lisp, but if you need to get something done right away, that may not be an option
<equwal>
I suppose. I'd just use some cheap shell hacking for that, CL kind of sucks for writing throw-away programs in my experience.
toorevitimirp has joined #lisp
<lukego>
phantomics: thanks for that pointer! hadn't seen (but know Max well)
<Nilby>
jmercouris: What feature do you want from curl that drakma doesn't do?
<equwal>
Here is 99% of my curl usage: curl --no-progress-meter 'wttr.in/Santa%20BARBARA,USA'
<phantomics>
equwal: I've used it for some useful throwaway things, but also if you're writing a significant application and you need something from Python, I'd rather put a Lisp app into production with some Python add-ons than a straight Python app
<phantomics>
And then over time work to reimplement the Python stuff in Lisp
enzuru has quit [Ping timeout: 265 seconds]
<equwal>
I can understand this use case. Seems too complex to me, why not write your Python hacks separately and keep your Lisp pure?
<equwal>
I did a project when I was in College with another student. He only knew python, so I just called his program with uiop:run-program.
<nij>
Does this really get you game of life?
toorevitimirp has quit [Remote host closed the connection]
<phantomics>
Yes, that function calculates the next generation of a life matrix
<Nilby>
equwal: nice, but what renders it for you?
toorevitimirp has joined #lisp
<nij>
jeez i should learn APL
<equwal>
I did a project when I was in College with another student. He only knew python, so I just called his program with uiop:run-program.
<equwal>
oops, sorry
<nij>
xD
<equwal>
nij: APL is has the highest ratio of 'totally cool, dude'/'what is that?' of any language. Kind of sad it is forgotten. I used it to mess around in my notebooks during my stats 101 course.
<phantomics>
Keeping Lisp pure is what I'd aim for, I haven't needed to directly generate Python yet, just envisioning use cases
<nij>
equwal: what's your favorite bible for APL?
<nij>
down for it
<nij>
i'm looking for notations that allow compact expressions
<nij>
apl seems pretty nice
<phantomics>
If you want to learn APL, I recommend: tutorial.dyalog.com
<phantomics>
This tutorial uses really primitive technology, but the quality of the material is superb
<nij>
The better; the nicher!
<nij>
Sad fact.
<nij>
phantomics: thanks for the recommendation. I care only about the content ;)
toorevitimirp has quit [Remote host closed the connection]
<equwal>
nij: dyalog stuff is good I guess. I could do without the profit-mongering/business attitude in what is left of APL.
<phantomics>
You don't need to pay for the tutorial, and April is patterned after Dyalog, so learning Dyalog can be applied to April, also to dzaima/APL, another FOSS APL built on Java
<phantomics>
What kind of things are you interested in doing nij? There are other languages in the same vector language family as APL that you can also look at
<nij>
equwal: so, I get it's ability to express (soooo!) compactly
<equwal>
nij: I like the finnapl idiom library and the microapl.com documentation.
<nij>
or an apl wizard, can they understand meanings from an apl expression quickly without confusion?
<nij>
phantomics: higher algebra in mathematics
<nij>
still exploring
<equwal>
It takes forever to read APL. It is fun, you can do magic tricks with it.
<nij>
equwal: thakns
<nij>
:(
<phantomics>
APL's a good choice for that, especially if you want to work with higher-rank arrays
Major_Biscuit has quit [Ping timeout: 256 seconds]
toorevitimirp has joined #lisp
<jackdaniel>
please keep in mind this channel's topic
<equwal>
I his ELS paper (paraphrased) we have these machines doing huge numbers of perations, all these tiny transistors, gigantic amounts of storage, and you can't figure out how insert a weird character into a text editor?
<phantomics>
And special characters are useful in Lisp too
nij has joined #lisp
<equwal>
Sorry to burn your ears Heisig.
<phantomics>
For example April uses a macro called λωα which expands thusly: (λωα (+ alpha omega)) => (lambda (omega alpha) (+ alpha omega))
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
nij has quit [Remote host closed the connection]
nij has joined #lisp
<equwal>
I have a hard time with extensions to APL like this BQN. APL is complex enough, please stop trying to extend it! If anything, I want less stuff in my APL.
<jackdaniel>
equwal: phantomics: these things seem to be offtopic on this channel, could you please move it to i.e #lispcafe ?
<jmercouris>
do you think it would be likely that a paper about Nyxt may be accepted into the ELS?
<jmercouris>
should I make a submission?
<phoe>
I think you should
<phoe>
even if, for whatever reason, it does not make it into the ELS program, I will have a reason to bother you for recording a video for the Online Lisp Meetings
prxq has quit [Remote host closed the connection]
<jmercouris>
:-D
prxq has joined #lisp
<Nilby>
Do you know if there's somewhere where those FOSDEM videos were archived?
aggin has quit [Remote host closed the connection]
aggin has joined #lisp
aggin has quit [Remote host closed the connection]
<hhdave>
jmecouris: it looks interesting. It was previously known as 'Next browser' wasn't it? I must have a play with it. It seems to have progressed quite a bit since I looked at it.
aggin has joined #lisp
mrcom has quit [Ping timeout: 265 seconds]
<hhdave>
(jmercouris I mean)
devon has joined #lisp
<Nilby>
hhdave: My opinion is it's progressed significantly recently.
ljavorsk has quit [Ping timeout: 240 seconds]
<flip214>
How do I upgrade a BASE-STRING to STRING? COERCE doesn't help, ADJUST-ARRAY gives an error, MAKE-STRING only allows a single INITIAL-ELEMENT, MAKE-ARRAY wants a list for :I-ELEMENTS....
<jmercouris>
hhdave: you are correct
<Bike>
flip214: base strings are strings. do you want a character array specifically?
<Colleen>
Bike: drmeister said 8 hours, 29 minutes ago: Here's my current plan for image-save...
<flip214>
Bike: the problem is that passing "http://localhost/?a=%c3%b6" breaks in PURI, as it wants to decode the string into a COPY-SEQ of the input - but if the input is a BASE-STRING, the "ö" isn't accepted
<Bike>
(coerce base-string '(simple-array character (*))) maybe
<Nilby>
jmercouris: Thanks! I couldn't find it on the main site.
<jmercouris>
Yeah, it’s not well documented IMO
Inline has joined #lisp
mrcom has joined #lisp
zaquest has quit [Quit: Leaving]
aggin has quit [Quit: WeeChat 3.0]
aggin has joined #lisp
cosimone has quit [Quit: cosimone]
cosimone has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
zaquest has joined #lisp
Wezl has quit [Read error: Connection reset by peer]
Wezl has joined #lisp
waleee-cl has joined #lisp
sunwukong has quit [Ping timeout: 256 seconds]
fubbiquantz has quit [Ping timeout: 258 seconds]
Alfr has quit [Ping timeout: 260 seconds]
Wezl has quit [Read error: Connection reset by peer]
Wezl has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
contrapunctus has joined #lisp
cosimone has quit [Quit: cosimone]
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 264 seconds]
X-Scale` is now known as X-Scale
sunwukong has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
Inline has quit [Quit: Leaving]
Inline has joined #lisp
villanella has joined #lisp
Wezl has quit [Read error: Connection reset by peer]
Wezl has joined #lisp
Alfr has joined #lisp
aggin has quit [Quit: WeeChat 3.0]
jonatack has quit [Ping timeout: 258 seconds]
varjag has joined #lisp
hiroaki has joined #lisp
skapata has joined #lisp
bilegeek has joined #lisp
cage_ has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
theothornhill has joined #lisp
jonatack has joined #lisp
sunwukong has quit [Quit: Leaving]
Major_Biscuit has quit [Ping timeout: 240 seconds]
froggey has quit [Ping timeout: 246 seconds]
Cymew has quit [Ping timeout: 272 seconds]
noobineer has quit [Ping timeout: 258 seconds]
froggey has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
mrcom has quit [Ping timeout: 265 seconds]
amb007 has joined #lisp
rabbit_05 has joined #lisp
rpg has joined #lisp
jonatack_ has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
jonatack__ has joined #lisp
jonatack_ has quit [Read error: Connection reset by peer]
pankajsg has quit [Ping timeout: 272 seconds]
jonatack has joined #lisp
hendursa1 has joined #lisp
jonatack__ has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
karlosz has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
theothornhill has quit [Ping timeout: 240 seconds]
jonatack has quit [Ping timeout: 258 seconds]
jonatack_ has quit [Ping timeout: 240 seconds]
aindilis has joined #lisp
<contrapunctus>
Thinking of writing a Git frontend for Gemini. There's Shinmera's `legit` and fourier's `git-api`; neither has had a commit since 2019; the latter does not require a Git binary, although that's not a big deal at least for my personal situation. What do y'all say? 🤔
<contrapunctus>
scymtym: thanks, that sounds like a more thorough approach
<phoe>
contrapunctus: "neither has had a commit since 2019"
<phoe>
maybe it didn't need one?
<contrapunctus>
phoe: git-api says, "Work in progress!!!"
orivej has joined #lisp
<phoe>
talking about legit here
<contrapunctus>
Yeah, that one sounds like it's more or less where the author wants it to be - v1.0.0, and "I will add features as they are needed. The low-level command API is fully mapped however."
jonatack_ has joined #lisp
skapata has quit [Remote host closed the connection]
varjagg has joined #lisp
karlosz has quit [Quit: karlosz]
miasuji has joined #lisp
hjudt has quit [Ping timeout: 256 seconds]
karlosz has joined #lisp
<rpg>
Unlikely any system is bulletproof enough to have required no patches in more than a year if it's in use.
long4mud has joined #lisp
jonatack_ has quit [Quit: jonatack_]
jonatack has joined #lisp
sauvin has quit [Ping timeout: 256 seconds]
jcowan has joined #lisp
<jcowan>
A question about actual functioning applications rather than the standard: are there any CLs that don't (a) provide at least 24-bit fixnums (b) have EQ work correctly on fixnums?
<jcowan>
s/applications/implementations
__jrjsmrtn__ has joined #lisp
jeosol has joined #lisp
<semz>
you can easily test (a) programmatically for what it's worth
_jrjsmrtn has quit [Ping timeout: 272 seconds]
mister_m has quit [Ping timeout: 240 seconds]
hjudt has joined #lisp
<jcowan>
Yes, if I had a lot of Lisps installed.
<semz>
I mean in the program that relies these two conditions.
<semz>
Since I assume you had a concrete use in mind
<semz>
relies on*
aartaka has joined #lisp
<jcowan>
I'm doing a feasibility study to see if Interlisp can be implemented in Common Lisp. There are a bunch of places in which IL is overspecified, like what the size of a fixnum is (17 bits) and that fixnums are reliably EQ.
<jcowan>
The main benefit of this effort would be to have something faster than the Interlisp bytecode compiler.
aartaka_d has quit [Ping timeout: 246 seconds]
<jcowan>
I guess the simplest approach is to install a bunch of CLs and test on them. Which ones should I test things like this on?
<Nilby>
I'm sure it could be worked out. Maybe you could just make a fixnum be an (integer 0 131072) or something and have a compiler macro for reliable-eq.
mister_m has joined #lisp
<semz>
Assuming I understand your question correctly, CCL fits your bill. As should most current implementations, SBCL is probably more popular. I'm just confused that you ask for "any impl that doesn't", as if you're trying to make it work on as many implementations as possible. You explicitly said the standard is no concern, so shouldn't it be enough to find one or just ensure it for the most common impls?
<semz>
I feel like I'm missing something
srandon111 has joined #lisp
<jcowan>
I would like it to be as portable as possible while still conforming to the IL standard, such as it is.
<Nilby>
I imagine it would be very rare code that cared how small, rather than how big, a fixnum is.
<jcowan>
It's more that IL code is written to rely on fixnums being EQ
<jcowan>
they are 17-bit in IL, whereas the ANS sets a lower threshold of 16 bits.
<edgar-rft>
jcowan: fixnums and EQ work only on very old computers reliably, because EQ compares memory pointers but on modern multi-level cache CPUs fixnums can also be stored in CPU registers and other places. That was the main reason why EQL was introduced, EQL is guaranteed to work reliably with fixnums in all memory places.
<jcowan>
So perhaps TRT is to implement IL:EQ with CL:EQL
<Nilby>
I imagine a litte eq tweaking in a package would suffice. One cool thing about CL packages is: you don't have to :use the CL package.
cosimone has joined #lisp
enzuru has joined #lisp
<jcowan>
Which leads to another question
<Nilby>
I have a vague recollection of some other Lisp, probably a commercial lisp, from the early Common Lisp era being able to run Interlisp code.
<jcowan>
Medley, the IL environment, has a CL in it, roughly CLtL2--.
jonatack has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
sauvin has joined #lisp
Josh_2 has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amplituhedron has joined #lisp
amb007 has joined #lisp
vms14 has joined #lisp
waleee-cl has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
waleee-cl has joined #lisp
<Josh_2>
Hi, is there a nice way to export symbols related to functions, classes and accessors from my package?
amb007 has joined #lisp
<Josh_2>
obviously I could type them out but that'll take a while
<jcowan>
If IL:EQ is to be implemented as CL:EQL, and assuming the compiler can inline the latter, what is the best way to make sure that property is not lost? Declare it inline, use a compile-time macro, something else?
jeosol has quit [Quit: Ping timeout (120 seconds)]
hjudt has quit [Ping timeout: 272 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
jeosol 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
<Nilby>
I'm not sure how it could get lost. Compilers seem pretty good about that.
thelounge7191 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
thelounge7191 has quit [Client Quit]
amb007 has joined #lisp
theothornhill has joined #lisp
<jcowan>
I'll need to have (defun eq (x y) (cl:eql x y)) so that it exists as a function for the benefit of higher-order functions, but I don't suppose the compiler is likely to be smart enough to see that this is just cl:eql under the covers.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Nilby>
They are smart enough.
<jcowan>
Ah, good.
<Nilby>
Also there's other ways, like (setf (fdefinition eq) (fdefinition cl:eql)).
<jcowan>
So the compiler actually checks whether the fdefinition of a function is the same as that of a known function?
amb007 has quit [Read error: Connection reset by peer]
<Nilby>
I'm not a compiler expert, but I don't think so. Rather a call to a function that only calls another function with the same arguments is an easy target for optimization. When you set the definintion, it just calls whatever it's set to.
amb007 has joined #lisp
<Nilby>
or whatever it can prove is equivalet code
<Nilby>
I think these detail of porting Interlisp would probably work out. I would guess that the hard part might be some kind of custom I/O routines, libraries or something?
aartaka has quit [Ping timeout: 272 seconds]
frodef``` has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
frodef`` has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
nij has joined #lisp
<nij>
For those who use lisp repl as main shell, which cronjob service do you use?
<jcowan>
The hard thing so far is NLAMBDA, the variant of LAMBDA that does not evaluate its arguments. That may be a showstopper altogether. Some NLAMBDAs can be mechanically converted to macros, but probably not all of them.
<jcowan>
see "Fexprs Considered Harmful"
rogersm_ has quit [Quit: Leaving...]
amplituhedron has quit [Remote host closed the connection]
<nij>
should be a video up soon too. very excited.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Wezl has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Wezl has joined #lisp
<Nilby>
jcowan: I converted some code from old Lisp that used fexprs and I just made a short define-fexpr macro which seemed to work. I'm sure one can make an nlambda macro too.
<jcowan>
Do you still have the macro somewhere?
<Nilby>
Let me check...
amplituhedron has quit [Quit: Leaving]
miasuji has quit [Ping timeout: 272 seconds]
vms14 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
theothornhill has quit [Remote host closed the connection]
Inline has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
<Nilby>
jcowan: I think the techinque used here https://plaster.tymoon.eu/view/2287#2287 wouldn't be appropriate for IL, but probably should work with a slighly modified apply function. But you can get the idea. An FEXPR in CL can basicaly be a function and macro. But you should probably ask someone who work on compilers.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<jcowan>
Thanks
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Nilby>
I'm pretty sure I've seen code the does nlambda in CL, since I think old Maclisp had nlambda.
<Nilby>
Also, some hacker ethic dictates, never take "it can't be done" for an answer.
<jcowan>
It can always be done with another layer of indirection, yes. But the right thing to do when trying to emulate a Lisp in which compiled functions are represented by their addresses as fixnums is to say hell no.
aindilis has quit [Remote host closed the connection]
theothornhill has joined #lisp
<Nilby>
A function boils down to an address in CL and every langauge, it's just Lisp has quite a bit of other information about it. A symbol is really just a number too. All the other detail can be stored separately. Anyway even if it's a 10x slowdown, it still be 1000x faster than the old hardware ran it.
cosimone has joined #lisp
<prxq>
it's all bits if you look closely enough. And heaps of cranky assembly.
aeth has quit [Ping timeout: 264 seconds]
aeth has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<nij>
it's all particles are waves if you look even closer
<jasom>
I installed a reader macro for every single character in unicode to get that to work; I agree that a readtable entry for tokens would be wonderful.
<jasom>
If you are willing to limit yourself to the initial character of symbols being in latin-1, you can do it without making the readtable gigantic
<jasom>
s/latin-1/latin-1 or any other small subset of unicode/
<Nilby>
jasom: Sounds like you could have used *read-inter* too.
<jasom>
phoe: I think they were responding to my comment about restricting package names to start with latin-1 in order to get custom interning
<nij>
phoe: you're super quick
<nij>
yeah i know xD
<phoe>
jasom: oop, yes
<nij>
s/xD/😂😂😂
<jasom>
https://github.com/jasom/spm-reader/blob/master/spm-example.lisp <-- don't use this in production, but this uses the keyword package as the root, so you can do :foo:bar:baz for absolute referencing and foo:bar:baz for referecning things relative to *package*
Wezl has quit [Read error: Connection reset by peer]
Wezl has joined #lisp
<jasom>
Nilby: hookable interning would also have made package-local-nicknames implementable as a library
<Nilby>
I've been using it for years. It solves many problems.
<_death>
eclector is great for such things
<jasom>
Nilby: that's SBCL only, right?
Inline has quit [Remote host closed the connection]
<jasom>
_death: nice; I don't think that existed when I did the spm-reader. I used pjb's lovely implementation, which required making spm-reader GPL licensed.
heisig has quit [Quit: Leaving]
<phoe>
yes, eclector is a fairly recent development
<Nilby>
I did it to ccl and ecl too. It's a very easy pactch.
<phoe>
Nilby: nice
<Nilby>
I use eclector as a workaroud on unpatched lisps, but it's a pretty heavy workaround.
<Nilby>
You'd be suprised how many things that enables.
<jasom>
I would rather it were an extra field in the readtable than its own special, but I would take anything if it would be upstreamed
<Nilby>
phoe: I bet if you asked every implementaion to accept *read-intern*, it might actaully happen.
<Nilby>
phoe: You're like the first in a long time to make a nearly universal defacto change like PLN.
<phoe>
uhhhh
<phoe>
I didn't make PLN
bilegeek has quit [Quit: Leaving]
<phoe>
I only implemented it in CCL, really
<phoe>
which was like the last missing puzzle, other than CLISP which got an implementation by mood_ not long afterwards
ezekielwordswort has joined #lisp
<Nilby>
I don't know, but it seems like you got the momentum goiing for it to be complete
<phoe>
I kinda guess so
<phoe>
again, it wasn't *that* much work to be done when I started the work on the CCL implementation
<ezekielwordswort>
hey did you guys know that typing "!cliki" on duckduckgo takes you to cliki automatically, i mean its not really useful but its quite neat to know
<phoe>
SBCL, ECL, Clasp, ACL, ABCL, these all already supported PLNs
<phoe>
ezekielwordswort: TIL!
<Nilby>
thankfully SBCL and CCL have essentiall the same reader
<ezekielwordswort>
it also supports "!clhs" which i guess you know what does, but it takes you to the lispworks website instead of the hyperspec
<Nilby>
clisp is the one i find hard to patch
paulj has joined #lisp
aeth has quit [Ping timeout: 256 seconds]
aeth has joined #lisp
<ezekielwordswort>
i prefer using SBCL but my muscle memory automatically takes me to clisp
Inline has joined #lisp
Wezl has quit [Ping timeout: 272 seconds]
theothornhill has quit [Ping timeout: 272 seconds]
engblom has quit [Ping timeout: 264 seconds]
engblom has joined #lisp
<_death>
makes me wonder how you start your lisp..
<nij>
any way to run cron jobs in a lispy way?
<mfiano>
|3b| made PLN
<aeth>
nij: have an image already running as a daemon and just talk to it with the cron job?
<aeth>
nij: otherwise, just like any other script
<jasom>
nij: I wrote something that checks timetstamps against the previously run job, and I call it every minute from cron, but it's proprietary
<_death>
think everyone writes their own
<aeth>
If it's rarely run and you don't want to persist the image, then you just run it like a script, e.g. sbcl --non-interactive --load some-entry-point-file.lisp
<jasom>
it uses local-time so that job times can be specified in arbitrary timezones, which was a requirement because neither UTC nor the local-time of the host it ran on worked for everyone with DST
engblom has quit [Ping timeout: 240 seconds]
engblom has joined #lisp
paulj has quit [Remote host closed the connection]
<nij>
jasom: :-(
<nij>
i see @@
attila_lendvai_ has quit [Ping timeout: 256 seconds]
<ezekielwordswort>
any example recursive descent parsers written in lisp
<jasom>
nij: it was fairly specialized to running daily tasks anyways; you could have any number of daily tasks, but it wouldn't do weekly, and the only way to do hourly would be to set up 24 tasks. As _death said it's the sort of thing that's just hard enough to be annoying and just easy enough that nobody has gone to the extra effort of making their special-purpose code general-purpose
mrcom has joined #lisp
<phoe>
why I should not think lisp 12 minutes before midnight: INSURE-CLASS-USING-CLASS
<phoe>
time to sleep, good night #lisp
<jasom>
At least if your class gets damaged, it will be financially sound.
ezekielwordswort has quit [Quit: WeeChat 2.9]
pankajsg has joined #lisp
ex_nihilo has quit [Ping timeout: 258 seconds]
jonatack has quit [Quit: jonatack]
villanella has quit [Ping timeout: 258 seconds]
Blukunfando has joined #lisp
jonatack has joined #lisp
jeosol has quit [Quit: Ping timeout (120 seconds)]