<beach>
yates: LET takes a list of bindings as its first argument.
<aeth>
Implementations only must support character (string), base-char (base-string), and bit... they will all support (unsigned-byte 8) which is called an "octet" in practice. Most will also support signed-bytes for 8, and signed/unsigned for 16, 32, fixnum and 64 if they're 64-bit implementations. All major implementations except CLISP will support single-float and double-float, too. Beyond that, most will
<aeth>
either round (if an unusual byte size) or be a T array (i.e. store anything, and not space efficiently beyond the normal fixnum/etc. optimization)
<aeth>
an "unsigned fixnum" in this context is just one bit less than a fixnum, since the fixnum is always signed.
<aeth>
so e.g. if the fixnum is a (signed-byte 61) then they may also support an (unsigned-byte 60) array.
<yates>
beach: +1
NicknameJohn has quit [Ping timeout: 255 seconds]
<beach>
yates: In Common Lisp, doing something like that would be a performance optimization, and you would do that only after careful profiling to determine that this code is the one causing the problem, and after being convinced that the code is not fast enough.
<beach>
Oh, and only after being absolutely sure that you will never ever want to store anything else in that vector.
<beach>
So you could say that statically typed languages kind of force you from the start to guess what part of the code needs optimization, because they force you to determine the representation of your objects just in order to compile.
molson has joined #commonlisp
molson_ has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
Inline has quit [Ping timeout: 252 seconds]
molson has quit [Read error: Connection reset by peer]
retropikzel has joined #commonlisp
molson has joined #commonlisp
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
Lycurgus has quit [Quit: leaving]
ronald_ has quit [Ping timeout: 256 seconds]
Aesth has joined #commonlisp
ronald has joined #commonlisp
molson_ has joined #commonlisp
molson has quit [Read error: Connection reset by peer]
elderK has joined #commonlisp
dra has joined #commonlisp
igemnace has joined #commonlisp
notzmv has quit [Ping timeout: 268 seconds]
amb007 has joined #commonlisp
igemnace has quit [Remote host closed the connection]
dcb has quit [Quit: Connection closed for inactivity]
rainthree has joined #commonlisp
shka has joined #commonlisp
igemnace has joined #commonlisp
igemnace has quit [Remote host closed the connection]
kenanb has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
dnhester26 has joined #commonlisp
random-jellyfish has joined #commonlisp
scymtym has quit [Quit: Application exit]
dnhester26 has quit [Remote host closed the connection]
dino_tutter has joined #commonlisp
random-jellyfish has quit [Quit: Leaving]
olnw has joined #commonlisp
olnw has left #commonlisp [#commonlisp]
_cymew_ has joined #commonlisp
Gleefre has quit [Remote host closed the connection]
donleo has joined #commonlisp
scymtym has joined #commonlisp
makomo has joined #commonlisp
pve has joined #commonlisp
glaucon has joined #commonlisp
notzmv has joined #commonlisp
random-jellyfish has joined #commonlisp
<random-jellyfish>
when I try to start sly I get this error: Error running timer: (void-function set-up-sly-ac)
<random-jellyfish>
what could be the cause
Inline has joined #commonlisp
_cymew_ has quit [Ping timeout: 264 seconds]
easye has quit [Remote host closed the connection]
amb007 has quit [Remote host closed the connection]
amb007 has joined #commonlisp
easye has joined #commonlisp
tertek has quit [Quit: %quit%]
tertek has joined #commonlisp
dra has quit [Ping timeout: 246 seconds]
rainthree has quit [Ping timeout: 255 seconds]
mgl has joined #commonlisp
rendar has joined #commonlisp
mgl has quit [Ping timeout: 246 seconds]
Aesth has quit [Read error: Connection reset by peer]
dinomug has quit [Remote host closed the connection]
<beach>
seok: I am betting all of them fail on some functions like closures.
<seok>
hmm
<seok>
what is the point of having function-lambda-expression as part of the standard when it allows implementations to return nil on any function?
<beach>
I think one reason is so that you couldn't get the source code of all of ACL or LispWorks.
<beach>
Well, that didn't answer your question, did it?
<beach>
Let me try again: I don't think there is much point to that function.
<seok>
eh, I don't see how it protects the source code of commercial implementations. the lambda lists are exposed in documentations so the user can use the function
<beach>
The name of the function is FUNCTION-LAMBDA-EXPRESSION, not FUNCTION-LAMBDA-LIST.
<beach>
So if it always worked, unless the implementation has first-class global environments, you could get the source code of the entire system.
NicknameJohn has joined #commonlisp
decweb has joined #commonlisp
elderK has quit [Quit: Connection closed for inactivity]
<seok>
I see that one would be able to peek into the lambda expressions of internal functions, but how would one peek into the function's body with universally working function-lambda-expression?
<beach>
FUNCTION-LAMBDA-EXPRESSION returns a lambda expression that represents the entire function, including the body.
<seok>
ah, indeed it does. lambda-expression not lambda-list
<beach>
I think I said that a few times.
<seok>
You did, but I did not understand lambda expression means the whole function definition
<seok>
I see it now, my mistake
<beach>
OK.
<seok>
I was only interested in the lambda list containing the parameters
<beach>
I agree with you that there is no reason why a function named FUNCTION-LAMBDA-LIST does not exist.
<seok>
as a matter of fact, it exists in lispworks,
<beach>
I am pretty sure it exists in almost every implementation.
<beach>
But what I meant was that three is no particular reason why a function named FUNCTION-LAMBDA-LIST does not exist in the standard. As opposed to FUNCTION-LAMBDA-EXPRESSION for which I could see a reason.
<beach>
s/three/there/
<beach>
*sigh*
<seok>
I agree
<seok>
it seems like a function that would be useful on many occasions
<seok>
I could not find function-lambda-list in sbcl, unless it is obscured inside one of its extended packages
<seok>
it works in lispworks though
mgl has joined #commonlisp
glaucon has quit [Ping timeout: 245 seconds]
Kyuvi has quit [Ping timeout: 250 seconds]
<beach>
Did you try (apropos "function-lambda-list") in SBCL?
<beach>
I get SB-INTROSPECT:FUNCTION-LAMBDA-LIST (fbound)
* beach
now fully expects a rant about how the standard needs to be rewritten.
thuna` has quit [Ping timeout: 255 seconds]
<yitzi>
Rants are acceptable as long they pipe into /dev/null
<beach>
With some occasional exceptions, yes.
jon_atack has joined #commonlisp
jonatack has quit [Ping timeout: 256 seconds]
<yitzi>
Heh. Of course.
Aesth has joined #commonlisp
jla has joined #commonlisp
mgl has quit [Ping timeout: 246 seconds]
jla has quit [Client Quit]
random-jellyfish has quit [Ping timeout: 268 seconds]
epony has quit [Quit: QUIT]
random-jellyfish has joined #commonlisp
Lycurgus has joined #commonlisp
Lycurgus has quit [Changing host]
Lycurgus has joined #commonlisp
dnhester26 has joined #commonlisp
mgl has joined #commonlisp
skyl4rk has joined #commonlisp
dino_tutter has quit [Ping timeout: 264 seconds]
AetherWind has joined #commonlisp
NicknameJohn has joined #commonlisp
tyson2 has joined #commonlisp
Aesth has quit [Read error: Connection reset by peer]
Kyuvi has joined #commonlisp
random-jellyfish has quit [Ping timeout: 255 seconds]
rtypo has joined #commonlisp
_cymew_ has joined #commonlisp
NicknameJohn has quit [Ping timeout: 264 seconds]
random-jellyfish has joined #commonlisp
dtman34 has quit [Quit: ZNC 1.8.2+deb3.1 - https://znc.in]
dtman34 has joined #commonlisp
mgl has quit [Ping timeout: 268 seconds]
Aesth has joined #commonlisp
Aesth has quit [Read error: Connection reset by peer]
lucasta has quit [Quit: Leaving]
monospod has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
kenanb has quit [Remote host closed the connection]
dra has joined #commonlisp
prokhor has joined #commonlisp
prokhor_ has quit [Ping timeout: 252 seconds]
<yates>
beach: something like what?
<beach>
yates: Defining a vector of (unsigned-int 32).
<yates>
why?
<beach>
Why would you immediately restrict the kind of objects that your vector can contain?
<yates>
if i want to obtain a fector of a specific type for a specific purpose, that is a functional requirement, not a performance requirement.
<yates>
s/fector/vector/
<beach>
In a statically typed language it is.
<beach>
yates: In Common Lisp, there are only a few possible specialized vectors. You can't define a vector of (say) people or factories. You will still get a vector that can hold anything.
igemnace has joined #commonlisp
<yates>
you and i must think in different ways.
<beach>
yates: So there is no great point in defining a vector of (unsigned-byte 32) unless you 1. know that the implementation has a specialized vector type like that and 2. You do it for reasons of performance.
<yates>
the point is in knowing/defining what i am dealing with.
<beach>
yates: I am telling you something about Common Lisp here. If you define a vector (say) like this (defparameter *v* (make-array 234 :element-type 'person)), you can still do (setf (aref *v* 10) "hello")
<beach>
yates: It seems your way of thinking is related to statically typed languages.
<aeth>
as a rule of thumb, element-type in general only works on basic numeric and character types.
<yates>
no argument there. but i want to do this for my own organization, so that i know the things in this vector are of a certain type.
olnw has joined #commonlisp
<yates>
there == telling me something about...
<beach>
yates: But I am telling you that in general you can't know that.
<yates>
i can semantically
<aeth>
It really does depend on the problem space, though. If you're doing linear algebra or something of course you want to separate your ([un]signed-byte 32)s and single-floats and double-floats or whatever.
dnhester26 has joined #commonlisp
<yates>
if i NAME a vector a certain thing, i know it's that type.
<beach>
yates: But you can do that by storing in the vector objects that you know the type of.
<aeth>
beach: on the other hand, you can just dispatch in an ETYPECASE if you really do want to create a bunch of numeric vectors. Or, say, convert if you're serializing.
<aeth>
so it really depends on if yates wants a fully OOP any-arbitrary-class array (which will disappoint) or just numbers
<aeth>
any-arbitrary-class-and-only-that-class
<aeth>
do we know what yates wants yet
<beach>
Maybe we are about to find out.
<aeth>
because e.g. I am doing (unsigned-byte 32) arrays right now... because that's SPIR-V so of course it needs to be in that format
<aeth>
but to just store some numbers, not needed
<aeth>
unless those "store some numbers" are matrices in which case, again, maybe needed again
<yates>
here is an example: let's say i'm reading in a file of linear, PCM digital samples which are signed, 32-bit.
<beach>
aeth It looked to me like yates was generalizing from my example. What was asked for was a vector of (unsigned-byte 32) but I fear that this was just an example and that an attempt would be made to generalize to arbitrary types.
<yates>
in this application (i.e., a signal processing algorithm), the bit width is important.
<beach>
yates: I am sorry to bring you bad news then. The Common Lisp standard does not require a vector of that type to exist.
<yates>
then perhaps this is the wrong language for my application
<beach>
Maybe so. But I am wondering, why do you care how your samples are stored if you get them back the exact way you put them in?
<yates>
because, for example, adding 1 to (2^31-1) should give you -2^31
<aeth>
yates: in Common Lisp, when you want to overflow/underflow, you do it explicitly
dnhester26 has quit [Remote host closed the connection]
<beach>
yates: It sounds like you want all the pain and all the limitations of a statically typed language with fixed bit width for integers. Then Common Lisp is not for you.
<aeth>
yates: the fun part is that at any point you can disassemble to see if it's actually optimizing like you want
<aeth>
and you can just have a little abstraction with macros and/or inline functions to make sure integers stay in the bounds you want
<aeth>
though it's easier with floats because they don't have to worry about overflow/underflow
<aeth>
Technically all implementations have disassemble, but not every implementation is going to optimize it and not every implementation is going to even expose a meaningful result to disassemble.
<aeth>
But you write it in a high-level and portable way and future implementations (or current implementations that don't do it) can make the same optimizations in the future
<aeth>
Though if you use 64-bit types in a 64-bit implementation, you either have to stay within the function scope or you have to box them into specialized arrays or else they will heap allocate (e.g. double-float, or integers sizes larger than the fixnum size but smaller than 64-bits, such as (unsigned-byte 63) and (unsigned-byte 64))
tibfulv has quit [Remote host closed the connection]
Kyuvi has quit [Ping timeout: 250 seconds]
tibfulv has joined #commonlisp
tibfulv has quit [Remote host closed the connection]
<aeth>
yates: The idea behind this is that arithmetic does what you intuitively expect by default like ,(/ 4 3) or ,(* (expt 2 64) 2)
<aeth>
But you can still generate efficient asm (if the compiler does so) if you request it and know what you're doing (and you can hide any boilerplate with macros or inline functions).
<beach>
aeth: I think perhaps yates has already decided against Common Lisp.
<yates>
that is correct
<yates>
thanks for all the help
yates has left #commonlisp [rcirc on GNU Emacs 29.1]
dino_tutter has joined #commonlisp
<aeth>
I guess yates doesn't understand macros
<aeth>
If you must interoperate with C, you can cut a huge chunk of that boilerplate down with some light macros and DEFTYPEs as e.g. (define-function foo ((x uint32)) ...)
<beach>
Again, I think yates really likes all the pain and all the limitations of a statically typed language with fixed-width integers and wrap-around arithmetic.
<beach>
Perhaps "likes" is the wrong word. Maybe "is so used to ..., that it seems normal"
<pfdietz>
integers being integers is one of the nice things of Common Lisp. It makes my testing so much easier.
<beach>
And the code itself too, because you don't have to check every arithmetic operation for sanity.
monospod has quit [Remote host closed the connection]
<beach>
I mean, the people who use languages with fixed-width integers don't check either, but they should.
Kyuvi has joined #commonlisp
khrbtxyz has quit [Ping timeout: 260 seconds]
<aeth>
usually you just assume you'll never overflow/underflow so it doesn't seem too weird to actually explicitly write that behavior (once, and then abstract it) if you actually need it
<aeth>
I live all day with bits of various widths and I'm fine with that, in fact better than when using an optimizing C compiler where any safeguard I add can safely be optimized away in the name of performance and in abuse of "undefined behavior". Plus, DISASSEMBLE tells me exactly what I need it to when I want it to.
<aeth>
Plus, I only need to do this when I need to, not throughout the whole program.
khrbtxyz has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
<aeth>
I'm actually strongly considering how to abuse the GPU into getting me overflow-into-bignum integers (-:
dnhester26 has joined #commonlisp
dnhester26 has quit [Remote host closed the connection]
<aeth>
If you don't care about performance, the real big problem with making your own bignums are when you get into SQRT, EXP, EXPT, etc.
<aeth>
And I'm assuming the GPU only makes this sort of thing worse.
Kyuvi has quit [Ping timeout: 250 seconds]
Aesth has joined #commonlisp
attila_lendvai has joined #commonlisp
dnhester26 has joined #commonlisp
lucasta has joined #commonlisp
Kyuvi has joined #commonlisp
davidt has joined #commonlisp
domovod has joined #commonlisp
Alfr has quit [Ping timeout: 256 seconds]
tyson2 has quit [Remote host closed the connection]
earl-ducaine_ has joined #commonlisp
justIrresolute is now known as justache
epony has joined #commonlisp
cage has joined #commonlisp
randm has quit [Remote host closed the connection]
randm has joined #commonlisp
skyl4rk has quit [Ping timeout: 252 seconds]
domovod has quit [Quit: WeeChat 4.1.2]
_cymew_ has quit [Ping timeout: 246 seconds]
davidt has quit [Quit: ERC 5.5.0.29.1 (IRC client for GNU Emacs 29.1)]
<NotThatRPG>
Query: I am seeing this style-warning from (I think) compiling and then loading a `defmacro` form (in random-state): redefining RANDOM-STATE:DEFINE-GENERATOR in DEFMACRO --- any idea why that happens? I don't think I always get this warning when loading a system with defmacro forms...
varjag has joined #commonlisp
rainthree has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]