<aeth>
I don't like ITERATE because it's not LOOP-with-parentheses that people promise when they compare the two
<aeth>
And if I have to learn it to use it, everyone else will have to learn it to read my code.
<aeth>
On the other hand, an actual LOOP-with-parentheses would be a very nice macro.
<aeth>
even a properly configured Emacs can't properly indent a LOOP that's advanced enough.
<moon-child>
indeed
<moon-child>
doesn't even need to be that advanced. Nested if-elses are enough to trip it up
<aeth>
right
<aeth>
all you need is conditional collect
<aeth>
which you kind of want to use LOOP for
<aeth>
If you don't have to collect (or similar) you can just use CL:COND or whatever, but if you are going to use collect, you suddenly need to use LOOP's if/else system
<moon-child>
yes
<moon-child>
raku and mathematica have gather/take, which are better because they compose with the rest of the language
<aeth>
again, sounds like something that would require special training, making code that only you can read
<aeth>
at least, if ported to CL
<moon-child>
sure. But you can already read lisp
<aeth>
all I want is a hypothetical, e.g. called DO-LOOP, that uses parentheses in a way that makes it fit in... every other feature the same except perhaps for a few things that break the syntax too much
<moon-child>
it's not a completely separate language, like loop
<moon-child>
adding parens to loop won't make it compose any better
<aeth>
it wouldn't just be parens
<aeth>
most of LOOP, parenthesized, could be turned into trailing plists. A few parts couldn't, e.g. the hash table stuff that uses multiple symbols in a row
<aeth>
or where order matters
<aeth>
once you have things as parenthesized and key/value plists, you have a reason to use it: extensibility
<moon-child>
if you want extensible loop, use sicl's version
<aeth>
(:for i :of-type (unsigned-byte 32) :from 0 :below 1234)
<moon-child>
parsers are fairly easy to write
<aeth>
that doesn't even need a parser, that's just a DESTRUCTURING-BIND
<aeth>
a few ()s go a long way.
<aeth>
(and :s I guess)
<moon-child>
sure. It might more might not be _better_, but I think it is definitely not _significantly_ better
<moon-child>
s/more/or/
<aeth>
(to anticipate being poked 5 hours from now... OK, a DESTRUCTURING-BIND or an APPLY, depending on how you'd want to do it)
<moon-child>
(in case anyone cares, here is my loop extensions wishlist: collect into string/array, collect major cells of multi-dimensional array, resulting-in clause, bind multiple values)
<aeth>
most important is the last one
<moon-child>
oh, also an initially clause
<aeth>
otherwise you have to cons up an intermediate list or give up half of the convenience of the LOOP form
<aeth>
and sometimes you REALLY just need to get the 2nd value of a function
<aeth>
I usually just PSETF at the start of a DO in the body when I need multiple values iirc.
<aeth>
or just MULTIPLE-VALUE-BIND if it's only relevant to that part of the iteration
<moon-child>
well, I mean--it's all convenience features, I don't think any of these are particularly _important_. Can just PROG like it's the 60s
<aeth>
poorly-written gigantic LOOPs are where bugs are found
<aeth>
but consing up in a giant LOOP isn't good, either
<aeth>
not having a M-V-B seems to be the main flaw, as well as no collect-into-array (which means you have to manually track the index)
semz has joined #commonlisp
semz has joined #commonlisp
<moon-child>
VECTOR-PUSH-EXTEND?
Volt has quit [Remote host closed the connection]
amk has quit [Ping timeout: 260 seconds]
<moon-child>
NB. I suggest SELECT, VOLITA, and VOLITAS for strings, array elements, and array major cells, respectively.
amk has joined #commonlisp
<aeth>
moon-child: collect-into-array at an implementation level of CL:LOOP (so you couldn't do it yourself) could be unsafe
<aeth>
so it could outperform VECTOR-PUSH-EXTEND
<aeth>
at least, if you want a simple-vector at the end (which requires copying, unless the implementation optimizes it, which they won't)
occ has joined #commonlisp
semz has quit [Quit: Leaving]
semz has joined #commonlisp
semz has quit [Changing host]
semz has joined #commonlisp
semz has quit [Client Quit]
<aeth>
i.e. an adjustable vector only when creating it, and then once returning it it becomes a simple-vector. This requires implementation-level support afaik
semz has joined #commonlisp
semz has quit [Changing host]
semz has joined #commonlisp
<moon-child>
so, it couldn't be implemented portably anyway :P
<moon-child>
(also would result in arguably odd behaviour; (let (x) (loop repeat 1 volita 5 into y do (setf x y)))
thomaslewis has joined #commonlisp
<jstoddard>
,wuit
<jstoddard>
sorry, typing too fast
<jstoddard>
On my way home from work, so see everyone later.
jstoddard has quit [Quit: ERC (IRC client for Emacs 27.2)]
<Josh_2>
Fukamachi says he is willing to hand over Dex to citizenandrew
gaqwas has joined #commonlisp
kingofcsu has joined #commonlisp
<aeth>
moon-child: no, it could be implemented portably, it just couldn't be optimized portably... it would have to be optimized at the implementation level
<aeth>
moon-child: I just told you the portable implementation... SUBSEQ at the end to turn an adjustable vector into a simple-vector
agrewal has joined #commonlisp
<aeth>
it's just that implementations have several ways that they could avoid that copy
<agrewal>
phoe: Just finished your condition system. It was a good read
<moon-child>
'just couldn't be optimized portably' sure
<moon-child>
but 'SUBSEQ at the end' again, this exposes the inconsistency
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<aeth>
you could just have into not apply to collect-as-array, except perhaps if that variable is only accessed inside of a finally
thomaslewis has left #commonlisp [#commonlisp]
<aeth>
since it's not collect, it's collect-as-array
<aeth>
between the loop body and the finally, you'd do the magic
<moon-child>
sure. I would rather have to ability to use INTO if I want it
<moon-child>
and: it doesn't seem like a problem for the result to be an adjustable array
gaqwas has quit [Ping timeout: 240 seconds]
<aeth>
except anyone who optimizes array code turns their function into one that only accepts a simple-array, for "free" optimization at the cost of breaking, well, this
<moon-child>
I would rather have whatever implementation-specific functionality is required to turn an adjustable array into a simple vector be exposed explicitly
<moon-child>
(with a portable fallback to SUBSEQ, presumably--it is not necessary to retain identity, and may even be impossible with certain tagging schemes. As with other destructive functions, the source may be left in undefined state)
<aeth>
It's specified to return a simple array of the rank, anyway. And as you see, it doesn't need to return the whole thing, so you only need to track the end point
<aeth>
If you wanted it to be portable, then you'd just have to get implementations to optimize the idiom of a SUBSEQ on an adjustable array that never leaves scope and so can't be referenced anywhere else... just used to build up a simple-array
molson has joined #commonlisp
molson_ has joined #commonlisp
molson_ has quit [Client Quit]
osp has joined #commonlisp
phantomics has joined #commonlisp
sloanr has quit [Ping timeout: 250 seconds]
perrierjouet has quit [Quit: WeeChat 3.4]
Oladon has joined #commonlisp
myrrh has quit [Ping timeout: 250 seconds]
igemnace has quit [Ping timeout: 256 seconds]
ahammer has joined #commonlisp
thomp has quit [Ping timeout: 256 seconds]
ahammer has quit [Ping timeout: 240 seconds]
rotateq has quit [Quit: ERC (IRC client for Emacs 27.2)]
kevingal has joined #commonlisp
ahammer has joined #commonlisp
lisp123 has joined #commonlisp
johnjaye has quit [Quit: WeeChat 3.3]
myrrh has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
ahammer has quit [Ping timeout: 256 seconds]
kingofcsu has quit [Quit: kingofcsu]
sloanr has joined #commonlisp
random-nick has quit [Ping timeout: 250 seconds]
sloanr has quit [Remote host closed the connection]
azimut has joined #commonlisp
sloanr has joined #commonlisp
morganw has quit [Remote host closed the connection]
perrierjouet has joined #commonlisp
ahammer has joined #commonlisp
ahammer has quit [Ping timeout: 250 seconds]
perrierjouet has quit [Quit: WeeChat 3.4]
ahammer has joined #commonlisp
perrierjouet has joined #commonlisp
ahammer has quit [Ping timeout: 256 seconds]
jdz has quit [Ping timeout: 256 seconds]
flip214 has quit [Ping timeout: 256 seconds]
flip214 has joined #commonlisp
ahammer has joined #commonlisp
jdz has joined #commonlisp
frodef_ has joined #commonlisp
frodef has quit [Ping timeout: 256 seconds]
ahammer has quit [Ping timeout: 250 seconds]
s-liao has joined #commonlisp
kevingal has quit [Remote host closed the connection]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<Josh_2>
I have thousands of SLOC that rely on plists, and now I have to convert it all to use hash tables :facepalm:
<lagash>
Josh_2: what for? performance?
<Josh_2>
Because I'm an idiot. I wish that Jonathan parsed as hash-table by default...
occ has quit [Ping timeout: 250 seconds]
ec has quit [Ping timeout: 276 seconds]
molson has quit [Quit: Leaving]
frodef has joined #commonlisp
frodef_ has quit [Ping timeout: 250 seconds]
perrierjouet has quit [Quit: WeeChat 3.4]
<White_Flame>
yeah, JSON tools really need configurability per use
sloanr has quit [Remote host closed the connection]
monaaraj has quit [Ping timeout: 256 seconds]
monaaraj has joined #commonlisp
rotateq has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
perrierjouet has joined #commonlisp
molson has joined #commonlisp
<beach>
Good morning everyone!
waleee has quit [Ping timeout: 250 seconds]
monaaraj has quit [Ping timeout: 240 seconds]
monaaraj has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.4]
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
<Josh_2>
Mornin'
s-liao has quit [Ping timeout: 256 seconds]
s-liao has joined #commonlisp
molson_ has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
molson has quit [Ping timeout: 252 seconds]
<beach>
Bike: I think your suggestion would be a violation of Common Lisp semantics.
<Bike>
you think? i'm not sure.
<beach>
But I can point to the exact location in the standard that would be relevant.
<Bike>
i think the question is whether undefined behavior means the entire program is undefined, or just the particular form
<beach>
It would seem to me that the forms have to be evaluated in order.
<beach>
Oh, sorry, you are right.
<beach>
I assumed WSCL already in place. :)
<beach>
Let me modify what I just said then: Provided AREF is required to signal an error, I think you example is a violation of Common Lisp semantics.
<Bike>
if aref is required to signal an error, sure.
<beach>
But yeah, you might very well be right.
<Bike>
but i was less asking about whether this would be conforming and more with whether people would like or dislike it or what if that was how it worked
<beach>
You are opening a Pandora's box here. Now, Common Lisp implementations can do what implementations of C do, namely exploit all undefined behavior to improve performance at all cost. :)
<beach>
Ah, yes, I understand. Well, my opinion would be that the definition of AREF should be fixed, so...
<Bike>
that's why i phrased it in terms of type errors
<Bike>
i recently spent like two entire days chasing down bugs caused by c compilers doing that, so i have no desire to continue that into lisp
<beach>
Whew! :)
<Bike>
i mean, let me put this another way. should WSCL or whatever else require type errors to be signaled by the operator, or could it just say that an error is signaled somewhere? for example, at any point after the violation is inevitable.
<beach>
That's a very good question. The latter could then allow for more optimizations.
<rotateq>
Good morning you smart people. :)
<Bike>
in any case i'd like the situation clarified, since as far as i can tell CLHS is ambiguous here
<beach>
Bike: But I have no idea how that would be phrased.
molson__ has joined #commonlisp
<beach>
rotateq: As Bike pointed out, simple arrays can very well have fill pointers and such.
<rotateq>
Oh okay, I wasn't too sure, so it was good again we talked about it. I just tried then a simple example in SBCL.
<Bike>
any phrasing would probably be pretty involved, but i think that's sort of required. the standard is kind of... vague in this area
<rotateq>
beach: All C implementations? I read some time Symbolics had their own too as with Ada and Fortran. :)
<beach>
You can't use a particular implementation to determine what the standard says.
* rotateq
should read backlog ..
<Bike>
there's a distinction made between "unspecified" versus "undefined" consequences, and the distinction is that unspecified consequences are "harmless"
<rotateq>
beach: You're right of course!
<beach>
Bike: Yes, that would be an interesting exercise.
gko has quit [Remote host closed the connection]
<Bike>
no definition of harmlessness that i can see
gko has joined #commonlisp
<Bike>
i can intuit that it means, you know, don't segfault, but it's unspecific
molson_ has quit [Ping timeout: 252 seconds]
<beach>
Bike: Yes, very interesting.
<rotateq>
Maybe the loopus also hunts C code when nothing else is there to eat.
<beach>
Bike: It looks to me like we (collectively) now have the ability to improve on the standard. Exciting!
<Bike>
I hope so
<moon-child>
(progn (setf x 5) (setf *y* 5) (aref x 0))
<moon-child>
if you signal an error early you kill the assignment to *y*
monaaraj has quit [Ping timeout: 256 seconds]
<moon-child>
this may be undesirable
<rotateq>
beach: As I often see, even more things to learn about what others so easily call just "trivial" and that's way more worth to explore and deepen as just flying in too abstract and "modern" things.
jealousmonk has quit [Remote host closed the connection]
<rotateq>
maybe using UNWIND-PROTECT? :)
<Bike>
is it? i mean, i can imagine it being so, but on the other hand, maybe if the error is signaled earlier the program is stopped before it can get halfway through a state change
monaaraj has joined #commonlisp
<Bike>
and leaving things inconsistent
<rotateq>
very powerful spell
<moon-child>
the program is probably already halfway through a state change when it figures out the thing that it's going to index later is not an array
<moon-child>
you just change where in that state change the problem happens
<moon-child>
realistically, you are not going to recover state from a program which fails a bounds-check
<moon-child>
without manual intervention (which can fix up such a thing anyway)
<moon-child>
but
<Bike>
why would it matter how far the program gets, then
s-liao has quit [Quit: Client closed]
<moon-child>
I don't know. But I can imagine cases where it would matter, esp. in context of other transformations
<Bike>
the other reason i'm thinking about this is that in a few cases, it is outright impossible to signal an error at the violation point
<Bike>
if you have (let ((f (the (function * float) f))) ...), there's no way (in general, but practically speaking, pretty much at all) for the implementation to determine f will return a non-float until it actually does
<Bike>
strictly speaking with the way function types are defined, it could technically work out, but nonetheless the error would be some time after the THE is evaluated
euandreh has quit [Ping timeout: 250 seconds]
<Bike>
(and i don't think anybody would seriously expect an error to be signaled immediately)
semz_ has joined #commonlisp
semz_ has joined #commonlisp
<Bike>
oh, and i forgot there is an analogous situation where the clhs does sort of say something
<Bike>
in 3.5.1.1.1, it says that when an error is signaled for a call problem (too many arguments etc), "it might be signaled at compile time or at run time, and if signaled at run time, it might be prior to, during, or after executing the call"
jeosol has quit [Ping timeout: 256 seconds]
semz has quit [Ping timeout: 250 seconds]
<Bike>
still pretty vague.
light has joined #commonlisp
wyrd has quit [Ping timeout: 276 seconds]
<Bike>
anyway mostly i want to sound out if someone has some code that this behavior would ruin, that kind of thing. and i'm just fishing for thoughts.
Bike has quit [Quit: and now, i'm sleeping]
thomp has joined #commonlisp
wyrd has joined #commonlisp
<rotateq>
hihi
<rotateq>
hm from which time zone is Bike?
<beach>
Eastern USA usually.
<rotateq>
ah :) okay today my sleep rhythm is again really broken
<pillton>
The (function * float) example is a good one. I think AREF should signal an error though. I think there should be another operator or operators introduced which either avoid using AREF or ensure that every call to AREF does not require checking its arguments.
pjb has quit [Read error: Connection reset by peer]
<beach>
I was just wondering what the advantage would be to signal the error early. I can imagine that there would be performance advantages. However, nothing prevents an implementation from detecting the error early, but not signaling it immediately. Instead, it would have two branches, one of which evaluates the intermediate forms and then signals an error.
osp has quit [Quit: Leaving]
thomp has quit [Quit: Konversation terminated!]
thomp has joined #commonlisp
<beach>
Does that make sense? I mean, we would then have the performance advantage in that the normal branch could be optimized to assume the right type, but we would still respect a more strict definition of semantics.
thomp has quit [Ping timeout: 240 seconds]
<pillton>
Are we talking about AREF or more general?
<beach>
More generally I think. I am contemplating a way to maintain the possible performance advantages with an early detection while still respecting the semantics of individual operators doing the signaling.
<beach>
So (let ((a (foo))) (map nil #'print a) (aref a 0)) would turn into (let ((a (foo))) (if (arrayp a) (progn (map nil #'print a) (aref a 0)) (progn (map nil #'print a) (error 'type-error...))))
<beach>
In the "normal" branch, the call to MAP could then be optimized to sasume A is an array.
<beach>
But the MAP operation would be performed in both branches, thereby respecting the semantics that AREF has to do the type check.
<beach>
And I believe this example could generalize to pretty much all similar cases.
<pillton>
I mostly worry about checking that the index is valid, which you still need to do in your example.
<beach>
It was Bike's example and he considered only the type of A.
<pillton>
Ok.
monaaraj has quit [Ping timeout: 256 seconds]
frodef has quit [Ping timeout: 240 seconds]
frodef has joined #commonlisp
monaaraj has joined #commonlisp
thomp has joined #commonlisp
thomaslewis has joined #commonlisp
lisp123 has joined #commonlisp
aartaka has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
lisp123 has quit [Ping timeout: 250 seconds]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
Jing has joined #commonlisp
monaaraj has quit [Ping timeout: 250 seconds]
<moon-child>
beach: (let (a) (if cond (setf a definitely-an-array) (setf a who-knows-what)) (aref a 0))
monaaraj has joined #commonlisp
<moon-child>
in that case, hm, you could hoist the check without any observable change in behaviour
<moon-child>
(if cond (setf a definitely-an-array) (progn (setf a who-knows-what) (check-type)))
<ns12>
Hello. If I have a string stored in a file, and I want to use that string as a string literal in Common Lisp code, I could use the hash-dot `#.` reader macro to read the string from the file. If I produce an executable of this program, the user will not need to have the file present because the file is only read at "read-time". My question is: how
<ns12>
does read-time differ from compile-time?
<rotateq>
yes ns12 :)
<rotateq>
and no.
<rotateq>
cause you can have pre-compiletime at readtime too like runtime
<ns12>
Oh? What does that mean?
<moon-child>
(however given more complex control flow such a simplification would no longer be feasible)
<rotateq>
ns12: That at the three main phases you always could have the other two.
<rotateq>
and when you have a string with "foo" in this .lisp it is read directly as an object of class simple-string
<rotateq>
cause #\" is one of the standard so called readmacros
<rotateq>
or is it in a "normal" file?
wyrd has quit [Remote host closed the connection]
wyrd has joined #commonlisp
<ns12>
From my understanding, the three phases are: read-time, compile-time, and run-time. During run-time, I can have read-time and compile-time by using COMPILE and EVAL. During compile time, there will always be a read-time phase. But where is the run-time? During read-time, where is the compile-time and run-time?
<rotateq>
most times there is no need to use EVAL directly ;)
<rotateq>
and no, compile main phase comes really AFTER readtime
<rotateq>
runtime is when you let expressions pre-evaluate
<rotateq>
or do other kinds of in between calculations
<rotateq>
when you do #.(+ 1 2) it is really done at readtime
<rotateq>
or when using the #+sbcl(+ 1 2) it first looks if :SBCL is in *features* at readtime but if not gives back (values) directly
rgherdt has joined #commonlisp
<White_Flame>
ns12: the phases really only have to do with compilation itself. It all happens "at runtime" and whatever is in the image at that time is available to any code at any phase
<White_Flame>
EVAL, however, does not invoke the reader. It starts from already-read source code
<White_Flame>
*source code forms
<White_Flame>
the reader is purely the text characters -> forms conversion
<ns12>
I think I need to study the HyperSpec. What is the relevant chapter? Is the chapter 3 "Evaluation and Compilation"?
<White_Flame>
I think it's fairly easily intuitive
<White_Flame>
the spec is complex
<ns12>
s/Is the chapter/Is it chapter/
<White_Flame>
the reader converts "(+ foo #.(+ 2 3))" to the list form (cl:+ cl-user:foo 5), assuming *PACKAGE is cl-user
<rotateq>
ns12: 15MB of mostly *pure* HMTL!
<White_Flame>
the compiler then takes that plain list of symbols etc and converts it to another executable form
<White_Flame>
(oh, presumably cl-user::foo, not single-coloned)
<White_Flame>
so when the reader is doing its thing, the current package matters, and it has to evaluate #. forms before any compilation of what it's working with has a chance to be compiled (because the compiler needs the reader to finish)
<White_Flame>
this is why (progn (ql:quickload "etc") (etc:init)) fails
<White_Flame>
assuming that the quickload manifests the package ETC
<White_Flame>
because the reader has to read that entire PROGN form before executing it, and the etc: package doesn't exist yet, meaning etc:init will fail the _read_ step
<ns12>
I see. The reader is a parser that converts strings to Lisp lists. The reader is programmable using reader macros. The reader will evaluate #. forms.
<White_Flame>
the actual creation of the symbol in the source code list (etc:init) fails, because that package doesn't exist at that time
<White_Flame>
and the reader is written in lisp itself, and all is executing in the same image :)
<White_Flame>
once these notions start being more known, the spec becomes much easier to read. It's not a tutorial at all
<beach>
moon-child: Yes, I see.
<White_Flame>
ns12: and once the reader is done, pretty much none of the rest of the system ever knows or cares about the original string representation. It's all about forms (which is what macros deal with, too)
<ns12>
White_Flame, rotateq: Thanks for the explanation.
<White_Flame>
np
<rotateq>
yes ns12, as it calls functions when defined readmacros are seen. the readtable works as a lookup-table
<ns12>
In the #. form, can I call any function? Even a function I defined myself?
<White_Flame>
sure, as long as it exists in the image
<White_Flame>
so for instance in your .asd file, any file that has been loaded before the current one should have all its macros, functions, toplevel vars, etc available
<rotateq>
and you can nest such things
<White_Flame>
the real muckety muck is loading from .fasl, though. If you have purely read/compile time effects that leave things set, those won't necessarily reappear next time you load your project
<ns12>
What if the user-defined function is in the same file as the #. form that calls the function? I think EVAL-WHEN is needed, no?
thomp has quit [Ping timeout: 240 seconds]
<rotateq>
hm no wouldn't work the first time i would say
<White_Flame>
I'm not sure, it might be up to the implementation
<White_Flame>
because of stuff like (in-package), some forms have to be read one at a time, because they affect how the next one is read
<rotateq>
so better doing such things in files that are processed before, as with pushing keywords to *features*
<White_Flame>
*read/compiled/executed one at a time
<White_Flame>
rotateq: yep
<ns12>
Okay. I'll experiment with these things.
<rotateq>
yes go ahead, we have it to do so :)
<phoe>
agrewal: thanks! glad that you liked it
<ns12>
White_Flame: "... the etc: package doesn't exist yet, meaning etc:init will fail the _read_ step" - Is this because the reader will try to intern `init` in the symbol table of the `etc` package, but that symbol table doesn't exist yet?
azimut has quit [Remote host closed the connection]
<rotateq>
good morning phoe :)
<phoe>
good morning
azimut has joined #commonlisp
<phoe>
(eval-always (defun foo ...)) #.(foo ...) should work though
<rotateq>
pre-readtime maybe :D
<rotateq>
(eval-before (:big-bang) ...)
<White_Flame>
ns12: correct
<White_Flame>
it sees the string "etc:init", and tries to hit the package ETC
<White_Flame>
in order to manifest the symbol (be it new in the package, or existing)
<White_Flame>
(well, with a single colon, even manifesting a new symbol will still not be exported, and still error)
dec0d3r has quit [Quit: Leaving]
Cymew has joined #commonlisp
myrrh has quit [Remote host closed the connection]
ksqsf has joined #commonlisp
ksqsf has left #commonlisp [ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
Algernon69 has joined #commonlisp
Algernon69 has quit [Ping timeout: 245 seconds]
wyrd has quit [Ping timeout: 276 seconds]
_ante_ has joined #commonlisp
thomaslewis has joined #commonlisp
wyrd has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
monaaraj has quit [Ping timeout: 256 seconds]
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
monaaraj has joined #commonlisp
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
mgl has joined #commonlisp
Algernon69 has quit [Ping timeout: 245 seconds]
gaqwas has joined #commonlisp
moon-child has quit [Read error: Connection reset by peer]
moon-child has joined #commonlisp
<mgl>
With paste.lisp.org gone, what's the current policy on pasting code?
<mgl>
Anyway, the above is on SBCL, but the same happens on all other lisps I tried AllegroCL, CCL, CMUCL, ECL.
<jackdaniel>
and what's wrong with this?
<mgl>
The XXX restart is only printed in one of the cases.
<jackdaniel>
I see, thanks
<mgl>
Needless to say, I don't understand this behaviour.
<jackdaniel>
If the restartable-form is a list whose car is any of the symbols signal, error, cerror, or warn (or is a macro form which macroexpands into such a list), then with-condition-restarts is used implicitly to associate the indicated restarts with the condition to be signaled.
<jackdaniel>
somewhat confusing requirement (especially given your use case) but that's what it says
<phoe>
the (in)famous condition-restart association
<phoe>
one of the least known features of CL
<jackdaniel>
mgl: there is a cleanup issue in the spec explaining the rationale
<phoe>
tl;dr if you are in the debugger because of condition A, and then you do something that signals a nested condition B and you end up in a nested debugger, then you usually do not want to see restarts that are strictly related to condition A because they would be confusing
<phoe>
usually you want to only see restarts not associated with any condition *OR* those associated with condition B
<phoe>
and that's what WITH-CONDITION-RESTARTS does, and what RESTART-CASE implicitly does as well
<phoe>
if inside (progn (error "one") 1) you instead do (let ((error (make-condition ...))) (with-condition-restarts ... (error error) 1)) then you will be able to reproduce this behavior
<phoe>
RESTART-CASE does it for you in simple cases
pve has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
<mgl>
jackdaniel: Thank you. It is unlike the spec to mandate such magic.
Alfr has quit [Quit: Leaving]
amb007 has joined #commonlisp
<mgl>
phoe: Thanks. I'm aware of the condition-restart association, but this restart-case magic caught me offguard.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<phoe>
mgl: sure; if condition-restart association is one of the least known features of CL, then the fact that RESTART-CASE performs it implicitly is surely one of the least known features of the least known features
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
igemnace has joined #commonlisp
varjag has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
icepic1984[m] has quit [Quit: You have been kicked for being idle]
lisp123 has joined #commonlisp
Alfr has joined #commonlisp
lisp123 has quit [Ping timeout: 250 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
perrierjouet has joined #commonlisp
gaqwas has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
semz_ is now known as semz
shka has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.4]
lispy has joined #commonlisp
<lispy>
Hi
<rotateq>
hi lispy :)
<phoe>
heyyy
<rotateq>
phoe: in which intervals do you rise new from the ashes?
_ante_ has quit [Ping timeout: 240 seconds]
<lispy>
I'm not sure how to interpret that question rotateq LOL
<rotateq>
but phoe does :P
lisp123 has joined #commonlisp
<lispy>
hi isp123
<rotateq>
(nreverse 'lisp123)
lisp123_ has joined #commonlisp
<rotateq>
now you're lisp321 aka lispcountdown
karlosz has quit [Ping timeout: 256 seconds]
pillton has quit [Remote host closed the connection]
MajorBiscuit has joined #commonlisp
MajorBiscuit has quit [Client Quit]
MajorBiscuit has joined #commonlisp
<phoe>
rotateq: #.most-positive-fixnum
<phoe>
I just don't know what unit that number is in
<rotateq>
nice so maybe you're a celestial like being
erjag has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
<rotateq>
haha i can violate the rule i follow every other time from physics studies :) "which unit?"
varjag has quit [Ping timeout: 256 seconds]
perrierjouet has joined #commonlisp
lisp123 has joined #commonlisp
<lisp123>
lispy: Hey :D
<lispy>
We both have good creative names
<jackdaniel>
lisp-service
<rotateq>
lispy: and you're the lispiest of them all :)
<rotateq>
jackdaniel: maybe 'jacklisp'?
<jackdaniel>
maybe
lisp123_ has quit [Ping timeout: 250 seconds]
<lispy>
rotateq: thank you, you're also pretty lispy
<flip214>
ns12: well, that architecture is independent of the programming language.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<flip214>
there's the parenscript library - it allows to push (a subset of) CL code as javascript to the client
<flip214>
which is nice for simple checks of input fields; eg. in lisp you'd have (defun check-field (stg) (cl-ppcre:scan "^regex$" stg)) and this snippet can be sent as JS to allow front-end verification without code duplication
tyson2 has joined #commonlisp
Algernon91 has quit [Ping timeout: 252 seconds]
_ante_ has joined #commonlisp
Algernon91 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Posterdati has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
tyson2 has joined #commonlisp
kevingal has quit [Ping timeout: 250 seconds]
kevingal has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.4]
VincentV` has joined #commonlisp
VincentVega has quit [Ping timeout: 256 seconds]
Algernon91 has quit [Ping timeout: 250 seconds]
dec0d3r has joined #commonlisp
Algernon91 has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.3]
MajorBiscuit has joined #commonlisp
erjag is now known as varjag
mcoll has joined #commonlisp
nature has joined #commonlisp
lispy has quit [Quit: Leaving]
lisp123 has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
random-nick has joined #commonlisp
<ns12>
flip214: Is ppcre the only library that can be used in parenscript?
<gamaliel>
Hi, common lisp newbie here. I was wondering whether there was a way to evaluate a quoted push statement. For instance, if I write (let ((a nil)) (eval `(push 2 a))), the eval statement fails, as it does not recognize 'a'. How could I express it so that (eval `(push 2 a)) makes a '(2)?
<phoe>
you can't
<beach>
gamaliel: You can't. Luckily, EVAL does not have access to the lexical environment. Only to the global environment.
<phoe>
but the more important question is: what are you trying to do?
<lisp123>
To add to that, this will work (for the reasons mentioned above) (let ((a nil)) (declare (special a))(eval `(push 2 a)))
<lisp123>
But do not it of course ;)
<gamaliel>
Ok. I was trying to circumvent a recursion by crafting a nested loop in quotes, but got stuck when I had to do the inside statement which involved push.
<phoe>
circumvent recursion, how exactly?
<phoe>
if anything, you can defer computation using closures, like (let ((a '())) (lambda () (push 2 a) a)) - this returns an anonymous function that repeatedly pushes a 2 into some list, and then returns that list
<phoe>
but I have no idea if that is what you are trying to do
<rotateq>
hi gamaliel
epolanski has joined #commonlisp
<gamaliel>
Ok. I was just seeing if it was possible to generate unevaluated nested loops to create a list of combinations.
<gamaliel>
So, for example, to generate the combinations of 3 elements from {0,1,2,3,4}, I could write (loop for i from 2 below 5 do (loop for j from 1 below i do (loop for k from 0 below j do (list i j k))))
<beach>
Sort of.
<beach>
But `do (list ...)' won't do very much.
<beach>
And you can do that, of course.
<gamaliel>
That's true. But coming up with a way to store it was where I got stumped.
<beach>
You just can't have EVAL access the lexical environment.
<beach>
Why not just return it as a value then.
<beach>
(let ((<mumble> (eval '(loop ....))))) if you need EVAL.
<phoe>
unevaluated nested loops? seems weird
<phoe>
nothing that you'd write in standard Common Lisp
<phoe>
or rather, nothing that you'd commonly encounter in Common Lisp that's written commonly
<phoe>
EVAL is almost never needed, truth be told
<phoe>
(dolist
<phoe>
(oops)
<gamaliel>
Yeah, I'm very new to the language. Just tinkering around some exercise problems I found to practice.
<phoe>
iterating over three variables would be like (dolist (i (iota 5)) (dolist (j (iota 5)) (dolist (k (iota 5)) ...)))
<phoe>
where IOTA is available in the Alexandria library, (ql:quickload :alexandria)
<phoe>
or just (defun iota (n) (loop for i below n collect i))
<semz>
I think he wants the number of variables to be variable
<phoe>
oh, like that
agrewal has quit [Ping timeout: 256 seconds]
<gamaliel>
That would be correct. I mean, it's quite readily solvable using recursion, but I wanted to challenge myself into the new parts of the language using a way to construct the loops unevaluated and collecting the final call afterwards.
<gamaliel>
*calling
<phoe>
you sound like you want macros
<phoe>
at least, unless the requirement is to stay functional, I'd macro it away - write something that can expand into nested DOLIST or DOTIMES
<gamaliel>
Ok, I will keep trying. Thank you everyone!
<rotateq>
so first learning to use the given macros :)
<phoe>
it's not really customizable at runtime, just syntax sugar over DOLIST
<phoe>
but if you want it to be customizable at runtime then you have a slightly more involved problem to solve
<phoe>
no matter whether you recurse or iterate
MajorBiscuit has quit [Quit: WeeChat 3.3]
MajorBiscuit has joined #commonlisp
<gamaliel>
The nested dolist seems like a very doable solution. I can modify it to use loop and it may just expand exactly the way I need it. Thank you!
<phoe>
gamaliel: the general way of thinking in CL is - if you need to operate on something in its raw, unevaluated form, then you most likely need macros
skeemer has joined #commonlisp
<gamaliel>
Ok. My experience doing that is limited to simple bquote() statements in R programming language for statistics courses. This will be a good refresher.
<phoe>
but looks OK, even if I'd prepare bindings the other direction
<phoe>
as in, group each var and start-val and end-val together
<phoe>
but that's just syntax sugar
perrierjouet has quit [Quit: WeeChat 3.4]
agrewal has joined #commonlisp
<gamaliel>
Ok. I just planned to use it as an internal template. Recursive macros are really mind-boggling for someone who has only programmed in other languages.
gamaliel has quit [Quit: Client closed]
gamaliel has joined #commonlisp
<phoe>
recursion is recursion - remember to check your termination conditions, and try to expand your macros one step at a time
<gamaliel>
phoe: thank you very much for your help.
<phoe>
macro writing is basically writing pure functions that transform one soup of conses and symbols into another soup of conses and symbols
<gamaliel>
I have to go, thank you all for your answers and help. Have an excellent day.
gamaliel has left #commonlisp [#commonlisp]
s-liao has quit [Quit: Client closed]
perrierjouet has joined #commonlisp
kevingal has quit [Ping timeout: 245 seconds]
<ns12>
Which computer architecture is best for Lisp? x86, ARM, or RISC-V?
<Xach>
yes
<rotateq>
:D
<empwilli>
(please someone say lisp machine)
<rotateq>
ns12: it's not just as special purpose in hardware terms as say C :)
<Xach>
empwilli: rainer joswig has a funny post about running lisp on his macbook air m1 6000x faster than his symbolic hardware, and consuming 6 watts vs 1KW for symboilcs
s-liao has joined #commonlisp
* Xach
cannot spell symbolics today
<jackdaniel>
symbollocks
<empwilli>
:)
monaaraj has quit [Ping timeout: 250 seconds]
<ns12>
Xach: High energy use means that you are doing more work.
monaaraj has joined #commonlisp
<rotateq>
ehm :D
Bike has joined #commonlisp
<Bike>
::notify pillton "I think there should be another operator or operators introduced which either avoid using AREF or ensure that every call to AREF does not require checking its arguments." what do you mean?
<Colleen>
Bike: Got it. I'll let pillton know as soon as possible.
kevingal has joined #commonlisp
monaaraj has quit [Ping timeout: 250 seconds]
monaaraj has joined #commonlisp
raeda has joined #commonlisp
<beach>
ns12: Lisp works fine on pretty much any modern architecture.
MajorBiscuit has quit [Ping timeout: 250 seconds]
<beach>
ns12: What is the reason for your question?
monaaraj has quit [Ping timeout: 256 seconds]
monaaraj has joined #commonlisp
notzmv has quit [Ping timeout: 250 seconds]
MajorBiscuit has joined #commonlisp
monaaraj has quit [Ping timeout: 256 seconds]
monaaraj has joined #commonlisp
ec has joined #commonlisp
VincentV` has joined #commonlisp
s-liao has quit [Quit: Client closed]
VincentVega has quit [Ping timeout: 256 seconds]
<ns12>
beach: I'm planning to learn an architecture in more detail. Just wondering if there is anything that's better for Lisp.
<beach>
I recommend you learn RISC-V. Not particularly for Lisp, but because it is clean and it could very well become widespread.
<Bike>
i mean, what did lisp machines have that was so great for lisp? 36 bit registers so you could store a 32 bit integer with tag? everything's 64 bit now anyway
<Bike>
i wouldn't be surprised if some architecture changes could make things easier for lisp, but as far as i can tell it's not a huge deal
<semz>
parallel type/bounds checks come to mind
<semz>
I also seem to recall some hardware support for GC, but don't remember any details
agrewal has quit [Ping timeout: 256 seconds]
<Bike>
"parallel type/bounds checks"?
Devon has joined #commonlisp
dec0d3r has quit [Quit: Leaving]
tyson2 has quit [Remote host closed the connection]
Devon has quit [Ping timeout: 256 seconds]
<semz>
As in, they're performed while the actual computation is done, so that a successful check doesn't come with a performance penalty
<Bike>
what would be an example?
<semz>
On a current machine, e.g. an unchecked array access is faster than a checked array access, even if the index lies within bounds, because the check comes before the access. Iirc on a Symbolics, both would be performed in parallel, and if the index lies in bounds, things would just carry on as if the check never happened.
<semz>
So there is no reason to elide them
<Bike>
so, what, no possibility of a memory fault or anything?
<semz>
I don't know about "no possibility", but significantly reduced risk for sure.
jealousmonk has joined #commonlisp
cosimone has joined #commonlisp
monaaraj has quit [Ping timeout: 256 seconds]
monaaraj has joined #commonlisp
<lisp123>
When I paste into plaster.tymoon.eu, the indenting is all wrong. But in Emacs / GitHub, it is fine. Does anybody know the setting to fix this?
<lisp123>
Its either something to do with spaces/tabs or some sort of hidden / incorrect space characters on my end
<semz>
Is it correct when you open the raw view? Might be your browser collapsing spaces. Lisp code usually is spaces-only so I doubt it's tabs.
<phoe>
lisp123: untabify your buffers
<phoe>
and/or teach your emacs to do it on its own
<lisp123>
semz: Yes, its fine in raw
<lisp123>
phoe: Thanks, will try that
thomaslewis has joined #commonlisp
Devon has joined #commonlisp
euandreh has joined #commonlisp
semz has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 250 seconds]
semz has joined #commonlisp
semz has quit [Changing host]
semz has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
monaaraj has quit [Ping timeout: 240 seconds]
monaaraj has joined #commonlisp
tyson2 has joined #commonlisp
<lisp123>
phoe: Thanks..got there in the end with untabbify. What a stupid default for Emacs
<rotateq>
hehe in another german channel on libera with mostly also autistic/asperger people i sometimes express things in CL code and now some girl asked what i would would speak: "elisp?" :D no ANSI CL it is with full steam! even not write, but THINK in it
mgl has quit [Ping timeout: 256 seconds]
<lisp123>
rotateq: That's the way! ANSI compliant thoughts ;)
<rotateq>
The way of Mandalor.
<ns12>
rotateq: ooo... What channel is that?
<edgar-rft>
emacs sucks because it forces us to learn things
<rotateq>
ns12: #autistenchat is the main one and often much fun and wonderful people
<rotateq>
edgar-rft: again, you bring it wisely to the point (now i hide from the ontopic police)
<Josh_2>
edgar-rft: You joke but this really is a massive barrier to entry for people :facepalm:
<beach>
Yeah, we wouldn't want people to have to learn things, now would we?
<lisp123>
Josh_2: Emacs is a very good excuse for Lispers not actually doing work :D
<Josh_2>
beach: apparently not. People seem to get very upset when someone says "uh if you cant learn emacs how are you gonna learn lisp?"
waleee has joined #commonlisp
<lisp123>
Josh_2: I find its always a similar type of complainer. (1) Emacs, (2) Standard not updated, (3) GUI, (4) Some random obscure detail, (5) etc. I don't think beginners actually complain that much, but its just the similar type who rather make excuses than actually program
<Josh_2>
Something like that, at the end of the day it seems to boil down to not liking the parens
<Josh_2>
seems to me that its easier to evangelize to people who have never written code but wish to learn, I had this experience yesterday irl
<Bike>
i don't think it's unreasonable to want to use an editor you're familiar with. if someone told me i had to use some specific program to use haskell i'd certainly be less inclined to learn and use haskell.
<lisp123>
Yeah, exactly. Its something to do with Lisp, because as far as I can tell from reading historic sources, this was an issue since the 90s
<lisp123>
For some reason it attracts this certain type of individual as well (apart from all the good and productive lispers out there)
<Alfr>
rotateq, lisp123 what, no mop?
<lisp123>
Bike: But VSCode / Atom has a Lisp plugin. And most IDEs take time to get used to. And there is always LW personal edition for those who want something more 'modern' in terms of keybindings
<Bike>
i was referring to "uh if you can't learn emacs how are you gonna learn lisp"
<semz>
"but can it do games?!"
<Bike>
if you can write lisp in something else, great. but condescending to someone who doesn't want to learn a new editor on top of a new language is silly.
<lisp123>
Swift requires Xcode, I (assume) Java is best done in JetBrains, most Microsoft languages (assuming again) are done in Visual Studio ~shrugs~
<semz>
I don't think anyone does Java in a raw text editor, it's miserable.
<aeth>
depends on if it's your own code or someone else's
<lagash>
semz: I used to, over a decade ago..
<aeth>
Java isn't THAT bad, it's the style people use in it
<lisp123>
Bike: I don't think people say that comment to beginners, if so, yes its not good to be condescending
<aeth>
I'm sure you could write CL where M-. and autocomplete are mandatory
<aeth>
they're just rare
<aeth>
maybe the equivalent would be macro-heavy code where you basically need to expand macros to see what's going on
<Josh_2>
Bike: yes but if that editor is VSC, they can get bent imo
sloanr has joined #commonlisp
<sveit_>
XB
notzmv has joined #commonlisp
_ante_ has quit [Ping timeout: 250 seconds]
cosimone` has joined #commonlisp
Algernon91 has quit [Read error: Connection reset by peer]
Algernon91 has joined #commonlisp
cosimone has quit [Ping timeout: 250 seconds]
NotThatRPG_away has quit [Read error: Connection reset by peer]
thomaslewis has left #commonlisp [#commonlisp]
Guest74 has joined #commonlisp
asarch has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
aartaka has joined #commonlisp
Algernon91 has quit [Ping timeout: 268 seconds]
monaaraj has quit [Ping timeout: 256 seconds]
Catie has joined #commonlisp
morganw has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.3]
lisp123 has quit [Quit: Leaving...]
johnjaye has joined #commonlisp
Algernon91 has joined #commonlisp
epolanski has quit [Quit: Connection closed for inactivity]
gxt has quit [Remote host closed the connection]
gxt has joined #commonlisp
nature has quit [Quit: Lost terminal]
ori has left #commonlisp [WeeChat 3.3]
domovod has joined #commonlisp
<Josh_2>
Oops, having that annoying problem with connecting to my remote lisp, I remember writing the solution in here but now looking through the logs I cannot find
<luis>
not yet as plug-and-play as the original commonqt was, since there's no precompiled binaries available yet.
* luis
eyes Shinmera
<Josh_2>
I knew when I updated my lisp I would have this problem
<phoe>
I might be able to help with building on Linux
* phoe
adds to his pile of TODOs
Oladon has quit [Quit: Leaving.]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
MichaelRaskin has joined #commonlisp
Lord_Nightmare has quit [Read error: Connection reset by peer]
dra has joined #commonlisp
Jing has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Lord_Nightmare has joined #commonlisp
thomaslewis has joined #commonlisp
triffid has quit [Quit: triffid]
thomaslewis has left #commonlisp [#commonlisp]
VincentV` has quit [Ping timeout: 250 seconds]
NotThatRPG has joined #commonlisp
jeosol has joined #commonlisp
<Guest74>
my only problem with people saying use emacs for common lisp because it 'indents properly' is that you get a rude awakening when pasting stuff because emacs by default does not indent CL properly since it sticks in a bunch of tabs.
<phoe>
yes, and it greatly displeases me
<aeth>
It also doesn't indent properly without SLIME, and without the libraries in question loaded into an active SLIME REPL
<aeth>
because it uses some things like the distinction between &rest and &body to inform its indentation
<aeth>
and without loading the library, it's going to assume that the macro is a function unless it's a COMMON-LISP built-in
cosimone` has quit [Remote host closed the connection]
cosimone has joined #commonlisp
<aeth>
Forgot to Quickload it before modifying it? Well, that means that you've just messed up your file's indentation.
amb007 has quit [Ping timeout: 250 seconds]
amb007 has joined #commonlisp
thomp has joined #commonlisp
<Guest74>
phoe: if I steal your rotation stuff you did for imago what would be the best way to credit you? Mind you I still haven't looked at it.
<phoe>
Guest74: Michał "phoe" Herda <phoe@disroot.org> is good enough
<Guest74>
I guess I can stick that in the commit message? It seems like a comment in code isn't sufficient attribution, at least in my mind.
lisp123 has joined #commonlisp
<phoe>
why not both~
<phoe>
also be cautious not to take too much imago code along the way if your code isn't LLGPL
Algernon91 has quit [Ping timeout: 245 seconds]
<Guest74>
yes, I'll do both. I guess I should probably have asked a more git specific method of attributing a commit to someone else. Though I'll probably have to change the code somewhat as all my stuff uses linear arrays.
<Josh_2>
Finally managed to find my note to my future self from 6 months ago in the IRC logs
<Josh_2>
Sunday 5th of September
karlosz has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
lisp123 has quit [Remote host closed the connection]
thomp has quit [Ping timeout: 240 seconds]
<Josh_2>
And ofcourse I followed the instructions I left myself and it didn't work
<Josh_2>
:facepalm:
Oladon has joined #commonlisp
Algernon91 has joined #commonlisp
Noisytoot has joined #commonlisp
nij- has joined #commonlisp
<nij->
Hi! I'm using sly in emacs. However, its completion doesn't work. When I do M-x sly-next-completion, a message says "No buffer named *sly-completion*." Anyone had this issue before?
<nij->
sly-symbol-completion-mode is on btw.
Algernon91 has quit [Ping timeout: 240 seconds]
<Josh_2>
Okay finally fixed it
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
johnjaye has quit [Quit: WeeChat 3.3]
karlosz has quit [Quit: karlosz]
_ante_ has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
Devon has quit [Ping timeout: 250 seconds]
karlosz has joined #commonlisp
Devon has joined #commonlisp
lisp123 has joined #commonlisp
<mfiano>
Josh_2: That's more than an off by one error.
lisp123 has quit [Ping timeout: 250 seconds]
Devon has quit [Ping timeout: 250 seconds]
karlosz has quit [Quit: karlosz]
Alfr has quit [Quit: Leaving]
karlosz has joined #commonlisp
karlosz has quit [Client Quit]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
Devon has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
thomp has joined #commonlisp
asarch has quit [Quit: Leaving]
varjag has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
euandreh has quit [Ping timeout: 250 seconds]
shka has quit [Remote host closed the connection]
shka has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
<Josh_2>
Rip
IPmonger has joined #commonlisp
sloanr has quit [Remote host closed the connection]
aartaka has joined #commonlisp
sloanr has joined #commonlisp
Alfr has joined #commonlisp
IPmonger has quit [Remote host closed the connection]
Lycurgus has joined #commonlisp
varjag has joined #commonlisp
aartaka has quit [Ping timeout: 256 seconds]
morganw has quit [Remote host closed the connection]
IPmonger has joined #commonlisp
IPmonger has quit [Remote host closed the connection]
Devon has quit [Ping timeout: 256 seconds]
shka has quit [Ping timeout: 256 seconds]
dra has quit [Quit: Leaving]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
morganw has joined #commonlisp
thomp has quit [Ping timeout: 250 seconds]
sloanr has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
sloanr has joined #commonlisp
euandreh has joined #commonlisp
mgl has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
mgl has quit [Ping timeout: 256 seconds]
wataru has joined #commonlisp
NotThatRPG has quit [Read error: Connection reset by peer]
NotThatRPG has joined #commonlisp
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
wataru has quit [Quit: -a- IRC for Android 2.1.59]
notzmv has quit [Ping timeout: 250 seconds]
dec0d3r has joined #commonlisp
dec0d3r has quit [Remote host closed the connection]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
lisp123 has joined #commonlisp
pve has quit [Quit: leaving]
lisp123 has quit [Ping timeout: 256 seconds]
rgherdt has quit [Ping timeout: 250 seconds]
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
karlosz has joined #commonlisp
anticomputer_ is now known as anticomputer
semz_ has joined #commonlisp
semz_ has joined #commonlisp
semz has quit [Ping timeout: 250 seconds]
kevingal has joined #commonlisp
gaqwas has joined #commonlisp
cosimone has quit [Remote host closed the connection]
waku has quit [Remote host closed the connection]
jmes has joined #commonlisp
<jmes>
When I use the executable of my program (built with asdf:make & sbcl), my (format t "...") output only gets displayed in a terminal after I exit the program. In SLIME it's fine. I'm pretty clueless so any ideas would be appreciated.
<jmes>
for example I have a prompt like (format t "Enter something:") and then a read-line. Even though I can enter something to be read and everything else works as intended I won't see the prompt text until I SIGINT the program
sloanr has quit [Remote host closed the connection]
sloanr has joined #commonlisp
<Alfr>
jmes, force-output
<Alfr>
jmes, or even finish-output, since you're querying.
<pjb>
jmes: -1 consider using *query-io* instead of *standard-input*/*standard-output*
<pjb>
jmes: always use finish-output (or force-output).
<pjb>
2- ^
sloanr has quit [Remote host closed the connection]