ebrasca` has quit [Remote host closed the connection]
pranavats has left #commonlisp [#commonlisp]
X-Scale has joined #commonlisp
gioyik has quit [Ping timeout: 276 seconds]
random-nick has quit [Ping timeout: 245 seconds]
attila_lendvai has quit [Ping timeout: 245 seconds]
khrbt has quit [Ping timeout: 245 seconds]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
tyson2 has joined #commonlisp
khrbt has joined #commonlisp
igemnace has quit [Remote host closed the connection]
khrbt has quit [Ping timeout: 252 seconds]
donovanquixote has joined #commonlisp
khrbt has joined #commonlisp
Bike has quit [Quit: Lost terminal]
Nilby has joined #commonlisp
notzmv has joined #commonlisp
Psybur has quit [Remote host closed the connection]
lad has joined #commonlisp
<lad>
is there a library for adding data literals to CL? for example, hmaking ash tables with {} or arrays with []? similar to () for lists?
<hayley>
That is easier said than done, because hash tables and arrays have test functions and element types respectively. Though you have #2a((1 2 3) (4 5 6) (7 8 9)) to make an array of with element type T.
<mfiano>
lad: hayley is correct. It would not make much sense, as Common Lisp does not have required type annotation syntax to instruct how keys are to be hashed.
prxq_ has quit [Ping timeout: 245 seconds]
<Nilby>
There's things like alexandria:alist-hash-table, but of course it's not exactly a literal.
prxq has joined #commonlisp
<waleee>
why is it 2a? (noticed the error with just #a)
<mfiano>
2 is a parameter to the #a dispatcher
<waleee>
"to array"?
<mfiano>
2 for 2d
<waleee>
ah
<mfiano>
0-n is possible
<mfiano>
where n is implementation-defined
<hayley>
#0aff00 ; look, CSS colour literals
<waleee>
thanks for the info
<hayley>
mfiano: FWIW types are orthogonal to hashing; you could use a string key for its value (e.g. EQUAL) or for its identity still (e.g. EQ), though the latter would be pretty useless in a literal.
<mfiano>
Right. I just meant that the test function is not really exposed in other languages with such syntaxes
<hayley>
Sure.
<mfiano>
I mean, you might be able to do something like {eq k1 v1 ... kN vN}, and dispatch based on parity (odd takes first element as test, even implies a default test) but I question the utility.
ullbeking has quit [Ping timeout: 260 seconds]
dbotton has quit [Ping timeout: 252 seconds]
<mfiano>
Instead I recommend using serapeum's DICT, which does similar in sexp form.
splittist has quit [Ping timeout: 260 seconds]
jcowan has quit [Ping timeout: 260 seconds]
travv0 has quit [Ping timeout: 260 seconds]
<hayley>
Right.
drmeister has quit [Ping timeout: 260 seconds]
drmeister has joined #commonlisp
stylewarning has quit [Ping timeout: 252 seconds]
jcowan has joined #commonlisp
sgithens has quit [Ping timeout: 260 seconds]
sgithens has joined #commonlisp
travv0 has joined #commonlisp
<mfiano>
Such questions are usually asked by those new to the language and don't understand the trade-offs such a syntax implies.
<lad>
someone recently mentioned to me that clojure is interesting because of the various data literals, that's why i ask. it hadn't occurred to me but it seems like most lisps aren't providing syntax for data literals. i'm used to data literals coming from ruby background, mostly just curious.
<lad>
one reason clojure is interesting*
<mfiano>
In lisp, everyhting is a data literal to be honest.
stylewarning has joined #commonlisp
splittist has joined #commonlisp
<lad>
:)
<hayley>
Yes, Clojure gets away with it because it doesn't (really) provide a concept of object identity, and only has one equality operator(?)
<Josh_2>
Imagine not having 500 equality operators
<Josh_2>
lame
<hayley>
So there is no need to provide test functions for literal hash tables (or the equivalent persistent data structures).
<mfiano>
The main problem is introducing these new data literals involves changing the read table, of which clean-up propagates down from library responsibility all the way down to user responsibility, by means of named-readtables or such.
<mfiano>
Being built-in to the language is another story
<hayley>
Josh_2: What's so bad about EQ, EQL, EQUAL, EQUALP, STRING=, NETFARM-TESTS::EQUAL-DWIM, NETFARM-SCRIPTS:VALUES-EQUAL?
<Josh_2>
Nothing :)
<Josh_2>
Dont forget string-equal
<hayley>
But I don't find a lack of object identity interesting. Children have a solid grasp on object permeance by the age of two usually.
<mfiano>
:)
zacque has joined #commonlisp
<mfiano>
Forgot =, TREE-EQUAL, CHAR=, and maybe more
<Josh_2>
yep
<hayley>
"Innumerable legions of my co-workers at Harlequin rushed to help me search out the EBCDIC character code for capital A; I shall be forever indebted to these fine and dedicated individuals." - Kent Pitman
<mfiano>
lad: But I would urge you to stop thinking in this way. Literals are evaluated at a different time than macros (earlier), and mutating them is undefined behavior, and there is no chance for programmatically generating them.
<lad>
so i notice that janet-lang is able to create tables with hash literals, https://janet-lang.org/docs/data_structures/tables.html -- wouldn't it be possible to add @{} to CL? I guess my Q may be why/how can janet get away with this syntax?
<mfiano>
You already asked this question and we already answered. Anything is possible, but you'd be throwing a lot away.
<Josh_2>
Yes there is library that adds a reader macro for creating hash tables
<hayley>
Now I'm curious if Pitman read Baker's "Equal rights for functional objects" before writing "Equal rights and wrongs in Lisp", or if the joke is that obvious.
<Josh_2>
(ql:quickload :reader)
<Nilby>
To be fair, natural systems have this problem to: = ≃ ≄ ≅ ≆ ≇ ≈ ≑ ≒ ≖ ≛ ≝ ⊴ etc.
<hayley>
This "specification" produces more questions than it answers to me.
ullbeking has joined #commonlisp
<hayley>
Does @{} refer to one table, or does it expand to some form which produces a new table?
dbotton has joined #commonlisp
<mfiano>
and where is the test?
<mfiano>
If this is the entirety of their hash table API specification I would be very surprised.
<hayley>
(Also, why can't you put a nil or NaN in a hash table? We seem to be overloading the meaning of nil because they can't signal an error, or return multiple values or a wrapper object?)
<mfiano>
Yes, this is sad
<hayley>
(I remember that Lua tables have the same limitation, and the creator of Janet also created a "Lisp" on Lua called Fennel, but surely you don't just copy its braindead semantics to make another language. What's the fun in that?)
<mfiano>
That implies they don't even have multiple values or some distinguishing tuple type
<Nilby>
Most people don't realize that hash table literals are like blinders on a horse.
<mfiano>
I mean, no nil for a value, really?
<lad>
Nilby, why's that? and hash table literals only? what about other data literals?
<hayley>
I don't get the analogy, but literals get very hairy with mutation. One classic blunder in Python is to write a function like def f(something=[]): ... assume that [] refers to a fresh list and modify that.
<lad>
what is a data literal anyway? syntactic sugar i guess?
<hayley>
Turns out, no, Python doesn't create a new list each time you call f without a value for something, and you are mutating the same list each time. Whoops.
<mfiano>
Without a specification, such semantics are subject to whenever
<Nilby>
lab: It may make it easier to work, but only because it hides a huge troublesome complexity. Other data literals, can be simpler.
<hayley>
It Depends. #(...) notation would be "literal" but it instructs the reader to produce a vector at read-time. It is then undefined behaviour to modify that vector. But another meaning of "literal" might be that, say, [a b c] is shorthand for (vector a b c), which would produce new objects when evaluated.
<hayley>
lad: JSON for hipsters.
<mfiano>
But Janet is obvious a toy language with some very questionable decisions.
<Nilby>
Even string literals are approaching fiction now.
<mfiano>
even string types are approaching fiction now
<mfiano>
</zig joke>
<hayley>
I think I should hold off on commenting on other languages, lest I get called a CL cultist or whatever's new.
Spawns_Carpeting has joined #commonlisp
<hayley>
mfiano: You have "strings are weird things" like Rust, "strings are arrays of characters" like CL, "strings are lists of characters" like Haskell, "strings are lists of code-point integers" like Erlang...
<Josh_2>
CL cultists unite!
<hayley>
Oh, also "strings are a null-terminated array of bytes" in C which IMO makes it incredibly dubious to handle untrusted input in C programs, unless you check for null bytes.
<Nilby>
I thought we were in the CL cultist safe containment zone.
* Qwnavery
accidentally turns his C program into a keylogger-buffer-overflow-memory-leak combo
* mfiano
waits for iron oxide to form
<Qwnavery>
lol
<hayley>
Speaking of literals, you can also use LOAD-TIME-VALUE to produce some object at load-time which can be mutated, which is handy sometimes.
* hayley
gets out the steel wool
<Alfr>
Nilby, are we in a containment zone which is "CL cultist safe" or a "safe containment zone" for CL cultists?
<waleee>
mfiano: zig is taking the cl datastructure approach to strings
<mfiano>
hayley: That's Steele
<Josh_2>
Good morning beach
<hayley>
But, long story short, equality of objects is poorly defined, often subjective, and moreso when you throw mutation into the mix. So one does not simply pick the right equality predicate, and thus one does not simply create a hash table literal without picking the right equality predicate.
<hayley>
I recall SBCL has an extension to #a syntax which allows specifying the element type, but I forgot how it works exactly.
tyson2 has quit [Remote host closed the connection]
pranavats has joined #commonlisp
semz has quit [Ping timeout: 245 seconds]
akoana has left #commonlisp [#commonlisp]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
semz has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
<White_Flame>
so is #a(...) without a dimension left unspecified by clhs?
CrashTestDummy2 has joined #commonlisp
CrashTestDummy3 has quit [Ping timeout: 260 seconds]
<mfiano>
Yes
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
pranavats has joined #commonlisp
lisp123 has joined #commonlisp
jealousm` has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
jealousmonk has quit [Ping timeout: 252 seconds]
opcode has quit [Quit: WeeChat 3.3]
lisp123 has joined #commonlisp
asarch has joined #commonlisp
opcode has joined #commonlisp
jealousm` has quit [Quit: ERC (IRC client for Emacs 27.1)]
karlosz has joined #commonlisp
ec has quit [Ping timeout: 276 seconds]
<lisp123>
How many people usually attend ELS?
<beach>
90
<lisp123>
Wow, thats a large turnout
<beach>
It's decent.
<beach>
And we have regular participants from places like the USA and Japan.
<mfiano>
Has it been decided if this year's conference will be an in-person/online hybrid as discussed at the last one?
<mfiano>
err next year's
<beach>
As I understand it, it will mainly be in-person, but the aim is to also do online. This has not been tried before so I am not sure what the plans are.
<lisp123>
Looks great, very snazzy website
<beach>
The works of Shinmera.
<beach>
Me and my (admittedly small) family will likely arrive before the weekend and stay a few days after the conference.
pranavats has left #commonlisp [Disconnected: Received SIGTERM]
<beach>
And, as usual, if you bring your copy of Lisp in Small Pieces, the translator will be there and sign it for you.
pranavats has joined #commonlisp
<lisp123>
Porto looks very beautiful
Spawns_Carpeting has quit [Ping timeout: 265 seconds]
zacque has quit [Quit: Client closed]
asarch has quit [Quit: Leaving]
lad has quit [Ping timeout: 245 seconds]
gioyik has joined #commonlisp
karlosz has quit [Quit: karlosz]
gioyik has quit [Client Quit]
selwyn has joined #commonlisp
selwyn has quit [Remote host closed the connection]
selwyn has joined #commonlisp
shka has joined #commonlisp
gaqwas has joined #commonlisp
pve has joined #commonlisp
zacque has joined #commonlisp
zacque has quit [Client Quit]
zacque has joined #commonlisp
zacque has quit [Quit: rcirc on GNU Emacs 27.2]
zacque has joined #commonlisp
rgherdt__ has joined #commonlisp
<hayley>
(assoc 'fixnum '((string) (integer)) :test #'subtypep) works, though I wasn't really expecting it to before checking the HyperSpec.
lisp123 has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 252 seconds]
hendursa1 has joined #commonlisp
JeromeLon has joined #commonlisp
hendursaga has quit [Ping timeout: 276 seconds]
pve has quit [Quit: leaving]
pve has joined #commonlisp
igemnace has joined #commonlisp
lisp123 has joined #commonlisp
<pve>
Does anyone know what it was like to develop graphical applications for the Lisp machines? Was it possible to do it "interactively", like in a Smalltalk environment? (as opposed to a write code - compile - run the app cycle)
<hayley>
I borrowed a book called "Lisp lore" which discussed graphics on the Lisp machine (from 1987 from memory?) and it was basically just CLIM.
<pve>
I must admit my knowledge of CLIM is not great, but from what I've gathered, interactive development is possible with CLIM?
<lisp123>
hayley: Where did you borrow it from? Suprised lisp books are in libraries
<lisp123>
pve: LispWorks has CAPI if you want to experience something not too dissimilar
<hayley>
lisp123: The university I left had it in the library, but they had to dig it out of storage.
<beach>
pve: Sure. You can start your CLIM application in one thread and modify its code in a REPL.
<hayley>
Seems every book I borrow [n=3] is lost somewhere in storage.
<lisp123>
hayley: Nice
<pve>
lisp123: ah, never tried lispworks
<beach>
pve: And you don't need a Lisp Machine anymore. There is McCLIM which is getting very good.
<beach>
lisp123: Why recommend a proprietary system when we have McCLIM?
<pve>
beach: That's great. So I can add, say a button, to the app while its running?
<pjb>
pve: yes, you don't need to kill your lisp and reboot it to add a button.
<pjb>
pve: in general, you never need to kill your lisp.
<beach>
pve: That's a good question. I don't use gadgets much.
<beach>
pve: But the display functions are re-run after every iteration of the command loop, so if you make a change to one of those, it will be reflected after the next command.
<pve>
beach: I'd be fine with closing the window and re-opening it too, of course
<beach>
pve: Oh, then definitely.
<pjb>
pve: the point is that there's no difference between "you" adding a button, and the application adding a button. THere's no static declaration that needs to be processed and compiled and loaded from a fresh image. This is not how lisp works!
<_death>
pve: (ql:quickload "clim-listener") (clim-listener:run-listener) in the listener you can do (with-output-as-gadget (*standard-output*) (make-pane 'push-button :label "Hello" :activate-callback (lambda (gadget) (declare (ignore gadget)) (format t "Hi there~%"))))
<pve>
_death: let me try that
<pjb>
And even if there was, since we have this compiler available at runtime thing, you could just reload it right on the spot!
<_death>
pve: I suppose you can build a dialog editor that lets you drag and drop to create gadgets etc.
<pjb>
Yes, it's called Interface Builder, and was developed originally in lisp.
<_death>
but I think that'd be more consistent with traditional style UI systems and less with presentation based systems
<beach>
lisp123: You didn't answer my question.
<lisp123>
beach: Brb (cooking)
<pve>
_death: yeah, I wasn't even thinking of drag and drop -type interactivity, just something where the app keeps running
zacque has quit [Quit: Goodbye :D]
zacque has joined #commonlisp
makomo has joined #commonlisp
<pve>
pjb: To think, that something like that was made in the 80's. It's really strange considering today's (primitive?) methods, like two entirely different timelines.
<beach>
pve: Also, it depends on what is meant by restarting the application.
<_death>
pve: the listener makes it easy to try things as you read clim tutorials/guides
<beach>
pve: I mean, you can have a complete CLIM application as an instance of a CLIM frame manager, and just restart the display part of it.
<beach>
Er, not frame manager, application frame.
<pve>
Hah! I'm looking at the clim-listener now
<pve>
_death: Your example worked. This is cool!
<_death>
pve: yep.. the listener is nice, though it could be greatly improved.. say by having an organized way to let independent actors extend the set of commands (via, say, command tables)
<pjb>
pve: well, it was nice, but it has its limitations. Having a way to declare the interface in an abstract way and a system to place and adjust the elements automatically is nice. In the 80s, since screens were small, it was important to be able to optimize manually the placements of the gadgets; it's less true nowadays.
<pjb>
That Interface Builder in lisp was written by Jean-Marie Hullot who was hired by NeXT computer Inc. to rewrite it in Objective-C; it still lives in Xcode…a
<lisp123>
beach: Just reading from before. McClim was already mentioned, that's why mentioned LW
<pjb>
On the other hand, there was also Hypercard, that Apple killed. But there are clones, and IIRC, the sources of the old Hypercard are now available.
Th30n has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.3]
mjoerg has joined #commonlisp
hubvu has quit [Ping timeout: 260 seconds]
hubvu has joined #commonlisp
cosimone has joined #commonlisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
<_death>
also looks like with-room-for-graphics doesn't work too well in HEAD :/
amb007 has quit [Read error: Connection reset by peer]
<pve>
I played around with the listener and clouseau a bit, they seem really nice. Thanks for showing me.
amb007 has joined #commonlisp
<beach>
Clouseau is great! I never use the SLIME inspector anymore.
<pve>
So in theory, I should be able to make a plotting library using McCLIM? I'd be interested in basic 2d charts, histograms, scatterplots at least..
<pve>
(not exactly a weekend project, I know)
mjoerg has quit [Ping timeout: 252 seconds]
<beach>
pve: There is already scigraph as part of the McCLIM distribution. And jackdaniel has a plotting library he has been working on.
<_death>
pve: scigraph can also be greatly improved.. I'd start by renaming the "GRAPH" package though, which is a breaking change, but I don't think many people use it so it'd be worth it
tfeb has joined #commonlisp
<beach>
Yes, improvements to things like scigraph would be welcome.
lisp123 has quit [Remote host closed the connection]
<pve>
oh wow, I see a scigraph chart now :)
<pve>
does it rely on gnuplot?
<_death>
there's mcclim/Apps/Scigraph/scigraph/demo-frame.lisp with some demos
<_death>
no, it draws everything by itself
<pve>
nice!
lisp123 has joined #commonlisp
Th30n has quit [Quit: WeeChat 3.3]
<_death>
in another clim app I used py4cl2 to call python to render a chart, and show that in clim UI
<mfiano>
also check out scymtym'
<lisp123>
pve: Let me know how you go, I'd be happy to test it out
<gin>
(loop for x from 1 to 10 when (evenp x) do (format t "~&~a~%" x) collect x) => prints 2 4 6 8 10 and returns (1 2 3 4 5 6 7 8 9 10). so the WHEN clause applies to the following DO clause. is there a way to make the WHEN clause apply to both DO and COLLECT?
<tfeb>
and I tgink
<mfiano>
yes
<mfiano>
AND
<beach>
DO .... AND ...
<tfeb>
do x and collect y
<gin>
tfeb, mfiano, beach: thanks!
<beach>
Pleasure.
rogersm has quit [Quit: Leaving...]
scymtym has quit [Ping timeout: 265 seconds]
<_death>
well, after bisection it appears that it's not w-r-f-g, but commit efcfd64 that's responsible (I used draw-circle* inside the w-r-f-g)
<beach>
Could you create an issue for that, please?
tfeb has quit [Remote host closed the connection]
cosimone` has joined #commonlisp
<_death>
sure
cosimone has quit [Ping timeout: 252 seconds]
<lisp123>
What's a good tool for searching / classifying large amounts of text?
igemnace has joined #commonlisp
elderK has quit [Quit: Connection closed for inactivity]
<mfiano>
depends on use. ropes, gap buffers, piece tables, are some of these data structures that various text editors use
<_death>
define "large"
<lisp123>
I want to classify & search through the entire comp.lang.lisp archives (upto 2017)
<_death>
well, you can use sqlite with full text search for example.. if you want just lisp, maybe montezuma, though I didn't try it with a large corpus
<lisp123>
So sqlite is pretty fast?
<lisp123>
I might just do that then
<_death>
sure, you just need to create the fts table add insert to it as well
<mfiano>
_death can probably help you with the Bayesian programming required for anything meaningful from that ;)
<lisp123>
Sounds good
pranavats has left #commonlisp [#commonlisp]
attila_lendvai has joined #commonlisp
random-nick has joined #commonlisp
cosimone` has quit [Quit: ERC (IRC client for Emacs 27.1)]
cosimone has joined #commonlisp
notzmv has joined #commonlisp
selwyn has quit [Read error: Connection reset by peer]
<pve>
lisp123: I was dreaming of indexing #lisp/#commonlisp logs the other day, you could have a go at that too, but I think it's more challenging to extract topics from irc logs.
<lisp123>
pve: Yes I'm looking at comp.lang.lisp archives now (1m lines opened up in 5 seconds in Sublime...seriously, I wish Emacs had the same backend), its very well structured
<lisp123>
How far back do the IRC logs go?
<beach>
There are Tunes logs from 2004-01-01
dec0d3r has joined #commonlisp
<lisp123>
beach: Do you remember when you started on IRC? Or was it all c.l.l back in the day
<_death>
more recently I used it on lisp book pdfs (converted with pdftotext) I have.. may be interesting to compare terms used by books of different dialects
<beach>
lisp123: I don't remember. 2002 or so.
<lisp123>
_death: Wow, nice
dec0d3r has quit [Remote host closed the connection]
<lisp123>
beach: I see
selwyn has joined #commonlisp
<mfiano>
I've been also thinking about how to store/process massive amounts of text
<mfiano>
Wanted to do some HMM, LSTM, or RNN stuff on large corpora
pranavats has joined #commonlisp
<beach>
This is a point where it is prudent to actually estimate the amount of data.
jjonah has joined #commonlisp
<beach>
The Tunes IRC logs from 2004 to 2018 contain around 660MB of text.
<_death>
often you just need terms and their counts, or small shingles
<pve>
I think segmenting the logs into "discussions" (something like a thread or article) could be worthwhile
frgo has quit [Read error: Connection reset by peer]
<Nilby>
my data fits in ram, it just doesn't fit the in (dynamic-space-size) many time :(
frgo has joined #commonlisp
<_death>
pve: I also attempted to do that in various ways.. based on time of messages and nick references
<_death>
pve: it was also a fun exercise to do it in the context of gbbopen (a blackboard system framework)
lisp123 has quit [Remote host closed the connection]
<pve>
_death: I guess it wasn't very easy?
<pve>
I feel like message timestamps and nicks should produce at least *something* to go on
<_death>
pve: well, it seems to work most of the time by eye inspection, but its success is difficult to measure if you don't want to read all that stuff again
<pve>
perhaps a small set of manually labeled data could be useful
<_death>
in the old days there were fun programs like mircstats.. they performed very crude statistics but were still fun
<_death>
which links to google to look at some samples
<pve>
things like activity stats could answer questions like "What time of day should I ask my questions?" to people new to the channel.. whoops have to step out now :)
<greyrat>
pve: So should you ask when there is little activity or when there is a lot? :))
<greyrat>
If the chatroom is busy, your question will get lost quickly
<greyrat>
Is there a way to make the shebang line `#!/usr/bin/env ...` eval as a comment?
<_death>
you can use reinforcement learning with reward a function of time-to-response ;)
<_death>
greyrat: sbcl ignores the shebang line if run with --script
<greyrat>
_death: Hmm. Wouldn't a simple regression work? The problem is that we do not know what was a reply to what in IRC.
<greyrat>
This is totally doable in Telegram though. Discord, too, I guess.
<greyrat>
_death: sbcl --script does, but evaling the buffer with emacs doesn't. I guess I could patch the emacs fn to skip the first line.
<_death>
greyrat: in RL context, a regression could be used to estimate the value function.. a simple regression may be good if the system is stationary and you already have a lot of data
lisp123 has joined #commonlisp
jjonah has quit [Remote host closed the connection]
White_Flame has quit [Remote host closed the connection]
White_Flame has joined #commonlisp
lisp123 has quit [Ping timeout: 260 seconds]
Odin- has joined #commonlisp
igemnace has quit [Remote host closed the connection]
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
scymtym has joined #commonlisp
<scymtym>
_death: the clouseau problem with class t was that the class is a specializer in too many methods, right? or did you encounter a different problem?
lisp123 has joined #commonlisp
Cymew has joined #commonlisp
Antsan has quit [Quit: ZNC 1.8.2+deb2+b1 - https://znc.in]
<_death>
scymtym: yeah, and I got some clx overflow error
<scymtym>
_death: ok. i guess i should use the paging mechanism there as well
<_death>
scymtym: I don't remember, does clouseau implement lazy inspection of compound structures?
<scymtym>
_death: not sure what you mean
<_death>
e.g., if you have a list with 1m elements, does it scan/display all of them at once?
<_death>
looks like it scans, but has a limit for display (which can be increased)
<scymtym>
for sequences, it shows a "window" into the sequence. the window can scroll or grow, like a viewport and scrolling. other possibly long lists like symbols of a package, hash-tables or specializers of a class do not yet use this mechanism
tyson2 has joined #commonlisp
<_death>
I see
<scymtym>
"moving" the window is not so obvious at the moment: you can click and drag the 0..30 part
<_death>
ah.. I right-clicked and picked the command
scymtym has quit [Ping timeout: 245 seconds]
<_death>
other commands (say show-as-graph) may also have issues with big lists
JeromeLon has quit [Quit: WeeChat 3.0.1]
taiju has joined #commonlisp
Cymew has quit [Ping timeout: 245 seconds]
scymtym has joined #commonlisp
<scymtym>
_death: right, but it is very hard, or at least a lot of work, to make an inspector completely safe
<scymtym>
admittedly, the SLIME does that part better at the moment
<_death>
nah, slime's inspector is not lazy
<_death>
I remember trying to demo it to someone by inspecting a 1m element list.. bad
<scymtym>
oh, i thought it had this paging-style behavior for everything including slots, restarts, etc. and was therefore safe in this regard
<_death>
it has paging, but builds all of the data regardless
<scymtym>
i see, interesting
lisp123 has quit [Remote host closed the connection]
selwyn_ has joined #commonlisp
selwyn has quit [Ping timeout: 245 seconds]
<_death>
but I agree, inspecting is hard :).. thank you for your work
<scymtym>
sure. to be honest, most of my work on clouseau is motivated by the fact that many of my workflows wouldn't be possible without it
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
theBlackDragon has quit [Ping timeout: 245 seconds]
<beach>
That would be some excellent motivation indeed.
<greyrat>
What are good general templating systems? (Not just for HTML.) I feel like a lot of languages can benefit from such textual macros, but I have not found any mature, flexible solutions yet.
<_death>
djula works
Qwnavery has quit [Quit: WeeChat 3.3]
Lord_of_Life has quit [Ping timeout: 245 seconds]
<_death>
it says "HTML templating" in the documentation, but I recently used it to generate css..
Lord_of_Life has joined #commonlisp
<greyrat>
_death: It uses a custom DSL; Can't we have a templating system where we can reuse real lisp?
<greyrat>
(Of course, some sort of DSL is needed to interperse the lisp code and the target text)
<_death>
well, there are many templating libraries.. unfortunately many of them limit themselves to html
<greyrat>
Well, I would appreciate any good templating library that uses a real PL (any real PL, I'm fine with Python, JS, etc).
Lord_of_Life has quit [Read error: Connection reset by peer]
<_death>
it's not so difficult to write a template renderer that uses plain lisp.. you do need to make it capable of reading fragments, so some lisp syntax is hardcoded
Lord_of_Life has joined #commonlisp
<greyrat>
_death: I know, but I prefer to use sth mature.
Lord_of_Life has quit [Read error: Connection reset by peer]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<greyrat>
_death: I am finding PHP rather promising for templating. Laravel's Blades also seem suitable.
Lord_of_Life has joined #commonlisp
Lord_of_Life has quit [Read error: Connection reset by peer]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 260 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
waleee has joined #commonlisp
<Shinmera>
I'll be presenting at a polish games industry conference at the end of the month. The talk is about using lisp for game development, and some of the advantages that its features bring. Because it's aimed at people that have no idea about lisp it's very surface level, but if you're interested, the first draft is here: https://filebox.tymoon.eu//file/TWpNM09BPT0=
<Shinmera>
Also if anyone else is around the conference, I'd be up for a brief meet!
rain3 has joined #commonlisp
Lord_of_Life has joined #commonlisp
<Josh_2>
Very cool Shinmera
raeda has joined #commonlisp
waleee has quit [Ping timeout: 260 seconds]
waleee has joined #commonlisp
amb007 has quit [Ping timeout: 245 seconds]
<beach>
Shinmera: Nice! Is the conference peer reviewed?
<Shinmera>
No, it's just an industry conference, so no journaly
<Shinmera>
*journal
<Shinmera>
I wouldn't dare submit something like this to an academic conference :)
<Josh_2>
Shinmera: I think you should reword this line "ultimately even more confusing design" so that it doesn't imply the design is confusing
ggoes has quit [Remote host closed the connection]
<beach>
Shinmera: It is preferable not to use genitive 's with non-proper nouns. It is much clearer of you rewrite with "of". You then get the additional advantage that the most important word comes first.
<beach>
"the scripting language's own data types and routines" -> "the data types and routines proper to the scripting language".
amb007 has joined #commonlisp
<beach>
Shinmera: The preposition used in the AMOP for specialization is "to". A method is specialized "to" a class. The preposition "on" is reserved for talking about the relation between a method and its associated generic function. The method "on" that generic function.
<beach>
I'll read it more in detail later.
ggoes has joined #commonlisp
CrashTestDummy3 has joined #commonlisp
waleee has quit [Ping timeout: 245 seconds]
CrashTestDummy2 has quit [Ping timeout: 260 seconds]
Nilby has quit [Ping timeout: 245 seconds]
<Shinmera>
Thanks, I'll take care of revisions tomorrow :)
<JeromeLon>
I'm getting: (#<FUNCTION EQUALP> ELF::*REF* 14) illegal function call
<JeromeLon>
with (checkref 14)
selwyn_ has quit [Read error: Connection reset by peer]
<JeromeLon>
oh, I think I know, I need a real symbol, not a function. nevermind.
<pjb>
greyrat: cpp can be used in general, if you assume its restriction. Otherwise, a general text macro processor is m4.
mjoerg has quit [Remote host closed the connection]
<pjb>
JeromeLon: exactly.
<JeromeLon>
So, my question becomes: what is the idiomatic way to specify the test function in a macro? If I initialize it as (test 'equalp), the user of the macro needs to use :test equalp, which is uncommon, one would expect to have to use :test #'equalp, no?
<Shinmera>
you can emit a funcall and use #'equalp instead. (though in the lambdalist it has to be '#'equalp !) . Any compiler worth bothering with will realise the constant argument and transform it into the same thing as (equalp ..)
<JeromeLon>
I think that there is no good answer to my question. #'name is converted by the reader, so there is no way to recover the symbol, and the macro needs the symbol to generate a simple function call.
amb007 has quit [Ping timeout: 260 seconds]
<JeromeLon>
Shinmera: yes, I have to use funcall indeed in this case
<Shinmera>
Uh.
khrbt has quit [Ping timeout: 265 seconds]
amb007 has joined #commonlisp
khrbt has joined #commonlisp
lad has joined #commonlisp
<pjb>
JeromeLon: perhaps you should not write a macro, but a function!
<JeromeLon>
pjb:yes, I am rewriting it. thanks for confirming
rogersm has joined #commonlisp
<JeromeLon>
pjb:the caller needs to pass some code, which is the reason I went for a macro. But I concluded that I'd rather eval that code and have none of the issues coming from having a macro.
<pjb>
JeromeLon: well: (defmacro fun (&key fun) (if (listp fun) (destructuring-bind (function name) fun (assert (eql function 'function)) `(list 'a 'symbol ',name)) `'(not (function something) ,fun))) (fun :fun #'foo) #| --> (a symbol foo) |# (fun :fun foo) #| --> (not #'something foo) |#
<pjb>
#'name is converted by the reader as (CL:FUNCTION name) which is a list… This is what the macro receives.
<pjb>
Your macro can take the function name (symbol) directly: (checkref equal foo) (checkref equalp foo)
hendursaga has quit [Remote host closed the connection]
selwyn_ has quit [Read error: Connection reset by peer]
<etimmons>
Shinmera: I'm happy with a condition/restart based interface. Only problem might be the need to establish a dynamic context around the code that signals the warning.
<Shinmera>
What do you mean?
<Shinmera>
oh, injecting a handler?
<etimmons>
Shinmera: But that's more of an issue of how you envision additions to Forge working
<etimmons>
Yeah
<Shinmera>
you can do that easily enough by using a stealth mixin.
<etimmons>
I've never actually used stealth mixins, but recall seeing them mentioned here somewhat recently and they seemed cool/applicable here.
<Shinmera>
it just injects a superclass into an existing class, allowing you to create around/after/before methods without forcing the user to subclass.
<Shinmera>
so, perfect for this kinda thing.
<etimmons>
One thing I like about CLPM integration with ASDF is that the user can just push a search function to some ASDF var (forget the name) and then use ASDF like normal.
<etimmons>
Unlike needing to call through another function like ql:quickload
<etimmons>
So as long as we can do a similar thing with Forge (and I think we can with stealth mixins), I'm happy
<Shinmera>
sure
<Shinmera>
forge is too generic to have something as localised as a "system search function"
<etimmons>
Yeah, and conditions/restarts is more extensible anyways
<etimmons>
johnjay: esrap has some issues with the latest SBCL, but they've all been fixed in the repo. So you need to either role back SBCL or use a newer version of esrap than is currently included in QL
<etimmons>
johnjay: What does using Roswell actually buy you if you've already got a system SBCL installed that you want to use?
<johnjay>
this package forces me to use it. i don't know why.
tux0r has left #commonlisp [Closing Window]
<johnjay>
i assume it's trying to compile this esrap package you're talking about
<johnjay>
or get it from quicklisp
<etimmons>
Well that's unfortunate.
<johnjay>
i installed a similar package from quicklisp in sbcl directly
<johnjay>
but i don't understand how to load it
<johnjay>
i see some references to it in dists/quicklisp/software though
notzmv has joined #commonlisp
<etimmons>
If you have Quicklisp installed and added to your SBCL init file, you should be able to just (ql:quickload "the-system-to-load")
splittist has quit [Read error: Connection reset by peer]
splittist has joined #commonlisp
derwolf has quit [Quit: Bye]
derwolf has joined #commonlisp
<johnjay>
right but i dont' know what to do after that
<johnjay>
i googled for how to startup a package or inspect it in quicklisp and didn't find anything
<johnjay>
is it usually (packagename-start)?
jcowan has quit [Ping timeout: 245 seconds]
<etimmons>
Package is a very specific CL term (basically a namespace for symbols), so you can't really "startup a package".
<etimmons>
If you want to start a program that's written in CL, it's up to that program's documentation to tell you what the correct functions to call are
<etimmons>
But in any case, I suspect #clschool might be a better place to ask these questions
jcowan has joined #commonlisp
<johnjay>
can i figure out how to invoke it from the .asd file?
<johnjay>
ok thanks
<johnjay>
right but it's a chicken egg question
<johnjay>
if i knew how to lookup that documentation i wouldn't need to ask
<etimmons>
There may be an :entrypoint defined in the .asd file. If so, that'd give you a very good hint of where to start looking
lisp123 has quit [Remote host closed the connection]