Nilby has quit [Remote host closed the connection]
<pjb>
saturn2: in posix, you would use /bin/df with the path of a item stored on the file system.
<pjb>
saturn2: but note that file systems are unrelated to disks: a disk may contain several file systems, and a file system may be stored on 0, 1 or more disks.
<pjb>
saturn2: if you have the access rights, you could try to read the parttion table on the raw disk device, and interpret it to see if there's some free disk space between partitions?
<pjb>
saturn2: also, some modern file systems just lie to you. For example, APFS.
Nilby has joined #lisp
yoonkn has joined #lisp
<saturn2>
yes, but none of that would be portable
Stanley00 has quit []
perrier-jouet has joined #lisp
<pjb>
saturn2: indeed.
<pjb>
saturn2: remember: computers are multi-process, multi-user systems.
<pjb>
saturn2: by the time you get the information you believe you need, it may be totally wrong!
<pjb>
saturn2: another user may have allocated all the remaining space, or another process may have deleted files!
<pjb>
saturn2: so the only way to do it, and this is the big lesson of unix, and why it has been so successful compared to other OSes old an new, is that you don't want to use such query, but instead you want to do what you want to do, and wait for an error to occur if it's not possible.
rumbler31 has joined #lisp
<pjb>
saturn2: you can pre-allocate a file: (handler-case (with-open-file (out "DATA:FILE.BIN" :element-type '(unsigned-byte 8) :direction :output :if-does-not-exist :create :if-exists :error) (loop with buffer = (make-array (* 1024 1024) :element-type '(unsigned-byte 8) :initial-element 42) repeat 1024 do (write-sequence buffer out))) (:no-error () t) (error () nil))
<pjb>
saturn2: if it returns T, you know you had 1 GB free.
<pjb>
(and now you have them to store your data).
<saturn2>
in fact i have a whole computer dedicated to this one task
<pjb>
I one of my first jobs we worked on a system where the admin allocated the files on the disk track-by-track…
<Nilby>
Another lesson of unix is that doing it that way is completely unreliable, and modern reliable software doesn't. And most unix is single user now.
<pjb>
manually.
<pjb>
Nilby: but still multi-process.
<pjb>
570 processes on this single-user macOS system.
<pjb>
<saturn2>
but also, there are other reasons to monitor disk usage than creating a file immediately
<pjb>
(but note that macOS allows for multiple user simultaneous logins).
<pjb>
saturn2: file system usage you mean?
<saturn2>
ok
<pjb>
Ok, ok. It's implementation and platform dependent.
<pjb>
uiop:run-program is there for something.
<pjb>
FFI too.
<pjb>
and #+/#-
<saturn2>
i was surprised that neither uiop nor osicat offer this functionality
<pjb>
because it's useless to offer all the functions: there are an infinite number of functions!
<Nilby>
The amount of things people expect from a portable O/S interface is finite, and relatively small, and I think seeing how much disk space you have is surely a useful one.
<pjb>
But anyways the output of df(1) is human readable, so it cannot be processed easily (format may change).
<pjb>
On linux you could get the information from /proc
ebrasca has quit [Remote host closed the connection]
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<asarch>
I am using cl-cffi-gtk to create the window using a Glade template file to CRUD the data from a local PostgreSQL cluster using Datafly
<beach>
I am unable to assist with anything that has to do with FFI.
<beach>
You need to wait for someone else.
mh__ has joined #lisp
<asarch>
Since I am learning the Japanese language, I was copying/inserting some grammar information into the cluster using this interface
<asarch>
And every once in a while I got that error
<beach>
Good luck!
<White_Flame>
do you think it's legitimately taking 1 GB of heap space?
<asarch>
I think it is from the dialog operation (creating/destroying the widget)
<asarch>
White_Flame, ?
motersen has quit [Remote host closed the connection]
<White_Flame>
if you're streaming data to PG asynchronously, then it might clog up in RAM?
motersen has joined #lisp
<White_Flame>
and same as beach, I have no idea about the effects of FFI on the lisp heap. Assuming that any malloc stuff is outside lisp-managed memory space, I wouldn't actually suspect it
<asarch>
Well, every time the data was inserted the CPU % use increased to the infinity and beyond
<White_Flame>
then profile it?
<beach>
asarch: I strongly recommend you use a Common Lisp GUI toolkit instead. Like McCLIM.
<asarch>
I can't. It is very abstract to me
<asarch>
I've trying hard but I still can't figure out how it works
<asarch>
top -d 1 shows the % used of the processors every time I "saved" the new data using this GTK+ application
<White_Flame>
beach: is there any effort towards keeping the mcclim website up to date?
<no-defun-allowed>
asarch: Do you have an idea of how much data you are loading into Postgres?
<beach>
White_Flame: I am sure there is. I am no longer directly involved, but I am sure jackdaniel has the ambition to keep it up to date.
<White_Flame>
ah, k. Seems to have been a couple of years since last update
<White_Flame>
and from around here it sounds like it's pretty active
<beach>
It is very active. I guess we can check with jackdaniel when he comes around. He probably spends the weekends with his family.
<asarch>
no-defun-allowed, actually the data is small posts from a Facebook account like: https://pastebin.com/SHtrRUpM
<no-defun-allowed>
How many do you have?
<asarch>
Only 3306 records
<asarch>
(Maybe after doing "SELECT * FROM note;" several times)
<saturn2>
asarch: could you make a backtrace from that thread?
edvardo_ has joined #lisp
mindCrime has joined #lisp
<asarch>
Well, actually, right now the process is off but, how could I do the backtrace?
<asarch>
Let me see if refreshing the content of the GTK+ window could create this condition
hjudt has quit [Ping timeout: 252 seconds]
<saturn2>
type "(sb-thread:release-foreground)" and then type "backtrace"
<asarch>
Is there any way to do more verbose the SBCL execution?
<asarch>
So FFI is evil?
<beach>
asarch: Because of the differences in semantics between Common Lisp and the foreign language, it is always going to be difficult to manage a combination of the two.
<no-defun-allowed>
There aren't really good and evil in programming, but debugging C is much more annoying than debugging Lisp.
<beach>
asarch: Typically, the foreign language does not have automatic memory management, for instance.
aartaka_d has quit [Ping timeout: 240 seconds]
<asarch>
I see
<beach>
asarch: And think about debugging? If you use something like GDB, adapted to the foreign code, you won't understand what is going on when your code is executing in Common Lisp. Conversely, even if you have a fantastic Common Lisp debugger, it won't be able to inform you what is happening when code in the foreign language is executed.
<asarch>
Good point
<asarch>
Question #2: How can you break a pipe in SBCL?
<asarch>
I also wrote a web application using Caveman2 for the same cluster and some times when I refresh the list of the notes I get those messages
<asarch>
In this case is when I call all the notes of the Duolingo annotations
<asarch>
Those annotations are like this: 彼女はいつも新聞を読みます。 kanojo wa itsumo shinbun o yomimasu She always reads the newspaper.
mindCrime has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
I think this happens when the web browser drops a connection when Hunchentoot didn't expect it. Though Hunchentoot usually logs it and carries on - does Caveman2 change that behaviour?
rumbler31 has joined #lisp
<saturn2>
if you call (hunchentoot:send-headers) to send the response directly to the output stream, you have to catch any stream errors yourself otherwise they will invoke the debugger
<asarch>
I don't know. Two or three updates of SBCL before, those message started to appear
<asarch>
And since the application was still running, I just ignored them
<no-defun-allowed>
Are tacos or GNOME 4 involved in your database issues?
<asarch>
D'oh! Wrong channel. Sorry, sorry :-(
<saturn2>
i'm fascinated that someone went to the trouble of making a vocal fry simulator
<asarch>
That was for a German friend :-(
* asarch
hides and runs
<asarch>
Tut es mir leid…
zacts has joined #lisp
homonyms has quit [Ping timeout: 260 seconds]
Oladon has quit [Quit: Leaving.]
karlosz has quit [Quit: karlosz]
mindCrime has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
Lycurgus has joined #lisp
mindCrime has quit [Ping timeout: 246 seconds]
waleee-cl has quit [Quit: Connection closed for inactivity]
karlosz has joined #lisp
vegansbane69636 has joined #lisp
vegansbane6963 has quit [Ping timeout: 240 seconds]
safe has quit [Quit: Leaving]
Lycurgus has quit [Quit: Exeunt]
mh__ has quit [Remote host closed the connection]
indathrone has joined #lisp
perdent has joined #lisp
mindCrime has joined #lisp
justBull has quit [Quit: Ping timeout (120 seconds)]
justBull has joined #lisp
perdent has quit [Max SendQ exceeded]
mh__ has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
mindCrime has quit [Ping timeout: 240 seconds]
xsperry has joined #lisp
zacts has quit [Quit: bbl]
zacts has joined #lisp
iamFIREcracker has joined #lisp
hsaziz has joined #lisp
zacts has quit [Client Quit]
froggey has quit [Ping timeout: 252 seconds]
mh__ has quit []
froggey has joined #lisp
shka_ has joined #lisp
frost-lab has joined #lisp
andrei-n has joined #lisp
shka_ has quit [Quit: Konversation terminated!]
shka_ has joined #lisp
hsaziz has quit [Quit: hsaziz]
jimka2001 has quit [Ping timeout: 246 seconds]
<moon-child>
writing a lisp, haven't implemented ,@ yet. I hadn't ever thought of doing this before (no call for it), but you can replace `(a b ,@c) with `(a b . ,c)
<moon-child>
(though of course, if the thing being spliced is in the middle of the list, there's no recourse)
<beach>
Are you saying you are creating an implementation of Lisp? Of Common Lisp?
<moon-child>
heh, no. Cl is large enough that most of my time would probably be spent reimplementing utility functions and macros rather than doing anything interesting
<beach>
So what did you mean by "writing a lisp, haven't..."?
<beach>
Missing pronouns make it hard to parse.
orivej_ has quit [Ping timeout: 246 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
<moon-child>
I have been writing a list processing programming language, and in it I haven't...
<beach>
Ah, OK.
<beach>
In Common Lisp, that construct is handled by a reader macro generating some special form.
contrapunctus has joined #lisp
<beach>
Er, let's not call it a "special form". Some data structure not intended for evaluation.
<moon-child>
Right. I know how to implement it, I just hadn't gotten around to it yet
<beach>
Got it.
<beach>
Good luck!
<moon-child>
thank you!
<beach>
Let me just say this: Given the number of libraries we have already created, and the ones that will exist soon, it should be much easier than it used to be to create a Common Lisp implementation, if that's what you want to do.
<moon-child>
SICL is a really great project. I think I might also have slightly different goals from cl with this project. Not entirely sure yet
<Nilby>
I must have forgot. Is there some way to turn a list into a function without eval, compile, or macro around defun?
<no-defun-allowed>
Can you be more specific about what kind of list?
<Nilby>
Like I want to turn l2 into a function: (let* ((l1 '(+ 2 3)) (l2 `(lambda () ,l1))) l2))
<no-defun-allowed>
You could COERCE to a FUNCTION, but that would call COMPILE.
<beach>
moon-child: Sure, I was pointing it out for all #lisp participants. Not just for you.
<Nilby>
no-defun-allowed: Hmmm. I guess compile and eval seem heavy for a tiny anonymous function.
<moon-child>
:)
<Nilby>
But it I guess has to happen somehow.
<no-defun-allowed>
In this specific case, you could make it (let ((closure (lambda () (+ 2 3)))) (lambda () (funcall closure))).
<Nilby>
Right, but I want to cons up the function body at runtime.
<no-defun-allowed>
Using a chain of closures works well enough most of the time. (For example, CL-PPCRE uses a chain of closures to basically produce a non-deterministic machine which finds matches.)
<saturn2>
what could do this that would be less "heavy" than eval?
skapate has quit [Remote host closed the connection]
<Nilby>
I guess I'm thinking of some old days where it just stored the lambda list as the function binding.
hendursaga has quit [Ping timeout: 240 seconds]
<Nilby>
Tangentially related, I was surprised by sbcl telling me this: "Objects of type COMPILED-FUNCTION can't be dumped into fasl files."
<saturn2>
that's pretty much what sbcl will do if you set sb-ext:*evaluator-mode* to :interpret
lotuseater has joined #lisp
<Nilby>
saturn2: That's what I was thinking I guess, but if I do that then I'm in non-portable land.
hendursaga has joined #lisp
<saturn2>
it seems more like a performance tweak, it shouldn't affect the semantics
<no-defun-allowed>
Really, if the forms you generate are similar enough, just use a chain of closures. If not, then compiling wouldn't hurt.
<no-defun-allowed>
...unless you do it in a loop - in which case, don't!
mindCrime has joined #lisp
Inline has joined #lisp
theruran has joined #lisp
xsperry has quit []
xsperry has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
anticrisis has quit [Read error: Connection reset by peer]
heisig has joined #lisp
<Nilby>
saturn2, no-defun-allowed: Thanks for helping me think through it.
surabax has joined #lisp
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #lisp
<lukego>
Hey how do you normally do a (list-of FOO) type? is there anything like that in e.g. alexandria or serapeum that's standard and idiomaic?
imode has quit [Ping timeout: 240 seconds]
<beach>
Can't be done unless you use SATISFIES.
<beach>
But look at jimka2001's work, for instance.
<beach>
He defines something called a "regular type expression", or RTE, that can express that kind of stuff. But it uses SATISFIES, obviously.
<lukego>
I will, but to be clear I mostly want to write (list-of FOO) in the source code for clarity, I don't mind if the impl would be e.g. with SATISFIES or just (deftype list-of (x) 'list)
<lukego>
yeah. I'll probably use SATISFIES although I understand that people generally resist this so wondered if there was another popular formulation
<lukego>
(surprised there isn't something like this in serapeum but I can't find it if so)
<lukego>
but for now I've written (deftype list-of (x) (declare (ignore x)) 'list) and this is ample for current purposes i.e. to avoid losing information while transcribing from an EBNF grammar into lisp structs.
<lukego>
I also added a similar (nyi-of X) that translates into T but captures that I need to define a proper X type later.
<lukego>
(I'm trying to transcribe an EBNF grammar for LLVM IR into Lisp structures - with serapeum DEFUNION - and trying on the one hand to only do the few bits I'm interested in right now while on the other hand keeping track in a disciplined way of what I'm skipping using information-preserving stubs.)
edvardo_ has quit [Remote host closed the connection]
<phoe>
the main issue with gensyms is that it's impossible to preserve their identity across FASL-dumping
<phoe>
but I think this can be solved via l-t-v in some way
terpri has quit [Remote host closed the connection]
asfswdf has quit [Remote host closed the connection]
klltkr_ has joined #lisp
klltkr has quit [Ping timeout: 252 seconds]
xsperry has quit [Ping timeout: 246 seconds]
hjudt has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 260 seconds]
mindCrime has joined #lisp
random-nick has joined #lisp
scymtym has joined #lisp
hjudt has joined #lisp
xsperry has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
niflce has joined #lisp
monolithic has joined #lisp
klltkr_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
homonyms has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 252 seconds]
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
homonyms has quit [Remote host closed the connection]
perrier-jouet has quit [Quit: WeeChat 3.1]
Inline has quit [Remote host closed the connection]
perrier-jouet has joined #lisp
Inline has joined #lisp
hypercube has joined #lisp
Inline has quit [Remote host closed the connection]
Inline has joined #lisp
mrchampion has quit [Remote host closed the connection]
klltkr has joined #lisp
klltkr has quit [Client Quit]
rgherdt has joined #lisp
aeth has quit [Ping timeout: 252 seconds]
aeth has joined #lisp
mrchampion has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
<gendl>
hey, I’ve been helping my son with his university C++ class. He recently decided to give Emacs a try, so I helped him follow the professor’s set up instructions to install company-mode and flycheck mode. These two modes pretty much makes emacs emulate the good parts of vscode, for c++ at least.
<gendl>
Then I noticed that company-slime mode is a thing, and it looks pretty active. I’m eager to give it a try. Any caveats there?
<gendl>
and how about flycheck-mode for CL? Is that a thing, or is there a potential for something like that?
<phoe>
gendl: slime-company you mean?
<phoe>
I use it all the time as a part of spacemacs, it's very good
<gendl>
Yes. Slime-company.
renzhi has joined #lisp
<phoe>
a strong upvote from me then
<gendl>
Should I switch to spacemacs?
<lotuseater>
if you're more used to vim bindings, then why not
orivej has joined #lisp
<gendl>
oh is that what spacemacs is. Sorry, should’ve looked it up. Are used to be a vi user years ago, and I can still use VI in a terminal when I need to, but my fingers have pretty much been trained with native Emacs editing commands now
<spacebat2>
spacemacs, doom-emacs, there are several "config distributions" that are good to get started
<spacebat2>
also consider trying out sly, which is a fork of slime that has diverged significantly
<gendl>
so I can use slime-company with any emacs flavor? As long as it has slime loaded?
<phoe>
t
<gendl>
well, I have a custom extension to slime called glime, I’m not sure if that would work with sly
<phoe>
spacemacs is just a collection of melpa packages that are preconfigured to work together, plus some custom configuration mechanisms
<phoe>
so, more or less, a distribution of emacs
<phoe>
slime-company should work fine wherever you have slime loaded, it's not like it has a spacemacs dependency
<gendl>
I am a complete noob with emacs lisp, glime was developed by a few consultants we hired over many years. At some point I’m gonna have to learn How it works, to be able to maintain it — or find a consultant who is willing to do same
<gendl>
glime gives slime-like completion for Gendl object messages
<gendl>
End it all shows up in the mini buffer, just like with normal slime.
<gendl>
So I am hoping it will “just work” with slime-company.
orivej has quit [Quit: orivej]
<gendl>
and* it all shows up...
<gendl>
Anyway, I’ll stop making noise here and just go try it for myself... 🙏🏻
<pjb>
What does glime do?
<gendl>
just like slime shows you completions in the mini buffer, function arguments, etc.
<gendl>
glime shows you The possible completions for gendl, which typically are object messages, it’s kind of a Smalltalk kind of thing
<gendl>
so if you type (the ap...)
<gendl>
and there’s an “apple” message available, glime will show you.
<gendl>
sorry, our “the” shadows cl:the
<gendl>
our `the` is a reference operator for messages in the currently active object. (
<gendl>
Where currently active object is captured an lexical variable `self`
<gendl>
)
frost-lab has quit [Quit: Connection closed]
<gendl>
glime just piggybacks on slime’s completion mechanism so we’ll see — if it’s set up properly, I’m supposing it should “just work” with slime-company. But I certainly won’t be surprised if some tweaking will be necessary. In which case I might be back here begging For help or asking if any slime experts would be interested in a small paid gig
cipherchess has quit [Quit: leaving]
<gendl>
Because I’m pretty sure we will make gendl look more attractive to the kids these days If it is mimicking their shiny “modern” IDEs such as vscode — and slime–company looks like a step in that direction.
monkey__ has joined #lisp
<gendl>
my 19 year old son being included in “the kids these days”
klltkr has joined #lisp
<gendl>
So how compatible is sly with slime? For example, would slime-company work with sly?
<gendl>
or is sly-company a separate package?
<gendl>
I just noticed there is a separate #slime channel in here. I suppose any more talk on this thread could move over there
<phoe>
gendl: AFAIK sly speaks the swank protocol
<phoe>
so it should be backwards-compatible
kenran has joined #lisp
<gendl>
Thanks. I’ll play around.
<pjb>
gendl: I see. Thanks.
<pjb>
you use the lisp syntax. Have you have a look at Objective-CL, my reader macro to use a Objective-C-like syntax: [objet messageWith:[ref getArgument] andWith:(+ 2 3)]
<pjb>
Using a reader macro let's you define syntactic scopes where you may use identifiers without shadowing similar named symbols.
<pjb>
[super sameMessage] and [self otherMessage] are such examples (super and self are just identifiers, not interned as symbols).
<gendl>
pjb: I have not.
<gendl>
We would have to work out some kind of licensing deal with you before I can truly take a look at your stuff or consider it, because I believe it is all AGPL licensed. And we do dual-license Gendl as Genworks GDL which is used for closed-source proprietary distributions.
Nilby has quit [Ping timeout: 245 seconds]
CrazyPython has joined #lisp
<gendl>
Gendl itself is also AGPL licensed, which I suppose makes it totally compatible with your stuff license-wise, if people are going to use it according to AGPL terms. So a third-party Who is not concerned about being exposed to these code bases could happily take a look at what you’re talking about and see if there is potential there.
renzhi has quit [Ping timeout: 260 seconds]
<gendl>
pjb: do you sell AGPL exceptions?
monkey__ has quit [Remote host closed the connection]
monkey__ has joined #lisp
orivej has joined #lisp
nicktick has quit [Ping timeout: 252 seconds]
<pjb>
gendl: I do :-)
<gendl>
OK, perhaps we can discuss potential terms in due course if it appears mutually advantageous to do so.
xkapastel has joined #lisp
<pjb>
The lower layer would have to be implemented for gendl. Do you need only the Objective-C smalltalk syntax?
<gendl>
pjb: my guess is that gendl could benefit from many of your packages. Objective-CL may or may not be one of them. But, our message passing syntax, especially for messages which take arguments, Is
<gendl>
certainly a bit awkward The way it is now — of that there is no doubt.
Oladon has joined #lisp
yoonkn has quit [Remote host closed the connection]
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 252 seconds]
aartaka has quit [Ping timeout: 240 seconds]
oned4 has joined #lisp
oned4 is now known as cipherchess
layerex has joined #lisp
niflce has quit [Ping timeout: 252 seconds]
aartaka has joined #lisp
Jachy has left #lisp [#lisp]
monkey__ has quit [Remote host closed the connection]
pjb has quit [Ping timeout: 260 seconds]
pjb has joined #lisp
klltkr has quit [Ping timeout: 240 seconds]
layerex has quit [Quit: Leaving]
Oladon has quit [Quit: Leaving.]
waleee-cl has joined #lisp
klltkr has joined #lisp
notzmv has quit [Ping timeout: 240 seconds]
maxwilliamson has quit [Ping timeout: 240 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
jimka2001 has joined #lisp
LispSporks has joined #lisp
jimka2001 has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
mindCrime has joined #lisp
aartaka has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 268 seconds]
orivej has joined #lisp
<pjb>
contrapunctus: beach: to be profitable in lisp, we need to be able to talk with the GC to manage zones that are mapped to files, and to specify file-local root-sets (since files could be used by several processes, the objects in memory mapped files cannot be collected willy-nilly).
hiroaki has joined #lisp
ksierka has joined #lisp
<pjb>
the question is what to do when an object is referenced from the root sets of two different files? In what zone should it be moved/stored?
<pjb>
file 1 rootset = {#1=(a . nil)} file 2 rootset = {#2=(a . nil)} (setf (get 'a :k) 42) should the plist (symbol-plist 'a) be stored in file 1, in file 2?
cage_ has quit [Quit: Leaving]
<pjb>
or should we just ignore files, and consider only memory-mapped image-based storage?
bjorkintosh has quit [Remote host closed the connection]
cosimone has quit [Read error: Connection reset by peer]
<pjb>
there could be a zone declaration similar to dynamic-extend.
<pjb>
or a dynamic scope? (with-zone (file1) (push (list 1 2 3 4) (root-set file1))) for explicit allocation in the memory mapped zone. Otherwise (push (list 1 2 3 4) (root-set file1)) would imply moving the objects.
<pjb>
Of course, great care must be applied to avoid moving the whole lisp image into a memory mapped file (unless this is what we want).
saganman has left #lisp ["WeeChat 2.3"]
klltkr has quit [Ping timeout: 240 seconds]
<pjb>
This could be used instead of fasl files. Compiling could generate such partial lisp images that would just be memory mapped when "loaded".
renzhi has quit [Ping timeout: 276 seconds]
notzmv has quit [Ping timeout: 260 seconds]
<pjb>
In ccl, if we compile this file, restart and load it, https://termbin.com/fsre then the symbol-value and the plist are lost, while the uninterned symbol itself is still referenced by foo::*foo*. Is this conforming? Is this acceptable?
<pjb>
Of course, if the symbol wasn't uninterned, we could have conflicts between values, functions, and plists coming from different files…
<waleee-cl>
jmercouris: isn't it ostensibly possible to use clim on windows? If so it must be ways to configure the font paths or another mechanism
mindCrime has quit [Excess Flood]
<phoe>
jmercouris: (ql:quickload :cl-dejavu)
<phoe>
then fill in that variable yourself with the value of (uiop/pathname:pathname-parent-directory-pathname (cl-dejavu:font-pathname (first (cl-dejavu:list-fonts))))
mindCrime has joined #lisp
<phoe>
I assume this should work
<waleee-cl>
ah, xserver dependeny. Ok, so technically possible to run on windows, but a hassle
<jmercouris>
waleee-cl: there is a restart that occurs under that condition
<jmercouris>
and there is a path that is probed "C:/Windows/Fonts/"
<jmercouris>
phoe: I don't see this system anywhere, that's OK, I'll specify the path in the restart
<jmercouris>
I'm just fooling around anyways
<phoe>
jmercouris: it should be available in quicklisp
sp41 has quit [Read error: Connection reset by peer]
<phoe>
fixed, thank you
lotuseater has quit [Remote host closed the connection]
<|3b|>
would you be likely to accept a PR for a version that supports deleting arbitrary elements and updating priorities? if so, any better name ideas than damn-fast-updatable-priority-queue?
<|3b|>
(seems noticeably slower, so i assume it shouldn't just be folded into the original)
<phoe>
I think so, sure
<phoe>
as long as it's appropriately documented and tested I'll accept it
<phoe>
though I'm kind of wary of combinatorial explosion because then we'll have DFPQ, DFSPQ, DFUPQ, and DFUSPQ
<phoe>
I guess there is no avoiding it
<|3b|>
yeah :/
<phoe>
so we may as well embrace it
* |3b|
somewhat avoids that problem by being too lazy to implement the US version until i need it :p
<phoe>
:D
<phoe>
well I'll request that when you make a PR
<|3b|>
does the stable version just keep an extra serial# to break ties for each entry? (and then get confused if there are more than 2^32 insertions in a given table)
<phoe>
yes
<phoe>
feel free to adjust the queue to use ub64 instead of ub32 for that if you think you can run out
* |3b|
thinks i don't need it for now (and probably wouldn't object to ub32 if i did)
<phoe>
okie
orivej has joined #lisp
* |3b|
is more likely to have a problem with ub32 priority, might like single-float instead (though i think single-floats are still ordered the same if the bits are compared as ub32, so close enough)
<phoe>
that should work too if you adjust the prio type
<phoe>
and should even compile without warnings
<phoe>
IIRC that mfiano tried doing something like that
undvrainbowvita8 has joined #lisp
<phoe>
anyway! sleep time
skami has joined #lisp
akoana has left #lisp ["Leaving"]
<|3b|>
(i guess using bits of float directly might only work if sign is the same, but i think that is true for my current needs)