zefram22 has quit [Remote host closed the connection]
zefram22 has joined #lisp
epony has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
MrFantastik has joined #lisp
perrier-jouet has joined #lisp
monolithic has quit [Remote host closed the connection]
hendursa1 has joined #lisp
bitmapper has joined #lisp
zefram22 has quit [Ping timeout: 240 seconds]
epony has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 252 seconds]
gigamonkey has quit [Remote host closed the connection]
gigamonkey has joined #lisp
Guest91421 is now known as notzmv
kagevf has quit [Ping timeout: 268 seconds]
kagevf has joined #lisp
DHARMAKAYA has joined #lisp
epony has joined #lisp
epony has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
test124 has joined #lisp
test124 has quit [Quit: WeeChat 3.1]
aeth_ has joined #lisp
aeth has quit [Ping timeout: 252 seconds]
aeth_ is now known as aeth
CrazyPython has quit [Read error: Connection reset by peer]
notzmv has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
Nilby has joined #lisp
rmandy8 has joined #lisp
rmandy8 has quit [Client Quit]
rmandy8 has joined #lisp
rmandy8 has quit [Client Quit]
rmandy8 has joined #lisp
rixard has quit [Read error: Connection reset by peer]
gigamonkey has quit [Ping timeout: 252 seconds]
rmandy8 has quit [Client Quit]
rixard has joined #lisp
srhm has quit [Quit: Konversation terminated!]
epony has joined #lisp
zefram22 has joined #lisp
hegz has joined #lisp
hineios2 has joined #lisp
<beach>
Good morning everyone!
<Oddity>
hello
<hegz>
morning!
Alfr is now known as Guest9009
Alfr has joined #lisp
hineios has quit [Ping timeout: 268 seconds]
hineios2 is now known as hineios
<beach>
Oddity, hegz : Are you new here? I don't recognize your nicks?
<Oddity>
I've lurked on and off for a few years
<beach>
I see.
Guest9009 has quit [Ping timeout: 250 seconds]
<hegz>
beach hehe, I'm a newbie lisper :)
<beach>
Great!
notzmv has joined #lisp
<beach>
hegz: #lisp is not really for truly basic questions, but they are tolerated. If it gets too lengthy, you might be redirected to #clschool. What are your plans with respect to Common Lisp? Write applications? Just play around? Something else?
Stanley00 has joined #lisp
<beach>
Thought I guess there are some questions that are "truly basic" but where the answers won't hurt to be repeated here, like the semantics of argument passing and how lists are represented.
gigamonkey has joined #lisp
semz has quit [Ping timeout: 245 seconds]
epony has quit [Ping timeout: 240 seconds]
gigamonkey has quit [Ping timeout: 265 seconds]
<hegz>
beach I'm still not sure whether I will dig deeper into CL or not tbh, my journey with lisp was mainly me reading SICP and I was kinda surprised this channel is specific to CL but not lisps in general haha
<beach>
I see. Well, SICP is a nice textbook for genera ideas about programming, like encapsulation, etc. But the style of object-oriented programming in SICP is not as practically useful as CLOS.
<beach>
*general
<beach>
hegz: There is ##lisp for general Lisp discussions, but since there is no widely agreed-upon definition of "Lisp", I imagine the discussions can become strange. That's part of the reason I am not in that channel.
Josh_2 has quit [Ping timeout: 246 seconds]
Necktwi has quit [Quit: leaving]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
<hegz>
beayeahch yeah, the main reason that drove me into starting with SICP was the approach to programming in general and you get to learn scheme as a bonus haha.
<hegz>
There were these MIT lectures of the book authors which I found brilliant.
<hegz>
<Nilby "hegz: One of our lispers has wri"> Lispers seem to love porting stuff don't they haha
zefram22 has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
Just wait until someone ports Common Lisp to Common Lisp.
<Nilby>
Yes they do, myself included. Once you have a CL environment that you like, it's hard to go back.
<raeda>
no-defun-allowed: Are you saying that nobody's made a self-hosting CL interpreter yet?
<no-defun-allowed>
A self-hosting interpreter? SBCL has an interpreter written in Common Lisp, but there aren't any full Common Lisp systems written entirely in Common Lisp (including garbage collector, operating system interface and so on).
<beach>
raeda: Modern Common Lisp systems don't have an interpreter at all, so it is entirely possible that nobody did that.
<moon-child>
you can use iota to run ecl
<hegz>
but now what makes CL superior to other lisps.
<hegz>
does it have something to do with the application or is it just entirely opinionated tastes.
<beach>
hegz: The condition system is unique, as is CLOS. But, again, there is no widely agreed-upon definition of "Lisp", so it is unclear which these "other lisps" might be.
<Alfr>
Isn't sbcl mostly there? Aren't the missing crucial bits only the loader and the gc?
<raeda>
A self hosting CL interpreter sounds like a fun lockdown project :D
<Alfr>
I don't think they intend to change that any time soon, but still.
<no-defun-allowed>
Common Lisp is a programming system, most other Lisp languages are just that.
<Alfr>
Hm ... i guess, getting away from C also would mean to implement handling systems calls.
<beach>
I believe Mezzano is written entirely in Common Lisp.
<moon-child>
Alfr: system calls are not difficult. The challenge is that few systems have a stable syscall interface
<moon-child>
linux is a rare exception in that respect
<Alfr>
beach, good to know, thanks.
<beach>
raeda: I suggest a compiler instead. It will take a bit longer, but it will be more useful.
MrFantas` has joined #lisp
shka_ has joined #lisp
<Nilby>
linux doens't have stable syscalls, it just pretends
<no-defun-allowed>
My personal opinion is that CL has more in common with Smalltalk or Self than some other Lisps (though it is hard to make a case with Scheme, I dunno).
<Alfr>
moon-child, handling errors is a pita though.
<moon-child>
not moreso than when calling the same functions through a c wrapper
<moon-child>
*more so
<Alfr>
no-defun-allowed, in scheme you have call/cc and thus you can easily get green threads. (I think you were complaining the lack thereof recently.)
<no-defun-allowed>
The language is designed around interacting with an image, and there are facilities to make it work nicely in the language and its implementations.
<beach>
Alfr: System calls are messy either way. I have a long-term project for defining an implementation-independent protocol for POSIX and Linux system calls.
<no-defun-allowed>
Alfr: But then you also have call/cc and apparently if you breathe on it hard, you get performance problems. Don't get me wrong, I find it fun, but everyone else seems to think it's a bad idea.
MrFantastik has quit [Ping timeout: 245 seconds]
<no-defun-allowed>
All that is necessary is a one-shot undelimited continuation, not multi-shot. And that is basically just a copy of all the registers of the thread, which is what operating systems use already.
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #lisp
<Nilby>
Even C isn't always exactly self-hosting as people thing. Ironically a popular C compiler has some tricky bits in a Lisp-like language.
<no-defun-allowed>
"Lisp is when you do (()) and the more ((())) you do the more Lisp it is"
<beach>
Nilby: You mean GCC? That's no surprise, since it was initially written by RMS.
<no-defun-allowed>
There is a .pd file with some S-expression stuff (pd for pattern dispatch?) and it is used for partial evaluation of C code.
<Nilby>
beach: Yes :)
<beach>
Nilby: RMS opted for a free version of Unix, rather than a free version of Genera, for political reasons. And he was right. If I had been in the position of RMS at the time I would have made the wrong decision.
<moon-child>
beach: did he not also make emacs? ;)
MrFantas` has quit [Ping timeout: 250 seconds]
dukester has left #lisp ["WeeChat 3.0.1"]
<no-defun-allowed>
Funny how I say that so-and-so clearly isn't Lisp, but then say I don't care because a language which just passes the definition doesn't interest me.
madagest has quit [Remote host closed the connection]
<beach>
moon-child: Indeed. But he was not the first one to write an Emacs in Lisp.
madage has joined #lisp
<moon-child>
no-defun-allowed: is that really lisp? I see quite a lot of c syntax, which would seem to indicate that's an sexp shim
<no-defun-allowed>
moon-child: That is what I was trying to get at.
<Nilby>
beach: I think it was also that he already had Emacs running on unix, and finding people who could write unix utilities is much easier than finding people to replicate Genera.
<beach>
Nilby: Yes, that's what I meant by "political reasons". His idea would have been a failure if he had chosen something other than Unix to copy.
<Nilby>
Indeed.
<beach>
Nilby: But that must have been a very hard decision to make. Knowing that there is something better, but choosing the worse alternative anyway. I remember his phrase "Unix is not great, but it is not too bad".
<moon-child>
well, that's 'worse is better' in general
<Nilby>
Exactly. I guess that's why we're still using Emacs as the top half of most of our current CL environments.
slyrus has joined #lisp
<Nilby>
Also GCL was probably assumed to go further.
slyrus has quit [Ping timeout: 252 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<beach>
Nilby: It seems RMS did not like Common Lisp at all. "Common Lisp is HUGE!"
<beach>
Of course, it is not that big compared to other languages today.
<no-defun-allowed>
I thought he didn't like keyword arguments at least, and this was from a presentation at some Lisp meeting in 2005.
<beach>
Do you remember the reason for not liking keywords arguments?
<no-defun-allowed>
"I don't mind if a very complex and heavyweight function takes keyword arguments. What bothers me is making simple
<no-defun-allowed>
basic functions such as “member” use them." Fine, write a simple definition of object equality first.
<Nilby>
beach: Yes. It's interesting to see his votes and opinions on the CL committee. And funny that only after he's backed off does Elisp get nice things lexical scope.
<beach>
no-defun-allowed: I see, yes.
<beach>
Nilby: Interesting.
<Nilby>
And funny that Gosling doesn't get more credit for writing most of the C code in the first versions of GNU+/Emacs, even if he made the worst lisp ever.
<no-defun-allowed>
It should be called "debit" or something like that.
gigamonkey has joined #lisp
<Jachy>
I'm still amazed at how prolific Stallman was just in keeping up with a dozen already prolific Symbolics hackers in duplicating so much of their functionality for LMI.
MrFantastik has joined #lisp
mindCrime_ has quit [Ping timeout: 246 seconds]
Bike has quit [Quit: leaving]
<Nilby>
Jachy: It's quite impressive, but it's sad that LMI eventually got hopelessly behind, and maybe it more explains why rms ragequit to work on unix.
<no-defun-allowed>
Yeah, sure.
<Nilby>
it's cool when you can ragequit in a way that seems to benefit humanity
<no-defun-allowed>
Yeah, sure.
<White_Flame>
the complaining about heavyweight arguments is certainly one of a snapshot in time, before compilers could do a whole lot more to statically eliminate things
<Jachy>
Xerox indirectly spawned many things. Imagine if they hadn't pissed rms off by not giving them its source code
<White_Flame>
always leave room for the Sufficiently Advanced Compiler of Tomorrow™
<Nilby>
I'd like to peek at the alternate universes without a pissed off rms, or with a sucessful Symbolics.
<White_Flame>
if Symbolics and Commodore had merged to bring lisp machines to the masses, I'd be quite a happy camper
<no-defun-allowed>
I read they were supposed to have a cheap Lisp chip in 1985, but that didn't happen.
<Nilby>
Heh. Symbolics seems to have had a something close to Video Toaster.
hiroaki has quit [Ping timeout: 260 seconds]
akoana has quit [Quit: leaving]
<beach>
I think we can do something better than Genera. In today's world, we need more security anyway. And Lisp runs just fine on stock hardware today.
andrei-n has joined #lisp
<beach>
We have better garbage collectors, and better compilers. And we now have a great native GUI library.
gigamonkey has quit [Ping timeout: 245 seconds]
hjudt has quit [Ping timeout: 268 seconds]
ebrasca has quit [Remote host closed the connection]
<fiddlerwoaroof>
Shinmera: do you happen to have documentation about issues with PARSE-NAMESTRING?
<fiddlerwoaroof>
I've found that using parse-namestring and a combination of MERGE-PATHNAME and MAKE-PATHNAME, I can get pathname behavior that's consistent enough across-implementations for most of my purposes
tempest_nox has quit [Read error: Connection reset by peer]
CL-ASHOK has joined #lisp
karlosz has joined #lisp
hjudt has joined #lisp
<fiddlerwoaroof>
I've slowly come to appreciate CL's pathnames
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<fiddlerwoaroof>
I'd still like to see URLs specified the way PLNs have been, and for them to subsume most of the pathname stuff
wxie has quit [Ping timeout: 265 seconds]
phadthai_ is now known as phadthai
daphnis has joined #lisp
mathrick has quit [Ping timeout: 252 seconds]
mathrick has joined #lisp
raeda has quit [Read error: Connection reset by peer]
raeda has joined #lisp
hiroaki has joined #lisp
monolithic has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
karlosz has quit [Ping timeout: 252 seconds]
<Shinmera>
fiddlerwoaroof: parse-namestring is hairy due to wild pathnames. So stuff like [], *, and others (implementation dependent!!) may need escaping.
<fiddlerwoaroof>
Interesting
<fiddlerwoaroof>
That's good to know :)
MrFantastik has quit [Ping timeout: 250 seconds]
<Shinmera>
implementing an analog to uiop's parse-native-namestring is on my todo for pathname-utils (and has been for years)
<fiddlerwoaroof>
I think it'd be useful to take the CLOSER-MOP approach with pathnames, really
<fiddlerwoaroof>
Specify the edge cases of the standard, and provide a package that implements that specification and a package that shadows the appropriate CL names
gaqwas has quit [Ping timeout: 260 seconds]
saganman has joined #lisp
wxie has joined #lisp
mathrick has quit [Ping timeout: 268 seconds]
mathrick has joined #lisp
ljavorsk has joined #lisp
varjag has joined #lisp
mathrick has quit [Ping timeout: 245 seconds]
mathrick has joined #lisp
frost-lab has joined #lisp
skapata has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 245 seconds]
notzmv has quit [Ping timeout: 245 seconds]
<pjb>
fiddlerwoaroof: or, having identified the edge cases, and specified them, patch the open source implementations so they behave the same on the same platform, and push so that commercial vendors implement the same.
<pjb>
fiddlerwoaroof: we have a strong position here given there are more free implementations than commercial ones.
tophullyte has quit [Ping timeout: 246 seconds]
<pjb>
fiddlerwoaroof: but remember: pathnames depend on the platform and the file systems that are mounted (depending on how the platform deals with them, check the mount options!)
<pjb>
fiddlerwoaroof: in general the problem is not so much that CL leaves things up to the implementations (there are a variety of platforms), but that there have not been defined a set of substandards specifying things for specific platforms. eg. how to deal with pathnames on MacOS, on Unix, on MS-DOS, on MS-Windows, on VMS, on Multics, etc.
Thom2503 has joined #lisp
<Nilby>
fiddlerwoaroof: The outputs of check-pathname for the various systems is very detailed answer to your original question.
<Nilby>
pjb: Thanks for the excellent resource.
refusenick has quit [Ping timeout: 245 seconds]
rumbler31 has joined #lisp
<Nilby>
Now we just have to pipe the output from check-pathname on all systems to the automatic implementation fixer and we're nearly done.
rumbler31 has quit [Ping timeout: 240 seconds]
<Nilby>
But my opinion is that the CL pathname stuff is written for a world which doesn't exist anymore, if it ever did, and there is a much simpler protocol that will cover all filesystems currently in use.
varjag has joined #lisp
<pjb>
Nilby: granted. But AFAIR, only for soft specifications items. Eg. the specification mentions the customary case, but this customary case doesn't depend on the platform but also on the file system mounted, and platforms that can mount different file systems can (or could) deal with different customary case. In the same pathname! (ie, per component).
<pjb>
Nilby: but for hard features, such as the structure of paths in components, the hierarchic directory structure, etc, it's about good.
<Alfr>
I don't think pathnames support forks. (Not that it's a good idea to use them in the first place.)
<pjb>
Nilby: eg. the distinction between directory and file pathnames, even if it's not so clear-cut in POSIX pathnames, is still enforced in POSIX (eg. opendir vs open, or rmdir vs rm for files).
<pjb>
Alfr: what do you mean with forks here?
<Alfr>
pjb, it's called alternate data stream in ntfs.
<pjb>
Oh, I see.
<pjb>
Well it's unrelated to pathnames. It'd be a parameter for OPEN. Since OPEN takes key arguments, it's already ready for an extension to specify what fork you want to open.
imode has quit [Ping timeout: 240 seconds]
<pjb>
Alfr: the only place where it could be visible in pathnames, is when you map file systems with forks on unix (thru a mount), and they're translated in the path /mnt/fs-with-forks/example-file/data-fork when example-file is a file with fork, not a directory.
<Alfr>
Hm ... that'd be a solution, but conceptually I'd still think it rather belongs to pathnames.
<pjb>
Alfr: but in practice mounting Apple file systems on unix can use the apple-double or apple-triple format, which use alternate files with extensions: /mnt/apple-triple/example-file{.data,.rsrc,.info} /mnt/apple-double/example-file{,.rsrc}
random-nick has joined #lisp
surabax has joined #lisp
<pjb>
This can be dealt with relatively easily with CL pathnames (the only thing to specify is how to deal with multiple dots in the file name.
<pjb>
)
<Alfr>
pjb, or some directory which also can store data, would be an other interpretation.
skapata has joined #lisp
<pjb>
That could be used when forks are user specifiable, indeed.
gigamonkey has quit [Ping timeout: 240 seconds]
<pjb>
But in reality, aren't files with forks exactly that: directories? Like "file packages" on NeXTstep/OpenStep/Cocoa/macOS/iOS ?
ljavorsk has quit [Ping timeout: 245 seconds]
<pjb>
So again, but depending on the target filesystem and platform, this can be dealt with by CL pathname without difficulty.
<splittist>
Nilby: I would expect all manner of competing CloudFS in the near future
srandon111 has quit [Quit: leaving]
<Nilby>
splittist: Yes, there's already a lot of CloudFS things, an they seem to usually use URLs or even more complicated things. I personally dread having URLs a file names. But there seems to be an opportunity for a more encompassing "resrouce locator"/filename library.
<Nilby>
pjbj: I'm pretty sure old MCL (and probably ccl now) could open resource forks, even on pre-unix MacOS.
<Nilby>
I think ms-windows is an example of how the more complexity you put into file names, the more problems you'll have.
<Alfr>
pjb, hm ... maybe name and type being :unspecific? I don't think there's anything in 19. prohibiting this.
<flip214>
At a first glance, I'd guess a subclass of PATHNAME that includes eg. a SCHEME (like :HTTPS) and a PORT (443) might be a reasonable approximation for many uses....
<Nilby>
I wonder has anyone made something like a cl-tramp ?
<flip214>
trampolines on the stack?
<Nilby>
like the emacs tramp package that allows very extensible url-like filenames
<pjb>
flip214: granted, we have enough places to run code in lisp, not to add one in file names…
skapata has quit [Remote host closed the connection]
zzappie has joined #lisp
<Nilby>
Yes, internet file names seems quite scary and insecure. I would wish it would be something that the operating system could manage in a more secure way.
<engblom>
In the first chapter of Practical Common Lisp there is a simple database made out of lists. In it remove-if-not is used for quering the database. If you know there will always be only one occurence, it seems to be a bit wasteful to filter the whole list instead of just finding the first (and only) occurence. What could I use instead?
DHARMAKAYA has quit [Quit: Turning off a portion of this simulation.]
vegai has left #lisp [#lisp]
<Shinmera>
find
<no-defun-allowed>
here it is →
anticrisis_ has quit [Read error: Connection reset by peer]
zap1 has joined #lisp
zzappie has quit [Ping timeout: 240 seconds]
gitgood has quit [Quit: Probably away to do something really awesome]
<pjb>
LOL
s8ori has joined #lisp
<pjb>
engblom: also, sometimes you will want position (position-if vs find-if), so that you may mutate the slot.
<engblom>
Thanks!
<contrapunctus>
no-defun-allowed, pjb: I didn't get that 🤔
hendursa1 has quit [Ping timeout: 240 seconds]
s8ori has left #lisp [#lisp]
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
<engblom>
In my case I have a list of lists. Each sublist is a keyed list like this: (:ip x.x.x.x :port xx :user x :password x). Given an ip I need to find the rest of the settings.
hendursa1 has joined #lisp
<engblom>
As IP is unique there will only be one occurence.
<jdz>
engblom: Those are called "property lists," or "plists" in short.
<engblom>
Is ip-equal-p already existing somewhere or do I have to write it myself?
<jdz>
engblom: You can use STRING= until you actually parse the IP addresses.
<engblom>
jdz: I was thinking to use string=, but as you put there ip-equal-p I was just wondering if a such function actually already exists.
<jdz>
engblom: I've started writing an IP address library, but it lacks IPv6 support, and I'm undecided about many implementation aspects: https://github.com/jdz/ip.
<jdz>
engblom: You should define IP-EQUAL-P as (declaim (inline ip-equal-p)) (defun ip-equal-p (a b) (string= a b)) until you have something better.
<no-defun-allowed>
contrapunctus: I should admit to not having read the question, and I had assumed Shinmera typed find into the wrong buffer. Maybe "found it!" would have been a more direct response.
<engblom>
In this case I am sure the string= is enough thou, because the ip that is looked for is actually originally from the same plist, so there will never be cases where I need to handle comparing 192.168.1.1 to 192.168.001.001
<jdz>
engblom: My library also does not "correctly" parse "127.1".
<no-defun-allowed>
That's easy enough then.
IIsi50MHz has quit [Read error: Connection reset by peer]
gendl has quit [Ping timeout: 248 seconds]
jmercouris has quit [Read error: Connection reset by peer]
rme has quit [Ping timeout: 250 seconds]
mpontillo has quit [Read error: Connection reset by peer]
adam4567 has joined #lisp
theruran has quit [Ping timeout: 258 seconds]
selwyn has quit [Ping timeout: 250 seconds]
<flip214>
well, IMO any IP comparision has to be done in the binary (or integer) representation, and should take optional netmasks anyway.
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
rme has joined #lisp
IIsi50MHz has joined #lisp
jmercouris has joined #lisp
selwyn has joined #lisp
gendl__ has joined #lisp
mpontillo has joined #lisp
Stanley|00 has joined #lisp
theruran has joined #lisp
Stanley00 has quit [Ping timeout: 252 seconds]
<pjb>
IP address comparison may be complexified by the fact that there exist 2 kinds of IP addresses (IPv4 and IPv6) and several representation variations. So it's better to abstract it away with a function.
<pjb>
You could also define classes to represent IP addresses in a normalized way.
<pjb>
engblom: In some programs too, domain names can be used interchangeably with IP addresses (DNS resolution being performed automatically).
<pjb>
But since a domain name may correspond to several addresses, the comparison is not a mere =, but rather a set intersection…
zefram22 has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
heisig has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
<phoe>
pjb: I think that DNS lookups and comparisons are a slightly different topic; munging IPs on their own is easy because they can be treated as ub8 vectors, and mapping between IPs and domain names already sounds like something that a DNS library would do
<phoe>
IP versus DNS, that's already two distinct protocols from distinct OSI layers
boogsbunny has joined #lisp
<phoe>
if a program accepts domain names, then I guess that it should call into a DNS library, which can then in turn accept actual domain names and bare IP addresses alike and do the necessary munging before passing the resultant IP addresses into the IP layer
<phoe>
but that's already general separation of concerns and nothing really lisp-related
notzmv has joined #lisp
saganman has quit [Ping timeout: 245 seconds]
Thom2503 has quit [Read error: Connection reset by peer]
ljavorsk has joined #lisp
srandon111 has joined #lisp
jeosol has quit [Quit: Connection closed]
pve has joined #lisp
Thom2503 has joined #lisp
daphnis has quit [Ping timeout: 240 seconds]
CL-ASHOK has quit [Quit: Connection closed]
sernamar has joined #lisp
daphnis has joined #lisp
zefram22 has quit [Ping timeout: 252 seconds]
<pjb>
phoe: granted. It depends on the layer of this data structure. I mentionned domain name, because at the user level (eg. configuration file) we will often accept domain names as well as IP addresses. But you may want to retain the domain name internally. The question is when you want the resolution to occur.
<pjb>
phoe: in general, the resolution is performed the latest possible, ie. when connecting.
fourier has joined #lisp
fourier has quit [Changing host]
fourier has joined #lisp
beach` has joined #lisp
beach has quit [Disconnected by services]
beach` is now known as beach
<flip214>
there are S3 client libraries for CL... has someone written or started a minimal S3 server that uses the filesystem as backend?
Stanley|00 has quit [Remote host closed the connection]
orivej has joined #lisp
Stanley00 has joined #lisp
gigamonkey has joined #lisp
daphnis has quit [Ping timeout: 240 seconds]
boogsbunny has quit [Quit: Connection closed]
<engblom>
I wish to run an external command and as the command is generating lines after lines I want to use them, rather than waiting for the program to terminate before using the output. Could someone help me with this?
<phoe>
engblom: uiop:launch-program and bind the program's stdio
<splittist>
remove-if-not takes a :count
<phoe>
splittist: huh? yes, it does
<phoe>
s/stdio/stdout/
<engblom>
phoe: Thanks
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
mrchampion has quit [Ping timeout: 252 seconds]
adam4567 has quit [Remote host closed the connection]
kevingal has joined #lisp
<pjb>
flip214: IIRC, somebody has some stuff with AWS, indeed. Perhaps Zach (of quicklisp)?
mrchampion has joined #lisp
easye has quit [Remote host closed the connection]
easye has joined #lisp
xsperry has quit [Ping timeout: 240 seconds]
gigamonkey has quit [Ping timeout: 265 seconds]
zap1 is now known as zzappie
sernamar has quit [Remote host closed the connection]
raeda has quit [Remote host closed the connection]
raeda_ has joined #lisp
<pjb>
flip214: oh, you want a server. Yep, only amazon has that AFAIK.
Stanley00 has quit [Remote host closed the connection]
sabra has joined #lisp
varjag has joined #lisp
ukari has quit [Remote host closed the connection]
<engblom>
I have been also playing a bit with uiop:run-program. When called with :output :string it will return all the output, except for when the process is killed. Is it possible to get it to return everything (output + error messages) in a single string regardless of how the process ended?
xsperry has joined #lisp
ukari has joined #lisp
<engblom>
For example: (uiop:run-program "ping 1.1.1.1" :force-shell t :output :string)
<engblom>
And then when I run in a terminal "pkill ping" I do not get anything returned, instead I end up in the debugger
<phoe>
engblom: invoke the first restart
<flip214>
pjb: no, there are quite a few S3 servers - even open-source. but nothing that "just" uses an existing local filesystem.
<no-defun-allowed>
I assume someone made a joke like (deftype silly-condition () '(and condition (not serious-condition)))
<engblom>
I am trying to understand what the conscencus is from the question I answered. How would you write the full line in this example?
<scymtym>
no-defun-allowed: phoe, twice :)
rumbler31 has quit [Ping timeout: 265 seconds]
<scymtym>
btw, one has to be careful with CONTINUE in SBCL since the restart for trying again to call an undefined function is called CONTINUE instead of RETRY for historic(?) reasons
hypercube has quit [Ping timeout: 250 seconds]
<sabra>
jackdaniel: I have a question on ecl and octets (different behavior from ccl and sbcl)
<no-defun-allowed>
What should PAD-OCTET-ARRAY do if the input vector is longer than the given length? And it would not work on any array, only vectors.
<sabra>
ok. Now all I can do is laugh at myself
<beach>
no-defun-allowed: I would use an IF rather than WHEN + RETURN-FROM.
scm has joined #lisp
<no-defun-allowed>
Sure, I had expected to write a longer else-form. But REPLACE returns its first argument, so it could even be written without a LET. One moment...
<no-defun-allowed>
I updated the previous paste.
<beach>
Much better!
boogsbunny has joined #lisp
<flip214>
no-defun-allowed: now it _sometimes_ returns the original data, and sometimes a newly allocated copy... that might make a difference if the vector is mutated later on.
<Shinmera>
sabra: Did you ever get the time to look at Parachute?
<flip214>
perhaps you should return a copy?
<no-defun-allowed>
Still I don't like to nest e.g. LET in IF. I don't know why, it just does not look nice to me.
<no-defun-allowed>
flip214: Yes, and so did the original function. But you have a point.
<flip214>
and (- length (length vector)) could only be calculated once, and used with PLUSP or so in the IF
<jackdaniel>
would that make the program more readable?
<flip214>
only depends on names, which are easy, as we all know ;)
<mfiano>
What makes it jarring to me is the arguments are split up oddly. I would move the :start1 keyword arguments to a new line.
<flip214>
or perhaps better (PLUSP ...) so if (ZEROP padding-entries) the original (or a copy) is returned
<no-defun-allowed>
Okay, you all keep working on this slightly-better-than-before code I wrote, and I'll head to bed.
rodriga has joined #lisp
<sabra>
Shinmera: Just restarted that project. I need to look at the reporting objects and figure out how to output successful test results and failures to files.
<Shinmera>
sabra: Cool. Any reason for the file output desire?
<Shinmera>
if it's useful outside of the comparison project I could be convinced to add the functionality directly into it.
<sabra>
Shinmera: audit reports
<Shinmera>
I'm not sure I know what that means, really?
<sabra>
Someone wants to blame someone 6 months later. You can pull a file proving the data and test results worked at time A. So any failure now is from subsequent development.
<Shinmera>
Ah, I see. Hmm. Makes me wonder whether having metadata in git would be useful for that.
<sabra>
Lawyers or, in our case, a question of reproducibility of research results.
<Shinmera>
I suppose one could make a file report with all the detail that parachute captures being output to file.
<sabra>
I expect that to be relatively straight forward. I just want the success and failures to be separate files.
<sabra>
Of course, I just thought I could make an array and forgot to initialize it in public ;)
CrazyPython has joined #lisp
<Shinmera>
Sure.
mgsk has quit [Quit: Connection closed for inactivity]
hypercube has joined #lisp
jerme_ has quit [Quit: Connection closed for inactivity]
<engblom>
Is there any tool for tidying up lisp source code that does a bit more than just indention? With a bit more I mean splitting long lines and such.
<flip214>
engblom: (PRINT (READ))
<Shinmera>
engblom: Not to my knowledge. The syntax rules for forms are complicated and often even need user input, for indentation alone.
<jackdaniel>
wasn't that the pretty-printer purpose?
frgo has quit []
<Nilby>
Since I've been trying using the pretty-printer to indent code in an editor, without a level of tweaking that I haven't yet achived, as you may know, it's sometimes better than nothing, but usually not.
daphnis has joined #lisp
theothornhill has joined #lisp
<engblom>
(print ...) apparently also changes the case.
<jackdaniel>
once when I've used the pretty printer it complained about a syntax error, so I've called it a petty printer
madage has quit [Remote host closed the connection]
<sabra>
I think there are now 29 testing frameworks in quicklisp, not counting 2am or various helper libraries.
madage has joined #lisp
cods has quit [Ping timeout: 246 seconds]
<Xach>
sorry so few
<Xach>
i will try to add more soon
<sabra>
lol
* jackdaniel
has a local wrapper around 5am written in clim- the directory has a proud name 7am ;) but I'm not going to spoil you by publishing it!
daphnis has quit [Ping timeout: 265 seconds]
<flip214>
jackdaniel: so there'll be a few 7am libraries, all with incompatible extensions...
<jackdaniel>
there won't, because I'm not going to release such half-baked effort
<Shinmera>
sabra: you can count Parachute 4x due to its emulation layers :)
<flip214>
jackdaniel: well, how are you gonna stop me from doing my own 7am? (1+ (1+ 5am)), a.k.a. 5am++
<flip214>
rather ++5am++
<pjb>
engblom: (let ((*print-right-margin* 72)) (loop for sexp = (read source nil source) until (eq sexp source) do (pprint sexp))) ;-) but you lose comments, and some () will be printed as NIL.
<flip214>
which makes my 7am a double-plus-good (constant) verification library ;)
<pjb>
engblom: you can set *print-case* too.
<pjb>
and others…
<sabra>
pjb: Thank you
<pjb>
sabra: perhaps you want (<= size length) instead of (= size length) ; depends on whether you want an error on (> (length vector) size) or not.
<sabra>
pjb: want an error on (> (length vector) 32). Something would be wrong in that case.
<pjb>
ok. Then replace should give it, if compiled with (optimization (safety 3)).
<pjb>
but it may be better to signal your own error condition.
hypercube has quit [Ping timeout: 250 seconds]
frost-lab has quit [Quit: Connection closed]
<pjb>
sabra: errors such as Array index -8 out of bounds for #(0 … 0) . may be cryptic. Better provide a condition with an error message such: vector too long for pad-octet-vector.
ljavorsk has quit [Ping timeout: 260 seconds]
zefram22 has joined #lisp
yonkunas has joined #lisp
raeda has joined #lisp
raeda_ has quit [Ping timeout: 265 seconds]
gigamonkey has quit [Ping timeout: 246 seconds]
jeosol has joined #lisp
shka_ has quit [Quit: Konversation terminated!]
shka_ has joined #lisp
long4mud has quit [Quit: WeeChat 3.0.1]
saganman has joined #lisp
<pyc>
I am going to form a large string by appending to an existing string iteratively inside a loop. Is this a good approach from performance perspective? In other languages, I normally append to a StringBuffer or a list and then convert it to a string in the end. Do we need to do something similar in CL too?
<flip214>
pyc: you can use (with-output-to-string () ...) and allocate a big(-enough) string beforehand.
<pjb>
pyc: not really. You can use with-output-to-string that'd be the equivalent of a StringBuffer.
<pjb>
pyc: it is assumed that with-output-to-string is at least asymptotically O(n).
<pjb>
pyc: an alterlative, is to manage it yourself: collect your string in a list, then compute the total length, and copy them in a newly allocated string of the right size.
<pjb>
s/rla/rna/
<pyc>
Shinmera, flip214, pjb: Thanks! Is with-output-to-string definitely a better approach than concatenating iteratively to a string or it does not matter whether I concatenate or use with-output-to-string?
<pjb>
pyc: it is expected that it will definitely be better for long resulting strings.
wsinatra has joined #lisp
<kevingal>
Would (format nil "~{~a~}" list-of-strings) be blasphemous?
<pjb>
It would do too.
<pjb>
Probably similar to with-output-to-string.
saganman has left #lisp [#lisp]
<pjb>
pyc: note that it is dependent on the implementation too. You may want to benchmark and see what works better for your (application cl-implementation) pair.
<pjb>
pyc: notably, asymptotic behavior doesn't say anything about the constants, and that's just expectation we have on implementations. Sometimes we may have surprises… (for example, on an unrelated note, reader macros are put in a sequential list in ccl, so when you have a lot of them (say on each unicode character) it becomes very slow to read stuff).
<pjb>
We often forget that some bodies are tagbodies indeed…
brownxoat has joined #lisp
slyrus has joined #lisp
cods has joined #lisp
<pyc>
heisig: pjb: Thanks! that works great
slyrus has quit [Ping timeout: 252 seconds]
jeosol has quit [Quit: Connection closed]
theothornhill has quit [Ping timeout: 265 seconds]
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
charles` has quit [Ping timeout: 250 seconds]
pankajsg has joined #lisp
mgiraud has quit [Ping timeout: 252 seconds]
theothornhill has joined #lisp
andrei-n has joined #lisp
rumbler31 has joined #lisp
theothornhill has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Ping timeout: 268 seconds]
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
renzhi has joined #lisp
xkapastel has joined #lisp
zzappie has quit [Ping timeout: 240 seconds]
boogsbunny has quit [Ping timeout: 240 seconds]
theothornhill has joined #lisp
epony has quit [Ping timeout: 240 seconds]
klltkr has joined #lisp
<engblom>
I made a tool for tidying lisp files based upon (pprint (read)). I run it on itself and here is the result: https://pastebin.com/16QCHEw0
theothornhill has quit [Ping timeout: 245 seconds]
<engblom>
As I am new to lisp, please comment what I should have been doing differently
theseb has joined #lisp
<phoe>
you can (let ((*print-case* :downcase)) ...) instead of a SETQ
<phoe>
this way (main) will have one side effect less
<phoe>
also, (loop ... do (pprint form) (terpri)) - unnecessary progn, and an explicit newline operator
<theseb>
In SICP, authors implement eval and make a point of saying to actually INVOKE functions, you need a special form called "apply". However, in Paul Graham's "Roots of Lisp" which I've always liked he does NOT make a point of saying you need a special extra operator like apply to implement eval...why?
<phoe>
also (read in nil) is going to be buggy if the file contains a literal () (which is possible)
<heisig>
engblom: You should use some library for handling command line options, at least once your programs grow larger. Something like https://github.com/didierverna/clon
zzappie has joined #lisp
<phoe>
theseb: likely because the syntax of RoL's lisp allows for ((lambda ...) ...) style which is an implicit APPLY
<engblom>
Thanks!
<Bike>
is that an explicit apply? that doesn't seem like an explicit apply.
<heisig>
engblom: Apart from that and the use of SETQ, that's a neat little program. Welcome to Lisp, try not to get too addicted :)
<Bike>
implicit
<Bike>
bleh
<phoe>
Bike: oh wait
<Bike>
also, apply is not a special form or operator, it's a function
<phoe>
does RoL allow for functions as values?
<Bike>
not sure
<theseb>
phoe: nice....i like that better...thanks for pointing that out
<phoe>
because it doesn't seem so; that would explain the lack of APPLY
<Bike>
i don't see it in the definition of eval
<phoe>
Bike: but then, EVAL. has a case for LAMBDA
<Bike>
yeah, but just a lambda form, isn't it?
<Bike>
like it handles ((lambda ...) ...)
<phoe>
so in theory you could pass the list form of a lambda and then call eval on it
<phoe>
yes
<Bike>
i think mostly roots of lisp is a sloppy (or, more charitably, simplified) article that shouldn't be relied on for details
<phoe>
and, if a list '((lambda ...) ...) is your function call, then evaling it is the implicit APPLY I meant
Stanley00 has joined #lisp
theothornhill has joined #lisp
<theseb>
Bike: i suspect RoL made a lot if Lisp fans...I've personally been more fascinated with the RoL than I'd care to admit
<phoe>
except for one thing I guess - we need the environment
<jcowan>
You can write aa simple APPLY-EVAL pair that constitute a classical Lisp interpreter. Needless to say, few Lisps around today actually provide this.
<phoe>
eval. accepts the form to be evaluated and the environment - do we have access to it inside RoL itself?
<phoe>
because if we have that, we don't really need an application operator
<Bike>
theseb: simplicity over accuracy is helpful for that kind of article
<Bike>
if it laid out denotational semantics or something you would have slept through it
<phoe>
and since it's just Lisp data, I guess we can make a special form that returns the current environment that can then be passed to eval. again
<engblom>
I did not go for the libary for parsing arguments at this point, as this tool will probably never grow. I fixed the rest: https://pastebin.com/TuZrmfn2
CrazyPyt_ has joined #lisp
waleee-cl has joined #lisp
Stanley00 has quit [Ping timeout: 246 seconds]
<phoe>
if the only argument is just a single namestring, then simplicity's gonna work well
CrazyPython has quit [Ping timeout: 252 seconds]
theothornhill has quit [Ping timeout: 260 seconds]
<phoe>
my nitpick would be using FIRST instead of CAR but that's a nitpick
<theseb>
phoe: i know right?....i vote we bury car and cdr forever
<phoe>
also SYNTAX-ERROR is a slight misnomer because it does not really signal a CL error; maybe name it PRINT-HELP-DIALOG instead?
<phoe>
theseb: actually when you have stuff like ((1 . 2) . 3) I'd be scared to use first/rest on it
<phoe>
first/rest kinda imply that the structure being operated on is a proper list
<theseb>
phoe: i also think lists should be vectors
<phoe>
whereas car/cdr don't
<phoe>
theseb: begone, heretic
<theseb>
phoe: and never expose the cons side of things
<theseb>
phoe: heh
<phoe>
:D
<shka_>
theseb: lol
<Bike>
lists being vectors makes some kinds of processing more annoying
<phoe>
well, clojure sort of went this way
<phoe>
but that's already ##lisp material
<pjb>
theseb: APPLY is not a special operator, it's a primitive function. FUNCALL can be implemented calling APPLY but the reverse cannot be.
<engblom>
pjb: Thank you very much!
<pjb>
engblom: cf *print-right-margin*
<pjb>
engblom: and yes, since they are global variables, you don't want to mess with the code in the other threads, or to mutate them for the rest of the REPL session. So use LET.
<theseb>
pjb: wow....i was assuming primitive function == special form == special operator....didn't know people here distinguished between those terms
jeosol has joined #lisp
<phoe>
theseb: people, d'oh
<phoe>
even CL recognizes it
<phoe>
(special-operator-p 'cl:apply) ;=> NIL
theruran has quit [Quit: Connection closed for inactivity]
<phoe>
but, yeah, the fact that some CL operators are functions does not mean that they can be expressed in terms of anything else
<pjb>
theseb: (if (= a b) 'yep 'nope) is a special form. IF is the special operator. APPLY is a "primitive" function in that it cannot be implemented in lisp without using metalinguistic abstraction. In the case of Common Lisp, all the functions in CL can be open-coded, which means they could be considered like special operators in a way. But special operators are a more specific set of 37 operators in CL. Note that macros in CL ca
<pjb>
implemented as special operators technically, but the implementation still has to provide an equivalent macro for users of MACROEXPAND.
<phoe>
APPLY is a prime example of that
heisig has quit [Quit: Leaving]
qewr has joined #lisp
<Bike>
"special operator" means an operator with special evaluation semantics. apply has the same evaluation semantics as any other function: in (apply a b), a and b are forms to be evaluated. so it's not special.
<pjb>
in any case, that doesn't mean that you cannot implement everything in CL. It's just that there's one level of metalinguistic abstraction required (ie. a compiler or an interpreter).
<pjb>
Don't worry, it's just a cosmic ray flipping a bit in my memory.
<_death>
(hamming 25 37) => 4 ;)
shka_ has quit [Quit: Konversation terminated!]
zefram22 has quit [Quit: zefram22]
zefram22 has joined #lisp
<jcowan>
Vectors are just lists with mutable cars and immutable cdrs. :-)
theothornhill has joined #lisp
hjudt has joined #lisp
<pjb>
adjust-array
shka_ has joined #lisp
theothornhill has quit [Ping timeout: 252 seconds]
Alfr has quit [Quit: Leaving]
zefram22 has quit [Ping timeout: 260 seconds]
theothornhill has joined #lisp
rumbler31 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
kmeow has joined #lisp
rumbler31 has quit [Remote host closed the connection]
choegusung has joined #lisp
kmeow has quit [Remote host closed the connection]
zefram22 has joined #lisp
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
srhm has joined #lisp
imode has joined #lisp
theothornhill has joined #lisp
epony has joined #lisp
rumbler31 has quit [Remote host closed the connection]
theothornhill has quit [Ping timeout: 252 seconds]
<jcowan>
okay, okay, simple vectors.
theseb has quit [Quit: Leaving]
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 268 seconds]
choegusung has quit [Quit: leaving]
Josh_2 has joined #lisp
daphnis has quit [Ping timeout: 252 seconds]
<Josh_2>
Good afternoon
theothornhill has joined #lisp
Nilby has quit [Ping timeout: 245 seconds]
cage_ has joined #lisp
<Josh_2>
I tell you sometimes I end up baffled that I didn't know I could do certain things
<Josh_2>
I'm sat here thinking I wonder if there is a destructuring-plist, turns out you can just destructure a plist using &key ...
theothornhill has quit [Ping timeout: 260 seconds]
attila_lendvai has joined #lisp
tophullyte has joined #lisp
<Bike>
http://ix.io/3cvy here is how i would do a roots of lisp thing. makes the difference between a special operator and built in function clearer. would be more involved to make it self hosting, though
mindCrime_ has joined #lisp
amerigo has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
epony has quit [Ping timeout: 240 seconds]
theothornhill has joined #lisp
fjMSX has quit [Quit: EXIT]
DHARMAKAYA has joined #lisp
theothornhill has quit [Ping timeout: 260 seconds]
hypercube has joined #lisp
rodriga has quit [Read error: Connection reset by peer]
rodriga has joined #lisp
jeosol has quit [Quit: Connection closed]
Sheilong has joined #lisp
theothornhill has joined #lisp
jmiven has quit [Quit: reboot]
jmiven has joined #lisp
theothornhill has quit [Ping timeout: 252 seconds]
<pjb>
pyc: note how concatenate-string is faster when you have more than between 50000 and 100000 strings to concatenate. (may also depend on the length of the strings).
<pjb>
pyc: but when you have 100 strings, with-output-string is faster (in ccl);
<pjb>
pyc: but when you have about 1000 strings, apply-concat is faster (in ccl, and given that call-arguments-limit #| --> 65536 |# );
theothornhill has quit [Ping timeout: 240 seconds]
pbgc has joined #lisp
raeda_ has joined #lisp
raeda has quit [Ping timeout: 252 seconds]
ukari has quit [Remote host closed the connection]
hendursa1 has quit [Ping timeout: 240 seconds]
mindCrime_ has quit [Ping timeout: 268 seconds]
<copec>
speaking of destructuring plists, a snip from the project I'm working on Josh_2 https://unaen.org/pb/1ym
<copec>
I wonder if there is a better way to do uri->string
<phoe>
can't destructuring-bind with &key help here?
<Josh_2>
well from what I just learned you can use (destructuring-bind (&key <your keys> &allow-other-keys) <your plist> <body>) to destructure a plist
<phoe>
yes, that's what I was thinking of
theothornhill has joined #lisp
<copec>
perhaps if I just make uri a plist
<Josh_2>
plists are great :D
theothornhill has quit [Ping timeout: 265 seconds]
<phoe>
plists are the last step before defclass/defstruct
attila_lendvai has quit [Ping timeout: 252 seconds]
mathrick has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
srandon111 has quit [Quit: leaving]
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
theothornhill has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
theothornhill has quit [Ping timeout: 246 seconds]
gigamonkey has joined #lisp
pankajsg has quit [Ping timeout: 245 seconds]
<jackdaniel>
hash tables are the last step because they always preserve identity
theothornhill has joined #lisp
theothornhill has quit [Read error: Connection reset by peer]
theothornhill has joined #lisp
theothornhill has quit [Read error: Connection reset by peer]
attila_lendvai has quit [Read error: Connection reset by peer]
theothornhill has joined #lisp
yottabyte has joined #lisp
attila_lendvai has joined #lisp
theothornhill has quit [Remote host closed the connection]
theothornhill has joined #lisp
zefram22 has quit [Ping timeout: 260 seconds]
<flip214>
copec: do you know the puri and quri libraries?
ukari has quit [Remote host closed the connection]
mht has joined #lisp
ukari has joined #lisp
theothornhill has quit [Ping timeout: 265 seconds]
Inline has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
theothornhill has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
<pjb>
About SBCL 2.1.3, I wonder why I get "Control stack exhausted during signal emulation: PC: 52077ee2" crashes, when call-arguments-limit is 4611686018427387903 ?
<moon-child>
possibly substitute '(unsigned-byte 8) for 'unsigned-byte
<Xach>
moon-child: yeah, UNSIGNED-BYTE is unlikely to be useful, as it upgrades to T
<moon-child>
right
<Xach>
opcode: #(...) will not produce the specialized array you need.
notzmv has quit [Ping timeout: 260 seconds]
<lotuseater>
ha yes thought the same ^^ just like with 'STRING
<opcode>
k. i find the docs very dense, but perhaps that's just because I have no formal CS training :/
raeda_ has quit [Remote host closed the connection]
raeda_ has joined #lisp
<opcode>
appreciate the help
<lotuseater>
opcode: i think that's one thing that is left to the implementation
<Xach>
opcode: i think ironclad is probably most useful if you already know generally how the algorithms are set up and used and you just need a reference for use
<Xach>
i don't always know how to give it what it wants, and i've used it a lot
<opcode>
yeah it's very, uh, particular about how it wants inputs haha
<opcode>
not just ironclad's docs though... the hyperspec itself is pretty dense
<opcode>
i read portions of it and I feel like it's not even english
<moon-child>
standards documents are frequently like that. You have to learn to read standardese ;)
<Xach>
i find the hyperspec to be a fantastic reference, but it helps that i've spent a long time getting used to how it presents info.
<Xach>
there are nice documents that are more tutorialistic
bilegeek has quit [Quit: Leaving]
emacsomancer has quit [Read error: Connection reset by peer]
loskutak has quit [Ping timeout: 252 seconds]
varjag has quit [Ping timeout: 252 seconds]
yonkunas has quit [Quit: Connection closed for inactivity]
random-nick has quit [Ping timeout: 246 seconds]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
emacsomancer has joined #lisp
<copec>
It is fantastic after you get it :-P If I don't understanding something, it's like it falls on deaf ears until I already understand it
Adamclisi has quit [Ping timeout: 246 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
Adamclisi has joined #lisp
remby has joined #lisp
CrazyPyt_ has joined #lisp
CrazyPython has quit [Ping timeout: 252 seconds]
dhil has quit [Ping timeout: 265 seconds]
luckless_ has quit [Ping timeout: 240 seconds]
luckless_ has joined #lisp
epony has joined #lisp
imode has quit [Quit: WeeChat 3.1]
mindCrime_ has joined #lisp
xy__ has joined #lisp
pbgc has quit [Quit: Computer has gone to sleep.]
xy__ has quit [Read error: Connection reset by peer]
<Josh_2>
Has anyone here used #0A before?
<Josh_2>
zero dimensional arrays
<White_Flame>
only briefly to test out some weird identities
<ebrasca>
Is there a way to compile the faster version of some fuction in compile time?
<Josh_2>
a compiler macro?
<moon-child>
Josh_2: in apl, a scalar is a 0-dimensional array
<ebrasca>
If you have multiple versions of some funtion for diferent cpu architectures.
<White_Flame>
I made a (defmacro fast-body (&body body) ...) which just wraps the body in a locally declare optimize
<White_Flame>
wrap that around a defun
<ebrasca>
Or if you have hardware sopport or not.
<White_Flame>
ah, yeah that sounds like a compiler macro
<ebrasca>
How can you make sure the bens algorith is chosen?
<ebrasca>
bens->best
<White_Flame>
I don't understand the situation. Where are the algorithms listed?
<Josh_2>
maybe you could use #.<some hardware feature> <my compiler macro for that hardware>
<Josh_2>
wait sorry #+ not #.
<White_Flame>
If you have multiple versions for different architectures, there will probably be #+ based compilation or file inclusion somewhere to select between them
Adamclisi has quit [Ping timeout: 240 seconds]
<White_Flame>
so only 1 version is probably in existence? the other thing affecting it would be optimization declarations
<White_Flame>
s/in existence/manifested/
acolarh has quit [Ping timeout: 240 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
<ebrasca>
I am just implementing CRC in CL. Probably overthinknig it.
xy__ has joined #lisp
Adamclisi has joined #lisp
xy__ has quit [Remote host closed the connection]
amerigo has quit [Quit: Connection closed for inactivity]