notzmv has quit [Remote host closed the connection]
igemnace has quit [Ping timeout: 265 seconds]
didi has quit [Ping timeout: 268 seconds]
igemnace has joined #lisp
karlosz has joined #lisp
permagreen has joined #lisp
smazga has quit [Quit: leaving]
rgherdt has quit [Ping timeout: 276 seconds]
permagreen has left #lisp [#lisp]
makomo has quit [Ping timeout: 268 seconds]
igemnace has quit [Ping timeout: 240 seconds]
quazimodo has quit [Read error: Connection reset by peer]
didi has joined #lisp
quazimodo has joined #lisp
notzmv has joined #lisp
gioyik has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
orivej_ has quit [Ping timeout: 268 seconds]
krid has joined #lisp
ebrasca has quit [Remote host closed the connection]
igemnace has joined #lisp
patrixl has joined #lisp
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 26.3)]
Kaisyu7 has joined #lisp
Lycurgus has joined #lisp
drl has quit [Remote host closed the connection]
_whitelogger has joined #lisp
igemnace has quit [Ping timeout: 250 seconds]
Patzy has quit [Ping timeout: 244 seconds]
iovec has quit [Quit: Connection closed for inactivity]
bitmapper has quit [Ping timeout: 268 seconds]
Patzy has joined #lisp
Lycurgus has quit [Remote host closed the connection]
krid has quit [Ping timeout: 265 seconds]
quazimodo has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
igemnace has joined #lisp
quazimodo has joined #lisp
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
EvW has quit [Ping timeout: 276 seconds]
kmeow_ has quit [Remote host closed the connection]
krid has joined #lisp
Oladon has joined #lisp
Oladon has quit [Read error: Connection reset by peer]
gioyik has joined #lisp
beaky_ is now known as beaky
quazimodo has quit [Ping timeout: 240 seconds]
clothespin_ has joined #lisp
clothespin__ has quit [Ping timeout: 265 seconds]
brettgilio has joined #lisp
clothespin__ has joined #lisp
quazimodo has joined #lisp
clothespin_ has quit [Ping timeout: 265 seconds]
quazimodo has quit [Ping timeout: 250 seconds]
quazimodo has joined #lisp
<mister_m>
I have a user-entered pathname that I've invoked (uiop:ensure-directory-pathame ...) on. I want to use that base directory and then join it with another "relative namestring" to make a full pathname to a file. If my pathname is #P"/home/x/y/z/", and i want to join on "testing/a/path.txt" to it to make in total #P"/home/x/y/z/testing/a/path.txt", how can I do that? Trying uiop:merge-pathnames* gives me #P"/home/x/y/z/path.txt". I'm
<mister_m>
realizing I really don't understand how pathnames work.
quazimodo has quit [Ping timeout: 268 seconds]
pjb has quit [Ping timeout: 276 seconds]
<mister_m>
oh my god i flipped the arguments
<mister_m>
to uiop:merge-pathnames*
<mister_m>
:)
pjb has joined #lisp
akoana has left #lisp ["Leaving"]
<markasoftware_>
test
<markasoftware_>
ok we're good
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
Bike has quit [Quit: Lost terminal]
gravicappa has joined #lisp
nirved has quit [Ping timeout: 276 seconds]
nirved has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
kajo has joined #lisp
kajo has quit [Ping timeout: 250 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 276 seconds]
Lord_of_Life_ is now known as Lord_of_Life
didi has quit [Ping timeout: 250 seconds]
<beach>
Good morning everyone!
ggole has joined #lisp
smokeink has joined #lisp
slyrus_ has quit [Quit: Leaving]
brown121408 has quit [Remote host closed the connection]
smokeink has quit [Remote host closed the connection]
krid has quit [Ping timeout: 250 seconds]
rople has quit [Ping timeout: 245 seconds]
rople has joined #lisp
mathrick_ has quit [Read error: Connection reset by peer]
scymtym has quit [Ping timeout: 250 seconds]
mathrick has joined #lisp
Inline has quit [Quit: Leaving]
elfmacs has joined #lisp
krwq has quit [Remote host closed the connection]
elfmacs has quit [Client Quit]
marusich has joined #lisp
elfmacs has joined #lisp
jonatack has joined #lisp
dmiles has quit [Ping timeout: 276 seconds]
vlatkoB has joined #lisp
sauvin has joined #lisp
edgar-xxx has quit [Quit: Leaving]
edgar-rft has joined #lisp
SaganMan has joined #lisp
zmt01 has joined #lisp
zmt00 has quit [Ping timeout: 245 seconds]
brown121407 has joined #lisp
parjanya has quit [Ping timeout: 276 seconds]
keep_learning has joined #lisp
zmv` has joined #lisp
nullniverse has quit [Read error: Connection reset by peer]
zmv has quit [Read error: Connection reset by peer]
nullniverse has joined #lisp
nullniverse has quit [Changing host]
nullniverse has joined #lisp
dmiles has joined #lisp
JohnMS_WORK has joined #lisp
<no-defun-allowed>
Random question, is it specified if #+FOO will intern FOO in the package KEYWORD?
<Shinmera>
"#+ operates by first reading the feature expression and then skipping over the form if the feature expression fails. While reading the test, the current package is the KEYWORD package. "
Bourne has quit [Read error: Connection reset by peer]
Bourne has joined #lisp
mathrick has quit [Read error: Connection reset by peer]
elfmacs has quit [Ping timeout: 245 seconds]
jeosol has left #lisp [#lisp]
jeosol has joined #lisp
cosimone has quit [Quit: Terminated!]
makomo has joined #lisp
mathrick has joined #lisp
cosimone has joined #lisp
<flip214>
Is there some function that can convert a number to some indirectly specified type?
<shka__>
this sounds cryptic
<flip214>
I'd like an average to be of the same type as the input (integers, floats, ratios), but (coerce (/ sum count) (type-of (first input))) doesn't work
<shka__>
oh, it kinda should
<flip214>
sbcl says that this ratio can't be converted to (INTEGER 0 ...)
<flip214>
and doing typecase here feels _very_ unclean, in a dynamic programming language ;)
<shka__>
well, obviously
<shka__>
you can't convert ratio to integer
<flip214>
shka__: FLOOR could
<shka__>
you can round
<shka__>
yes, but floor does not convert
<shka__>
it does much more
<flip214>
I would like to avoid doing that "by hand" ...
<flip214>
ain't there some REALLY-COERCE function or so?
<loke`>
flip214: What do you want such function to do?
<shka__>
what you are doing is not coercing though
<flip214>
well, it's not casting either, is it?
<flip214>
loke`: I'd like a lossy change from one number to the type of another
<loke`>
flip214: Such as?
<shka__>
flip214: you will have to write your own function
<flip214>
loke`: converting a ratio to an integer
<flip214>
shka__: Yeah, I put a TYPECASE in now
<loke`>
flip214: That would be TRUNCATE, no?
<shka__>
that would do
<loke`>
I mean, when do you really need a coerce function where the type is variable?
<shka__>
there is no generic function for this because it wouldn't be usefull for general use
<flip214>
loke`: when the inputs are integer, I'd like the average to be an integer as well
<loke`>
flip214: That sounds like a rather odd requirement.
<loke`>
I'm sure you have a use case, but it's not really generic.
<Bike>
but if they're ratios and the average is a ratio you want that ratio?
<nirved>
the average of ratios can be integer
warweasle has joined #lisp
techquila has joined #lisp
<Bike>
that's why i said "and the average is a ratio", yeah
<flip214>
Bike: right
<pjb>
flip214: use a hash-table, or a vector.
<Bike>
i'm with loke in not understanding why you want this. you'll have to apply these rules yourself by checking the classes of the arguments.
mindthelion has quit [Ping timeout: 250 seconds]
drl has quit [Quit: Ex-Chat]
<Bike>
unlike the contagion rules in the language arithmetic these don't even associate, i don't think
<pjb>
If you want to convert numbers to numbers, some rounding will be necessary. And even, how do you round #C(2 2) to integer? Is it 2? 3? 4? does this mean anything?
<nirved>
flip214: maybe you'd like to take the median instead of mean
<Bike>
well you could only get a complex average if one of the arguments was complex
<Bike>
in which case presumably there would be no coercion to integer
<loke`>
And even if you have solution in your specific case (such as for example just taking the realpart of a complex number), that's never a generic solution.
<flip214>
pjb: I'd like to print average and stddev in the same format as the input.. so that column values (1 2 3 4) don't require a 2.5 in the "average" row
<Bike>
i mean, your average will be wrong, then
<flip214>
actual numbers are 7 digits or more, so rounding is insignificant
<bbsl>
does cl base have any way to manipulate strings like lists? I just need a way to from a string get head (the first char) and tail (the rest of the chars)
bendersteed has joined #lisp
techquila has quit [Remote host closed the connection]
<kritixilithos>
bbsl: in cl a string is an array
<Xach>
bbsl: you would use subseq to get parts of the string. or you could displace an array to parts of the string. the sequence operations have different implications than with lists.
<Xach>
you can't get the tail of a string for "free"
<Shinmera>
Most sequence functions also take a start and an end
<Shinmera>
so you don't have to create an explicit subsequence.
trittweiler has joined #lisp
<Xach>
bbsl: any new cool info about what you're doing so we can offer more suggestions? some of them possibly helpful?
rgherdt has joined #lisp
kritixilithos has quit [Quit: quit]
jfb4_ has quit [Ping timeout: 240 seconds]
jfb4 has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
bendersteed has quit [Remote host closed the connection]
efm has joined #lisp
sauvin has quit [Remote host closed the connection]
zmv`` has joined #lisp
zmv` has quit [Read error: Connection reset by peer]
<bbsl>
Xach: well I didnt get much wiser. Online I found a string-to-list function referenced but its not part of the std lib so meh. I can use (subseq) I guess but that wont work for be because I do not know the start and end of these "sequences" other than by index. I guess the mythical sequence start/end params mentioned here is the answer to my question
<Xach>
bbsl: i mean why do you want to work with a string like that in the first place?
<bbsl>
Xach: I dont but its the input to my program so I have to parse it somewhere.
<Xach>
ok
<Xach>
I guess my general advice would be "don't try to work with strings like that if you can avoid it"
<Xach>
there are lots of ways to avoid it
<bbsl>
Shinmera: oh :o) heh ty
hhdave has joined #lisp
hhdave has quit [Client Quit]
<bbsl>
Xach: Im sure but this is my 3rd day (I guess hour even) of cl so I am not expecting my code to be very idiomatic
<Bike>
like by iterating over a string one character at a time.
<Bike>
you can also just write out '(#\h #\e #\l ...) if you really want a list. or (coerce "hello world" 'list)
<jasom>
bbsl: I usually use a string and an offset for that case. Then head would just be (char string offset) and tail would be (1+ offset).
trittweiler has quit [Ping timeout: 276 seconds]
<aeth>
bbsl: In general, most things are sequence-generic, which includes strings, which are just character vectors
<aeth>
bbsl: If you're clever and you need an output list, you can e.g. use MAP to take advantage of this
<aeth>
(map 'list #'char-code "hello world") ; combines the conversion-to-list step with a processing step, in this case #'char-code
<bbsl>
aeth: ahh right Il remember that. At least map is somewhat familiar in this language even though it has like 6 of them :)
<aeth>
This is the equivalent in LOOP. Notice there is a slight difference because you use vector's :across instead of list's :in. (loop :for char :across "hello world" :collect (char-code char))
<aeth>
LOOP's a bit more confusing, but it's basically just a for loop when used like this.
<aeth>
It's just that :collect automatically builds a list instead of having to manually do so in :do
<aeth>
bbsl: As for the various variations of MAP, only MAP itself is generic, the others are specific to lists. MAPCAR is very roughly equivalent to MAP, but for lists alone.
brown121408 has quit [Ping timeout: 268 seconds]
brown121407 has joined #lisp
gioyik has quit [Ping timeout: 265 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<galdor>
REDUCE works indeed, thank you!
GloriaReed has joined #lisp
efm has quit [Ping timeout: 276 seconds]
GloriaReed has left #lisp [#lisp]
cosimone has quit [Read error: Connection reset by peer]
cosimone_ has joined #lisp
iovec has joined #lisp
nitrix has quit [Quit: Quit]
nitrix has joined #lisp
nitrix has quit [Client Quit]
malfort has joined #lisp
<bbsl>
aeth: ok thank you for the clarifications though I am not familiar with the :<bar> syntax of ie loop yet. I know you use :<bar> :<baz> to adress variables (?) in objects (?) but for lopp ie I am writing it like (loop for i from foo to bar <blergh>) ie. though I know you can do (loop :for ). I guess it makes sense if what I said first and loop is a iterable object or smt?
<bbsl>
*if what I said first is correct
smazga has quit [Ping timeout: 276 seconds]
<Bike>
using ":for" or "for" doesn't matter to the semantics of the loop macro
<Bike>
there are reasons to use one or the other, but they're boring and you shouldn't worry about it
<bbsl>
yea I am just not very confident with the syntax but I know that both work, though I am not sure why yet :)
<bbsl>
I guess I should learn about macros I have ignored that part so far
<jasom>
bbsl: I recommend not learning the guts of macros for now if you are a beginner.
<Bike>
this is kind of a special LOOP thing.
<jasom>
bbsl: once you are more comfortable with lisp they are quite easy to reason about, but until then it will likely just confuse you more
cosimone_ has quit [Remote host closed the connection]
vaporatorius has joined #lisp
<bbsl>
hmm I guess I will put it off then. for now my goal is just to fiddle around with the language
cosimone_ has joined #lisp
<bbsl>
Also. Does anyone know if there is a way (prefrably in slime) to given a type list out the functions available (prefrably in my env) that works on that type
<Xach>
bbsl: no
<Bike>
not really. that concept makes less sense outside of an environment like java where functions are tied to classes.
pnp has joined #lisp
<Bike>
(and parameters have static types, and etc)
pnp has left #lisp [#lisp]
<bbsl>
well it would increase discoverability by a lot. In haskell ie you can use hoogle to search for a function signature that matches what you want. In cl I feel stuck some times because I do not know the names of functions
<Bike>
haskell has static types. it makes sense in haskell.
<Bike>
common lisp is not really organized in the same way, that's all
<Bike>
plus there are higher order functions but not universally quantified types, so some things would be hard to express
<_death>
well, there is an xref facility that may work for some types
cosimone_ has quit [Remote host closed the connection]
omarish has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
smazga has joined #lisp
cosimone_ has joined #lisp
omarish has joined #lisp
<dlowe>
you can view methods which are specialized on types
<dlowe>
but most functions aren't methods
cosimone_ has quit [Excess Flood]
cosimone_ has joined #lisp
<boeg>
I've only been using sly in emacs to run common lisp, but now I want to run a script in a shell. Problem is, I have been using quickload to load modules, but this doesn't seem to work when I do "sbcl --script script.lisp", says it can't find QL which I use to require the module "split-sequence". How do I use a module with sbcl like that?
<Bike>
when you use --script it skips the sbcl init files that load quicklisp.
<Bike>
for a start you can try using --load instead
<boeg>
that works, thank you
<Bike>
alternately you can load quicklisp at the top of your script
brown121407 has quit [Read error: Connection reset by peer]
<boeg>
Bike: ill remember that
brown121407 has joined #lisp
<_death>
does sbcl default image contain asdf?
gareppa has joined #lisp
<Bike>
i... don't remember. you can just (require :asdf) tho
gravicappa has quit [Ping timeout: 265 seconds]
efm has joined #lisp
cosimone_ has quit [Remote host closed the connection]
cosimone_ has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
zmv`` is now known as zmv
zmv has quit [Changing host]
zmv has joined #lisp
cosimone_ has quit [Remote host closed the connection]
cosimone_ has joined #lisp
karlosz has joined #lisp
cosimone_ has quit [Remote host closed the connection]
cosimone_ has joined #lisp
slyrus has joined #lisp
cosimone_ has quit [Client Quit]
mathrick has quit [Read error: Connection reset by peer]
slyrus_ has quit [Ping timeout: 268 seconds]
gareppa has quit [Ping timeout: 265 seconds]
omarish has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
omarish has joined #lisp
<phoe>
_death: AFAIK the vanilla image doesn't, you need to explicitly require it.
hiroaki has joined #lisp
<phoe>
Yes, that's correct.
bbsl has quit [Remote host closed the connection]
bbsl has joined #lisp
chipolux has quit [Ping timeout: 245 seconds]
chipolux has joined #lisp
brettgilio has joined #lisp
<Xach>
/win 3
<no-defun-allowed>
congratulations, Xach is the winner of random IRC game where one must write "/win 3" to win
<bbsl>
too bad he did'nt write "/win 3" but rather " /win 3" :D
nowhere_man has joined #lisp
<_death>
phoe: good to know, thanks
<bbsl>
could someone please have a look at the bottom of https://rextester.com/BWJYD91713 . I am trying to (like I write in the comments) run a function against every item in a list but for each time it runs I want to take one of the (values x y) it returns and also feed that into the next call. My head is jumbled with all the new syntax and I am trying to use a let binding inside a collect but I guess thats not how you do it. I guess I can
<bbsl>
mapcar with a lambda to do the same thing?
<Bike>
you're talking about map-path?
<Bike>
i don't understand what you're trying to express here.
<Bike>
you call map-dir, and it returns two values, and you do what with them?
<Bike>
using let with collect is fine, but your let here is invalid syntax
<_death>
maybe something like (loop for dir in path for (m p) = (multiple-value-list (map-dir dir pos)) collect m do (setf pos p))
<_death>
looks like aoc day 3
<bbsl>
ahh yes I can bind variables when looping. and yes it is aoc3, 3rd day of cl :o
<_death>
maybe you should rethink your interface, however
karlosz has quit [Quit: karlosz]
gioyik has joined #lisp
varjag has quit [Ping timeout: 276 seconds]
akoana has joined #lisp
bitmappe_ has joined #lisp
bitmapper has quit [Read error: Connection reset by peer]
<bbsl>
_death: yes I have a feeling that knowing how to use setf propperly would be a big boon. I am borking stuff trying to shoehorn my usual goto of returning tuples
<phoe>
bbsl: in order to learn how SETF works, I'd start with learning how places work and what they are
<phoe>
do you have some sort of grasp on these?
stepnem has quit [Ping timeout: 265 seconds]
<bbsl>
phoe: not realy I started reading Practical Common Lisp but I started jumping around after the author went all in on the global `database` state nonsense
shka__ has quit [Ping timeout: 245 seconds]
stepnem has joined #lisp
<Shinmera>
???
nowhere_man has quit [Remote host closed the connection]
<Xach>
Practical Common Lisp is a good book and you will learn a lot from it if you read it carefully.
varjag has joined #lisp
shka_ has quit [Ping timeout: 276 seconds]
<Bike>
you mean in the "simple database" chapter for CDs or something?
<Bike>
that's just so that it's easy to understand. even says it's global "for simplicity"
<Bike>
and the globalness is kind of irrelevant to the book.
<phoe>
bbsl: the initial chapter is not meant for being understood
<phoe>
the initial chapter is there to give you an overall feeling of how working with the language looks like,.
<phoe>
I've always thought that this is the missing sentence that should have been printed in bold text at the beginning of PCL chapter 2
<Shinmera>
Confucius say: all state is local and global
<phoe>
because people try to read it and assume that they need to follow *EVERYTHING* that this chapter is about
shka__ has joined #lisp
shka_ has joined #lisp
<phoe>
and the author uses like 50% of all CL taught in PCL to write that database
srji has quit [Ping timeout: 246 seconds]
<bbsl>
well I lost interest trying to get trough that chapter. Wish there was a better resource like 'learn you a Haskell' but I guess I will pick the book up again in a while
<phoe>
bbsl: start straight from chapter 3
<phoe>
for about a year now, I have consistently been not sure whether chapter 2 of PCL in its current form is not a mistake
<phoe>
precisely for the reason that you mention
<Shinmera>
I liked it.
<phoe>
sure, but not everyone has the background to understand the technical parts and/or the attitude to just sit back and enjoy the ride instead of trying to understand everything that is going on
<phoe>
it's a trap, in a way
<phoe>
;; Disclosure: I liked that chapter as well.
<Shinmera>
people have preferences. whether they'll like it or not you can't know until they've tried reading it.
<Shinmera>
is my point.
bitmappe_ has quit [Remote host closed the connection]
bitmapper has joined #lisp
bitmapper has quit [Ping timeout: 240 seconds]
moon-child has joined #lisp
<phoe>
agreed
shifty has joined #lisp
<bbsl>
you should glance at the 'learn you a haskell' or the rust book, both are easyer to read with less fluff imo. compared to those Id say the Practial Common Lisp book is pretty lackluster but I guess they are two different sets of books to be fair
lucasb has joined #lisp
<fengshaun>
how can I pass <place> designator (e.g. used for setf) to functions? is it only doable with macros?
<fengshaun>
and just leave the place specifier as unevaluated until passed to whatever function/macro that needs it?
<White_Flame>
a place designator is a syntactic thing, so yes it's in the domain of macros if you pass it around
bitmapper has joined #lisp
<White_Flame>
you can also make a getter/setter pair of lambdas compiled to that place
<White_Flame>
if you want to be fully runtime
<fengshaun>
hmm how would I go about that?
<White_Flame>
say for car, (defun car-locative (cons) (list (lambda () (car cons)) (lambda (val) (setf (car cons) val))))
<White_Flame>
although it'd be more powerful than lisp machine locatives, iirc
<phoe>
if you don't want that, just use closures
<fengshaun>
oh that's what it's called
<White_Flame>
a locative used to be a slot pointer
<White_Flame>
where it had its own type and specific get/set functions into data it pointed to
<fengshaun>
what's a slot pointer?
<White_Flame>
but yeah, wrapping a place in a getter/setter function offers the same sort of interface, but you can actually access anything, even bits within a byte
<fengshaun>
my lack of understanding is showing
<White_Flame>
slot = a variable binding location, an element of a struct/class instance/array, the car or cdr of a cons, etc
<fengshaun>
oh ok
<White_Flame>
not knowing where you are with things, #clschool is a bit more newbie friendly, while #lisp assumes a lot more :)
random-nick has quit [Ping timeout: 240 seconds]
<fengshaun>
very new, just finished "gentle intro to symbolic computation"
<fengshaun>
thanks
bbsl has quit [Remote host closed the connection]
vlatkoB has quit [Remote host closed the connection]
<moon-child>
what's the best way to do gui in cl, barring lispworks? I saw eql, which seems to be ecl-specific; commonqt, which is still on qt4; a bunch of interfaces to tk, which apparently some people think is ugly; and a binding to gtk, which apparently looks ugly on macos and windows
<moon-child>
leaning towards the gtk binding
<moon-child>
oh, also considering using abcl and going through swing
<phoe>
qtools
<phoe>
that's what I use, and it's good enough
<phoe>
and yes, that is based on commonqt
<jasom>
tk is only ugly on linux, fwiw
<jasom>
and you can theme it to make it less ugly if you care.
<moon-child>
phoe: yeah. I don't want to be relying on a framework which isn't going to be maintained in the future
<moon-child>
jasom: really, huh, didn't know that. Theming like gtk where it's a user-applied theme, or can I make it look good from within the application?
<moon-child>
might actually use tk if I can make it look good
bendersteed has joined #lisp
<jasom>
moon-child: yes to both, but it's not popular enough for many people to have a user-applied theme
<moon-child>
any recommendations there?
<moon-child>
(of tk bindings, that is)
<phoe>
moon-child: really annoying bugs tend to sometimes get backported into qt-libs that commonqt can use
<phoe>
but yes, that's about it - Lisp could really use a qt5 binding
<moon-child>
I wonder if eql could be taken out of ecl?
<jasom>
qt5 doesn't really do C bindings like qt4 did, so that's a big part of it.
<moon-child>
I know someone made qt5 bindings for d, going through a c layer, so it's definitely possible
<jasom>
If you're willing to write your GUI in C++ and export out hooks to call into lisp, you could make a dynamically loadable library that lisp could call.
<moon-child>
I don't think it'd be worth it for me; it's not going to be a ui-heavy app. Just would be nice to use a nicer lib if it were possible
<jasom>
moon-child: D did it by making a generic DLL with bindings (QtE5Widgets) I suppose we could use that DLL from common lisp.
doublex_ has quit [Ping timeout: 245 seconds]
<phoe>
jasom: woah
<phoe>
that sounds like the way forward
<jasom>
Of course I don't know if it has foreign bindings or not; it might be D specific (D can generate DLLs)
Bourne has quit [Remote host closed the connection]
<moon-child>
d also is able to call directly into c++, which idk if they're using that at all
<jasom>
moon-child: oh, does it? I didn't realize that.
<moon-child>
yep. But most people don't use it because there isn't a good automatic binding generator and there are some unimplemented features. So if they're going through an intermediate dll, there's a good chance they're not using it
drl has joined #lisp
<jasom>
generateAlias("t_v__qp_qp_i_i_i_i_i") <-- looks like they could be using it, that looks like a C++ mangled name
<moon-child>
(aside: cl could call into qte5's c library, instead of needing to create our own. Be an annoying dependency but ¯\_(ツ)_/¯)
<phoe>
moon-child: commonqt does that already
<moon-child>
jasom: nope. generateAlias() makes an extern(C) function, meaning c ABI and name mangling
<moon-child>
phoe: dependency on a d library is less practical than a dependency on a c|c++ library
<moon-child>
especially since you need one already for qt
<jasom>
commonqt uses the smoke bindings which do not exist for qt5
<moon-child>
ahh
<moon-child>
how does pyqt5 do it, then?
khisanth__ has quit [Ping timeout: 268 seconds]
khisanth__ has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
<jasom>
moon-child: Python extsnsions are usually written in any language that can export C functions; there is a C api that allows manipulation of python objects.
<Xach>
_death: how do normally install libhspell.so?
doublex_ is now known as doublex
Bike_ has joined #lisp
Bike has quit [Disconnected by services]
Bike_ is now known as Bike
lottaquestions has joined #lisp
efm has quit [Read error: Connection reset by peer]
efm has joined #lisp
<lottaquestions>
Hi all, I have a question about SLDB with SBCL. How does one know which frames can be restarted and which ones cannot? Also, I seem to be losing global variables when I restart frames. I how do I prevent against that?