asdf_asdf_asdf has quit [Remote host closed the connection]
dale has quit [Quit: dale]
nirved has joined #lisp
vms14 has joined #lisp
nirved_ has quit [Ping timeout: 258 seconds]
caltelt has joined #lisp
baiyang has joined #lisp
dale has joined #lisp
zotan has quit [Ping timeout: 248 seconds]
zotan has joined #lisp
Kundry_Wag has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
Kundry_Wag has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
JetJej has quit [Read error: Connection reset by peer]
ym555_ has joined #lisp
mindthelion has quit [Remote host closed the connection]
ym555 has quit [Ping timeout: 246 seconds]
techquila has joined #lisp
FreeBirdLjj has joined #lisp
ym555 has joined #lisp
jtecca has joined #lisp
ym555_ has quit [Ping timeout: 252 seconds]
oni-on-ion has joined #lisp
Kundry_Wag has joined #lisp
ym555 has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 268 seconds]
t58 has quit [Quit: Night]
jtecca has quit [Ping timeout: 248 seconds]
mindCrime__ has joined #lisp
ym555 has joined #lisp
rdh has joined #lisp
ym555 has quit [Ping timeout: 246 seconds]
<rdh>
hey, i was playing around with format and printing out ordinals and then i discovered that lisp actually like to express fractions. But I couldn't find anything on formatting fractions... cardinal/ordinal?
<rdh>
this is on clisp
ym555_ has joined #lisp
<Bike>
lisp has ratios as a basic data type. what are you trying to do exactly? print 2/3 as "two thirds" or something?
<rdh>
Bike, sure, i had some code that printed out to espeak for fun. and just realized i couldn't find any specific to this
<Bike>
i don't know of any. there's nothing built in, i don't think.
<loke`>
That said, you'll probably be better of using an internationalisation library. These tricks only works in English.
ym555 has joined #lisp
<loke`>
1234/1235 renders asL
<loke`>
one thousand two hundred thirty-four one thousand two hundred thirty-fifths
<loke`>
not very readable
<loke`>
You probably want to only render small fractions as words
Kundry_Wag has quit [Ping timeout: 248 seconds]
<no-defun-allowed>
i think the idea was to feed it to a speech synth so it's supposed to be hearable
<rdh>
loke`, but its not incorrect.
ym555_ has quit [Ping timeout: 246 seconds]
<loke`>
121234/121235 is one hundred twenty-one thousand two hundred thirty-four one hundred twenty-one thousand two hundred thirty-fifths
<loke`>
but unreadable
<White_Flame>
technically correct, the best kind
<rdh>
loke`, lol so is... (format t "~r" 234234234234234) two hundred and thirty-four trillion, two hundred and thirty-four billion, two hundred and thirty-four million...
<loke`>
rdh: Yeah, SBCL at least has support for words up to some ridiculous size
<loke`>
one hundred vigintillion is the highest
<loke`>
1E66 to be precise.
<aeth>
Is this a reply to the Brainfuck I posted in here yesterday? ~*~[~:*~:*~r ~:r~:*~:*~p~;~:*~:*~r~:;~:*~:*~r ~:r~:*~:*~p~]
libertyprime has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 246 seconds]
altgray has joined #lisp
rdh has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
nicdev has quit [Ping timeout: 245 seconds]
vms14 has quit [Quit: WeeChat 2.3]
ym555 has quit [Ping timeout: 248 seconds]
dacoda has joined #lisp
karlosz has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
Arcaelyx has quit [Ping timeout: 255 seconds]
sjl has joined #lisp
karlosz has quit [Client Quit]
karlosz has joined #lisp
nirved_ has joined #lisp
nanoz has joined #lisp
notzmv has joined #lisp
nirved has quit [Ping timeout: 258 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
marusich has joined #lisp
libertyprime has joined #lisp
Bike has quit [Quit: Lost terminal]
Oladon has quit [Quit: Leaving.]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
cyberoctopi has joined #lisp
jeosol has joined #lisp
ebzzry has joined #lisp
<ebzzry>
Is xach.com/clhs down?
igemnace has quit [Read error: Connection reset by peer]
<edgar-rft>
ebzzry: http://l1sp.org/html/ woks for me, xach.com/clhs gives me a 502 error
<beach>
aeth: Yes, I am working very hard to get the new shape of HIR turned into Common Lisp. Then that new shape will also be turned into MIR and native code.
<ebzzry>
edgar-rft: yes, it works indeed.
vlatkoB has joined #lisp
sauvin has joined #lisp
pankajgodbole has joined #lisp
lavaflow has quit [Read error: No route to host]
<aeth>
Earlier we were talking about GCs and this was mentioned: < flip214> beach is trying for a parallel GC, that might be good enough (with enough threads, at least ;)
ebzzry has quit [Quit: WeeChat 2.3]
<beach>
I suspect most of the cores do nothing on a modern desktop computer. Might as well put them to work.
<aeth>
That's probably an understatement. You can get a desktop PC up to 32c (64t) and at some point this year that's expected to double.
<aeth>
I wouldn't be surprised if we all have at least 16 cores in 10 years.
<beach>
So I am likely on the right track.
mindCrime has quit [Ping timeout: 245 seconds]
mindCrime has joined #lisp
<aeth>
I hope one day we see a Common Lisp with a concurrent, parallel, real-time GC because afaik only Java's JVM (or is it an alternate Java environment?) can fill that niche right now
pierpal has quit [Quit: Poof]
<LdBeth>
Will asymmetrical processors be popular
<LdBeth>
?
<beach>
I think you can forget about real time as long as you are running on a typical operating system.
pierpal has joined #lisp
torbo has quit [Remote host closed the connection]
<aeth>
beach: Yes, as long as.
altgray has quit [Remote host closed the connection]
nirved has joined #lisp
nirved_ has quit [Ping timeout: 258 seconds]
<beach>
My aim is for the system to be good enough for processing sound in real time.
<beach>
That is already a much tougher requirement than what is needed for video.
<Jachy>
aeth: I think only IBM's JVM claims a real-time GC. Azul's is widely regarded for proprietary JVMs but it only claims "pauseless", I don't know if that's just marketing for ultra-low pause times though.
<beach>
I am hoping to do a thread-local collection in a few milliseconds.
zooey has quit [Remote host closed the connection]
<beach>
Of course, the stack has to be scanned for roots, and if the stack depth is not bounded, then no real-time guarantees can be made.
<beach>
So I am not aiming for real time. Just something like "if you don't use recursion too much, then it is probably good enough for processing sound".
<beach>
It is non-trivial because of the existence of callee-save registers.
mindCrime has quit [Ping timeout: 258 seconds]
<beach>
A register of the machine may "belong" to a stack frame arbitrarily far from the top of the stack, and to find out whether it contains a Common Lisp datum or some arbitrary bit pattern, the entire stack has to be "unwound". Interesting stuff, but complicated.
igemnace has quit [Quit: WeeChat 2.4]
wigust- has joined #lisp
wigust has quit [Ping timeout: 248 seconds]
khisanth_ has joined #lisp
<beach>
So if you want real-time guarantees, you may have to allocate the control stack on the heap, which will slow things down considerably. But that's a traditional trade-off. Many people confuse "real-time" with "really fast"
<aeth>
yeah, RT is really fast if you exclude the preallocating stage
<aeth>
people forget the if
caltelt has quit [Ping timeout: 252 seconds]
lavaflow has joined #lisp
elazul has joined #lisp
cyberoctopi has quit [Remote host closed the connection]
charh has joined #lisp
<beach>
I am saying that real-time performance can be very slow. The important part of real-time performance is to guarantee upper bounds on all computations. In order to do that, it may be necessary to be conservative in the entire system, often making it impossible to be fast as well.
<beach>
The example above was about the control stack. You can have no real-time garbage collector of you need to scan an arbitrarily large stack for roots.
manualcrank has quit [Quit: WeeChat 1.9.1]
<beach>
The only solution to that problem that I can see is to allocate the control stack on the heap. And since modern processors have circuits that depend on the control stack being allocated in the traditional way, things like call/return will be much slower.
esrse has joined #lisp
ggole has joined #lisp
Nilby has joined #lisp
dacoda has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
scottj has left #lisp [#lisp]
libertyprime has quit [Ping timeout: 252 seconds]
dale has quit [Quit: dale]
itsech0 has joined #lisp
andrei-n has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
libertyprime has joined #lisp
JohnMS_WORK has joined #lisp
nowhereman has joined #lisp
nowhere_man has quit [Ping timeout: 245 seconds]
slyrus__ has joined #lisp
Kundry_Wag has joined #lisp
nowhereman has quit [Ping timeout: 252 seconds]
slyrus_ has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 245 seconds]
t58 has joined #lisp
scymtym has quit [Ping timeout: 255 seconds]
varjag has joined #lisp
makomo has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
schweers has joined #lisp
Kundry_Wag has quit [Ping timeout: 258 seconds]
rippa has joined #lisp
campy_fellow has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
dddddd has joined #lisp
fivo has joined #lisp
campy_fellow has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
impaktor has left #lisp ["ERC (IRC client for Emacs 25.3.2)"]
Arcaelyx has joined #lisp
elazul has quit [Ping timeout: 248 seconds]
vertigo has quit [Ping timeout: 255 seconds]
vertigo has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
itsech0 has quit [Quit: Lost terminal]
aindilis has joined #lisp
dacoda has joined #lisp
nanoz has quit [Ping timeout: 246 seconds]
nisen has joined #lisp
nisen is now known as nisenasdf
reverse_light has joined #lisp
marusich has quit [Remote host closed the connection]
campy_fellow has quit [Quit: Quit]
campy_fellow has joined #lisp
orivej has joined #lisp
karlosz has quit [Quit: karlosz]
igemnace has joined #lisp
longshi has joined #lisp
Kundry_Wag has joined #lisp
campy_fellow has quit [Ping timeout: 244 seconds]
campy_fellow has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
shifty has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
hhdave has joined #lisp
kini has quit [Quit: No Ping reply in 180 seconds.]
dacoda has quit [Ping timeout: 276 seconds]
scymtym has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
aindilis has joined #lisp
kini has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
kini has quit [Client Quit]
Kundry_Wag has joined #lisp
aindilis has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
kini has joined #lisp
heisig has joined #lisp
ym555 has joined #lisp
kini has quit [Quit: No Ping reply in 180 seconds.]
Kundry_Wag has joined #lisp
notzmv has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Ping timeout: 268 seconds]
PuercoPop has quit [Ping timeout: 245 seconds]
PuercoPop has joined #lisp
Kundry_Wag has joined #lisp
kini has joined #lisp
libertyprime has quit [Ping timeout: 248 seconds]
amerlyq has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
kini has quit [Client Quit]
kini has joined #lisp
nisenasdf has quit [Remote host closed the connection]
<schweers>
fivo: sbcl also has a single stepper, works quite well in slime. Or rather: it used to work. Lately I’ve had some problems with it.
<no-defun-allowed>
Did you (declaim (optimize (debug 3)))?
<no-defun-allowed>
It's worked perfectly for me so far.
lumm has joined #lisp
ym555 has quit [Ping timeout: 248 seconds]
<fivo>
no-defun-allowed: If do step-into with the standard STEP the evaluation just continues normally, even with your declaim.
<no-defun-allowed>
recompile the code you're stepping after?
<fivo>
no-defun-allowed: so (compiled-funciton-p #'fun) returns true
<fivo>
do I need to do something else?
<no-defun-allowed>
reload, recompile, whichever word you find most appropriate for "C-c C-c the function again"
<no-defun-allowed>
SBCL pretty much always compiles so c-f-p doesn't matter too much
amerlyq has joined #lisp
kini has quit [Quit: No Ping reply in 180 seconds.]
<fivo>
no-defun-allowed:ok I am not sure we are understanding each other
<fivo>
what is the expected behaviour of STEP in sbcl
<schweers>
no-defun-allowed: in case your question was directed at me, yes I do compile my code with debugger friendly optimizations (optimize (speed 0) (safety 3) (debug 3))
<jackdaniel>
that would be fun, sadly only 0-3 range is allowed
kini has joined #lisp
<shka_>
(speed most-positive-fixnum)
<shka_>
:D
<shka_>
gotta go fast
campy_fellow has quit [Ping timeout: 248 seconds]
kini has quit [Quit: No Ping reply in 180 seconds.]
<jackdaniel>
good opportunity for an easter egg: (defun xxx () (declare (optimize (speed most-positive-fixnum))) ...) ;; compiler: your program has been optimized away.
<shka_>
warp speed
<heisig>
This could be the opportunity for the compiler to start an experimental superoptimizer with a run time of several decades :)
<heisig>
On the other hand, I'm not sure whether I want my compiler to have easter eggs. Computers are already weird enough.
<jackdaniel>
innocent easter eggs (which doesn't impede functionality) are one of few things which make programming still fun (intellectual challenges is another one)
<jackdaniel>
hint: popular CL compilers have some hidden easter eggs
<jackdaniel>
(sb-mop:class-prototype (find-class' fixnum)) ; ← to name one
kini has joined #lisp
clothespin has quit [Ping timeout: 245 seconds]
<fivo>
does quickload apply the optimizations currently being set?
<jackdaniel>
it doesn't modify them, so if you compile software by means of quickload they should take effect
<jackdaniel>
note though, that asdf may not compile things when you quickload a system (compilation artifact may be cached)
<fivo>
ok so is there a way to force it to recompile
<jackdaniel>
there is!
Bike has joined #lisp
<jackdaniel>
(I was going to wait in awkward silence for a few mintues, but I'm going to take a break now so I'll answer now: load-system has :force keyword which semantics are not clear to me, but you may also simply remove ~/.cache/common-lisp directory)
sshirokov has joined #lisp
kini has quit [Quit: No Ping reply in 180 seconds.]
sbryant has joined #lisp
Kundry_Wag has joined #lisp
t58_ has joined #lisp
jdz has quit [Ping timeout: 255 seconds]
<fivo>
jackdaniel: thanks that finally did it
jdz has joined #lisp
t58 has quit [Ping timeout: 259 seconds]
Kundry_Wag has quit [Ping timeout: 248 seconds]
lucasb has joined #lisp
kini has joined #lisp
nicball has joined #lisp
<Bike>
hellooooo, obscure lisp things question time. i noticed that CALL-NEXT-METHOD is explicitly described as having indefinite extent, so you can do things like (setf *global* #'call-next-method) and call it a bunch of times later. Anybody ever taken advantage of this?
lumm has quit [Remote host closed the connection]
<heisig>
Bike: Yes, of course :)
<Bike>
e.g.?
<scymtym>
Bike: i think you can store it, but not call it: "The function call-next-method can be used within the body forms …" "The function call-next-method has lexical scope and indefinite extent and can only be used within the body of a method …"
<shka_>
I also did this
nicball has quit [Ping timeout: 248 seconds]
<shka_>
i am not proud of that
<shka_>
behavior is undefined
<Bike>
scymtym: depends on what "used" means, i guess. but there's no reason to make it indefinite extent if it can't be called later, is there?
<Bike>
and i don't think it's actually very hard to give it real indefinite extent in the sense of being callable
<shka_>
well, maybe it is eq??
<heisig>
Bike: I once spliced (if *magic* #'call-next-method ACTUAL-BODY) into a method lambda to be able to get effective methods.
JohnMS has joined #lisp
<Bike>
i'm not sure i understand
<scymtym>
Bike: i agree that "used" is unclear. not sure what the intention was
<Bike>
the reason i'm asking is because i was like "oh, i can speed up the clos implementation a little by having these be dynamic extent" and then the clhs is explicitly like nah, and i'm curious why
orivej has quit [Ping timeout: 245 seconds]
JohnMS_WORK has quit [Ping timeout: 246 seconds]
<Bike>
no xjwhatever issue about it
<heisig>
Bike: The goal I had was to skip dynamic dispatch by having (let ((*magic* t)) (GF args)) return #'call-next-method.
<heisig>
So consecutive code could call that function directly.
<Bike>
oh.
<Bike>
that's... weird.
<Bike>
but ok.
<heisig>
I can, however, confirm that it is not faster at all. At least on SBCL.
<Bike>
dispatch isn't that expensive, i guess.
shka_ has quit [Quit: WeeChat 1.9.1]
<heisig>
And, SBCL (rightfully) turns of a lot of optimizations as soon as one uses non-standard metaobjects and accesses the value of #'call-next-method.
<heisig>
*off
<Bike>
yeah that too.
<Bike>
might be an interesting feature to support, though. explicit pre-dispatch like that. i could do it pretty easy in clasp's clos
<heisig>
Bike: I'm currently writing my own MAKE-EFFECTIVE-METHOD-USING-PROTOTYPES for each implementation. So if Clasp had such a feature, I'd gladly use it.
<Bike>
the way the system works, generic functions have a list of (classes . effective-method). so it would be... not hard, i think
<heisig>
Bike: How do you deal with eql specializers?
<Bike>
uh, it's a little involved to explain, but basically they force slow path unless there's no possibility of ambiguity.
<Bike>
the "classes" can also include eql specializers sometimes.
<heisig>
Oh, ok. That's why I decided to use unambiguous prototypes instead of classes.
Josh_2 has joined #lisp
nicball has quit [Ping timeout: 258 seconds]
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
nicball has quit [Remote host closed the connection]
nicball has joined #lisp
cage_ has joined #lisp
nicball has quit [Ping timeout: 245 seconds]
v88m has quit [Remote host closed the connection]
v88m has joined #lisp
nicball has joined #lisp
Inline has joined #lisp
campy_fellow has joined #lisp
nicball has quit [Ping timeout: 246 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
mindCrime has joined #lisp
t58_ is now known as t58
nicball has joined #lisp
nicball has quit [Ping timeout: 246 seconds]
FreeBirdLjj has joined #lisp
nullman` has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
heisig has quit [Quit: Leaving]
sjl_ has joined #lisp
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 248 seconds]
orivej has joined #lisp
nanoz has joined #lisp
nanozz has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
beach has quit [Disconnected by services]
beach has joined #lisp
amerlyq has quit [Quit: amerlyq]
dale_ has joined #lisp
dale_ is now known as dale
amerlyq has joined #lisp
longshi has quit [Ping timeout: 245 seconds]
FreeBirdLjj has joined #lisp
Josh_2 has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
<oni-on-ion>
why do you guys treat lisp like its prose ? such long symbols
<jackdaniel>
one witty answer which comes to mind is: you've answered yourself, it is the prose ,-)
<oni-on-ion>
o_o
<oni-on-ion>
the contentness *is* the koan =)
<oni-on-ion>
related note, i've mentioned a few times in passing, that lisp is better without syntax coloring. except maybe just non-alphanumeric characters.
<oni-on-ion>
we certainly dont read prose with coloring unless it has got some kind of links like Info or html
Josh_2 has joined #lisp
<dlowe>
we're used to having editors with smart tab completion
* schweers
likes to have some syntax coloring.
<dlowe>
some super smart syntax coloring would color symbols based on package
<beach>
oni-on-ion: Syntax coloring would be great if it weren't as stupid as that of Emacs. Like if the color somehow reflected the role of the symbols in the code.
<jackdaniel>
it usually does
<dlowe>
so you could color things in the CL package as keywords, but different other packages would look different, too
<schweers>
beach: what kind of role do you have in mind? special form, macro, function, variable?
<schweers>
Or do you mean something else entirely?
<beach>
schweers: Yes, stuff like that.
<jackdaniel>
schweers: it is about the fact, that slime does not check symbol role but rather uses a regexp to guess it
<schweers>
that would be nice. Doesn’t sound too hard, but I guess there are edge-cases which I’m not thinking about now
<beach>
schweers: For instance, Common Lisp function names can be used as lexical variables.
<beach>
Then the role changes.
<schweers>
hmm. It seems it is way more difficult than I first thought.
<oni-on-ion>
hmmm. seems simple though. especially if the "coloring" was relative to say, cursor position
* jackdaniel
don't understand the concept of color relative to a position
<oni-on-ion>
i've been thinking of this. as i use my emacs font colors for the same "level" as org mode headings so the brain picks up quickly and intuitively the "scope"
<jackdaniel>
doesn't°
<oni-on-ion>
well, i have been using rainbow-mode as well, which colors parens based on depth
<beach>
schweers: Difficult is not a problem. Just find the right solution.
<oni-on-ion>
now if this were relative to cursor, it wouldnt matter what is "top level" or the leafs of a form
<oni-on-ion>
and because context is especially important
devon has joined #lisp
<fivo>
beach: can I ask you a question about eclector?
<beach>
Sure.
<fivo>
beach: you haven't written that file so I am not sure you can help. Is the when statement on this line needed
<pjb>
We'd like different colors for when foo is used as a variable, a function [ (foo x) #'foo and 'foo if data flow shows it's used in a (funcall 'foo) ], type, catch label, block label, tagbody label, etc.
<beach>
Indeed.
<pjb>
But it's not trivial, it would have to be done within CL, not with emacs lisp. A good code walker will have to be used.
<beach>
We have one. It is called cleavir.
<beach>
And it works with first-class global environments that can be made incremental.
<beach>
Plus, we have Eclector to show us where in the source code language items are located.
devon has quit [Quit: rcirc on GNU Emacs 27.0.50]
schweers has quit [Ping timeout: 248 seconds]
<beach>
pjb: Or do you have any objections to that solution?
<oni-on-ion>
cleavir... does it relate to climacs ?
<beach>
minion: Please tell oni-on-ion about Cleavir.
<minion>
oni-on-ion: Cleavir: A project to create an implementation-independent compilation framework for Common Lisp. Currently Cleavir is part of SICL, but that might change in the future
<beach>
minion: Please tell oni-on-ion about SICL.
<minion>
oni-on-ion: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<oni-on-ion>
ah! i thought they were one and the same.
<beach>
oni-on-ion: But the plan is to use Cleavir to analyze the Common Lisp source code in a buffer of Second Climacs.
<oni-on-ion>
(especially i thought that SICL was the platform-independant CL )
<pjb>
beach: not at all; on the contrary, that should motivate somebody to implement it, since all the pieces are now available.
<oni-on-ion>
cool cool. is second climacs using [mc]clim ?
wmfree has joined #lisp
wmfree has left #lisp ["ERC (IRC client for Emacs 26.2)"]
<oni-on-ion>
i am digging into desktop ideas here and emacs/exwm is feeling like quicksand
<beach>
pjb: All the pieces are in place, that's true. But it is unlikely that someone other than me and perhaps one more person (who shall not be named at this point) would be motivated to do it.
<oni-on-ion>
$$
<beach>
oni-on-ion: I tried to make it as independent of the GUI library as I could, but the only one that it is currently using is McCLIM.
<oni-on-ion>
beach, alright cool. going to browse those 3 repos and digest some things
<pjb>
beach: the only cognate to futile starting by S I can find are sad and sterile… Sad Implementation of CL Sterile Implementation of CL :-(
<beach>
oni-on-ion: Great! I advise against trying to compile and run Second Climacs. It is not ready. But you can browse the code and the documentation.
<pjb>
Let's be more positive, it's not futile, it's Super! Super Implementation of CL!
<jackdaniel>
pjb: I belive that Superb Implementation sounds better ,-)
<pjb>
Or Superb, yes.
<beach>
pjb: It was just meant to be pronounced. Not interpreted as an acronym.
<oni-on-ion>
beach, checked out pharo recently. i am a sucker for 'wholesome' desktops like NeXTSTEP/GNUstep and smalltalk. but lisp now
<pjb>
We can't resist :-)
<oni-on-ion>
sacrosanct sacreligious
<oni-on-ion>
secret sanctified solitary sordid severe
<oni-on-ion>
eclector is (tm) marvel universe
<TMA>
google translate suggests sleeveless as a synonym to futile
<beach>
oni-on-ion: The issue isn't money. I have offered to pay someone part time to help me out. The issue is that it is hard to find someone with the right qualifications, the right motivation, and enough time.
v88m has quit [Ping timeout: 252 seconds]
quazimodo has quit [Ping timeout: 244 seconds]
nullman` has quit [Ping timeout: 248 seconds]
q9929t has joined #lisp
quazimodo has joined #lisp
<oni-on-ion>
qualifications, ie. well versed in CL ?
campy_fellow has quit [Ping timeout: 252 seconds]
<beach>
And algorithms and data structures, and compiler design, and editor representation, and software engineering, and English writing skills.
<phoe>
this does not produce code that itself has an IGNORABLE declaration
<phoe>
so compiling it will cause a style-warning
<phoe>
the IGNORABLE declaration should be propagated into the generated code
v88m has joined #lisp
<aeth>
I think that's come up for me before, not being able to use one of the alexandria forms (was it once-only or with-gensyms or something else?) because then I'd have to remove the ignorable, which is required to make it like the built-in macros
<phoe>
...oh no, no no no no
<phoe>
not the double backquote
<phoe>
shit
<_death>
the question is, do you want to declare something about X or about the variable bound in the expansion
andrei-n has quit [Read error: Connection reset by peer]
shka_ has quit [Ping timeout: 248 seconds]
ggole has quit [Quit: Leaving]
asdf_asdf_asdf has joined #lisp
akoana has joined #lisp
lumm has quit [Ping timeout: 245 seconds]
<oni-on-ion>
i would like to know more about CL types, i dont see much use of it in my travels
<oni-on-ion>
such as; it seems to me that one could do polymorphic variants as in ocaml (this_type OR that_type OR ..)
<oni-on-ion>
using deftype and the various specialisers
quazimodo has quit [Ping timeout: 258 seconds]
amerlyq has quit [Quit: amerlyq]
quazimodo has joined #lisp
<aeth>
oni-on-ion: Off the top of my head... You can do OR, you can do AND, you can do NOT, you can do things like integer ranges, and you can but shouldn't use SATISFIES because that's slow
<aeth>
And some fun with SATISFIES from 2019-04-10 here... (let ((x `(progn (format t "Hello, world!~%") (zerop (random 2 (make-random-state t)))))) (check-type x (satisfies eval)) x)
<aeth>
This might be the one case where retry on CHECK-TYPE makes sense :-p
<phoe>
pjb: oni-on-ion: CL types are based on sets and binary algebra. You can do negation, intersection and union of them, and define new basic types via DEFCLASS and DEFSTRUCT.
<phoe>
You cannot have custom parametric types in the type system though without using the slow SATISFIES type specifier.
campy_fellow has quit [Ping timeout: 252 seconds]
<aeth>
You can do things like specify array size, but only an exact match, not <= or >= etc.
<oni-on-ion>
aeth, is it enforced by compiler, or warned at - like 'type inference' ?
<oni-on-ion>
phoe, ouuu =)
<oni-on-ion>
ah ok - 'satisfies' is slow. i was wondering about that
<aeth>
oni-on-ion: If I'm parsing your question correctly, both. Types can be inferred, and they can be declared via forms like DECLARE and THE. The line can also be fairly blurred, since CHECK-TYPE has you explicitly provide the type, but below that the implementation probably infers that the thing you checked is in fact of that type.
cdegroot has joined #lisp
<oni-on-ion>
hmm interesting =) very flexible. cool
<aeth>
I'm not sure if :element-type in array and :type in defstruct slots counts as inference or declared. :type in defclass can be ignored and even then can't really give type information because of stuff like :after and :around iirc.
<aeth>
An make-array's :element-type is pretty restrictive. Mostly aimed at numbers. Portably, only bit and character, but (unsigned-byte 8) is pretty much universally included, too. Everything else is just ignored and turned into T.
<oni-on-ion>
something i seen in Cltl2 yesterday, when a type is 'upgraded' to array element type. it was a long function name
<oni-on-ion>
asdf_asdf_asdf, cool!! thanks =) =)
<asdf_asdf_asdf>
Sorry, should be: (defun hello2(n) (and (> n 0) (< n 10))) .
<aeth>
asdf_asdf_asdf: You can write that without satisfies. e.g. if an integer it would be (integer 1 9) but unfortunately the ranges are <= and there is no (number 0 10) even if your example was <= so you'd probably have to add a bunch of ORs if you want more than integers
<aeth>
Probably still faster than SATISFIES, though
<asdf_asdf_asdf>
Because without (and ...), only last condition it's be true.
campy_fellow has joined #lisp
<aeth>
Oh, I left out MEMBER. You can say (member :foo :bar :baz) e.g. (let ((x :bar)) (check-type x (member :foo :bar :baz)) x)
<aeth>
It's basically the CL enum-equivalent.
<phoe>
MEMBER is basically OR EQL
<phoe>
(member x y z) === (or (eql x) (eql y) (eql z))
<phoe>
but also also (eql x) === (member x)
<asdf_asdf_asdf>
MACROLET is probably better.
<phoe>
asdf_asdf_asdf: what for?
Kundry_Wag has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
Kundry_Wag has quit [Ping timeout: 246 seconds]
campy_fellow has quit [Ping timeout: 252 seconds]
<oni-on-ion>
asdf_asdf_asdf, the hello2 can also be a lambda ?
<asdf_asdf_asdf>
Wait.
sjl_ has quit [Quit: WeeChat 2.3-dev]
sjl has quit [Quit: WeeChat 2.2-dev]
elazul_ has quit [Ping timeout: 252 seconds]
akoana has left #lisp [#lisp]
Josh_2 has joined #lisp
sz0 has quit [Quit: Connection closed for inactivity]
<vaartis>
im not sure but it seems that CFFI+libffi cannot pass by-value to callbacks but can to other things..?
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
karlosz has quit [Quit: karlosz]
vaartis has left #lisp ["ERC (IRC client for Emacs 26.2)"]
karlosz has joined #lisp
karlosz has quit [Client Quit]
sjl has joined #lisp
<mgsk>
Any idea why on Windows drakma raises SB-BSD-SOCKETS:SOCKET-ERROR but on macOS raises USOCKET:SOCKET-ERROR. It looks like USOCKET *is* loaded and available on Windows, but isn't used?