<jcowan>
a book called "Implementations of Prolog"
<no-defun-allowed>
(And I recall in a SICP video, Sussman stated he thought implementing logic programming with streams was simpler than with continuations.)
<Josh_2>
When using :export in defpackage do I have to use symbols?
<jcowan>
on the bad side, there are typos in the code; it obviously was retyped by someone who couldn't count parens
<LdBeth>
Wait, you lisp people all can counting parens from just a glance?
<easye>
LdBeth: you get to the point that the "shape" of the code looks wrong.
* easye
is kinda reminded about the similarity to the shape of "correct" sexpr to that of a pattern in Go that will "live".
<Josh_2>
I defined a package, exported some symbols and then used that package in another but I have to refer to the functions within that package with a double colon.. <package>::<function> I was hoping the symbols would simply be imported and I could refer to them simply as (<function>) what have I oofed?
notzmv has joined #lisp
<clothespin>
:use
<pjb>
LdBeth: yes, lispers are magical beings able to match parens at a glance!
<pjb>
LdBeth: once I found a bug for a single wrong pixel on the screen (true stories, it was in 1986, the screens had only (* 512 348) #| --> 178176 |# pixels! ;-)).
<Josh_2>
clothespin: I have used :use
DGASAU has joined #lisp
smokeink has joined #lisp
<jcowan>
LdBeth: I messed with this program a few decades ago and a friend and I carefully counted the parens and figured out which ones to insert/delete. Unfortunately I lost the hard copy on which I did that.
Hofpfist` has joined #lisp
<jcowan>
Lispers *with emacs* are magical beings etc. etc. Lispers without emacs, like me, have to recite "end of this, end of that" as we go. Not too hard really
<clothespin>
try debugging from the repl with (in-package :second-pkg)
<jcowan>
I mutter "cons cons a b end-of-cons c end-of cons" to myself as I go.
lucasb has quit [Quit: Connection closed for inactivity]
<jcowan>
where "end-of-*" is typed ")"
<LdBeth>
jcowan: yeah that’s what I thought, figuring out parentheses printed on paper is not easy to me
Hofpfister has quit [Ping timeout: 268 seconds]
<Josh_2>
clothespin: I am in the second package in the repl and I have to refer to my previous packages functions with <package>::<func> even though I have them in the :export clause of (defpackage )
orivej has quit [Ping timeout: 276 seconds]
<clothespin>
some lisps get buggy when redefining packages, try (symbol-package 'my-symbol) for debugging
<clothespin>
buggy not meaning their wrong, just meaning they get upset
<Josh_2>
it says It's in my package
<Josh_2>
I think I will restart my image and try again
<clothespin>
first or second
<Josh_2>
second
<clothespin>
sbcl gets upset, allegrocl quietly makes package changes
<Josh_2>
It's ccl
<clothespin>
if you intern the symbol in the second package before putting it in your :use it could act like that
<Josh_2>
it was actually sbcl sorry, I had ccl and sbcl both running remotely oof
<Josh_2>
Okay
<Josh_2>
Well I restarted my image and It's working now
<Josh_2>
I don't even know xD
<pjb>
clothespin: you may want to use (com.informatimago.tools.symbols:check-duplicate-symbols)
<clothespin>
slime can intern symbols without you being concious of it
<Josh_2>
Well It's working now anyways
<Josh_2>
Thanks for the help :)
<clothespin>
i usually restart sbcl as well but for the record i rarely had to do that with allegeocl
meepdeew has joined #lisp
<Josh_2>
Restarting isn't really a problem when It's running locally
<Josh_2>
but I am connecting to an instance on an external server oof
trufas has joined #lisp
clothespin_ has joined #lisp
trufas has quit [Ping timeout: 246 seconds]
Josh_2 has quit [Ping timeout: 252 seconds]
clothespin has quit [Ping timeout: 276 seconds]
_jrjsmrtn has quit [Ping timeout: 265 seconds]
__jrjsmrtn__ has joined #lisp
<Xach>
darn it
<Xach>
i wish i was here to help with the package thing earlier
ax-hack has quit [Read error: Connection reset by peer]
ax-hack has joined #lisp
trufas has joined #lisp
Frobozz has joined #lisp
trufas has quit [Ping timeout: 250 seconds]
trufas has joined #lisp
jeosol has joined #lisp
shifty has joined #lisp
trufas has quit [Ping timeout: 252 seconds]
pjb has quit [Ping timeout: 250 seconds]
davepdot_ has joined #lisp
davepdot_ has quit [Ping timeout: 276 seconds]
ax-hack has quit [Read error: Connection reset by peer]
ax-hack has joined #lisp
amerigo has quit [Quit: Connection closed for inactivity]
pjb has joined #lisp
gko` has left #lisp ["ERC (IRC client for Emacs 26.3)"]
bitmapper has quit [Ping timeout: 250 seconds]
ebzzry_ has quit [Ping timeout: 265 seconds]
bacterio has joined #lisp
trufas has joined #lisp
trufas has quit [Ping timeout: 276 seconds]
ax-hack has quit [Ping timeout: 268 seconds]
clothespin__ has joined #lisp
clothespin_ has quit [Ping timeout: 246 seconds]
Oladon has joined #lisp
trufas has joined #lisp
trufas has quit [Ping timeout: 240 seconds]
meepdeew has quit [Quit: Connection closed for inactivity]
<parisienne>
Hello everybody, is it okay to ask a emacs lisp question related to macros here?
<PuercoPope>
parisienne: #emacs is probably the channel you are looking for
<no-defun-allowed>
Probably not, given this is a Common Lisp channel.
refpga has joined #lisp
<parisienne>
yeah, that is why I am asking :) Thank you.
<no-defun-allowed>
Though elisp macros and CL macros are fairly similar, so it still might make sense in a CL context.
khisanth__ has quit [Ping timeout: 265 seconds]
mathrick has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 250 seconds]
<pjb>
parisienne: or ##lisp
mathrick has joined #lisp
orivej has joined #lisp
<parisienne>
yeah, the question I have is kind of generic and related to the appropriate use of macros. Not really about Emacs. Didn't want to risk a kick. What is ##lisp?
<pjb>
##lisp is for lisp in general. #lisp is for common lisp in particular.
<beach>
parisienne: Go ahead and ask. You will be told if your question is not appropriate for this channel.
Lord_of_Life_ is now known as Lord_of_Life
khisanth__ has joined #lisp
_whitelogger has joined #lisp
lottaquestions has quit [Remote host closed the connection]
<pjb>
parisienne: so your question is quite emacs specific. In emacs lisp, like in CL, variables should be declared first. Using setq works, but since emacs 25 there is lexical bindings, so it is very preferable to define variables with defvar… (and of course, also use setq, since emacs lisp doesn't have defparameter, unless you define such a macro).
<parisienne>
the idea was just to have whatever symbol I define to nil. Still not sure about evaluation/compilation process in all the lisps. That is why I wanted to ask here. You can throw a CL example at me if you have anything.
<pjb>
We cannot throw any code at you, since your specifications are unclear.
<parisienne>
specification is basically, I pass in a symbol -> it should generate a "global" variable that gets a value from something else (in this case a file).
<pjb>
You say "define a variable" and you call it setq-something and use setq!
<parisienne>
exactly
<pjb>
You say compile-time, but you only do things at macro-expansion time. And you don't say what happens at run-time.
<pjb>
If you mean "define" what should happen if the variable is already defined?
<parisienne>
at the moment I just call the setq-if-exists in a function and after the call I use the passed in symbol in something else.
<parisienne>
Didn't think about that. But in my mind it should just override whatever value is/was there.
trufas has joined #lisp
<parisienne>
But does this type of usage make sense for macros?
Hofpfist` has quit [Ping timeout: 268 seconds]
<parisienne>
wait, is macro-expansion and compile time different?
<pjb>
Sorry, the fifth lne should be: file :if-does-not-exist nil)))
trufas has quit [Ping timeout: 240 seconds]
<parisienne>
Thank you. So the basic idea would work and it would make sense for a macro?
<pjb>
Well, it's rare to be wanting to load in a variable data at compilation-time. Configuration is something that is more often left for run-time and the end-user or administrator.
<pjb>
Compilation is usually completed long before the software is installed, on a different computer, by different people, than those who will install it, or use it.
<pjb>
While it's possible in lisp to inline data, when we save the program as an executable image, usually programs are distributed with resource files to be installed in specific places on the target system, and loaded at run-time.
<pjb>
It may be worth considering this scheme, notably if the data is big.
<parisienne>
well, the idea for this started when I was writing a REST library in Clojure. What I wanted was to read all the endpoints definitions from a file and generate some base functions at compile time. I would have attempted the same thing in CL. Not sure if my reasoning makes any sense.
<parisienne>
Yeah, that makes absolutely sense.
davepdot_ has joined #lisp
<parisienne>
Your code snippet absolutely covers exactly this.
arma_ has quit [Quit: arma_]
mathrick has quit [Ping timeout: 240 seconds]
davepdot_ has quit [Ping timeout: 265 seconds]
<pjb>
parisienne: when you have something like this, you actually have code in this file. There's no point in using a different system to load this code and compile it than normal lisp code.
<pjb>
parisienne: instead, write a macro to interpret this code, and put it directly in your sources!
dddddd has quit [Remote host closed the connection]
<pjb>
I assume you have a function such as (generate (parse *data-read-at-compilation-time*)) Then you can write: (defmacro define-endpoints (&rest endpoints-definitions) `(generate (parse endpoint-definitions))) ; parsing will be simplier, since the lisp reader will have already tokenized it.
<pjb>
s/`//
<pjb>
parisienne: and thus you write your first embedded DSL.
<parisienne>
pjb: yeah, exactly! This was exactly what I planned to do. But I didn't feel confident doing that yet.
<pjb>
Note the macro cannot be simplier. So you can gain confidence easily, by testing and debugging the parser and the generator independently.
<parisienne>
pjb: exactly. But you got my point and I assume it would not be unusual to see something like that in a library, correct?
ebzzry_ has quit [Quit: WeeChat 2.3]
ebzzry has joined #lisp
<montxero>
I have a question, is it possible to construct an a-list where the cdr is a proper list?
shka_ has joined #lisp
<montxero>
It is almost a contradictory definition, however I would like to hear ideas
shka_ has quit [Ping timeout: 252 seconds]
<pjb>
montxero: (let ((attributes '())) (acons 'colors '(red blue white) attributes)) #| --> ((colors red blue white)) |# seems possible…
<montxero>
pjb: You're here too!!! great. But we get a proper list
<pjb>
It's only the printed representation. Since there are no list and no a-list in lisp (paradox!), you need to interpret the bunch of cons cells as you wish.
refpga has quit [Read error: Connection reset by peer]
<pjb>
When you consider a-lists, ((colors red blue white)) is interpreted as ((colors . (red blue white))).
<beach>
montxero: Maybe there is something I don't understand, but the CDR of an alist is always a proper list.
<pjb>
He meant "an a-list entry".
<beach>
My brain is too small to interpret what people utter in a way that contradicts what they actually did utter.
<fengshaun>
what's an a-list?
<pjb>
An association list.
<pjb>
A p-list is a property list.
<fengshaun>
oh, thanks, like ((a . b) (c . d))?
<beach>
fengshaun: It is defined in the Common Lisp HyperSpec glossary.
<pjb>
There's not much difference between an association and a property, it's just how they're represented: plist: (k1 v1 k2 v2 … kn vn) alist: ((k1 . v1) (k2 . v2) … (kn . vn)).
PuercoPope has quit [Remote host closed the connection]
<fengshaun>
makes sense, thanks!
<pjb>
Furthermore, alist (the CL functions working with a-lists) can use keys of any class (there's a :test argument to use the equality you want), while plist (the CL functions working with p-lists) use only symbols (normally) and always use EQL to compare the keys).
<pjb>
fengshaun: note that both a-list and p-lists use the same number of cons cells, and are as efficient one as the other.
<aeth>
Scheme uses alists because they usually don't have a plist equivalent, and definitely don't portably. In CL, plists tend to be more common than alists.
<aeth>
And almost always with a keyword as the key
<aeth>
The main disadvantage of plists is that you can't use map/mapcar, but you can loop by #'cddr and use a few other things
<aeth>
The main advantage of plists is that you can use &key in destructuring-bind, essentially treating plists like keyword arguments.
<pjb>
Well, you need more parentheses to write a-lists. But there's less risk of desynchronisation with a-lists than p-lists. If you miss two keys or values in a p-list, you can mix it almost entirely: (k1 k2 v2 k3 v3 k4 v4 v5) vs. ((k1) (k2 . v2) (k3 . v3) (k4 . v4) (nil . v5))
brown121408 has quit [Ping timeout: 240 seconds]
brown121407 has joined #lisp
<aeth>
That can get confusing when the key and value are of the same type, usually a keyword in that case. It's the same issue with function calling with keyword arguments. You're basically requiring newlines for clarity at that point.
<aeth>
On the other hand, plists mirror keyword arguments so closely (see my previous two lines) so that's probably why they're more common than alists
<p_l>
'morning
<beach>
Hello p_l.
Oladon has quit [Quit: Leaving.]
<montxero>
beach: nice play the cdr of an a-list is always a proper list. I meant the cdr of an element of an alist
<beach>
OK, so pjb was right.
<montxero>
yeah
anlsh` has joined #lisp
<Cymew>
aeth: Are you sure plists are more common? I find alists are mentioned so often as a suggested solution. I actually struggled to find a plist when I needed an example.
<Shinmera>
every time you call a function with &key you use a plist.
anlsh has quit [Ping timeout: 250 seconds]
DGASAU has quit [Ping timeout: 252 seconds]
<pjb>
a-list might be more common, because you can map other types than symbols (or other EQL-able objects).
<Cymew>
Shinmera: Huh. That is propably making them more common. I wonder how often they are used intentionally, though, rather than that indirect manner. Like pjb say, alists have some flexibility.
<Cymew>
But, I have not read that much new code in a while, so things might have changed. :)
DGASAU has joined #lisp
<aeth>
Cymew: only someone who has all of Quicklisp installed can know for sure, but unlike most things, this would be pretty hard to search. Effectively impossible to get exact numbers on because so many macros implicitly would use plists/alists/etc.
vlatkoB has joined #lisp
<aeth>
any destructuring-bind with &key in a macro is using a plist tail at the very least, if not a full plist
<Cymew>
I'm learning more about implementing lisp cores than I expected. I have never given plists much thought before. I have been enlightened.
<Cymew>
I should get back to hacking lisp again.
dale has quit [Quit: My computer has gone to sleep]
<p_l>
Cymew: plists were also basis of the original "object orientation" in Lisp
<p_l>
(back when it was all caps)
brettgilio has joined #lisp
<pjb>
And of course, it was an essential implementation data structure, since symbol themselves were implemented as a plist (we still have symbol-plist, but the symbol name, the function slot, the value slot, and others were stored on the symbol plist in LISP 1.5).
<Cymew>
I remember reading something like that once, probably some lm docs.
<p_l>
by the time of LM the symbols were a more complex structure already
<beach>
p_l: More complex than what?
<p_l>
beach: more complex than just a plist, an early specialized structure
<beach>
I see. So with SICL symbols, I am going back in time.
<p_l>
beach: depends how far
<beach>
A symbol has only a name and a package in SICL.
<p_l>
beach: how do you access standard symbol slots in this case?
<beach>
There is no such thing as "standard symbol slots" that I know of.
<p_l>
beach: symbol-function, symbol-value, symbol-plist, etc.
<beach>
They are in a first-class global environment.
<beach>
... so that their contents can vary according to the environment.
<p_l>
hmmm. Separate the values from identity, so symbols in different environments are still EQ?
<beach>
Yes.
<p_l>
that makes sense
<p_l>
beach: then you're not going back in time at all ;)
<beach>
metamodular.com/SICL/environments.pdf
<beach>
The trick was to make function calls fast, i.e. to avoid doing a hash-table lookup for each call of the form (f ...).
<p_l>
shouldn't be a problem for lexically bound f, should it?
varjag has joined #lisp
<beach>
Correct.
<beach>
I just "tie" the code to a particular environment.
<beach>
The static environment of a function contains disembodied function cells (in the form of CONS cells) containing the function object.
<beach>
It's all in the paper, so I won't go into details.
<beach>
But this way, I will be able to isolate implementation code from user code, for better safety. And I'll be able to do sandboxing a bit easier.
<beach>
The ultimate objective being a full multi-user system.
<beach>
This feature can also be used to separate the compilation environment from the run-time environment.
pjb has quit [Remote host closed the connection]
JohnMS_WORK has joined #lisp
<beach>
Anyway, I'll add "symbols have function cells" to a list of misconceptions along with "Lisp is interpreted".
<p_l>
beach: well, symbols being structures are implementation detail, what matters I guess is that there's "illusion" of symbols having a set of standard "slots" of information
pjb has joined #lisp
<p_l>
beach: I think SICL isn't even the first implementation to separate the data
<beach>
p_l: It is better seen as just another protocol. Once one realizes that, then there is more freedom of choice with implementation.
<beach>
p_l: Maybe so. All I could find in the literature was Scheme environments with hash-table lookups for each function call.
<beach>
It should be in the "previous work" section of the paper.
Bourne has joined #lisp
<p_l>
beach: that sounds like very inefficient implementation for language that explicitly pushed lexical environments
<beach>
I agree.
<ggole>
Why would fetching the function stored in a symbol require a table lookup? Wouldn't the code for (f ...) load the function from the symbol for f (which is looked up at read time)?
<beach>
No, because then the function can't be redefined later.
<beach>
The indirection is required.
<ggole>
It can be redefined by changing the field of the symbol.
<p_l>
or any other local redirection table
<ggole>
I agree that indirection is required.
<ggole>
But not a hash table.
<p_l>
if you push max perf, you can even remove the indirection without disabling redefinition, at the cost of making redefinitions slow (but possibly enabling safe redefinition of inlined functions)
davepdot_ has joined #lisp
trufas has joined #lisp
<ggole>
Yeah, some JITs do that trick
<p_l>
(instead of location used as jump table, keep track of callers)
<loke>
p_l: That's what the JVM does. It has a concept of "uncompiling" a function.
brown121407 has quit [Read error: Connection reset by peer]
<beach>
ggole: Yes, a hash table is not required, as I show in my paper.
montxero has quit [Ping timeout: 265 seconds]
brown121408 has joined #lisp
<beach>
ggole: It can't be redefined by changing the field of a symbol if the goal is to have different environments that allow different values for the property.
davepdot_ has quit [Ping timeout: 245 seconds]
clothespin__ has joined #lisp
Cymew has quit [Remote host closed the connection]
<ggole>
I see.
clothespin_ has quit [Ping timeout: 276 seconds]
trufas has quit [Ping timeout: 268 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
_phoe has quit [Remote host closed the connection]
Cymew has joined #lisp
Duuqnd has joined #lisp
karlosz has quit [Quit: karlosz]
trufas has joined #lisp
Lycurgus has joined #lisp
trufas has quit [Ping timeout: 240 seconds]
HDurer has joined #lisp
smokeink has quit [Remote host closed the connection]
EvW has joined #lisp
Davd33 has joined #lisp
smokeink has joined #lisp
hhdave has joined #lisp
Davd33 has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
t3rtius has joined #lisp
stepnem has quit [Ping timeout: 276 seconds]
stepnem has joined #lisp
oni-on-ion has quit [Read error: Connection reset by peer]
ljavorsk has joined #lisp
t3rtius_ has joined #lisp
t3rtius_ has quit [Client Quit]
t3rtius_ has joined #lisp
t3rtius has quit [Ping timeout: 265 seconds]
wiselord has joined #lisp
Davd33 has joined #lisp
Davd33 has quit [Remote host closed the connection]
jonatack__ has joined #lisp
jonatack_ has quit [Ping timeout: 250 seconds]
<phoe>
I do not yet understand why (format nil "~E" 1.0) is expected to produce "1.e+0".
<phoe>
> If the parameter d is omitted, then there is no constraint on the number of digits to appear. A value is chosen for d in such a way that as many digits as possible may be printed subject to the width constraint imposed by the parameter w, the constraint of the scale factor k, and the constraint that no trailing zero digits may appear in the fraction, except that if the fraction to be printed is zero then a
<phoe>
single zero digit should appear after the decimal point.
<phoe>
If I am reading this correctly, then "if the fraction to be printed is zero then a single zero digit should appear after the decimal point" applies in this case.
<phoe>
So we should print "1.0e+0" instead.
<phoe>
Where do I get this wrong?
<phoe>
K is defaulted to one and therefore positive, so we should print one decimal digit after the decimal point.
<pjb>
AFAIK, it should produce 1.0e+0
stepnem has quit [Ping timeout: 240 seconds]
stepnem_ has joined #lisp
<pjb>
phoe: there's one constraint that must be respected, when k is absent, it defaults to 1, and the constraint is k<d+2 ; since d is absent, any value of d is possible, such as k<d+2, ie. 1<d+2 ie.-1<d ie. 0<=d ie. any value is possible, such as the number can be printed.
trufas has joined #lisp
<pjb>
But k is still 1..
<phoe>
pjb: in this case, we may choose any value of D that lets us accurately print the number. Most implementation choose the minimum required number of digits.
<phoe>
But, this is orthogonal to the question I've asked.
<pjb>
And the minimum to represent a floating point number!
<pjb>
1.e+0 is valid reader syntax for a floating point number, so I guess it can be printed as such (contrarily to my expectation).
<phoe>
pjb: yes, I meant, the minimum to represent the number accurately.
<pjb>
which is 0 when the number is integral.
<phoe>
However my question is about "except that if the fraction to be printed is zero then a single zero digit should appear after the decimal point.".
<pjb>
oops, I missed the except. Yes, it clearly indicates that it should be printed as 1.0e+0
trufas has quit [Ping timeout: 268 seconds]
<phoe>
"If k is positive, then it must be strictly less than d+2; k significant digits are printed before the decimal point, and d-k+1 digits are printed after the decimal point."
<phoe>
K is 1 and therefore positive.
<pjb>
and d being absent, you can choose any convenient value, but subject to the following constraints, including the except.
<phoe>
K must be less than D+2.
<pjb>
Here K is fixed to 1, so D must be >= 0.
<phoe>
1 < D + 2, so -1 < D.
<phoe>
So D can be, uh, unsigned-byte in that case?
<pjb>
yes.s
<pjb>
But since it must also be at least 1 to print the 0 when it's 1.0, then we have (and (<= 0 d) (<= 1 d)) <=> (<= 1 d).
<phoe>
This implies that an implementation may want to print 1, 2, 5, or MOST-POSITIVE-FIXNUM zeroes, and all of these are correct.
<phoe>
And this doesn't look well.
<phoe>
Let me re-re-read.
<pjb>
phoe: another constraints is that there should be no trailing 0s.
<pjb>
So you cannot print 1.23000000000 You must reduce d to 2 and print 1.23.
<pjb>
1.0 being an EXCEPTion.
<phoe>
Yes, I see.
<phoe>
So if the fraction to print is zero, we must print at least one zero to satisfy the part about "if the fraction to print is zero" and at most one zero to satisfy the "no multiple trailing zeroes" rule.
<phoe>
And this implies that "1.0e+0" is the correct way to go, which in turn clashes with the body of the ANSI-TEST.
<phoe>
Which still doesn't make sense. I need to figure out the rationale that this test follows, since it is possible that this clashes with our understanding so far.
<pjb>
My reference is the CLHS, not the ansi-test.
<pjb>
(apart in the case of PROG2).
<phoe>
(:
<phoe>
So is mine, but ansi-test should be consistent with the spec. That is why I ask a question - the way I read it, this test is not correct, so either that test is not correct, or I am not reading something correctly.
gxt has quit [Quit: WeeChat 2.6]
<pjb>
You should ask in the github issue comments of the ansi-test project…
<pjb>
For me, it's a bug in ansi-test.
<phoe>
I will - but only once I verify that I am reading the spec correctly.
<phoe>
I'd like a few more minds to chip in and verify that I'm not missing anything.
gxt has joined #lisp
trufas has joined #lisp
m00natic has joined #lisp
EvW has quit [Ping timeout: 252 seconds]
trufas has quit [Ping timeout: 250 seconds]
t3rtius_ has quit [Ping timeout: 265 seconds]
trufas has joined #lisp
trufas has quit [Ping timeout: 240 seconds]
clothespin__ has quit [Ping timeout: 245 seconds]
trufas has joined #lisp
lnostdal has quit [Quit: "Fascism, Nazism, Communism and Socialism are only superficial variations of the same monstrous theme—collectivism." -- Ayn Rand]
trufas has quit [Ping timeout: 265 seconds]
CrazyEddy has joined #lisp
patrixl has joined #lisp
EvW1 has joined #lisp
Davd33 has joined #lisp
scymtym has joined #lisp
wiselord has quit [Ping timeout: 240 seconds]
Davd33 has quit [Remote host closed the connection]
<refusenick>
quickloading clws failed because g++ tried to compile a file with "#include <lfp.h>"
<refusenick>
What external libraries do I need?
<refusenick>
I think it might be Boost
t3rtius has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
EvW1 has quit [Ping timeout: 250 seconds]
CrazyEddy has quit [Remote host closed the connection]
<Xach>
libfixposix-dev: /usr/include/lfp.h
<Xach>
refusenick: that's what apt-file tells me on debian 10
CrazyEddy has joined #lisp
enrio has joined #lisp
EvW has joined #lisp
t3rtius has quit [Quit: leaving]
wiselord has joined #lisp
srji has quit [Ping timeout: 265 seconds]
_paul0 has joined #lisp
paul0 has quit [Ping timeout: 252 seconds]
EvW has quit [Ping timeout: 245 seconds]
raghavgururajan has joined #lisp
Lycurgus has quit [Remote host closed the connection]
<refusenick>
Xach: That fixes it. Thanks!
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
orivej has joined #lisp
<Xach>
i use apt-file a lot to discover such things
nirved has joined #lisp
random-nick has joined #lisp
ArthurStrong has joined #lisp
nirved_ has quit [Ping timeout: 246 seconds]
smokeink has quit [Ping timeout: 246 seconds]
amerlyq has joined #lisp
ArthurStrong has quit [Quit: leaving]
wxie has joined #lisp
refusenick has quit [Ping timeout: 245 seconds]
wxie has quit [Quit: wxie]
wxie has joined #lisp
t3rtius has joined #lisp
jonatack__ has quit [Read error: Connection reset by peer]
mathrick has joined #lisp
<lukego>
drat I would love to be at SBCL20 but it doesn't seem doable. Damn you all who manage to attend.
_paul0 is now known as paul0
raghavgururajan has quit [Read error: Connection reset by peer]
<Shinmera>
Same
raghavgururajan has joined #lisp
Kundry_Wag has joined #lisp
<Shinmera>
Meanwhile for ELS20 I'm currently busy getting the food organisation in order. Consulting all the various options is quite time intensive.
<lukego>
Rösti, rösti with cheese, rösti with ham...
* lukego
ducks :)
<Shinmera>
I would actually like a menu with Röschti
<pjb>
Where will it be?
<Shinmera>
Zürich
<pjb>
Right. Thanks.
mercourisj has joined #lisp
<Shinmera>
Zürich is.. not cheap for food, so getting a reasonable offer is tricky.
<jackdaniel>
ach, placki ziemniaczane ;)
<lukego>
Is there much of a Lisp contingent at FOSDEM btw? that's been my hangout the past couple of years
<mercourisj>
anyone know of a markup templating language that uses CL directly? (or perhaps cl-markup or some other similar technology)
<Shinmera>
"uses CL directly" in what way
<mercourisj>
I'm imagining something like being able to make a template file like this:
<Shinmera>
like, sexpr syntax, or parser in CL, or?
<Shinmera>
Clip uses lisp forms for template arguments.
<mercourisj>
OK, I've only experience with cl-markup and spinneret, I'll take a look
<jackdaniel>
there is cl-emb which works fine
<mercourisj>
ah, cl-emb looks very like it, yes
<jackdaniel>
I suspect that every now and then someone writes such thing so I wouldn't be surprised if there are many nih libraries doing the same thing
<mercourisj>
I just dont like those weird templating languages like jinja
<mercourisj>
they are simple, but their syntax is strange and there are fun gotchas all the time
EvW1 has joined #lisp
trufas has joined #lisp
wxie has quit [Ping timeout: 250 seconds]
trittweiler has quit [Quit: Leaving]
trufas has quit [Ping timeout: 265 seconds]
trufas has joined #lisp
trufas has quit [Ping timeout: 240 seconds]
Duuqnd has quit [Quit: Leaving]
raghavgururajan has quit [Remote host closed the connection]
<jeosol>
My application loads tens of systems, some of these systems are libraries, layered on each other, and I have examples to test different aspects. Sometimes I have two examples (different complexity) to test some system. I can't have two system loaded.
<jeosol>
Lately, with the application grown so large, I have been trying to have the examples test cases, as separate systems, which loads all required application cases.
<phoe>
I don't understand the part "I can't have two system loaded"
<phoe>
Why? Do they collide with each other?
<jeosol>
Two systems will usually override global variables and causing inconsistent
<jeosol>
phoe: I was providing some context.
<phoe>
jeosol: which libraries are those? If they mutate some global state upon load, this will make it harder for other systems to load nicely. This warrants a bugticket.
<jeosol>
Now, I am able to separate the system, but because of the size, there is still a system still loading an example. Is there a hack with asdf or quicklisp to let me know what system is being load so I can track the issue easily
<phoe>
As in, mutate global state in a non-nice way.
<jeosol>
phoe: Everything I have describe is on the application side, nothing with SBCL
Frobozz has quit [Quit: quit]
<phoe>
jeosol: I am not talking about SBCL, I am talking about the systems you load.
<jackdaniel>
phoe: I think that this is irrelevant to he question
<phoe>
OK.
Davd33 has joined #lisp
<phoe>
The question is basically, you want a list of all systems being loaded when you (asdf:load-system :foo). Correct?
<jeosol>
I meant by application global variables. To given an example, my application works with 3d grids for fluid modeling. I have simple example 100x1x1 grid that runs fast for testing, and I have another case, 100x100x50 that is slower
<jeosol>
So I have to test with the smaller, if things work, I go the larger one. There globals, e.g., the size of the grid that are different in both cases
<jeosol>
Some of you are probably aware of my project, thats the link. It's not been updated for a while, but hopefully that shows the size of files in the repo.
* phoe
mutters something about shared mutable state being the root of all evil
<jeosol>
I often have to load a good portion of that to test different things.
<jackdaniel>
jeosol: try inspecting the plan from (asdf:make-plan 'asdf:sequential-plan (asdf:make-operation :load-op) (asdf:find-system "alexandria"))
<jeosol>
phoe: I do agree with you
<jackdaniel>
ignore entries which are not operating on systems
<jeosol>
jackdaniel: thanks. I save that code
<jackdaniel>
(you could filter them by component type in cdr of each entry)_
<jeosol>
I -> I'll
Mike3620 has joined #lisp
<jeosol>
I hope the above is clear. In summary, I am disentangling the examples/applications to be loadable as separate systems apart from the libraries so I can test cases consistently without clobbing global variables.
scymtym has quit [Ping timeout: 245 seconds]
test12300001 has joined #lisp
<test12300001>
i am testinjg out a clim (comon lisp interface maganger) irc client called bbeirc in mezzanoi
<ebrasca>
test12300001: Hi
<phoe>
22.3.3.2 says, "If k is positive, then it must be strictly less than d+2"
<phoe>
test12300001: heyyy
Davd33 has quit [Ping timeout: 268 seconds]
<phoe>
Is it therefore legal to (format t "~,2,,4e" 1.0) where D is 2 and K is 4?
<test12300001>
hello, phoe
Mike3620 has quit [Remote host closed the connection]
test12300001 is now known as Mike3620
<jeosol>
phoe, jackdaniel: thanks for the suggestions. I will report back once I resolve the issue
t3rtius has quit [Ping timeout: 245 seconds]
<jeosol>
need to updated my asdf skills I suppose
<phoe>
so do I
Mike3620 has quit [Changing host]
Mike3620 has joined #lisp
<phoe>
ASDF is still magic to me, especially the under-the-hood parts
bitmapper has quit [Remote host closed the connection]
ArthurStrong has left #lisp [#lisp]
<beach>
Mike3620: It is entirely possible that beirc needs some care.
Kundry_Wag has quit [Remote host closed the connection]
<beach>
... it probably needs abbrevs and a spell checker for starters.
<jeosol>
phoe: yeah me too. But I had some chat with Fare a while back when he was looking hands to support. From that convo, I started using the :package-inferred-system for my setup.
<jeosol>
phoe, jackdaniel: I was able to figured out the errant system manual, by loading system one by one (will explore a better way).
<phoe>
I gotta repeat my question - is (format t "~,2,,4e" 1.0) legal?
<phoe>
Since that is what ANSI-TEST FORMAT.E.20 does
<phoe>
and k is NOT strictly less than (2+ k)
<phoe>
and k is NOT strictly less than (2+ d)*
Kundry_Wag has joined #lisp
bitmapper has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
FreeBirdLjj has joined #lisp
bitmapper has quit [Ping timeout: 265 seconds]
Kundry_Wag has joined #lisp
jcowan has left #lisp [#lisp]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
orivej has joined #lisp
shifty has quit [Ping timeout: 252 seconds]
ebrasca has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
m00natic has quit [Remote host closed the connection]
trufas has joined #lisp
Kevslinger has joined #lisp
<jeosol>
phoe,jackdaniel: the system loads correctly with latest SBCL now and saved a core file for quick restart.
<matthewzmd>
hey guys, for anyone familiar with emacs lisp. Is it possible to write a function with parameter f that creates a function with the name f
<beach>
matthewzmd: This channel is dedicated to Common Lisp. Sorry!
<beach>
matthewzmd: Maybe Emacs Lisp has (SETF FDEFINITION).
vlatkoB has quit [Remote host closed the connection]
<phoe>
now launch-program will work
<phoe>
because it is there
<Josh_2>
Now It's working :)
<Josh_2>
Thanks for saving the day phoe :D
<Josh_2>
Now I don't have to use Python natively xD
pjb` has joined #lisp
bitmappe_ has quit []
bitmapper has joined #lisp
<sjl>
Anyone involved with gitlab.common-list.net here? I created an account to try to send a PR to fix a bug in iterate, but I can't seem to fork the iterate repo to my own account. It says I've "reached my project limit" even though I have zero projects.
Kundry_Wag has quit [Remote host closed the connection]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lnostdal has joined #lisp
cosimone has quit [Quit: Terminated!]
pjb` has quit [Remote host closed the connection]
gravicappa has quit [Ping timeout: 250 seconds]
brown121407 has joined #lisp
pjb` has joined #lisp
brown121408 has quit [Ping timeout: 246 seconds]
pjb` has quit [Ping timeout: 276 seconds]
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
pjb` has joined #lisp
scymtym has joined #lisp
pjb` has quit [Remote host closed the connection]
pjb` has joined #lisp
pjb` has quit [Remote host closed the connection]
refusenick has joined #lisp
pjb` has joined #lisp
refusenick has left #lisp [#lisp]
Inline has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
shka_ has quit [Ping timeout: 268 seconds]
pjb` has quit [Remote host closed the connection]
pjb` has joined #lisp
pjb` has quit [Ping timeout: 246 seconds]
pjb` has joined #lisp
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
shka_ has joined #lisp
clothespin has joined #lisp
pjb` has quit [Ping timeout: 276 seconds]
MichaelRaskin has joined #lisp
akoana has joined #lisp
pjb` has joined #lisp
amerlyq has quit [Quit: amerlyq]
pjb` has quit [Ping timeout: 252 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
Volt_ has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
enrio has quit [Ping timeout: 252 seconds]
dale has joined #lisp
vaporatorius has quit [Quit: Leaving]
trufas has quit [Quit: WeeChat 2.6]
Ven`` has joined #lisp
thonkpod has joined #lisp
brettgilio has joined #lisp
buffergn0me has quit [Ping timeout: 250 seconds]
vaporatorius has joined #lisp
andonilsson has joined #lisp
<Josh_2>
What is loops version of do's step form?
<no-defun-allowed>
Maybe (loop for x = initial-value then next-value ...)?
<Josh_2>
hmm I tried that
<no-defun-allowed>
That could look like (loop for x = 0 then (1+ x) ...)
ljavorsk has quit [Ping timeout: 250 seconds]
<Josh_2>
Yes
<no-defun-allowed>
It could go wrong if you try something like (let ((x ...)) (loop for x = x then ...)) since LOOP will set up another binding for X.
<Josh_2>
It's cool I had made an error, missed a letter in one of my variables xD
<Josh_2>
pretty typical
shka_ has quit [Ping timeout: 240 seconds]
jonatack_ has joined #lisp
jonatack_ has quit [Read error: Connection reset by peer]
jonatack has quit [Ping timeout: 268 seconds]
gravicappa has joined #lisp
clothespin has quit [Ping timeout: 265 seconds]
buffergn0me has joined #lisp
andonilsson has quit [Quit: ERC (IRC client for Emacs 26.2)]
slyrus has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
gxt has quit [Quit: WeeChat 2.6]
gxt has joined #lisp
poet has joined #lisp
clothespin has joined #lisp
rgherdt has quit [Quit: Leaving]
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
jonatack has joined #lisp
dilated_dinosaur has quit [Ping timeout: 265 seconds]
<jeosol>
is anyone using CL to develop rest API applications. I am quite comfortable using some web libs (hunchentoot, caveman, etc) but not an expert. Wondering if anyone has some rest API examples to share or their applications.
LiamH has quit [Quit: Leaving.]
clothespin has quit [Ping timeout: 268 seconds]
bitmapper has joined #lisp
gravicappa has quit [Ping timeout: 265 seconds]
jbayardo has joined #lisp
jbayardo has quit [Client Quit]
dilated_dinosaur has joined #lisp
whiteline has quit [Remote host closed the connection]
whiteline has joined #lisp
ebrasca has quit [Remote host closed the connection]