yonkunas has quit [Quit: Connection closed for inactivity]
cosimone has quit [Ping timeout: 264 seconds]
cosimone_ is now known as cosimone
dbotton has joined #lisp
ghard has quit [Ping timeout: 264 seconds]
igemnace has joined #lisp
ghard has joined #lisp
joethecodhr_ has joined #lisp
wsinatra has joined #lisp
joethecodhr has quit [Ping timeout: 256 seconds]
deltab has quit [Ping timeout: 256 seconds]
joethecodhr_ has quit [Remote host closed the connection]
joethecodhr_ has joined #lisp
ikrabbe|2 has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
ikrabbe has quit [Ping timeout: 246 seconds]
joethecodhr_ has quit [Remote host closed the connection]
joethecodhr_ has joined #lisp
joethecodhr_ has quit [Remote host closed the connection]
ebrasca has quit [Read error: Connection reset by peer]
joethecodhr_ has joined #lisp
matijja has quit [Quit: bye]
joethecodhr has joined #lisp
joethecodhr has quit [Remote host closed the connection]
joethecodhr_ has quit [Ping timeout: 240 seconds]
joethecodhr has joined #lisp
deltab has joined #lisp
joethecodhr has quit [Remote host closed the connection]
ghard has joined #lisp
fubbiquantz has joined #lisp
ghard has quit [Ping timeout: 264 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Josh_2 has quit [Remote host closed the connection]
ghard has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
ralt has quit [Quit: Connection closed for inactivity]
nij has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
nij has left #lisp [#lisp]
dbotton has joined #lisp
<White_Flame>
is there any reason that opening with :direction :output :if-exists :append should fail with a file-does-not-exist error?
<White_Flame>
the default for if-does-not-exists should be :create on :output
<White_Flame>
it works if the if-exists is not specified
<White_Flame>
s/not-exists/not-exist/
jeosol has joined #lisp
ghard has joined #lisp
dbotton has quit [Quit: Leaving]
ghard has quit [Ping timeout: 264 seconds]
<Nilby>
White_Flame: The logic is a bit convoluted, but I guess that if you specify you want append, it creating it isn't considered the same a appending. It's semi-arbitrary the way lisp file operations correspond to unix.
<Nilby>
I think thankfully most implementations have chosen a consistent way.
<pillton>
White_Flame: "The default is :error if direction is :input or if-exists is :overwrite or :append;"
<White_Flame>
pillton: ah, so it is. missed that
<White_Flame>
thanks
<pillton>
np
ghard has joined #lisp
ebrasca has joined #lisp
judson_ has quit [Read error: Connection reset by peer]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
srandon111 has quit [Quit: leaving]
vaporatorius has quit [Ping timeout: 272 seconds]
Nilby has quit [Remote host closed the connection]
enzuru has quit [Ping timeout: 272 seconds]
Nilby has joined #lisp
ghard has joined #lisp
ikrabbe has joined #lisp
Nilby has quit [Ping timeout: 272 seconds]
ikrabbe|2 has quit [Ping timeout: 264 seconds]
ghard has quit [Ping timeout: 264 seconds]
fubbiquantz has quit [Ping timeout: 246 seconds]
enzuru has joined #lisp
ghard has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
charles` has joined #lisp
<charles`>
Hi everyone
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
ghard has joined #lisp
cosimone has quit [Quit: cosimone]
<charles`>
Are there compiler hooks other than *macroexpand-hook*?
wsinatra has quit [Quit: WeeChat 3.0.1]
<Bike>
there are various ways to get the compiler to run things. what do you have in mind?
ghard has quit [Ping timeout: 264 seconds]
X-Scale has quit [Ping timeout: 256 seconds]
<charles`>
I'm not completely sure, I'm just exploring. Maybe something like *macroexpand-hook* but for every form
<Bike>
that doesn't exist, no.
Lord_of_Life_ has joined #lisp
abhixec has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 240 seconds]
<charles`>
Is it reasonable to assume that IF is implemented using COND?
<Bike>
no.
Lord_of_Life_ is now known as Lord_of_Life
<Bike>
usually it's the other way around, even.
semz has quit [Ping timeout: 260 seconds]
<charles`>
oh, I see. Is there any conditional that doesn't come down to IF?
<Bike>
depends on the implementation
ghard has joined #lisp
<charles`>
Do you have an example? I can't think of what the reasoning be would be
toorevitimirp has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
ikrabbe|2 has joined #lisp
ikrabbe has quit [Ping timeout: 272 seconds]
ghard has joined #lisp
<Bike>
sometimes CASE might be so the implementation can do a jump table or whatever other optimized multiway branch
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
ghard has quit [Ping timeout: 264 seconds]
mrcom has quit [Ping timeout: 265 seconds]
<charles`>
genius
<Bike>
of course whether things are defined in terms of IF shouldn't really matter to the programmer very much if ever
<charles`>
in sbcl at least case->cond->if. Matters not to the programmer, but it could matter to the compiler hacker
ghard has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
mathrick has quit [Ping timeout: 265 seconds]
mathrick has joined #lisp
mister_m has quit [Ping timeout: 264 seconds]
mrcom has joined #lisp
karlosz has joined #lisp
ebrasca has quit [Remote host closed the connection]
prxq_ has joined #lisp
ghard has joined #lisp
prxq has quit [Ping timeout: 246 seconds]
Sheilong has quit []
mathrick has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
ghard has quit [Ping timeout: 260 seconds]
contrapunctus has joined #lisp
Alloc has joined #lisp
Alloc has quit [Remote host closed the connection]
ghard has joined #lisp
ghard has quit [Ping timeout: 264 seconds]
tsrt^ has joined #lisp
ghard has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
Alfr_ has joined #lisp
<beach>
Good morning everyone!
Alfr has quit [Ping timeout: 260 seconds]
ghard has joined #lisp
<charles`>
Hi beach
ghard has quit [Ping timeout: 260 seconds]
<charles`>
What are you up to?
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
<beach>
Me? Working on SICL and the paper to submit to ELS.
<beach>
What about you?
<charles`>
I'm exploring derived types in hopes of enjoying compile type invariant checking even beyond rust or kotlin. What is ELS?
<beach>
European Lisp Symposium.
<beach>
The only Lisp conference in the world that is not dead.
perrier-jouet has quit [Quit: WeeChat 3.0]
<charles`>
I'll have to join in this year
<beach>
Good idea.
<beach>
Next year, let's hope we can meet for real again.
<charles`>
except I live on the other side of the pond
<beach>
You are still welcome to attend. We have regular participants from the US, Japan, etc.
<charles`>
That would be quite the adventure
ghard has joined #lisp
<charles`>
types for functions can be defined with (declaim (ftype, but it isn't required by conforming implementations right?
zxq2 has joined #lisp
<beach>
A conforming implementation must accept such a proclamation.
<zxq2>
what's the most widely used dialect of lisp in the industry?
<charles`>
but it isn't required to have them for each function in common-lisp package
<charles`>
wait, lisp is used in industry?
ghard has quit [Ping timeout: 264 seconds]
<beach>
zxq2: There is no consensus about the definition of "Lisp", so that's hard to answer.
<beach>
zxq2: If you consider Clojure to be a Lisp dialect, then that's probably the one that is most widely used.
<zxq2>
hmm.. okay
<beach>
zxq2: But it's also off topic. This channel is about Common Lisp.
mathrick has joined #lisp
<zxq2>
what do you use common lisp for?
<beach>
Me? Implementing Common Lisp.
<charles`>
mainly web development
<charles`>
and fun
<zxq2>
do you think in order to become an effective lisp programmer, you need more of a grasp of theoretical CS, than say the other, imperative languages?
<beach>
No.
<beach>
zxq2: Common Lisp is an imperative language as well.
<beach>
Multi-paradigm to be precise.
<zxq2>
is it not primarily functional?
<beach>
No.
<beach>
In fact, the evaluation model of Common Lisp is simpler than that of C, and WAY simpler than that of C++.
<zxq2>
yeah C++ is a mess
<charles`>
I personally try to write my common lisp in functional style
<beach>
Common Lisp uses what I call "uniform reference semantics", which is the only sane way of programming. It means that the objects you manipulate behave as if they are actually references to a chunk of memory. C is much more complicated in that you sometime use pointers, sometimes copy the objects, etc.
<beach>
A programming language without automatic memory management can't really use that sane semantic model, so such a language is necessarily more complicated.
<zxq2>
to modify my above, it seems like someone with knowledge of lisp has more insight into PL theory. do you agree?
<zxq2>
*my above question
pankajsg has joined #lisp
<beach>
People who program in Common Lisp seem to be more knowledgeable than people who don't program in Common Lisp. But that doesn't mean that it is a requirement in order to program in Common Lisp.
<beach>
I think it has to do with the kind of people who are likely to pick up a language that is not mainstream.
<beach>
It takes some courage to invest time in a language that is not as popular as the mainstream languages. Programmers of mainstream languages in their surroundings may even ridicule them for doing so.
ghard has joined #lisp
<zxq2>
i'm trying to understand the practical benefits and motivations for learning lisp or its dervitaves. it seems like with knowledge of these languages comes a deeper insight into programming langs in general.
<beach>
That might very well be true.
<beach>
But Common Lisp is also a great programming tool, so you don't have to look much further than that.
<beach>
Common Lisp has several excellent implementations, many of which generate code that is comparable in speed to that of C.
* beach
now fully expects "But isn't Common Lisp an interpreted programming language?" And no, there is no such thing.
<zxq2>
have you studied lambda calculus?
<beach>
Me? Yes.
ikrabbe has joined #lisp
ghard has quit [Ping timeout: 260 seconds]
<zxq2>
amazing that all of computation can come from such a simple formalism
<beach>
Apparently, Conway's game of life is Turing complete.
heisig has joined #lisp
<zxq2>
wasn't McCarthy influenced by the l. calc when developing lisp?
<charles`>
How would I declaim an ftype with &rest &option or &key
<zxq2>
and there is a difference betwen interpreted and compiled langs, no? your belief is that the former do compilation at run-time?
<beach>
There is no such thing as an interpreted or compiled programming language.
<beach>
It is a quality of the implementation.
<beach>
Any language can be implemented with either technique, more or less well, of course.
cchristiansen has joined #lisp
<beach>
Most modern Common Lisp implementations compile on the fly. Non JIT, but the REPL compiles the form and then executes it.
<beach>
zxq2: The "danger" of using "interpreted programming language" is that people then assume that every implementation of that language is slow. And they would be right if it were the case that the language had to be implemented using an interpreter. But no language requires that.
<beach>
zxq2: And people without sufficient knowledge of programming-language implementation techniques might assume that an interactive language like Common Lisp is necessarily interpreted, so they incorrectly assume that such a language is slow.
<beach>
charles`: Did you check the page on the FUNCTION system class? The answer is there.
<charles`>
Yes thank you beach, this is certainly the page I was looking for.
<beach>
moon-child: Hence my "more or less well, of course".
ghard has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
<moon-child>
beach: insofar as a compiler is just a mapping between two sets of formal semantics, sure. But that doesn't mean that you performed a meaningful transformation
<contrapunctus>
So I had SLIME autodoc working fine when I was working locally, but for some reason I don't see it anymore when I'm working with a remote Lisp...any ideas? 🤔
<beach>
charles`: Functions are not required to have a proclaimed type, so no.
<Bike>
recalloc:
ghard has joined #lisp
Bike has quit [Quit: sleeping]
<charles`>
I suppose really what I mean was: for every function (in cl package) could there exist a type declaration that would work across implementation
<recalloc>
Awesome, thanks!
<beach>
charles`: That's not necessarily true I think. Implementations are sometimes allowed to add stuff like keyword arguments.
ghard has quit [Ping timeout: 264 seconds]
<charles`>
&allow-other-keys?
toorevitimirp has quit [Ping timeout: 240 seconds]
<beach>
That might work. I am not so good with type declarations.
<charles`>
part of my goal is to allow people to get the benefits of type declarations without having to write them
toorevitimirp has joined #lisp
<charles`>
Thanks for the heads up about allowing other keys. Now to comb through the spec and write type declarations for every function...
<beach>
Sure, that would be a good library.
<charles`>
a big hurdle in the future will be function hoisting in compile file
<beach>
I don't understand what that means.
<charles`>
if you do COMPILE-FILE the order of the functions doesn't matter. It won't warn you about undefined functions as long as they are defined in that file.
<beach>
So what's the hurdle?
<charles`>
If I'm working on the level of DEFUN those other functions aren't defined yet, thus how can I possibly know their types. I could find their definitions in the file being compiled, but that is as far as I want to think about it right now
toorevitimirp has quit [Ping timeout: 240 seconds]
ghard has joined #lisp
toorevitimirp has joined #lisp
<recalloc>
Hmm, that's weird. Quicklisp can't find my local package, and if I eval the .asd manually, SBCL cries that it can't find the compiled .fasl.
<beach>
Did you try (ql:register-local-projects)?
ghard has quit [Ping timeout: 260 seconds]
<charles`>
You're package is in quicklisp/local-projects/ right?
<recalloc>
Huh, that works. Thanks
<recalloc>
Yeah it's in local-projects.
toorevitimirp has quit [Ping timeout: 246 seconds]
texno has joined #lisp
<charles`>
strangely enough, I have never needed to use register-local-projects
<beach>
Apparently it is not needed unless you have symbolic links.
<beach>
... which is what I have.
<recalloc>
I never needed to use it, either.. until now. I don't have symlinks in my sources.
<recalloc>
I remember there being a function which allowed me to copy one vector *into* another vector. Completely lost the name of it, though
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<lukego>
Hey is there an easy way to get Emacs/SLIME to keyword-fontify serapaem defining macros like `defconst' ?
<lukego>
(Or rather, is there a canonical way that other people do it, or should I just hack Emacs font-lock-keywords?)
Cymew has joined #lisp
ralt has joined #lisp
gaqwas has quit [Ping timeout: 256 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
orivej has joined #lisp
<theothornhill>
You could extend cl-font-lock-built-in-mode?
<splittist>
I would like to use a Docker container to build an executable from a lisp project. There are many fine lisp images, but what's the best way to give the container access to the local projects (i.e. the components not in quicklisp) that are needed to create that executable?
Oddity- has quit [Read error: Connection reset by peer]
<splittist>
(new keyboard). lukego: that seemed the obvious way, so I assumed it was wrong (:
<lukego>
new keyboard! I remember seeing your old one, it looked like the best one available on the market ;-)
sbryant has joined #lisp
<lukego>
Maybe `-v` isn't ideal really since that's more of a runtime rather than build-time thing. If you want `docker build` to do the whole job then maybe that doesn't work. I guess you could have your Dockerfile COPY stuff into the same location instead?
<lukego>
disclaimer: I've used Docker for various things but usually just cutting through the shortest path without necessarily knowing what is correct..
<splittist>
I sort of have this feeling I should be copying the local projects and letting quicklisp pull things into the container. Particularly since I have a locally-patched version of some things to make them work on my Windows dev machine and the container will be linux, of course.
aartaka has joined #lisp
<lukego>
That makes sense to me but take that with a grain of salt :)
<Xach>
unless your goal is to test ongoing compatibility, that is
<splittist>
I think I'd call that 'homework mode'
<splittist>
My problem is that the executable is to use in a non-lisp project (<gasp!>), and I was hoping to use a multi-stage dockerfile to build the executable then COPY -from=lisp-building-container-thingy etc. But dockerfiles can't pick up context outside their root.
<splittist>
(I'm mangling the terminology, sorry.) So either I (a) copy the relevant local-projects into the non-lisp project; (b) develop them under this non-lisp project (but some of the lisp projects are general libraries, not limited to this use case); or (c) create my own quicklisp distribution ???
aartaka has joined #lisp
<Xach>
you don't need a distribution if you just want to get some code. it could be a tarball that you fetch and unpack.
<splittist>
OK. (It's just annoying that the files are sitting there in a sibling directory and I have to do something outside the dockerfile to get at them. I understand the reasons, but... I think I'm thinking about this the wrong way.)
mister_m has joined #lisp
Bike has joined #lisp
galex-713 has joined #lisp
jonatack has joined #lisp
rogersm has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
ukari has quit [Remote host closed the connection]
<Xach>
every time you fetch quicklisp stuff in a CI pipeline it costs me a picodollar
<jackdaniel>
(loop (vroom :clean t))
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<flip214>
Xach: during the next real-world ELS I can offer you a nanoeuro
<jackdaniel>
or a nanocrown in some countries, and the crown is trendy lately
igemnace has quit [Remote host closed the connection]
albusp has quit [Ping timeout: 256 seconds]
albusp has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<Xach>
μbles?
ljavorsk has joined #lisp
random-nick has joined #lisp
<shka_>
Xach: good one
hjudt has joined #lisp
OlCe has quit [Remote host closed the connection]
nij has joined #lisp
jonatack has quit [Ping timeout: 240 seconds]
aeth has quit [Ping timeout: 264 seconds]
cage_ has joined #lisp
jonatack has joined #lisp
aeth has joined #lisp
phantomics_ has joined #lisp
phantomics has quit [Ping timeout: 265 seconds]
phantomics__ has joined #lisp
phantomics_ has quit [Ping timeout: 256 seconds]
flazh has quit [Quit: flazh]
flazh has joined #lisp
vaporatorius has joined #lisp
ljavorsk has quit [Remote host closed the connection]
ljavorsk has joined #lisp
orivej has joined #lisp
yonkunas has joined #lisp
valerianka has joined #lisp
srandon111 has joined #lisp
valerianka has quit [Client Quit]
lisp-machine has joined #lisp
pfdietz has joined #lisp
Nilby has quit [Ping timeout: 264 seconds]
<edgar-rft>
with a nonocrown you're nanoking! welcome to your nanokingdom
charles` has joined #lisp
tsrt^ has quit []
sjl has joined #lisp
dbotton has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
<dbotton>
Working now on "thick" bindings with clog now - Working api for desktop environment in and now adding dialogs etc :)
hjudt has quit [Ping timeout: 272 seconds]
<mfiano>
Congratulations on all the positive feedback on CLOG and your hard work learning CL
<splittist>
So my solution is to create the lisp-builder with executable image separately. Only my dump-exe.lisp script, which runs fine from outside the container, and fine from inside the container, does not run from a RUN command in the Dockerfile.
sauvin_ has quit [Remote host closed the connection]
sauvin has joined #lisp
waleee-cl has joined #lisp
zaquest has quit [Remote host closed the connection]
alandipert has quit [Quit: Ping timeout (120 seconds)]
alandipert has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
<dbotton>
mfiano thanks!
ldbeth has joined #lisp
sjl has quit [Quit: WeeChat 2.3-dev]
<ldbeth>
good midnight
* ldbeth
lol
dbotton has quit [Quit: This computer has gone to sleep]
sjl has joined #lisp
<flip214>
Is there an equivalent of CHECK-TYPE that evaluates the type? So that I can pass in expected array sizes?
<jackdaniel>
flip214: (assert (typep)) ?
<flip214>
Like (check-type input `(array fixnum (,size ,size)))
ldbeth has quit [Ping timeout: 246 seconds]
<jackdaniel>
you can't do it at runtime, that's the point of check-type
<jmercouris>
you can do type-of
<jackdaniel>
jmercouris: and what of it?
<jmercouris>
you could do it
<flip214>
jackdaniel: well, I want to tell the compiler that the used indizes _must_ be in the array, so no bounds checks are necessary in a loop
dbotton has joined #lisp
<jmercouris>
type-of object => typespec
<jmercouris>
compare if it matches your expectations... at run time
<jackdaniel>
flip214: ah
<jmercouris>
also you are a tomato
<jmercouris>
sorry, wrong channel
<jackdaniel>
flip214: all I can think of is typecase with known sizes put in there and a generic otherwise clause
imode has joined #lisp
<scymtym>
flip214: do you want the code to still be safe? if not, (locally (declare (optimize (sb-c::insert-array-bounds-checks 0))) …) would be one (non-portable) option
<jmercouris>
I don't understand this error message
<flip214>
scymtym: I'd like to still be safe... OTOH, if I check the input types beforehand, the arithmetic can't go wrong - so SAFETY 0 might be acceptable
<jmercouris>
(INTERN (SYMBOL-NAME INTERFACE) (PACKAGE-NAME (SYMBOL-PACKAGE INTERFACE))) is not a string designator.
<jackdaniel>
jmercouris: the first argument to define-user-class is not evaluated
<jmercouris>
do I have to evaluate it or something
<jmercouris>
ah damnit I was just about to say something like that
zaquest has joined #lisp
<jmercouris>
OK, so how should I rewrite this?
<flip214>
well, I've got an (ASSERT (TYPEP input `(array fixnum (,size ,size)))) and (DOTIMES (i (1- size)) (DOTIMES (j (1- size)) ...))
<scymtym>
i for one am glad that we /can/ do something like that if needed
luni has quit [Quit: Connection closed]
Nilby has joined #lisp
<contrapunctus>
Anyone know why SLIME autodoc might work correctly for a local image, but stop working over SSH?
ldbeth has joined #lisp
<prxq>
contrapunctus: paths
<jackdaniel>
maybe it tries to find locally the file?
<prxq>
contrapunctus: what exactly do you mean 'over SSH'? You log in via SSH remotely? Or are u using swank?
<flip214>
scymtym: well, I'd like to tell the compiler that the array is a specific size; and DOTIMES won't go over the limit (that should be known already)
<flip214>
jackdaniel: I got some similar stuff working with sbcl already
<flip214>
just right now I'm too dumb, I believe
<Bike>
yeah i'm not sure if sbcl can actually track that kind of dependent type
<Bike>
also, you have it as an array rather than a simple-array
<Bike>
that might screw up doing any optimization whatsoever
ldbeth has joined #lisp
<Nilby>
yes, my experience is that you ususally need a simple-array to get the fast path
ukari has joined #lisp
<Nilby>
although I guess, like the case in the paste, sometimes it's obvious it's not displaces, fill-pointered, or adjusted
<Bike>
i don't see anything in the paste that would force M to be a simple array
ldbeth has quit [Ping timeout: 256 seconds]
bilegeek has joined #lisp
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
supercoven has quit [Max SendQ exceeded]
supercoven has joined #lisp
skapata has joined #lisp
sauvin has quit [Remote host closed the connection]
jonatack has quit [Read error: Connection reset by peer]
* Nilby
fell down an asm diffing rabbit hole
euandreh has quit [Ping timeout: 256 seconds]
<contrapunctus>
prxq, jackdaniel: thanks, it was indeed missing path translation config! ^^
sauvin has joined #lisp
euandreh has joined #lisp
charles` has joined #lisp
jeosol has quit [Ping timeout: 240 seconds]
euandreh has quit [Ping timeout: 260 seconds]
jonatack has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
euandreh has joined #lisp
X-Scale has joined #lisp
aeth has quit [Ping timeout: 265 seconds]
aeth has joined #lisp
hiroaki has joined #lisp
ljavorsk has quit [Ping timeout: 256 seconds]
jonatack has quit [Ping timeout: 256 seconds]
rogersm_ has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` is now known as X-Scale
cosimone has quit [Quit: cosimone]
galex-713 has quit [Ping timeout: 265 seconds]
galex-713 has joined #lisp
rogersm_ has quit []
<scymtym>
flip214: as bike said, to generate optimized array accesses, SBCL must infer the simpleness of the array, the array element type (even if t) and the array dimensions. i'm certain that it can't do that based on a dynamically constructed TYPEP assertion. however, if you write something like (dotimes (i (array-dimension a 0)) …), SBCL can infer a constraint between I and A so that accesses in the body will not require a bounds
dbotton has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
dbotton has joined #lisp
amb007 has joined #lisp
<flip214>
ah, with (DECLARE (TYPE (SIMPLE-ARRAY... ))) it looks better
aeth has joined #lisp
<scymtym>
flip214: 1) what is MATRIX? 2) as i said, i don't think the (assert (typep …)) with a dynamically constructed type specifier allows inferring anything
akoana has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<scymtym>
also, speed 3 with safety 0 will elide the bounds irregardless of type inference and constraints
amb007 has joined #lisp
<scymtym>
(compile nil (lambda () …)) (as opposed to (compile nil '(lambda () …))) does not usually compile
jonatack has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
jonatack has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
CrazyPython has joined #lisp
jonatack has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
dbotton has quit [Read error: Connection reset by peer]
dbotton has joined #lisp
dra has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
sauvin has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
dbotton has quit [Read error: Connection reset by peer]
<jmercouris>
Nilby: still within that package... I don't know, it seems like I could accidentally cause all sorts of havoc
<prxq>
jmercouris: why do you do it this way? Why not subclass?
<jmercouris>
I guess I could get rid of the find-if and use the one loop until I have a result I like
<jmercouris>
prxq: it's a long story, do not worry about that part
Jesin has quit [Quit: Leaving]
<jmercouris>
there is a very good reason for it
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<jmercouris>
a user-class is a macro generated subclass, you can still use normal subclasses
<prxq>
okay, I can relate to that long-story situation :-)
dddddd_ has quit [Ping timeout: 256 seconds]
nij has quit [Remote host closed the connection]
contrapunctus has joined #lisp
surabax has quit [Quit: Leaving]
hendursa1 has quit [Quit: hendursa1]
<Nilby>
jmercouris: Perhaps you could just do the intern in a :key in the find-if and just do one make-instance wrapping the find-if ? That is if you don't mean to make all the interfaces instances as a side-effect.
hendursaga has joined #lisp
attila_lendvai_ has quit [Ping timeout: 240 seconds]
<jmercouris>
hm, that's true
dddddd_ has joined #lisp
<jmercouris>
that is possible
Jesin has joined #lisp
<jmercouris>
I think you mean the object creation in the key
dra has quit [Remote host closed the connection]
dbotton_ has joined #lisp
shka_ has quit [Ping timeout: 264 seconds]
madage has joined #lisp
dddddd__ has quit [Ping timeout: 256 seconds]
<pve>
Hey, I'm trying to get an intuition for how replacing a call to a generic function with a call to a closure in a loop will affect performance. Will this test land me in the right ballpark?