anticrisis has quit [Read error: Connection reset by peer]
anticrisis has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
anticrisis has joined #lisp
brandflake11 has left #lisp ["ERC (IRC client for Emacs 27.1)"]
akoana has joined #lisp
theothornhill has joined #lisp
theothornhill has quit [Ping timeout: 246 seconds]
rgherdt has quit [Ping timeout: 260 seconds]
pfdietz has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
vutral_ has quit [Quit: Connection closed for inactivity]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
skapata has quit [Remote host closed the connection]
Lycurgus has joined #lisp
nij has joined #lisp
<nij>
It's nice to be able to define printing function for cl-structs. However, sometimes I want to see its raw presentation (record-like). Can I temporarily disable the printing function?
<Xach>
nij: you can, but it's often easier to use DESCRIBE or an inspector instead.
<Xach>
nij: like (describe instance)
mindCrime_ has joined #lisp
charles` has quit [Ping timeout: 264 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Quit: Exeunt]
dddddd has quit [Ping timeout: 256 seconds]
nicktick has joined #lisp
zyz_ has joined #lisp
<nij>
I see! Thank you :)
zyz__ has joined #lisp
zacts has quit [Quit: leaving]
wxie has joined #lisp
zyz_ has quit [Ping timeout: 256 seconds]
dddddd has joined #lisp
nij has quit [Ping timeout: 260 seconds]
ralt has quit [Quit: Connection closed for inactivity]
charles` has joined #lisp
dddddd has quit [Ping timeout: 256 seconds]
Anonymous_ has quit [Remote host closed the connection]
charles` has quit [Ping timeout: 264 seconds]
dddddd has joined #lisp
jeosol has joined #lisp
aindilis has quit [Remote host closed the connection]
bitmapper has joined #lisp
zyz_ has joined #lisp
ym_ has quit [Quit: Leaving]
ym has joined #lisp
zyz__ has quit [Ping timeout: 260 seconds]
mr-iznogud has joined #lisp
dddddd has quit [Ping timeout: 256 seconds]
charles` has joined #lisp
luis has quit [Ping timeout: 272 seconds]
akoana has left #lisp ["Leaving"]
dddddd has joined #lisp
attila_lendvai has quit [Ping timeout: 272 seconds]
zyz__ has joined #lisp
orivej has joined #lisp
zyz_ has quit [Ping timeout: 246 seconds]
logand` has joined #lisp
luis has joined #lisp
Josh_2 has quit [Ping timeout: 240 seconds]
logand has quit [Ping timeout: 260 seconds]
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
mindCrime_ has quit [Ping timeout: 246 seconds]
antonv has joined #lisp
<antonv>
hi
<charles`>
Good morning
<antonv>
in ASDF, if my system consists of several files, each file depends on differend libraries
<antonv>
can I expresse that?
<charles`>
I don't see a need to. the whole system depends on all of them
<charles`>
You could make different files different systems
<antonv>
when I remove one of the files, I want to know what to remove from dependencies
zyz_ has joined #lisp
<antonv>
creating separate .asd file for every .lisp file - not desirable
<antonv>
And I haven't learned yet how to use package-inferred-systrems
krkini is now known as kini
zyz__ has quit [Ping timeout: 246 seconds]
dddddd has quit [Ping timeout: 256 seconds]
zyz__ has joined #lisp
zyz_ has quit [Ping timeout: 272 seconds]
dddddd has joined #lisp
<fiddlerwoaroof>
alandipert: there has been some work done to make extensible specifiers
<fiddlerwoaroof>
I think it's been partly merged into sbcl's clos implementation
rozenglass has quit [Remote host closed the connection]
wxie has quit [Ping timeout: 264 seconds]
_jrjsmrtn has quit [Ping timeout: 265 seconds]
v3ga has quit [Ping timeout: 240 seconds]
kapil_ has quit [Read error: Connection timed out]
kapil_ has joined #lisp
ebrasca has joined #lisp
Posterdati has joined #lisp
v3ga has joined #lisp
antonv has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
aindilis has joined #lisp
andreyorst has joined #lisp
lowryder has quit [Ping timeout: 246 seconds]
lowryder has joined #lisp
lowryder has quit [Ping timeout: 240 seconds]
lowryder has joined #lisp
Nilby` has joined #lisp
kapil_ has quit [Ping timeout: 265 seconds]
kapil_ has joined #lisp
Nilby has quit [Ping timeout: 246 seconds]
winny is now known as wInNy
andreyorst_ has joined #lisp
shka_ has joined #lisp
charles` has quit [Ping timeout: 244 seconds]
Bike has quit [Quit: Lost terminal]
_whitelogger has joined #lisp
zyz__ has joined #lisp
zyz__ has quit [Remote host closed the connection]
zyz__ has joined #lisp
zyz_ has quit [Ping timeout: 246 seconds]
wxie has quit [Ping timeout: 272 seconds]
sauvin has joined #lisp
mrchampion has quit [Remote host closed the connection]
DGASAU has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
johnjay has quit [Remote host closed the connection]
johnjay has joined #lisp
jumping_sloth has joined #lisp
leo_song has quit [Ping timeout: 264 seconds]
yonkunas has quit [Ping timeout: 246 seconds]
leo_song has joined #lisp
yonkunas has joined #lisp
banjiewen__ has quit [Ping timeout: 264 seconds]
nicktick has quit [Ping timeout: 246 seconds]
banjiewen__ has joined #lisp
nicktick has joined #lisp
andreyorst` has joined #lisp
andreyorst` has quit [Remote host closed the connection]
andreyorst` has joined #lisp
phadthai has quit [Ping timeout: 272 seconds]
phadthai has joined #lisp
theothornhill has joined #lisp
frgo_ has joined #lisp
DGASAU has quit [Ping timeout: 260 seconds]
frgo has quit [Ping timeout: 260 seconds]
zyz_ has joined #lisp
daphnis has joined #lisp
Cymew has joined #lisp
rgherdt has joined #lisp
rumbler31 has joined #lisp
theothornhill has quit [Ping timeout: 260 seconds]
asarch has joined #lisp
zyz__ has quit [Ping timeout: 256 seconds]
<asarch>
What :element-type should I use for an array of boolean values?
<beach>
asarch: I would probably use BIT and test for 0/1. Otherwise, you get a full word for each value.
<asarch>
'bit? Ok!
hiroaki has quit [Ping timeout: 246 seconds]
narimiran has joined #lisp
<asarch>
And how would I set the :initial-element to nil?
<asarch>
It seems that the 'bit doesn't like the nil value as initial element
<beach>
asarch: BIT means 0 or 1, so NIL won't qualify.
<beach>
Like I said, if you want NIL, you get a full word for each element. You can do that if you want, but the element type would then be T.
<asarch>
So, what type should I use for :initial-element nil?
<asarch>
Yeah, I only want T and NIL in the arrau
<asarch>
*array
<beach>
OK, good luck then.
<asarch>
!?
<asarch>
So, what should I use in the :element-type value?
ralt has joined #lisp
<beach>
If your choices are 0 or 1, I don't see what the problem is, and I don't see why you would choose NIL.
<beach>
If you want NIL in there, then since NIL is a symbol, you will have an array of element type T.
wxie has joined #lisp
<asarch>
Ok, ok. Sorry, sorry. Let's start again
<beach>
It is very unlikely that your Common Lisp implementation has a Boolean element type for arrays.
<asarch>
I only want an array of 35 elements of Ts and NILs
<beach>
Then use element-type T which is the default.
<asarch>
Ok. Thank you!
[d] has quit [Excess Flood]
[d] has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
<asarch>
One last stupid question: how would I get a full-created array with the 35 elements with nil so I could randomly (setf (elt my-array some-random-index) t)?
pfdietz has quit [Quit: Ping timeout (120 seconds)]
jeosol has quit [Quit: Ping timeout (120 seconds)]
<asarch>
I got: "Invalid index 3 for (VECTOR T 35) with fill-pointer 0, should be a non-negative integer below 0."
<beach>
Why do you set your fill pointer to 0.
<beach>
(make-array 35 :initial-element nil)
<beach>
Then (setf (aref * (random 35)) t) I would think.
<asarch>
I do (setf (elt my-array 3) t) and I get: Invalid index 3 for (VECTOR T 35) with fill-pointer 0, should be a non-negative integer below 0.
<asarch>
?
<asarch>
I use: (my-array (make-array the-size :adjustable t :initial-element nil :element-type 'T :fill-pointer 0))
<beach>
Why do you set the fill pointer?
<asarch>
Because, among other things, I also want the array 'expandable'
jeosol has joined #lisp
<asarch>
I got from PCL
<beach>
asarch: ELT obeys the fill pointer, so if you set it to 0, that means your array has 0 elements in it.
<beach>
... as far as elt is concerned.
<asarch>
And mostly because I get: #(NIL NIL T T NIL T NIL NIL NIL NIL NIL NIL ...) is not an array with a fill pointer.
<asarch>
Oh
<asarch>
So, how would create an array with 35 initial element set it to nil with the possibility that the array could increase its size dynamically?
zyz__ has joined #lisp
<asarch>
*how would you...
<beach>
You could use AREF which doesn't take the fill pointer into account, or you could not have a fill pointer.
varjag has joined #lisp
zyz_ has quit [Ping timeout: 244 seconds]
<asarch>
Ok
<beach>
... or you can set the fill pointer to T when you create the array. Then it will be the same as the size of the array initially.
rumbler31 has quit [Remote host closed the connection]
zyz_ has joined #lisp
<asarch>
Thank you!
<asarch>
Thank you very much!
<asarch>
Array: #(NIL NIL T T NIL T NIL NIL NIL NIL NIL NIL NIL T NIL NIL T NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)
<asarch>
That worked!
iskander- has joined #lisp
aartaka has joined #lisp
zyz__ has quit [Ping timeout: 246 seconds]
iskander has quit [Ping timeout: 260 seconds]
hjudt has joined #lisp
iskander- has quit [Ping timeout: 264 seconds]
iskander has joined #lisp
theothornhill has joined #lisp
DGASAU has joined #lisp
theothornhill has quit [Ping timeout: 246 seconds]
galex-713 has quit [Ping timeout: 265 seconds]
n3t has quit [Ping timeout: 268 seconds]
galex-713 has joined #lisp
arora has joined #lisp
theothornhill has joined #lisp
theothor` has joined #lisp
theothor` has quit [Remote host closed the connection]
theothor` has joined #lisp
theothor` has quit [Remote host closed the connection]
theothor` has joined #lisp
theothor` has quit [Remote host closed the connection]
theothornhill has quit [Remote host closed the connection]
theothornhill has joined #lisp
n3t has joined #lisp
theothor` has joined #lisp
theothornhill has quit [Disconnected by services]
theothor` has left #lisp [#lisp]
theothor` has joined #lisp
theothor` has left #lisp [#lisp]
galex-713 has quit [Ping timeout: 272 seconds]
theothornhill has joined #lisp
rumbler31 has joined #lisp
galex-713 has joined #lisp
X-Scale` has joined #lisp
zyz__ has joined #lisp
X-Scale has quit [Ping timeout: 260 seconds]
X-Scale` is now known as X-Scale
zyz_ has quit [Ping timeout: 264 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
<ralt>
anyone knows a library that can be used to send/receive file descriptors over unix sockets? Using ancillary data. I'm fine if it's sbcl specific.
rumbler31 has joined #lisp
pve has joined #lisp
dyelar has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 240 seconds]
asarch has quit [Quit: Leaving]
rumbler31 has joined #lisp
keizerrijk[m] has quit [Quit: Idle for 30+ days]
rumbler31 has quit [Ping timeout: 256 seconds]
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 268 seconds]
nicktick has quit [Ping timeout: 256 seconds]
zyz_ has joined #lisp
theothornhill has quit [Remote host closed the connection]
DGASAU has quit [Read error: Connection reset by peer]
heisig has joined #lisp
DGASAU has joined #lisp
zyz__ has quit [Ping timeout: 272 seconds]
_linker_ has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
madand has joined #lisp
daphnis has quit [Ping timeout: 240 seconds]
surabax has joined #lisp
karlosz has quit [Quit: karlosz]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
zyz__ has joined #lisp
theothornhill has joined #lisp
zyz_ has quit [Ping timeout: 240 seconds]
paulj has joined #lisp
theothornhill has quit [Ping timeout: 244 seconds]
ljavorsk has joined #lisp
mrios22 has joined #lisp
narimiran has quit [Ping timeout: 265 seconds]
Posterdati has quit [Ping timeout: 260 seconds]
daphnis has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
theothornhill has joined #lisp
Posterdati has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
daphnis has quit [Ping timeout: 240 seconds]
zyz__ has quit [Ping timeout: 260 seconds]
theothornhill has joined #lisp
Posterdati has quit [Ping timeout: 240 seconds]
Posterdati has joined #lisp
theothornhill has quit [Ping timeout: 272 seconds]
attila_lendvai has joined #lisp
Lord_of_Life_ has joined #lisp
attila_lendvai has quit [Remote host closed the connection]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
DGASAU has quit [Read error: Connection reset by peer]
theothornhill has joined #lisp
v3ga has quit [Ping timeout: 264 seconds]
v3ga has joined #lisp
daphnis has joined #lisp
VincentVega has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
wxie has quit [Quit: wxie]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
wxie has joined #lisp
cosimone has joined #lisp
Nilby` has quit [Read error: Connection reset by peer]
DGASAU has joined #lisp
cosimone has quit [Quit: cosimone]
orivej has joined #lisp
wxie has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
Codaraxis_ has quit [Read error: Connection reset by peer]
<dim>
context: a friend of mine is trying to figure out how CL would approach the async situation that Python finds itself into nowadays, and I'm like, you know, we don't need any language-level decision making, any lib could do that
<beach>
Great!
<dim>
and I think that the protocol ideas might help my friend better grasp what I mean
<dim>
you could easily have an async protocol or even just a protocol implementation that is async
<beach>
I am afraid I don't know what the "async situation that Python finds itself into" is.
<jackdaniel>
dim: do you mean a situation, where you have a protocol i.e for a mailbox, and that protocol could have a thread-safe implementation and a simpler implementation that works only in a single thread?
<dim>
beach: I'm still trying to figure out what my friend means here, it seems to be both a syntax issue and a semantics issue, where you have to use what the core developers of the language have designed
<beach>
Hmm.
<dim>
in that case, methods have to be declared async and then return with the await keyword in their source, and the caller then must use another keyword to plug into the event loop of async stuff, if I understand correctly
<dim>
I don't think we can easily relate to anything like that in CL
<beach>
That chapter merely specifies a generalization of an interface.
<beach>
It has nothing to do with async anything.
<dim>
the most comparable thing to me would be providing the same protocol with both a sync and an async implementation and the caller would have to pick one at call time
villanella has quit [Ping timeout: 244 seconds]
<dim>
jackdaniel: not sure, sounds relevant
_linker_ has quit [Remote host closed the connection]
<dim>
but I think my friend is curious more about the language itself somehow, well, let's be honest, I'm lost here ;-)
perrier-jouet has quit [Ping timeout: 265 seconds]
theothor` has joined #lisp
rogersm has joined #lisp
theothor` has quit [Ping timeout: 246 seconds]
perrier-jouet has joined #lisp
pagnol has quit [Ping timeout: 246 seconds]
theothor` has joined #lisp
nicktick has joined #lisp
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #lisp
theothor` has quit [Ping timeout: 264 seconds]
theothornhill has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
mrios22 has quit [Remote host closed the connection]
dbotton has joined #lisp
v3ga has quit [Ping timeout: 265 seconds]
dbotton has quit [Client Quit]
<ralt>
dim: you're talking about colored functions?
<dim>
I don't know what that is
<flip214>
ralt: you want colored bits next too, right?
amb007 has quit [Remote host closed the connection]
troydm has quit [Ping timeout: 265 seconds]
troydm has joined #lisp
skapate has joined #lisp
skapate is now known as skapata
skapata has quit [Killed (adams.freenode.net (Nickname regained by services))]
luni has joined #lisp
theothor` has joined #lisp
<phoe>
jmercouris: I don't remember anymore, but I think attaching a debugger is standard stuff
<jmercouris>
I was wondering how you got some symbols
<jmercouris>
I know how to attach the debugger, I didn't think there would be any other information than some memory addresses though
theothor` has quit [Ping timeout: 240 seconds]
<ralt>
dim: in general, lisp doesn't have a great story w.r.t. async though
daphnis has quit [Ping timeout: 246 seconds]
Bike has joined #lisp
narimiran has joined #lisp
theothor` has joined #lisp
<VincentVega>
Is there a library that would do permutations directly on lists out of the box? E.g. (1 2 3) with length 2 -> ((1 2) (2 1) (1 3) (3 1) etc). I found cl-permutation, but it just permutes numbers, and I don't want to convert a list into a vector and all that. And it also doesn't seem to support length, unless its larger than the permutation size. I
<VincentVega>
can see some other math libraries on cliki, but the immediately relevant ones I could identify are not on quicklisp, but maybe someone happens to know one that I am not seeing?
<jackdaniel>
VincentVega: how about (alexandria:map-permutations #'print (list 1 2 3) :length 2 :copy nil) ;?
dbotton has joined #lisp
theothor` has quit [Ping timeout: 272 seconds]
<VincentVega>
jackdaniel: great, thank you!
<jackdaniel>
sure
gxt has quit [Quit: WeeChat 3.0]
mrios22 has joined #lisp
Vultyre has quit []
<ralt>
sounds like a valid usage for #'identity
Vultyre has joined #lisp
<jackdaniel>
ralt: afaik this function returns nil
<ralt>
bummer
StargazerZZZ has joined #lisp
<jackdaniel>
I don't know whether it keeps all permutations in the memory, but in principle it should not to avoid blowing the heap when working on somewhat big sequences
<jackdaniel>
and in that case it could not cons up the results either
Vultyre has quit [Client Quit]
daphnis has joined #lisp
<flip214>
you can just have (lambda (x) (push x my-list)) instead of #'print to accumulate the results
<jackdaniel>
yes
wsinatra has joined #lisp
rumbler31 has joined #lisp
theothor` has joined #lisp
Vultyre has joined #lisp
caret has joined #lisp
theothor` has quit [Remote host closed the connection]
theothor` has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
StargazerZZZ has quit [Quit: Connection closed]
tassleoff has joined #lisp
pfdietz has joined #lisp
theothor` has quit [Remote host closed the connection]
dbotton has quit [Quit: This computer has gone to sleep]
random-nick has joined #lisp
pfdietz has quit [Ping timeout: 248 seconds]
<jdz>
VincentVega: I'd also suggest looking into screamer, where working with permutations would not require consing up all the results first.
varjag has joined #lisp
daphnis has quit [Ping timeout: 240 seconds]
nij has joined #lisp
<nij>
Any function that lifts arrows to list?
<nij>
Eg. (-> 1 (+ 1) (* 2)) => 4
<nij>
I'm thinking of
<nij>
(m-> (1 3) (+ 1) (* 2)) => (4 8)
<nij>
(in-package :arrows)
theothor` has joined #lisp
<phoe>
nij: I'd rather mapcar a single-arg function over a list
<aeth>
I don't know about the particulars of that library or the problem, but with numbers in general, if you can phrase the problem as MAP-INTO on an simple-array (whose elements' type is known) then that's usually an easy performance gain, which you might have to consider if it's large.
<aeth>
"easy" performance gain as in, the code's almost the same as the list code.
theothor` has quit [Ping timeout: 240 seconds]
<nij>
thx :)
<aeth>
Iirc (map-into a the-same-lambda a) assuming you don't need the original around anymore. Not as elegant as pure functions and in theory a compiler could do this (in practice, no CL one will), of course.
ljavorsk has quit [Ping timeout: 240 seconds]
<aeth>
Don't do it on '(1 3) though because that's literal. You'd need to use (list 1 3) if you're still using a list.
<phoe>
or (map 'vector ...) to cons a new sequence
<VincentVega>
jdz: I did stumble into that library once, maybe I need to learn some prolog first to understand what kind of problems it would be well suited for, because it looks pretty esoteric to me at this point (in a good way). Do you use it often?
DGASAU has joined #lisp
<aeth>
phoe: yes, but you'd probably want something more like (map '(simple-array (unsigned-byte 32) (*)) ...) or whatever you think can contain your problem. (Which is why float types are great, because they definitely will stay that float type unless you mix them with other types of floats, or explicitly coerce them, or accidentally make a complex)
<aeth>
(I know you know, but nij does not)
<phoe>
sure
<aeth>
Anyway, these are very, very small changes that can make huge performance gains, but generally only with numbers (and maybe characters)
wsinatra has quit [Ping timeout: 260 seconds]
daphnis has joined #lisp
<nij>
I'd keep that in mind :)
<aeth>
also keep in mind when not to do it, e.g. doing math at the REPL-as-a-calculator
nicktick has quit [Ping timeout: 246 seconds]
amerlyq has joined #lisp
<dim>
ralt: I like lparallel and I'm not sure if I would need more than that for my async needs
<ralt>
dim: an example I like is the actor model that Erlang uses: you want to have a queue and a thread per object, and if you have millions of objects, you need millions of threads. It is not feasible with OS threads, but perfectly fine with green threads.
amb007 has joined #lisp
<dim>
yeah I am fond of Erlang and that's why I like lparallel so much ;-)
OlCe has quit [Ping timeout: 246 seconds]
<nij>
Finally, my first little script :) thank you folks on #lisp <3
<jdz>
VincentVega: I've played around with it a bit, and used it to solve a problem once. But I remember working with permutations (i.e., non-determinism) was really convenient, straight forward and with no performance penalties in Screamer.
<dim>
nij: in pgloader I have picked $(toplevel)/build/bin for the binary artefact
<nij>
what is toplevel?
<nij>
(for example?)
<dim>
the directory created when I do `git clone`
<nij>
Ah. But then with each script, you add a PATH?
<dim>
usually you have a `make install` target or something similar, and install all your scripts in either /usr/local/bin or maybe ~/bin or somewhere else, and yes that place then needs to be listed in PATH
<VincentVega>
jdz: Hmm, interesting. Thanks for making this connection between the two.
dyelar has joined #lisp
<amerlyq>
can someone explain or give me link/chapter where described how Lisp "live coding" works under the hood? I used swank in emacs and everything worked intuitively, but when I tried to reproduce same _workflow_ with ipython/jupyter -- it was barely "live coding" requiring to reload everything recursively (due to multilevel assignments through modules, instances, methods, etc). And I can't grasp the
<amerlyq>
magic difference :(
mrios22 has quit [Ping timeout: 256 seconds]
<beach>
What is it that you are having difficulties with? I mean, one thread will be executing the program, and another thread runs the REPL.
<ralt>
dim: in that model, green threads just make so much more sense, no?
DGASAU has quit [Read error: Connection reset by peer]
<dim>
I don't know, I'm not used to thinking at that abstraction level, and lparallel has a notion of a kernel with a number of workers and only some of them might be allowed active at anytime, so it might implement what you're talking about already
tassleoff has quit [Ping timeout: 260 seconds]
vutral_ has quit [Quit: Connection closed for inactivity]
<jackdaniel>
amerlyq: python has interactivity bolted to the language as an afterthought
<jackdaniel>
while lisp is built ground up with repl in mind
luni has quit [Quit: Connection closed]
<jackdaniel>
probably that's the reason why many things doesn't work as you would expect in python when you try incorporate live coding
OlCe has joined #lisp
arora has quit [Ping timeout: 264 seconds]
theothor` has joined #lisp
OlCe has quit [Client Quit]
aeth has quit [Ping timeout: 265 seconds]
<ralt>
dim: it looks like it actually does, yes
theothor` has quit [Remote host closed the connection]
<ralt>
looks like it's implementing an event loop
theothor` has joined #lisp
Josh_2 has joined #lisp
<beach>
amerlyq: Are you still there?
<amerlyq>
beach, jackdaniel: basically I tried "hy" which is lisp syntax for python, but... it didn't worked like lisp :) CL design is to have global symbol table and to resolve symbols before calling, moreover to store values of these symbols on stack as per-frame env
<phoe>
hy is more or less python with parens
aeth has joined #lisp
<phoe>
it doesn't really change the underlying language semantics
<beach>
amerlyq: That doesn't sound like a correct analysis of Common Lisp semantics.
<jackdaniel>
it is a little more complex than having a global table, but sure, that may be a nice metaphore
<Josh_2>
Afternoon all. Is there a library I can use to modify images?
<amerlyq>
beach: but it's enough to conclude that python has too much isolation between modules/instances etc. and you can't easily replace e.g. method in class without monkey-patching or reloading whole module and recreating all instances
<beach>
amerlyq: I shall have to take your word for that.
theothor` has quit [Ping timeout: 240 seconds]
<amerlyq>
so, the question is -- how CLOS in CL had overcome this assignment limitation? Are class methods still contained in "global table" or only on stack of instance data?
<beach>
Methods are associated with generic functions.
<jackdaniel>
amerlyq: first and foremost, methods are not associated with the class
<beach>
amerlyq: Functions are often associated with names in the global environment.
matryoshka has quit [Ping timeout: 272 seconds]
<beach>
amerlyq: When you add a method to a generic function, its discriminating function is recomputed so that the next time the generic function is called, the new method is taken into account.
bjorkint0sh has quit [Quit: Leaving]
sjl has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
theothor` has joined #lisp
<edgar-rft>
Let's all take place and have dinner at the one global table.
<beach>
Bah, we would have the "dining Lispers problem".
mrchampion has joined #lisp
<jackdaniel>
no biggie, I'll use my hands and unlock others
<amerlyq>
jackdaniel: nice read, thanks. As I understood from it -- specific methods are added to local table of generic, not to global one. So to reload method, you must reload whole generic.
<amerlyq>
> redefine a generic function with `defgeneric´, a fact that you should note right now before it comes back to bite you if you think you can load a file of updated `defmethod´ forms and expect it to run
<jackdaniel>
amerlyq: when you define a new method, the generic function is updated, as beach said above
<edgar-rft>
beach: I'm not responsible for your eating manners :-)
* Xach
fondly remembers the dining lispers problem at Mary Chung in Cambridge - having a fun conversation with kmp and others about the clhs
<beach>
amerlyq: You can forget about "loading" and "reloading" it is just a matter of evaluating forms.
charles` has joined #lisp
<beach>
amerlyq: When you add a method, you don't redefine or "reload" the generic function.
nicktick has quit [Ping timeout: 264 seconds]
theothor` has quit [Ping timeout: 260 seconds]
<beach>
amerlyq: I am not sure where you picked up this evaluation model.
<beach>
amerlyq: But you could definitely load a file containing DEFMETHOD forms. The next time the generic function is called, those methods will be taken into account.
<amerlyq>
sorry on that, it's a hard to escape matter of habit -- when talking with other langs devs, they are more familiar with concepts of "hot reloading" and "live coding". Basically I used "reload" to focus only on this aspect of "form evaluation".
<amerlyq>
beach: but "will be taken into account" contradicts my quote above from jackdaniel link
<jackdaniel>
there is a fancy exception: methods defined as (:method …) option to defgeneric are removed before the function is redefined (and if still present -added once again)
<dim>
I think image based development as in CL is also sometimes referred to as “incremental compilation” (rather than reload)
<jackdaniel>
amerlyq: that quote you've mentioned talks about things you can use with a default generic function
orivej_ has joined #lisp
nicktick has joined #lisp
<jackdaniel>
(i.e when you forget to write a defgeneric form), in other words it speaks about something else
orivej has quit [Ping timeout: 265 seconds]
<beach>
amerlyq: What jackdaniel said.
<jackdaniel>
namely - always define a function with defgeneric, do not depend on defmethod defining a function for you
Vultyre has quit [Read error: Connection reset by peer]
<amerlyq>
oh, thanks for elaboration
<jackdaniel>
sure
Madvax has quit [Ping timeout: 260 seconds]
Vultyre has joined #lisp
aindilis has quit [Ping timeout: 256 seconds]
<amerlyq>
Hm, in this case "jet-live" approach for incremental compiling in C++ is more similar to Lisp, than any python approaches. Jet-live has global table of symbols, which prolog it rewrites by tramplines to newly added code, and actually broken OO becomes a generic-like bunch of differently named functions. The only problem is related to not preserving multiple environments on stacks and problem that
<amerlyq>
types data layout may not match
OlCe has joined #lisp
<amerlyq>
by the way... are there any other non-lisp languages designed for interactivity from the start? I seem can not find anything outside of research papers
<phoe>
Smalltalk!
<amerlyq>
phoe: is it still the thing in our millennia?
<alandipert>
java
<jackdaniel>
smalltalk and forth come to mind
<phoe>
alandipert: I wouldn't call Java interactive in the slightest
<amerlyq>
I fear java suffer the same problem as python
<phoe>
amerlyq: yes, see Pharo for an implementation that is alive and kicking
waleee-cl has joined #lisp
<Gnuxie[m]>
If it were dead you'd still be a fool to dismiss it
<aeth>
to be fair, Common Lisp already took inspiration from the relevant parts of Smalltalk :-p
<aeth>
I suspect that Common Lisp is a bit more successful than Smalltalk because Smalltalk is more deeply integrated with the editor, so it needs a good IDE, not just a good implementation.
<alandipert>
java/jvm were designed from the start to load code at runtime, later this functionality allowed jvm to host various dynamic langs, so support seems slight at worst imo
<amerlyq>
Gnuxie[m]: from scientist standpoint -- yes, from engineer standpoint -- no. Basically you need tons of libs to strive now, because after 30 you don't have time to write them yourself anymore :) And without libs even kicking lang is as good as dead for me, as it will never cross the borderline of kitchen experiments.
<phoe>
alandipert: hm, yes, if we take Java classloaders and such into account - but that'a already #lispcafe material
hiroaki has joined #lisp
<jackdaniel>
amerlyq: I think that you are oversimplifying; from the engineer standpoint abstraction-bloat and updating all libraries on weekly basis (I'm thinking about what I saw when npm and pip were part of the build process) is a disaster
<jackdaniel>
engineers strive for stability, not a mess
<jackdaniel>
maybe code ninjas like this kind of updates though!
<jackdaniel>
see, we know your questions before you ask them ,_)
<seeg1234>
:D thanks
<jackdaniel>
sure
<amerlyq>
phoe: Pharo looks promising enough to at least try over the weekends, thanks!
aeth_ has joined #lisp
<amerlyq>
jackdaniel: I'm not so sure. If you need some components, especially integration-like ones, you simply pick between maintaining stream of updates from others, maintaining frozen version, or maintaining constant development of your own. You simply convert the same your personal time into one of chosen complexities. And I don't see how to NOT convert your time at all.
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
<jackdaniel>
all that I'm saying is that what you describe is a work of a plumber, not an engineer
<jackdaniel>
nothing wrong with that
<amerlyq>
aeth: considering I felt like "Pharo demo show so much mouse clicks to get things done... lets try to write in vim", you may be right on that :)
aartaka_d has quit [Ping timeout: 265 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
theothor` has joined #lisp
<dim>
my understanding is that the comparing is not in the right dimension here, when using vim/emacs/editor you edit a file with characters that are going to be transformed into code later by some tooling or another, in Pharo you actually edit the code itself, live
<amerlyq>
jackdaniel: and what engineer isn't plumber? You still combine your abstractions to get model in the same way like you combine libs to get work done. Nothing changes beside type of dirt on your hands.
Steeve has joined #lisp
<dim>
and I believe Common Lisp with SLIME or equivalent sits in the middle of the two models
<amerlyq>
dim: you edit "code representation as text" in Pharo, not code itself :) So you still have explicit compilation transactions at checkpoints, despite being hidden. Nothing different from slime.
dbotton has joined #lisp
DGASAU has joined #lisp
<jackdaniel>
I suppose that wasn't a question but rather a revelation, so I'll get back to my things
theothor` has quit [Ping timeout: 246 seconds]
andreyorst` has quit [Quit: andreyorst`]
<amerlyq>
So, at the end of the day we still have only CL, Pharo, and maybe Forth for live coding. Seems like I cease my attempts to make CL from the python (but a pity).
<amerlyq>
jackdaniel, beach: thanks
<beach>
Sure.
dbotton has quit [Read error: Connection reset by peer]
dbotton_ has joined #lisp
dbotton_ has quit [Client Quit]
theothor` has joined #lisp
VincentVega has quit [Quit: Ping timeout (120 seconds)]
jeosol has quit [Quit: Ping timeout (120 seconds)]
<dim>
I would add Emacs Lisp and Clojure/Kawa and Racket and some other Scheme implementations to that list I believe, and Prolog and Erlang too, and most certainly quite a number of other things that I don't know exist yet ;-)
theothor` has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 264 seconds]
igemnace has joined #lisp
matryoshka has joined #lisp
VincentVega has joined #lisp
vutral_ has joined #lisp
theothor` has joined #lisp
daphnis has quit [Ping timeout: 240 seconds]
theothor` has quit [Ping timeout: 256 seconds]
<sjl>
Is there a way to print a rational as a decimal with an arbitrary amount of precision in CL? Format's ~F converts the number to a float first, so if the rational requires more decimal places than double-float can handle it won't work.
<sjl>
(I ended up using https://wukix.com/lisp-decimals to do it for this one off-the-cuff calculation but was wondering if there's a built-in way)
<ebrasca>
How to use borodust claw?
<ralt>
Pharo is Smalltalk descendant, right?
aartaka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<beach>
sjl: Can't you just multiply it by (expt 10 <number-of-decimals>), round it, and then insert a period before the decimal part?
<sjl>
I could probably cook up a function to do it... I was hoping there was something easily built-in that I was missing though
amb007 has quit [Read error: Connection reset by peer]
<ebrasca>
ralt: wikipedia says Pharo is one Smalltalk Implementation
<sjl>
Some format directive I don't know about or something.
<phoe>
I don't think so; CL has no real support for fixed-point numbers, which is what you want to do here
<phoe>
...other than rationals, of course
<beach>
We need to revise the standard to include it.
<phoe>
I don't think there's a format directive for that
amb007 has joined #lisp
<beach>
[sorry, bad joke. I have had to deal with another suggestion for a new standard lately]
<sjl>
(ql:quickload :wu-decimal) isn't that bad
<sjl>
I can live with it for the rare times I need it
<waleee-cl>
(image based like both cl and smalltalk)
amb007 has quit [Read error: Connection reset by peer]
<alandipert>
fiddlerwoaroof this "generalizer" paper/code you sent is really interesting, thanks for that. opens my eyes to the continuum of things before predicate dispatch and dependent types
<beach>
waleee-cl: What is the meaning of "image based"?
amb007 has joined #lisp
<waleee-cl>
aka the core eg. sbcl can dump and use
<beach>
I see.
<waleee-cl>
usually called image based outside of common lisp
<waleee-cl>
s/image//
<beach>
I just wasn't sure. I guess I confuse it with the kind of system where you do all the work inside the running system, even edit code and such.
<beach>
... like I hear Interlisp was.
<waleee-cl>
By that definition factor is leaning more to the interlisp / smalltalk & pharo-side
heisig has quit [Quit: Leaving]
<beach>
And I don't think of Common Lisp as such a system at all.
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
<beach>
... which is why I asked.
<beach>
Erm, I mean, I don't think of current Common Lisp systems as such systems.
<aeth>
All you really need is variations of float-producing functions like SQRT with user-specified precision that result in rationals (and no, ISQRT doesn't count, even if it does technically result in an integer, which is a rational)
theothor` has quit [Ping timeout: 272 seconds]
sxmx has quit [Ping timeout: 272 seconds]
hnOsmium0001 has joined #lisp
<amerlyq>
alandipert: so, is Clojure live coding is a thing in the same transparent way as CL/slime? If you don't mind amateurish question.
phantomics has quit [Ping timeout: 246 seconds]
<alandipert>
amerlyq clojure prefers sticking with JVM limitations when they conflict with CL debug/repl affordances, so from the CL perspective it feels rather impoverished
sxmx has joined #lisp
secretmyth has joined #lisp
liberliver has quit [Quit: liberliver]
lowryder has quit [Ping timeout: 240 seconds]
lowryder has joined #lisp
sxmx has quit [Ping timeout: 260 seconds]
bilegeek has joined #lisp
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
amerlyq has quit [Quit: amerlyq]
theothor` has joined #lisp
aindilis has joined #lisp
<charles`>
Is it considered bad for syntax extensions to be loaded when a the system is loaded or is it always better to have (enable-syntax-extension)
Aurora_v_kosmose has quit [Remote host closed the connection]
theothor` has quit [Ping timeout: 246 seconds]
Aurora_v_kosmose has joined #lisp
<Xach>
charles`: named-readtables is a nice way to manage syntax extensions.
mindCrime_ has joined #lisp
<charles`>
but it isn't a reader extension
<Xach>
charles`: oh. what is a syntax extension?
<charles`>
a superset of reader extensions
<Xach>
can you be more specific?
<charles`>
it is a utility that allows types to be functions
<charles`>
so you could define a function for integer type then do (12 .....)
<Xach>
Neat. I don't have any opinion on when that should be enabled, I don't think I've seen anyone do something like that before.
ukari has quit [Remote host closed the connection]
<Xach>
How does it work?
theothor` has joined #lisp
ukari has joined #lisp
VincentVega has quit [Quit: Connection closed]
<Josh_2>
Xach: did you create a png manipulation library?
<charles`>
Xach: Clojure has a similar thing where lists and hash-tables can be called as functions to access their contents. I am using plists and a custom eval function
<Josh_2>
a custom eval function?
<Xach>
Josh_2: not exactly. i wrote a png-writing library, and a vector drawing library that can write pngs, but it does not load pngs. (other libraries can do that though.)
theothor` has quit [Ping timeout: 240 seconds]
<charles`>
Josh_2: I wrote an eval function that wraps cl:eval, then set cl:eval to my custom eval
<Xach>
charles`: does it work with compilation too?
<Xach>
Josh_2: did you have a particular application in mind?
<Josh_2>
Xach: yes I need to be able to draw dots based on X/Y coordinates on an image
<charles`>
you mean compile-file, I havent tried yet... It happens totally at run time tough
<Xach>
charles`: not limited to compile-file, thinking also of straight COMPILE.
<Josh_2>
the image would be a PNG and It's not a big deal if I redrew the image each time
<Xach>
Josh_2: you could do that by linking together pngload and vecto, but it isn't a directly supported way to work. (vecto's underlying canvas is compatible with the data pngload works with, i think)
<phoe>
> then set cl:eval to my custom eval
<Josh_2>
Well I could just draw an SVG and modify it based on where I want my dots and then export that as a PNG each time
<Josh_2>
using your SVG library
<phoe>
charles`: if you SETF FDEFINITION of CL:EVAL, that's UB - is that what you're doing?
<Xach>
i don't have an svg library...
<Xach>
Josh_2: maybe i'm overthinking. are you trying to draw dots on an existing image, or create a fresh new image with some dots in certain places?
<Josh_2>
isn't that 'vector drawing library'?
<Josh_2>
I can do either
<Xach>
SVG is an XML standard for defining some drawing and other graphical operations. It's useful for making 2d images. My library doesn't use or emit SVG.
<Xach>
well, if you want to make a PNG with some dots in it, vecto can do that pretty easily. (vectometry helps too.) for example, (with-box-canvas (box 0 0 200 200) (centered-circle-path (point 100 100) 25) (fill-path) (save-png "circle.png"))
rogersm has quit [Quit: Leaving...]
<Xach>
hey presto, a black circle with radius 25 in the center of a 200x200 png
<Josh_2>
oh nice that might work
<charles`>
phoe: I am doing (setf (symbol-function
<pve>
charles`: is this heading towards (12 :to 15 :do (lambda (n) (print "Whee!")))? :)
<charles`>
that is certainly a possibility!
<charles`>
just define your integer function to do that
<alandipert>
charles` i've always wondered about hacks to make arbitrary classes funcallable via mop, could be another means toward that end
<Xach>
alandipert: funcallable instances are pretty well supported, i believe!
<Xach>
that is not "arbitrary", granted
theothor` has quit [Ping timeout: 272 seconds]
<charles`>
It is not really mop based (that is a bit over my head), they are not technically fun-callable (in my utility)
cage_ has joined #lisp
<OlCe>
Just as an example of interesting uses for this functionality, NewLISP has implicit indexing, one variant of which is to put one (or more) integers at start of a list form to do slicing.
<alandipert>
fixnum-macros anyone
<charles`>
in my utility, the function is actually more like a macro, so it can do ast changing before it form is actually evaled
yottabyte has quit [Quit: Connection closed for inactivity]
<alandipert>
neat
<charles`>
but still happens at runtime
theothor` has joined #lisp
jeosol has joined #lisp
arora has joined #lisp
<_death>
it's not neat, it's silly.. (12 ...) is like (op 12 ...).. now you can have (op 12 to 15 do ...) and you can have (op 12 some-array), but having both, each defined by a different user, creates an impractical mess.. so instead we give different names like loop or aref
theothor` has quit [Ping timeout: 260 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 264 seconds]
<charles`>
_death: the conflicts would be horrible. as long as people are conservative in defining new and crazy ones, it can be nice.
<alandipert>
we have this problem with symbols already, and have devised various mitigations.. and all the mitigations seem as applicable to eq fixnums as they are to eq symbols. i can imagine a concept of package-qualified fixnum for example
<alandipert>
granted this is in language design fun world, not CL world. where i wouldn't use it either heh
<charles`>
classes are already package local, so if you define a class then define an type-function for that class, then I think it would be pretty safe
mindCrime_ has quit [Ping timeout: 260 seconds]
theothor` has joined #lisp
<_death>
I suppose every lisper goes through that phase ;)
emacsomancer has quit [Read error: Connection reset by peer]
emacsomancer has joined #lisp
<charles`>
What would be ideal is the type-functions being enabled be package local
theothor` has quit [Ping timeout: 240 seconds]
vutral_ has quit [Quit: Connection closed for inactivity]
karlosz has quit [Quit: karlosz]
rumbler31_ has joined #lisp
Cymew has joined #lisp
anticrisis has joined #lisp
theothor` has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
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
theothor` has quit [Ping timeout: 256 seconds]
dddddd_ has joined #lisp
yottabyte has joined #lisp
dddddd has quit [Ping timeout: 256 seconds]
theothor` has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
sxmx has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
karlosz has joined #lisp
theothor` has quit [Ping timeout: 260 seconds]
bilegeek_ has joined #lisp
bilegeek has quit [Ping timeout: 264 seconds]
OlCe has quit [Ping timeout: 240 seconds]
<pve>
charles`: you might want to investigate using readtables instead of clobbering cl:eval, if you're going to pursue that further
amb007 has quit [Read error: Connection reset by peer]
rogersm has joined #lisp
rogersm has quit [Remote host closed the connection]
amb007 has joined #lisp
rumbler31 has joined #lisp
rumbler31_ has quit [Ping timeout: 264 seconds]
aeth_ has joined #lisp
kpoeck has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
ebrasca has quit [Remote host closed the connection]
aeth__ has joined #lisp
amb007 has joined #lisp
aeth has quit [Disconnected by services]
aeth__ is now known as aeth
<charles`>
pve: I'll look into it, but I wouldn't call it clobbering; it is more like a thin wrapper that calls the original cl:eval.
aeth_ has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
luni has joined #lisp
theothor` has joined #lisp
andreyorst_ has quit [Ping timeout: 246 seconds]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
theothor` has quit [Ping timeout: 240 seconds]
<pve>
charles`: I understand, but it's not something you would want to do if you intend to release it as a library.
aeth has quit [Ping timeout: 240 seconds]
Jesin has quit [Quit: Leaving]
aeth has joined #lisp
Anonymous_ has quit [Remote host closed the connection]
Steeve has quit [Quit: end]
Jesin has joined #lisp
bilegeek_ has quit [Remote host closed the connection]
bilegeek_ has joined #lisp
mindCrime_ has joined #lisp
banjiewen__ has quit [Ping timeout: 264 seconds]
kilimanjaro has quit [Ping timeout: 265 seconds]
cage_ has quit [Quit: Leaving]
banjiewen__ has joined #lisp
luni has quit [Quit: Connection closed]
arora has quit [Ping timeout: 264 seconds]
kilimanjaro has joined #lisp
zacts has joined #lisp
villanella has joined #lisp
villanella has quit [Client Quit]
andreyorst has quit [Remote host closed the connection]
Vultyre has quit [Quit: Leaving]
galex-713 has quit [Ping timeout: 265 seconds]
kpoeck has quit [Ping timeout: 248 seconds]
Nilby` has joined #lisp
galex-713 has joined #lisp
jeosol has quit [Quit: Ping timeout (120 seconds)]
charles` has quit [Ping timeout: 264 seconds]
galex-713_ has joined #lisp
galex-713 has quit [Ping timeout: 265 seconds]
gaqwas has quit [Ping timeout: 240 seconds]
Anonymous_ has joined #lisp
galex-713 has joined #lisp
aeth has quit [Ping timeout: 264 seconds]
shka_ has quit [Ping timeout: 264 seconds]
galex-713__ has joined #lisp
aeth has joined #lisp
Vultyre has joined #lisp
galex-713_ has quit [Read error: Connection reset by peer]
galex-713_ has joined #lisp
galex-713__ has quit [Read error: Connection reset by peer]
galex-713___ has joined #lisp
Josh_2 has quit [Ping timeout: 264 seconds]
galex-713 has quit [Ping timeout: 265 seconds]
galex-713__ has joined #lisp
kpoeck has joined #lisp
galex-713___ has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
caret has quit [Quit: Leaving]
galex-713_ has quit [Ping timeout: 264 seconds]
secretmyth has quit [Quit: Leaving]
galex-713_ has joined #lisp
galex-713__ has quit [Read error: Connection reset by peer]
scymtym has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
charles` has joined #lisp
rumbler31 has joined #lisp
notzmv has quit [Ping timeout: 265 seconds]
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
zacts has quit [Quit: leaving]
zacts has joined #lisp
zacts has quit [Client Quit]
gaqwas has joined #lisp
gaqwas has joined #lisp
OlCe has joined #lisp
Vultyre has quit [Quit: Leaving]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
attila_lendvai has quit [Ping timeout: 260 seconds]
samlamamma has joined #lisp
euandreh has joined #lisp
aartaka_d has quit [Ping timeout: 265 seconds]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
mindCrime_ has quit [Excess Flood]
mindCrime_ has joined #lisp
surabax has quit [Quit: Leaving]
scymtym has joined #lisp
paul0 has joined #lisp
gaqwas has quit [Ping timeout: 246 seconds]
<charles`>
pve: I don't see how name-readtables will help me get around rebinding cl:eval
Nilby` has quit [Quit: [deleted]]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
aeth has quit [Ping timeout: 246 seconds]
IPmonger has joined #lisp
Josh_2 has joined #lisp
aeth has joined #lisp
<Josh_2>
Hey. With asdf can I specify a pathname for each module?
scymtym_ has joined #lisp
<Josh_2>
Normally I would add a key like :pathname "src" and all my code would go in 'src' and then my files are found relative to src, however I want to have a module which contains static files, if I use :pathname isn't it going to look in src?
akoana has joined #lisp
sjl has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 265 seconds]
<Josh_2>
like a :module component looks in <pathname>/<modulename>
<Josh_2>
I still want all the other modules to be in "src" just not one module
aeth has quit [Ping timeout: 260 seconds]
aeth has joined #lisp
<phoe>
I think this is recursive
<phoe>
like, when you have (:module "foo" ... (:module "bar" ... (:file "baz"))) then you'll end up with a relative path name #p"foo/bar/baz" that ASDF will use to look for the resultant file
<Josh_2>
I might have done it
<Josh_2>
Well asdf didn't complain but I'm not sure if it worked or not because It's a :static-file