<saturn2>
has anyone else noticed that dexador leaks file descriptors a lot?
notzmv has quit [Read error: Connection reset by peer]
<aeth>
I realize that Apress as a publisher seems to be the only publisher publishing Common Lisp books, but... damn, I must have unsubscribed from their email spam 5x and I still get it.
karlosz has joined #lisp
edgar-rft has joined #lisp
space_otter has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 244 seconds]
diamondbond has joined #lisp
ayuce has quit [Remote host closed the connection]
wxie has joined #lisp
diamondbond has quit [Ping timeout: 244 seconds]
<kinope>
I know next to nothing about garbage collectors, but out of curiosity, is it possible to provide an implementation of a garbage collector to be used instead of the one that already exists? Perhaps to change it's characteristics to be more suited to soft-realtime applications.
notzmv has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
netctrl has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
<edgar-rft>
kinope: It's not possible to replace the builtin garbage collector entirely but there are many of ways to write your own memory management in Lisp, PAIP describes some of them (Paradigms of Artificial Intelligence Programming by Peter Norvig).
<edgar-rft>
If you tell a specific example we can help you better :-)
<saturn2>
it's not intrinsically impossible, but most implementations don't allow it
<White_Flame>
many are still written in C instead of CL
<White_Flame>
as part of a bootstrap runtime
brettgilio has joined #lisp
vutral has joined #lisp
<kinope>
Okay cool, thanks guys. I don't have a specific example, just curious.
<kinope>
Looking closer at garbage collection may be in my future if I get into soft-realtime applications like games or media encoding/decoding and playback.
<White_Flame>
you can always try a poor man's version in sizing your nursery large enough to contain work done in a pass, and manually calling the GC
<White_Flame>
to attempt to normalize the gc pause times fairly well
<kinope>
Okay I'll try to remember that, now I know nurseries are a thing.
<kinope>
what is the purpose of a nursery?
orivej has quit [Ping timeout: 246 seconds]
<edgar-rft>
kinope: in games for example it's a common strategy to pre-allocate things you need at the beginning of the game, re-use them during the game as much as possible, and manually call the garbage collector when a level is finished.
<kinope>
Oh so is it possible to tell the garbage collector to not run automatically? or will it always be run under certain circumstances
<saturn2>
typically it will run every time the nursery becomes full
<saturn2>
the purpose of a nursery is to run the GC every time a certain amount of memory has been allocated, and to scan newly created objects more often, since they are more likely to be garbage
EvW has quit [Ping timeout: 260 seconds]
bsd4me has joined #lisp
<edgar-rft>
kinope: in all Lisp implementations I know the garbage collector can be configured and also called manually from program code. But this is not specified by ANSI, instead you must read the manuals of the respective Common Lisp implementation.
<aeth>
So, portably, (afaik) all you can do is (trivial-garbage:gc :full t) at the times when you know you can handle potential GC pauses, and hope that's enough to avoid it the rest of the time
<xristos>
i think it's safe to say that if you're after finegrained GC control, portability libraries is not the way to do it
<xristos>
rather focus on a specific implementation and see what it offers
<aeth>
If you focus on SBCL, you can just avoid allocating (it's hard, though) and profile everything for "consing" (heap allocations) to make sure nothing falls through. I think this means the GC won't run.
<xristos>
SBCL GC is quite configurable through various parameters
<aeth>
kinope: In my game engine I just use SB-PROFILE to guarantee that the game loop (anything before is afaik fine) doesn't cons, mainly through preallocation but with a few tricky parts using (declare (dynamic-extent foo))
<aeth>
It's not as hard as it sounds because a game is probably mostly a bunch of single-float arrays.
FreeBirdLjj has quit [Remote host closed the connection]
<aeth>
It's not easy, though... e.g. I had to write my own vector math library because no one else has this constraint... and none of my example games using the engine avoid consing in the game loop
<moon-child>
if it's this fragile and this much work to maintain, I would rather just use a language with manual memory management. (Or a lisp that uses rc?)
<xristos>
moon-child: i suggest you try it out and form your own conclusions, rather than accepting what people say on IRC as gospel
<xristos>
it can be as simple or as complex as you make it
<xristos>
and in many cases, it doesn't have to be complex
diamondbond has joined #lisp
<aeth>
moon-child: I mean, nobody has to do this
<aeth>
moon-child: but it's probably still less work than using C++
<aeth>
And it compiles almost instantly, which is more than you can ask of any language I know of that has no GC
<moon-child>
I mean, gc is fine. The only problem is tracing non-rt gc because it has unreliable pause times. So, maybe clojure with zgc?
<aeth>
This isn't the channel to trashtalk other languages (#lispcafe is) but Clojure would be terrible for games because as I said they're basically just mutable arrays of single floats.
Archenoth has quit [Read error: Connection reset by peer]
<aeth>
So any language that focuses on immutability would either (1) make the efficient impossible or (2) make the efficient nonidiomatic
<moon-child>
(can also just accept the occasional stutters; they're not that bad. It just seems to me like wasted effort to force a gc language to do non-gc stuff)
<moon-child>
aeth, depends on what part of the game. Graphics is all mutable arrays of floats; other things get to be more interesting sometimes
<aeth>
You can GC as much as you want at macro time, or before the loop starts, or even between levels if you get that far.
Lycurgus has joined #lisp
<aeth>
You can also GC during the level if you're willing to lose some performance for the worst case, and you probably can. You can do a lot in 0.01 seconds.
<moon-child>
I wonder if running gc manually and keying it to player input would work? Stutter doesn't really matter when you're not moving
Lycurgus has quit [Remote host closed the connection]
<aeth>
Most things you think of that can allocate wouldn't be allocating in the normal part of a game loop unless you're doing some building game, and even then you could probably come up with an architecture
<aeth>
I guess maybe open world level streaming or something, but open worlds are expensive to make
<aeth>
although to be fair, it would be potentially consing if I didn't have an entity limit (preallocated in advance) and it adjusted to make room for new entities when the entities were full
<moon-child>
ha, fair enough
<aeth>
and, worse, if adjustable it would insert bounds checks on every array access since now it wouldn't know at compile time what the length is
<aeth>
I think it's far more impressive that almost every bounds check isn't there in SBCL than that it's non-consing
<aeth>
Known entity-limit => known to be in bounds if not full.
<saturn2>
if you could just limit the garbage collector to only run for a certain amount of time per cycle, that would probably be good enough for most games
<moon-child>
what's wrong with concurrent gc?
<aeth>
I mean, I have 12 cores 24 threads, use them all
<saturn2>
moon-child: there aren't enough sbcl developers to write one
Alfr__ has joined #lisp
Alfr_ has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
EvW1 has joined #lisp
<White_Flame>
also fully current GCs slow down the system
<White_Flame>
*concurrent
<White_Flame>
the main code will usually need additional read and/or write barriers on everything
<beach>
Good morning everyone!
bernard__ has joined #lisp
diamondbond has quit [Ping timeout: 260 seconds]
bernard__ has left #lisp [#lisp]
Oladon has joined #lisp
<moon-child>
White_Flame: this isn't the 90s. A loss in performance in exchange for better abstractions is an acceptable tradeoff
<White_Flame>
well, real-time tends to be about performance
<White_Flame>
a subsection of which is latency
<moon-child>
real-time means, effectively, no latency. Real-time GCs have minimal effect on latency. (Not something you'd want to use for HFT, but zgc max pause time is 1ms--more than reasonable for video games, where a frame is 16ms)
<White_Flame>
unless you're munching enough memory to trigger 8+ of those per frame ;)
mindCrime has quit [Excess Flood]
mindCrime has joined #lisp
<White_Flame>
but still, the tradeoff could still be that your frame runs in 12ms + long GC pauses, or in 20ms with realtime GC/short pauses
<moon-child>
I would take the latter any day
<White_Flame>
(numbers pulled from the Department of Posterior Fabrication)
<moon-child>
iirc worst-case performance hit was 40-50%. Average more like 15%
vutral has quit [Quit: Connection closed for inactivity]
FreeBirdLjj has quit [Remote host closed the connection]
aurelius has joined #lisp
equwal has joined #lisp
FreeBirdLjj has joined #lisp
edgar-rft has quit [Quit: Leaving]
aurelius has quit []
EvW1 has quit [Ping timeout: 244 seconds]
shangul has joined #lisp
<seok>
why is C-c C-c unbound on my emacs
<seok>
: /
<seok>
which mode enables C-c C-c?
<seok>
its disabled for one buffer only
<seok>
bah. restart fixed it
<seok>
slimes been buggy last couple of days
<White_Flame>
make sure to add (setq bugs nil) in your .emacs file
<kinope>
I had to duck out, but I appreciate the discussion re: garbage collection.
krid has quit [Ping timeout: 240 seconds]
<seok>
White_Flame lol
shifty has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
tmpnode1 has joined #lisp
<aeth>
moon-child: Don't tie your logic to your graphics framerate or you introduce all sorts of fun bugs because the varying physics step size can produce very different results... The renderer runs at 16 ms, but the logic can run at anything. 10 ms is a nice, round number for that.
Fare has quit [Ping timeout: 260 seconds]
<aeth>
White_Flame: Using a RTGC for RT programming is about predictability, not necessarily being faster. A fixed overhead is better (less noticable) than dropping frames with a GC pause.
FreeBirdLjj has quit [Ping timeout: 260 seconds]
bsd4me has quit [Quit: Leaving]
Oladon has quit [Quit: Leaving.]
<beach>
kinope: So, in summary, the garbage collector is most often tied to the data representation of the Common Lisp implementation, so you typically can't replace it with a different one. You can, of course, implement a totally different garbage-collection algorithm for a particular implementation, but that's a lot of work.
<beach>
kinope: Another important piece of information is that most current Common Lisp implementations were written several decades ago, so the garbage-collection technology they use is from that time. A lot of progress has been made on garbage collection since then.
karlosz has quit [Quit: karlosz]
even4void has joined #lisp
mangul has joined #lisp
shangul has quit [Ping timeout: 240 seconds]
gravicappa has joined #lisp
im663 has joined #lisp
<im663>
Hi there, I was trying to get a lisp project up and running, and I was running into an error, I'm not sure if there are any mastadon/gab users that are interesting in possibly looking at the code with me
<im663>
When I attempt to use gab.com as my instance I get a "Invalid URI scheme: ~S" error, this is not the case however with other Mastadon instances, I'm not exactly sure why this is occuring
<tmpnode1>
Hello, having problems with troubleshooting the alien-funcall function in SBCL lisp.I am trying to call this function from c:char* hello (char* name){ char* test = strcat("Hello ", name); return (test);}The lisp code is:(let ((name (make-alien (* char) (length "test")))))(setf name "test")(alien-funcall (extern-alien "hello" (function (* char) (*
<tmpnode1>
char)) name))
<moon-child>
aeth: I don't mean tie logic to framerate. I mean, trigger collection cycles manually when there's not a lot happening on the screen so a stutter wouldn't be as noticeable
<tmpnode1>
The main part I am scratching my head at is: (alien-funcall (extern-alien "hello" (function (* char) (* char)) name))
<markasoftware>
when are the :type s verified in a class?
brettgilio has left #lisp ["ERC (IRC client for Emacs 26.3)"]
<beach>
markasoftware: Depends on the implementation. I think SBCL does it with high DEBUG setting. Unfortunately, the DEBUG setting in SBCL is not at its highest by default.
<markasoftware>
so it's not checked at all usually?
<markasoftware>
this is highly disappointing
<aeth>
The SBCL solution is to use DEFSTRUCT when types matter, but unfortunately some other implementations check in DEFCLASS, but not in DEFSTRUCT
<aeth>
So there are two directions you can go when you must type check. You can write a DEFSTRUCT* that inserts CHECK-TYPEs in those non-SBCL implementations when they're missing, or you can use the Metaobject Protocol to guarantee type checks in a metaclass so you can use DEFCLASS.
gravicappa has quit [Ping timeout: 256 seconds]
brown121408 has joined #lisp
brown121408 has quit [Client Quit]
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
<beach>
tmpnode1: Since you are using SBCL-specific stuff, you may want to ask in #sbcl. Or, even better, you can program in Common Lisp instead.
minerjoe has joined #lisp
farooqkz__ has joined #lisp
even4void has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Lycurgus has joined #lisp
mangul has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
jonatack has quit [Ping timeout: 272 seconds]
space_otter has quit [Ping timeout: 246 seconds]
<tmpnode1>
beach will do
gaqwas has joined #lisp
pve has joined #lisp
retropikzel has joined #lisp
space_otter has joined #lisp
retropikzel has quit [Remote host closed the connection]
retropikzel has joined #lisp
space_otter has quit [Ping timeout: 240 seconds]
seok53 has joined #lisp
seok53 has quit [Remote host closed the connection]
<seok>
Is writing to file acid?
<seok>
How can I make it y
<seok>
acid
<phoe>
not without some OS support I think
<seok>
Hi phoe
<phoe>
I don't think you can easily make it transactional
<seok>
maybe I can make a temporary folder
<seok>
and move when done instead?
<phoe>
I think that's the closest to acid that you can get, yes - write elsewhere, and then move
<seok>
ugh, might be safer to use postgres
<phoe>
I agree with that one
brettgilio has joined #lisp
space_otter has joined #lisp
gaqwas has quit [Remote host closed the connection]
<phoe>
but CLISP complains that MAKE-CONDITION: cannot find a CONDITION class that is a subtype of (AND ERROR (SATISFIES FOO))
<phoe>
so it's not all that omnipotent
<beach>
I see.
<ldb>
Today I find a well formatted PDF of CLtL2 in Axiom CAS's code archieve, it is better than the one avaliable from CMU AI Repo, with full index and hyperlinks enabled.
<beach>
phoe: So, as I just said in #sicl, I think I will make make-condition a generic function. The default method signals an error. The method specialized to SYMBOL does a FIND-CLASS with ERROR-P being true. And the method specialized to CONDITION-CLASS calls MAKE-INSTANCE.
<phoe>
yes, I suggest you treat it the same way as MAKE-INSTANCE which seems to be the way to go
<beach>
OK, thanks for confirming.
<beach>
I was concerned about giving good error messages in case things go wrong.
<beach>
I think I can with my suggestion.
<phoe>
sure, if the thing is of unknown type then you could signal a type-error and/or no-applicable-method; if no class is found then class-not-found or whatever else you have; elsewhere you can proceed with make-instance
<beach>
Exactly.
jonatack has joined #lisp
gaqwas has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
gaqwas has quit [Changing host]
gaqwas has joined #lisp
jonatack has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
aurelius has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
aurelius has quit [Read error: Connection reset by peer]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 260 seconds]
MindForeverVoyag has quit [Ping timeout: 256 seconds]
MindForeverVoyag has joined #lisp
orivej has joined #lisp
FreeBirdLjj has joined #lisp
im663 has quit [Remote host closed the connection]
Lycurgus has quit [Remote host closed the connection]
contrapunctus has left #lisp ["Disconnected: closed"]
farooqkz__ has quit [Ping timeout: 256 seconds]
heredoc has quit [Ping timeout: 244 seconds]
markong has joined #lisp
space_otter has quit [Remote host closed the connection]
bhartrihari has left #lisp ["Disconnected: closed"]
markong has quit [Ping timeout: 240 seconds]
markong has joined #lisp
wxie has quit [Remote host closed the connection]
wxie has joined #lisp
heredoc has joined #lisp
drot has quit [Read error: Connection reset by peer]
shinohai has quit [Read error: Connection reset by peer]
mindCrime has quit [Ping timeout: 260 seconds]
ldb has quit [Ping timeout: 256 seconds]
mindCrime has joined #lisp
<beach>
phoe: Since you are an expert in the condition system, I would like to bounce an idea on you. The basis for my idea is that I want to be able to make condition reporters subject to internationalization. I would like to know whether my idea is conforming, given the phrase in the standard saying that defining :REPORT is "equivalent to... (DEFMETHOD PRINT-OBJECT....)".
<beach>
So the idea is as follows: I define a mixin class for condition classes. It is included in the list of superclasses when the :REPORT option is given and not otherwise.
<beach>
PRINT-OBJECT has a single method (DEFMETHOD PRINT-OBJECT ((OBJECT THAT-MIXIN-CLASS) STREAM) (IF *PRINT-ESCAPE* (CALL-NEXT-METHOD) (PRINT-CONDITION OBJECT STREAM))).
<beach>
PRINT-CONDITION trampolines to (PRINT-CONDITION-USING-CLIENT *CLIENT* OBJECT STREAM).
<beach>
The default condition on PRINT-CONDITION-USING-CLIENT accesses the print function in the mixin class. But client code can define methods on PRINT-CONDITION-USING-CLIENT specialized to other clients, and those methods can print using a different language or whatever.
<beach>
This idea not only allows for internationalization, but it also avoids adding and removing methods from PRINT-METHOD when the condition class is defined/redefined.
<beach>
phoe: I am taking a long-ish lunch break, but I'll read any opinions of yours when I get back.
mindCrime has quit [Ping timeout: 240 seconds]
<phoe>
beach: that's the way I imagined.
<phoe>
I mean, when I started reading this block of text, I was like, "oh, he wants to do that with clients"
<phoe>
and I wasn't disappointed
<phoe>
internationalized code can define its own client class; if anything, you could possibly extend DEFINE-CONDITION :REPORT to accept some sort of client argument that will allow one to easily write multiple :REPORT clauses for different langs.
drot has joined #lisp
farooqkz__ is now known as shangul
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
random-nick has joined #lisp
ggole has joined #lisp
bhartrihari has joined #lisp
v3ga has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
q3d has joined #lisp
ldb has quit [Quit: leaving]
gigetoo has quit [Ping timeout: 240 seconds]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
gigetoo has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
wxie has quit [Ping timeout: 256 seconds]
Lycurgus has joined #lisp
edgar-rft has joined #lisp
q3d has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
orivej has joined #lisp
wxie has joined #lisp
oni-on-ion has joined #lisp
bhartrihari has joined #lisp
shifty has joined #lisp
jonatack has quit [Ping timeout: 246 seconds]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
Lycurgus has quit [Remote host closed the connection]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
Inline has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
gaqwas has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
<beach>
phoe: Thanks.
orivej_ has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
mangul has joined #lisp
shifty has quit [Ping timeout: 264 seconds]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
shifty has joined #lisp
ayuce has joined #lisp
shangul has quit [Ping timeout: 260 seconds]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
FreeBirdLjj has quit [Ping timeout: 272 seconds]
puchacz has joined #lisp
<puchacz>
hi, can I re-signal the same condition from handler-bind ? or from handler-case ?
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
<phoe>
puchacz: yes
<phoe>
but
<phoe>
the idea is that the situation you're resignaling must be *the same* situation that you are trying to handle
<puchacz>
phoe: yes, the same situation. I wanted to do what I do in Java try {...} catch (MyException e) { do something, then throw e; }
<puchacz>
the same e
<puchacz>
so here I would get e, do something and (signal e)
<puchacz>
right?
paul0 has quit [Quit: Leaving]
<phoe>
you want handler-case, not handler-bind, for emulating try/catch
ebrasca has joined #lisp
<phoe>
or rather, try/catch/rethrow
<puchacz>
so calling signal on the condition that I already received is ok, isn't it?
<phoe>
note that you don't need to resignal the same condition if your handler is created using handler-bind instead and simply declines to handle the condition
<phoe>
this way next handlers will get a chance to be invoked.
<phoe>
so resignaling conditions from handler-case might not be the most idiomatic way of achieving the same thing in CL
orivej has quit [Ping timeout: 264 seconds]
orivej_ has joined #lisp
<phoe>
"is ok" - again, depends on your use case
<puchacz>
sounds like I should use handler-bind ((serious-condition (lambda (e) (do-somethign e))) body and it gets "retrhown" automatically
<phoe>
not really "rethrown"
<phoe>
it just doesn't get handled
<phoe>
but, yes, I'd suggest that
<puchacz>
okay, thanks :)
<phoe>
this way you get to execute some code and then let other handlers higher up the stack get a chance at handling it
bhartrihari has left #lisp ["Disconnected: Broken pipe"]
<puchacz>
phoe: is the only difference between handler-case / signal and handler bind that in handler-case, does not matter if I re-signal or not, the stack is unwound, so I have no restarts?
<puchacz>
actually, no
orivej_ has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
orivej has joined #lisp
minerjoe has quit [Ping timeout: 256 seconds]
contrapunctus has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
Ven`` has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
TwoNotes has joined #lisp
ft has quit [Ping timeout: 265 seconds]
jonatack has joined #lisp
Lycurgus has joined #lisp
Lycurgus has quit [Read error: Connection reset by peer]
xkapastel has joined #lisp
EvW has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
Fare has joined #lisp
_whitelogger has joined #lisp
<phoe>
puchacz: handler-case always transfers control
<phoe>
handler-bind doesn't necessarily do that
<phoe>
handler-case first performs a non-local exit and then executes forms
<phoe>
handler-bind just executes some code at the signaling site
ravndal has joined #lisp
<phoe>
I don't understand the "no restarts" part though
<phoe>
if I understand you correctly, then unwinding the stack may disestablish some restarts, and then COMPUTE-RESTARTS will have fewer restarts to find than if it was executed without first unwinding the stack
<puchacz>
phoe: I got confused with restarts as I see in emacs. this is debugger thing, orthogonal to handler-bind vs handler-case
<phoe>
not strictly debugger, but yes, the debugger tends to utilize those a real lot
kaftejiman has joined #lisp
<phoe>
if you land in the debugger, it's most often because #'ERROR was called and nothing handled the signaled condition
<phoe>
which calls INVOKE-DEBUGGER and bam, you're in the debugger
<phoe>
and the easiest option to leave it is to invoke a restart of some sort
<puchacz>
so if I have (block whatever (handler-bind ((serious-condition (lambda (e) (return-from whatever))) ....) is it like (handler-case ... (serious-condition () )) ?
<puchacz>
to take into account non-local exit
<phoe>
that's going to be equivalent, yes
<puchacz>
I think I got it then, thanks again :)
<phoe>
it becomes less equivalent if the function is more complex than a simple RETURN-FROM
<phoe>
but for this simple case it's equivalent
<puchacz>
the function that contains the whole handler or the function that is invoked on condition in handler-bind you mean?
<phoe>
I mean the concrete control flow
<phoe>
with HANDLER-CASE, you need to account for the fact that you first transfer control, and then execute handler forms
<phoe>
and this means a somewhat more complex net of possible control transfers e.g. via TAGBODY and GO
<phoe>
;; shameless plug: see my upcoming book for details
<puchacz>
oh, yes, please
<puchacz>
but still not available....
<phoe>
yes, it'll be available later this year
gravicappa has joined #lisp
<phoe>
but anyway - I think the CLHS page has an example of translating these
<phoe>
that example is a bit buggy but should work for illustrating the thing
<phoe>
the proper handler function first transfers the condition object outside the handler by setting a variable it closes over
<phoe>
then it performs a jump to the proper tag
<phoe>
and then the proper set of handler forms is executed with the condition object bound to a lexivar
<phoe>
and everything returns the values from an outermost block
<phoe>
there's also :NO-ERROR that is orthogonal because it's always possible to split a HANDLER-CASE with a :NO-ERROR into some code + a HANDLER-CASE without :NO-ERROR
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
FreeBirdLjj has joined #lisp
Inline has quit [Ping timeout: 265 seconds]
contrapunctus has left #lisp [#lisp]
ravndal has quit [Ping timeout: 264 seconds]
rawr is now known as grumble
ravndal has joined #lisp
ralt has joined #lisp
<ralt>
Hello
<ralt>
Is there a sharplispers thing for cl-fuse?
<ralt>
The library is completely unmaintained and has a couple of bugs and severely limiting features, I'm wondering if I should just maintain a fork or if there's another solution that's potentially more community-friendly
<MichaelRaskin>
Hm, never actually used the rename as rename (mv does cp-and-rm on my FS'es missing the rename). Thanks for the information
<MichaelRaskin>
ralt: It is mostly unmaintained because I have no damned idea what people would find useful direction for its extension; all my use cases are covered by different queries for QueryFS, but I do use CL-FUSE based tooling literally daily.
vornth has joined #lisp
<ralt>
MichaelRaskin: oh, great
<ralt>
The other gripe I have with it is the inability to set stat() data, e.g. mtime
<MichaelRaskin>
I am not perfectly sure if there are remaining libfuse version issues for dropping fuse-launcher
<ralt>
I'm writing a fuse fs that represents a git repository, so mtime is a fairly important metadata
<MichaelRaskin>
(symbol versioning is horrible and I gave up at some point)
<MichaelRaskin>
Ah
<ralt>
I haven't dug that deep into the lib
<MichaelRaskin>
I think once I have a monotone fs somewhere, but for git libgit wrappers were broken an I never returned to look at it
<ralt>
Hm, so, are you the maintainer? If so, should I report those issues somewhere? The monotone links all give 404, so it felt like just abandoned to me
<MichaelRaskin>
Well, at some point public monotone hostings died out, sadly.
<MichaelRaskin>
I guess Gitlab.Common-Lisp.net is the most canonical public repo now
<ralt>
ah, damn...
<ralt>
I can't manage to get an account on this gitlab
<MichaelRaskin>
(I am not sure if notifications work; I periodically _try_ to enable email notifications there; I do read the email listed in the Online Lisp Meeting talk slides, and I have an always-on bot in #query-fs)
<coltkirk>
does anyone use Colleek irc bot framework itc
Fare has quit [Ping timeout: 244 seconds]
<coltkirk>
i mean *colleen
<p_l>
Shinmera? :)
orivej has joined #lisp
<MichaelRaskin>
ralt: is «reported by Florian Margaine (ralt)» a reasonable acnowledgement or do you prefer something else?
<ralt>
That's fine, thanks!
<beach>
coltkirk: Yes, where minion is not present, Colleen comes in handy.
<beach>
coltkirk: Oh, framework, sorry.
<beach>
I thought you meant the bot itself.
<coltkirk>
oh i'd be interested in minion
<p_l>
I think most of minion sources might be included in cl-irc?
<p_l>
the actual running minion might have diverged, though
v88m has quit [Ping timeout: 256 seconds]
<p_l>
coltkirk: I honestly would recommend Colleen rather than minion as a base for something new :V
<puchacz>
is it possible to set up via command line args or something a package different to cl-user in sbcl?
<p_l>
puchacz: wdym? that REPL starts in different package?
ravndal has quit [Quit: WeeChat 2.9]
<puchacz>
when I start sbcl, I can evaluate *package* and I get:
<MichaelRaskin>
ralt: I also still have access to that github account, and I have a bot writing logs for me in #query-fs
<puchacz>
p_l: can I put something to --eval or other command line option to sbcl to have another package on startup by default?
<ralt>
MichaelRaskin: great, I'm reassured
<ralt>
What kind of logs is the bot writing?
torbo has joined #lisp
<p_l>
puchacz: let me build sbcl in a moment
<MichaelRaskin>
Just the normal channel logs via ii
shifty has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
<MichaelRaskin>
My main laptop ii is rarely online during the weekdays, but I do check for updates in the selected low-traffic channels via another ii instance on a VPS
<MichaelRaskin>
ralt: what you actually want to use in stat? I already have executable/writeable callbacks, so a times callback returning 0 to 3 values mtime (default=epoch), ctime (default=mtime) and atime (default=mtime) sounds like the simplest plan.
bhartrihari has joined #lisp
<ralt>
MichaelRaskin: right now mtime only, but yes, simple callbacks for most values probably makes sense
<MichaelRaskin>
On the other hand, you can just redefine a fuse callback for getattr from scratch if you want.
<MichaelRaskin>
(fuse-path-callback getattr …) is a kind of a default implementation of a lispy wrapper; overriding would work fine
<ralt>
The existing callback is not that big, so it doesn't sound too hard to write from scratch. I didn't yet look if the fuse-callback macro was exported and if it was redefineable though
<puchacz>
p_l: trying
<MichaelRaskin>
fuse-callback is exported
shinohai has joined #lisp
<puchacz>
p_l: thanks!
<puchacz>
it worked
<MichaelRaskin>
Hm, fuse-path-callback is not, and this is a bug…
<p_l>
np
<MichaelRaskin>
If you are going to use mtime, adding a lisp callback for mtime makes sense. Otherwise… see rename's fate
Fare has joined #lisp
<MichaelRaskin>
Hm; for git-fs I am not even sure if you would prefer cl-fuse or cl-fuse-meta-fs. I guess your interface to git works with whole paths, so cl-fuse-meta-fs makes no sense for this task
_whitelogger has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
cosimone has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
mokulus has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
krid has joined #lisp
sailorCat has quit [Ping timeout: 244 seconds]
<MichaelRaskin>
ralt: times added
EvW has quit [Ping timeout: 260 seconds]
oni-on-ion has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
theBlackDragon has quit [Read error: Connection reset by peer]
<ralt>
MichaelRaskin: thanks!
Inline has joined #lisp
theBlackDragon has joined #lisp
<ralt>
MichaelRaskin: the code is here if you want to take a peak https://gitlab.com/ralt/labfuse (worth noting that is very much WIP)
<ralt>
MichaelRaskin: also, while you're around, I haven't managed to figure out if cl-fuse enables multithreading or not?
<MichaelRaskin>
ralt: I think your repo is private
<phoe>
cannot access that repo either
<MichaelRaskin>
Well, complicated… look at the fuse-test.lisp , there is some support
<ralt>
My bad, fixed
<ralt>
I'll look, thanks
<ralt>
The basic idea of the repo is to have all of your private gitlab exposed by fuse and to lazily fetch git repos when asked for... I still need to add a readme :)
krid has quit [Remote host closed the connection]
<ralt>
a-ha, that's what :call-manager is for, thanks
<MichaelRaskin>
ralt: you might also want to see what cl-fuse-meta-fs does with call-manager
<MichaelRaskin>
Which is probably not very good but seems good enough for last many years of my use
cosimone has quit [Remote host closed the connection]
<ralt>
Using a thread pool?
cosimone has joined #lisp
<ralt>
That makes a lot of sense
<MichaelRaskin>
Yep, slapped together _something_ on top of pcall library
<MichaelRaskin>
ralt: BTW, one option you might take is using cl-fuse-meta-fs to cleanly separate the «list-groups» logic and «list group projects» logic, and then at the project level return a symlink to a fetched-and-just-updated checkout
<ralt>
No, I want to be a bit smarter with storage
<ralt>
I store a single .git/ folder and each branch ends up reusing the same one
<MichaelRaskin>
Well, you can also use git worktrees
<MichaelRaskin>
But sure.
<ralt>
(by exposing a different .git/index file)
<MichaelRaskin>
By the way, you are allowed to pass nil instead of most callbacks
<MichaelRaskin>
So if you are read-only, no need to define unlink
orivej has quit [Ping timeout: 260 seconds]
orivej_ has joined #lisp
<ralt>
I plan on making it read-write, but thanks
<ralt>
As for git work trees, the idea is that it's transparent for the user
<MichaelRaskin>
I guess I am biased by the fact I use Nixpkgs. Which means a… pretty large checkout I would not want to feed through FUSE
<seok>
How do I mutate a list so resulting list is eq original list?
<p_l>
EQ will only check the first cons pair, so if you mutate any cons pair later in the list it will still be EQ
<seok>
I mean
<seok>
(defvar x '(0 1)
<seok>
(defvar y x)
<seok>
then mutate list in x
<phoe>
seok: mutating literal data is undefined
<phoe>
use (list 0 1) instead
<seok>
Ah ok
<phoe>
for the two to be EQ, they must be the same cons
<seok>
So I should use CLOS instead?
<phoe>
so you cannot mutate X, you can only mutate the CAR or CDR of X
<phoe>
what do you mean, use clos?
<seok>
this works with hash or clos
<phoe>
(defvar *x* (list 0 1))
<phoe>
(defvar *y* *x*)
<seok>
then I want to change x
<phoe>
(setf (car *x*) 42 (cdr *x*) (list 24))
<seok>
(push 2 *x*)
<seok>
ah
<phoe>
oh, that's not doable
<seok>
yeah
<phoe>
PUSH creates a new cons cell that will no longer be EQ to any previous cons cell
<seok>
I can (defvar x (make-hash-table))
adyatlov has joined #lisp
<seok>
then (defvar y x)
<seok>
then mutate it
<phoe>
yes, that'll work with hash tables
<seok>
but not with lists
<seok>
ok
<phoe>
no, it will also work with lists
<seok>
I can?
<phoe>
if you mutate the parts of the same cons cell, it'll work
<seok>
So it will work with plists?
<phoe>
but you rarely want to do that, because that prevents you from using PUSH or POP
<seok>
hm indeed
<beach>
phoe: This is one of the very frequent questions that I was planning a node for in the online teaching lecture series.
<phoe>
if you want to preserve identity, you can usually do some simple structure with one slot
<phoe>
then you can copy your headers around and mutate their HEADER-LISTs and have EQ equality
<phoe>
you can, if you use a cons as a header
<phoe>
then you mutate the CDR of that header
<phoe>
(defvar *x* (cons nil '(1 2 3 4 5)))
<phoe>
(defvar *y* *x*)
<phoe>
(push 0 (cdr *x*))
<seok>
Oh you are right
<seok>
it worked
<seok>
cheesy hack
<seok>
ty
<phoe>
not really cheesy
<phoe>
depends on what you mean by EQ
<beach>
seok: It is a standard programming technique.
<beach>
seok: Not only in Common Lisp.
<phoe>
lists are singly linked lists in CL and each cons has its individual identity, so pushing a new, fresh cons cell into some variable obviously makes it non-EQ to anything else in the system
<phoe>
and that's the expected behavior
<seok>
beach, my other languages are python and js/node, haven't encountered this
<seok>
actually, I've only seen cons in lisp
<beach>
I guess those languages don't have singly-linked lists.
<seok>
yeah
<phoe>
beach: or they have them as classes
<tychoish>
lists in python are closer to CL's vectors
<beach>
phoe: Classes or not, they would have the same problems unless the implementation provides some header object to turn it into an abstract data type.
<seok>
but CL vectors have fixed size tychoish?
<tychoish>
seok you can make vectors adjustable
<beach>
seok: What makes you think that?
<phoe>
beach: I think both python and JS access them by headers, so there's a layer of indirection
<phoe>
seok: depends, VECTOR-PUSH-EXTEND and ADJUST-ARRAY exist in CL
<beach>
phoe: Yeah, that explains it.
<beach>
Still it is totally amazing that seok has not encountered ordinary singly-linked lists in the past. I guess those languages hide the concrete data types from the programmer.
<tychoish>
(make-vector <n> :adjustable t :fill-pointer 0)
<seok>
phoe doesn't that copy the vector and re create it?
<seok>
That's how I understood it
<phoe>
seok: it usually does
vornth has quit [Remote host closed the connection]
<beach>
seok: There is usually some extra space so that it doesn't reallocate every time.
<beach>
I never read Knuth's books myself. But plenty of others.
<xristos>
i'm shaking my head watching folks recommend TAOCP to a CS newbie
<seok>
xDD
Oladon has joined #lisp
<xristos>
so seok i suggest you find some sample chapters online before you waste your money
<seok>
I'm still reading on lisp
gaqwas has joined #lisp
<TwoNotes>
Volume 1, Chpter 2, is "Data Structures". It covers all sorts of lists
<bjorkintosh>
seok> curious how long you guys spend working on one of these books? hahah. that's the joke. The author hasn't yet finished writing the goddamned books!
<TwoNotes>
Knuth is 82 now.
<seok>
bjorkintosh well thats the fourth book
<bjorkintosh>
he first planned the book in 1962.
<bjorkintosh>
it's now the year 2020
<bjorkintosh>
I'd find something easier if I were you, unless you're really good at the math part of it.
<bjorkintosh>
or can skip it guiltlessly.
<TwoNotes>
If you have ever used the TeX typesetting package, Knuth is responsible for that as well.
<beach>
Yeah, I would go for something simpler too, with a more recent algorithmic language.
<lieven>
MMIX isn't modern enough for you? :)
<bjorkintosh>
hahaha
<TwoNotes>
Common LISP: A Gentle Introduction to Symbolic Computation
<shka_>
i find the explanation in the practical common lisp to be the most enlightening
orivej has quit [Ping timeout: 240 seconds]
<shka_>
there is no list, there are cons cells
<shka_>
good evening btw
<beach>
Hello shka_.
kaftejiman has quit [Remote host closed the connection]
<shka_>
beach: nice to see you here
<beach>
Thanks. But I'm about to leave to fix dinner for my (admittedly small) family. :)
<TwoNotes>
Back in the dark ages, computers had 'words' that could hold two addresses at once. The structure of Lisp CONS cells grew natrally out of that.
<shka_>
that's good
<shka_>
TwoNotes: oh, how fascinating!
<shka_>
i didn't knew that this was the case
<shka_>
but it makes sense
<shka_>
car and cdr are supposed to be instruction in some old assembly language
<aap>
nope
<aap>
but the IBM 704 did have address and decrement fields in an instruction
FreeBirdLjj has quit [Remote host closed the connection]
ineiros has joined #lisp
<TwoNotes>
The idea of two addresses in a word was carried forward into the IBM 7094 (same as a 704 but with transistors) and the DEC PDP-6 and PDP-10. The PDP-10 in particular was quite popular in the early Lisp days
rippa has joined #lisp
akoana has joined #lisp
EvW has joined #lisp
FreeBirdLjj has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<phoe>
stylewarning: who's going to author the CLOS book by Apress?
<shka_>
the old book is not even that bad, but not ideal either
<shka_>
and CLOS harbors a lot of interesting possibilities
ft has joined #lisp
<phoe>
first pet peeve: it's not available as an ebook
<phoe>
second pet peeve: it's *not* available as an ebook
karlosz has quit [Quit: karlosz]
<TwoNotes>
I just with the CLHS was available as an ebook
<TwoNotes>
I'd take a PDF too
<lonjil>
ｕｌｔｒａｓｐｅｃ
Fare has quit [Ping timeout: 260 seconds]
<phoe>
nooooooooo
Oladon has quit [Quit: Leaving.]
Ven`` has joined #lisp
elflng has quit [Read error: Connection reset by peer]
markoong has joined #lisp
gaqwas has quit [Remote host closed the connection]
markong has quit [Remote host closed the connection]
elflng has joined #lisp
Oladon has joined #lisp
<ralt>
MichaelRaskin: I'm hoping that fuse will be able to serve me well for gigantic repos as well :)
<MichaelRaskin>
FUSE does have quite a bit of overhead: conside a process switch per FS operation
<MichaelRaskin>
This is expensive, actually
mangul has joined #lisp
minerjoe has joined #lisp
karlosz has joined #lisp
retropikzel has quit [Quit: retropikzel]
diamondbond has joined #lisp
farooqkz__ has joined #lisp
Fare has joined #lisp
EvW has quit [Ping timeout: 272 seconds]
mangul has quit [Ping timeout: 256 seconds]
minerjoe has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
mokulus has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
Jeanne-Kamikaze has joined #lisp
natter has joined #lisp
zigpaw has quit [Ping timeout: 256 seconds]
<ralt>
MichaelRaskin: I'm aware, but I'm pretty sure it's not that expensive. We'll see, maybe I'll be terribly wrong.
Fare has quit [Ping timeout: 260 seconds]
zigpaw has joined #lisp
<MichaelRaskin>
Well, to be fair, even hitting the FUSE limitations in a multi-threaded setup would require a different architecture of the bindings
karlosz has quit [Quit: karlosz]
<MichaelRaskin>
And definitely less funcall-the-global-variable
orivej has joined #lisp
<MichaelRaskin>
ralt:
<TwoNotes>
What is with the price of college-text-type books? The KINDLE version of Steele's Common Lisp book, published 30 years ago, costs $58!
cosimone has quit [Quit: Quit.]
jackdaniel has quit [Remote host closed the connection]
jackdaniel has joined #lisp
EvW has joined #lisp
<stylewarning>
phoe: sorry for the false excitement
gaqwas[m] has joined #lisp
ayuce has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 260 seconds]
ayuce has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
cage_ has quit [Quit: Leaving]
farooqkz__ has quit [Ping timeout: 256 seconds]
<ralt>
MichaelRaskin: that's a fair point, but I'm not sure that's even necessary to begin with, the use case is reading/writing code there, it's not as filesystem-intensive as, say, serving a website or a game.
<MichaelRaskin>
Bwahaha
<ralt>
The couple of read()s I did on big-ish files were definitely in the same order of magnitude, and readdir() was actually faster than on tmpfs for some reason
<MichaelRaskin>
Just listing ~ 40k files is not cheap, not even on HDD — and even worse via FUSE
<MichaelRaskin>
Depends on the number of nested levels
coltkirk has quit [Read error: Connection reset by peer]
minerjoe has joined #lisp
coltkirk has joined #lisp
<ralt>
Obviously there will be some ill cases, but I don't care too much if it's good enough or better for 95%
coltkirk has quit [Read error: Connection reset by peer]
coltkirk has joined #lisp
<ralt>
This is solving a real problem there, at work our gitlab has 1500 gitlab repos, it's can become tedious to know whether you have it cloned or need to visit the web etc
<ralt>
s/it's/it/
<MichaelRaskin>
Ouch, 1500
space_otter has joined #lisp
<MichaelRaskin>
Then yeah, I guess each specific one should be smaller than the megamonorepos I think about
<ralt>
Yeah, this is specifically not about supporting monorepos
chosenone has joined #lisp
<ralt>
Which git is ill-suited for, I'd argue
orivej_ has joined #lisp
<MichaelRaskin>
Erm, the original use case of git is a megarepo
<ralt>
monorepo != megarepo
<MichaelRaskin>
And the Nixpkgs monorepo is _not_ pulling in vendor stuff even, it is just a ton of packaging stuff
<MichaelRaskin>
Well, I guess you divide monorepos by provenance
<MichaelRaskin>
In that case, I am thinking «just» of megarepos
<ralt>
For me at least, monorepo = tons of components and libraries all in the same repo
<MichaelRaskin>
But with 1500 repos I would rate the risk of megarepos arising as acceptably low, too
orivej has quit [Ping timeout: 246 seconds]
<ralt>
We have a couple of them, I'll be able to test how/if it works :)
<ralt>
(our "nexus" is a git-annex repo, so every single release of every single component and library ends up in there)
mindCrime has joined #lisp
<p_l>
it would be nice to have linux fuse implementation of MS git extensions for "omg huge" repos
<p_l>
especially if said implementation was in CL :D
Fare has joined #lisp
jw4 has quit [Quit: tot siens]
<MichaelRaskin>
As it seems to be most critical for Git repos even larger than Linux/LibreOffice/etc., I am not sure I have any compassion to people ending up with such repos…
<ralt>
It's monorepos.
<ralt>
And this extension requires server side help as well, given that git itself (protocol and internals) is very much "whole repo"-based
Oladon has quit [Quit: Leaving.]
Fare has quit [Ping timeout: 246 seconds]
<MichaelRaskin>
I believe there is some narrow-checkout work in Git, and catching up with Subversion as of 15 years ago is obviously a more useful feature than some horror requiring patches to both the server and the client's FS
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
<p_l>
MichaelRaskin: it's not really a horrible extension, and a lot of it is due to requiring ability to do normal checkout on a repo that has *significant* amount of history
<ralt>
I believe that's already supported by shallow clones?
<p_l>
ralt: shallow clones break apart when you need something more than checkout
orivej has quit [Quit: No Ping reply in 180 seconds.]
<p_l>
generally, the whole thing MS did was to avoid all the "hacky" versions and allow everyone to have /apparent/ full checkout of gigantic repo with history stretching 30 years of very active development
<p_l>
and the approach is IMO quite compatible with Git in many ways but I wish it got ported over, it's not like MS is hiding details about it
orivej has joined #lisp
EvW1 has joined #lisp
puchacz has quit [Remote host closed the connection]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
diamondbond has quit [Ping timeout: 244 seconds]
shifty has quit [Ping timeout: 256 seconds]
notzmv has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
philweb has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
karlosz has joined #lisp
karlosz has quit [Client Quit]
cairn has quit [Quit: authenticating]
cairn has joined #lisp
Alfr__ has quit [Remote host closed the connection]
ggole has quit [Quit: Leaving]
cosimone has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
markong has joined #lisp
markoong has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 264 seconds]
orivej_ has joined #lisp
Oladon has joined #lisp
cosimone has quit [Quit: Quit.]
cosimone has joined #lisp
gravicappa has quit [Ping timeout: 256 seconds]
<phoe>
c.l.l got seemingly banned from Google Groups
<TwoNotes>
Can CFFI express a foreign vector of strings? I think SBCL can do it, but I would prefer staying with CFFI. This is like what you get from the 'argv' parameter to a main C program.
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
notzmv has joined #lisp
<phoe>
TwoNotes: that's just an array of char pointers
jw4 has joined #lisp
<TwoNotes>
Yes, in C. But what in LISP?
<phoe>
what do you mean, what in Lisp?
<phoe>
that would be a vector of strings if we converted that from C to Lisp
<phoe>
or a list of strings
<TwoNotes>
Yes, I have a list of strings I need to pass that to a C function as an array of char*
<phoe>
the manual way would be to translate all strings to C, allocate an array of wanted length, set all slots of that array to point to your strings, pass the array address to the function
shifty has quit [Ping timeout: 246 seconds]
<phoe>
sounds like a nice idea for a helper macro, WITH-C-STRINGS-ARRAY or something
shifty has joined #lisp
<_death>
you can define a foreign type to do that
<TwoNotes>
Hmm. I could write that if there is not already one
<phoe>
_death: TIL
<phoe>
can this be automated by CFFI itself?
<TwoNotes>
That is what I was hoping. I have not found it yet.
Blukunfando has quit [Read error: Connection reset by peer]
<TwoNotes>
SBCL's 'alien type' interface does include vectors of things
gaqwas has quit [Remote host closed the connection]
<TwoNotes>
But the CFFI spec does not really mention vectors as a built-in foreign type
voidlily_ has quit [Remote host closed the connection]
<TwoNotes>
mem-ref seems to support arrays
<_death>
phoe: no, you need to do what you said.. but you can have a strings-list foreign type to do the translations
<_death>
TwoNotes: there's mem-aref
<TwoNotes>
yes
<TwoNotes>
I think I can see how to do it then. Use mem-aref to fill in the slots in the array
<TwoNotes>
I like a powerful macro facility like LISP has I was once responsible for maintaining the MACRO facility in the DEC Bliss compilers