<hineios>
phoe I don't know about a VM but I've stumbled across at least one docker image that claimed (although I didn't test it) that it contained all the necessary foreign libraries to load all of quicklisp.
midre has quit [Ping timeout: 260 seconds]
midre has joined #lisp
hineios2 has joined #lisp
hineios2 has quit [Client Quit]
hineios5 has joined #lisp
<hineios5>
I'm on my phone right now and I can't find it...
sz0 has quit [Quit: Connection closed for inactivity]
papachan_ has joined #lisp
grewal has quit [Ping timeout: 256 seconds]
papachan has quit [Read error: Connection reset by peer]
grewal has joined #lisp
emys has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
jfrancis has joined #lisp
ahungry has joined #lisp
jfrancis_ has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
emys has quit [Ping timeout: 272 seconds]
pjb has quit [Ping timeout: 272 seconds]
emys has joined #lisp
v3ga has quit [Ping timeout: 260 seconds]
v3ga has joined #lisp
bitmapper has quit [Ping timeout: 260 seconds]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
emys has quit [Ping timeout: 264 seconds]
ArthurStrong has quit [Read error: Connection reset by peer]
emys has joined #lisp
pjb has joined #lisp
oxum has joined #lisp
gravicappa has joined #lisp
jfrancis_ has joined #lisp
dawgmatix has quit [Ping timeout: 258 seconds]
jfrancis has quit [Ping timeout: 260 seconds]
emys has quit [Ping timeout: 260 seconds]
emys has joined #lisp
emys has quit [Ping timeout: 260 seconds]
frgo has quit [Ping timeout: 260 seconds]
oxum_ has joined #lisp
emys has joined #lisp
oxum has quit [Ping timeout: 260 seconds]
jacks2 has joined #lisp
emys has quit [Ping timeout: 258 seconds]
Getgle has joined #lisp
jesse1010 has quit [Ping timeout: 246 seconds]
frgo has joined #lisp
FreeBirdLjj has joined #lisp
emys has joined #lisp
FreeBirdLjj has quit [Ping timeout: 260 seconds]
shangul has joined #lisp
emys has quit [Ping timeout: 260 seconds]
emys has joined #lisp
gaqwas has quit [Ping timeout: 265 seconds]
gaqwas has joined #lisp
emys has quit [Ping timeout: 246 seconds]
<beach>
Good morning everyone!
<ober>
morning
emys has joined #lisp
<Getgle>
hey
<Getgle>
whats better scheme or common lisp
<beach>
Getgle: This channel is dedicated to Common Lisp. So you won't gen an unbiased answer.
<beach>
Getgle: Try ##lisp instead for such comparisons.
<beach>
Getgle: But if you would like to learn Common Lisp, we will be happy to help you.
Bit_MCP has joined #lisp
<Getgle>
they all look really cool tbh
<beach>
All what?
<Getgle>
the answer may be biased but why did you guys specificially choose common lisp over racket/scheme/clojure etc
<Getgle>
all of the lisp languages
<Getgle>
i want to pick one
<beach>
There is no widely agreed-upon definition on "Lisp". That's why we dedicate this channel to Common Lisp, which *is* well defined.
<beach>
Language comparisons like that are unfortunately off topic here.
<pjb>
perhaps in ##lisp
Bike has quit [Quit: leaving]
<pjb>
Getgle: just use Common Lisp.
aindilis has quit [Remote host closed the connection]
<beach>
Getgle: I can tell you why I ended up with Common Lisp...
Kundry_Wag has quit [Read error: Connection reset by peer]
<beach>
Getgle: It has a stable, independent standard.
<beach>
Getgle: Which I emphasize in my talks to industry. A project manager who chooses a language with a single implementation or a language that is controlled by a single person or organization should be fired.
<beach>
Getgle: Common Lisp also has the absolute best condition system around (called exception system in other languages), and the best object-oriented facility as well.
emys has quit [Ping timeout: 260 seconds]
<Getgle>
i see
emys has joined #lisp
<beach>
Here is another piece of information that might help with your choice: Common Lisp is a multi-paradigm language. If you are into strict functional programming, there are other languages that might be preferable to you. Common Lisp supports functional programming, but it has strong support for imperative and object-oriented programming as well.
<beach>
For example, recursion is not recommended where iteration is practical.
<beach>
One more piece of information: I often hear that this channel is very good with giving people advice, and also very tolerant with newbies. And there are always lots of participants around to help.
<beach>
In fact, some people who desperately need help with other languages regularly show up here, just because the participants here are often very smart and very knowledgeable. Those people are, of course, kindly told to go elsewhere with their questions.
oxum_ has quit [Remote host closed the connection]
<beach>
So, lately, I have consider "IRC helpfulness" as a possible factor when a language is to be chosen.
aindilis has joined #lisp
<Getgle>
i see
<Getgle>
im gonna go common lisp then
<beach>
Sounds good. If you need help, there is also #clschool for truly trivial questions.
oxum has joined #lisp
<beach>
I don't know your background, so I don't know how familiar you are with Lisp concepts.
marusich has quit [Quit: Leaving]
shifty has joined #lisp
emys has quit [Ping timeout: 260 seconds]
emys has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
ArthurStrong has joined #lisp
emys has quit [Ping timeout: 256 seconds]
emys has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
emys has quit [Ping timeout: 256 seconds]
emys has joined #lisp
shka_ has joined #lisp
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
nicktick has quit [Ping timeout: 240 seconds]
oxum has quit [Ping timeout: 260 seconds]
emys has quit [Ping timeout: 246 seconds]
emys has joined #lisp
ljavorsk has joined #lisp
sdumi has quit [Ping timeout: 246 seconds]
sdumi has joined #lisp
zaquest has quit [Quit: Leaving]
ljavorsk has quit [Ping timeout: 246 seconds]
veiny_juicer has joined #lisp
emys has quit [Ping timeout: 272 seconds]
oxum has joined #lisp
emys has joined #lisp
ech has quit [Ping timeout: 256 seconds]
terpri_ has joined #lisp
terpri has quit [Remote host closed the connection]
karlosz has quit [Ping timeout: 256 seconds]
karlosz has joined #lisp
emys has quit [Ping timeout: 260 seconds]
zaquest has joined #lisp
sdumi has quit [Ping timeout: 256 seconds]
emys has joined #lisp
gko has joined #lisp
gko has quit [Ping timeout: 246 seconds]
oxum has quit [Remote host closed the connection]
karlosz_ has joined #lisp
karlosz has quit [Ping timeout: 256 seconds]
karlosz_ is now known as karlosz
ArthurStrong has quit [Ping timeout: 246 seconds]
ahungry has quit [Remote host closed the connection]
emys has quit [Ping timeout: 246 seconds]
<phoe>
hineios: oh! nice
emys has joined #lisp
Bit_MCP has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
emys has quit [Ping timeout: 272 seconds]
sdumi has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
dddddd has quit [Ping timeout: 260 seconds]
notzmv has quit [Ping timeout: 264 seconds]
emys has joined #lisp
nicktick has joined #lisp
oxum has joined #lisp
emys has quit [Ping timeout: 272 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
emys has joined #lisp
sauvin has joined #lisp
Getgle has quit [Read error: Connection reset by peer]
andrei-n has joined #lisp
space_otter has joined #lisp
emys has quit [Ping timeout: 264 seconds]
veiny_juicer has quit [Remote host closed the connection]
varjag has joined #lisp
emys has joined #lisp
emys has quit [Ping timeout: 258 seconds]
space_otter has quit [Remote host closed the connection]
space_otter has joined #lisp
Aurora_v_kosmose has quit [Remote host closed the connection]
Aurora_v_kosmose has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
random-nick has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
anticrisis has joined #lisp
hiroaki has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: closed"]
oxum has quit [Remote host closed the connection]
bhartrihari has joined #lisp
antaoiseach has joined #lisp
<boeg>
wrong?
<boeg>
I have an asdf:defsystem :next/darwin/gtk-application and :next/gtk-application and it looks to me that if I call asdf:make :next/gtk-application, it chooses :next/darwin/gtk-application instead of :next/gtk-application. If I comment out the defsystem of :next/darwin/gtk-application, then :next/gtk-application is chosen, but else its :next/darwin/gtk-application. Does that make any sense? Why is it doing that? Am I reading it
<boeg>
Shouldn't asdf:make :next/gtk-application make :next/gtk-application and not :next/darwin/gtk-application ?
hiroaki has quit [Ping timeout: 272 seconds]
oxum has joined #lisp
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
pve has joined #lisp
<boeg>
ah, my bad- the problem isn't that it chooses the wrong system, but that the wrong system has a dependency, and when the systems are defined, it looks for the dependency and fails, even though its not the system that is used
orivej has quit [Ping timeout: 256 seconds]
orivej_ has joined #lisp
heisig has joined #lisp
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
jonatack_ has quit [Ping timeout: 246 seconds]
jonatack_ has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
liberliver has joined #lisp
SGASAU has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 260 seconds]
sz0 has joined #lisp
SGASAU has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
orivej has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
orivej_ has quit [Ping timeout: 272 seconds]
seok has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 260 seconds]
orivej_ has joined #lisp
hineios3 has joined #lisp
orivej_ has quit [Ping timeout: 272 seconds]
hineios has quit [Ping timeout: 260 seconds]
hineios3 is now known as hineios
<ChoHag>
What data type can I use to hold on to a blob of undecoded binary data?
jonatack_ has quit [Quit: jonatack_]
<ChoHag>
Some equivalent of scheme's bytevector perhaps.
<beach>
(vector (unsigned-byte 8)) probably.
space_otter has quit [Remote host closed the connection]
jonatack has joined #lisp
space_otter has joined #lisp
Kundry_Wag has joined #lisp
SGASAU has quit [Remote host closed the connection]
<beach>
ChoHag: Did you faint?
SGASAU has joined #lisp
<ChoHag>
No, wading through some of this so-called documentation.
<no-defun-allowed>
What documentation?
Kundry_Wag has quit [Ping timeout: 265 seconds]
<ChoHag>
Quite.
<no-defun-allowed>
What documentation?
gaqwas has quit [Remote host closed the connection]
antaoiseach has left #lisp [#lisp]
doomlist3 has joined #lisp
liberliver1 has joined #lisp
liberliver has quit [Ping timeout: 246 seconds]
liberliver1 is now known as liberliver
<ChoHag>
A concise description of type specifiers would be nice.
<beach>
ChoHag: It is customary to at least acknowledge that you saw the advice that was given to you.
<no-defun-allowed>
What document are you expecting to have a concise description of type specifiers?
<ChoHag>
beach: It is not. Welcome to IRC. Enjoy your stay.
<beach>
I see.
splittist_ has joined #lisp
rutabaga_ has joined #lisp
lukego_ has joined #lisp
abbe_ has joined #lisp
creat_ has joined #lisp
<ChoHag>
It is equally customary (you mean "polite" by the way) to not get stroppy when acknowledgements are not immediately forthcoming, especially on an asynchronous medium.
<ChoHag>
If you must know I am in the process of reading the (scant) documentation to expand on the knowledge you gave in order to find out if it helps, how much, and (if I were to have not forgotten and/or the conversation moved on by that time) thank the original source appropriate to its usefulness.
<beach>
I will take that advice into account.
<no-defun-allowed>
What document are you reading?
<ChoHag>
At the moment I'm sidetracked reading a semi-rant about tulpes vs. lists.
<aeth>
ChoHag: What I literally do in my Scheme is essentially: (deftype octet () `(unsigned-byte 8)) (deftype bytevector () `(simple-array octet))
<ChoHag>
(Which is partly why I haven't got around to fawning over beach yet)
<aeth>
ChoHag: CL types are basically like C types except instead of hardcoding the number, it's programmable. (unsigned-byte 8) instead of uint8_t, (signed-byte 8) instead of int8_t...
<ChoHag>
aeth: As in, that is how bytevector is defined rather than as a type of its own?
<aeth>
ChoHag: Correct, that's how you define a Scheme bytevector in CL to the best of my knowledge.
<aeth>
ChoHag: My bad, this includes multidimensional arrays, so you might want to further restrict it to (*) which says any size as long as it's 1D
<aeth>
then that's (simple-array octet (*))
<no-defun-allowed>
aeth: Should it be (simple-array octet (*)) for a vector?
bfig_ has joined #lisp
<pjb>
ChoHag: note that beach's been on irc for more than 25 years, and available online using one protocol or another for at least 40 years.
oxum has quit [Remote host closed the connection]
<ChoHag>
He beats me by a decade or so then.
<ChoHag>
You'd think that after so many years, 7 minutes no longer seems such a long time.
<pjb>
ChoHag: that's the magic of lisp channels: whatever your age, you'll find older people more experienced than you.
KawJe has joined #lisp
<beach>
pjb: Thanks, but don't bother. I got the point.
<ChoHag>
Also perhaps he'd be aware that there are such things as timezones? I'm not even halfway through coffee number 1 over here.
KawJe has quit [Remote host closed the connection]
<pjb>
LOL. beach + timezones :-)
bfig has quit [Ping timeout: 260 seconds]
<pjb>
ChoHag: Hint: this channel is logged. You may want to browse the history.
KawJe has joined #lisp
<aeth>
ChoHag: The only way you can get "a type of its own" is by using OOP, such as defclass or defstruct, so it's much more efficient (and you get to keep using language built-ins) to just use DEFTYPE for arrays and numbers, or in this case arrays of numbers.
<ChoHag>
That's basically what the rant is 'complaining' about.
<ChoHag>
Basically that it's fantastically useful to represent tuples as typeless lists, except when it breaks and/or confuses things.
deselby has joined #lisp
<aeth>
ChoHag: For lists, you can define your own out of your own conses with DEFSTRUCT at the cost of about 30% performance (at least for my custom ones) and not being able to use built-in functions (unless it's a rare implementation that supports trivial-extensible-sequences). https://github.com/Shinmera/trivial-extensible-sequences/
space_otter has quit [Remote host closed the connection]
<aeth>
Custom array-like things are more difficult, potentially impossible (portably) depending on what you want to do.
<ChoHag>
That seems quite a lot of overhead.
<aeth>
Well, the overhead was probably the typechecking, since I defined a :type for the contents.
<ChoHag>
Even so.
<aeth>
Some of it might also be using naive cons-based list algorithms rather than SBCL's optimized ones, too
space_otter has joined #lisp
<aeth>
But, yes, custom collections (not just sequences, also things like custom hash tables) are often fairly expensive and there isn't a rich set in the standard library (at least by the standards of something like C++ or Java).
space_otter has quit [Remote host closed the connection]
<aeth>
And if you want a convenient API, most implementations have a fairly expensive generic dispatch vs. regular function calls.
<beach>
aeth: Let's hope that will change in the not-too-distant future.
mangul has joined #lisp
<aeth>
beach: I don't think method calls are normally inlined even when the type is inferred/declared, which could help a bit with this sort of thing.
<aeth>
Even if the dynamic semantics means that it still might have to do some small lookup (to check for e.g. a :before?), maybe this would help.
<phoe>
aeth: method calls? you mean method-function calls?
<beach>
But we are currently discussing a technique that would allow that.
<phoe>
or GF calls?
shangul has quit [Ping timeout: 246 seconds]
<aeth>
phoe: GF, yes. They're defined with defmethod (okay, they're not, but they kind of are, since you can implicitly create a defgeneric from a defmethod)
<phoe>
aeth: see Marco Heisig's work on that matter
<beach>
aeth: Er, no, the effective-method-function would already contain the auxiliary methods that are applicable. There is no "lookup" at run time.
<phoe>
in general, however, it's impossible to avoid runtime checks of any kind because GFs are extensible at runtime. that's why his technique explicitly shuts off any further extensibility of the sealed GFs
<beach>
phoe: Better yet, we are currently sketching a technique that would do most of those optimizations automatically.
doomlist3 has quit [Quit: not part but quit]
corpix_ has quit [Remote host closed the connection]
<phoe>
beach: very nice
shka_ has quit [Ping timeout: 264 seconds]
<beach>
We hope so. We are quite excited about this possibility.
corpix has joined #lisp
<beach>
We have some thread-safety issues to resolve though.
anticrisis has quit [Read error: Connection reset by peer]
<aeth>
IMO what CL is generally lacking, at least in common use, is efficient, immutable, and typed-element variations of sequences/hash-tables/etc. like one might expect in other programming languages.
Kundry_Wag has joined #lisp
<beach>
Here we go again.
<beach>
Yeah, we need a new standard, decided upon by the participants of #lisp.
<aeth>
And somewhat relatedly, "memory-dense" struct pseudo-arrays for C/C++-like code. At the moment, a struct of numerical arrays is trivial as long as the implementation supports the types, while an array of structs is inefficient. The distinction is that the semantics are incompatible so you couldn't just (make-array 42 :element-type your-struct)
<aeth>
beach: None of this requires a new standard.
<aeth>
It just requires a handful of extensions, and then libraries on top of that.
<aeth>
Although I guess arrayable structs could violate standard semantics a bit if done poorly.
<beach>
Those "dense arrays" pose a serious problem with object identity.
<beach>
I can't see anyway it can be done right.
<ChoHag>
That's no reason not throw a cascade of teenagers with no attention span at it.
<aeth>
beach: They couldn't be done as arrays, they would have to be done as their own thing. I think that they would have to be immutable vector-like sequences with mutable contents. So (setf (fooref foo 42) 1234) or even (setf (fooref foo 42) (make-whatever)) would be impossible
<phoe>
that's no longer standard structs though
<aeth>
beach: But (setf (foobar (fooref foo 42)) 37) would be possible
<luis>
ralt: pinging is the way to go. There's fierce competition in the things-to-do-outside-work space :) Just merged one of the PRs. BTW, the Git gospel prescribes that the subject line shouldn't end with a period
<aeth>
phoe: No, it's no longer standard vectors/arrays. It could be standard structs, but you might need/want a way to forbid inheritance.
Kundry_Wag has quit [Ping timeout: 260 seconds]
<aeth>
phoe: Of course, if the implementation doesn't support :type in struct slots or it isn't an optimized type, then the "dense" part would effectively just be pointers.
<heisig>
aeth: You can always submit a pull request to your implementation of choice :)
<aeth>
heisig: Potentially, but if not done right it'd just be another thing like SBCL's multiple precision library
<aeth>
It also afaik would require (1) generic sequences to be more acceptable and (2) immutable generic sequences to in some sense be expected.
oxum has joined #lisp
<heisig>
I am working on (1).
<phoe>
aeth: if I understand you correctly, then your "dense struct arrays" would not preserve identity of individual structs. It's more like a collection of densely packed places.
<aeth>
The idea would be that if you have a simple type, a specialized array, one of these pseudo-arrays, or a struct (but inheritance interferes with this, but you could make it a length-1 pseudo-array)... then you could put it in a :type'd slot in a struct in a pseudo-array, potentially recursively, and now you have a way to potentially direct-port a lot of C++-ish efficient code, avoiding FFI
<aeth>
phoe: No, it should preserve the identity of individual structs. You could (fooref foo 42) [or (elt foo 42) if generic] to get the 43rd struct from the foovector, but you couldn't (setf (fooref foo 42) (make-whatever-struct)) because the foovector is immutable. The main complication is that you'd consider the struct allocated in the foovector, not on its own in the heap.
<beach>
heisig: We should just go ahead an implement "dense arrays" for SICL. :)
<aeth>
phoe: Now, the complication would be GC as described since a reference to the 43rd struct from the foovector could be kept after every other reference to the foovector is gone, which kind of defeats a big advantage of specialized arrays.
<phoe>
aeth: how would you implement that? you'd need a Lisp object, and there's no real Lisp object in such a vector
oxum has quit [Ping timeout: 258 seconds]
<aeth>
phoe: It's a real Lisp object, it's just allocated into the foovector instead of on the heap (without the type tag, to save space? honestly, I wouldn't mind wasting the RAM that much), which when used recursively to build elaborate data structures could allow direct porting of many C/C++ data structure concepts.
<heisig>
beach: Yes, we'd need that anyway for good C++ interoperability :)
<phoe>
aeth: OK.
<aeth>
That is a foovector of structs of foovectors of structs of (unsigned-byte 8) arrays or whatever gives you things that are fairly similar to what you might see in C.
<beach>
heisig: Exactly!
<beach>
We already have immobile code for that very purpose.
<aeth>
phoe: Every time I bring this up, I adapt it to further criticism and I guess pretty soon I'll wind up with a CDR out of it (if those are still a thing)
<phoe>
aeth: in theory, they are.
<aeth>
Oh, and if you make the foovector "static" then you could even use this to replace static-vectors/etc. with a more robust FFI-friendly thing (at least when using FFI-friendly types).
<aeth>
Of course, you wouldn't normally want this, only when FFIing
oxum has joined #lisp
<aeth>
I guess you could call them struct-vectors?
<aeth>
It has the disadvantage that "svref" is already taken.
<phoe>
aeth: vector-structs!
<phoe>
#'vsref will totally not confuse anyone
<aeth>
You could call them struct-arrays and allow them to be multidimensional and a svarray of size '() is essentially just a special, potentially-more-FFI-friendly struct.
<aeth>
You probably wouldn't want to FFI anything that's not size () or (*) though
<aeth>
Also, then they wouldn't always be sequences.
liberliver has quit [Ping timeout: 240 seconds]
mangul is now known as shangul
<aeth>
phoe: One potential complicating factor is that you might want one layer of indirection. That is, if you have [A|B|C|D|...] and want to "delete" B, then you might want to do it by copying D into B (manually, of course... the data structure wouldn't know how to do this), but then you have [A|D|C|...] and any reference to D is now wrong and any reference to B is now D. So these might be most useful if there's some kind of locative.
<aeth>
(Would "locative" be the correct concept? Not sure.)
<aeth>
But it would still be pretty useful even if it's just the simple form of memory-dense struct-arrays
terpri_ has quit [Remote host closed the connection]
terpri_ has joined #lisp
<aeth>
(In my example, I also didn't say if the "..." is there and treated as unused or if it's actually growing/shrinking like e.g. vector-push/vector-push-extend)
<aeth>
heisig: What do you think?
Necktwi has quit [Ping timeout: 265 seconds]
liberliver has joined #lisp
<phoe>
aeth: you have problems with object identity if you delete elements like that. For all purposes, you don't delete B; you just overwrite all of its slots with values taken from D, so B is still B, it just has different contents.
<phoe>
this also means that D is likely still there, just inaccessible, if we use the fill pointer analogy.
<phoe>
that is, unless you use some sort of locatives which preserve identity, but then the locatives become the actual structs and the vector simply becomes external storage for them. bam, we've reinvented displaced vectors, in a way.
<phoe>
I therefore don't think deleting stuff from such a vector is a meaningful operation, not unless you want to copy the vector in the process.
bhartrihari has left #lisp ["Disconnected: closed"]
bhartrihari has joined #lisp
<heisig>
aeth: Whenever I really care that much about the memory footprint of structs, I use a single struct with specialized arrays for each 'slot'.
<heisig>
I am also not sure about the capabilities of CFFI. It could be that such vectors are already supported.
<aeth>
heisig: Yes, that's what I've been doing in my game engine, just making structs of arrays.
<aeth>
phoe: Right. In this case, I think that the perfect (maintaining object identity even in the case of my example) is probably the enemy of the good (having struct-arrays in the first place).r
<aeth>
s/.r//
RedMallet has joined #lisp
<aeth>
phoe: Similarly not being immutable and doing something like e.g. (setf (saref foo 42) (saref foo 43)) to copy elt-43 into elt-42 would be nice to have, but would probably be too complicated since (1) (setf (saref foo 42) (make-barfoo)) would copy-into which isn't what you'd expect and (2) now you'd need a way to define copy-into for every struct, and is it deep vs. shallow, etc., and now you enter into the mess of what C/C++ has to deal wi
nicktick has quit [Ping timeout: 264 seconds]
<aeth>
And those are the two main drawbacks I can think of
<phoe>
aeth: 1) stems from the fact that such vectors naturally wouldn't preserve identity, and 2) is solvable by "shallow copies by default, write your own SETF function if you want more"
Grisha has joined #lisp
<Grisha>
hello everyone, I'm trying to build an s-expr parser using Java CUP ( = bison/yacc counterpart) and JLex. It all goes quite well, but I'm struggling with how to handle single quotes, should it be performed during the lexing or parsing stage. I think I need to do it during the parse pass, since quoting a non-atom should be able to consume the whole quoted expression (can be of an arbitrary depth), but how
<Grisha>
would I ensure that there is no space between the quote itself and the thing being quoted?
<phoe>
Grisha: `' ( 1 2 3 )`
<phoe>
this is equivalent to '(1 2 3)
<Grisha>
is it?
<phoe>
yes!
<phoe>
try it in the CL REPL
<Grisha>
hmm, not in elisp
<phoe>
ELISP> ' (1 2 3)
<phoe>
(1 2 3)
<phoe>
works for me in IELM
<phoe>
also, Lisp is not traditinally parsed or lexed - it is read
<phoe>
obviously, you can't have read-eval without a Lisp evaluator
<phoe>
but I guess that if Grisha is implementing a sexp reader without Lisp then they won't bother with read-eval
<no-defun-allowed>
If one has an implementation of a stream, they are already more prepared than most people to try to read (a subset of) Common Lisp expressions.
<beach>
So then the question becomes: What subset of READ is still acceptable for it to be called a "Lisp reader?"
<Grisha>
I'm doing this (s-expr lexer/parser) as a preparatory example before going to a larger grammar
<Grisha>
just to have something simple and with a well-defined scope
<phoe>
beach: I don't think Grisha is trying to read Common Lisp code, just some whatever subset of s-expressions
<beach>
Sure.
<Grisha>
exactly, just a small subset of s-exprs
jesse1010 has joined #lisp
paul0 has quit [Ping timeout: 246 seconds]
<pjb>
Grisha: the C-x C-e command in *scratch* works by moving the cursor using text-based operations.
<phoe>
Grisha: the *scratch* error is likely because emacs attempts to evaluate either (a b c) or ' alone from the other part
<Grisha>
I somehow assumed that C-j would eval the whole line
<Grisha>
you're correct
<Grisha>
folks, you've been most helpful, thank you everyone
<phoe>
Grisha: <3
<pjb>
Grisha: otherwise, a lot of reader macros and dispatching reader macros work by reading a sexp after having read the macro character or the argument, options and dispatching macro character. This means that any whitespaces can be inserted between the later and the former.
<Grisha>
yeah, it would mean that I can handle the single quote (or the backtick or whatever similar construct) by a parser rule
<Grisha>
having single quote as a terminal
<pjb>
Or even, that you can use other reader macros there, such as #. !
<pjb>
(quote (#P "foo" #' foo ' foo #2A #.(read-from-string "( ( 1 2 3) (a b c) (dx dy dz))"))) #| --> (#P"foo" #'foo 'foo #2A((1 2 3) (a b c) (dx dy dz))) |#
<phoe>
Xach: beep boop
amerlyq has joined #lisp
<pjb>
Grisha: I don't know what you mean by "handle the single quote", but if you are implementing a Common Lisp reader, you must use the Common Lisp reader algorithm that is specified in chapter 2. Note that this is the ONLY algorithm that is specified in CLHS!!!
<phoe>
pjb: they are *not* implementing a Common Lisp reader, which we have established twelve minutes ago.
<pjb>
Grisha: also, have a look at Rivest SEXPS, Expired November 4, 1997 RFC S-Expressions draft-rivest-sexp-00.txt
<Grisha>
pjb: thank you
<Grisha>
my initial plan was to stick to quite a limited subset of s-exprs
<phoe>
what's your final plan?
<Grisha>
it's just an exercise for me to get used to parsing/lexing using my tools
<Grisha>
my final plan is to introduce the notion of the single quote to my parser, call it a day and continue with a larger grammar
<Grisha>
I'm going through the Stanford's cs143 compilers course
<phoe>
Grisha: if your tools allow this, you might want to use the identity 'foo == (quote foo) somewhere
<Grisha>
that sounds great, at the same time I'm a bit skeptical if the transformations like this should be part of parsing
<phoe>
that's how the quote reader macro works in Lisp
<Grisha>
what you're talking about is manipulating the AST
<Grisha>
right now I'm interested in just generating it from input
<phoe>
I guess you can lex `'foo` as `#<QUOTE> foo` and then, during the parsing step, for each `#<QUOTE> x` encountered in the syntax, instead collect `(quote x)`
<Grisha>
in this Java CUP tool, you specify your grammar by saying "an s-expr is either an atom or a list", "an atom is either a number, a string, or a symbol", "a list is an open paren followed by zero or more s-exprs followed by a closing paren" and so on
<phoe>
definitely not the Lisp way, but if we must use lexers and parsers...
<Grisha>
doing the quote during the lex pass is difficult becauase if the quoted s-expr a list, we don't really know how nested it is
shangul has quit [Ping timeout: 256 seconds]
<Grisha>
all a lexer can do is just simple pattern matching by regexes
<axion>
an atom is either what now?
<Grisha>
number, string, or symbol (plus many things I'm missing like characters and so on)
<phoe>
Grisha: you don't need to care about that in the lexing stage; if you have (1 2 '(3 4)) just read that as a four-element list where the third element is a loose quote.
<phoe>
you can fix that up in the parsing stage.
<Grisha>
is then "'(3" going to be a token??
<Grisha>
a single token?
<phoe>
is "(3" going to be a single token?
<Grisha>
it's not how I understood lexing
<phoe>
let's take that to #lispcafe - it's getting off-topic
Grisha has quit [Quit: Lost terminal]
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
Bourne has quit [Read error: Connection reset by peer]
oxum has quit [Ping timeout: 256 seconds]
cantstanya has quit [Ping timeout: 240 seconds]
cantstanya has joined #lisp
SGASAU has quit [Remote host closed the connection]
<phoe>
a comma must always be inside a matching backquote.
<beach>
What does DEFENTITY do?
<phoe>
beach: I think that question may come later, let's get the syntax straightened out first.
<rogersm>
This is part of a definition file that will generate code in C and SQL
<phoe>
rogersm: why is there a lone comma in there
<rogersm>
but the expectation is the syntax no to be too lispy
<beach>
Did you invent this notation?
<rogersm>
if the question is this can be changed, yes it can be
<beach>
If the syntax is not supposed to be Lisp-y, then you can't use the Lisp reader to read it.
<phoe>
rogersm: commas have a special meaning in Lisp syntax, they must not happen in source code on their own.
<rogersm>
this is why I was using macros, so I could escape from the reader (and have no evaluation)
<phoe>
nope
<phoe>
macros cannot escape from the reader
<beach>
rogersm: Macro code is read by the usual reader.
<rogersm>
So then the alternative is a parser, something that we already have in C
<phoe>
I don't understand, what are you trying to do? invent your own Lisp syntax?
<beach>
Usually, the best alternative is to adapt your syntax so that it would be acceptable as Lisp sysntax.
<rogersm>
phoe: remove the complexity of a C program and move it to lisp
<phoe>
rogersm: which Lisp dialect? Is it Common Lisp?
<beach>
Excellent plan.
oxum has joined #lisp
<rogersm>
yes
<rogersm>
Common Lisp
<phoe>
rogersm: then the lone comma must go
<phoe>
unless you hack the reader to use your own syntax, which is rarely a good idea and even more rarely a necessary thing
<phoe>
do you mean (defentity pc :description "..." :component named :component descriptable :component locatable)?
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
easieste has joined #lisp
easieste has quit [Remote host closed the connection]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
oxum has quit [Remote host closed the connection]
<rogersm>
that would be an option
<dlowe>
what about (defentity :component (descriptable locatable) ...)?
oxum has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
<phoe>
that's another way to dress that in s-expressions, sure; I guess that rogersm would be the one to decide which suits his intent the best, since it's his macro
pjb has joined #lisp
<rogersm>
yes, the main question is completely solved :D
shifty has quit [Ping timeout: 246 seconds]
oxum has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
EvW has quit [Ping timeout: 272 seconds]
xenon- has joined #lisp
oxum has joined #lisp
liberliver has quit [Ping timeout: 258 seconds]
notzmv has joined #lisp
oxum has quit [Ping timeout: 260 seconds]
pjb has quit [Ping timeout: 272 seconds]
whartung_ has joined #lisp
nikka has quit [Read error: Connection reset by peer]
milanj has quit [Quit: This computer has gone to sleep]
orivej_ has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
ech has quit [Ping timeout: 260 seconds]
even4void has joined #lisp
even4void has quit [Remote host closed the connection]
smazga has joined #lisp
msk has quit [Remote host closed the connection]
msk has joined #lisp
even4void has joined #lisp
<gendl>
Hi, is there a standard way in Slime/Swank, when doing (swank:create-server), to detect whether a port is busy, and if so, try the next one, and the next, etc until an open one is found?
even4void has quit [Remote host closed the connection]
<gendl>
or, should I just not give the :port argument at all?
fluxwave has quit [Ping timeout: 246 seconds]
even4void has joined #lisp
<gendl>
(I having to know what the port number is, at least, because I'm gonna try to connect to it remotely through an ssh tunnel)
even4void has quit [Remote host closed the connection]
even4void has joined #lisp
even4void has quit [Remote host closed the connection]
even4void has joined #lisp
even4void has quit [Remote host closed the connection]
even4void has joined #lisp
<xristos>
gendl: you can implement the try-port-if-busy-try-another logic yourself outside of create-server
even4void has quit [Remote host closed the connection]
francogrex has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
pjb has joined #lisp
efm has quit [Ping timeout: 264 seconds]
<gendl>
xristos: How does it normally pick a port?
<xristos>
gendl: type (swank:create-server in a SLIME buffer and hit M-. to jump to the source
<xristos>
well you don't even need to do that, just look at the argument
<xristos>
so it will use the port you provide and if you don't provide one, default-server-port
SGASAU has quit [Remote host closed the connection]
kpoeck has quit [Ping timeout: 245 seconds]
SGASAU has joined #lisp
francogrex has quit [Quit: Leaving]
liberliver has quit [Ping timeout: 272 seconds]
<phoe>
gendl: * (swank:create-server :port 0)
<phoe>
;; Swank started at port: 46675.
shangul has joined #lisp
orivej_ has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
cosimone has joined #lisp
grewal has quit [Ping timeout: 265 seconds]
grewal has joined #lisp
karlosz has joined #lisp
lucasb has joined #lisp
shangul has quit [Ping timeout: 258 seconds]
grewal has quit [Ping timeout: 256 seconds]
pjb has quit [Ping timeout: 272 seconds]
grewal has joined #lisp
ahungry has joined #lisp
<gendl>
phoe: aha.
<gendl>
Looks like it's doing some manner of try-port-if-busy-try-another already... i'll check the code, should have done that first, thanks.
izh_ has joined #lisp
<flip214>
gendl: port 0 asks the OS to choose a free port.
<gendl>
flip214: ah - is that without any extra work on Swank's part? That's an os-level feature with port 0?
<phoe>
yes
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
oxum has joined #lisp
emys has quit [Ping timeout: 264 seconds]
zulu-inuoe has joined #lisp
emys has joined #lisp
emys has quit [Ping timeout: 260 seconds]
cosimone has quit [Quit: Quit.]
izh_ has quit [Quit: Leaving]
emys has joined #lisp
pjb has joined #lisp
cosimone has joined #lisp
bfig_ has joined #lisp
bfig has quit [Read error: Connection reset by peer]
jonatack has quit [Ping timeout: 246 seconds]
jonatack has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
shifty has quit [Ping timeout: 240 seconds]
bhartrihari has joined #lisp
voidlily has quit [Remote host closed the connection]
voidlily has joined #lisp
oxum has quit [Ping timeout: 272 seconds]
msk has quit [Read error: Connection reset by peer]
msk has joined #lisp
pjb has quit [Ping timeout: 272 seconds]
karayan has quit [Remote host closed the connection]
ech has joined #lisp
jeosol has quit [Remote host closed the connection]
defaultxr has joined #lisp
bfig_ is now known as bfig
voidlily has quit [Ping timeout: 260 seconds]
grewal has quit [Ping timeout: 256 seconds]
grewal has joined #lisp
karayan has joined #lisp
<defaultxr>
hi. i'm working on a macro that wraps defun along these lines: (defmacro foo (name args) `(defun ,name ,args (apply other-func (list ,@args)))) . this works for stuff like (foo blah (arg1 arg2)) and similar, but if i include &optional or &key arguments, i.e. (foo blah (arg1 &optional (arg2 :hello))) then the APPLY in that case ends up being (apply other-func (list arg1 &optional (arg2 :hello))) when
<defaultxr>
what i really want is just (apply other-func (list arg1 arg2)) . i could try to clean up the args manually in my macro, but is there a better/recommended way to do this?
ahungry has quit [Remote host closed the connection]
<Bike>
usually you'd stick with &rest args for that.
<Bike>
like `(defun ,name (&rest rest) (apply other-func rest))
<defaultxr>
yeah but then the function signature would just be "&rest rest" of course, which isn't very informative...
<Bike>
yeah. hard to deal with that without parsing the lambda list.
<Bike>
of course you can do (setf (fdefinition name) other-func) as well
voidlily has joined #lisp
<defaultxr>
i guess i should've included that it actually is a wrapper macro, and it does have a &body section to it, so just (setf (fdefinition ...) ...) wouldn't really do what i want either
<defaultxr>
i know i could also do something like (defmethod swank::compute-enriched-decoded-arglist ...) to make it show up correctly in swank but that feels hacky and like it shouldn't be necessary (plus then that only affects swank ofc)
<defaultxr>
if there's nothing in standard CL, i wonder if anyone knows of a decent library for this functionality that's already out there
<Bike>
what does the body section like do, though
gravicappa has quit [Ping timeout: 256 seconds]
pjb has joined #lisp
<defaultxr>
basically the macro makes a funcallable object instance that contains a function slot, then a function (defun) with the specified name that calls that funcallable object
<defaultxr>
now that i think of it, in this case i guess i could do it the other way around, and have the funcallable object just call the function with itself as an argument. though i have other similar macros where i wouldn't be able to do it that way
<Bike>
you mean like a mop funcallable object?
mikecheck has joined #lisp
<defaultxr>
yes
<Bike>
maybe i'm not following. can you not just do (setf (fdefinition name) funcallable-object)?
<Bike>
though i'm not sure swank will do well at getting the lambda list of a funcallable object to display
shka_ has quit [Ping timeout: 240 seconds]
Bourne has joined #lisp
<defaultxr>
hm, actually, that does seem to work in this case
<defaultxr>
i still need to parse the lambda-list for my other similar macros though i think. was just wondering if there was a more standard/obvious way of doing it than that
voidlily has quit [Ping timeout: 256 seconds]
<Bike>
not really.
<Bike>
alexandria has a lambda list parser you can use.
voidlily has joined #lisp
<defaultxr>
that looks like it will help a lot actually
rgherdt_ has quit [Ping timeout: 272 seconds]
<defaultxr>
i figured there was something obvious i was missing... thanks for your help!
botanick has joined #lisp
andrei-n has quit [Quit: Leaving]
stoneglass has joined #lisp
voidlily has quit [Ping timeout: 260 seconds]
karayan has quit [Ping timeout: 260 seconds]
voidlily has joined #lisp
ArthurStrong has quit [Read error: Connection reset by peer]
ArthurStrong has joined #lisp
emys has quit [Ping timeout: 272 seconds]
emys has joined #lisp
Mawile has joined #lisp
Archenoth has quit [Ping timeout: 246 seconds]
sjl_ has quit [Ping timeout: 256 seconds]
pve has quit [Quit: leaving]
emys has quit [Ping timeout: 265 seconds]
emys has joined #lisp
anticrisis has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
nikka has quit [Quit: Leaving]
paul0 has joined #lisp
random-nick has quit [Ping timeout: 256 seconds]
SGASAU has quit [Remote host closed the connection]
SGASAU has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
igemnace has joined #lisp
tsrt^ has joined #lisp
cosimone has quit [Quit: Quit.]
SGASAU` has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
SGASAU has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
orivej has quit [Quit: No Ping reply in 180 seconds.]
emys has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
wxie has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
jonatack_ has joined #lisp
chipolux_ has quit [Ping timeout: 256 seconds]
jonatack has quit [Ping timeout: 260 seconds]
oxum has joined #lisp
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
Jesin has quit [Quit: Leaving]
SGASAU` has quit [Remote host closed the connection]
SGASAU` has joined #lisp
oxum has quit [Ping timeout: 240 seconds]
dyelar has quit [Quit: Leaving.]
emys has joined #lisp
orivej_ has joined #lisp
Jesin has joined #lisp
botanick has quit [Ping timeout: 260 seconds]
whiteline has quit [Read error: Connection reset by peer]
whiteline has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej_ has quit [Ping timeout: 265 seconds]
emys has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
cracauer has quit [Remote host closed the connection]
emys has joined #lisp
oni-on-ion has joined #lisp
kaftejiman has joined #lisp
T3ns0r has joined #lisp
SGASAU` has quit [Remote host closed the connection]
lemoinem has quit [Killed (kornbluth.freenode.net (Nickname regained by services))]