Xach changed the topic of #commonlisp to: Common Lisp, the #1=(programmable . #1#) programming language | Wiki: <https://www.cliki.net> | IRC Logs: <https://irclog.tymoon.eu/libera/%23commonlisp> | Cookbook: <https://lispcookbook.github.io/cl-cookbook>
Devon has quit [Ping timeout: 256 seconds]
nature has quit [Ping timeout: 256 seconds]
gaqwas has quit [Ping timeout: 260 seconds]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
rgherdt has quit [Ping timeout: 252 seconds]
s-liao has joined #commonlisp
s-liao has quit [Client Quit]
s-liao has joined #commonlisp
djuber has quit [Ping timeout: 256 seconds]
Devon has joined #commonlisp
rotateq has quit [Quit: ERC (IRC client for Emacs 27.2)]
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
jstoddard has quit [Remote host closed the connection]
Oladon has quit [Quit: Leaving.]
karlosz has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
igemnace has quit [Ping timeout: 252 seconds]
Catie has quit [Quit: Going home]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
Bike has quit [Quit: Lost terminal]
hineios has quit [Ping timeout: 240 seconds]
taiju has quit [Ping timeout: 252 seconds]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
jpl01 has quit [Remote host closed the connection]
taiju has joined #commonlisp
Catie has joined #commonlisp
Guest74 has joined #commonlisp
poselyqualityles has joined #commonlisp
igemnace has joined #commonlisp
Catie has quit [Quit: something's]
zardoz has quit [Quit: CGI:IRC (Session timeout)]
<Guest74> anybody know what causes asdf to complain it can't find the file it was compiling in /tmp ?
<Guest74> oh, that it can't find its TRUENAME
<beach> Good morning everyone!
poselyqualityles has quit [Ping timeout: 260 seconds]
makomo has quit [Ping timeout: 256 seconds]
tyson2 has quit [Remote host closed the connection]
semz has quit [Ping timeout: 250 seconds]
makomo has joined #commonlisp
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
semz has joined #commonlisp
karlosz has quit [Quit: karlosz]
Oladon has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
taiju has quit [Ping timeout: 260 seconds]
kakuhen has quit [Quit: Leaving...]
s-liao has joined #commonlisp
thomaslewis has joined #commonlisp
<susam> Good morning, beach!
<susam> Good morning, everyone! Hope you are all having a great weekend.
thomaslewis has left #commonlisp [#commonlisp]
shka has joined #commonlisp
<beach> Hello susam. Great indeed. When I woke up, I discovered that hayley had already made good progress on global value numbering for SICL. I like it when things happen while I'm asleep. :)
<jackdaniel> pancakes pancakes
<jackdaniel> two more to fry
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
dre has quit [Quit: Leaving]
notzmv has quit [Ping timeout: 260 seconds]
<phantomics> Anyone here use usocket much? I'm having trouble reading the responses I'm supposed to get after writing TCP packets to a socket stream, there doesn't seem to be any way to receive the expected ACK packet
s-liao has quit [Ping timeout: 256 seconds]
Alfr has quit [Read error: Connection reset by peer]
Alfr has joined #commonlisp
<Guest74> did you flush/finish the output?
<Guest74> Or are you talking about the actual packet and not the payload of the tcp packet?
<phantomics> The docs for the device I'm talking to say to expect the response data as part of an ACK packet
<phantomics> I may have found what I need to do: (write-binary datum (socket-stream *service*)) (read-binary 'binary-format (socket-stream *service*))
<phantomics> I'm using lisp-binary to send/receive data in a binary format
<Guest74> what I meant to say by flush/finish was FORCE-OUTPUT.
<phantomics> I do (force-output (socket-stream *service*)) at the end of the function, it just returns NIL.
<phantomics> Should I do that before reading from the stream?
<Guest74> just needs to be done once. You might want to use wireshark or something similar to see what's going on.
thomaslewis has joined #commonlisp
<Guest74> things will refuse to communicate if you don't introduce yourself the right way or end your communications the right way.
<phantomics> Ok, it seems that I'm getting the data the same whether I (force-output) before or after doing the (read binary). This stage of the problem seems to be solved, thanks
<Guest74> np
thomaslewis has left #commonlisp [#commonlisp]
Oladon has quit [Quit: Leaving.]
elderK has quit [Quit: Connection closed for inactivity]
taiju has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
ldb has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
attila_lendvai has joined #commonlisp
frgo has quit [Ping timeout: 268 seconds]
shka has quit [Quit: Konversation terminated!]
gaqwas has joined #commonlisp
Algernon69 has joined #commonlisp
aartaka has joined #commonlisp
treflip has joined #commonlisp
<susam> beach: That is great news. It is nice to see a successful collaboration occurring on a programming language IRC channel. :)
<hayley> Don't worry, it only bursts into flames when trying to compile (LOOP REPEAT 1 COLLECT 1).
ldb has quit [Quit: ERC (IRC client for Emacs 27.2)]
Devon has quit [Ping timeout: 260 seconds]
notzmv has joined #commonlisp
rgherdt has joined #commonlisp
s-liao has joined #commonlisp
peterhil has quit [Remote host closed the connection]
peterhil has joined #commonlisp
Colt has quit [Remote host closed the connection]
pdietz has quit [Quit: Client closed]
peterhil has quit [Remote host closed the connection]
peterhil_ has joined #commonlisp
peterhil__ has joined #commonlisp
peterhil_ has quit [Ping timeout: 260 seconds]
peterhil_ has joined #commonlisp
peterhil__ has quit [Remote host closed the connection]
peterhil_ has quit [Remote host closed the connection]
peterhil_ has joined #commonlisp
nature has joined #commonlisp
peterhil_ has quit [Remote host closed the connection]
peterhil_ has joined #commonlisp
cage has joined #commonlisp
rain3 has joined #commonlisp
VincentVega has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 250 seconds]
Lord_of_Life_ is now known as Lord_of_Life
waleee has quit [Ping timeout: 268 seconds]
s-liao has quit [Ping timeout: 256 seconds]
Algernon69 has quit [Ping timeout: 268 seconds]
s-liao has joined #commonlisp
karlosz has joined #commonlisp
random-nick_ has joined #commonlisp
karlosz has quit [Ping timeout: 268 seconds]
s-liao has quit [Ping timeout: 256 seconds]
cosimone has joined #commonlisp
s-liao has joined #commonlisp
karlosz has joined #commonlisp
varjag has joined #commonlisp
pve has joined #commonlisp
robin has quit [Ping timeout: 252 seconds]
karlosz has quit [Ping timeout: 256 seconds]
varjag has quit [Ping timeout: 256 seconds]
Algernon69 has joined #commonlisp
s-liao has quit [Quit: Client closed]
rotateq has joined #commonlisp
Algernon69 has quit [Ping timeout: 268 seconds]
tyson2 has joined #commonlisp
varjag has joined #commonlisp
<rotateq> What does the term "finalization" mean for a class in CLOS?
igemnace has quit [Remote host closed the connection]
<rotateq> thank you pjb
<rotateq> some days ago i was curious why AMOP does not list update-instance-for-redefined-class in the cross reference at the near end (at least in my version of the book i have)
<beach> rotateq: It is a bit strange. Sometimes, the AMOP lists standard functions and sometimes it does not.
<beach> By "standard functions" I mean functions defined by the Common Lisp standard, as opposed to defined by the MOP.
<rotateq> yes I see
<beach> When the MOP mentions such a function, I tried to remember to put in a note and a reference to the Common Lisp HyperSpec.
<beach> mop make-instance
<beach> ... as you can see in the Comments and Remarks section.
<rotateq> I do. :)
<beach> Oh, and sometimes the two definitions are not identical, and then I try to mention such differences.
attila_lendvai has quit [Ping timeout: 250 seconds]
s-liao has joined #commonlisp
nature has quit [Remote host closed the connection]
s-liao has quit [Quit: Client closed]
nature has joined #commonlisp
Colt has joined #commonlisp
s-liao has joined #commonlisp
Colt has quit [Remote host closed the connection]
Colt has joined #commonlisp
s-liao has quit [Quit: Client closed]
Colt has quit [Remote host closed the connection]
Colt has joined #commonlisp
Colt has quit [Remote host closed the connection]
Colt has joined #commonlisp
Colt has quit [Remote host closed the connection]
Colt has joined #commonlisp
Colt has quit [Remote host closed the connection]
voltron has joined #commonlisp
voltron has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
voltron has joined #commonlisp
<lisp123> I have a long algorithm with multiple steps (around 6). Each step does not make sense outside of the algorithm, so typically I would look to define them as local functions
<lisp123> However, that would make the overall function too long, so I am currently planning on using global functions. To avoid passing too many variables between functions, I plan on using dynamic scope. Furthermore, to denote these functions to be considered "local" vs. useful in their own right, I'm planning on writing them as _function-name.
<lisp123> (1) Thoughts on this approach + (2) is there a better naming convention to follow?
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
<beach> Just use the package as the namespace, and don't export those "local" functions. Then you can name them whatever you like.
<lisp123> That works
Lycurgus has joined #commonlisp
waleee has joined #commonlisp
<rotateq> lisp123: I like using TAGBODY to prototype algorithms from The Art of COmputer Programming.
<lisp123> rotateq: How does that work?
<Nilby> lisp123: You might consider using a state object if there's enough shared between functions.
<beach> Packages still seem under-utilized, and Common Lisp books and other material, especially older stuff, suggest that it was even worse then.
<rotateq> lisp123: you mean tagbody?
treflip has quit [Read error: Connection reset by peer]
<lisp123> Nilby: I'm actually doing that, it feels "icky" since its not purely a functional approach, but the problem with functional programming is you don't save down the intermediate steps either
_73` has joined #commonlisp
<beach> lisp123: I think rotateq means that the algorithms in those books have a lot of GOTO and such in them, so TAGBODY is a good match.
tyson2 has quit [Remote host closed the connection]
<Nilby> With a state object it's easy to switch between implict dynamic and an explicit argument.
treflip has joined #commonlisp
<rotateq> yes, in a sense Don has a very clear style, as long as the current context and notation is clear
OlCe has quit [Ping timeout: 268 seconds]
<lisp123> rotateq & beach: Ah I see. I will try that and see how it feels
<rotateq> and it's not even near to trivial bringing those into the correct LOOP form for example
_73 has quit [Ping timeout: 260 seconds]
<rotateq> lisp123: look into Practical Common Lisp. was the point on some chapter where I learned that this way it's translatable 1:1
<beach> rotateq: But what makes you think it is this kind of algorithm that lisp123 is working on?
<Nilby> mmix as tagbody?
<rotateq> page 250 and following in PCL
<rotateq> beach: I just wanted to give the possibility. :) and has he wrote "multiple steps"
<ns12> Hello, when gensym generates a unique symbol, how does it know that the generated symbol will always be unique?
<rotateq> hi ns12
<lisp123> rotateq: Do you know which chapter (I have the online copy, have ordered the hardcopy during the recent Apress sale but waiting for it)
_73` has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Quit: Exeunt]
<rotateq> it works with *gensym-counter* and uses #: to make an uninterned symbol
<pjb> ns12: it knows, because it creates a new symbol and doesn't intern it in any package.
<rotateq> lisp123: chapter 20
<pjb> ns12: the name of the symbol can be not unique, but the symbol is a new one.
<Alfr> lisp123, how about simply ensuring that you don't modify the state object? Instead, always create a new one, so that you can rely on (foo state bar baz) always giving you an equivalent result for the same state, bar and baz? ;p
<lisp123> rotateq: Thanks!
<pjb> ns12: and since it's not interned, there's no way to read it again. You can only have it if you have it. (a reference to it).
<pjb> ns12: compare with gentemp.
<rotateq> lisp123: Which algorithm are you on right now?
<Nilby> ns12: Note that it's only unique for a certain lisp image.
<ns12> rotateq: pjb: But what if I reset *gensym-counter* to its initial value after every call to gensym?
<rotateq> you could but you shouldn't :)
<pjb> (let ((*print-circle* t)) (prin1-to-string (loop repeat 3 collect (let ((*gensym-counter* 42)) (gensym))))) #| --> "(#:g42 #:g42 #:g42)" |#
<pjb> ns12: as I said, you can easily have gensym generate symbols with the same name, but it doesn't matter.
<pjb> (let ((*print-circle* t)) (prin1-to-string (loop repeat 3 collect (make-symbol "FOO")))) #| --> "(#:foo #:foo #:foo)" |#
<pjb> Note if they were the same symbol, with *print-circle*: (let ((*print-circle* t)) (prin1-to-string (loop with g = (gensym) repeat 3 collect g))) #| --> "(#1=#:g200731 #1# #1#)" |#
<lisp123> Alfr: It's more that none of the intermediate steps make any sense on their own, but they are useful to keep a copy of in, for example, to auto-generate a printed summary of the process. The "process-record" is generated fresh on each run of the overall algorithm, and each step will generate a component of the record
<beach> ns12: Two symbols are not the same just because they have the same name. Symbol identity is a separate concept.
<pjb> ns12: the advantage of gensym over make-symbol, is just that it makes it easier to read sexps using them. With make-symbol, you would easily be confused.
<lisp123> rotateq: Just a theorem verifier. Take a statement to prove and a theorem to check against, and see if the theorem can prove the statement. So I have about 5 arrays (theorem outputs, required inputs of theorem, theorem inputs in terms of the statement to prove, available results in the problem set that can satisfy the required inputs, etc.)
<rotateq> lisp123: do you already know ACL2?
<ns12> pjb: I don't quite understand your explanation of the advantage of gensym over make-symbol? How does gensym make s-expressions easier to read?
<lisp123> I heard of it, but don't want to read its code as then I will just end up copying it vs. thinking on my own
<Alfr> lisp123, okay. But I only intended to offer a way out, as you meant a state object isn't sufficiently functional as to your liking. (Though this certainly depends on what you consider functional.)
<beach> ns12: Every time you call MAKE-SYMBOL with a particular name, a (new) symbol with that name is created, so if you do that several times, it is not easy to distinguish them to the person seeing their names. With GENSYM, each new symbol usually has a separate name, you when you print out a bunch of them, you can tell the difference.
<ns12> beach: Understood. Thanks.
<lisp123> Alfr: No worries, your suggestion does make sense though
<lisp123> beach: I need to get into the habit of using packages more for their external/internal symbols separation...not sure why I (and I guess others) have developed an aversion to it
<lisp123> It would make more structured to test later
<beach> lisp123: Yeah, it puzzles me. Especially now that we have package-local nicknames.
<ns12> pjb: Thank you for the explanations.
<lisp123> I tend to think of each package as being self contained, that might be the hang up
<ns12> beach: "With GENSYM, each new symbol usually has a separate name ..." - Why do you say "usually" instead of "always"?
<beach> ns12: Didn't we just discuss resetting the *GENSYM-COUNTER*?
<beach> If you do, then the same names will appear again.
<beach> The symbols will still be unique, of course, but the names will be the same.
<beach> ns12: Try (list (let ((*gensym-counter* 1)) (gensym)) (let ((*gensym-counter* 1)) (gensym)))
<beach> ns12: Now you have a list of two unique symbols with the same name.
voltron has quit [Remote host closed the connection]
Inline has quit [Quit: Leaving]
<ns12> Okay. Thank you.
<beach> Sure. Does that make sense to you?
<ns12> beach: Yes. Your explanation is clear.
<beach> Great!
<Nilby> I'm glad that CL can do things that would normally be disaster, like reset *gensym-counter* and (delete-package :cl) because they're potentially useful for bootstrapping, image operations, and making new languages.
<Guest74> Xach any plans on adding metamodular to l1sp?
<ns12> Nilby: What's the use of resetting *gensym-counter*?
Algernon69 has joined #commonlisp
Algernon91 has joined #commonlisp
<Nilby> ns12: If you wanted to reset your image, say to make compiler output identical. Of course you'd have to take other precautions and preparations.
<rotateq> ns12: a bit like the sense for setting and resetting counters in for a LaTeX document :)
OlCe has joined #commonlisp
Algernon69 has quit [Ping timeout: 260 seconds]
<ns12> Nilby: rotateq: I guess I'm still far from having a legitimate use for these things in Common Lisp. But I'm happy to know that the language provides such flexibility. I need to study more ...
tyson2 has joined #commonlisp
<rotateq> so you can just profit from the things that your implementation does automatically for you
voltron has joined #commonlisp
igemnace has joined #commonlisp
<Nilby> It's not very interesting, but (mapcar (lambda (x) (eval-in x '*gensym-counter*)) '(sbcl ccl clisp ecl cmucl abcl)) => (435 1 2949 1 2496 44)
<lisp123> Nilby: What's that?
<Nilby> Initial values of *gensym-counter* in various lisps.
<lisp123> CCL and ECL have the best defaults
<lisp123> strange how sbcl differs from cmucl
voltron has quit [Ping timeout: 268 seconds]
<Guest74> are they really initial counts? Maybe they use lots of gensyms?
voltron has joined #commonlisp
<Nilby> Guest74: Those are the results for me from running with no user init files. I guess the non-1 ones might vary with version.
<Guest74> i see that. but maybe they use gensym in their implementation is what I'm saying. I guess grep might reveal that.
<rotateq> lisp123: try setting *gensym-counter* to -1 :P
tyson2 has quit [Remote host closed the connection]
Lycurgus has joined #commonlisp
<_death> I found this a useful hack a year or two ago (defun make-var-name (&optional (x "G")) (gensym (string-right-trim "0123456789" x)))
<_death> so I could have it generate symbols like "FOO123", and generate symbols from that name that'd be "FOO124" and not "FOO123124"
<White_Flame> neat
tyson2 has joined #commonlisp
cosimone has quit [Remote host closed the connection]
<_death> ooh, I've not noticed the existence of issue GENSYM-NAME-STICKINESS:LIKE-TEFLON until now
cosimone has joined #commonlisp
voltron has quit [Remote host closed the connection]
Inline has joined #commonlisp
<rotateq> haha like teflon. like when i saw this week in uiop the exported symbol NUKE-SYMBOL
Lycurgus has quit [Quit: Exeunt]
cosimone has quit [Ping timeout: 260 seconds]
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
Jing has quit [Read error: Connection reset by peer]
tyson2 has quit [Remote host closed the connection]
lisp123 has quit [Ping timeout: 240 seconds]
Jing has joined #commonlisp
cosimone has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
voltron has joined #commonlisp
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
thomaslewis has joined #commonlisp
thomaslewis has left #commonlisp [#commonlisp]
<Guest74> any thoughts on what reads better? font:monospacedp font:fixed-width-p font:fixed-pitch-p font:monospaced? font:fixed-width? font:fixed-pitch?
<rotateq> in CL wie suffix predicates with "p" or "-p" as you correctly gave by convention :P for example the str lib provides both for some predicates
tyson2 has joined #commonlisp
anticomputer has joined #commonlisp
<White_Flame> I use and prefer the scheme-style #\? suffix. not much into legacy style just for its own sake
<rotateq> but okay, there's slot-boundp in the standard
anticomputer_ has quit [Ping timeout: 276 seconds]
<Guest74> though i'm leaning towards ? as it returns the actual width if it is fixed. p might be misleading even though some things like digit-char-p use it anyways.
<Guest74> though i guess after saying that it eliminates monospace.
<White_Flame> I only use ? for "pure" booleans
<semz> I think just fixed-width would work if it's an optional width value
<semz> Returns nil if there is no fixed width, because the width is not fixed
<Guest74> yeah, that's starting to sound better. at least width is more understandable than pitch. It is a generalized boolean though so not sure just fixed-width indicates that directly.
<Guest74> cause I do see myself using this in rendering pipeline though I guess i'd probably stuff it in a variable anyways and can name that something readable for the IF.
<Guest74> needing to write a generic font/glyph interface before more work on text rendering. I got so much font specific stuff it's ridiculous.
<White_Flame> it never ends
<White_Flame> there will always be some other assumption somewhere from some other language/font
<Guest74> I'm sure whenever whomever is working on otf is finished there will be more stuff. so far covered for all the old tech.
<Guest74> I do have no clue where to stick unit conversions though.
karlosz has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.3]
perrierjouet has joined #commonlisp
varjag has quit [Ping timeout: 268 seconds]
_73 has joined #commonlisp
lisp123 has joined #commonlisp
karlosz has quit [Quit: karlosz]
thomaslewis has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
varjag has joined #commonlisp
varjag has quit [Remote host closed the connection]
varjag has joined #commonlisp
Algernon91 has quit [Ping timeout: 250 seconds]
Guest74 has quit [Quit: Connection closed]
treflip has quit [Quit: good night ✨]
<mfiano> Hello all
<mfiano> As part of a new project, I had to wrap quite a few libc functionality for FreeBSD's libc implementation. It's growing enough that it deserves to be lifted out into its own library. Any idea what one would even call a set of low and highlevel wrappers for a small subset of a specific libc implementation?
<mfiano> Ya know, naming things is hard and all
<phoe> cl-freebsd-libc-ffi
<mfiano> I was considering something similar, but I have no intention of covering all of libc. This is very very tiny as of yet
<phoe> don't cover all of it yet then, just the subset that you need
<phoe> leave the rest to the future you, even if it turns out to be someone else
<mfiano> I guess that doesn't need to be reflected in the name
<mfiano> I'm also upset at things like opne()
<phoe> opne()?
<mfiano> signature is basically (path, flags, ...), where flags is either logiored by the user, or given as &rest. I don't like the former. and the ... at the end is a umask mode for when a file is created etc
<mfiano> obviously mode won't work well if flags is &rest
<mfiano> things like this annoy me
<phoe> (open ... :flags '(:foo :bar :baz) :umask ...)
<mfiano> and then there's things like ioctl which _really_ annoy me
<phoe> with a compiler macro that checks for constant flags
<phoe> and calls an #'%open with a precomputed integer bitmask
<mfiano> the defcfun of ioctl() requires an &rest at the end, which makes it expand into a lisp _macro_, not a lisp function
<mfiano> Hmm, maybe. I'm just annoyed I can't treat some c functions as lisp functions because of the way defcfun works
hobo has quit [Quit: ZNC 1.8.2 - https://znc.in]
cosimone has quit [Remote host closed the connection]
cosimone has joined #commonlisp
attila_lendvai has joined #commonlisp
lisp123 has joined #commonlisp
<pjb> rotateq: what is a "slot-bound" ?
<rotateq> no I mean SLOT-BOUNDP
waleee has quit [Ping timeout: 250 seconds]
abrantesasf has joined #commonlisp
<pjb> rotateq: the difference between slot-bound-p and slot-boundp is that in slot-bound-p we test if the object is a slot-bound, and in slot-boundp we test if the slot is bound.
<pjb> It's like string-lessp vs. string-less-p If you had objects that are string-less, then you could test them with string-less-p. But if you want to compare two strings with lessp, then use string-lessp
<pjb> This is why defstruct lets you specify the :predicate name.
<pjb> The default is not always correct.
<VincentVega> I refer to this quite often https://www.cliki.net/Naming+conventions (the predicate explanation is also there)
<_death> pjb: when would it not be correct, according to this criterion?
<rotateq> that's a good point, thx
<mfiano> How do I represent a "const" type annotation in a C parameter list using CFFI?
<_death> pjb: it's true that it's "not always correct" if the convention has another rule.. if the type is a single word (no hyphens) then P (no hyphens) is used.. like stringp or consp
lisp123 has quit [Remote host closed the connection]
srhm has quit [Ping timeout: 265 seconds]
srhm has joined #commonlisp
Jing has quit [Remote host closed the connection]
akoana has joined #commonlisp
Jing has joined #commonlisp
hobo has joined #commonlisp
<_73> How can I mutate a list special variable by looping through it and mutating each element? This example code suggests that you cannot do this with `dolist`: http://dpaste.com/ACHTCQVNQ
lisp123 has joined #commonlisp
<rotateq> _73: NUM is not a symbol-macro so it doesn't wonder me
<rotateq> and yes, (SETF FIRST) works of course ^^ via looping you could use SETFing via NTH or ELT
* _73 is searching docs for symbol-macros
rain3 has quit [Ping timeout: 250 seconds]
lisp123 has quit [Ping timeout: 268 seconds]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
<rotateq> it's for condensing a form and bind that to a symbol
<rotateq> or a bit like a macro that doesn't need parameters and can be called without parentheses
Alfr has quit [Quit: Leaving]
<_73> is the problem that the element in *NUMS* is being copied to a fresh symbol, NUM, on each iteration?
<rotateq> (macrolet ((foo () ...))) still needs it to be called with (foo), but when having (symbol-macrolet ((foo form)) ...) it's just foo
<pjb> _death: well, the default for defstruct is always -p giving point-p instead of pointp for (defstruct point x) You need to write: (defstruct (point (:predicate pointp)) x)
<VincentVega> _73: you are simply setting a symbol NUM to a new value, you need to setf a place in the list, like (loop for num-rest on *nums* do (incf (first num-rest) 100))
<semz> map-into is another option
<semz> underrated function
<pjb> _73: You're not wanting to mutate the variable. The variable is irrelevant to your question, since you want to mutate the elements of the list (ie. the car cells).
<_73> ok I understand now thanks
<VincentVega> semz: hmm cool
<pjb> _73: the only pre-condition to be able to mutate the car slot of the cons cells, is that the cons cell be not a literal (immutable) cell.
<pjb> _73: (defparameter *foo* (list 1 2 3)) (mapl (lambda (cell) (incf (car cell) 100)) *foo*) *foo* #| --> (101 102 103) |#
<pjb> If you wrote (defparameter *foo* '(1 2 3)) or (let ((n 2)) (defparameter *foo* `(1 ,n 3))) this would break.
Alfr has joined #commonlisp
<rotateq> gilberth told me about a special rule for symbol-macros some months ago, that you even can use SETQ on them, which is consistent imo, so that you don't have to remember what's a place and what's not
srhm has quit [Ping timeout: 250 seconds]
tyson2 has quit [Remote host closed the connection]
Guest74 has joined #commonlisp
<_73> (map-into *nums* (alexandria:curry #'+ 100) *nums*)
<_73> I like this solution
CrashTestDummy has quit [Quit: Leaving]
perrierjouet has quit [Quit: WeeChat 3.3]
perrierjouet has joined #commonlisp
<Guest74> mfiano: is this a freebsd only project? What's the interest in freebsd?
perrierjouet has quit [Client Quit]
CrashTestDummy has joined #commonlisp
dra has joined #commonlisp
perrierjouet has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.3]
azimut has quit [Ping timeout: 276 seconds]
akoana has quit [Quit: leaving]
anticomputer has quit [Ping timeout: 276 seconds]
gxt has quit [Ping timeout: 276 seconds]
varjag has quit [Ping timeout: 268 seconds]
dra has quit [Remote host closed the connection]
anticomputer has joined #commonlisp
azimut has joined #commonlisp
tyson2 has joined #commonlisp
gxt has joined #commonlisp
perrierjouet has joined #commonlisp
hobo has quit [Quit: ZNC 1.8.2 - https://znc.in]
Jing has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 260 seconds]
Jing has joined #commonlisp
Algernon91 has joined #commonlisp
Algernon666 has joined #commonlisp
dra has joined #commonlisp
Algernon91 has quit [Ping timeout: 260 seconds]
pve has quit [Quit: leaving]
attila_lendvai has quit [Ping timeout: 252 seconds]
lisp123 has joined #commonlisp
voltron has quit [Remote host closed the connection]
dra has quit [Quit: Leaving]
lisp123 has quit [Ping timeout: 268 seconds]
tyson2 has quit [Remote host closed the connection]
abrantesasf has quit [Read error: Connection reset by peer]
abrantesasf has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.3]
<phoe> Online Lisp Meeting #12 announced, https://www.reddit.com/r/lisp/comments/reahby/
<phoe> a mail announcement will be sent out tomorrow, minor issues with mailing list server today
<rotateq> i have no twitch account, but will try to be there passively
<phoe> no twitch account required
<phoe> maybe we should be able to set up an IRC bridge again, so commenting can happen on IRC
<phoe> Duuqnd: do you feel like lending a hand yet another time?
opalvaults2 has joined #commonlisp
cosimone has quit [Ping timeout: 268 seconds]
<opalvaults2> Can common lisp do full stack web development? I'd like to create a web application completely in lisp (frontend,db,backend). Someone in #scheme mentioned parascript. Anyone have any experience with this sort of thing?
<phoe> s/parascript/parenscript/
<pjb> opalvaults2: it can.
<ecraven> opalvaults2: there's also weblocks (https://common-lisp.net/project/cl-weblocks/), not sure how dead that is :-/
<Guest74> ecraven: is the revival dead?
<ecraven> I have no idea.. I wanted to use it 10 years ago or so, but never managed to fully understand it
<ecraven> it just seemed like it had some really nice ideas
<opalvaults2> phoe: thank you for the correction
<ecraven> seems to be dormant too :-/ https://40ants.com/weblocks/changelog.html
<opalvaults2> I figure Common Lisp is likely the best candidate for this time of development?
<opalvaults2> Are there other lisps/scheme that would work better for this purpose?
<Guest74> i think the revival might have scrapped a bunch of the interesting stuff.
<opalvaults2> s/time/type
<ecraven> opalvaults2: noone but you can answer that question. give the candidates that were mentioned a try, with some toy project, to find out which fits you best
<opalvaults2> ecraven: good point. will do :)
random-nick_ is now known as random-nick
<random-nick> there's also jscl https://github.com/jscl-project/jscl/
<random-nick> parenscript is more like an alternative syntax for writing javascript, while jscl is a (partial) implementation of common lisp as a javascript library
<opalvaults2> oh wow random-nick this looks promising as well, thank you
<random-nick> common lisp also has more traditional web libraries and frameworks, see fukamachi's work
<opalvaults2> Thank you Guest74 as well
<Duuqnd> phoe: Sorry I didn't see your message before
<Duuqnd> I'm not sure that the bot will work with libera.chat right away since last time I tried I had some trouble
<phoe> Duuqnd: no problem
<Duuqnd> I could give you the source code though if you want it
<phoe> sure! I'll take a look and try to run it
<phoe> but, tomorrow
<phoe> good night for now
<opalvaults2> I found this article for those interested in web devel in Common Lisp. https://dev.to/rajasegar/lisp-for-the-web-5-13ca
<opalvaults2> Seems like Fukamachi's caveman2 is a good option. Gonna hack for a bit. Thanks for the suggestions all!
tyson2 has joined #commonlisp
nature has quit [Ping timeout: 268 seconds]
<phantomics> opalvaults2: I use a library called Panic to generate React components using Parenscript for full-stack development
<phantomics> Here's the repo: https://github.com/michaeljforster-zz/panic
<phantomics> It hasn't been updated in a long time but I've made some of my own changes to it, may publish at some point
LoopMacro has joined #commonlisp
<rotateq> ohai phantomics good to read you (don't want to interrupt)
azimut_ has joined #commonlisp
<phantomics> hey rotateq, how've you been? I'm getting back into writing an integration for laser control
azimut has quit [Ping timeout: 276 seconds]
<opalvaults2> thank you phantomics! i will take a look :)
<rotateq> I'm good, hope you too.
<rotateq> oha laser control o_O
<phantomics> yes, for ILDA lasers that use rotating mirrors to aim the beam, it would be a natural application for APL since it's all about a series of points, similar to vector graphics
<rotateq> yes i thought so it has to do with it, like your big display
<mfiano> Guest74: Because I have an interest in it.
gaqwas has quit [Ping timeout: 256 seconds]
Jing has quit [Remote host closed the connection]
Jing has joined #commonlisp
<phantomics> opalvaults2: what kind of web project are you thinking about?
Algernon666 has quit [Ping timeout: 260 seconds]