dddddd has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
phoe has quit [Ping timeout: 276 seconds]
phoe has joined #lisp
dacoda has quit [Ping timeout: 272 seconds]
akoana has joined #lisp
libertyprime has quit [Quit: leaving]
semz has quit [Quit: Leaving]
szmer has quit [Ping timeout: 258 seconds]
<LdBeth>
good morning
VTToonses has joined #lisp
phoe has quit [Ping timeout: 252 seconds]
phoe has joined #lisp
t58 has quit [Quit: Night]
grewal has quit [Quit: leaving]
semz has joined #lisp
<no-defun-allowed>
Well, I might see how well poiu works since I intend to get a Pi 4 soon (as 64-bit SBCL will run on it, which I think has a stable thread implementation) and at least on my Pi 2, it is very slow and only utilises one of four cores
keep_learning_M has quit [Quit: This computer has gone to sleep]
semz has quit [Ping timeout: 252 seconds]
VTToonses has quit [Ping timeout: 260 seconds]
libertyprime has joined #lisp
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life has joined #lisp
ebrasca has quit [Remote host closed the connection]
semz has joined #lisp
phoe has quit [Ping timeout: 252 seconds]
phoe has joined #lisp
CloseToZero has joined #lisp
torbo has joined #lisp
phoe has quit [Ping timeout: 252 seconds]
phoe has joined #lisp
libertyprime has quit [Ping timeout: 248 seconds]
ltriant has quit [Ping timeout: 245 seconds]
libertyprime has joined #lisp
alexanderbarbosa has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<drmeister>
no-defun-allowed: Can you drop a note in #clasp with what you learn?
<no-defun-allowed>
Might be a while till I get one (maybe the price will drop for the 2GB model), but sure.
<no-defun-allowed>
Or maybe there is a different SBC that I can get better value from. I haven't a clue about what to do really.
<loke>
Oh... asdf...
<loke>
Section 3.2 in the manual says: “Don't use *central-registry*”. Then moves on to explain how to use it, without explaining what to use instead!
<no-defun-allowed>
Has it been worked on recently?
<loke>
I have no idea
<no-defun-allowed>
They would probably keep it so if you need it for whatever reason, you know how to use it. Then there might be a "You should use [replacement link] instead" statement after.
<loke>
But if I'm a user who simply wants to have my project made available to ASDF for loading, section 3.2 is what Google will point you to.
phoe has quit [Ping timeout: 252 seconds]
phoe has joined #lisp
libertyprime has quit [Ping timeout: 246 seconds]
<LdBeth>
I don use central-registry to load my local projects
<LdBeth>
That’s interesting, I don’t remember where I put the line pushnew to central-registry
<loke>
LdBeth: how do you do it then? I mean, you can drop it into local-projects, but in this particular case that's not an option for me (I'm creating a flatpak build)
stacksmith has quit [Ping timeout: 244 seconds]
<LdBeth>
you reminds me I did put it into local-init
<no-defun-allowed>
I don't see where it factors into this, honestly.
libertyprime has joined #lisp
<LdBeth>
loke: I create a dir named asdf and symbol link all the asdf files I want to load into that dir, and push the path to asdf to central registry, so I can just call asdf:load-system
quazimodo has quit [Ping timeout: 272 seconds]
<LdBeth>
And the projects can be everywhere in the file system, ASDF can trace the symbol link to find the actual location of those projects
<no-defun-allowed>
Hm, I think the plan representation might have changed somewhere.
quazimodo has joined #lisp
ltriant has joined #lisp
<no-defun-allowed>
Okay, I removed the serialize-plan method that turned the plan into a list and now asdf blew the stack, seemingly with an :around method that called itself a lot of times.
<beach>
Good morning everyone!
quazimodo has quit [Ping timeout: 268 seconds]
<LdBeth>
Morning, beach
<no-defun-allowed>
`; caught 6997 fatal ERROR conditions` That must be a record surely.
<LdBeth>
loke: if you are comfortable with the default setting ASDF provides $XDG_DATA_HOME/common-lisp/systems/ for link farm
nanoz has joined #lisp
<no-defun-allowed>
Well, I got it to load something by removing the recursive call I made by not letting POIU serialise effectively.
<no-defun-allowed>
Is there any reason POIU has to fork instead of, say, make a thread?
<White_Flame>
probably because compilers may not be multi-threaded?
<White_Flame>
I think SBCL was that way for quite a long time
<no-defun-allowed>
I'm pretty sure SBCL is now (they removed a lock on COMPILE at least), so I'd rather use threads then.
libertyprime has quit [Ping timeout: 245 seconds]
torbo has quit [Remote host closed the connection]
<aeth>
yeah, threads are much better of an option if it works.
<no-defun-allowed>
Still not a clue what to do.
libertyprime has joined #lisp
akoana has left #lisp ["Leaving"]
ltriant has quit [Ping timeout: 248 seconds]
<no-defun-allowed>
What stops ASDF from running in parallel without POIU?
ltriant has joined #lisp
<p_l>
theoretically - nothing
phoe has quit [Ping timeout: 252 seconds]
<p_l>
practically? all those :serial t systems
<no-defun-allowed>
Right.
phoe has joined #lisp
<no-defun-allowed>
Maybe I could rephrase: what processes make ASDF sequential without something like POIU?
<no-defun-allowed>
I saw asdf:sequential-plan which just generates a list of operations, which is sequential, for example.
aindilis has quit [Ping timeout: 245 seconds]
keep_learning_M has joined #lisp
asarch14 has joined #lisp
asarch14 has left #lisp [#lisp]
aindilis has joined #lisp
asarch has joined #lisp
<asarch>
If I have: (let ((values) (data "Lisp")) (setf values '(data "really" "rocks")) (loop for element in values do (format t "Parsing: ~a~%" element))), how could I get "Parsing Lisp, Parsing really, Parsing rocks"?
<beach>
asarch: You can not take a symbol representing a lexical variable to its value.
<asarch>
Is there any way to get around this?
orivej has quit [Ping timeout: 272 seconds]
<beach>
asarch: And that is for very good reasons. If you could, then Common Lisp would be intrinsically slow just the way many scripting langauges are.
<semz>
maybe he's just looking for backquoting
<semz>
does the symbol have to be looked up at runtime?
aindilis has quit [Read error: Connection reset by peer]
<LdBeth>
Yes
aindilis has joined #lisp
<LdBeth>
I mean funcall
libertyprime has quit [Ping timeout: 272 seconds]
<asarch>
(let ((values) (data "Lisp")) (setf values '( (princ data ....) also doesn't work either
<LdBeth>
You can pass a closure and funcall it
<semz>
asarch: does `(,data "really" "rocks") do what you want in your scenario?
MichaelRaskin has quit [Quit: MichaelRaskin]
<asarch>
YEAH!!!
<semz>
It's not really clear from the question whether you want something very basic or pretty advanced.
<asarch>
Thank you!!!
<asarch>
Thank you very much :-)
brett-soric has joined #lisp
Lycurgus has joined #lisp
CrazyEddy has joined #lisp
<asarch>
Actually the problem was this. I get the value of data from a POST method in a form and I need its value in order to run the command (uiop:run-program '("apt-cache" "seach" package-name")). However the evaluator complains about package-name is not of the type SEQUENCE
<beach>
asarch: If you want people to read your code, you should make sure it respects Common Lisp conventions. For starters, make sure it is indented correctly.
<krwq>
asarch: and then to make a list: (list foo bar baz)
<krwq>
asarch: now if you really need that weird construct you can create a macro but I think it is not necessarily a good idea
stacksmith has joined #lisp
nanoz has quit [Ping timeout: 244 seconds]
<beach>
asarch: What made you stick a quote there, as opposed to (list "apt-cache" "search" package-name)?
stacksmith has quit [Ping timeout: 245 seconds]
shka_ has joined #lisp
vlatkoB has joined #lisp
Necktwi has quit [Ping timeout: 248 seconds]
Necktwi has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
Inline has quit [Quit: Leaving]
<asarch>
Ok, ok
<beach>
asarch: You don't get it.
<beach>
asarch: Trying to help you is very frustrating, because you don't seem to be willing to put in the energy in order to understand the semantics of Common Lisp, nor even the energy to make things easier for the people who are willing to help you out.
<beach>
Without knowledge of the semantics of the language, you are always going to need help with trivial stuff like this latest question of yours.
<beach>
asarch: Maybe that's how you like to work. But some of us are going to lose interest in trying to help you out unless you change this attitude.
brett-soric has left #lisp [#lisp]
esrse has joined #lisp
<loke>
Holy crap... That indentation... My eyes.
<beach>
Exactly.
<beach>
asarch: Personally, I am willing to help people out if I think there is some chance that they can become contributors to the community sometime in the future. When I suspect that this is probably not going to happen, I must cut my losses and work on something more profitable.
shka_ has quit [Quit: Konversation terminated!]
<beach>
loke: And asarch has been with us for some time. You would think that the indentation would be a solved problem by now.
quazimodo has joined #lisp
<Lycurgus>
well it's settled, I will violate that convention with prejudice
<Lycurgus>
since it is nothing more than that
<beach>
Lycurgus: You are free to do what you want, of course. I am just reminding asarch that such conventions exist in order to facilitate communication between people. If you don't want to (or don't need to if you keep your stuff to yourself) facilitate such communication, that is your decision.
<LdBeth>
GG
<beach>
Lycurgus: I may be mistaken, of course, but when asarch posted the link to the code, I assumed that communication was the purpose. So I then reminded asarch that, because of the lack of respect of these conventions, the communication may suffer a lot.
<Lycurgus>
point, I don't ever ask for such help
<beach>
That's fine then.
<Lycurgus>
not with code
<beach>
That's fine then.
<Lycurgus>
and actually I will continue to observe it on preexisting code
<asarch>
I don't have Emacs in this box
<asarch>
So, really sorry for the indentation
<asarch>
I will fix the indentation as soon as I get Emacs
<Lycurgus>
what did you do line up the parens?
<asarch>
?
<asarch>
What do you mean?
<asarch>
"sbcl" "Common Lisp compiler and development system"
<Lycurgus>
that's the main gripe you hear, lining up parens, the opening and closing ones in the same column like in other langs
<Lycurgus>
instead of all piled up at the end of the form
<asarch>
Oh, I just pressed tab a la C/C++ code
<Lycurgus>
i c
Folkol has quit [Read error: Connection reset by peer]
<LdBeth>
Actually you can write a script call lisp implementation’s pretty print which could save lots of work even you already have an editor
zigpaw has quit [Remote host closed the connection]
zigpaw has joined #lisp
dacoda has joined #lisp
<asarch>
Is there any Lisp code on-line prettier?
Folkol has joined #lisp
<asarch>
Maybe I could use it
<LdBeth>
asarch: there’s one already in the standard
<asarch>
How could I get the cdr of the list without ( and )?
<asarch>
(makes this box really rocks) -> make this box really rocks
<no-defun-allowed>
(format t "~{~s~^ ~}" (cdr values))
atgreen has quit [Ping timeout: 276 seconds]
<ck_>
isn't the cdr of a list always a list?
<beach>
No.
<beach>
(cdr '(a . b))
<ck_>
but that's not a list, is it? Maybe I have my nomenclature wrong
<beach>
It is.
<beach>
(listp '(a . b)) => true
<p_l>
also, (cdr '(a))
dale has quit [Quit: dale]
<p_l>
I'm not sure if pure NIL counts as list
<ck_>
Of course. I misremembered between dotted list and dotted pair
<ck_>
nil is definitely a list
<beach>
p_l: NIL is a list.
<p_l>
hmm, it does for the purpose of LISTP, yes
<beach>
Also for the system class.
<p_l>
isn't there a separation between a "list" and a "proper list", with the latter not having a type specializer due to being checked only by doing a complete walk over it?
<asarch>
And, how could I get it without the " quotes? "makes this box really rocks" -> make this box really rocks
<beach>
p_l: No.
<ck_>
p_l: a proper list is a list terminated by nil, hence '(a b . c) is an improper one
nowhereman has quit [Ping timeout: 248 seconds]
<LdBeth>
ck_: I think nested case such as '(a (b . c) d) should be considered
<LdBeth>
Oh, I misunderstand that
<LdBeth>
So a proper list can have an improper list as elements
p9fn has joined #lisp
<ck_>
asarch: what is it you're trying to do, ultimately?
manualcrank has quit [Quit: WeeChat 1.9.1]
<asarch>
When you do apt-cache search postgresql, you get a line like: postbooks-schema-common - multi-user accounting / CRM / ERP suite (demo database)
<asarch>
I use the cl-ppcre:split function to get the colums "postbooks-schema-common" and "multi-user accounting / CRM / ERP suite (demo database)"
<ck_>
Yes, I see that. you're displaying apt-cache results in an html table. Maybe you should look into how your html generator macros work, there's probably a way to do it that way
<asarch>
However, there are some packages that fake the split pattern like: pgadmin4-apache2 - PostgreSQL management tool - WSGI application
<asarch>
So, from the list splitted I get the first column with (car result) which is pgadmin4-apache2 and the rest of the list with (cdr result)
<asarch>
However, cdr surround the resulting list in parentheses (PostgreSQL management tool WSGI application)
<asarch>
And if I use no-deful-allowed code, (format t "~{~s~^ ~}" (cdr values)), I get it surrounded by quotes: "PostgreSQL management tool WSGI application"
<ck_>
first of all, if you know you want to split at the first dash, why don't you do that instead of splitting at every one?
<asarch>
I just need to remove the quotes and the parentheses
<ck_>
... I see.
<asarch>
Yeah, HTML code doesn't need the quotes at all
<asarch>
I updated the code
<ck_>
cl-ppcre:split takes a :limit argument. Say :limit 2 to only split at the first dash.
<no-defun-allowed>
Best you keep 22.3 bookmarked somewhere.
<asarch>
Thank you!
<asarch>
There are so much to learn
<ck_>
what do you mean, so much to learn? I thought you "just needed to get rid of the quotes and the parentheses" ? :)
<beach>
ck_: Right. Especially since there are neither quotes nor parentheses in there at all.
<asarch>
Those tricks really help you
<ck_>
beach: I really should learn to bail out earlier, like you do. Teach me your ways.
<beach>
Heh.
<LdBeth>
So I think prior knowledge on how computer works is necessary to properly learn a computer programming language
zotan has quit [Ping timeout: 252 seconds]
<LdBeth>
I get some point why people would teach C
<LdBeth>
Given that “ALGOL improves on all of its successors”
zotan has joined #lisp
<no-defun-allowed>
Nah, not if you're writing in a high level language.
<no-defun-allowed>
And even then, C is described in terms of an abstract machine.
mangul has joined #lisp
<no-defun-allowed>
(@ "prior knowledge on how computer works is necessary ...")
<beach>
I tend to agree with LdBeth.
<beach>
It is very hard to understand the semantics of a programming language without understanding how it was meant to execute on a real computer.
<no-defun-allowed>
Right.
<beach>
And that goes for Common Lisp too. Imagine understanding linked lists, without knowing about addresses.
<asarch>
How can you convert string encoded in ISO-8859-1 into UTF-8?
Lycurgus has quit [Quit: Exeunt]
<asarch>
I am getting from the aserve: got error The value 8212 is not of type (UNSIGNED-BYTE 8) when setting an element of (ARRAY (UNSIGNED-BYTE 8))
zotan has quit [Ping timeout: 264 seconds]
<LdBeth>
asarch: how to handle encoding depends on which implementation you use
<LdBeth>
Besides, how’s you first question related to the second
<asarch>
Because the language of this box is set in es_MX.UTF-8 and it seem the server has some problems with text like "El niño quería una piñata de pingüino"
<no-defun-allowed>
Probably something to with the Babel library.
<no-defun-allowed>
Though, I think that's a problem with aserve (or your HTTP client maybe, if it isn't describing its encoding correctly).
<shka__>
but most of the time it is not worth the effort
<LdBeth>
jackdaniel: shka__ thank you
<shka__>
jackdaniels approach is easier to understand
<shka__>
and maintains
<jackdaniel>
is boxing/unboxing really more efficient?
<jackdaniel>
as far as I can see you wrap the object in a slot "content"
<jackdaniel>
so you need to access it, no?
<shka__>
jackdaniel: yeah
<asarch>
Anyway, thank you very much guys
<asarch>
(bed-time)
<asarch>
Have a nice day
<jackdaniel>
"yeah" it is more efficient or "yeah" you need to unbox it?
<jackdaniel>
or "yeah" to both?
<shka__>
yeah, i need to unbox it
<shka__>
but this may not be always needed, in this case i need it so i can find position for sub-expression in flat representation
<jackdaniel>
yes, but you say this is a "super efficient way" to have flat representation of the nested structure
<jackdaniel>
I'm wondering about the "super efficient" part
asarch has quit [Remote host closed the connection]
<shka__>
well, if you skip the boxing part (which is not always required and can be done in other ways) you have preserved group relationship with overhead of just extra elements representing beginings of groups
<shka__>
while holding both nested and flat representation will require twice as much memory
<shka__>
so this can be compact, it is just not in this case
* jackdaniel
is lost
<shka__>
sorry, i am not any good when it comes to explaining
zymurgy has joined #lisp
v88m has quit [Ping timeout: 272 seconds]
libertyprime has joined #lisp
amerlyq has joined #lisp
eschatologist has quit [Remote host closed the connection]
krwq has quit [Remote host closed the connection]
maxxcan has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 248 seconds]
hhdave_ is now known as hhdave
Necktwi has quit [Quit: leaving]
donotturnoff has quit [Read error: Connection reset by peer]
maxxcan has quit [Quit: maxxcan]
maxxcan has joined #lisp
<White_Flame>
jackdaniel: instead of a list (1 2 (3 4)) of length 3, consider a list of (1 2 start-list 3 4 end-list) of length 6, but with no nesting
<White_Flame>
(I think :) 0
<LdBeth>
White_Flame: but I want the ability to iterate as if nested list is single item at the same time
<jackdaniel>
I've built ecl locally once with extra pointer in cons (called it cor) to debug something
<jackdaniel>
I suppose such hack could be used to store the nesting information
<White_Flame>
LdBeth: then you could have a flat array but with offset numbers indicating where a list's end is
random-nick has joined #lisp
<LdBeth>
White_Flame: the thing is nesting can be arbitrarily deep
<White_Flame>
yeah, that's not a problem
<ck_>
LdBeth: do you want to iterate over all elements, or index them?
<ck_>
For iteration, consider subst-if
<LdBeth>
Indexing is not a requirement
<ck_>
I remember Xach posting about using the comparison or substitution functions for that effect, just a second..
<LdBeth>
But for some reason the structure should be flat
<LdBeth>
Since concatenation and insertion could happen
<White_Flame>
LdBeth: is this for implementing some sort of cursor iterator over a nested structure?
<ck_>
what do you mean, the structure should be flat? I don't understand your use case
<jackdaniel>
I think he means that it should be *ordered*
<jackdaniel>
or, he really wants it to be that way (without realising)
<White_Flame>
I think this sort of thing works well with properly nested structures; requiring elt of the same vector/list is something that would need to be defended as a requirement
xkapastel has quit [Quit: Connection closed for inactivity]
<White_Flame>
any sort of flattening will be painful if there is external mutation while the iterator is holding its state
<LdBeth>
It is like a editor for lisp code while additional properties are kept and each token is atomic
SaganMan has joined #lisp
<ck_>
Okay, so you basically have the syntax tree. I don't understand the part where you said "the structure should be flat since concatenation and insertion could happen"
<ck_>
You can insert into a tree. What am I missing?
<White_Flame>
and flattening can easily equal "premature optimization"
<LdBeth>
If I change "(a b (c d) e f)" to "((a b c) d e f)" the syntax structure can change drastically
<LdBeth>
It seem extra works have to be done if it is represented as a tree
<White_Flame>
I presume you con't currently use paredit?
<White_Flame>
*don't
<LdBeth>
> instead of a list (1 2 (3 4)) of length 3, consider a list of (1 2 start-list 3 4 end-list) of length 6, but with no nesting
<LdBeth>
This is like what I’m planning to do
<ck_>
"hey if you call start-list ( and end-list ), they look the same!!11"
<ck_>
seems like I really don't get it. I'm out
Necktwi has joined #lisp
<LdBeth>
It does incremental syntax check, which could be used in a Common Lisp based editor
<White_Flame>
common lisp technically has very little syntax to check
<LdBeth>
Anyway, I already got some idea today
<LdBeth>
Oh, yes, but you might like to check argument number or undefined variable while editing
<White_Flame>
If you're not doing a structure editor, but text editor, what you're describing is a cache of what's parsed
<White_Flame>
I don't think a purely naive approach there without caching is generally a problem, so you don't really need to do much of anything
<White_Flame>
and most editors don't refresh that type of feedback on a character-by-character basis, but rather when you stop typing for N msec
<LdBeth>
It’s sort like a structure editor
<LdBeth>
But I find the typical way doing projectional editing is too rigid
zigpaw has quit [Remote host closed the connection]
<LdBeth>
Several days ago I asked if subexps are valid and suitable for the context the entire exp is valid
libertyprime has quit [Read error: Connection reset by peer]
<White_Flame>
that's kind of a bad question because "the context" is equal to "the entire exp"
<White_Flame>
so it reduces to "if the entire exp is valid, then can I assume the entire exp is valid"
<LdBeth>
It is like if the entire exp is valid if I replace a subexp with a valid one the entire exp is still valid
<LdBeth>
This is how I view incremental parsing
<White_Flame>
"valid" is too vague of a word to use here
<White_Flame>
you still predicate on the entire expression
<White_Flame>
it all depends on what you cache, and how you can maintain that cache correctly
<White_Flame>
all you need to do is enumerate the interactive features of your editor and ... implement them
<White_Flame>
none of these decisions can really be made beforehand, before you figure out exactly where the focus needs to be. The fundamental data structures should best support what needs the most focus
<ck_>
"It is simply a matter of pushing the correct buttons in the right order, Robin" -- Batman (probably)
alexanderbarbosa has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
<LdBeth>
Valid means it can be pass to a standard ANSI CL read function and doesn’t signal an error
<jackdaniel>
- "Give me a new battery." -- Batman; - "No idea what is a terry..." -- Robin
<White_Flame>
LdBeth: this is all still premature optimization
<White_Flame>
and you need to predict all of CL, plus all of the currently in-place dynamic state of the image to make that predicate possible
<White_Flame>
for instance, if you use a macro, you need to ensure that the macro expansion won't signal
<White_Flame>
it easily gets into halting problem territory the way you word it
<White_Flame>
you need to take a more practical approach and simply implement a non-optimized version first
<ck_>
LdBeth: (+ 1 0) is valid, right? 0 is valid. nil is valid. replace 0 with nil. what happen? somebody set us up .. and so forth
<LdBeth>
But an editor doesn’t have to be interactive, a perfect example of scriptive editor is TECO.
<ck_>
oh, you said read, not eval. disregard my last.
SaganMan has quit [Ping timeout: 258 seconds]
* White_Flame
tosses a #. to ck_
<pjb>
minion: memo for asarch: well, you can map symbols to lexical variables, LEXICALLY! (let ((values) (data "Lisp")) (setf values '(data "really" "rocks")) (loop for item in values for element = (case item (data data) (otherwise item)) do (format t "Parsing: ~a~%" element))) #| Parsing: Lisp / Parsing: really / Parsing: rocks
<pjb>
--> nil |#
<minion>
Remembered. I'll tell asarch when he/she/it next speaks.
keep_learning_M has joined #lisp
Necktwi has quit [Ping timeout: 272 seconds]
* ck_
catches it, with the calm composure of the avid lisper
<ck_>
LdBeth: #.(+ 1 0) is valid, right? 0 is valid. nil is valid. replace 0 with nil. what happen? somebody set us up .. and so forth
<LdBeth>
White_Flame: it is nearly impossible to prove macroexoand is correct, but it is possible to detect some although not all of the errors. The only thing I needs to do to prevent the halting problem is cut.
<LdBeth>
ck_: so, read time eval is treated as a entire form, for it to be accepted, you have to prove it can be executed in the read environment
cosimone has quit [Quit: WeeChat 2.3]
orivej has joined #lisp
maxxcan has quit [Quit: maxxcan]
<pjb>
minion: memo for asarch: studies have shown that programmers who use spaces for indent earn more than programmers using tabs. (at least 10% more IIRC).
<minion>
Remembered. I'll tell asarch when he/she/it next speaks.
<pjb>
minion: memo for asarch: seriously!
<minion>
Remembered. I'll tell asarch when he/she/it next speaks.
<shka__>
White_Flame: thanks, you explained this very well
<pjb>
minion: memo for asarch: it takes 5mn to get emacs on this box: VERSION=26.1 ; wget ftp://ftp.gnu.org/gnu/emacs/emacs-${VERSION}.tar.gz ; tar zxf emacs-${VERSION}.tar.gz ; cd emacs-${VERSION} ; ./configure && make && make install
<minion>
Remembered. I'll tell asarch when he/she/it next speaks.
Arcaelyx_ has quit [Ping timeout: 268 seconds]
<pjb>
minion: memo for asarch: (let ((values '("Lisp" "makes" "this" "box" "really" "rocks"))) (format t "~?" "~*~@{~a~^ ~}~%" values)) #| makes this box really rocks |#
<minion>
Remembered. I'll tell asarch when he/she/it next speaks.
<pjb>
beach: I don't think you need addresses to undersand linked lists. The point is that the computer you need to know to understand the semantics of a programming language, even C, is different from the actual processors. (Unless you have a PDP-11 ;-)) Haven't you tried to teach linked lists with match boxes and wool wires?
<pjb>
s/wire/strings/
<LdBeth>
pjb: but you might need to know how data is represented to understand REPL
<pjb>
LdBeth: you might need to know A representation of data, Not necessarily the "real" representation of data.
<pjb>
LdBeth: also, you never get the real description of what occurs in our computers. For this, have a look at: http://paste.lisp.org/display/139933
<LdBeth>
A interesting I discovered here and other places is many beginners take the printed representation of lisp objects as if it is the actual inner representation
orivej has quit [Ping timeout: 248 seconds]
<pjb>
LdBeth: This is linked to the definition of formal system semantics, which is basically a circular definition: formal system semantics are defined as the mapping between one formal system and another formal system. Ie. you haven't explained anything!
<ck_>
wool wires sounds like a great product for electrical engineers with brittle skin
<pjb>
(well, you have explained something, because the new formal system is different and in general smaller, but it must have its own semantics, so you'd need another mapping and so on).
<LdBeth>
So sometime just come up with a fake definition
maxxcan has joined #lisp
<pjb>
Define "fake"? Why would one mapping be better than another, if they both give some "meaning"?
<pjb>
LdBeth: but read my paste, it's profound!
<LdBeth>
pjb: because human usually does cut when encounters circular definitions, and sometimes a “fake” definition makes the cut more easier.
<pjb>
It's like theories. As long as both theories work, who are we to say one is fake? We can only say one is simplier, but perhaps future experiment will disprove it.
<LdBeth>
Even experiment can disprove it, they’re still useful in some domains
<pjb>
jackdaniel: I wonder if Elon Musk has already heard it. Probably…
<pjb>
White_Flame: (setf post-command-hook (lambda () (save-buffer) (eval-in-cl (format nil "(ql:quickload %s)" *current-system*)))) ; usually compilation is fast enough nowadays, you could do it after each key typed! ;-) almost.
kajo has joined #lisp
dddddd has joined #lisp
atgreen has joined #lisp
libertyprime has joined #lisp
maxxcan has quit [Quit: maxxcan]
orivej has joined #lisp
Josh_2 has joined #lisp
esrse has quit [Ping timeout: 268 seconds]
APic has joined #lisp
d4ryus has quit [Ping timeout: 258 seconds]
carmack has joined #lisp
<carmack>
Hi! How to decode json string to hash table with cl-json?
<Josh_2>
decode the string and then put the contents into a hashtable?
VTToonses has joined #lisp
<carmack>
Josh_2: when i use cl-json:decode-json-from-string this function return CONS type, can i return hash table?
yharnam has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
yharnam has joined #lisp
atgreen has quit [Ping timeout: 252 seconds]
amerlyq has quit [Read error: Connection timed out]
amerlyq has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
gxt_ has joined #lisp
koenig1 is now known as koenig
gxt has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
igemnace has quit [Quit: WeeChat 2.5]
ebrasca has joined #lisp
_death has joined #lisp
Inline has joined #lisp
igemnace has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
t58 has joined #lisp
dyelar has joined #lisp
smazga has joined #lisp
manualcrank has joined #lisp
CloseToZero has quit [Ping timeout: 245 seconds]
sjl has joined #lisp
frgo has quit []
Arcaelyx has joined #lisp
frgo has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
gareppa has joined #lisp
FreeBirdLjj has joined #lisp
fivo has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
FreeBirdLjj has joined #lisp
gareppa has quit [Quit: Leaving]
varjag has joined #lisp
frgo_ has joined #lisp
Lycurgus has joined #lisp
frgo has quit [Ping timeout: 246 seconds]
frgo_ has quit [Ping timeout: 245 seconds]
notzmv has quit [Ping timeout: 245 seconds]
dale has quit [Quit: dale]
Lord_of_Life has quit [Excess Flood]
Lord_of_Life has joined #lisp
dale has joined #lisp
igemnace has quit [Quit: WeeChat 2.5]
FreeBirdLjj has quit [Remote host closed the connection]
linli has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
jxy has quit [Quit: leaving]
linli has quit [Remote host closed the connection]
jxy has joined #lisp
shka_ has joined #lisp
simendsjo has joined #lisp
gigetoo has quit [Read error: Connection reset by peer]
v88m has joined #lisp
vivit has joined #lisp
<vivit>
What's the standard practice regarding linebreaks in :documentation strings?
<pfdietz>
Good question
<Josh_2>
Personally I just hit return ¯\_(ツ)_/¯
<vivit>
How are :documentation strings typically used? Are they queried from the REPL? Do people just look at them while they're reading the source code the way they read code comments?
<beach>
vivit: I use #.(format nil "....") That way I can use the tilde-newline with the @ option, so that subsequent lines can be indented in the code without destroying the layout of the documentation string.
Arcaelyx has quit [Read error: Connection reset by peer]
<beach>
vivit: Documentation strings should be used when they are meant for the person that USES the code, not the person looking at the source.
<beach>
For the latter, comments are more appropriate.
NickBusey has joined #lisp
slac-in-the-box has joined #lisp
libertyprime has quit [Ping timeout: 245 seconds]
<sjl>
vivit: I have a keybinding that shows me the docstring for the thing under my cursor. Some people also generate HTML documentation from them, and I sometimes read/search that. And they are often helpful when reading the code, but beach is right about the intended audience.
<shka_>
vivit: usually they are queried from emacs
<shka_>
but technically, they are accessed with documentation function
<shka_>
documentation is also setfable place so you can define docstrings outside of let's say function definition
<shka_>
this is very helpful when docstring elaborates in things that are irrelevant when reading the source code
<shka_>
(i don't think that there is anything more to say about those)
nanoz has joined #lisp
* shka_
still wonders what was the first system implementing docstrings feature
<shka_>
if anybody knows, please tell
Arcaelyx has joined #lisp
<shka_>
good evening all, btw
Arcaelyx has quit [Read error: Connection reset by peer]
pest-ctrl has joined #lisp
<vivit>
beach: What's this about (format nil ...)?
Arcaelyx has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
random-nick has quit [Read error: Connection reset by peer]
<beach>
vivit: Line breaks in documentation strings look ugly in source code.
<beach>
vivit: So by doing things like #.(format nil "First line of docstring ~@
random-nick has joined #lisp
<beach>
vivit: I can indent the second line under the F, and the leading white space is not included in the string.
hhdave has quit [Quit: hhdave]
<beach>
vivit: Yes, scymtym's link is a good example.
<vivit>
emacs tries to indent the beginning of the line only a couple of spaces to the right of the left margin of the file altogether
<pjb>
vivit: there are basically two ways docstrings are used. 1- you type (documentation foo 'kind) at the REPL. 2- the same is used in documentation extraction programs to be embedded in nicely formatted documentation. eg. http://quickdocs.org and various other local such tools.
<jackdaniel>
emacs is a mean program
<jackdaniel>
i.e it pops windows all around when I don't want to
<jackdaniel>
and resizes them
<pjb>
emacs has some rules about its docstrings. Notably, the first line is a summary (you get it in M-x apropos for example), while the other lines are displayed by C-h f for example.
<pjb>
So it might indeed indent things according to those rules, which may be strange.
amerlyq has quit [Quit: amerlyq]
<pjb>
jackdaniel: there are usually customization variables you can set to limit the window popping in emacs.
<jackdaniel>
I'm sure there are, like there are means to put down mean people
<jackdaniel>
s/means/ways/
<jackdaniel>
that said I want it *not* to touch it at all
<jackdaniel>
and faield many times. but this is offtopic, sorry
<vivit>
ait hold on
<vivit>
What do the tildes at the end of lines do?
Arcaelyx has joined #lisp
<pjb>
~ #\newline is a format specifier that specifies, depending on the options, how newlines and spaces are to be treated, whether they're included in the read string.
<_death>
pjb: there is another way that docstrings are used, in my experience the primary way.. they are read while looking at the source code.. for that, #. tricks and format control sequences are not beneficial
<_death>
docstrings should be kept short and sweet.. but if there's more to say, have a first short line, then paragraphs following
<shka_>
should, but in practice you will have conditions, corner cases and stuff
<_death>
shka: this is where the paragraphs are useful
vivit has joined #lisp
<vivit>
In Common Lisp, what's the simplest way to copy a value?
<dlowe>
it depends on the kind of value
<vivit>
Sorry, I'm confused
<vivit>
s/confused/was confused/
<vivit>
Okay, say I have two variables, *foo* and *bar*. How do I set *bar* to a new list contains the same elements as *foo*, but is not eq to *foo*?
<vivit>
(Assuming *foo* contains a list)
<dlowe>
(setf *bar* (copy-list *foo*)
<dlowe>
)
<dlowe>
it's a shallow copy, though
<dlowe>
which doesn't matter for immutable data, but if you change the value of a struct or class in there, you won't be changing a copy
notzmv has joined #lisp
igemnace has joined #lisp
bexx has left #lisp ["WeeChat 2.5"]
xkapastel has quit [Quit: Connection closed for inactivity]
milanj has joined #lisp
<pjb>
(setf *bar* (map 'list (function copy-thing) sequence-of-things)) in general ;-)
<vivit>
Alright.
<vivit>
Mainly asking because losing track of what's a reference to what and accidentally passing a reference when I meant to copy a value is a recurring nightmare for me that resurfaces whenever I try to get into any languages that has pointers/references but isn't as explicit about them as C is.
makomo has joined #lisp
<dlowe>
vivit: just consider them all as references
<pjb>
vivit: it doesn't have to be a nightmare. The solution is simple: never mutate data input into functions (parameters).
<pjb>
vivit: the only case where you should allow yourself to mutate data, is when you just created it yourself. You can mutate it to set it up as you wish.
<vivit>
I don't quite follow
<vivit>
What do you mean by "data input into functions"?
<pjb>
parameters.
<dlowe>
whether you have a reference or a value only matters if you change the value
<vivit>
True
<vivit>
Ahh I see
<pjb>
For example: (defun concatenate-items (list) (reduce (function nconc) list)) is bad. nconc will mutate the items in the list parameter.
<pjb>
instead, write: (defun concatenate-items (list) (reduce (function nconc) list :key (function copy-list))) Here we makes new copies of the items in list, and mutate those new copies with nconc.
<vivit>
So you're saying it's okay to mutate something you've (for example) created with a LET, but not something passed to a function?
<pjb>
a function such as (defun first-set-to-zero (list) (setf (first list) 0)) would have to be named nfirst-set-to-zero or first-set-to-zero!
simendsjo has quit [Ping timeout: 268 seconds]
<pjb>
So the rule would be to avoid writing functions named nsomething or something!
<_death>
it is also OK to mutate values passed to a function, given that you document this.. for example, CL functions that do that are documented as destructive.. but by default pjb's rule makes sense
<vivit>
What does the n- prefix mean? Is it the same as an exclamation point in the same way that the -p suffix is the same as a question mark?
<pjb>
Now there may be the case where you have a big sophisticated mutating algorithm that uses some and mutate some data structure. You would want to implement this algorithm using several functions. Those functions will have to be passed the data structure that they will mutate.
<pjb>
In that case, name those functions with a % and make it clear that they will mutate the working space data structure.
<pjb>
vivit: n- as in nsubstitute means that it is "non-consing" ie. it will re-use the conses passed in argument, ie. it will mutate them.
<sjl>
for some value of "conses"
<pjb>
vivit: for example REMOVE doesn't mutate the argument, DELETE does mutate the argument. DELETE is the legacy name for NREMOVE ;-)
<pjb>
ok, REMOVE/DELETE is the exception to the naming rule.
<pjb>
substitute/nsubstitute subst/nsubst string-downcase/nstring-downcase etc.
<sjl>
also sort is destructive and unfortunately doesn't have a nondestructive counterpart
<pjb>
Notice the fact that we use the result of the function when it's non-mutating. (setf list (delete item list)) (setf foo (capitalize foo)) etc.
<edgar-rft>
fight capitalism!
<semz>
What was the reason for SORT being destructive anyway? Is there some sequence type where nondestructive sorting would be very expensive?
xkapastel has joined #lisp
<vivit>
Design style question. My current project has a class called 'TRAIT, which has some class-allocated slots and some instance-allocated slots. 'TRAIT has a subclass 'CUSTOM-TRAIT, which makes the class-allocated slots into instance-allocated slots but is otherwise exactly the same. I have a method CUSTOMIZE, which (destructively) changes the class of a trait into 'CUSTOM-TRAIT.
linli has quit [Remote host closed the connection]
<vivit>
Am I making things more complicated than I need to?
<pfdietz>
SORT is another legacy gotcha. It should have been called NSORT. Thanks, Interlisp.
<_death>
semz: it's expensive by definition, since the sequence is copied.. you can always write your own nondestructive sort and be done with it
<pfdietz>
(scrolls) ah, mentioned.
<pfdietz>
It was because Interlisp called it SORT, and backwards name compatibility was considered important. Interlisp is long dead now.
<pfdietz>
(And it was destructive in Interlisp)
scymtym has quit [Ping timeout: 252 seconds]
<pjb>
semz: the reason why it's destructive, is because it is assumed that the implementation will have to copy the sequence to perform the sort in a lot of cases. Notably when you sort lists. Therefore it would be costly to have a sort that is specified to perform this copy anyways.
Josh_2 has quit [Read error: Connection reset by peer]
<_death>
vivit: does profiling suggest that the savings from class-allocated slots are justified?
<dlowe>
vivit: it's probably called TRAIT, not (QUOTE TRAIT)
<pjb>
semz: but on the other hand, if you know that you need a non-mutating sort, you can always implement it yourself. (defun non-mutating-sort (seq lessp &rest rest &key &allow-other-keys) (apply (function sort) (copy-seq seq) lessp rest))
<dlowe>
(at least, I hope so)
<vivit>
uhh yeah
<semz>
Yeah now that I think about it, copy + destructive sorting is the best non-destructive sorting in many cases
<_death>
semz: related operator MERGE is also destructive, by the way
<vivit>
I called them 'TRAIT and 'CUSTOM-TRAIT just now because that's how they have to be passed to functions that operate on classes
<pfdietz>
I have seen bugs, too many times, caused by sort. It really should have been consistent in its naming.
<vivit>
_death: I have design reasons to make them class-allocated
<_death>
vivit: well, what you described seemed OK to me
<vivit>
Alright
eschatologist has joined #lisp
<vivit>
Is there some conventional way to mark CUSTOMIZE as destructive?
<vivit>
would the n- prefix be appropriate?
<Xach>
vivit: the docstring and documentation
<_death>
it is destructive, but note that change-class preserves the identity of the object
milanj has quit [Ping timeout: 258 seconds]
<ck_>
phoe: TIL about /r/LispMemes, thank you!
<pjb>
vivit: it can be implied by the name. Or you could use %customize or customize! or indeed ncustomize, if you have a customize version that is non-mutating.
<pjb>
change-the-customization-setting would quite clearly indicate mutation.
eschatologist has quit [Remote host closed the connection]
<phoe>
there are three classes, in fact: pure (nothing is changed), mutative (references to original arguments are still valid but their contents may be changed), and destructive (original arguments may no longer be valid)
<phoe>
e.g. SORT is destructive on lists but mutative on arrays
dacoda has joined #lisp
<phoe>
and CONS is pure
<phoe>
but CLHS conflates mutative and destructive into destructive
sz0 has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
v0|d has joined #lisp
<pjb>
CONS is purely mutating the memory. Technically, CONS calls the memory MUTATOR. The mutator itself may call the garbage collector.
milanj has joined #lisp
Sanctus has joined #lisp
<_death>
so does + :)
nanoz has quit [Ping timeout: 258 seconds]
orivej has quit [Ping timeout: 245 seconds]
Folkol has quit [Ping timeout: 244 seconds]
<Godel[m]>
Why is it mutation and not binding? (Earlier value of the now bound memory cell was not of concern)
yharnam has quit [Remote host closed the connection]
Folkol has joined #lisp
dacoda has quit [Ping timeout: 252 seconds]
<shka_>
Godel[m]: because pjb, that's why
<Godel[m]>
Lol
<_death>
binding is association of a name with a value.. you could choose to interpret conses as names, but it's not really a common viewpoint :)
<pjb>
Lexical bindings are local. So mutating the binding is in the same category as mutating an object you just created yourself. Furthermore, lexical bindings are usually dead when you exit the scope (not if you create an escaping closure that takes it away).
<shka_>
Godel[m]: pjb will have different view point for the sake of having different viewpoint
<pjb>
Note that closures are equivalent to objects. Therefore you can indeed have the same preventions on mutating lexical bindings, as you have of mutating CLOS object or structures.
<pjb>
Clearly: (let ((x 42)) (dotimes (i 10) (let ((x i)) (do-something x)))) is better than (let ((x 42)) (dotimes (i 10) (setf x i) (do-something x)))
<pjb>
The compilers may have it easier to remove LET bindings (ie, to notice that the variable is not needed) when you don't use SETF.
<_death>
pjb: only you cannot pass bindings to CL functions.. but "destructive" can be applied to any kind of operator, so your argument may hold.. your example may differ in semantics if DO-SOMETHING is not a function
<vivit>
Is it possible to write your own accessor with the same name as an accessor created with the :ACCESSOR flag?
<_death>
pjb: I guess there are colloquial limits that we apply to our informal terminology.. this is one of those edge cases, so normally we would not say that that function is destructive, but we can think of a ways to reduce our common language to the absurd
sauvin has quit [Read error: Connection reset by peer]
<pjb>
_death: we'd need for precise qualifiers.
<dlowe>
it's always possible to misrepresent commonly held language and then claim some higher comprehension.
<pjb>
s/for/more/
<_death>
it's one of our unstated rules of the Lisp paradigm in the Kuhnian sense ;)
<Godel[m]>
I just looked up the definition of cons the defun in sbcl source, and it was (defun cons (se1 se2) (cons se1 se2))
VTToonses has quit [Ping timeout: 260 seconds]
<pjb>
Godel[m]: cons in ccl might more more informative.
<_death>
Godel[m]: it's classic puzzler.. read about open-coding
random-nick has quit [Read error: Connection reset by peer]
<_death>
Godel[m]: your next challenge is to fully understand your implementation's DEFUN... hint: it's not just (setf (fdefinition ...) ...)
<Godel[m]>
Thanks.
<Godel[m]>
Yeah, I was told it is setf...
<Godel[m]>
Or eq
<Godel[m]>
≡
<Bike>
i mean, roughly
<Godel[m]>
What value would/could a pure lisp add?
rotty has joined #lisp
<Bike>
what?
<Bike>
numbers, i guess?
<Godel[m]>
Why would we want to have a pure lisp?
<dlowe>
I don't
<Bike>
pure programs are easier to understand and reason about sometimes.
yharnam has quit [Ping timeout: 245 seconds]
<semz>
i think a fully pure lisp is overkill but something like a (declare pure) might be nice for optimization or error reporting
igemnace has quit [Remote host closed the connection]
yharnam has joined #lisp
<Godel[m]>
Yeah, that would be nice.
<dlowe>
anything that smacks of C++'s constness needs to die before it can reproduce
<semz>
That sounds like trauma speaking :-)
<dlowe>
purity propagation sounds like a headache in the making
<dlowe>
You can't use that function, it's IMPURE
<semz>
I was thinking more on the lines of specifying intent (and checking that you didn't do it wrong)
<semz>
Though I guess it isn't fully opt-in without some sort of analysis for existing code, bleh
<semz>
devil's in the details as usual
<pfdietz>
Clojure is a step toward a pure lisp, but not a Common Lisp.
<Godel[m]>
I wish it targeted native code (too) though.
LiamH has quit [Ping timeout: 246 seconds]
<dlowe>
I tried Clojure and stopped when I got a big nasty java backtrace on an error.
<ober>
anything common is of little value -nietzsche
ebrasca has quit [Read error: Connection reset by peer]
<ober>
dlowe: :P
ebrasca has joined #lisp
<ober>
yeah... in the end it's just jvm bytecode and traces
<_death>
a little value is better than no value -lisztsche
milanj has quit [Quit: This computer has gone to sleep]
cosimone has quit [Quit: WeeChat 2.4]
cosimone has joined #lisp
vlatkoB has quit [Remote host closed the connection]
<Godel[m]>
Why isn't SERIES more popular though?
<Godel[m]>
Do other lisps have anything like that?
yharnam has quit [Remote host closed the connection]
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
<dlowe>
Godel[m]: are you searching for the perfect lisp?
vlatkoB has joined #lisp
<pfdietz>
I suggest instead that you push Common Lisp as far as you can and only when you find where it craps out do you ask for something new/improved. Depending on what you are asking for this can take a while.
yharnam has joined #lisp
<jackdaniel>
Godel[m]: series is nice in concept and you may write some code with it, but you can't use it with other standard cl operators like you would use list or a vector
<Godel[m]>
dlowe: I would like to, but not yet. I have a lot to learn from the so called imperfect ones.
random-nick has joined #lisp
<jackdaniel>
to that you have flowers like infinite data structures which try to print themself in a readable form
<Godel[m]>
Why not?
<_death>
Godel[m]: do you know about fset? I think it's a good library
<jackdaniel>
because that's how series are defined, they are not a sequence nor a stream
<dlowe>
I think the ideas behind series are super good, but the current implementation does some ugly non-composable things. If it were actually built into an implementation, I think it would be brilliant.
<jackdaniel>
on top of that you have some obscurities like using implementation-specific stuff from implementations (because CL is not enough to implement series efficiently)
<Godel[m]>
Yeah. And sycamore, though I haven't used it (it claims to perform faster than fset).
<jackdaniel>
dlowe: I tend to agree, I've found the abstraction very appealing, but in practice it was getting in a way all the time
<dlowe>
jackdaniel: and the abstraction is fragile, so you can change something and have the optimizations break in surprising ways
<Godel[m]>
dlowe: It was in the Appendix to the standard. Implementations should have picked it up as well.
<Godel[m]>
Oh, no not the standard
Xach has quit [Ping timeout: 258 seconds]
<pfdietz>
CLtL, probably
<Godel[m]>
Yeah
<Godel[m]>
CLTL2
aeth_ has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
Xach has joined #lisp
<jackdaniel>
but, from the "good" parts it works
<jackdaniel>
I didn't find anything what could be called a bug (when compared with the specification)
aeth has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
<_death>
I also remember a critique of SERIES by Joe Marshall
<Godel[m]>
Do you have a link?
<_death>
'twas in comp.lang.lisp, so duckduckgo is your friend ;)
<_death>
or just some data passed to LIST or VECTOR..
simendsjo has quit [Quit: ERC (IRC client for Emacs 26.2)]
<Bike>
nasty, jackdaniel
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
refpga has joined #lisp
<pjb>
jackdaniel: so you're saying that since array-total-size-limit could be as low as 1024, a structure could be at most as low as 1024 slots (or 1023), and therefore a function should take at least 2048 arguments, so call-arguments-limit should be at least (* 2 array-total-size-limit).
<Bike>
call-arguments-limit only has to be 50, so you could just claim drei is nonconforming,
<pjb>
jackdaniel: as soon as I have a ticket on a time machine, I'll be sure to pass it on to you so you may give this remark to the comitee.
<sjl>
Xach: Oh, the test system has to build entirely in quicklisp too, huh
<sjl>
Xach: I can fix that, one sec
<pjb>
Or indeed, you can take the constraint the other way, and say that you cannot define a structure (or a CLOS object) with more than 24 slots total.
<pjb>
(conformingly).
<Xach>
sjl: it doesn't have to - but if you'd like it to be available, it should.
<Xach>
since it doesn't it's not
<pjb>
Writing conforming code is certainly quite difficult.
<pfdietz>
The argument limit runs afoul of functions with &REST arguments, when used with APPLY.
<sjl>
Xach: Oh, I already removed the actual dependency a while back, I just forgot to remove it from `:depends-on`
<pfdietz>
(apply #'+ 0 lots-and-lots-of-numbers)
<pfdietz>
Yes, one could use REDUCE. But I still see APPLY used all over like this.
<sjl>
Xach: pushed a fix, sorry
Folkol_ has joined #lisp
<pfdietz>
Also, when using APPLY to propagate key arg lists, the lists grow as keys are overridden. (apply #'foo :k x old-keys)
cosimone has joined #lisp
vlatkoB has quit [Remote host closed the connection]
Folkol has quit [Ping timeout: 245 seconds]
<jackdaniel>
to make it clear, ecl's argument limit is 65k, 63 is a limit of arguments passed via C stack
<jackdaniel>
and some exotic usage with mop triggers this error
<_death>
pfdietz: sometimes the naive apply->reduce conversion will be less performant.. other times, reduce with a more limited operator will be more performant ;)
<jackdaniel>
and while I'll be happy to reduce drei arguments (since I have commit bit) I'd also like to fix ecl's bug :)
Folkol has joined #lisp
Folkol_ has quit [Read error: Connection reset by peer]
kajo has joined #lisp
Folkol has quit [Ping timeout: 244 seconds]
milanj has joined #lisp
Folkol has joined #lisp
Oddity has quit [Read error: Connection reset by peer]
khisanth_ has quit [Ping timeout: 246 seconds]
yharnam has quit [Remote host closed the connection]
yharnam has joined #lisp
ricchi has joined #lisp
<jackdaniel>
for those who are curious about a reason: segfault is an off-by-one error and argument shift is *yet another* off by one error, two brids with one stone :)
khisanth_ has joined #lisp
cosimone has quit [Ping timeout: 252 seconds]
cosimone has joined #lisp
yharnam has quit [Remote host closed the connection]
refpga has quit [Read error: Connection reset by peer]
refpga has joined #lisp
yharnam has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
smokeink has joined #lisp
yharnam has quit [Remote host closed the connection]
yharnam has joined #lisp
shka_ has quit [Ping timeout: 245 seconds]
vivit has quit [Ping timeout: 268 seconds]
hiroaki has joined #lisp
fms has joined #lisp
fms has quit [Client Quit]
mindCrime has quit [Ping timeout: 246 seconds]
sukaeto has quit [Quit: WeeChat 1.0.1]
yharnam has quit [Remote host closed the connection]
yharnam has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
kajo has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
<_death>
"Of course, both those games were just throwaway tests to see if our tools worked, to see if our assembler written in LISP was going to be sufficient. [...]" unexpected Lisp reference of the day