acolarh has quit [Read error: Connection reset by peer]
acolarh has joined #lisp
robotoad has joined #lisp
FreeBirdLjj has joined #lisp
rumbler31 has quit [Remote host closed the connection]
k4rtik has joined #lisp
Kundry_W_ has quit [Quit: Leaving...]
Kundry_Wag has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
JuanDaugherty has quit [Quit: Exeunt]
<beach>
Good morning everyone!
anewuser has joined #lisp
Guest995` has joined #lisp
Guest9950 has quit [Ping timeout: 256 seconds]
iridioid has joined #lisp
smasta has quit [Ping timeout: 240 seconds]
<theemacsshibe[m]>
hi beach
skapata has quit [Remote host closed the connection]
k4rtik has quit [Ping timeout: 244 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
nickenchuggets has quit [Quit: Leaving]
k4rtik has joined #lisp
pierpa has quit [Quit: Page closed]
gabiruh has quit [Ping timeout: 244 seconds]
Guest995` has quit [Remote host closed the connection]
buffergn0me has joined #lisp
Guest995` has joined #lisp
FreeBirdLjj has quit [Ping timeout: 265 seconds]
vtomole has joined #lisp
jack_rabbit has joined #lisp
brettgilio has joined #lisp
vaporatorius has quit [Ping timeout: 240 seconds]
EvW1 has joined #lisp
Guest995` has quit [Remote host closed the connection]
Guest995` has joined #lisp
k4rtik has quit [Quit: WeeChat 2.1]
shka_ has joined #lisp
MoziM has quit [Ping timeout: 240 seconds]
bjorkintosh has quit [Quit: Leaving]
MoziM has joined #lisp
Kundry_Wag has quit [Quit: Leaving...]
fikka has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
Guest995` has quit [Read error: Connection reset by peer]
jasmith has joined #lisp
Guest995` has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
Pixel_Outlaw has quit [Remote host closed the connection]
myrkraverk has quit [Remote host closed the connection]
isospin has joined #lisp
AetherWind has joined #lisp
Guest995` has quit [Ping timeout: 256 seconds]
Inline has quit [Quit: Leaving]
brettgilio has quit [Ping timeout: 240 seconds]
Guest995` has joined #lisp
Lord_Nightmare has quit [Ping timeout: 240 seconds]
graphene has quit [Remote host closed the connection]
Lord_Nightmare has joined #lisp
graphene has joined #lisp
Guest995` has quit [Ping timeout: 256 seconds]
mindCrime_ has quit [Ping timeout: 240 seconds]
mindCrime_ has joined #lisp
brettgilio has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
caltelt has quit [Ping timeout: 244 seconds]
<beach>
A new version of the specification of the SICL memory allocator is now available in case someone feels like reviewing it: http://metamodular.com/allocator.pdf
igemnace has joined #lisp
FreeBirdLjj has joined #lisp
terpri has joined #lisp
anewuser has quit [Quit: anewuser]
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
FreeBirdLjj has quit [Ping timeout: 268 seconds]
omilu has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 240 seconds]
Bike has quit [Quit: Lost terminal]
MinnowTaur has quit [Remote host closed the connection]
MinnowTaur has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
karswell has quit [Read error: Connection reset by peer]
fikka has joined #lisp
karswell has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
vtomole has quit [Ping timeout: 252 seconds]
daniel-s has joined #lisp
wewewe has joined #lisp
faraco has joined #lisp
faraco has quit [Client Quit]
buffergn0me has quit [Ping timeout: 240 seconds]
faraco has joined #lisp
faraco has quit [Changing host]
faraco has joined #lisp
<wewewe>
hmm
faraco has quit [Client Quit]
wewewe has quit [Client Quit]
<stacksmith>
beach: looks good!
<beach>
Thanks!
<beach>
It works too it seems. :)
<stacksmith>
That's even better than just looking good.
<beach>
I agree.
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
nickenchuggets has joined #lisp
shifty has joined #lisp
nickenchuggets has quit [Quit: Leaving]
brettgilio has quit [Remote host closed the connection]
flamebeard has joined #lisp
Smokitch has joined #lisp
froggey has quit [Ping timeout: 244 seconds]
vlatkoB has joined #lisp
shrdlu68 has joined #lisp
iridioid has quit [Ping timeout: 244 seconds]
mange has quit [Remote host closed the connection]
<beach>
shrdlu68: I think that book has some very deep insight. It is quite hard to read though, so I am taking my time. But it has already given me some interesting understanding of some parts of society that concern me.
karswell has quit [Remote host closed the connection]
karswell has joined #lisp
<LdBeth>
Good afternoon
<beach>
Hello LdBeth.
<beach>
shrdlu68: I don't know whether the author is going to mention it, but it occurred to me right away that commercial software development is an inadequate equilibrium, which is why free software is often able to do "better" in terms of some quality metric.
quazimodo has joined #lisp
<shrdlu68>
beach: Indeed, the book made me appreciate how powerful behavioral economics is at creating useful models of complex systems.
<beach>
I can see that.
FreeBirdLjj has joined #lisp
<TMA>
shrdlu68: beach: which book are you talking about? I am unable to find it in logs
graphene has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
cage_ has quit [Remote host closed the connection]
<fe[nl]ix>
Xach: 3-0 ?
cage_ has joined #lisp
graphene has joined #lisp
Khisanth has quit [Ping timeout: 264 seconds]
jibanes has quit [Ping timeout: 265 seconds]
jibanes has joined #lisp
fikka has joined #lisp
surya has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Khisanth has joined #lisp
* Xach
sold a physical object today that was created in part by a lisp program
<Josh_2>
was it from a cad program?
brettgilio has joined #lisp
vap1 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
vaporatorius has joined #lisp
<jasom>
beach: read the allocator description; looks like a reasonably sane malloc implementation. The only "gotcha" I see is if that some allocation patterns could generate very large bins.
<jasom>
of course if those allocation patterns are unlikely in real-world code it's probably a non-issue.
<beach>
jasom: Thanks. By "big" I presume you mean "with many chunks in them"?
<jasom>
beach: correct
fikka has joined #lisp
<beach>
I don't know. But this technique is from Doug Lea and it is known to be the best one around.
surya has quit [Ping timeout: 240 seconds]
<Xach>
Josh_2: No, it was a sign. The design and layout was done in lisp (including parsing curves out of the font file) and a lisp program emitted a vector file for a vinyl cutter.
<beach>
jasom: Plus, I will catch many short-lived objects in the nursery. Objects that get promoted to this heap are likely to be long lived.
<Xach>
(The font was a unique one I commissioned from a font designer, but that part wasn't lisp)
k4rtik has joined #lisp
k4rtik has joined #lisp
k4rtik has quit [Changing host]
<jasom>
Right, but real world mallocs are ultimately about heuristics; if you have linear probing of unbounded length linked lists, there is the potential for slow performance, so it's all about choosing an algorithm where that is unlikely to happen.
<beach>
jasom: I think it is virtually impossible to judge an an allocator or a GC from the looks of it. So I intend to put in "meters" in the code. The size of bins would be an obvious candidate.
<beach>
jasom: Sure, I agree.
Kundry_Wag has joined #lisp
<beach>
jasom: I just don't have any data either way to give a straight answer.
<beach>
jasom: I can say this though...
<jasom>
also be aware that malloc implementations are limited by their API; all you get is a pointer which means that you need to store the metadata next to the data. There are some allocation patterns for which this is highly suboptimal so I've seen C code with non-malloc allocators for just this reason.
<beach>
jasom: If there are big bins like that, it means that the chunks could not be coerced with others. And Paul Wilson's result makes that very unlikely.
fikka has quit [Ping timeout: 265 seconds]
<jasom>
beach: I believe that
<beach>
jasom: Yes, I totally agree with everything you say. Again, I am counting on the nursery collectors to filter the problematic stuff.
<jasom>
excellent!
<beach>
This is even more true since the nursery collectors use a sliding GC algorithm, so that the relative age of objects that are promoted is very precisely known.
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<beach>
So objects that are promoted together in the global heap are very likely used by the same point in the application. I did not include this optimization in my description, but it is described by Doug Lea: if no perfect fit is found, then the previous big block is reused again, so that objects stay together.
<jasom>
The worst fragmentation I ever saw was with a real-time allocator that was disallowed any unbounded iteration, so it never moved allocations up in bins, just down...
<beach>
Er, what does "up" and "down" mean here?
<jasom>
in size category
<beach>
So it only ever split existing chunks. Never coalesced?
<jasom>
small chunks were binned, large chunks were traditional malloc.
<jasom>
correct.
skapata has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
How is that related to disallowing unbounded iteration? Oh, because reusing blocks would make it unable to bound the time?
fikka has joined #lisp
<jasom>
right it would either require significant space overhead for a non-in-place store of blocks for a bin, or it would have to walk a list like yours does, neither of which was acceptible
<beach>
Got it. Nasty case indeed.
<jasom>
then someone with a non-embedded background decided to allocate a bunch of temporary stuff in a C++ std::list early on in the program, and suddenly no large allocations were possible :(
<beach>
Heh!
fikka has quit [Ping timeout: 264 seconds]
FreeBirdLjj has joined #lisp
pjb has joined #lisp
nowhereman_ has quit [Ping timeout: 268 seconds]
thuffir has joined #lisp
<Josh_2>
Xach what's the sign for?
<Xach>
Josh_2: it's a decoration, it replicates a style of town line sign that is unique to Maine, and slowly being replaced with generic signs as the old ones wear out.
<Xach>
mainetownline.com is a lisp-powered website to make them as graphics
iridioid has quit [Ping timeout: 256 seconds]
vap1 has quit [Quit: Leaving]
DingoSaar has joined #lisp
<Josh_2>
idk if my internet is being slow but that site took a while to load
<Xach>
It's in montreal and not part of a CDN or anything.
<beach>
Josh_2: Lisp is slow. Everyone knows that.
<Josh_2>
was faster using drakma, so am gonna assume it was my browser
<Josh_2>
yes, real slow, like a snail
thuffir has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
hhdave_ has quit [Ping timeout: 240 seconds]
iridioid has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
mindCrime has quit [Ping timeout: 264 seconds]
orivej has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
<sjl_>
fast here, NY VPNed to SF
pagnol has joined #lisp
ntqz has quit []
fikka has quit [Ping timeout: 248 seconds]
<Josh_2>
sat here wondering why I can't connec to my hunchentoot site, turns out I had 127.0.0.1/4242 instead of 127.0.0.1:4242 Q_Q
DingoSaar has quit [Ping timeout: 256 seconds]
<stacksmith>
Good morning. Could someone clarify: what namespace are slot names in?
nowhereman_ has joined #lisp
thuffir has joined #lisp
<dlowe>
slot names are symbols. They can be in any package.
<dlowe>
amusingly, slot initargs can also be in any package - they aren't limited to the keyword package.
Smokitch has joined #lisp
<dlowe>
I've seen a reasonable article that we should be using non-keyword initargs to prevent collision between different users of a class
<Bike>
if you mean "namespace" like how variable and function bindings are separated, they're not in a global namespace. they're particular to the class.
<stacksmith>
dlowe: yeah, by namespace I mean function/var/type etc.
<akkad>
clos is pretty damn bad, as it makes all the other oo models feel insufficient imho
kuwze has quit [Ping timeout: 252 seconds]
<stacksmith>
Is there a place in CLHS or elsewhere that lists the separate binding spaces? I've counted 7 but would love to see an authoritative list...
fikka has joined #lisp
<dlowe>
stacksmith: maybe it doesn't matter that much.
<jasom>
stacksmith: I'm pretty sure there isn't anything in the spec; google "lisp-n" for lists other people have come up with
<dlowe>
lisp-1 vs lisp-2 was an interesting implementation question. This lisp-n business is just useless pedanticism.
<dlowe>
Now, I appreciate useless pedanticism as much as any nerd, but we've been hammering that this for 30 years and it's time to find some new jokes.
shka_ has joined #lisp
<jasom>
also are we talking only about things with symbol names, or do packages count too?
m00natic has quit [Remote host closed the connection]
<stacksmith>
Not asking just to start an argument - I am happy with whatever n is. I actually need to know (I think) to analyze source for my project. Just knowing the symbol is not sufficient - I need to know what kind of a binding is implied, and where the binding takes place...
<Bike>
another measure is introspection tools. sbcl's interface to swank has sixteen forms of global definition that aren't sbcl specific
<Bike>
some of them overlap namespace, like defmacro and defun
<dlowe>
I can make my own namespace by just making a hash table and populating it with symbol keys
fikka has quit [Ping timeout: 244 seconds]
<stacksmith>
Bike: could you point me to the said sbcl's swank interface? Do you mean the implementation-specific files in the swank project?
<Bike>
i do.
<Bike>
specifically, the variable *definition-types*
<Bike>
oh, and you sorta need another namespace for struct definitions that aren't classes.
graphene has quit [Remote host closed the connection]
<jasom>
I think that only variable, function/macro/operators, declarations and tagbody tags are lexically scoped, but I might be wrong.
<stacksmith>
Bike: functions, macros, compiler macros and setf expanders seem to share a 'namespace'...
<Bike>
functions and macros do
<Bike>
the other two are separate
<Bike>
as in, you can have a compiler macro and a function with the same name.
graphene has joined #lisp
<stacksmith>
Bike: ah.
<jasom>
and if you define a setf expander than the (setf foo) function is ignored
<Bike>
the clhs page on lexical environments includes blocks also, but that's pretty much the same as tagbody tags
<jasom>
totally forgot about blocks, those are part of it too
<stacksmith>
tags and blocks are strictly lexical and have no global meaning, correct?
<dlowe>
slots also have no global meaning
<Bike>
there are no global blocks or tags, no.
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
<stacksmith>
Are restarts in a separate space?
JuanDaugherty has quit [Remote host closed the connection]
jdz has quit [Ping timeout: 256 seconds]
jdz has joined #lisp
<Bike>
they're not lexical
graphene has quit [Remote host closed the connection]
lumm has quit [Ping timeout: 256 seconds]
graphene has joined #lisp
acolarh has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
xuxuru has joined #lisp
graphene has quit [Read error: Connection reset by peer]
igemnace has quit [Remote host closed the connection]
<stacksmith>
Bike: right, but is the dynamic binding separate from other bindings for that symbol?
<dlowe>
stacksmith: yes, they're separate
graphene has joined #lisp
<stacksmith>
I am now up to 10. 1) var/symbol-macros 2)fun/macro 3)compiler-macro 4)setf expander 5)classes/types 6)restarts 7)method combinations 8)declarations 9)tags 10)blocks
fikka has quit [Ping timeout: 240 seconds]
JuanDaugherty has joined #lisp
<stacksmith>
and packages.
<Bike>
why are you conflating lexical and global bindings?
mathrick has quit [Ping timeout: 276 seconds]
lumm has joined #lisp
<stacksmith>
Bike: looking at source, it does not seem to matter. depending on context, some symbols require a lexical 'search' for the binding site and if not found, have a global meaning. Others are lexical-only - like tags. And slots names come from classes. I think.
mathrick has joined #lisp
<Bike>
matter to what?
<jasom>
Bike: he's writing a static analyzer
fikka has joined #lisp
acolarh has joined #lisp
ebrasca has quit [Read error: No route to host]
ebrasca has joined #lisp
<stacksmith>
I was trying to use the sbcl walker but it seems to skip some parts of source, and does not provide information about _where_ the bindings actually take place.
<Bike>
i'm not sure what you mean by "where".
<Bike>
it's not like lexical bindings have to "occur" somehow at runtime.
Kundry_Wag has quit [Remote host closed the connection]
<stacksmith>
In some situations, like refactoring names, you want to identify the origination of names.
fikka has quit [Ping timeout: 256 seconds]
lumm has quit [Ping timeout: 240 seconds]
thuffir has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
thuffir has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<stacksmith>
The location of the lexical binding site in source affects the meaning of symbols with that name in the subtree of the source. Knowing the namespace of a reference is important - you dont want to rename a tag with the same name as a lexical variable, for instance. Or a global variable. Hence the conflation of global and lexical bindings.
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
skapata has joined #lisp
shrdlu68 has quit [Ping timeout: 276 seconds]
lumm has joined #lisp
<stacksmith>
Is there a lexical form of setf-expander?
Folkol has quit [Read error: Connection reset by peer]
Folkol has joined #lisp
<stacksmith>
CLHS says "If a define-setf-expander form appears as a top level form, ..." which seems to imply that it may be used inside a definition, but the scoping is not clear...
nowhereman_ has quit [Ping timeout: 256 seconds]
<Bike>
it's global.
<Bike>
pretty much every global defining form has a clause like that.
<Bike>
that said, lexical function bindings affect setf bindings
fikka has joined #lisp
brettgilio has quit [Remote host closed the connection]
<stacksmith>
Bike: what does it mean if the form is not a top level form? I am confused. Could you elaborate on how lexical function bindings affect setf bindings?
thuffir has quit [Ping timeout: 248 seconds]
<Bike>
are you asking what being a "top level form" means?
lumm has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 268 seconds]
iridioid has quit [Ping timeout: 240 seconds]
thuffir has joined #lisp
rpg has joined #lisp
<stacksmith>
Yikes. Call me dense, but what the heck happens if a defining macro is inside another definition? It appears that there are no compile-time effects for that form (or the rest of the file), but at some later time - like the next file?
<jasom>
stacksmith: defmacro says exactly what happens if it's not a toplevel form.
<jasom>
the compiler need not store the definition of it, so strange things can happen. Ultimately just don't do that
milanj has quit [Quit: This computer has gone to sleep]
<stacksmith>
jasom: it says what happens if it is a toplevel form, but not if it is not...
<jasom>
stacksmith: then the compiler doesn't have to stor, but it could if it wanted to
<jasom>
stacksmith: from a practical point of view, your analysis tool could be free to reject code with non-toplevel defmacros
<stacksmith>
jasom: is there a reason the spec doesn't just say that defining macros _should_ be toplevel? Is there a situation where it is useful otherwise, or would be problematic if so stipulated?
<jasom>
non-toplevel DEFUNs have some uses (e.g. a defun inside a let), but I'm strugging to think of any use for a non-toplevel defmacro
fikka has joined #lisp
xuxuru has quit [Quit: xuxuru]
Kundry_Wag has quit [Remote host closed the connection]
<Bike>
stacksmith: if it's not toplevel it doesn't have the effects described if it's toplevel, namely, being done at compile time. the same as any other form, its effects will occur when it's executed. so if it's in a function body, the global macro binding will be made when the function is called and control reaches the defmacro form.
Kundry_Wag has joined #lisp
cage_ has quit [Remote host closed the connection]
al-damiri has quit [Quit: Connection closed for inactivity]
<stacksmith>
Bike: thanks.
fikka has quit [Ping timeout: 256 seconds]
<Bike>
but no, you don't usually want to do that.
Kundry_W_ has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
dddddd has joined #lisp
fikka has joined #lisp
<stacksmith>
Usually you don't macroexpand at runtime, I suppose. But binding a global function at runtime is valid, isn't it? CLHS states that there are no compile-time side effects for defun and the definition is not even available. So a defun deep inside another function body will get compiled with the surrounding function but bound when the surrounding function is executed, correct?
<stacksmith>
I mean when the inner defun is reached, of course, not just the surrounding function.
fikka has quit [Ping timeout: 240 seconds]
<jasom>
there are limitations to redefining functions though, related to the rules of when it is permissible to inline
<jasom>
but yes, (funcall 'foo) (defun foo () ...) (funcall 'foo) ;; <-- the second funcall will get the new definition of foo
<jasom>
and this is true regardless of whether or not it happens at the toplevel
<jasom>
you can also (setf (fdefinition foo) ...) though
Kundry_W_ has quit [Remote host closed the connection]
<jasom>
using defun inside a function definition is IMO less idiomatic
<jasom>
you provably cannot do a lot of useful static analysis on unrestricted CL code, so you'll need to determine a subset you are going to work with
brettgilio has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
pfdietz has joined #lisp
nowhereman_ has joined #lisp
<stacksmith>
Ideally I would restrict the subset to thing actually defined by the standard, but sometimes it's a little hard to figure out as I am only an egg.
milanj has joined #lisp
DingoSaar has joined #lisp
random-nick has quit [Ping timeout: 256 seconds]
<stacksmith>
jasom: I am assuming modern compilers know that you are fiddling with a global function binding, whether it's by setfing fdefinitions or defunning inside a function body, and compile an indirect call. It seems in some cases you can make it impossible to figure out, which should also default the compile to a runtime-safe behaviour. But is there a CLHS restriction of where defun may be located, if not at toplevel?
iridioid has joined #lisp
<stacksmith>
Or is it just 'undefined behaviour'?
k4rtik has quit [Ping timeout: 265 seconds]
k4rtik has joined #lisp
fikka has joined #lisp
<Bike>
there's no restriction on where defuns go. there doesn't need to be
<Bike>
there are restrictions on how redefinitions take effect, is all
fikka has quit [Ping timeout: 240 seconds]
k4rtik has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
<stacksmith>
I truly appreciate the help of all who answered.
Kundry_Wag has quit [Remote host closed the connection]
<stacksmith>
Is there a static analysis library for CL? I haven't found much - and I can see why...
<pfdietz>
Not that I know of. Macros could be a problem.
<stacksmith>
There are more problems than I ever imagined. A walker almost does the trick, but the walkers I've seen do not correlate source forms to walked forms or provide adequate hooks to definitively walk a form and identify every subform.
fikka has joined #lisp
karlosz has quit [Quit: karlosz]
<pfdietz>
A source object can occur more than once in a form, so any such linkage would require some representation of the path down to the objecr.
fikka has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
xrash has joined #lisp
<stacksmith>
Ideally, the walker would literally walk the source tree with a callback on every cons, providing environmental info and data about the car. I don't care about macroexpansions other than the side-effects such as new bindings, etc.
<stacksmith>
But no. Apparently I am unique in this desire.
JuanDaugherty has quit [Quit: Exeunt]
<stacksmith>
One would think in the last 60 years or so someone - anyone - would want something like that.
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
fikka has joined #lisp
pfdietz has quit [Read error: Connection reset by peer]
iridioid has quit [Ping timeout: 240 seconds]
iridioid has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
thuffir has quit [Ping timeout: 240 seconds]
<jasom>
walkers usually don't walk trees, they walk already read-in forms.
<jasom>
Someone (beach?) has done some work for representation of lisp source code.
Kundry_Wag has quit [Remote host closed the connection]
<jasom>
You not only lose source locations, but also things like #+/#- and comments when you operate on code already processed with READ
<jasom>
stacksmith: well it's not *just* that nobody's done it, but doing it in the general case is impossible so there is no general purpose tool.
<jasom>
most lisp code includes macros not part of the standard that implement new bindings, so you can't not care about macroexpansions
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
pfdietz has joined #lisp
<jasom>
and you can't just macroexpand the code because implementations are free to macroexpand standard forms to code that includes non-standard special operators
fikka has joined #lisp
<stacksmith>
jasom: yeah, I understand. As for macros - by not caring I mean I don't want to see/get callbacks for macroexpansions, but just get a report about new bindings.
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
raynold has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
brettgilio has quit [Remote host closed the connection]
vlatkoB has quit [Remote host closed the connection]
<Bike>
walkers exist. compilers are walkers. some implementations include a more general mapping interface.
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<stacksmith>
I've been using SBCL's... Bike - have you used others?
Kundry_Wag has joined #lisp
<Bike>
well, i work with the sicl compiler a lot
<Bike>
michael raskin also wrote a weirdly named walker that might be good
<aeth>
You can write your own custom conses out of structs. You'd lose about 30% performance, though.
<aeth>
Classes will in general be even worse for performance here.
<dlowe>
or you can edit the conses of your implementation :D
<Bike>
okay, but you'd also need a way to read source text that produces those conses
<dlowe>
Sure.
<stacksmith>
SBCL's cons is a primitive object... Do you think that walkers don't mind walking shit conses as long as car and cdr work and the class name is 'cons'?
<dlowe>
stacksmith: how would they know?
<dlowe>
but yes, they'd be slower
<Bike>
they would know because they're written to call cl:car and cl:cdr
<Bike>
you'd have to hack the walker code to use your cons package
Kundry_Wag has joined #lisp
<dlowe>
well, yes.
<stacksmith>
Interesting.
<dlowe>
a simple shadowed package
<dlowe>
if SERIES can do it, why not HACKY-CONS
<Bike>
if you want source code but with extra location information attached, beach's CST systems work for that
<Bike>
also have a reader that produces them, so you don't need to do weird shit
<dlowe>
there's still some weird shit involved, sadly
<dlowe>
because conses produced by #. and company will still be standard conses
<stacksmith>
I would need more than location, but a bunch of binding-related info, etc.
<stacksmith>
But yeah.
<dlowe>
stacksmith: I think at this point, you might as well just stop calling what you have conses and start calling them AST nodes
<Bike>
the binding related information is not apparent from mere parsing
<Bike>
dlowe: beach does stuff for arbitrary reader macros
HighMemoryDaemon has joined #lisp
<stacksmith>
Binding information is largely available from walking, which includes looking into macros and such.
fikka has joined #lisp
<Bike>
that's not parsing, yes
<Bike>
stacksmith: you could have somewhat freaky, but legal code like (progn #1=(print *x*) (let ((*x* 19)) #1#)). in this case there is one (print *x*) cons that refers to two different bindings.
<stacksmith>
AST nodes is fine - the interesting part is that you can actually compile these.
<Bike>
i really recommend using some kind of internal representation.
<HighMemoryDaemon>
Is Practical Common Lisp the best starting point for someone looking to learn the language?
<stacksmith>
Or convert back to source after refactoring masturbations.
<Bike>
HighMemoryDaemon: if you've programmed before it's pretty good, yeah.
<HighMemoryDaemon>
Bike: Very amazing that it is completely free online. I wish the physical book wasn't so expensive or I'd love to support the author by purchasing it.
fikka has quit [Ping timeout: 260 seconds]
angavrilov has quit [Remote host closed the connection]
housel has quit [Remote host closed the connection]
housel has joined #lisp
varjag has quit [Ping timeout: 260 seconds]
xrash has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
kerframil has joined #lisp
shrdlu68 has quit [Read error: Connection reset by peer]
mindCrime_ has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
shrdlu68 has joined #lisp
brettgilio has quit [Remote host closed the connection]
HighMemoryDaemon has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
moei has quit [Quit: Leaving...]
kaun has joined #lisp
fikka has joined #lisp
<scymtym>
stacksmith: i second Bike's suggestion of using a non-s-expr representation and the eclector and concrete-syntax-tree libraries (now in quicklisp) specifically. this is a test i made using those in which the lexical variable X and a reference to it are correctly associated despite some obfuscation: https://techfak.de/~jmoringe/eclector-cst-toy-macrolet.png
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
brettgilio has joined #lisp
ineiros_ has quit [Ping timeout: 248 seconds]
varjag has joined #lisp
thuffir has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
Smokitch has quit []
pierpal has joined #lisp
kaun has quit [Quit: IRC for Sailfish 0.9]
Bike has quit [Ping timeout: 252 seconds]
thuffir has quit [Ping timeout: 240 seconds]
pdv has joined #lisp
brettgilio has quit [Remote host closed the connection]
pierpa has joined #lisp
thuffir has joined #lisp
pdv has quit [Client Quit]
fikka has joined #lisp
thuffir has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 260 seconds]
iridioid has quit [Ping timeout: 240 seconds]
papachan has quit [Quit: WeeChat 2.1]
fikka has joined #lisp
pdv has joined #lisp
k4rtik has joined #lisp
k4rtik has quit [Changing host]
k4rtik has joined #lisp
Pixel_Outlaw has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
varjag has quit [Ping timeout: 264 seconds]
Bike has joined #lisp
anunnaki has quit [Ping timeout: 264 seconds]
lumm has quit [Ping timeout: 240 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
lthms has left #lisp ["WeeChat 2.1"]
fikka has joined #lisp
kerframil has quit [Ping timeout: 256 seconds]
anunnaki has joined #lisp
rumbler31 has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
graphene has quit [Remote host closed the connection]
thuffir has joined #lisp
shka_ has quit [Ping timeout: 244 seconds]
graphene has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
libre-man has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
mindCrime_ has joined #lisp
graphene has quit [Remote host closed the connection]
shrdlu68 has quit [Read error: Connection reset by peer]
kerframil has joined #lisp
zmt01 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
graphene has joined #lisp
thuffir has quit [Ping timeout: 244 seconds]
housel has quit [Read error: Connection reset by peer]
ineiros has joined #lisp
housel has joined #lisp
subroot has joined #lisp
EvW has joined #lisp
shrdlu68 has joined #lisp
Oddity has quit [Ping timeout: 244 seconds]
swampflared has quit [Ping timeout: 244 seconds]
libre-man has joined #lisp
fikka has joined #lisp
LiamH has quit [Quit: Leaving.]
pdv has quit [Remote host closed the connection]
Oddity has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
rumbler31 has quit [Remote host closed the connection]
sjl_ has quit [Ping timeout: 276 seconds]
karlosz has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
kerframil has quit [Quit: Leaving]
housel has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
orivej has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
raynold has quit [Quit: brb reboot]
housel has joined #lisp
moei has joined #lisp
patlv has joined #lisp
Murii_ has quit [Remote host closed the connection]
pfdietz has quit [Ping timeout: 276 seconds]
josemanuel has quit [Quit: leaving]
fikka has quit [Quit: leaving]
fikka has joined #lisp
dxtr has quit [Read error: Connection reset by peer]
dxtr has joined #lisp
rumbler31 has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 265 seconds]
iridioid has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
k4rtik has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
patlv has quit [Ping timeout: 264 seconds]
eminhi has quit [Remote host closed the connection]
rumbler3_ has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
dxtr has quit [Ping timeout: 240 seconds]
patlv has joined #lisp
iridioid has quit [Ping timeout: 264 seconds]
robotoad has quit [Quit: robotoad]
brettgilio has joined #lisp
anunnaki is now known as vertigo
k4rtik has joined #lisp
brettgilio has quit [Remote host closed the connection]
patlv has quit [Ping timeout: 260 seconds]
<stacksmith>
scymtym: looks interesting, thanks.
brettgilio has joined #lisp
subr has joined #lisp
monoda has joined #lisp
subroot has quit [Ping timeout: 244 seconds]
monoda_ has joined #lisp
thuffir has joined #lisp
monoda__ has joined #lisp
housel has quit [Read error: Connection reset by peer]
<sjl>
ugh, reconsidering my redefining of /= as NOT= after I just lost 10m debugging why (\= n m) was returning t when n and m were both 1
monoda has quit [Ping timeout: 265 seconds]
<Bike>
huh?
anewuser has joined #lisp
<sjl>
I had (\= n m) in my code
<sjl>
the function is called /=
brettgilio has quit [Remote host closed the connection]
monoda_ has quit [Ping timeout: 240 seconds]
<sjl>
forward-slash-equals
<Bike>
oh, so it was =. right.
EvW has quit [Ping timeout: 240 seconds]
<sjl>
so it read in as =
monoda has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]