Arcaelyx has quit [Read error: Connection reset by peer]
<mfiano>
Xach: Ah, that is a bit. Let me know if there is anything to help with.
caltelt_ has joined #lisp
Arcaelyx has joined #lisp
dieggsy has joined #lisp
<aeth>
MichaelRaskin: How? I tried macroexpanding outside of the symbol-macrolet and inside and I couldn't get either. e.g. this just gives me (+ foo foo): (let ((bar 42)) (macroexpand-1 `(symbol-macrolet ((foo (expt bar 2))) (+ foo foo))))
<aeth>
I expect (+ (expt bar 2) (expt bar 2)) in the body of that
rumbler31 has joined #lisp
<aeth>
I've tried moving the macroexpand-1 around in different places, and quoting and unquoting different things.
<MichaelRaskin>
When you macroexpand-1 with 1 argument, you are macroexpanding in the global environment
<aeth>
ah
<MichaelRaskin>
To notice a local symbol-macrolet — as well as for macrolet — you need to expand in the local lexical environment
m3tti_ has joined #lisp
<MichaelRaskin>
The only method to obtain it is to be inside a macro-function
<MichaelRaskin>
Well, the only standard-described method
gector has quit [Ping timeout: 268 seconds]
<Bike>
functions are not implicitly aware of their caller's lexical environment
<Bike>
please rember
pierpal has joined #lisp
<MichaelRaskin>
macro-function can be, though
<MichaelRaskin>
In defmacro you need to declare &environment parameter
gector has joined #lisp
<MichaelRaskin>
(Also, macros + scope = fun effects that we don't talk about because we lack proper words for them)
fisxoj has quit [Quit: fisxoj]
m3tti has quit [Ping timeout: 276 seconds]
pierpal has quit [Ping timeout: 240 seconds]
subroot has quit [Read error: Connection reset by peer]
rumbler31 has quit [Ping timeout: 264 seconds]
azimut has quit [Ping timeout: 264 seconds]
jack_rabbit has quit [Ping timeout: 264 seconds]
eli_oat has joined #lisp
<Bike>
macro-function can be what
<MichaelRaskin>
A macroexpand-1 call cannot know the calling lexical environment, a macro expansion function defined with defmacro and used because of a macro invocation is allowed to be aware of lexical environment at the call site.
<MichaelRaskin>
(if declared with &environment)
<Bike>
i said "functions" not macros
megalography has joined #lisp
shangul has quit [Remote host closed the connection]
<stacksmith>
Good morning... Could someone confirm that in (defun foo(a) (macrolet ((bar (b) `(list ,b a)))...) bar's a is not foo's parameter a? I am confused by CLHS example - it seems to imply that lexicals above the macrolet are not accessible, but later states the opposite...
azimut has joined #lisp
Naergon has quit [Remote host closed the connection]
pierpal has joined #lisp
Beep-Lord has quit [Quit: WeeChat 1.6]
<LdBeth>
stacksmith: function body is macroexpand
Murii has quit [Ping timeout: 256 seconds]
angavrilov has quit [Remote host closed the connection]
<stacksmith>
So the comment "The parameters x and flag are not accessible at this point" is referring to the macro-expansion function itself (as opposed to the expansion) But then there is a really ominous "but the consequences are undefined if the local macro definitions reference any local variable or function bindings that are visible in that lexical environment", referring to the lexical environment of the macrolet definition. That is sti
angavrilov has joined #lisp
brendyn has joined #lisp
eli_oat has quit [Quit: Leaving.]
<stacksmith>
In my book quasiquoting/splicing lexicals in the scope of the macro definition is a kind of a reference to a local variable binding (that seems to be prohibited).
<LdBeth>
but macrolet is not macro
<LdBeth>
So a is in the lexical scope
<LdBeth>
Or not, depending on the actual implementation of macrolet
<stacksmith>
LdBeth: could you clarify - I've been thinking of macrolet as a local defmacro...
doesthiswork has quit [Quit: Leaving.]
<Bike>
the parameter a of foo shadows the outer parameter a.
<Bike>
er. wait. misread. durr.
<Bike>
the bar macro function the variable A is not even referred to
<Bike>
so there's no problem
<Bike>
in the bar macro function*
Murii has joined #lisp
robotoad has joined #lisp
doesthiswork has joined #lisp
<stacksmith>
Bike, SBCL happily expands foo's a right into the list. I was assuming CLHS means to say that values of lexicals are not accessible to the expander (because it runs at compile time and only symbols are availble) but the macro is free to expand lexicals like in my example. But it really says something else - and what it is I cannot figure out.
<Bike>
the macro function doesn't know anything about A at all.
<Bike>
as you say, what CLHS means is that outer lexicals are not available to the expander.
<stacksmith>
Bike, please explain - if the macro function knows nothing about A... Does it not expand to (list 'c a)? It has to know about the binding...
<Bike>
it does expand to (list 'c a), but doesn't know about the binding.
<Bike>
you could just as well write `(list ,b zweihander)
<Bike>
and get (defun foo (a) (list 'c zweihander)) and get an unbound variable error
<LdBeth>
I think CLHS means an proper implementation can let MACROLET use dynamic binding
<Bike>
No.
<stacksmith>
OK, I was considering the act of expander copying a name as knowing something about the binding, but I see that it's better to say it does not. So all the warnings really have to do with the expander's environment, right?
<Bike>
Warnings?
buffergn0me has joined #lisp
<stacksmith>
CLHS stating things like "but the consequences are undefined if the local macro definitions reference any local variable or function bindings that are visible in that lexical environment.".
<Bike>
you had the right idea with the compile time stuff.
<Bike>
if you have (let ((a (some-long-computation))) (macrolet ((foo () a)) ...)) it's a problem because obviously the long computation only happens at runtime
<Bike>
but ((foo () 'a)) is fine because it's not using the value, it's just returning a symbol that happens to name a variable sometimes.
<White_Flame>
stacksmith: issues like this is why many macros ask you to provide variables for them to use in bodies
<White_Flame>
ie, in (with-open-file (stream "foo.txt") ...) you give it the variable named 'stream, instead of using a variable that it expands to and hope everything matches
<White_Flame>
but macrolet is always within a lexical scope, so if it expands references to lexical variables in its outer scope, that's a generally safe expansion
<stacksmith>
Yeah, that makes sense with macros that provide a lexical environment to the body... I was concerned with the opposite - a macro consuming the existing lexicals...
<Bike>
it can't use them at macro expansion time, but in the expansion it doesn't matter
<White_Flame>
the macro expansion code... yeah what Bike said
<White_Flame>
in the macrolet examples above, the value of lexical variable A is never accessed during the expansion. It's simply a literal symbol in a source code expression that is being generated
<White_Flame>
so it's safe
<stacksmith>
I've always assumed that, but reading CLHS confused me a bit. Probably because I was not thinking of bindings incorrectly and wrongly thought of symbols in a macro as bindings. Obviously, they are just symbols at that point.
<Bike>
yes, exactly.
<stacksmith>
Many thanks.
fisxoj has joined #lisp
fisxoj has quit [Client Quit]
<White_Flame>
however, in classic LISPs there were f-expressions, which are sort of like macros, but take source code and execute it
<White_Flame>
there are libraries that emulate that behavior in CL
<White_Flame>
those things do have the full runtime per-invocation environment available to them
<aeth>
Afaik it's like using EVAL at runtime, and isn't very efficient, and that's why it got dropped
<White_Flame>
right
<Bike>
you can't really compile them and their existence further implies that the lexical environment has to be available at runtime
<Bike>
thus making almost every optimization a compiler does impossible
Denommus has joined #lisp
<stacksmith>
Works well on a Lisp machine...
<Bike>
apparently not, according to pitman
<stacksmith>
I suppose having a Lisp machine does not alleviate the itch to optimize...
papachan has left #lisp ["WeeChat 2.1"]
papachan has joined #lisp
eli_oat has joined #lisp
pierpa has quit [Quit: Page closed]
edgar-rft has joined #lisp
NotSpooky has quit [Quit: Leaving]
papachan has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
vtomole has joined #lisp
Pixel_Outlaw has joined #lisp
skapata has quit [Remote host closed the connection]
asarch has joined #lisp
Jasko has joined #lisp
Jasko has quit [Client Quit]
eli_oat has quit [Quit: Leaving.]
mrcom has quit [Read error: Connection reset by peer]
Pixel_Outlaw has quit [Quit: Leaving]
<asarch>
Reading about CLOS and the way it does OOP, I've come to realize that is also possible (more or less) the same with the C programming language
<asarch>
You'll see, there is a widget toolkit to develop GUI-based apps
<asarch>
Its name is GTK+
<asarch>
It seems that the main developers of this widget toolkit knew about the CLOS techniques and they implemented across this toolkit
<asarch>
In C++ using GTK+, you could create a window with: Window my_window; and the change the properties with: window.set_tite("Hello GTK+ world!");
<Bike>
that's just normal C++ so far
<Bike>
window.set_title is a very single dispatch way to write it
<asarch>
On the other hand, with C you must: GtkWidget *my_window = gtk_window_new(); gtk_window_set_title(GTK_WINDOW(my_window), "Hello, GTK+ world!");
<Bike>
oh, that's how you meant
<asarch>
Which it resembles the general dispatch from CLOS
<asarch>
Yeah
<Bike>
how do you define methods on it
<asarch>
For every action to the window (resize it, clicked it, close it, etc), you must declare a callback function
<Bike>
are there actual multimethods
Denommus has quit [Remote host closed the connection]
pagnol has joined #lisp
<asarch>
This is, however, made it with the C style: void my_callback_for_a_click(); g_signal_connect(my_window, "clicked", my_callback_for_a_click, "somedata");
<asarch>
What do you mean with "multimethods"?
<Bike>
a function that can be specialized on any parameter or more than one parameter, instead of just one as in C++ dispatch.
<p_l>
asarch: creators of GTK+ wrote GIMP sometime after going crazy from writing a compiler in Common Lisp for assignment
<asarch>
Yeah, actually there is a function to "refresh" a widget on the screen: gtk_show(my_window); or gtk_show(my_button); or gtk_show(my_some_other_widget);
<vtomole>
Is there any situation where it is acceptable to write Lisp source in all caps?
<asarch>
YEAH! I WAS RIGHT!!!
<Bike>
to express your rage against the machine
<Bike>
it's called primal scream therapy
<p_l>
asarch: that said, it's far from CLOS
<asarch>
?
shka_ has joined #lisp
<p_l>
asarch: you might want to lookup "COS", "C Object System", which is as direct port of CLOS as possible :)
* asarch
digs...
<p_l>
GTK+'s object model is afaik pretty common for GUI toolkit in C
<asarch>
...is it bad or is it good?
<Bike>
i think it's mainly just far from clos
<asarch>
Oh :-(
<asarch>
D'oh!
<p_l>
core WinAPI is quite similar, IIRC
<asarch>
Anyway, I just wanted to share this with you
<asarch>
I'll better keep reading the Sonja's book about CLOS....
* asarch
goes to read...
SlowJimmy has quit [Ping timeout: 256 seconds]
vtomole has quit [Ping timeout: 260 seconds]
flazh has quit [Ping timeout: 256 seconds]
quazimodo has quit [Ping timeout: 245 seconds]
quazimodo has joined #lisp
aijony has quit [Ping timeout: 260 seconds]
TheReal_aijony has joined #lisp
TheReal_aijony is now known as aijony
pagnol has quit [Ping timeout: 240 seconds]
<aeth>
How do you get the ftype of a function?
<aeth>
Someone asked in #lispcafe and I can't find it
<Bike>
no standard way
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<pillton>
p_l: Is what you said about the creators of GTK+ true?
rumbler31 has joined #lisp
smurfrobot has joined #lisp
<pillton>
aeth: You need cltl2 support and it will only give you the declaration.
<pillton>
aeth: The function function-information in chapter 8.5 of CLtL2.
<p_l>
pillton: "A couple of students at Berkeley, Spencer Kimball and Peter Mattis, decided they wanted to write an image manipulation program rather than write a compiler in scheme/lisp for professor Fateman (CS164). "
<p_l>
GTK arrived after they got fed up with Motif
pierpal has quit [Ping timeout: 240 seconds]
<pillton>
p_l: Oh ok. Thanks.
smurfrobot has quit [Ping timeout: 248 seconds]
rumbler31 has quit [Ping timeout: 248 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
<aeth>
I guess that's (introspect-environment:function-type 'car)
<aeth>
(or function-information)
Oddity has joined #lisp
<beach>
Good morning everyone!
<MichaelRaskin>
Good morning
dilated_dinosaur has quit [Ping timeout: 260 seconds]
<beach>
MichaelRaskin: In my specification, I wrote that the application may not stop if there is a non-local control transfer.
<MichaelRaskin>
Is GO non-local?
flazh has joined #lisp
<beach>
Not always.
<MichaelRaskin>
For step-over of (go 1)
<beach>
Actually, I don't think I specified non-local in the specification. But to answer your question, you can't tell from the form itself whether it is non-local or not.
<beach>
It is local in (tagbody 1 ... (go 1)) but not in (tagbody 1 ... (f (lambda () (go 1))))
asarch has quit [Remote host closed the connection]
igemnace has joined #lisp
<beach>
And I don't know that the Common Lisp HyperSpec actually specifies any difference.
<beach>
I think it mentions transfer to an exit point.
<beach>
So, if the transfer is lexical, you can probably have the application stop, but if it is dynamic, then you might have to solve the halting problem.
<MichaelRaskin>
Well, for go unlike throw you still have to find yourself in instrumented area
<beach>
I don't know what that means.
<beach>
I guess "instrumented area" is specific to the way you do things.
dilated_dinosaur has joined #lisp
<beach>
But GO and RETURN-FROM are lexical, so you know statically where they end up. Therefore, you can decide to stop at that exit point when you are about to evaluate a form like that.
<MichaelRaskin>
Yes
mrcom has joined #lisp
Oladon has quit [Quit: Leaving.]
makomo has joined #lisp
<pillton>
aeth: Oh I forgot about introspect-environment. Sorry Bike.
<MichaelRaskin>
Actually, supporting GO and RETURN-FROM at the level of LOOP is already a bit annoying
<beach>
MichaelRaskin: You speak in riddles as far as I am concerned. But then, I am notorious for having a hard time understanding what people want to say here.
<MichaelRaskin>
Well, step-over is a nice and simple operation when there is no go/throw/return-from inside
<beach>
And I still don't know why LOOP is annoying.
<beach>
And I don't know why it is a special case.
<MichaelRaskin>
To support LOOP I need to support code has a lot of GO inside WHEN
<beach>
Not that it matters much that I don't understand. I just wanted to let you know that I am not following.
<MichaelRaskin>
And to support that in STEP-OVER I need to implement some special cases carefully.
<MichaelRaskin>
I haven't yet, and debugging that code turns out to be a bit annoying.
spm_ has quit [Read error: Connection reset by peer]
spm_ has joined #lisp
makomo has joined #lisp
Ukari has quit [Remote host closed the connection]
jack_rabbit has joined #lisp
dcluna has quit [Ping timeout: 240 seconds]
dcluna has joined #lisp
Ukari has joined #lisp
Inline has quit [Quit: Leaving]
groovy2shoes has quit [Ping timeout: 260 seconds]
pagnol has joined #lisp
caltelt_ has quit [Ping timeout: 256 seconds]
fraya has joined #lisp
robotoad has quit [Max SendQ exceeded]
robotoad has joined #lisp
MichaelRaskin has quit [Quit: MichaelRaskin]
asarch has quit [Quit: Leaving]
flamebeard has joined #lisp
jlarocco has quit [Remote host closed the connection]
jlarocco has joined #lisp
Myon has quit [Ping timeout: 255 seconds]
Myon has joined #lisp
SlowJimmy has joined #lisp
bigfondue has quit [Ping timeout: 245 seconds]
arkaros has joined #lisp
Folkol_ has joined #lisp
groovy2shoes has joined #lisp
shrdlu68 has joined #lisp
montxero has joined #lisp
arkaros has quit [Ping timeout: 260 seconds]
arkaros has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
Xof has quit [Remote host closed the connection]
Xof has joined #lisp
Athas has joined #lisp
fraya has quit [Remote host closed the connection]
Folkol_ has quit [Ping timeout: 256 seconds]
bigfondue has joined #lisp
makomo has joined #lisp
Smokitch has joined #lisp
AetherWind has joined #lisp
lel has quit [Ping timeout: 248 seconds]
Fredman97 has joined #lisp
arkaros has quit [Ping timeout: 245 seconds]
fraya has joined #lisp
fikka has joined #lisp
arkaros has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
lel has joined #lisp
Ricchi has quit [Read error: Connection reset by peer]
shangul has joined #lisp
fraya has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
dddddd has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
nsrahmad has joined #lisp
fikka has joined #lisp
lagagain has quit [Quit: Connection closed for inactivity]
smurfrobot has joined #lisp
schweers has joined #lisp
easye has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
easye has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
montxero has left #lisp [#lisp]
hhdave has joined #lisp
makomo has joined #lisp
varjag has joined #lisp
SlowJimmy has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 260 seconds]
eMBee has quit [Quit: leaving]
eMBee has joined #lisp
scymtym has quit [Remote host closed the connection]
kozy has quit [Read error: No route to host]
kozy_ has joined #lisp
mflem has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
makomo has quit [Quit: WeeChat 2.0.1]
nsrahmad has quit [Ping timeout: 276 seconds]
makomo has joined #lisp
makomo has quit [Ping timeout: 264 seconds]
_cosmonaut_ has joined #lisp
makomo has joined #lisp
scymtym has joined #lisp
shangul has quit [Remote host closed the connection]
shangul has joined #lisp
kozy_ has quit [Ping timeout: 264 seconds]
kozy has joined #lisp
kozy has quit [Read error: Connection reset by peer]
Athas has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
igemnace has quit [Read error: Connection reset by peer]
jmarciano has joined #lisp
fikka has joined #lisp
lumm has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
arkaros has joined #lisp
arkaros has left #lisp [#lisp]
arkaros has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Guest33711 has quit [Remote host closed the connection]
itruslove has quit [Remote host closed the connection]
lumm has quit [Read error: Connection reset by peer]
giraffe has joined #lisp
mangul is now known as shangul
giraffe is now known as Guest34814
itruslove has joined #lisp
<arkaros>
Hello all lispers just curious what are you guys working with currently?
<beach>
minion: Please tell arkaros about SICL.
<minion>
arkaros: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<beach>
minion: Please tell arkaros about Cleavir.
<minion>
arkaros: Cleavir: A project to create an implementation-independent compilation framework for Common Lisp. Currently Cleavir is part of SICL, but that might change in the future
<arkaros>
Cool i will make sure to look in to it. I'm mostly looking for some lisp code to read and play around with. Im just getting in to lisp. Have some clojure experience but not much
<beach>
What kind of code are interested in looking at?
<arkaros>
Not sure hehe
<jackdaniel>
arkaros: there is a good book about Common Lisp: Practical Common Lisp
<jackdaniel>
minion: please tell arkaros about pcl
<minion>
arkaros: direct your attention towards pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
milanj has quit [Read error: Connection reset by peer]
jmarciano has quit [Read error: Connection reset by peer]
<jackdaniel>
it shows many important aspects of the language (it is a bit clos-centric though)
<jackdaniel>
for a different perspective you may take a look at ANSI Common Lisp by Paul Graham (you need to pay for this one though)
<arkaros>
Thanks you guys have been really nice. I would love to get in to lisp a bit more since I really like the simplicity (but at the same time complexity) of the language
fikka has joined #lisp
<beach>
arkaros: You can come here for advice when you start producing code. Also, before deciding on what to install and how, you should ask advice.
<beach>
It is easy to get it wrong.
<LdBeth>
Where can I learn about funcallable instance?
<arkaros>
What i have installed now is SBCL and also set up quicklisp for it
<beach>
arkaros: You should also install SLIME for Emacs.
<jackdaniel>
that's the most common setup (+ emacs and slime)
<jackdaniel>
also shinmera has prepackaged all these things in "Portacle"
<arkaros>
I used to use emacs actually but i prefer vim since i think that it integrates better in my current work flow
<LdBeth>
Too bad
<beach>
arkaros: Then you should try to find something SLIME-like for vim.
makomo has quit [Ping timeout: 264 seconds]
<beach>
arkaros: Otherwise your Common Lisp work flow will be seriously slowed down.
<arkaros>
I always have the option to jump back in to emacs too.
<beach>
Sure, if you can do that. Some people seem unable to switch between editors.
<arkaros>
But at the moment I work as an android developer so i spend most of the time in android studio and use vim mostly for quick edits for git commits and README files
Folkol_ has joined #lisp
<jackdaniel>
it is a shame that the only way to be productive in CL is to use emacs, which is pretty awkward editor if you ask me
<jackdaniel>
there is slimv for vim, but I don't know how well it works
<arkaros>
I quite liked emacs. Especially since i used spacemacs that had most of the config premade for me
<arkaros>
And with evil mode it was not that differnt from using vim any how
gabiruh has quit [Ping timeout: 265 seconds]
<beach>
jackdaniel: What do you find awkward about it?
<arkaros>
The main issue for me is that I use the reminal quite heavily and the terminal emulator in emacs just wasn't that good imo and tmux+vim just made more sense to me
<arkaros>
terminal*;2~
<LdBeth>
There are several different IDE’s, although they are all Emacs like
<LdBeth>
That’s to say, they just happen to share a fair amount of keybindings, and they all use a dialect of lisp as config language.
fikka has joined #lisp
gabiruh has joined #lisp
<dim>
jackdaniel: I prefer M-x shell over M-x term, and I've reduced my use of a terminal to almost nil these days
milanj has quit [Read error: Connection reset by peer]
<dim>
oh sorry I think that was directed at arkaros
fikka has quit [Ping timeout: 240 seconds]
<arkaros>
But i actually prefer the terminal to almost any tool i have used so far. For instance git integration is mostly just a wrapper around the command line git client. Quite often i find my self needing to to something custom and need to jump back in to the terminal and run git from there so I though why no use it directly
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
Folkol_ has quit [Ping timeout: 240 seconds]
<dim>
the terminal is not the same thing as the shell, what you're talking about seems to be a shell, and M-x shell provides a very nice environment wherein to run shell commands
<dim>
then there's M-x eshell too, but I'm yet to play with that, even though I hear it's pretty awesome
devon has joined #lisp
papachan has joined #lisp
papachan has quit [Client Quit]
<devon>
(loop with a = (list 1 2 3) for b on a when (evenp (car b)) do (push -1 (cdr b)) finally (return a)) ; result specified or unspecified?
<beach>
devon: Unspecified I believe.
<devon>
Trying to find the relevant section in the spec.
<beach>
devon: But, instead of using the ON loop keyword, you can use FOR B = A then (CDR B)
<arkaros>
-1
<beach>
devon: Let me see if I can find it for you...
<beach>
devon: But you can easily get around the problem like I suggested.
<LdBeth>
devon: (1 2 3)
<beach>
LdBeth: What?
<devon>
LdBeth: Lol, in which implementation?
<beach>
LdBeth: What happens in a particular implementation does not determine what is specified or unspecified by the Common Lisp HyperSpec.
<LdBeth>
Xdevon: both CCL and Emacs’s cl-loop
<devon>
Definitely not in CCL
<devon>
Nor in emacs
arkaros has quit [Ping timeout: 240 seconds]
<beach>
devon: (loop with a = (list 1 2 3) for b = a then (cdr b) until (null b) when (evenp (car b)) do (push -1 (cdr b)) finally (return a))
<LdBeth>
How does FOR keyword different from WITH?
<devon>
with is once, for is every time
<beach>
devon: Oh, sorry, perhaps you weren't interested in doing this at all, just in knowing the relevant section in the Common Lisp HyperSpec.
Kaisyu has joined #lisp
<devon>
Perhaps I should not hack before breakfast, I forget essential things like where to look in the spec - but I did want to know whether to use ON vs. = a then (cdr b)
shangul has quit [Ping timeout: 240 seconds]
<devon>
beach: Thanks again.
<beach>
Sure.
arkaros has joined #lisp
eschatologist has quit [Ping timeout: 244 seconds]
eschatologist has joined #lisp
mrcom has quit [Ping timeout: 264 seconds]
<jackdaniel>
beach: sorry, didn't have this terminal open. for once, the way buffers jump into each other is incomprehensible - it is impossible to have a static frame layout for me. other than that, it is a tool impossible to master for me – I know less than 5% of it despite exclusive use for around 8 years (and getting it to usable state as a text editor took me > month, so the learning curve is not quite steep)
igemnace has joined #lisp
<jackdaniel>
I could think of many other things, but the first one is the most annoying (and I'm sure there is some magic combo of settings and elisp scripts which solves that); second one is a dreadful blocker for many people I try to convince to use CL (and I really don't like emacs myself, despite said exclusive use)
<beach>
I understand.
milanj has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
devon has quit [Ping timeout: 276 seconds]
<dim>
jackdaniel: I'm using several packages to tame the layout problems
Bike has joined #lisp
arkaros has quit [Ping timeout: 245 seconds]
<dim>
jackdaniel: escreen and popwin
doesthiswork has joined #lisp
<dim>
popwin is pretty good at maintaining your layout, and worst case, C-g gets you back to the one you like in many situations
<dim>
I also have: C-c <left> runs the command winner-undo
<dim>
but we're shifting to Emacs topic rather than CL here, sorry about that, I guess it's still relevant as it helps with using SLIME…
Arcaelyx has joined #lisp
fikka has joined #lisp
pagnol has quit [Quit: Ex-Chat]
White_Flame has quit [Ping timeout: 265 seconds]
White_Flame has joined #lisp
jmercouris has joined #lisp
<jmercouris>
I'm trying to make a sort of "lazy list" type object that you can iterate for
<jmercouris>
so for example (loop for element in lazy_list do ...)
<jmercouris>
I want it to only generate or get element when it gets to that item
<jmercouris>
how can I do this?
<jmercouris>
is there a generator paradigm equivalent in lisp?
<dlowe>
(loop for x = (funcall (lambda () (get-next))) ...)
<dlowe>
Series would be a lot better if it were built into the implementation
dtornabene has joined #lisp
<jmercouris>
dlowe: aha, that is very simple indeed
<jmercouris>
dim: also interesting, but I prefer no external dependencies when possible
<jmercouris>
I like dlowe's solution simpley enough
<dlowe>
The current implementation is non-composable.
<dim>
oh you're a NOH person, ok
<dim>
I meant to write NIH, oops
<jmercouris>
dim: No, I'm a carefully select dependencies here type person
<jmercouris>
I do use dependencies in my projects, but sparingly
<dim>
and that's not the same thing?
<jmercouris>
no, it isn't
<jmercouris>
I don't think using a thunk is reinventing the wheel
<jmercouris>
if several people in the channel know about it, it must be a pretty consistent pattern
<jmercouris>
s/consistent/common
ineiros has quit [Ping timeout: 256 seconds]
arkaros has joined #lisp
arkaros has left #lisp [#lisp]
warweasle has joined #lisp
<dim>
well it's always the same thing, it begins with a single simple enough use case than reusing known tricks is good, and then you take it to the next level, with a couple of API calls abstracted over the technique, and... soon enough you reinvented the lib you didn't want to import
devon has joined #lisp
<dim>
hindsight is 20/20 as they say
<dim>
so it's not easy to differienciate NIH from reusing known techniques on your own code, in my opinion
<warweasle>
dim: For warned is for armed.
<dim>
I prefer to say that it's the same thing, and not call NIH bad per-se, but only most occurences of it
<warweasle>
Also, anyone who has four arms is psychic because four armed is forewarned.
<jmercouris>
I'm weary, lisp may be a new language to me, but I've been a developer for many years
<jmercouris>
I therefore understand and appreciate your advice, but given my context, and my application this problem, I think dlowes approach is sufficient
<dim>
lisp is very different than most other languages in that a lib that has received no commit in the last 5 years is pretty good news, usually means it just works
<jmercouris>
definitely, I've used plenty of very old libs, like s-xml-rpc
devon has quit [Ping timeout: 240 seconds]
mrcom has joined #lisp
Khisanth has quit [Ping timeout: 256 seconds]
<random-nick>
jmercouris: what do you need the lazy list for?
<jmercouris>
random-nick: an expensive operation
<random-nick>
if you're only going to use it for writing iteration in functional style then you should use something like SERIES
<jmercouris>
No need to do all of the expensive operations at once, since the expensive operation is also I/O blocked
<jackdaniel>
dim: thanks, I'll look into these packages
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
mrcom has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
Khisanth has joined #lisp
ogamita has joined #lisp
orivej has joined #lisp
smurfrobot has quit [Remote host closed the connection]
mindCrime has joined #lisp
lumm has joined #lisp
finky has joined #lisp
<dlowe>
series strikes me as a thing you either want to use everywhere or not at all
mrcom has joined #lisp
sjl has joined #lisp
finky has quit [Quit: Leaving]
kuribas has joined #lisp
lumm_ has joined #lisp
<kuribas>
if I make an array with (make-array 8 :element-type '(signed-byte 8)), does it use efficient storage?
<kuribas>
(8 bytes)
<kuribas>
+ some header stuff
<beach>
kuribas: Depends on the implementation.
<kuribas>
beach: sbcl
<trittweiler>
kuribas: (upgraded-array-element-type '(signed-byte 8)) will tell you the actual element-type that your implementation uses
<beach>
kuribas: I am not sure.
markoong has joined #lisp
lumm has quit [Ping timeout: 256 seconds]
lumm_ is now known as lumm
<kuribas>
trittweiler: it returns (SIGNED-BYTE 8)
fyodost has quit [Quit: Leaving]
smurfrobot has joined #lisp
Inline has joined #lisp
<trittweiler>
kuribas: So that should mean that it will use a byte to store the elements. You can play with upgraded-array-element-type, e.g. try '(signed-byte 11) or '(signed-byte 65)
<kuribas>
trittweiler: interestingly, 52 returns FIXNUM, 65 returns T
<trittweiler>
That sounds quite reasonable to me :)
<trittweiler>
T means here that it will be an array of pointers.
<kuribas>
trittweiler: what about fixnum?
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
ineiros has joined #lisp
<beach>
kuribas: Fixnum means a number that will fit in a pointer. As I recall, SBCL has a single tag bit for fixnums, so a fixnum contains 63 significant bits.
<trittweiler>
kuribas: Lisps usually uses tagged pointers. This means that some bits of each pointer are used to represent types (the "tag"). A fixnum is a pointer where non-tag bits represent a number
<Xach>
re tcr
<kuribas>
I see. Haskell does that as well.
Bike_ has joined #lisp
igemnace has quit [Remote host closed the connection]
<beach>
kuribas: But it probably doesn't have to. In a dynamically typed language like Common Lisp, objects must be tagged so that the type can be determined at run time.
pfdietz has joined #lisp
Bike has quit [Disconnected by services]
Bike_ is now known as Bike
<scymtym>
tags can be omitted within specialized arrays, though
<xificurC>
I would be surprised if haskell did that
<xificurC>
in the final compiled representation
<beach>
xificurC: What, tagging objects?
<xificurC>
beach: yes
<beach>
xificurC: It is sometimes used in order to simplify the garbage collector.
ogamita has quit [Ping timeout: 264 seconds]
<xificurC>
beach: true, forgot about that. Will have to check
<kuribas>
beach: I presume it's because of thunks
<kuribas>
beach: to enable integers to be lazy
<beach>
kuribas: I don't understand.
warweasle has joined #lisp
<kuribas>
beach: values in haskell can be unevaluated, and the compiler must be able to check for that.
<beach>
Sure, but I don't see why tag bits would be required for that.
omilu has quit [Remote host closed the connection]
<kuribas>
xificurC: ghc is de de-facto standard implementation.
<xificurC>
kuribas: you mean the only implementation that survived and has so many non-standardized but useful extensions that noone is considering any other options?
mindCrime has quit [Ping timeout: 260 seconds]
<kuribas>
xificurC: basically yes
<kuribas>
xificurC: also the most advanced in terms of optimizations and code generation.
<xificurC>
kuribas: I think jhc was very good too, not sure what happened to it. But we're getting off topic now
<beach>
Indeed.
<beach>
Lucky for us, we have several good implementations that all seem to survive.
smurfrobot has quit [Remote host closed the connection]
asarch has joined #lisp
smurfrobot has joined #lisp
<kuribas>
beach: it seems that Int and Int64 are the same. So I suppose the two reserved bits are intended for tagging, but not used in ghc...
<xificurC>
beach: I think the CL standard is a bit more feature complete :)
<beach>
kuribas: As xificurC pointed out, we should get back to the topic.
Denommus has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
Denommus has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 268 seconds]
nowhere_man has quit [Ping timeout: 245 seconds]
skapata has joined #lisp
Denommus has joined #lisp
xrash has joined #lisp
kuwze has quit [Quit: Page closed]
kozy has quit [Quit: No Ping reply in 180 seconds.]
kozy has joined #lisp
guaqua has quit [Ping timeout: 268 seconds]
lumm_ has joined #lisp
kozy has quit [Read error: Connection reset by peer]
kozy has joined #lisp
lumm has quit [Ping timeout: 260 seconds]
lumm_ is now known as lumm
kozy has quit [Read error: Connection reset by peer]
buffergn0me has joined #lisp
smurfrobot has joined #lisp
guaqua has joined #lisp
papachan has joined #lisp
nowhere_man has joined #lisp
shrdlu68 has quit [Ping timeout: 276 seconds]
mindCrime has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
ineiros has quit [Ping timeout: 264 seconds]
ineiros has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
nowhere_man has quit [Remote host closed the connection]
smurfrobot has quit [Remote host closed the connection]
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
kajo has joined #lisp
smurfrobot has joined #lisp
nowhere_man has joined #lisp
ineiros has quit [Ping timeout: 256 seconds]
ineiros has joined #lisp
asarch_ has joined #lisp
Folkol_ has joined #lisp
asarch has quit [Ping timeout: 256 seconds]
nowhere_man has quit [Ping timeout: 240 seconds]
igemnace has joined #lisp
ineiros has quit [Remote host closed the connection]
al-damiri has joined #lisp
ineiros has joined #lisp
ineiros has quit [Ping timeout: 245 seconds]
ineiros has joined #lisp
dtornabene has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
kajo has quit [Ping timeout: 256 seconds]
kajo has joined #lisp
kuwze has joined #lisp
kuribas has quit [Remote host closed the connection]
buffergn0me has quit [Ping timeout: 240 seconds]
hhdave has quit [Ping timeout: 256 seconds]
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
DemolitionMan has joined #lisp
flamebeard has quit []
pjb has joined #lisp
jmercouris has quit [Ping timeout: 264 seconds]
aindilis has quit [Remote host closed the connection]
nowhere_man has joined #lisp
``Erik has joined #lisp
makomo has joined #lisp
Beep-Lord has joined #lisp
orivej has joined #lisp
lumm has quit [Ping timeout: 248 seconds]
asarch_ has quit [Quit: Leaving]
lumm has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
brendyn has quit [Ping timeout: 256 seconds]
oni-on-ion has quit [Read error: No route to host]
MoziM has quit [Quit: WeeChat 2.1]
shifty has quit [Ping timeout: 240 seconds]
slyrus1 has joined #lisp
varjag has joined #lisp
eli_oat has quit [Quit: Leaving.]
Kaisyu has quit [Quit: Connection closed for inactivity]
lumm has quit [Ping timeout: 245 seconds]
oni-on-ion has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
aindilis has joined #lisp
dtornabene has joined #lisp
igemnace has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
lisping_lisp has joined #lisp
vap1 has quit [Ping timeout: 260 seconds]
vaporatorius has joined #lisp
vaporatorius__ has joined #lisp
moei has quit [Quit: Leaving...]
housel has quit [Remote host closed the connection]
m00natic has quit [Remote host closed the connection]
Quetzal2 has joined #lisp
vaporatorius has quit [Quit: Leaving]
guaqua has quit [Ping timeout: 240 seconds]
lumm has joined #lisp
guaqua has joined #lisp
lisping_lisp has quit []
<makomo>
what would be the difference between: (1) an accessor, (2) a place and (3) a generalized reference? i suppose (2) == (3) but (1) is the name of the operator within *some* of the places (some places might not use an accessor). is this right?
<Inline>
an acessor, is an acessor, they can be either read or both (read-write)
<Bike>
according to the glossary, an accessor is an operator that performs an access, and an access is to read or write a place.
<Inline>
a place as a storage, can be both read and writ
<Inline>
unless prohibited
<makomo>
Bike: yes, i've checked out the glossary first, but for example, (setf a 10)
<makomo>
supposing a is not a symbol-macro, is a an accessor?
<Bike>
it's not an operator,so i guessnot.
<makomo>
i don't think so, it's only a place/generalized reference
<makomo>
right
<makomo>
so not all places/generalized references have operators/accessors within them
<makomo>
but can every accessor be used as a place?
<Inline>
when it can be writ to yes
<makomo>
ah, true
<makomo>
right, one might provide F but not (SETF F)
<Inline>
otherwise there are read-only acessors, in which case you don't call them acessors or so
<Inline>
just a read-only slot
<makomo>
well, you'd still call them accessors, as per the glossary
<Inline>
ah ok then
guaqua has quit [Ping timeout: 265 seconds]
<makomo>
also, they don't have to read/write slots do they
<makomo>
you can write an """accessor""" that does something completely different
<makomo>
well, doing something dumb would be an extreme example
<Inline>
sorry, i mean an acessor is a slot
<makomo>
but it could set a global variable for example
<Inline>
rather than has a slot
<makomo>
that's not right though
<makomo>
an accessor is an *operator*
<makomo>
the glossary says so
<Inline>
well yes ofc
<makomo>
right, so it can't be a slot, but it *might* fiddle around with a slot
<makomo>
although it doesn't have to
<makomo>
so the two aren't directly related
<makomo>
so places == generalized references, but accessors are a thing of their own and could be used within places
<Inline>
maybe i should have said, it's an operator, defined in the context of a slot (but the slot can name it's acessors name, so it's independent of it) and it can fiddle with anything it's designed to
vlatkoB has quit [Client Quit]
<Inline>
if the accessors name happens to be referencing a function (i.e. pointing to it) then it will be a function, otherwise it can be anything
vlatkoB has joined #lisp
<Inline>
function, macro.....
<Inline>
or am i wrong ?
guaqua has joined #lisp
eli_oat has joined #lisp
_cosmonaut_ has quit [Ping timeout: 245 seconds]
<makomo>
Inline: an accessor doesn't necessarily have anything to do with slots. DEFCLASS has the option of defining accessor for your slots for you, but all it does is define a function of the same name that sets the object's slot
<makomo>
the two aren't directly related
<makomo>
i could also have an accessor with the name FOO that sets a slot named BAR
<makomo>
i could also have an accessor FOO that sets a global variable called *HELLO*
<makomo>
and/or reads it as well
<makomo>
of defining accessors*
<makomo>
also, in the context of DEFCLASS, they're not plain functions but generic functions/methods
moei has joined #lisp
<Inline>
ya ok
eli_oat has quit [Quit: Leaving.]
eli_oat has joined #lisp
Beep-Lord has quit [Ping timeout: 265 seconds]
smurfrobot has quit [Remote host closed the connection]
sauvin has quit [Read error: Connection reset by peer]
guaqua has quit [Ping timeout: 256 seconds]
kuwze has quit [Quit: Page closed]
smurfrobot has joined #lisp
guaqua has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
guaqua has quit [Ping timeout: 248 seconds]
eli_oat has quit [Quit: Leaving.]
eli_oat has joined #lisp
fikka has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
guaqua has joined #lisp
dddddd has quit [Remote host closed the connection]
dddddd has joined #lisp
pfdietz2 has joined #lisp
Lauven has joined #lisp
smasta has joined #lisp
smurfrobot has quit [Remote host closed the connection]
mindCrime has quit [Read error: Connection reset by peer]
zachk has joined #lisp
mindCrime has joined #lisp
smasta has quit [Client Quit]
zachk has quit [Changing host]
zachk has joined #lisp
Yaargh has left #lisp ["Closing Window"]
fikka has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
lumm has quit [Read error: Connection reset by peer]
Murii_ has joined #lisp
fikka has joined #lisp
caltelt has quit [Ping timeout: 248 seconds]
Smokitch has quit []
igemnace has quit [Remote host closed the connection]
caltelt has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Jesin has quit [Quit: Leaving]
jibanes has quit [Ping timeout: 248 seconds]
jibanes has joined #lisp
fikka has joined #lisp
Beep-Lord has joined #lisp
eli_oat has quit [Quit: Leaving.]
Murii_ has quit [Quit: Leaving]
fikka has quit [Ping timeout: 255 seconds]
Murii_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
eli_oat has joined #lisp
SenasOzys has joined #lisp
eli_oat has quit [Quit: Leaving.]
milanj has quit [Quit: This computer has gone to sleep]
milanj has joined #lisp
fikka has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
Jesin has joined #lisp
energizer has quit [Quit: ZNC 1.6.3+deb1 - http://znc.in]
energizer has joined #lisp
smurfrobot has joined #lisp
milanj has quit [Ping timeout: 276 seconds]
Myon has quit [Quit: reboot]
smurfrobot has quit [Remote host closed the connection]
<dtornabene>
why did no one tell me about universal time
fikka has quit [Ping timeout: 264 seconds]
<dtornabene>
this aggression will not stand
smurfrobot has joined #lisp
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
smurfrobot has quit [Remote host closed the connection]
pfdietz2 has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
fikka has joined #lisp
Folkol has quit [Ping timeout: 240 seconds]
energizer has quit [Quit: ZNC 1.7.0+deb0+xenial1 - https://znc.in]
eli_oat[m] has joined #lisp
spm_ has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
energizer has joined #lisp
smurfrobot has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
MolluskEmpire has quit [Ping timeout: 265 seconds]
<dxtr>
So is there a complete list of all the quicklisp packages with the description of each package?
<dxtr>
The reason I'm asking is because I want to code something but I can't really come up with anything fun to do so I was hoping to get some inspiration from that list :)
pfdietz2 has quit [Ping timeout: 256 seconds]
dmiles has quit [Read error: Connection reset by peer]
Naergon has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
logicmoo has joined #lisp
Domaldel has joined #lisp
Bike has joined #lisp
SlowJimmy has joined #lisp
smurfrobot has joined #lisp
<Beep-Lord>
dxtr, port Perl 6's grammars to lisp. I would be eternally grateful.
_cosmonaut_ has quit [Ping timeout: 248 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
random-nick has quit [Read error: Connection reset by peer]
<pillton>
dxtr: I got as far as (map nil (lambda (s) (print (ql-dist:short-description s))) (ql:provided-systems (ql-dist:find-dist "quicklisp"))).
<pillton>
dxtr: I don't think long descriptions are part of the quicklisp distribution metadata.
<mfiano>
I would urge you to a) work on something in Lisp, rather than some foreign bindings, and b) work on something that would benefit the Lisp ecosystem -- if it's duplicated work, it should be for good reason, but there are lots of areas untouched still that would benefit all.
<mfiano>
So looking at a list of existing Lisp software may or may not be a good idea. It'd be a good idea if it's to check what is not already available.
_cosmonaut_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
lumm has quit [Ping timeout: 264 seconds]
sz0 has joined #lisp
<pillton>
I don't understand people's aversion to foreign bindings.
<Beep-Lord>
pillton, it's pretty much all I do. I wrote a library to help me change functionality of foreign libraries on the fly because I do it a lot it seems.
<akkad>
,clhs foreign binding
smurfrobot has joined #lisp
<aeth>
pillton: It turns debugging and packaging binaries into a nightmare.
<aeth>
And you lose all safety.
<mfiano>
and it's not Lisp and cannot conform to a standard that enables less bitrot.
Ukari has quit [Ping timeout: 268 seconds]
<pillton>
I understand the issues surrounding debugging. The binary packaging can be fixed. People don't complain about having to ship resources like images, video, 3D meshes and the like.
<aeth>
Resources are ideally the same thing on every platform. Compiled C libraries are not.
<pillton>
You can't ship platform independent lisp applications.
<aeth>
Compiling CL that works on both Linux and Windows is a completely different thing than compiling C than works on both Linux and Windows.
kjeldahl has quit [Ping timeout: 245 seconds]
<aeth>
For one, you can use SBCL on both Linux and Windows. You'd generally use an entirely different C compiler on Linux than on Windows afaik.
<aeth>
So now you have cross-implementation issues as well as cross-OS issues.
<pillton>
You have cross platform issues anyway with pathnames.
<mfiano>
Side topic: If I were to develop a large project with many tens or even hundreds of files offering a wide variety of functionality, that has already been decided not to be split up into several systems for internal reasons, my first instinct would be to split it up logically into multiple packages. I've never developed such monolithic applications apart a few game engines where package exports and the like soon
<mfiano>
became a problem. I'm wondering if anyone has developed very large systems using a different packaging scheme. My primary concern is preventing myself and other the other developers from maintaining an internal use API with exports, and a user API in parallel, because I dislike accessing un-exported symbols cross-package with ::. Thoughts?
Ukari has joined #lisp
<raynold>
ahh it's a wonderful day
robotoad has joined #lisp
<Beep-Lord>
Does anyone know how big the binary for ECL is?
<pillton>
aeth: UIOP is a common lisp system designed to address incompatibilities across common lisp implementations. The same approach could be used to solve the C issues you mentioned.
smurfrobot has quit [Remote host closed the connection]
<White_Flame>
just get cracking on a C&C++->Lisp "transpiler"
<White_Flame>
it's not like it's without precedent
<White_Flame>
and for binaries, just do like console emulators and dynarec x86/64 to CL :)
smurfrobot has joined #lisp
fikka has joined #lisp
dddddd has quit [Read error: Connection reset by peer]
<Beep-Lord>
Has there been any work started on dynarec for CL?
<pillton>
What is the likelihood of finding people willing and capable of implementing things like eigen decomposition, singular value decomposition, image codecs and video codecs in CL?
caltelt_ has joined #lisp
<ebrasca>
Is there some cache system in common lisp for file systems?
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<pfdietz>
mfiano: use of :: is a code smell.
<slyrus_>
pillton, i'm guessing there are many svd implementations in CL
hph^ has joined #lisp
<ebrasca>
pfdietz: What is bad with :: ?
<pillton>
slyrus_: Sure, but I bet most of them are the power method.
fikka has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Ping timeout: 248 seconds]
<pfdietz>
If you use ::, you are exposing the entire inside of a package to your use. The maintainer of that package either can't change anything, or can break what you're depending on. Exported symbols, on the other hand, are the public interface that can be held steady.
<ebrasca>
pfdietz: I am using some functions with :: .
Kaisyu has joined #lisp
fikka has joined #lisp
Jesin has quit [Quit: Leaving]
<White_Flame>
I use in on rare occasion where 1 package that I control needs to do some deep-dive into another packaget that I also control, for some lower level stuff that I really don't want public
fikka has quit [Ping timeout: 260 seconds]
<White_Flame>
and of course, it's always encapsulated in a small utility function
subroot has joined #lisp
fikka has joined #lisp
<aeth>
White_Flame: I have an idea to use a C->CL that uses CFFI data structures
<aeth>
So in some sense, it would be 'real' C.
<aeth>
Perhaps LLVM IR would be better, if it's high level enough (never looked at it)
<pillton>
aeth: The fundamental principles of Microsoft's Component Object Model are sufficient.
* pillton
apologises for the tautology.
<pillton>
aeth: Which can be implemented using CFFI alone.
lel has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 256 seconds]
<aeth>
Let's say that there's a function and the function is defun'd under a top-level let to get variables that persist across calls to that function. How would this interact with threads?
<aeth>
The function would always be called in the same thread, but not the thread where it was defined.
<Bike>
are you asking how threads and closures go together?
<pillton>
I doubt there would be a lexical environment per thread if that is what you are asking.
orivej has quit [Ping timeout: 256 seconds]
lel has joined #lisp
<aeth>
Would there be a performance issue with such a closure being accessible to all threads? The potential to be out of sync?
<aeth>
Would it need locks/etc.?
smurfrobot has quit [Remote host closed the connection]
<Bike>
i would expect access to closure variables to be atomic
fikka has joined #lisp
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Lord_Nightmare has quit [Ping timeout: 276 seconds]
<pillton>
There was a blog post about this subject years and years ago. Something about lock free communication between threads. I think it was by Christophe Rhodes or Paul Khuong but I cannot find it.