<Guest74>
thanks. The hard part will be making it look decent without implementing a postscript interpreter, but that seems inevitable since a postscript repl just sounds cool.
karlosz has joined #commonlisp
yewscion has joined #commonlisp
<Guest74>
wth am I saying, I can't stand trying to understand postscript and it's weird reverse stacks.
<weary>
what's weird to you about postscript stacks?
<Guest74>
It would have been rather elegant if I could just push args on to a stack and then when a name comes up, just funcall the name and pop of the args, but the functions take the args in reverse order. ugh, i'll give an example.
<Guest74>
x y rlineto, is a ps command. If you push as you read then the args come out y x if you pop them.
dmc00 has quit [Ping timeout: 260 seconds]
<weary>
what's weird about that?
<Guest74>
because then you have to reverse them to call the function.
<weary>
sure, but it makes sense from the standpoint of a push-down stack
<Guest74>
no, what would make sense is that the first arg you pop is the first arg required by the function.
<weary>
why would that make more sense than lifo, which is pretty standard with the paradigm of stack languages?
<Guest74>
I described lifo
aeth has quit [Ping timeout: 244 seconds]
karlosz has quit [Ping timeout: 244 seconds]
dmc00 has joined #commonlisp
<weary>
yes, postscript is lifo. i am just wondering what's weird about that to you.
mariari has joined #commonlisp
<Guest74>
it would be nice to do (funcall fn (pop stack)..(pop stack))
<weary>
isn't cl pop backwards anyway?
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 255 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<White_Flame>
at least in forth, usually implementations call the function, then the function pops the arguments itself
<White_Flame>
this is especially important since the number of values consumed can vary at runtime
<X-Scale>
PostScript is strongly inspired by Forth
<White_Flame>
and of course the function can just mutate the stacks for levels that are both pushed & popped
<White_Flame>
eg, add = pop x, tos += x
<White_Flame>
instead of pop, pop, add, push
<White_Flame>
X-Scale: yeah, I've done both forth & ps, though I don't remember enough specifics about ps to know how much applies
<Guest74>
i think it's ugly having to do (apply fn (reverse(list (pop stack)..(pop stack))))))))))
<White_Flame>
I'm saying you shouldn't be using apply/funcall with args at all
<White_Flame>
because that will break things
<White_Flame>
or at least make some things impossible
<Guest74>
break what?
<White_Flame>
<White_Flame> this is especially important since the number of values consumed can vary at runtime
<Guest74>
they can't though. this is just for type 1 fonts. I'm not writing a ps interpreter.
<White_Flame>
of course, I guess you could just assume 0 parameters, or N static parameters for the sake of the funcall/apply and still let the function itself pop the rest
<White_Flame>
but again, always popping can be a performance hit vs mutating the stack cells directly, especially as there's lots of small low-level calls in stack langauges
<Guest74>
the functions only take a static amount of args.
<White_Flame>
the postscript functions?
<White_Flame>
or the lisp functions?
<Guest74>
adobe's claim is that it's possible to use type 1 fonts without a ps interpreter by just ignoring anything that is postscript and implementing some specific well documented functions.
<Guest74>
I call vector graphic functions that do take varying amounts of args but that makes no difference.
morganw has quit [Remote host closed the connection]
aeth has joined #commonlisp
<weary>
> i think it's ugly having to do [snippet]
<weary>
couldn't you just use roll?
<weary>
oh, just read down to the part where you said you're trying to avoid postscriptyness
<weary>
yeah there's definitely a degree of inconvenience you're going to hit up on here
<weary>
but i don't think that's postscript's fault personally
aeth has quit [Ping timeout: 246 seconds]
lisp123 has joined #commonlisp
<Guest74>
I just wonder how they do it internally. If I do I write an interpreter I'd probably use an adjustable vector and pull off sequences.
lisp123 has quit [Ping timeout: 258 seconds]
<weary>
"I just wonder how they do it internally." -> you wonder how postscript interpreters work, internally?
<weary>
the execution model is actually pretty simple
weary has quit [Remote host closed the connection]
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
karlosz has joined #commonlisp
aartaka has quit [Ping timeout: 255 seconds]
aartaka has joined #commonlisp
pillton has joined #commonlisp
akoana has joined #commonlisp
icer has joined #commonlisp
icer has left #commonlisp [Leaving.]
irc_user has quit [Quit: Connection closed for inactivity]
<beach>
Good morning everyone!
tyson2 has quit [Remote host closed the connection]
yewscion has quit [Ping timeout: 276 seconds]
Bike has quit [Quit: Connection closed]
pranavats has left #commonlisp [#commonlisp]
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
aeth has joined #commonlisp
akoana has quit [Ping timeout: 255 seconds]
totoro has joined #commonlisp
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
irc_user has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 240 seconds]
shka has joined #commonlisp
<char[m]>
What` is a good way to forward an input stream to an output stream?
kiki_lamb has joined #commonlisp
<char[m]>
uiop:slurp-stream-input-stream look like the way.
kiki_lamb has quit [Client Quit]
pve has joined #commonlisp
karlosz has quit [Ping timeout: 240 seconds]
azimut has quit [Ping timeout: 240 seconds]
prokhor has joined #commonlisp
irc_user has quit [Quit: Connection closed for inactivity]
tok has joined #commonlisp
rainthree has joined #commonlisp
ttree has quit [Ping timeout: 244 seconds]
attila_lendvai has joined #commonlisp
pve has quit [Quit: leaving]
attila_lendvai has quit [Ping timeout: 276 seconds]
rotateq has joined #commonlisp
pillton has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
pve has joined #commonlisp
treflip has joined #commonlisp
random-nick has joined #commonlisp
tok has quit [Remote host closed the connection]
tok has joined #commonlisp
tok has quit [Quit: ERC 5.4.1 (IRC client for GNU Emacs 29.0.50)]
Th30n has joined #commonlisp
tok has joined #commonlisp
tok has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 240 seconds]
pranavats has joined #commonlisp
<utis>
is it possible to get something like #'with-output-to-vector ?
<semz>
ccl has that as an extension
<rotateq>
utis: Yes you get the macro-function object by that (in SBCL what I see here now), but it's not applyable, as well, it's a macro.
kpoeck has joined #commonlisp
<rotateq>
semz: Is it then like with with-open-file, creating such and cleaning up with unwind-protect afterwards?
<semz>
...erm, CCL has it as a macro. What rotateq says applies to CCL just as well.
<semz>
it's closer to with-output-to-string
notzmv has joined #commonlisp
<rotateq>
Ah okay.
<bollu>
beach good morning!
<utis>
so, on sbcl, if i have a method for writing a string as utf-8 to a stream, can i get a utf-8 vector without going through a temporary file?
kpoeck has quit [Quit: Client closed]
<beach>
Sure, make the stream a Gray stream.
treflip` has joined #commonlisp
treflip` has quit [Remote host closed the connection]
treflip has quit [Ping timeout: 258 seconds]
<utis>
ah, thanks!
<beach>
Sure. Good luck.
Dynom has joined #commonlisp
<jackdaniel>
utis: since you ask about sbcl, just use (sb-ext:string-to-octets …)
<jackdaniel>
also, the library babel (I think) has the function that does exactly that
Th30n has quit [Ping timeout: 256 seconds]
<utis>
perfect
tibfulv has quit [Remote host closed the connection]
<rotateq>
Can someone describe to me in some simple words where the differences are between a "normal" stream and a gray stream?
tibfulv has joined #commonlisp
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
<jackdaniel>
a "normal" stream is an instance of a stream provided by the implementation (i.e a string-stream, or a file-stream), it is not a standard-class (i.e you can't extend them)
<jackdaniel>
gray stream is a user-specified stream
<rotateq>
ah cool
<jackdaniel>
gray as in Gray, the name of the person who proposed the extension (and not the color name in american english)
<rotateq>
haha okay, I once tried reading about those and this is what stuck :)
<mfiano>
They are incredibly useful if you aren't hell-bent on performance like a lot of people are. Embrace the CLOS :)
<mfiano>
So my backup replication application has been running for a few days on a test subnet and in "perfect" working status, however, I notice that it performs a lot of syscalls that have to wait on the filesystem driver, when in actuality, it can cache 90% of them on the first iteration, so I am not quite ready to release it yet. It deserves more CLOSification.
lisp123 has joined #commonlisp
<mfiano>
I also just found what I firmly believe to be an SBCL bug after a few hours of debugging, but I haven't been able to reduce it to a simple test case.
<mfiano>
I was able to work around it though. I didn't actually need an output stream when a list of strings worked fine.
<lisp123>
what is it?
<mfiano>
The bug is, that when constructing a condition report with a string obtained from get-output-stream-string, and making sure to #'finish-output (or even #'force-output), to condition displays just fine, however I am also writing to a log file with the same finished/forced stream string, and only the first line shows up (of 3).
<mfiano>
It's a little more involved than that, but that's the simple explanation.
<lisp123>
interesting
<mfiano>
I didn't actually need a stream though, just a stack of strings I could #'format with ~{
<mfiano>
To be honest, a list is more correct anyway, since I was testing if #'file-position was plusp to see if errors should be signalled/written to disk. #'file-position is not guaranteed to return anything but NIL though as per the standard. It is much safer to check non-NIL with a list of strings.
aartaka has quit [Ping timeout: 244 seconds]
pranavats has left #commonlisp [Error from remote client]
aartaka has joined #commonlisp
<jackdaniel>
my first guess would be that you have a dynamic extend for the string-stream and you use that stream outside of that context
<mfiano>
Actually no. This was all done in the lexical environment of a single function.
<mfiano>
If I have time later I'll try to reduce it to a simple test case, but I admit that may be difficult, as this mostly only occurred in the context of a dumped executable image.
aartaka has quit [Read error: Connection reset by peer]
lisp123 has quit [Remote host closed the connection]
<pve>
Hello! The hyperspec page for call-next-method mentions, in "Exceptional situations", that "the ordered set of applicable methods for a changed set of arguments for call-next-method must be the same as the ordered set of applicable methods for the original arguments to the generic function."
<pve>
I'm not entirely sure I understand this. Are there any illuminating examples I could look at?
<pjb>
it means you must not change the set of applicable methods during the execution of a chain of call-next-method
<pjb>
or the class of the arguments. ie call-next-method doesn't redo the dispatching.
<pve>
hmm ok, sbcl will let me do something like (defmethod select-node (selector (page page)) (call-next-method selector (node page)))
<jdz>
It says you must not do (call-next-method 42) in a method that is specialized on STRING.
<pve>
(in the context of examining html docs)
<pve>
where the method select-node t t is defined
<pve>
jdz: yeah ok that I understand
<jdz>
Even if SBCL "lets" you do it, does not mean the result is sound. SBCL probably just does not check whether you're shooting yourself in the foot or not.
<pve>
does sbcl not complain because the next applicable method is the "t t" method?
<pve>
hm ok
<jdz>
If the next method is the one that is unspecialized you're probably safe (just my feeling).
<jdz>
The model in my head is that the effective method is computed for the initial arguments, and if you change the arguments incompatibly in the middle of call-next-method it's on you.
Th30n has joined #commonlisp
Oddity has quit [Ping timeout: 276 seconds]
<pve>
So it's not undefined behaviour, I just need to make sure the arguments are compatible with the next method if I choose to mess with them?
lisp123 has joined #commonlisp
<pve>
(and that the set of applicable methods don't change)
<jackdaniel>
the requirement is to pass arguments that result in the same effective method (by virtue of having the same set of applicable methods)
<jackdaniel>
that's all. if the set of methods change, then the implementation will (or at least should) signal an error
<beach>
pve: It is not just the SET of applicable methods that can't change. The ORDER must be the same too.
<pve>
beach: oh yes, sorry
<jackdaniel>
right
<jdz>
I'd say the behavior is implementation defined — there should not arise a situation that a method is called with arguments of incompatible types, and what an implementation does in such situations is up to them.
<jackdaniel>
well, that would be contrary to the standard requirements
Th30n has quit [Quit: Bye!]
Oddity has joined #commonlisp
lisp123 has quit [Ping timeout: 255 seconds]
<pve>
ok so to check my understanding, I managed to get SBCL to signal an error about the set of applicable methods when I defined:
<mfiano>
CCL for example, defaults to a higher safety level and this will error by default. SBCL is generally much more forgiving across the board.
Bike has joined #commonlisp
szos has joined #commonlisp
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
causal has quit [Quit: WeeChat 3.5]
fitzsim has quit [Remote host closed the connection]
taiju has joined #commonlisp
<Guest74>
So what have people used call-next-method for?
<rotateq>
Guest74: Afaik it's for example to go further from an :around method.
<beach>
One typical use is when you have an :AROUND method and you want to conditionally call the primary method.
<Guest74>
and you're using the :around to block normal execution for a specific purpose?
<beach>
Also, when you have several primary methods, and you want to invoke a less specific one from the more specific one.
<beach>
Guest74: Typically yes. You may have some cached value to use and you want to call the primary method to compute it if not.
<Guest74>
I'm wondering what people have actually used it for, in hopefully innovative ways.
<pjb>
Guest74: it's to forward the message to super.
<Shinmera>
I've used it plenty for exactly what beach mentioned.
<beach>
Guest74: It is used in several standard CLOS techniques. I am not sure why it would have to be innovative.
dec0d3r has quit [Quit: Leaving]
<Guest74>
at least to me, reading code is more eye opening than discussion of possibilities
<Shinmera>
Off the top of my head: in Kandria there's a superclass for any entity that can take damage. The player has an around method on the damage function to either reduce or elide it depending on the user's accessibility options.
<Guest74>
beach: if it was innovative I probably haven't thought of it before and who isn't interested in things they haven't thought of before?
<Guest74>
Shinmera: nice, that's interesting and wouldn't have been my first thought.
<Shinmera>
If you grep through my sources for :around I'm sure you'll find plenty of examples :)
<Guest74>
So you only use call-next-method in :around?
<Shinmera>
No, of course not
<Shinmera>
It can also be useful in primaries, in case I need fine grained control over the order in which methods are called.
<Guest74>
lol, my biggest use appears to be in print-object
<Guest74>
it'd be nice to browse github repositories through the repl.
<Josh_2>
GM
<Josh_2>
I make heavy use of call-next-method for exactly what beach mentioned
<Josh_2>
Primarily in :around methods
<Guest74>
example code?
<Josh_2>
Sure
rainthree has quit [Read error: Connection reset by peer]
<rotateq>
And combine that maybe with next-method-p.
<Josh_2>
I have a few main classes that are made from mixins, I am using this generic to automatically convert the slots provided by mixins into HTML
<Josh_2>
using :around to generate inline style after the applicable methods are called
<rotateq>
Josh_2: useful too, that :around is available for other method combinations than standard, too
<beach>
Guest74: Imagine you have a library for manipulating geometric objects, and you want client code to be able to subclass your classes. You tell clients to provide a method on the generic function AREA that computes the area of objects that are instances of client-supplied subclasses.
<beach>
But computing the area may be expensive, so the library provides an :AROUND method on AREA, specialized to the base class GEOMETRIC-OBJECT. The :AROUND method checks whether there is a cached value of the area and then returns it. Otherwise, it invokes CALL-NEXT-METHOD and caches the value. This mechanism is then invisible to client code.
<Josh_2>
I have never considered using an :around to aid with memoization
<beach>
Well, this is the "cached value" scenario that I hinted about before.
<Guest74>
Josh_2: that's an interesting way to generate html.
<jackdaniel>
mmclim does that for bounding boxes
pranavats has joined #commonlisp
<jackdaniel>
mc*
<Guest74>
you construct and cache bounding boxes without the objects 'participation'?
<beach>
The participation is by means of the primary method.
<jackdaniel>
bbox slot is added as part of the mixin class
<Guest74>
oh, ok, so it's not some magic attribute without a slot.
<beach>
Guest74: But the thing here is that only the base class needs to be concerned with the caching. Methods on subclasses just compute.
<jackdaniel>
you could store that in an external hash table too, but I'm not sure whether there is a useful scenario for doing that (since you need to mix a class either way to add the around method)
kpoeck has quit [Quit: Client closed]
<beach>
Guest74: But this is not "innovative". As you see, the technique is used by several people in several programs.
<Guest74>
it's 'innovative' to me.
<beach>
Well, then. You have your answer.
<jackdaniel>
having many around methods that conditionally skip computation is a wonderful opportunity to introduce hard to spot bugs
<Guest74>
well, sort of. like I said, i like code better than discussions.
<jackdaniel>
ibrd - innovative bug ridden development
<Guest74>
jackdaniel: that's what i was thinking
<beach>
jackdaniel: You must be traumatized by that scenario as you mention it pretty often. :)
<Guest74>
at least for one possible use I can see, which is dealing with vector fonts.
<jackdaniel>
beach: no, not really; it is just a cautionary tale
<jackdaniel>
it is just that bugs more often flock "around" auxilliary methods
fitzsim has joined #commonlisp
<Guest74>
I've been trying to think of a nice way to have fonts report transformed measurements without having to constantly recalculate them.
orestarod has joined #commonlisp
<Guest74>
right now I just have fonts report in font units with an &optional size which reports in screen units for the given size.
razetime has joined #commonlisp
<Guest74>
though I guess it might get confusing to have to remember what size the font is at if you can change it any time.
<Guest74>
I've thought of adding a REALIZE method that would take a vector font and transform all coordinates and measurements into display measurements, apply the hinting and return a new font object for only that point size stored in a relative vector format.
<jackdaniel>
another somewhat interesting method to delay computation is defining a slot-unbound method
<Guest74>
I guess separating that out from your accessor is a good thing.
kpoeck has joined #commonlisp
rainthree has joined #commonlisp
<Josh_2>
jackdaniel: mind blown :joy:
<Josh_2>
I did not realize that was a generic
<Guest74>
too bad there wasn't one for unb(f)ound package
* mfiano
wonders if alexandria or another utility library has something like a "push multiple" macro
<mfiano>
similar to list* instead of cons
<jackdaniel>
appendf ;?
<Guest74>
so setf append?
<Guest74>
what he said
<jackdaniel>
or you want to reverse the order of the first list?
<mfiano>
I'm looking to prepend a couple elements to a large list without writing the trivial macro myself
<Guest74>
revappend?
akoana has joined #commonlisp
<mfiano>
I could do (setf place (list* foo bar place) but meh
<Guest74>
sorry, nreconc is what I was thinking.
<mfiano>
Also I want to prepend instead of append because the original list is a literal
<mfiano>
And I want to share structure with it rather than have undefined behavior
<jackdaniel>
you'd write a simple wrapper macro around list* two times in the meantime :)
<jackdaniel>
it is literally (ha!) (setf place (list* foo bar place)
<mfiano>
Oh
<mfiano>
I see
<jackdaniel>
it changes the pointer value
<mfiano>
Right
<mfiano>
Seems like a useful thing for my utility library that re-exports alexandria with my other stuff :)
<jackdaniel>
it may get messy when you put as place something like (cdr x), that's why I've suggested to assert that the place is a symbol
<jackdaniel>
perhaps it won't get messy for cdr, but you know what I mean
<mfiano>
I'd mostly use it with a class accessor call as a place
<jackdaniel>
wherever (setf <x> (list* … <x>)) works this macro will work too
azimut has joined #commonlisp
<mfiano>
So why would I need to assert that the place is a symbol?
Oladon has joined #commonlisp
<jackdaniel>
you don't need to do that; the macro expands to setf and it will do the right thing. I've confused myself by considering setf expander concerns in this macro
<mfiano>
I'd almost always want the place to be a form of (some-accessor some-instance) which is not a symbol.
<mfiano>
But it doesn't seem to work how I expect in certain cases
<mfiano>
Oh I confused myself as well
<mfiano>
This is fine, thank you.
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
jealousmonk has quit [Ping timeout: 276 seconds]
<jackdaniel>
sure
taiju has quit [Ping timeout: 240 seconds]
anticomputer has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
waleee has quit [Ping timeout: 240 seconds]
akoana has quit [Ping timeout: 276 seconds]
gaqwas has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
Oladon has quit [Quit: Leaving.]
Oladon has joined #commonlisp
razetime has quit [Ping timeout: 276 seconds]
jolby has joined #commonlisp
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #commonlisp
aartaka has quit [Ping timeout: 240 seconds]
aartaka has joined #commonlisp
tyson2 has joined #commonlisp
jealousmonk has joined #commonlisp
gaqwas has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
gaqwas has joined #commonlisp
kpoeck has quit [Ping timeout: 252 seconds]
morganw has joined #commonlisp
Guest74 has quit [Quit: Connection closed]
Oladon has quit [Quit: Leaving.]
gaqwas has quit [Remote host closed the connection]
gaqwas has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
<utis>
i've made an executable, executed it in a terminal, and connected to it with sly. can i now type something in the repl that will print something on the terminal?
<jackdaniel>
yes, but you need to find the stream ,)
<jackdaniel>
the easiest way to do that is to type in the console
<jackdaniel>
(defvar *console-io* *query-io*)
<jackdaniel>
and then, from sly: (format *console-io* "hello world!~%")
<jackdaniel>
utis: ^
Oddity has joined #commonlisp
<utis>
hm . . that doesn't seem to work for me
<jackdaniel>
did you type defvar in the actual terminal?
<utis>
no, i don't have a repl there
<jackdaniel>
so, the idea I've suggested must be executed in the terminal, before sly binds streams to its own thing
<utis>
all right, thanks
Catie has quit [Ping timeout: 250 seconds]
pranavats has left #commonlisp [Error from remote client]
<utis>
still doesn't work if i put the defvar into the program
waleee has joined #commonlisp
rainthree has quit [Ping timeout: 246 seconds]
<rotateq>
utis: Maybe it's already bound and you would need defparameter instead?
treflip has quit [Quit: bye!]
<utis>
that didn't change anything. it seems to be bound to *terminal-io*
<utis>
or maybe not
<utis>
#<synonym stream :symbol *terminal-io* . .
<jackdaniel>
then instead of binding query-io try binding terminal-io
<ecraven>
beach: if you have a minute, we were talking about your reader reading even comments, how are they represented in the read forms? are they metadata that exists in addition to the form that is read, or are they part of the form (special instances or structs or something?)
<rotateq>
I think he comes up in around 7h the next time. (just a hint so you don't wait too long)
<rotateq>
ecraven: Do you mean with eclector or the default definition?
<ecraven>
I'd be interested in both cases ;)
<ecraven>
it's not urgent, just something I've been thinking about
<rotateq>
Okay so the default is like for the #\; readmacro: "Advance stream to next #\Newline and throw away all information."
<rotateq>
eclector then makes it available *not* loosing information about those source parts itself, like in which line and how long
<rotateq>
Or when you use #| ... |# to write in line comments.
Dynom has quit [Quit: WeeChat 3.5]
<Bike>
i am pretty sure they are not part of the forms, though. i think stuff like that is returned as extra values from READ.
<Nilby>
as rotateq eluded to, you don't even need eclector to read comments. you just do it with changing the readtable on a standard lisp reader.
<rotateq>
One of my next steps would be using named-readtables to switch between different ones if needed.
<rotateq>
In assembly the #\; is sometimes used similarly, in languages like C it's to end statements.
<rotateq>
ecraven: Or when the reader sees a '"' I imagine it the way, that until another unescaped '"' is read from stream, all chars are taken literally to store in a simple-string, so no other readmacro has effect inside this scope. (again just default, no barrier to do otherwise)