<no-defun-allowed>
fengshaun: The Land of Lisp book has a "periodic table" of LOOP clauses.
<Josh_2>
no-defun-allowed: is that online?
<Josh_2>
I have the physical copy buuuut ya know, easier online
<fengshaun>
thahnks
<no-defun-allowed>
No, sadly.
<aeth>
ebrasca: I haven't written the backend to a machine learning system, but I wouldn't be surprised if a lot of the algorithms there deal with "t" in equations in a non-time manner.
<no-defun-allowed>
Though I don't find the CLHS syntax description unreadable.
<aeth>
The most straightforward application of course does use time as "t"
<LdBeth>
BNF is quite reasonable too read
<LdBeth>
dv/dt
<aeth>
any syntax is reasonable once you're used to it
<fengshaun>
no-defun-allowed, not *unreadable* per se, just takes time to put together all the bits
<fengshaun>
I thought I'd ask before trying to make my own graph of loop syntax
<ebrasca>
aeth: It is easy to use t as time. Yes , any leter is equal in mathematics.
<aeth>
LdBeth: Yes, dv/dt, but is that change in velocity w.r.t. time in physics or is that the vector v (probably the second vector in your equations, with u being the first) in some arbitrary differential equation that could be applied to any domain where diff. eq. makes sense?
<phoe>
vsync: uiop:strcat
<aeth>
LdBeth: Perhaps "velocity" and "time" are good substitutions for "v" and "t", but perhaps "v" and "t" are the most straightforward variables here, in which case you have to replace "t" with "u" or "t*". If vectors, then "u" is probably taken, so you'd have to do "t*"
<LdBeth>
aeth: the first thing I came up in mind is the former “velocity” “time”
<aeth>
LdBeth: Right, but that's just the application of physics, which might not be what you're doing with your numerical code... and if it's a library, you have to assume that someone will have some exotic application, too.
orivej has quit [Ping timeout: 240 seconds]
<mister_m>
If i have two classes A, and B - and B is a subtype of A - and they also both define intitialize-instance :after methods - if I thenperform a make-instance on the subclass B, will the initialize-instance method of the parent type A also be executed?
<aeth>
LdBeth: Although, really, you can just see "time" as a useful fiction even if it has nothing to do with time. I think some people interpret "t" that way.
<aeth>
Probably a good way to get a flamewar in a bug tracker, though.
<ebrasca>
aeth: For you, can "t" be terraforming ?
ebzzry_ has joined #lisp
<ebrasca>
aeth: Thank you1
<LdBeth>
mister_m: yes, and beach mentioned there’s something wrong with your code design if you intends to get rid of the :after method of class A
<aeth>
ebrasca: No, I was talking specifically about calculus, especially differential equations. There are quite a few equations of t, and "t" is just afaik a variable that you use to step through things in your system, at least when viewed as numerical computations.
<aeth>
Which could be time.
<aeth>
ebrasca: Interestingly, Wikipedia says "time dependence of a point in geometrical space" for "dynamical system" so it sort of disagrees with me. https://en.wikipedia.org/wiki/Dynamical_system
<mister_m>
LdBeth: in this case I have a general bit of initialization that happens with the superclass A, and some more specialized initialization with B. Shouldn't really change I don't think
<aeth>
I wouldn't be surprised if t's use in physics and differential equations is the main reason why Scheme went with #t instead of CL's T
<LdBeth>
Good to hear that mister_m
libertyprime has quit [Ping timeout: 268 seconds]
rgherdt has quit [Ping timeout: 252 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
reb has joined #lisp
reb has quit [Remote host closed the connection]
davepdotorg has joined #lisp
wiselord has quit [Read error: Connection reset by peer]
wiselord has joined #lisp
davepdotorg has quit [Ping timeout: 268 seconds]
libertyprime has joined #lisp
<dlowe>
CL could have gone with something crazy like CL:TRUE
<dlowe>
Scheme just didn't like generalized booleans
<aeth>
dlowe: The main disadvantage with true is that you have "true" and "false" and they're different lengths, but it's not like CL even has an f. Nope, it's just t and nil.
<aeth>
(The length issue can impact a visual glance of certain things)
<aeth>
(Or column alignment)
<White_Flame>
CL:TRUTHY and CL:FALSY
<aeth>
dlowe: I will probably use "true" and "false" in my SXP file format because dealing with t/nil vs. #t/#f/() is a mess and those are just the two languages where it's the most trivial to implement an SXP reader
<aeth>
No ()s at all. All lists will require a first element. That kills an ambiguity issue with e.g. using lists like JSON's [] and plists like JSON's {}
<White_Flame>
and then there's true/false/null/undefined, and zero vs non-zero, etc across other languages
<aeth>
I like how CL uses nil as false and as null, effectively meaning that there *is* no null, since it's more of a false than a null.
<aeth>
Using it as the empty list, too, can cause some ambiguity issues when serializing to/from a text-based format, though.
anewuser has quit [Ping timeout: 245 seconds]
<aeth>
Your naive s-expression writer probably won't know when to print nil as () and as NIL and will probably err on the side of too many NILs
wiselord has quit [Ping timeout: 268 seconds]
<Xach>
there are so many new advent of code lisp repos on github today.
<aeth>
Too bad Advent of Code dropped at the wrong time for me. Well, I mean, it's not like it was going to appear at some other time.
libertyprime has quit [Ping timeout: 265 seconds]
<aeth>
I think I'm going to take a CL break for the next 7-10 days.
<aeth>
I can tell when I'm too exhausted to have time for CL when most of my comments are things like comments and docstrings instead of substance. (It's still pretty useful to document code, of course.)
<aeth>
s/my comments/my commits/
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 265 seconds]
marusich has joined #lisp
ebrasca has quit [Remote host closed the connection]
<White_Flame>
aeth: technically in the image (but usually not in serailized data), there's NIL, non-NIL, and unbound
libertyprime has joined #lisp
<aeth>
White_Flame: But if you try to access unbound, you'll get an error, right?
<White_Flame>
yep
<aeth>
White_Flame: So it's unserializable without a special case code for it
<White_Flame>
obviously images are serialized too, though
<aeth>
General serialization is kind of a doomed task, anyway
<White_Flame>
it just usualy doesn't hit serialized user data
smokeink has joined #lisp
<aeth>
I mean, general and portable. Images aren't even portable across versions typically afaik
<White_Flame>
but one could consider unbound to be a "special value" tested with unboundp (sort of like NaN tests need a different predicate), as that is also how it's often implemented
<White_Flame>
although I don't believe anything in the spec considers unboundness in that sense, especially with the history of a-list environments
<aeth>
White_Flame: The easiest way to handle serialization of an instance of an arbitrary class is to make the user deal with it
<aeth>
Some architectures are easier to serialize than others, e.g. the Entity Component System that's currently popular in game engine dev
marusich has quit [Ping timeout: 250 seconds]
smokeink has quit [Ping timeout: 276 seconds]
ozzloy_ is now known as ozzloy
ozzloy has quit [Changing host]
ozzloy has joined #lisp
<dlowe>
aeth: That "main disavantage" seems hilariously trivial
<dlowe>
I mean, t and nil aren't the same either
<pfdietz>
I want serialization (in the sense of being able to put them in fasl files) of closures and lexical environments.
v0|d has joined #lisp
v0|d has quit [Remote host closed the connection]
marusich has joined #lisp
<aeth>
dlowe: right, it is hilariously trivial
<vsync>
what's a good word for "I've completed the first pass over some work and there may or may not be more work to do after handing it off, which fact I may or may not actually already know"?
<vsync>
I meant "antonym" for concatenate earlier, btw, not "acronym" :-P
rople has joined #lisp
libertyprime has quit [Ping timeout: 265 seconds]
<nirved>
vsync: antonyms of concatenate - disconnect, disjoin, divide, separate
<vsync>
I ended up using... wait, what did I end up using?
<mfiano>
decatenate, split
<edgar-rft>
un-concatenate
<vsync>
oh, slice because rather than a single-purpose "split this string into single-char strings", I made something to slice up a sequence into equal lengths and then defined string-char-strings in terms of that
<vsync>
unless this already exists I have plans to augment it with many lovely keyword arguments
<vsync>
could it be implemented in terms of split-sequence-if? perhaps, but this seems clearer and, I think, more performant
<vsync>
also this allows for a nice companion: splice
<White_Flame>
I've heard the notion that 10-12 list items is where it becomes faster to use a hashtable than searching the list. Has this been measured for Lisp implementations, or do you think it's more specific to other-language implementations?
<edgar-rft>
antonym-of-conctenate would be *much* more lispy :-)
<mfiano>
Yes that operation is common, and is usually called "partition"
<nirved>
"I've completed..." -> 1. or I.
<vsync>
mfiano: I thought I had seen that somewhere, but when I looked at util packages it seemed to be an alias for split-sequence
<vsync>
distressingly
<vsync>
edgar-rft: ooh a friend of complement called antonym... or better, converse
<vsync>
converse or inverse?
<nirved>
chitchat or contrary?
<mfiano>
vsync: actually partition is for splitting based on a predicate function. "batches" is what you want. It's found in a few libraries such as serapeum
<mfiano>
CL-USER> (serapeum:batches "foobar" 2)
<mfiano>
("fo" "ob" "ar")
<vsync>
:-( but also :-)
<edgar-rft>
found-no-better-name could also be an altenative to take into account
<vsync>
heh
<mfiano>
There are 2 hard problems in computer science
* White_Flame
clears mfiano's cache
<mfiano>
:)
<vsync>
tanagra, a function which takes a function designator and returns a meme reference if available
<mfiano>
If I wanted to obfuscate code, I have reader macros as my primary weapon
monokrom has quit [Remote host closed the connection]
<White_Flame>
reader macros + unicode + emoji would be the ultimate in human-unreadability
<mfiano>
i'd still probably sprinkle tagbody, case-specific symbols, and others liberally
<mfiano>
a CL obfuscator would be pretty unfair compared to other languages
<LdBeth>
Why need obfuscator when the code can be compiled
<LdBeth>
After searches a little bit I find out that even C has a need for it
marusich has quit [Ping timeout: 276 seconds]
<mfiano>
White_Flame: Instead of emoji, just use combinations of unicode whitespace and non-printable character symbol names.
<pfdietz>
Let's not forget zero width space characters.
<mfiano>
err that's what i meant
<mfiano>
You'd be left with a series of parens, and you could change the dispatching characters for them to be similar
PuercoPope has quit [Remote host closed the connection]
kmeow has joined #lisp
<kmeow>
I have an array defined like (defvar arr #('(5 "David") '(3 "Sarah") '(2 "Alex"))), but doing a (car (elt arr 2)) gives me QUOTE, which is not what I was expecting [since (car '(3 "Sarah")) gives 3]
<kmeow>
I know how to get the numbers out of those lists in the array, but I don't understand what's going on exactly
Necktwi has quit [Quit: leaving]
<Xach>
kmeow: '(5 "David") is a list of two elements, QUOTE and (5 "David")
<Bike>
#(...) constructs literal vectors. the elements aren't evaluated.
<Xach>
'<anything> is shorthand for (QUOTE <anything>)
<kmeow>
ohhhhhhhhhhhhhhhhhhhh
<Xach>
when evaluated, (QUOTE <anything>) results in <anything>
Necktwi has joined #lisp
<kmeow>
so ' needed to be evaluated for it to turn the lists inside into actual lists
<Xach>
kmeow: right
<Xach>
before evaluation it's just a list
<White_Flame>
try (vector '(5 "David") ...). That's a function that will evalate them as parameters.
<White_Flame>
whereas #( just compiles the vector from the literals you put there
rople has quit [Read error: Connection reset by peer]
karlosz has quit [Quit: karlosz]
rople has joined #lisp
clothespin has joined #lisp
gko has joined #lisp
anewuser has joined #lisp
EvW1 has quit [Ping timeout: 246 seconds]
igemnace has joined #lisp
libertyprime has quit [Ping timeout: 246 seconds]
pjb has quit [Remote host closed the connection]
libertyprime has joined #lisp
torbo has quit [Remote host closed the connection]
pjb has joined #lisp
quazimodo has quit [Ping timeout: 252 seconds]
quazimodo has joined #lisp
clothespin_ has joined #lisp
karlosz has joined #lisp
mindthelion has joined #lisp
techquila has quit [Ping timeout: 245 seconds]
clothespin has quit [Ping timeout: 276 seconds]
Bike has quit [Quit: Lost terminal]
<beach>
Good morning everyone!
<fengshaun>
20min to next AoC puzzle!
<beach>
Appelation d'origine controlée?
<no-defun-allowed>
Probably Advent of Code. No wine or cheese involved, sadly.
<fengshaun>
beach, Advent of Code
<fengshaun>
no-defun-allowed, why not?
<aeth>
Probably «Avent du code source»
<beach>
Ah.
<no-defun-allowed>
fengshaun: Wikipedia tells me the name beach had in mind "is the French certification granted to certain French geographical indications for wines, cheeses, butters, and other agricultural products."
<aeth>
Of course, I'm not sure how they got "AoC" from "ACS"
<fengshaun>
time to get some wine and cheese then!
<fengshaun>
I don't have any projects that lend themselves to high level languages, so AoC is a good place to do some lisp
<beach>
fengshaun: I have a web page of suggested project in case you are looking for something.
<fengshaun>
I have quite a few in my todo list, but almost all are embedded stuff
<aeth>
fengshaun: one of these days some unfortunate person is going to read 'a web browser' from the list, not realize how hard it is, and 5 years later actually have one written
<beach>
fengshaun: Feel free to give me feedback on the items of that list.
<fengshaun>
aeth, that sounds like a worthwhile adventure considering the state of browsers
<fengshaun>
beach, the list looks good!
<beach>
Thanks.
<fengshaun>
maybe I should put my to-do-projects list up somewhere
gravicappa has joined #lisp
brown121408 has quit [Ping timeout: 240 seconds]
brown121408 has joined #lisp
brown121408 has quit [Remote host closed the connection]
<beach>
"email client" and "calendar program" should be very easy given that we have McCLIM.
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life has joined #lisp
<beach>
And "web browser" can be thought of as a collection of modules for displaying text, images, movies, PDF documents, etc.
clothespin__ has joined #lisp
clothespin_ has quit [Ping timeout: 276 seconds]
anewuser has quit [Read error: Connection reset by peer]
sindan has quit [Remote host closed the connection]
sindan has joined #lisp
mathrick has quit [Ping timeout: 265 seconds]
mathrick has joined #lisp
rople has quit [Ping timeout: 250 seconds]
rople has joined #lisp
Cymew has joined #lisp
orivej has joined #lisp
rgherdt has joined #lisp
brown121407 has joined #lisp
froggey has quit [Ping timeout: 265 seconds]
vlatkoB has joined #lisp
froggey has joined #lisp
rgherdt has quit [Quit: Leaving]
khisanth__ has quit [Ping timeout: 268 seconds]
epiwafer has joined #lisp
epiwafer has quit [Client Quit]
kritixilithos has joined #lisp
kmeow has quit [Remote host closed the connection]
trittweiler has joined #lisp
khisanth__ has joined #lisp
Codaraxis_ has joined #lisp
Codaraxis has quit [Ping timeout: 268 seconds]
trittweiler has quit [Ping timeout: 245 seconds]
JohnMS_WORK has joined #lisp
libertyprime has quit [Read error: Connection reset by peer]
megalography has quit [Ping timeout: 250 seconds]
dddddd has quit [Remote host closed the connection]
<mfiano>
Is McCLIM usable on modern displays yet? I had tried a couple months ago and it was not.
<beach>
It is probably best to ask that in #clim. What made it not usable for you?
<mfiano>
CLX does not properly consult the X resource database. As such, on a high DPI display, the cursor size is so tiny that you can barely see it, let alone accurately manipulate it. The same for font sizes, etc, although there are workaround hacks for them, unlike the cursor.
Kevslinger has quit [Quit: Connection closed for inactivity]
<vsync>
mfiano: s/modern/high-dpi/
<mfiano>
That is true. I haven't had a non-high DPI display in years.
scymtym has quit [Ping timeout: 276 seconds]
gravicappa has quit [Ping timeout: 265 seconds]
<beach>
So the problem is with X11 and/or CLX?
<mfiano>
CLX. X11 apps are to query the X resource manager for information such as the DPI. CLX does not
<beach>
It is true that CLX has not kept up with X11 evolution. An update is needed. I would like to see it use more generic functions as well.
<beach>
And more standard classes.
<mfiano>
That would be nice.
varjag has joined #lisp
<beach>
Also, an update should emphasize xrender more than what is currently done.
<MichaelRaskin>
email client for the modern mess would probably be fine-ish, given it can just refuse to do any scripting. A Web browser nowadays is not a collection of modules for displaying sane documents, it's a damned operating system with API creep and compatibility expectations creeping apparently beyond the scope of POSIX…
<beach>
MichaelRaskin: Is your description of the current state of things a necessity, or just the result of the use of traditional language and linker technology?
<MichaelRaskin>
It is not a necessity for bulding a useful Web, but it is a necessity to use modern government Web services
<mfiano>
I did get a chance to learn McCLIM on a friend's computer, and it was nice. Although sometimes it would crash X11 completely with a memory error, so I'm sure CLX can be made more correct on multiple counts.
<MichaelRaskin>
(and many commercial services are worse, not better, than the government ones)
<no-defun-allowed>
Um, if it crashes X11, I think that is a server bug.
<beach>
mfiano: Some of those problems have been fixed by avoiding the execution of code that would make the server crash.
<beach>
no-defun-allowed: Indeed, but we can work around them.
libertyprime has joined #lisp
<beach>
MichaelRaskin: What I meant to ask was whether it is a necessity for a web browser to not be modular.
<mfiano>
I'm not sure whose fault it was, but I could reliably crash the X server by resizing a McCLIM window.
<beach>
I fail to see how such a property could be the fault of the particular web sites being consulted.
<mfiano>
That was about a year ago though.
<beach>
mfiano: It is definitely a server problem, but like I said, things have been fixed with workarounds.
<mfiano>
I wouldn't know. I haven't had a computer where McCLIM renders visibly in about a year.
<no-defun-allowed>
A web browser is modular (one may decompose one into rendering engines, parsers and script interpreters/compilers, at least) but the stages one would also imagine (read the file from the server, read any dependencies like scripts and stylesheets, then render it) are expected to be very interleaved.
<MichaelRaskin>
Browsers are kind of modular, but in your classification most of the complexity is just one part, Web APIs. Then there is CSS. Then there are some small and nice additional modules.
<MichaelRaskin>
And of course modern browsers try to do Web API implementations kind of modular (however they are eventually brought together), but it is a huge mess just by size
flamebeard has joined #lisp
<MichaelRaskin>
CSS is probably smaller on total size, but worse on density of connections
<beach>
Why is size a problem if the thing is modular?
<MichaelRaskin>
Well, CSS might just be a small number of huge modules that are hard to modularise further, and in Web APIs there are large chunks where Blink breaks the spec, and Gecko implements both the proper and Blink behaviour, and to test the result you need enough APIs to test against the trash-quality websites that actually use this API (and a ton of others)
<beach>
I shall have to take your word for it. I don't know enough of web technology to understand.
davepdotorg has joined #lisp
<MichaelRaskin>
I agree that Web APIs are just a large pile of kind-of-modularisable things with imprecise spec and compatibility concerns, so they can be written part-by-part. But for that level of modularity Object Pascal is enough.
<MichaelRaskin>
I guess adding just enough JavaScript support that Lobste;rs submission form works is nice and doable and modularisable
<beach>
I don't understand why you brought up Object Pascal. Is that what things are typically written in?
<MichaelRaskin>
Just to say that facilities for modularisation have not be a bottleneck in the last 30 years
uplime has joined #lisp
<MichaelRaskin>
These things are written in C++, or in Rust nowadays. It looks like Rust has enough memory safety to be a fully sufficient choice for them
<beach>
I don't know Object Pascal, but anything with manual memory management or that does not use uniform reference semantics is going to be problematic for modularity.
davepdotorg has quit [Ping timeout: 250 seconds]
<Shinmera>
Implementing an HTML renderer is a big task, but doable. Implementing an HTML5 renderer probably already not. Implementing a CSS renderer is a gigantic task not even the big players can keep up with.
scymtym has joined #lisp
<beach>
The web is a mess, that's for sure.
mathrick has quit [Ping timeout: 240 seconds]
<MichaelRaskin>
Mere HTML5 without CSS is not yet that bad, I think
<MichaelRaskin>
It's just never without CSS
<Shinmera>
Video rendering and the JS canvas is pretty damn bad I'd say.
<Shinmera>
Video codecs are an entire hellscape of their own
mathrick has joined #lisp
<MichaelRaskin>
I think one can list «pretty damn bad» Web APIs for a long time without much effort…
frgo has quit [Ping timeout: 250 seconds]
<no-defun-allowed>
The part I dislike the most is that whitespace is significant. If I write <span>foo</span><span>bar</span>, it is different to <span>foo</span> <span>bar</span>, which is sometimes what I want, but also sometimes not.
<no-defun-allowed>
Or maybe that's a CL-WHO problem for not letting me choose in places where it matters, like disabling whitespace between elements which I use to create a bar graph, but keeping it everywhere else to make the source more readable.
akoana has quit [Quit: leaving]
asarch has joined #lisp
makomo has joined #lisp
Oddity has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 252 seconds]
MichaelRaskin has quit [Quit: MichaelRaskin]
HDurer has joined #lisp
Oddity has joined #lisp
shenghi has quit [Ping timeout: 268 seconds]
ljavorsk has joined #lisp
hhdave has joined #lisp
maxxcan has joined #lisp
shenghi has joined #lisp
Codaraxis__ has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
frgo has joined #lisp
Codaraxis_ has quit [Ping timeout: 276 seconds]
froggey has quit [Ping timeout: 240 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
froggey has joined #lisp
drl has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
frgo has quit [Remote host closed the connection]
vaporatorius has quit [Read error: Connection reset by peer]
dale has quit [Quit: My computer has gone to sleep]
asarch has quit [Quit: Leaving]
frgo has joined #lisp
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
frgo_ has quit [Ping timeout: 268 seconds]
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
rgherdt has joined #lisp
rople has quit [Ping timeout: 252 seconds]
rople has joined #lisp
pbgc has joined #lisp
ebrasca has joined #lisp
shifty has quit [Ping timeout: 268 seconds]
<p_l>
in order to implement HTML5 you need to implement JS, and to fairly high level
frgo has joined #lisp
mathrick has quit [Ping timeout: 276 seconds]
wiselord has joined #lisp
<edgar-rft>
The funny thing is that HTML originally was meant to be a *simple* markup language.
jonatack has quit [Ping timeout: 276 seconds]
<no-defun-allowed>
All of cl-who is compile-time, right? So I couldn't set some magic variable or something to change the whitespace mode?
<no-defun-allowed>
I could probably embed another with-html-output macro inside the body with different settings though.
gaqwas has quit [Changing host]
gaqwas has joined #lisp
drl has joined #lisp
pbgc has quit [Ping timeout: 252 seconds]
orivej has joined #lisp
mindthelion has quit [Ping timeout: 240 seconds]
z3t0_alt has quit [Remote host closed the connection]
z3t0 has joined #lisp
shka__ has quit [Ping timeout: 276 seconds]
shka__ has joined #lisp
gravicappa has joined #lisp
hhdave has quit [Ping timeout: 268 seconds]
hhdave has joined #lisp
mrcom has quit [*.net *.split]
hhdave has quit [Ping timeout: 268 seconds]
mrcom has joined #lisp
vaporatorius has quit [Read error: Connection reset by peer]
ggole has joined #lisp
flamebeard has quit []
hhdave has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 268 seconds]
hhdave_ is now known as hhdave
jonatack has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 268 seconds]
hhdave_ is now known as hhdave
kmeow has joined #lisp
<kmeow>
is there an easy way to append elements to a vector?
<Bike>
i wonder if there would be some value in exposing the copying that change-class is defined to use, though.
<Bike>
an easily defined shallow copy
<dlowe>
pretty easy to do that with mop
gareppa has quit [Ping timeout: 268 seconds]
<Bike>
well, by looping over the slots and stuff, yeah
<Bike>
implementations might have something faster under the hood, like copying a storage vector
Zanitation has joined #lisp
gareppa has joined #lisp
karlosz has quit [Quit: karlosz]
kapitanfind-us has joined #lisp
amerlyq has quit [Quit: amerlyq]
amerlyq has joined #lisp
Dibejzer has joined #lisp
orivej has joined #lisp
kapitanfind-us has quit [Ping timeout: 268 seconds]
Dibejzer has quit [Client Quit]
mindthelion has joined #lisp
mindthelion has quit [Read error: Connection reset by peer]
Dibejzer has joined #lisp
Dibejzer has quit [Remote host closed the connection]
techquila has joined #lisp
bitmapper has quit [Ping timeout: 245 seconds]
vap1 has joined #lisp
vaporatorius has quit [Ping timeout: 268 seconds]
shifty has quit [Ping timeout: 268 seconds]
vap1 has quit [Client Quit]
gareppa has quit [Quit: Leaving]
orivej has quit [Ping timeout: 265 seconds]
clothespin has joined #lisp
shka_ has joined #lisp
slyrus_ has joined #lisp
karlosz has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
slyrus has quit [Ping timeout: 250 seconds]
brettgilio has quit [Ping timeout: 245 seconds]
vlatkoB has quit [Remote host closed the connection]
cosimone has joined #lisp
clothespin has quit [Ping timeout: 245 seconds]
karlosz has quit [Quit: karlosz]
orivej has joined #lisp
clothespin has joined #lisp
wiselord has quit [Quit: Leaving]
sauvin has quit [Ping timeout: 265 seconds]
wiselord has joined #lisp
varjag has joined #lisp
cosimone has quit [Quit: Terminated!]
sjl_ has joined #lisp
Codaraxis has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
varjagg has joined #lisp
bitmapper has joined #lisp
varjag has quit [Ping timeout: 268 seconds]
bjorkintosh has quit [Remote host closed the connection]
bjorkintosh has joined #lisp
Codaraxis has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
gareppa has joined #lisp
varjagg is now known as varjag
ark has quit [Ping timeout: 245 seconds]
ark has joined #lisp
ggole has quit [Quit: Leaving]
krwq has joined #lisp
_whitelogger_ has joined #lisp
scal_ has joined #lisp
froggey_ has joined #lisp
sebboh1 has joined #lisp
froggey has quit [Disconnected by services]
brown121407 has quit [Ping timeout: 276 seconds]
froggey_ is now known as froggey
xantoz_ has joined #lisp
brown121407 has joined #lisp
bitmapper has quit [Ping timeout: 276 seconds]
cosimone has joined #lisp
cg505_ has joined #lisp
bjorkintosh has quit [*.net *.split]
orivej has quit [*.net *.split]
techquila has quit [*.net *.split]
Zanitation has quit [*.net *.split]
enrio has quit [*.net *.split]
Kevslinger has quit [*.net *.split]
kmeow has quit [*.net *.split]
drl has quit [*.net *.split]
mfiano2 has quit [*.net *.split]
patrixl has quit [*.net *.split]
creat has quit [*.net *.split]
_whitelogger has quit [*.net *.split]
Blkt has quit [*.net *.split]
``Erik has quit [*.net *.split]
jfb4 has quit [*.net *.split]
notzmv has quit [*.net *.split]
dtw has quit [*.net *.split]
Tordek has quit [*.net *.split]
doublex has quit [*.net *.split]
remexre has quit [*.net *.split]
xantoz has quit [*.net *.split]
edgar-rft has quit [*.net *.split]
entel has quit [*.net *.split]
madand has quit [*.net *.split]
Xizor has quit [*.net *.split]
boeg has quit [*.net *.split]
hydan has quit [*.net *.split]
cg505 has quit [*.net *.split]
markasoftware has quit [*.net *.split]
Kaisyu has quit [*.net *.split]
scal has quit [*.net *.split]
Colleen has quit [*.net *.split]
Grue` has quit [*.net *.split]
sebboh has quit [*.net *.split]
loke has quit [*.net *.split]
greaser|q has quit [*.net *.split]
teej has quit [*.net *.split]
beaky has quit [*.net *.split]
knobo has quit [*.net *.split]
add^_ has quit [*.net *.split]
antoszka has quit [*.net *.split]
hydan_ is now known as hydan
Kevslinger_ is now known as Kevslinger
Kaisyu_ is now known as Kaisyu
entel_ is now known as entel
boeg_ is now known as boeg
kapitanfind-us has joined #lisp
hiroaki has quit [Ping timeout: 265 seconds]
cg505_ is now known as cg505
drl has joined #lisp
teej has joined #lisp
antoszka has joined #lisp
karlosz has quit [Quit: karlosz]
kapitanfind-us is now known as arichiardi
Finnfinn has quit [Quit: The humanity!]
Colleen has joined #lisp
arichiardi has quit [Remote host closed the connection]
Finnfinn has joined #lisp
knobo has joined #lisp
bjorkint0sh has quit [Quit: Leaving]
bjorkintosh has joined #lisp
hiroaki has joined #lisp
nowhere_man has joined #lisp
kapitanfind-us has joined #lisp
kapitanfind-us has quit [Remote host closed the connection]
kapitanfind-us has joined #lisp
kapitanfind-us is now known as arichiardi
arichiardi is now known as arichiardi_
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
manualcrank has joined #lisp
arichiardi_ is now known as arichiardi
arichiardi has quit [Remote host closed the connection]
drl has quit [Quit: Ex-Chat]
kapitanfind-us has joined #lisp
Zanitati1 has quit [Ping timeout: 268 seconds]
scymtym has quit [Ping timeout: 245 seconds]
kapitanfind-us is now known as arichiardi
igemnace has quit [Ping timeout: 276 seconds]
arichiardi is now known as kapitanfind-us
kckasumi has joined #lisp
Zanitati1 has joined #lisp
kapitanfind-us has quit [Remote host closed the connection]
kckasumi has quit [Remote host closed the connection]
kckasumi has joined #lisp
Oladon has quit [Ping timeout: 268 seconds]
Zanitati1 has quit [Ping timeout: 250 seconds]
didi has joined #lisp
<didi>
Should systems automatically define -USER packages?
<phoe>
didi: depends on the system
<phoe>
I don't see any reason for SPLIT-SEQUENCE-USER
<didi>
phoe: I see what you're saying.
Finnfinn has quit [Quit: The humanity!]
brown121407 has quit [Read error: Connection reset by peer]
brown121408 has joined #lisp
<no-defun-allowed>
Only if you expect the user to a package like that quite frequently. The only system I've made that does is lisp-strikes-twice.
<no-defun-allowed>
And that is an exploitation framework like metasploit or whatever skiddies use these days, but in Lisp and using the full power of the user's Lisp's REPL.
Finnfinn has joined #lisp
<no-defun-allowed>
So I would expect a user to want a -user package for that, because most of the functions they use are in that system.
Finnfinn has quit [Client Quit]
sebboh1 has quit [Changing host]
sebboh1 has joined #lisp
kajo has joined #lisp
<copec>
I was under the impression that most clos implementations are storing each slot grouped together referenced by clos object instance, unlike a vector or like a c struct
<Shinmera>
every slot has a location which is a positive integer
<Shinmera>
making the actual storage for standard-instance-access a vector is sensible with that in mind.
<Shinmera>
this is for standard-classes. Others may have entirely different storage and access methods of course.
iovec has joined #lisp
<copec>
Makes me want to read the standard closely this evening for slot storage
<copec>
Is that what the standard says about slot location Shinmera
<Shinmera>
you'll have to consult the MOP for what I said
enrioog has quit [Ping timeout: 252 seconds]
* didi
should read The Art of the Metaobject Protocol
<Shinmera>
Specifically the Instance Structure Protocol section
gravicappa has quit [Ping timeout: 265 seconds]
<copec>
I read the art of the mop some time ago, but iirc the example implementation used a hashtable for each slot definition
gareppa has quit [Quit: Leaving]
<Bike>
in closette, the slots are a simple vector.
karlosz has joined #lisp
karlosz has quit [Quit: karlosz]
igemnace has joined #lisp
<copec>
Well, so goes my human memory
mindthelion has quit [Remote host closed the connection]
<Bike>
by "each slot grouped together referenced by clos object instance" you mean like, each slot name would have a hash table where the keys are instances and the values are the slot values? i think there might have been an implementation of "virtual slots" in there doing that
no-defun-allowed has quit [Ping timeout: 240 seconds]
Gnuxie[m] has quit [Ping timeout: 240 seconds]
mindthelion has joined #lisp
<copec>
I probably saw something at some point, or conflated the storage of slot (meta) properties with the storage of actual slot data
kckasumi has quit [Ping timeout: 250 seconds]
kajo has quit [Ping timeout: 252 seconds]
bbsl has joined #lisp
igemnace has quit [Ping timeout: 250 seconds]
khisanth__ has quit [Ping timeout: 245 seconds]
<bbsl>
q
mathrick has joined #lisp
<bbsl>
hi! I am trying to do part one of a8c but I am getting stuck on the last bit which is using my (hacky) function (eval-all). Anyone care to have a look and tell me what I am doing wrong?: https://rextester.com/live/UJVC52026 (this is my 2nd day of lisp so)
<dlowe>
bbsl: Hi, you might be interested in the #clschool channel
shka_ has quit [Ping timeout: 246 seconds]
<bbsl>
dlowe: ty I will ask again in there :)
shka_ has joined #lisp
<dlowe>
bbsl: it's fine to ask in here too
<dlowe>
I'm looking at it
<bbsl>
oh nice ty :)
<dlowe>
I assume your int-split function works?
<Bike>
"part one of a8c"?
<Bike>
is this sicp or something?
<bbsl>
aoc*
zooey has quit [Ping timeout: 260 seconds]
<jackdaniel>
sounds like advent of code mispell
<bbsl>
jackdaniel: yes :)
<LdBeth>
I assume set-nth works as intended
mathrick has quit [Ping timeout: 240 seconds]
<aeth>
advent is 6 letters long so you could all it a6c :-p
<bbsl>
dlowe: everything works except for the last function eval-all
<Bike>
um, well, you're passing eval-all -4, so offsetn will be zero, right?
<Bike>
and zero is definitely going to be <= the length of anything
<dlowe>
bbsl: you can literally (setf (nth 3 lst) 5) btw
<Bike>
so the recursive part will never happen
<Bike>
i don't know what you want this function to do, but that seems weird?
zooey has joined #lisp
<dlowe>
I think he's trying to do the recursive iteration popular in scheme
<Bike>
i mean that's fine, but it won't happen
<dlowe>
but the program doesn't stop when it reaches the end - it stops when it encounters opcode 99
<dlowe>
so there's really no reason for that check anyway
<Bike>
oh, it's a bytecode interpreter, i see.
<bbsl>
hmmm I guess let me try to remove that part, I thought I was checking for the inverse I guess that (a < b)
<jackdaniel>
and we ain't gonna stop even at the end, opcode 99 is our stay, la la la
<Bike>
i mean you could just swap <= to >= i guess.
<Bike>
or indeed just remove it
<dlowe>
or swap the consequent and the alternate
<dlowe>
you still need to stop at opcode 99 though
Bourne has joined #lisp
<bbsl>
I guess I do not understand return values very well (or at all) in cl. "setf" will morph the input given in the context of the funtion or? I just want to return a new list with the new values
<Bike>
the setf-nth function is different from (setf nth) in that it returns a fresh list
<Bike>
that's fine. it's not how i'd write it but there's nothing wrong with doing it that way, it's just maybe inefficient
kajo has joined #lisp
<Bike>
just doin some of that functional programming
no-defun-allowed has joined #lisp
<no-defun-allowed>
Maybe a vector would be more suitable.
<Bike>
plus that way you don't have to understand setf yet, because I don't think you do based on that description
<LdBeth>
bbsl: so halt when reach 99 is your intended behavior?
<bbsl>
LdBeth: yes I want to halt at 99
kckasumi has joined #lisp
<LdBeth>
bbsl: But I don’t see your code do anything “halt” the program when the op is 99, so I guess that’s the problem
<Bike>
the other problem.
<bbsl>
:D
bars0 has joined #lisp
<Bike>
i'm pretty sure the initial problem is that with the offsetn = 0 thing, eval-current isn't called at all.
<bbsl>
Bike: I think you are correct in that
<Bike>
other than that this is like what, a three address code i guess
<Bike>
with this structure, to handle 99 correctly i suppose you could have eval-current return some kind of special object (e.g. nil) to indicate that there is nothing left to do, and then eval-all has to check that
<bbsl>
LdBeth: how should I go about making it halt then I guess I can check if last-return from eval-current == this-return or I can return nil when I get 99 and always keep last-return so I can return that when I get nil
<bbsl>
nice it works now. ty for all the pointers.
<bbsl>
While we are at it does anyone know of a link to a decent cl dev-env setup for emacs? I am using slime currently but that is about it. Would be nice if it was possible to get flychecking and company mode working ie.
<phoe>
or set yourself up with spacemacs with the common-lisp layer - that's what I do
<bbsl>
I was using spacemacs but they borked scala support with the whole metals/ensime thing so I stopped using it :o. ty for the link will check it out.
igemnace has joined #lisp
Josh_2 has quit [Ping timeout: 265 seconds]
mathrick_ has joined #lisp
mathrick has quit [Ping timeout: 276 seconds]
gioyik has quit [Ping timeout: 245 seconds]
scymtym has joined #lisp
Bike has quit [Quit: Bike]
igemnace has quit [Ping timeout: 240 seconds]
monokrom has joined #lisp
bitmapper has joined #lisp
monokrom has quit [Client Quit]
karlosz has joined #lisp
quazimodo has quit [Ping timeout: 246 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
clothespin has joined #lisp
shifty has joined #lisp
random-nick has quit [Ping timeout: 276 seconds]
gabiruh has quit [Quit: ZNC - 1.6.0 - http://znc.in]
gabiruh has joined #lisp
clothespin_ has joined #lisp
My_Hearing has joined #lisp
My_Hearing has quit [Client Quit]
clothespin has quit [Ping timeout: 240 seconds]
davsebam1e has joined #lisp
notzmv has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
clothespin__ has joined #lisp
arichiardi` has quit [Ping timeout: 276 seconds]
davsebamse has quit [Ping timeout: 276 seconds]
libertyprime has quit [Quit: leaving]
clothespin_ has quit [Ping timeout: 265 seconds]
dddddd has quit [Remote host closed the connection]
LiamH has quit [Quit: Leaving.]
igemnace has joined #lisp
akoana has joined #lisp
igemnace has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
cosimone has quit [Quit: Quit.]
varjag has quit [Remote host closed the connection]
Dibejzer has joined #lisp
Dibejzer has quit [Remote host closed the connection]