<Spawns_Carpet[m]>
i couldn't find that from a quick search, the only thing I could find was turning a string into a list, but not the other way around
<antoszka>
It works both ways.
<antoszka>
COERCE works similar for this particular case, but args are reversed
<antoszka>
* (coerce '(#\f #\o #\o) 'string)
<antoszka>
"foo"
lisp123 has joined #commonlisp
<White_Flame>
and coerce works the other way, too, going string to list
<Spawns_Carpet[m]>
that is good to know
<mfiano>
(map 'string #'identity list) is another
<White_Flame>
oh, concatenate goes backwards, too
<antoszka>
yep
<White_Flame>
I would say that coerce is probably the most intentionally correct method
<antoszka>
I agree.
<Spawns_Carpet[m]>
I hate to ask another noob question, but how can I represent special chars like \n or \t with the #\x char syntax
<mfiano>
#\newline etc
<antoszka>
#\Newline #\Tab
<White_Flame>
#\Space
<antoszka>
Most of them have reasonable (unicode-compatible) names
<Spawns_Carpet[m]>
darn, it's that easy
<Spawns_Carpet[m]>
that's pretty cool
<antoszka>
Try converting a string into a list of chars
<White_Flame>
now of course this is all technically implementation-dependent behavior, but things are converging on unicode
<antoszka>
yep
lisp123 has quit [Ping timeout: 256 seconds]
<Spawns_Carpet[m]>
i am on SBCL
<Spawns_Carpet[m]>
i imagine thats the most common implementation
<White_Flame>
I think that's a reasonable assumption
<Spawns_Carpet[m]>
the more I learn CL the more impressed with it I am, especially for how old it is
<White_Flame>
I think that's a common impression
<Spawns_Carpet[m]>
its lots of fun to use as well
<dbotton>
I know I have not been around much, been busy with personal matters and a project I had to complete (pay for a wedding for son). I started work again on CLOG. I've added a 4th demo of a database driven website with content management built in (super simple so far but purpose is to demo ease of using CLOG for this) - https://github.com/rabbibotton/clog/blob/main/demos/04-demo.lisp
robin has quit [Read error: Connection reset by peer]
robin has joined #commonlisp
<White_Flame>
dbotton: neat, I wasn't familiar with that before, and is definitely the sort of thing I've wanted
semz has joined #commonlisp
<dbotton>
One stop for GUIs on your machine and Websites on the net
<beach>
Spawns_Carpet[m]: Old versions of languages other than Common Lisp become unusable, because the specification evolves. And the specification evolves because that's the only way new features can be added to those languages. Not so with Common Lisp.
s-liao has quit [Quit: Client closed]
<dre>
I'm really mad because I can't get SBCL working on 'my lisp machine'
<dre>
( which is an a4 eink tablet + bt keyboard so i can do things outside)
<Spawns_Carpet[m]>
very true beach. I am looking at some looping libraries that add in custom loop syntax and they are super impressive in what they can do without having to extend the language
<dre>
but I've got fennel working, which might be ok
<Spawns_Carpet[m]>
i actually like 'loop' a lot even though people seem to not like it very much
<hayley>
lol
<beach>
Spawns_Carpet[m]: I like LOOP fine. And I decided to use it as the main looping construct in SICL code, which is also why I created a new version of LOOP for SICL.
<Spawns_Carpet[m]>
what is SICL beach? is that your lisp that you are working on
<beach>
minion: Please tell Spawns_Carpet[m] about SICL.
<minion>
Spawns_Carpet[m]: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<hayley>
I quite like LOOP too, though the only thing that stands out perhaps is collecting list without the PUSH/REVERSE dance, recursion, or some mapping function that I forgot the name of.
<hayley>
But, then again, it could also be written as a reduction, just the same as "maximising" or "minimizing" or "counting" or so on. So I have failed to convince anyone that it's any good, somehow.
<Spawns_Carpet[m]>
that's really cool beach
<beach>
Thanks.
<White_Flame>
hayley: doing a common reduction in a single word is a clear ease-of-use advantage
<Spawns_Carpet[m]>
that looks like a HECK of an undertaking for sure
<Spawns_Carpet[m]>
what is a common reduction? would that be like filter/map/etc?
<White_Flame>
max/min/count/collect
<hayley>
A reduction is performed with REDUCE in Common Lisp. Some other languages might call it fold or foldr and foldl (fold-left, fold-right, for which order the reduction is done).
<White_Flame>
but it's especially easy as those terms can be behind loop conditionals as well
shka has joined #commonlisp
Oladon has joined #commonlisp
aartaka has quit [Ping timeout: 265 seconds]
Guest1099 has quit [Quit: Leaving]
Inline has quit [Quit: Leaving]
White_Flame has quit [Remote host closed the connection]
White_Flame has joined #commonlisp
elderK has quit [Quit: Connection closed for inactivity]
karlosz has joined #commonlisp
gaqwas has joined #commonlisp
shka has quit [Ping timeout: 256 seconds]
peterhil has quit [Remote host closed the connection]
aartaka has joined #commonlisp
peterhil has joined #commonlisp
tophullyte has joined #commonlisp
Oladon has quit [Quit: Leaving.]
aartaka has quit [Ping timeout: 256 seconds]
aartaka has joined #commonlisp
rotateq has joined #commonlisp
amb007 has quit [Ping timeout: 250 seconds]
amb007 has joined #commonlisp
VincentVega has joined #commonlisp
peterhil has quit [Remote host closed the connection]
peterhil has joined #commonlisp
lrkrr has joined #commonlisp
s-liao has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
vegai_ has joined #commonlisp
vegai_ is now known as vegai
amb007 has joined #commonlisp
rgherdt has joined #commonlisp
s-liao has quit [Ping timeout: 256 seconds]
gaqwas has quit [Remote host closed the connection]
gaqwas has joined #commonlisp
amb007 has quit [Ping timeout: 250 seconds]
lisp123 has joined #commonlisp
Cymew has joined #commonlisp
lisp123 has quit [Ping timeout: 250 seconds]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
frgo has quit [Ping timeout: 250 seconds]
dec0d3r has quit [Quit: Leaving]
santiagopim[m] has quit [Quit: You have been kicked for being idle]
s-liao has joined #commonlisp
pranavats has left #commonlisp [#commonlisp]
Colt has quit [Quit: Leaving]
s-liao has quit [Ping timeout: 256 seconds]
Colt has joined #commonlisp
s-liao has joined #commonlisp
dre has quit [Ping timeout: 268 seconds]
aartaka has quit [Remote host closed the connection]
waleee has joined #commonlisp
peterhil has quit [Remote host closed the connection]
taiju has quit [Read error: Connection reset by peer]
taiju has joined #commonlisp
Devon has joined #commonlisp
aartaka has joined #commonlisp
VincentV` has joined #commonlisp
VincentVega has quit [Ping timeout: 265 seconds]
travv0 has quit [Ping timeout: 264 seconds]
random-nick has joined #commonlisp
ullbeking has quit [Ping timeout: 256 seconds]
ullbeking has joined #commonlisp
rain3 has joined #commonlisp
travv0 has joined #commonlisp
lisp123 has joined #commonlisp
random-nick has quit [Ping timeout: 250 seconds]
lisp123 has quit [Ping timeout: 256 seconds]
random-nick has joined #commonlisp
tophullyte has quit [Ping timeout: 265 seconds]
karlosz has quit [Quit: karlosz]
VincentV` has quit [Ping timeout: 265 seconds]
edgar-rft has quit [Quit: Leaving]
beach has quit [Remote host closed the connection]
igemnace has quit [Remote host closed the connection]
s-liao has quit [Quit: Ping timeout (120 seconds)]
s-liao has joined #commonlisp
sgithens has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
sgithens has joined #commonlisp
amb007 has joined #commonlisp
jmercouris has quit [Ping timeout: 256 seconds]
pl has quit [Ping timeout: 268 seconds]
griffinmb has quit [Ping timeout: 264 seconds]
amb007 has quit [Ping timeout: 265 seconds]
jmercouris has joined #commonlisp
amb007 has joined #commonlisp
pl has joined #commonlisp
griffinmb has joined #commonlisp
d_run has quit [Ping timeout: 264 seconds]
d_run has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
frgo has joined #commonlisp
atgreen has joined #commonlisp
green_ has joined #commonlisp
frgo has quit [Ping timeout: 256 seconds]
frgo has joined #commonlisp
spiaggia has joined #commonlisp
VincentVega has joined #commonlisp
spiaggia has quit [Ping timeout: 256 seconds]
tyson2 has joined #commonlisp
Posterdati has quit [Ping timeout: 268 seconds]
spiaggia has joined #commonlisp
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 256 seconds]
s-liao has quit [Ping timeout: 256 seconds]
X-Scale` has quit [Ping timeout: 250 seconds]
X-Scale has joined #commonlisp
Posterdati has joined #commonlisp
Charles_Attends has quit [Quit: WeeChat 3.3]
perrierjouet has joined #commonlisp
lrkrr has quit [Remote host closed the connection]
<az_reth>
Is it possible to initialize an array using a function? As I understand it, :initial-element inserts references to the same object
<az_reth>
Or should I just initialize it after creation?
aartaka has quit [Ping timeout: 250 seconds]
<Xach>
az_reth: after. but you can make it terse with map-into.
<az_reth>
Xach: thanks!
s-liao has joined #commonlisp
<jdz>
It is also possible to create the array with just MAP.
<random-nick>
doesn't map only create vectors and not multi-dimensional arrays?
<random-nick>
ah, map-into also works on sequences and not arrays
lisp123 has quit [Ping timeout: 265 seconds]
yewscion has joined #commonlisp
pve has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
<drmeister>
What implementations of Common Lisp support something like SAVE-LISP-AND-DIE? SBCL obviously.
<yitzi>
drmeister: uiop has an function so maybe look there.
<drmeister>
Clasp does (I'm currently working on it). It's a difficult feature to get right. Especially when we interoperate with C++ and standard unix object files and linking.
<yitzi>
Looks like allegro, clisp, ccl, lispworks, sbcl and scl
<yitzi>
That code probably needs to be updated for clasp
<yitzi>
I would think (naively) that clisp would have some that same problems that clasp does.
Bike has joined #commonlisp
cosimone has joined #commonlisp
jealousmonk has joined #commonlisp
<random-nick>
mezzano has something similar called taking a snapshot, where you can overwrite the image on the mezzano partition with the current image
<random-nick>
there's no dying involved though
<drmeister>
random-nick: Thank you.
<drmeister>
Is not dying very valuable? It would complicate the implementation but it's doable.
<yitzi>
Not dying would seem useful for Smalltalk like development?
<random-nick>
for mezzano it is since it would require rebooting the machine, but for something running under a host OS I don't think it is since SBCL still doesn't have such a feature
<random-nick>
even thought SAVE-LISP-AND-DIE was renamed from CMUCL's SAVE-LISP so that there might be a save which doesn't die
* drmeister
leans more towards SAVE-LISP-AND-DIE-DIE-DIE!
<drmeister>
...as an implementer that is.
<_death>
save-lisp-and-I
random-nick has quit [Ping timeout: 250 seconds]
X-Scale has quit [Ping timeout: 256 seconds]
lisp123 has joined #commonlisp
Guest74 has joined #commonlisp
ym has joined #commonlisp
X-Scale has joined #commonlisp
<jackdaniel>
(quit :exit-code (coerce list 'integer))
<rotateq>
LISP will never die :)
<lisp123>
Is there a way to do pacakge inferred systems with a "." separator instead of "/"?
rotateq has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
jeosol has joined #commonlisp
s-liao has quit [Quit: Client closed]
igemnace has joined #commonlisp
djuber has joined #commonlisp
green__ has joined #commonlisp
green_ has quit [Ping timeout: 250 seconds]
atgreen has quit [Ping timeout: 250 seconds]
atgreen has joined #commonlisp
atgreen has quit [Read error: Connection reset by peer]
green__ has quit [Read error: Connection reset by peer]
tyson2 has quit [Remote host closed the connection]
<NotThatRPG>
lisp123: Not built in, but it is probably doable given the source..
<lisp123>
NotThatRPG: Yeah, I am just about to write a function that creates a DEFSYSTEM and converts :import-from to :depends-on and then for each package I'll just run that function
<lisp123>
Does package-inferred-systems create an .asd for each component?
<NotThatRPG>
No: it does not do any file-to-file translation -- everything is in memory.
NotThatRPG is now known as NotThatRPG_away
<NotThatRPG_away>
lisp123: I have to go for a while, you can hit me up later or you could try the asdf-devel email list.
<lisp123>
NotThatRPG_away: cheers
NotThatRPG_away has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<spiaggia>
NotThatRPG_away: I like your new nick. :)
aartaka has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
lisp123_ has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
yewscion has quit [Quit: Connection closed]
cage has joined #commonlisp
cage has quit [Client Quit]
lisp123 has quit [Ping timeout: 250 seconds]
NotThatRPG has joined #commonlisp
Cymew has quit [Ping timeout: 256 seconds]
aartaka has quit [Ping timeout: 250 seconds]
<etimmons>
lisp123: Do you really need each file to have its own system? If not, you may be interested in <https://gitlab.common-lisp.net/etimmons/asdf-inferred-components/>. I've got a local branch I'm working on that lets you take the package-inferred approach with arbitrary names for packages.
bcasiello__ has joined #commonlisp
taiju has quit [Ping timeout: 264 seconds]
yewscion has joined #commonlisp
taiju has joined #commonlisp
<lisp123_>
etimmons: That looks interesting, esp. the one package per system solution
<lisp123_>
What I was thinking was: Assume package name = system name. Read all symbols in a package, extract their package name and then do a :depends-on for those systems
<lisp123_>
So one system is created for each package
frgo has quit [Ping timeout: 256 seconds]
<lisp123_>
But I like your approach better
aartaka has joined #commonlisp
Lycurgus has joined #commonlisp
pranavats has joined #commonlisp
<Guest74>
doesn't this encourage non-reusable components?
<lisp123_>
etimmons: I have thought some more, and your approach makes perfect sense for one package across multiple files
<lisp123_>
Thanks for sharing, I will use that when I am in that situation
<lisp123_>
Guest74: In what way?
<lisp123_>
etimmons: Is it okay to start using the local branch?
<lisp123_>
(no rush)
<Guest74>
how do you load a package in the system without loading both the whole system and this AIC
Lycurgus has quit [Quit: Exeunt]
<Guest74>
though I've noticed that it's kinda the norm.
shka has joined #commonlisp
<lisp123_>
Ah I see
<lisp123_>
That's in relation to the "One package per file" section right?
<lisp123_>
I also had a similar view (not in relation to this project, but generally), which is why I was going to create 1 system for each 1 package / 1 file file
<etimmons>
lisp123_: I wouldn't be surprised if there are bugs on the main branch, but I think it's usable (and welcome any bug reports). My local branch is horribly broken ATM, but I can ping you when it's fixed and pushed.
aeth has quit [Ping timeout: 256 seconds]
<lisp123_>
etimmons: Thansk! Will do
<etimmons>
Guest74: If you want each individual file to be loadable by someone else, then package-inferred-system is definitely what you want. I personally like having a lot of files but don't want each file to be some sort of entry point for others to depend on.
Oladon has joined #commonlisp
aeth has joined #commonlisp
<Guest74>
I think I just think more in terms of reusability. I see so much duplication in multiple libraries, hidden in 'interior' packages.
<etimmons>
I'd argue that means those should be split into standalone systems and explicitly advertised as something for people to use. In the package-inferred-system approach, it can be tough to figure out if some system is internal or meant to be used by others.
<Guest74>
I'd argue that too. But it's not what seems to happen.
frgo has joined #commonlisp
frgo has quit [Read error: Connection reset by peer]
frgo has joined #commonlisp
frgo__ has joined #commonlisp
frgo_ has joined #commonlisp
edgar-rft has joined #commonlisp
Catie has joined #commonlisp
frgo has quit [Ping timeout: 265 seconds]
frgo__ has quit [Ping timeout: 265 seconds]
rain3 has quit [Ping timeout: 265 seconds]
tyson2 has joined #commonlisp
hhdave_ has joined #commonlisp
hhdave has quit [Ping timeout: 264 seconds]
hhdave_ is now known as hhdave
rain3 has joined #commonlisp
spiaggia has quit [Ping timeout: 250 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
<_death>
maybe a little duplication is better than leftpad libraries
amb007 has quit [Ping timeout: 256 seconds]
<Guest74>
leftpad?
amb007 has joined #commonlisp
<Guest74>
ah, nevermind
karlosz has joined #commonlisp
Oladon has quit [Quit: Leaving.]
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
ym has quit [Quit: Leaving]
amb007 has quit [Ping timeout: 250 seconds]
amb007 has joined #commonlisp
ym has joined #commonlisp
lisp123_ has quit [Quit: Leaving...]
<NotThatRPG>
etimmons: ping?
<etimmons>
NotThatRPG: I was just about to send you a "sorry..." lol
<NotThatRPG>
Kind of OT: are you informed about GitHub actions? I am wondering if the problem I see that looks like lisp hanging is the CI job getting cut off for exceeding an *aggregate* compute time budget.
<NotThatRPG>
I assumed they had only a duration constraint, but it's possible not.
<etimmons>
Ah. That could make sense. But I'm not up to speed on them enough to know if that's what's happening.
<etimmons>
I'm exclusively a Gitlab CI guy since before Actions really took off
aeth has quit [Ping timeout: 250 seconds]
aeth has joined #commonlisp
karlosz has quit [Ping timeout: 250 seconds]
epolanski has quit [Quit: Connection closed for inactivity]
tyson2 has quit [Remote host closed the connection]
peterhil has joined #commonlisp
samps has joined #commonlisp
<samps>
Hey folks. I'm trying to get into common lisp but I can't make one project with barely any code be picked up by `ql:quickload`. At the moment I reverted back to using `:serial t` and listing the files under `:components` but I would still like to understand what I'm doing wrong. I have more context here, if it helps:
<Xach>
samps: (ql:register-local-projects) may help
amb007 has quit [Read error: Connection reset by peer]
<samps>
ran it a few times after finding it... somewhere on the internet, but it seemed to have no effect :/
<Xach>
samps: are you up for trying a few things?
<samps>
this is invoked when we choose `2: [REGISTER-LOCAL-PROJECTS] Register local projects and try again` on the condition raised by quicklisp, right?
<samps>
Xach of course :)
<Xach>
Hmm, that's not part of vanilla quicklisp.
<Xach>
At least, I don't think it is.
<samps>
hmmmm, interesting. This was installed by `brew install roswell`. I think it's sbcl-bin, I can pull up the version for you
<samps>
I haven't done anything else besides having roswell installed
<Xach>
samps: what do you get when you evaluate ql:*local-project-directories*?
<etimmons>
samps: one error I see is that if you're using package-inferred-system, in main.lisp the package name should be foo/main with a nickname foo, you currently have it the other way around.
<Xach>
I don't think that's very nice to do.
<samps>
that likely explains it. So It's a roswell-specific thing, let me try to move it to this particular local-projects location
<Xach>
(Change how things are laid out so that people who know quicklisp can't help as easily, that is.)
<samps>
etimmons thanks for the tip! I'll fix this right away
<etimmons>
Xach: Roswell installs the entire QL tree under ~/.roswell/lisp/quicklisp :(
<samps>
now it works. Damn, I was sure it was something simple
<samps>
and it is, really simple
karlosz has joined #commonlisp
<Xach>
etimmons: i guess it makes some sense, but it's a little frustrating.
* Xach
is far from blameless in making things easy to troubleshoot and communicate about
<samps>
I cloned a few open source repos to the wrong place. This explains why `pokepay/paras` didn't load with quicklisp... it likely wasn't in the dist to begin with, but `ambrevar/fof` was
ryanbw has quit [Ping timeout: 245 seconds]
ryanbw has joined #commonlisp
<samps>
thanks for the help, folks! I'm coming from Clojure and will do some experiments with CL now
keepitalphanumer has joined #commonlisp
<keepitalphanumer>
Hi all, i have a question: Why (map-into '(0 1) #'+ '(1 1)) returns (1 1) and not (1 2)?
<Catie>
I wonder if it has something to do with modifying constant data?
<Xach>
samps: the function is applied to the sequences after the function, not the sequence preceding it. (the preceding sequence receives the results.)
<Xach>
modifying constant data is also not good
<samps>
maybe you're replying to the wrong person?
<Xach>
yes, i am
<Xach>
keepitalphanumer is the person
<keepitalphanumer>
Got it... it would be something like "(0 1) <-- ((+ 1) (+ 1))" (This is not an valid expression)
<Xach>
keepitalphanumer: right.
<_death>
(mapcar #'+ '(0 1) '(1 1))
<keepitalphanumer>
Yes, that's better.
<Xach>
you could do something like: (let ((list (list 0 1))) (map-into list #'+ list '(1 1))))))
<keepitalphanumer>
@Xach, thanks!
<keepitalphanumer>
Well, see you around. Thank you.
keepitalphanumer has left #commonlisp [ERC (IRC client for Emacs 27.2)]
cage has joined #commonlisp
paule32 has joined #commonlisp
lisp123 has joined #commonlisp
Inline has joined #commonlisp
Guest74 has quit [Quit: Connection closed]
rain3 has quit [Ping timeout: 265 seconds]
<NotThatRPG>
The QL issue above suggests another question -- anyone know how roswell interacts with saved images?
<NotThatRPG>
I mean, I would hope that an image being built from a roswell lisp wouldn't make a difference, but what do I know?
<NotThatRPG>
(question relevant to using roswell to test CL system in GitHub actions)
ebrasca has quit [Remote host closed the connection]
tfeb has joined #commonlisp
<lisp123>
etimmons: This is probably too primitive for you, but in case its useful as an idea - https://plaster.tymoon.eu/view/2713#2713 (don't mind the indenting) --> if we assume package names = system names in a one package per file workflow, we can use this to automate some of the :depends-on clauses
<lisp123>
I imagine package-inferred-systems does something similar, but just in case its useful..
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
VincentVega has left #commonlisp [ERC (IRC client for Emacs 27.2)]
Inline has quit [Remote host closed the connection]
tfeb has quit [Ping timeout: 250 seconds]
Inline has joined #commonlisp
frgo_ has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
<Spawns_Carpet[m]>
is it a bad thing that lisps tend to use linked lists and their most commonly used data structure? I was talking elsewhere and people seem to strongly dislike linked lists for some reason
<Catie>
Nah, not really
<Catie>
Linked lists have downsides of course, but it's not the only data structure in most Lisps. And for most things they're used for, they work really well
ym has quit [Ping timeout: 268 seconds]
peterhil has quit [Ping timeout: 256 seconds]
samps has quit [Quit: Client closed]
jealousmonk has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
karlosz has joined #commonlisp
karlosz has quit [Client Quit]
karlosz has joined #commonlisp
akoana has joined #commonlisp
aartaka has quit [Ping timeout: 250 seconds]
samps has joined #commonlisp
random-nick has joined #commonlisp
<NotThatRPG>
Spawns_Carpet[m]: For symbolic computing the linked lists work very nicely. As Catie suggests, there was a tendency to overuse this data structure in the past, but there's the full set of arrays and hash-tables you would expect in common lisp
servytor has joined #commonlisp
jealousmonk has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
edgar-rft has quit [Ping timeout: 256 seconds]
edgar-rft has joined #commonlisp
aeth has quit [Ping timeout: 250 seconds]
aeth has joined #commonlisp
samps has quit [Ping timeout: 256 seconds]
cage has quit [Quit: rcirc on GNU Emacs 27.1]
<White_Flame>
Spawns_Carpet[m]: also, linked lists tend to be heavily used in construction & deconstructing source code. There's a lot of passing around of partial lists & inserting elements and such which can get very cumbersome with arrays
aartaka has joined #commonlisp
<Spawns_Carpet[m]>
where do you guys normally put your test code for projects? In rust and c++ I always put my tests in the source file directly and put them behind an #ifdef to compile them out when disabled
<hayley>
I've usually had a Tests/ directory which may or may not mirror the structure of how the code is stored. Then you have to go out of your way to make protocol-breaking changes, since you have to fix the tests too.
kevingal has joined #commonlisp
<Spawns_Carpet[m]>
do you think it's "cheating" to write a lisp like language in lisp itself? I am working on a lisp in rust but recently restarted the project from scratch and have been debating whether I should use a different language
<Spawns_Carpet[m]>
i thought I would learn more if I used a language that was different and did not provide some of the features I would need
<copec>
This question comes from only a rough understanding of the erlang paradigm: Is there a library for which you can write functions (with respective constraints), and can schedule and execute function calls across threads in a pool?
<Xach>
Spawns_Carpet[m]: common lisp is nice for implementing lisp
<copec>
Spawns_Carpet[m], That's pretty much what defines Lisp
<Spawns_Carpet[m]>
what is the erlang paradigm copec ?
<Alfr>
copec, you refer to the two dozen odd lines? (Assuming the underlying things are somehow provided?)
<hayley>
Spawns_Carpet: Well, are implementations like SBCL, SICL, and Clozure cheating? And what's the language?
<copec>
Spawns_Carpet[m], as I understand it, you write small processes that are essentially functions, and each is mapped to a green thread, and all the green threads which are scheduled and executed across cpu(s)
<White_Flame>
If you go all the way down to C or C++, you also lose garbage collection and have to waste time reimplementing that. So at the very least, if you're going to implement toy lisp on top of non-lips, use a GC'd language
<copec>
Alfr, I apologize, I don't quite follow
<Odin->
White_Flame: Depends on just what it is you're looking to understand.
<hayley>
But, to be fair, if you think Lisp (perhaps more precisely Common Lisp, and then your own language) is any good, then you should bootstrap from Common Lisp, so that you get interactive development at the least, and then make a meta-circular implementation of your own language.
<White_Flame>
Odin-: yep
<Spawns_Carpet[m]>
it's not cheating if your goal is to make an actual production ready programming language, but if your goal is to learn rather than make something useful it's a bit different I think
<copec>
Spawns_Carpet[m], To be more specific about Lisp, most sufficiently complex programs in a Lisp are really an evolved DSL in Lisp fit to implement the program
<Spawns_Carpet[m]>
like, I could use a library that parses sexprs for me, but what's the point in that?
<copec>
So implementing a lisp dialect in lisp for an arbitrary program is sort of par for course
<Odin->
White_Flame: Then again, in some ways it's more interesting to write a compiler for a lisp in lisp, and then have that bootstrap its own GC...
<copec>
Implementing a full lisp is just an extreme example of what I'm talking about
* Odin-
wonders idly if it'd be possible to build a sensible (not-common) Lisp for the Harvard architecture that is webassembly using a strategy like that.
<White_Flame>
compiling on the fly seems weird there
<hayley>
Personally, I find parsing to be boring and avoid it where possible.
<White_Flame>
hayley: that's the nice thing about sexprs at least, it's one of the easiest parsers to write for a real programming language
<hayley>
Odin-: Can you somehow generate a new WASM file and load it in?
<Odin->
White_Flame: The whole system is kind of designed not to have it make sense.
<White_Flame>
and of course you can't change the function call ABI like you can in raw process asm
<hayley>
Alfr: It's funny that the article mentions the Lisp 1.5 manual page with eval[] on it, but then goes to implement a completely different language.
Inline has quit [Remote host closed the connection]
<copec>
Odin-, There are a couple of things with wasm they need to change to make an efficient CL implementation (according to my understanding anyways)
<Odin->
hayley: It needs host support, so you could get it working.
<copec>
There are some Lisps and schemes
<copec>
in wasm
<Odin->
copec: Part of why I said 'non-common'.
<copec>
ah, okay
tyson2 has joined #commonlisp
<hayley>
In fact, I'd bet the article is just Norvig's Lisp-in-Python tutorial with some noise at the start and end.
<hayley>
Well, they do write a metacircular interpreter, but it doesn't hit the same as metacircularity.
<Alfr>
hayley, it's one of things I tend to remember when someone asks about a minimal lisp.
<Odin->
The thing about wasm is that it makes a really, seriously strict distinction between code and data spaces.
<Odin->
You can build a compiler, but a compiler-only implementation is just about unfeasible.
<Spawns_Carpet[m]>
what do you guys think about the norvig lisp in python thing btw? Also do you guys know of any other good resources that are similar ?
<hayley>
Not bad, but not notably good. The lexing/parsing step is just silly.
Inline has joined #commonlisp
<White_Flame>
lexing/parsing as two such separated steps are silly in the first place, regardless of language
<White_Flame>
there's too many contextual edge cases
<Odin->
Historical artifact.
<Alfr>
hayley, it's not really useful, I mean in the excerpt form you'll even have implement numbers and other amenities; or just do as the author does and use some of the underlying language's facilities.
<copec>
It's great for learning lisp buildup imo
pve has quit [Quit: leaving]
<hayley>
It's no Lisp in Small Pieces still, you just have a lexically scoped language with numbers, lists and strings, and only a tree-walking interpreter.
Inline has quit [Ping timeout: 265 seconds]
<Alfr>
hayley, iirc it has environments and working closures. As for it being interpreted, I couldn't care less, as for me that's just a demonstration on how a lispy language could be implemented with not too much code.
<hayley>
Yes, that's lexical scoping.
<Alfr>
hayley, also I didn't advocate using it in any way.
<Odin->
The 1.5 manual example isn't exactly supremely useful, to be honest...
<hayley>
But I got stuck in a local maxima trying to figure out how Lisp implementations worked for like a year.
<hayley>
Well, are they the "Maxwell's equations of software" or not then?
<Odin->
I don't think you'd easily be able to extrapolate optics from Maxwell's equations, so that's an entirely distinct question. :)
<Alfr>
hayley, I don't think so, or maybe one incantation of those. Also my original motivation referencing it was because copec implicitly stated that lisp is definable in lisp. ^
shka has quit [Ping timeout: 256 seconds]
dre has joined #commonlisp
<dbotton>
Is there a way to declare a forward reference so as to avoid warnings?
<Bike>
a forward reference to what kind of thing?
<dbotton>
function sorry
<dbotton>
I am using sbcl but prefer a general cl way
<dbotton>
if there is such a thing
<dbotton>
I have a circular decency between two functions.
<dbotton>
dependency
<Bike>
usually what you do is just define them in the same file, and then the implementation is probably smart enough to know to delay warnings when you compile-file
<dbotton>
sbcl is not so patient it seems
<dbotton>
granted they are style warnings to errors, but would be nice to avoid
<Bike>
no, sbcl definitely elides the warnings. are you using compile-file, or are you using something else like loading the source with LOAD?
<dbotton>
load
<semz>
I think (declaim (ftype ...)) suppresses that, but of course it has other side effects that may be unwanted in other implementations.
<dbotton>
my RUN-DEMO loads the demo then using FUNCALL to start it up
<dbotton>
using LOAD
<dbotton>
is there a better then LOAD
<dre>
What other implementations of commonlisp are there? I can't get SBCL working on my android 6 tablety.
<random-nick>
I think ECL works on android
<random-nick>
also ABCL probably, since it's on java
<dre>
I saw the common-lisp client in the play store but it segfaults on my chinese hardware
<dre>
so my dealio is:
<dre>
I use termux and a bt keyboard, and so I can run some standard linux packages
<dre>
like make and etc, but termux only have racket in terms of lisp interpreters
<Bike>
dbotton: yeah, you can do like (load (compile-file file))
<Bike>
dbotton: you might also be able to do a "forward declaration" with an ftype proclamation, but i don't know how well implementations respect that
<random-nick>
dre: apparently termux has an ecl package
<random-nick>
maybe it's not built for all CPU architectures?
yewscion has quit [Ping timeout: 265 seconds]
<dre>
hmm, let me check
<dbotton>
Bike, thank you
<dbotton>
that seems to have worked but now I get errors around defconstant being redefined
<dre>
yeah nah ecl isn't in my termux packages, ._.
<dbotton>
I will play with it Bike, thank you
random-nick has quit [Ping timeout: 250 seconds]
<Bike>
dbotton: you might want alexandria:define-constant
<dbotton>
Will do
servytor has quit [Quit: Connection closed for inactivity]
Guest74 has joined #commonlisp
sander has quit [Ping timeout: 268 seconds]
sander has joined #commonlisp
cosimone has quit [Ping timeout: 268 seconds]
john__ has joined #commonlisp
gaqwas has quit [Ping timeout: 268 seconds]
NotThatRPG has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
tyson2 has quit [Remote host closed the connection]