varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
MoziM has quit [Quit: WeeChat 2.1]
orivej has quit [Ping timeout: 265 seconds]
Pixel_Outlaw has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 256 seconds]
nowhere_man has joined #lisp
eschatologist has joined #lisp
rumbler31 has joined #lisp
caltelt_ has joined #lisp
<aeth>
How do non-SBCL implementations deal with type declarations?
<aeth>
Has someone looked into this in depth?
<aeth>
I use them for performance, static checking, and documentation (although I doubt any current documentation generator supports them) so they're actually a better fit than check-type in most places where I use them.
rumbler31 has quit [Ping timeout: 240 seconds]
<Xach>
??? check-type can portably get you those things?
<aeth>
(I do use check-type where I want the type checked more than anything else)
<aeth>
Xach: check-type in SBCL produces functions where the types are all T for the args because you can correct them at runtime
FreeBirdLjj has joined #lisp
<aeth>
Xach: What I might do is #+sbcl declare and #-sbcl check-type
<aeth>
I do the types in a macro so something like that could work
eschatologist has quit [Ping timeout: 244 seconds]
<Xach>
aeth: you mean ftype declarations for performance, then?
<aeth>
SBCL sees (defun foo (x) (check-type x single-float) (+ x x)) as a function where its one arg is T, where anything can go in because anything will become single-float at the moment of check-type
edgar-rft has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
<aeth>
The ftype is shown in describe. I just declare types. It will infer the return type most of the time
<aeth>
(defun foo (x) (declare (single-float x)) (+ x x)) will have a more useful describe in SBCL
<Xach>
ok
karlosz has joined #lisp
<aeth>
What I could do for my define-function macro is fall back to check-type in implementations where declare is ignored. That might significantly slow some things down, though. Especially in implementations that have unsophisticated compilers.
<aeth>
It would also make type errors correctable everywhere but SBCL
ravndal has quit [Quit: WeeChat 2.1]
ravndal has joined #lisp
<aeth>
(defstar is GPL, which kind of justifies my MIT-licensed NIH project a bit more than when I started)
fikka has joined #lisp
brettgilio has joined #lisp
joh11 has quit [Ping timeout: 256 seconds]
<LdBeth>
Morning
fikka has quit [Ping timeout: 245 seconds]
<brettgilio>
LdBeth: Good morning, how are you?
<LdBeth>
Getting ready for work
<LdBeth>
brettgilio: what about you?
eschatologist has joined #lisp
markoong has quit [Read error: Connection reset by peer]
markoong has joined #lisp
<brettgilio>
LdBeth: Just got home from the lab, thankfully.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
slyrus_ has joined #lisp
markoong has quit [Ping timeout: 260 seconds]
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
brettgilio has quit [Read error: Connection reset by peer]
brettgilio has joined #lisp
fikka has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
Naergon has quit [Ping timeout: 260 seconds]
mathZ has joined #lisp
brettgilio has quit [Remote host closed the connection]
mathZ` has joined #lisp
mathZ has quit [Ping timeout: 255 seconds]
eschatologist has quit [Ping timeout: 244 seconds]
FreeBirdLjj has joined #lisp
nicht has joined #lisp
quazimodo has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Ping timeout: 255 seconds]
mathZ` has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
eschatologist has joined #lisp
brettgilio has joined #lisp
Beep-Lord has left #lisp ["WeeChat 1.6"]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
eschatologist has quit [Ping timeout: 244 seconds]
robotoad has quit [Quit: robotoad]
eschatologist has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
brendyn has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
alphor has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
alphor has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
loli has quit [Quit: WeeChat 2.1]
Kundry_Wag has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
loli has joined #lisp
pierpa has quit [Quit: Page closed]
eschatologist has quit [Ping timeout: 244 seconds]
<blep-on-external>
are there any neural networks written in lisp?
<blep-on-external>
(ones which use BLAS would be cool, since those can be optimized the hell out of)
fikka has quit [Ping timeout: 256 seconds]
graphene has quit [Remote host closed the connection]
brettgilio has quit [Remote host closed the connection]
graphene has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
buffergn0me has joined #lisp
robotoad has joined #lisp
Kundry_Wag has joined #lisp
graphene has quit [Remote host closed the connection]
AetherWind has joined #lisp
ebzzry has joined #lisp
<ebzzry>
What is a good Java interface library that is available with Quickdocs?
eschatologist has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
quazimodo has joined #lisp
brettgilio has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
brettgilio has quit [Remote host closed the connection]
robotoad has quit [Remote host closed the connection]
brettgilio has joined #lisp
robotoad has joined #lisp
brettgilio has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
nowhere_man has quit [Remote host closed the connection]
pierpal has joined #lisp
brettgilio has joined #lisp
nowhere_man has joined #lisp
<pillton>
aeth: You shouldn't customize your define-function macro according to specific CL implementations. You should write tests which examine the functionality of the current CL implementation and add exported symbols to *features* based on the test results. You then write your define-function macro according to what is in *features*.
pierpal has quit [Read error: Connection reset by peer]
brettgilio has quit [Quit: Goodbye!]
brettgilio has joined #lisp
loli has quit [Quit: WeeChat 2.1]
loli has joined #lisp
nowhere_man has joined #lisp
eschatologist has joined #lisp
Khisanth has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
makomo has joined #lisp
eschatologist has quit [Ping timeout: 244 seconds]
<aeth>
pillton: Good point, especially since it's probably not hard to add check-types to functions with type declarations in implementations. (The rest of the functionality is probably a lot harder. Also, SBCL doesn't quite run check-type on it because you cannot specify a replacement value if the type is wrong.)
<aeth>
(And declare within let/etc. would just be equivalent to a the afaik)
brettgilio has quit [Remote host closed the connection]
pierpal has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
shangul has quit [Ping timeout: 240 seconds]
nicht has quit [Ping timeout: 256 seconds]
Misha_B has joined #lisp
brettgilio has joined #lisp
Arcaelyx has joined #lisp
Bike has quit [Quit: Lost terminal]
DGASAU has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
DGASAU has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
<pillton>
aeth: You could create two functions where one is a "hidden" function which assumes all of the arguments are correct. The second function is public which just checks the arguments and then calls the hidden function. You could then use a compiler macro to switch between the two when sufficient information is available at compile time.
DGASAU has joined #lisp
fikka has joined #lisp
makomo has quit [Ping timeout: 245 seconds]
krwq has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
makomo has joined #lisp
fikka has joined #lisp
shka_ has joined #lisp
karlosz has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 276 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
shifty has quit [Ping timeout: 264 seconds]
Smokitch has joined #lisp
nowhere_man has quit [Ping timeout: 255 seconds]
skapata has quit [Remote host closed the connection]
milanj has joined #lisp
igemnace has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
eschatologist has joined #lisp
lnostdal has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
robotoad has quit [Quit: robotoad]
milanj has quit [Quit: This computer has gone to sleep]
Inline has quit [Quit: Leaving]
light2yellow has joined #lisp
vlatkoB has joined #lisp
robotoad has joined #lisp
gector has quit [Read error: Connection reset by peer]
gector has joined #lisp
shka_ has quit [Ping timeout: 256 seconds]
brettgilio has quit [Remote host closed the connection]
nickenchuggets has quit [Read error: Connection reset by peer]
mathZ has joined #lisp
brettgilio has joined #lisp
brettgilio has quit [Remote host closed the connection]
scymtym has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
shrdlu68 has joined #lisp
brettgilio has joined #lisp
AetherWind_GJ has joined #lisp
AetherWind has quit [Disconnected by services]
Naergon has joined #lisp
AetherWind_GJ is now known as AetherWind
flamebeard has joined #lisp
light2yellow has quit [Quit: light2yellow]
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
eschatologist has quit [Ping timeout: 276 seconds]
brettgilio has quit [Remote host closed the connection]
eschatologist has quit [Ping timeout: 244 seconds]
varjag has joined #lisp
eschatologist has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
caltelt_ has quit [Ping timeout: 256 seconds]
mathZ has quit [Remote host closed the connection]
eschatologist has quit [Ping timeout: 244 seconds]
heisig has joined #lisp
scymtym has joined #lisp
eschatologist has joined #lisp
lemoinem has quit [Read error: Connection reset by peer]
lemoinem has joined #lisp
shrdlu68 has quit [Ping timeout: 256 seconds]
SaganMan has joined #lisp
pierpal has quit [Ping timeout: 265 seconds]
<loke>
Is there a docbook parser for Lisp?
shrdlu68 has joined #lisp
graphene has quit [Remote host closed the connection]
<edgar-rft>
loke: What exactly do you want to do? A "docbook parser for Lisp" is something that parses docbook XML files for producing Lisp output, is this what you want?
graphene has joined #lisp
mflem has quit [Read error: Connection reset by peer]
doesthiswork has quit [Quit: Leaving.]
CrazyEddy has quit [Ping timeout: 256 seconds]
deng_cn has quit [Quit: deng_cn]
<beach>
Maybe he just wants to create some internal data structure that he can then use in further processing.
eschatologist has quit [Ping timeout: 276 seconds]
shrdlu68 has quit [Ping timeout: 256 seconds]
eschatologist has joined #lisp
shrdlu68 has joined #lisp
littlelisper has quit [Quit: leaving]
rumbler31 has quit [Ping timeout: 264 seconds]
milanj has joined #lisp
wigust has joined #lisp
eschatologist has quit [Ping timeout: 244 seconds]
nowhere_man has joined #lisp
thodg has joined #lisp
eschatologist has joined #lisp
wigust- has quit [Ping timeout: 248 seconds]
dddddd has joined #lisp
MichaelRaskin has quit [Quit: MichaelRaskin]
brettgilio has quit [Remote host closed the connection]
hhdave has joined #lisp
CrazyEddy has joined #lisp
xrash has quit [Ping timeout: 260 seconds]
Smokitch has quit []
_cosmonaut_ has joined #lisp
_cosmonaut_ has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
lumm has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
Krisostoomus has joined #lisp
pillton has quit [Ping timeout: 240 seconds]
graphene has quit [Remote host closed the connection]
fikka has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
acolarh has quit [Ping timeout: 268 seconds]
graphene has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 260 seconds]
_cosmonaut_ has joined #lisp
random-nick has joined #lisp
fikka has joined #lisp
littlelisper has joined #lisp
m00natic has joined #lisp
acolarh has joined #lisp
shrdlu68 has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
shrdlu68 has joined #lisp
ebzzry has quit [Quit: WeeChat 2.1]
fikka has quit [Ping timeout: 265 seconds]
pierpal has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 276 seconds]
xificurC has joined #lisp
Bindler has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Krisostoomus has quit [Ping timeout: 264 seconds]
ebrasca has quit [Ping timeout: 264 seconds]
acolarh has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
schweers has joined #lisp
thodg has quit [Read error: Connection reset by peer]
jmercouris has joined #lisp
nowhere_man has quit [Ping timeout: 276 seconds]
acolarh has joined #lisp
ogamita has joined #lisp
quazimod1 has joined #lisp
quazimodo has quit [Ping timeout: 264 seconds]
<LdBeth>
What might be the best approach to strip HTML for indexing ( with Montezuma)?
<LdBeth>
1. Simply use regexp to remove all html tags
<LdBeth>
2. Use a HTML parser so URLs can be extracted separately.
ogamita has quit [Read error: Connection reset by peer]
ogamita has joined #lisp
Bindler has quit [Ping timeout: 256 seconds]
<TMA>
LdBeth: regexes tend to do poorly in the corner cases; if you do not mind, they might be simpler
<loke>
edgar-rft: I'll tell you, sorry for being late.
<loke>
I was out of the office for a while.
<loke>
Basically, I have the Maxima documentation in texinfo format on one hand. And in the other hand I have a markup engine that takes Lisp forms and displays them in on a CLIM stream.
<loke>
There is no Texinfo parser in Lisp, and my attempts to write one stopped rather quickly after I realised how complex the texinfo format is.
<loke>
The alternative would be to base it on Docbook, which is more common.
rumbler31 has joined #lisp
scymtym_ has joined #lisp
smasta has joined #lisp
<loke>
So yes, I'd like to be able to load docbook and have some way of processing the content
<loke>
(so that I eventualkly can render it in CLIM)
ogamita has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 240 seconds]
<loke>
However, I haven't been able to find anything at all that processes Docbook, so I believe it doesn't matter.
<LdBeth>
TMA: thanks for you advice
thodg has joined #lisp
rumbler31 has quit [Ping timeout: 268 seconds]
smasta has quit [Ping timeout: 260 seconds]
vlatkoB_ has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
<lieven>
loke: can't you use the emacs texinfo stuff to mangle the Maxima documentation. not quite CL but maybe good enough?
vlatkoB has quit [Ping timeout: 265 seconds]
<edgar-rft>
loke: you want the *entire* manual to be rendered in CLIM or only some online helf for a maxima interface? Most of the reference part of the Maxima manual are just printed Lisp docstrings. I assume using the docstrings would save you a lot of bac-and-forth conversion.
<edgar-rft>
*online help
thodg has quit [Remote host closed the connection]
<loke>
edgar-rft: I am going render documentation for individual functions in maxima
scymtym__ has joined #lisp
<loke>
it's a reference, so there will be a list of function (from the index) and a way to pop up documentation for a given function directly from the command completion menu
<loke>
edgar-rft: No. Maxima has a very extensive texinfo manual
<loke>
That's where all the documentation is
thodg has joined #lisp
Younder has quit [Remote host closed the connection]
scymtym_ has quit [Ping timeout: 240 seconds]
<loke>
Maxima has functions to look up entires in the info index actually, which is what I'm using right now. However, it uses the plain text version of the info pages generated by makeinfo. CLIM can do better than that.
thodg has quit [Read error: Connection reset by peer]
<loke>
Another lanternative is to base it on the HTML output from texinfo
slyrus1 has quit [Remote host closed the connection]
Fare has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
lumm_ has joined #lisp
<zigpaw>
(and embed chromium into CLIM? ;-))
lumm has quit [Ping timeout: 248 seconds]
lumm_ is now known as lumm
lnostdal has joined #lisp
graphene has quit [Remote host closed the connection]
<shka>
zigpaw: that could be useful :-)
m00natic has quit [Ping timeout: 245 seconds]
graphene has joined #lisp
m00natic has joined #lisp
<zigpaw>
Still plan to use ceramic (electron) on one of my new pet projects, can't find spare time unfortunately. For many people HTML become the next cross platform GUI library.
<antoszka>
Unfortunately so.
<shka>
this is unfortunate
<antoszka>
shka: o/
Kundry_Wag has joined #lisp
<shka>
antoszka: hello
graphene has quit [Remote host closed the connection]
<flip214>
Is there a way to get SWANK-CONTRIB/SWANK-TRACE-DIALOG to get a string representation of arguments and return values at the time of calling/returning?
graphene has joined #lisp
Naergon has quit [Ping timeout: 256 seconds]
<flip214>
I've got a use case where a special variable gets filled piecewise, and the trace only records the _instance_ and so shows the same textual representation for all the calls
<flip214>
and not how the data in there gets accumulated in chronological order
<loke>
zigpaw: Rendering simple HTML is trivial. And the output from texinfo is indeed trivial.
<loke>
and simple :-)
<flip214>
of course, storing _only_ a representation means that inspecting objects isn't really useful later on... so it should capture _both
<loke>
And building a GUI using HTML and JS is absolutely terrible, and nto something that should be condoned.
<_death>
what, you don't like having 1000 reinventions of a button widget and syntax to make it happen?
<loke>
_death: Well... When you put it _that_ way. :-)
<loke>
_death: Then again, the web/JS community has reinvented everything _else_ about 1000 times already, so why not?
<loke>
How many build systems are they up to by now?
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<jackdaniel>
chaos is a great carrier for innovations
ogamita has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
shrdlu68 has quit [Ping timeout: 256 seconds]
robotoad has quit [Quit: robotoad]
vsync_ is now known as vsync
shrdlu68 has joined #lisp
SaganMan has quit [Ping timeout: 256 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
lumm has quit [Ping timeout: 248 seconds]
igemnace has quit [Quit: WeeChat 2.1]
orivej has joined #lisp
AetherWind has quit [Quit: Leaving]
shka has quit [Remote host closed the connection]
shka has joined #lisp
fikka has joined #lisp
pillton has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
nowhere_man has joined #lisp
<jmercouris>
anyone familiar with text classification?
<jmercouris>
I'm trying to classify a sentence as either a definition, or a not-definition
<jmercouris>
e.g. does this sentence contain a definition for a term
<jmercouris>
I'm interested in either supervised or unsupervised techniques
<jmercouris>
preferrably online due to my RAM limitations
makomo has joined #lisp
gigetoo has joined #lisp
Kundry_Wag has joined #lisp
<littlelisper>
i am making an rsvp for myself, having trouble with do loop
<littlelisper>
(do* ((n 0 (1+ ch))
<littlelisper>
(words book (nthcdr ch book)))
Kundry_Wag has quit [Remote host closed the connection]
<jmercouris>
ogamita: yes, it is not an easy problem
<jmercouris>
I can't solve it with some simple heuristic
<ogamita>
littlelisper: what is a rsvp?
<jmercouris>
which is why I'm looking for classification algorithms
makomo has quit [Client Quit]
<jmercouris>
I know of course of many, they are publicly discussed on the internet, I'm more interested in experiences or maybe someone a lot more knowledegable than me could chime in with some insight
<ogamita>
jmercouris: do you already have some semantics?
markoong has joined #lisp
<littlelisper>
read without movin your eyes
<ogamita>
I don't have actual practical experience, sorry.
<jmercouris>
ogamita: Not sure what means
<ogamita>
jmercouris: if you have an AI (symbolic or ANN) understanding sentences, then you can start from the meaning to determine if it's a definition or not. Any equivalence can be considered as a definition, if one of the term is "simple".
<ogamita>
littlelisper: ok. So what's your problem with DO? your code seems ok.
<littlelisper>
it keeps printing the second cycle. does not moves ahead
<nirved>
littlelisper: n is first 0 then 1+ch
<nirved>
ch is not modified
<littlelisper>
ch is constant, no of words to display per cycle
<littlelisper>
oops. i got it
<ogamita>
(+ n ch) to increment n!
<littlelisper>
thanks ogamita
<ogamita>
it may be easier to use loop: (loop for n from 0 below book-len by ch for words on book by (lambda (words) (nthcdr ch words)) do (print (subseq words n (min (+ n ch) book-len))) (sleep (wpm-delay wpm)))
<Ukari>
if i write a :version in format v[Major].[Minor].[Patch] in defsystem, is it necessary to update the patch version in defsystem in every git commit ?
fikka has joined #lisp
<Ukari>
i work directly on master branch
<ogamita>
Yes. and the format is [Major].[Minor].[Patch].
<ogamita>
no "v".
<ogamita>
Ukari: that said, you could write a pre-commit hook that would increment automatically the Patch number in the asd of the current repo (and even you could check if the modified files are in the depend files of the asd when you have several asd in the repo).
<ogamita>
Ukari: but it may still be better to leave it to the user to increment them, since eg. a change of formatting shouldn't increment even the patch.
<Ukari>
thanks
littlelisper has quit [Ping timeout: 245 seconds]
smasta has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
Fare has quit [Ping timeout: 276 seconds]
thodg has joined #lisp
smasta has quit [Ping timeout: 265 seconds]
ogamita has quit [Read error: Connection reset by peer]
scymtym__ has quit [Ping timeout: 245 seconds]
micro has quit [Changing host]
micro has joined #lisp
rumbler31 has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
jmercouris has quit [Remote host closed the connection]
jkordani has joined #lisp
thodg has quit [Read error: Connection reset by peer]
rumbler31 has quit [Ping timeout: 248 seconds]
shrdlu68 has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
shrdlu68 has joined #lisp
igemnace has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
Beep-Lord has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
lumm has joined #lisp
SenasOzys has quit [Ping timeout: 260 seconds]
Bike has joined #lisp
milanj has joined #lisp
SenasOzys has joined #lisp
thodg has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
Murii_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
Arcaelyx has joined #lisp
fikka has joined #lisp
quazimod1 has quit [Ping timeout: 240 seconds]
doesthiswork has joined #lisp
quazimodo has joined #lisp
smasta has joined #lisp
SenasOzys has quit [Remote host closed the connection]
Krisostoomus has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
<flip214>
is there a way to find out whether a Copier-function is defined for some argument X? ie. for strings, numbers, (perhaps) structs, etc.?
NotSpooky has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
<flip214>
I found COPY-STRUCTURE, but that still means I need a big CASE around that
fikka has quit [Ping timeout: 264 seconds]
rumbler31 has joined #lisp
shrdlu68 has joined #lisp
Kundry_Wag has joined #lisp
<_death>
there is no generic way.. like equality, copying is ambiguous
<Bike>
yeah, there's deep versus shallow and so on
<Bike>
image is spam
Krisostoomus has quit [Quit: Leaving]
sellout- has joined #lisp
<shka>
Bike: thanks for info
<shka>
beach: i read your garbage-collector text
<shka>
excellent, as usual
<beach>
Oh, thank you!
<beach>
In SICL, a heap-allocated object is one of two things, namely a CONS cell or a GENERAL INSTANCE. A CONS cell is two word block and that's it. A general instance has a two-word HEADER, where the first word contains the (pointer to the) CLASS, and the (pointer to the) RACK.
<beach>
Now, CONS cells and two word headers are treated the same in many instances. I am getting tired of typing "A CONS cell or the two-word header of a general instance", so I need a name for it. I was thinking of a "deuce". Any objections?
<shka>
i thank you, i think I learned more about garbage collection reading your articles
<beach>
shka: Great!
rumbler31 has quit [Ping timeout: 256 seconds]
<beach>
shka: Was it the section on the nursery GC?
<shka>
yes
<beach>
OK, that one I consider fairly complete.
<Bike>
you call it a "header" but it's not contiguous with anything, is it?
<beach>
Correct.
<loke>
beach: Wouldn't that be simply "heap object"? Are there other things that can be on the heap?
<Bike>
i see. that's been tripping me up. kind of an unrelated thought, of course
<beach>
loke: No, because the heap object would be the header PLUS THE RACK if it is a general instance.
<shka>
was thinking the same as loke
Kundry_Wag_ has quit [Ping timeout: 248 seconds]
test1600 has joined #lisp
<Bike>
deuce is probably fine. it has a slang meaning but that's probably irrelevant
<beach>
What is the slang meaning?
<beach>
I could look in the urban dictionary I guess.
<Bike>
poop.
<beach>
Oh! Heh.
<beach>
How about "dyad" then?
<shka>
i like dyad better
warweasle has joined #lisp
<loke>
beach: Aparently it means "poop" (i.e. "number 2")
<Bike>
I've only seen that word in the context of APL, so no problem there
sellout- has quit [Ping timeout: 248 seconds]
<beach>
OK, dyad it is.
<loke>
In APL I've seen the word "dyadic". I don't think "dyad" is used.
fyodost has joined #lisp
<shka>
well, it has greek root, probabbly it is used somewhere
<lieven>
think of the PR gains. Haskell has monads but CL has dyads :)
<shka>
but not in computer science i think
<beach>
loke, shka: You are right in that the only heap-allocated objects are CONS cells and general instances, but, again, the general instance is the entire thing. Not just the header.
<jackdaniel>
call it "dyngiel" :-)
<beach>
lieven: Heh, nice one!
<shka>
:D
<shka>
jackdaniel: lol
<shka>
jackdaniel: good one
<shka>
i also recommend tentego
<shka>
all seriously though
<shka>
oh, well, not all seriously at all
<shka>
lieven: and explanation of what dyad is easier to comperhand then what monad is! :D
<beach>
Thanks to everyone. Very helpful as usual.
<jackdaniel>
[ref.: dyngiel in Polish is a word used to describe "a thing to do stuff" or "a thing which is meant for something", probably came from German language because I can't think of any Polish-related etymology]
sjl has joined #lisp
<beach>
jackdaniel: I was guessing a Polish word.
sellout- has joined #lisp
NotSpooky has quit [Ping timeout: 240 seconds]
<antoszka>
jackdaniel: Same as "wichajster", originating from “wie heisst er” and probably „dynks”, too.
<lieven>
shka: a monad is just a monoid in the category of endofunctors. What's your problem?
<_death>
just install monadblock
nowhere_man has joined #lisp
shifty has joined #lisp
NotSpooky has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
rafadc has joined #lisp
thodg has quit [Ping timeout: 260 seconds]
<shka>
antoszka: wichajster maybe difficult to pronounce for non native i guess
<shka>
:D
FreeBirdLjj has joined #lisp
<antoszka>
:)
lnostdal has quit [Ping timeout: 260 seconds]
shangul has joined #lisp
charh has quit [Remote host closed the connection]
nicht has joined #lisp
LiamH has joined #lisp
scymtym has joined #lisp
m00natic has quit [Ping timeout: 260 seconds]
Inline has joined #lisp
thodg has joined #lisp
fikka has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
lumm has quit [Ping timeout: 268 seconds]
test1600 has quit [Ping timeout: 245 seconds]
attila_lendvai has quit [Quit: Leaving.]
test1600 has joined #lisp
Murii_ has quit [Ping timeout: 260 seconds]
fyodost_ has joined #lisp
lumm has joined #lisp
fyodost has quit [Ping timeout: 260 seconds]
NotSpooky has quit [Quit: Leaving]
robotoad has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
flamebeard has quit []
FreeBirdLjj has joined #lisp
Kundry_Wag_ has joined #lisp
shangul has quit [Ping timeout: 268 seconds]
shangul has joined #lisp
brettgilio has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
robotoad has quit [Quit: robotoad]
eschatologist has quit [Ping timeout: 244 seconds]
housel has quit [Remote host closed the connection]
Khisanth has quit [Ping timeout: 240 seconds]
graphene has quit [Remote host closed the connection]
charh has joined #lisp
bigblue has joined #lisp
<bigblue>
hi
<beach>
Hello bigblue.
<bigblue>
just curious, why does this form actually work: (1- 100) ... i thought all forms started with an operator and that should read: (- 1 100)?
<beach>
It is the operator that subtracts 1 from its argument.
<bigblue>
oh! right i should have tested furtehr before wasting yoru time.
<White_Flame>
the function name is 1- specifically so it doesn't read as a number
<bigblue>
thank you kindly
<bigblue>
*nod* thank you very much
<beach>
bigblue: It is equivalent to (- 100 1) and not to (- 1 100)
<White_Flame>
ie, it's not "one minus ..."
<brettgilio>
Hey all, is this channel specifically for Common Lisp, or are other Lisps like Scheme welcome too?
<beach>
Only Common Lisp.
<beach>
There is ##lisp for general Lisp talk.
<brettgilio>
Thank you, beach
<beach>
Sure.
Kundry_Wag has joined #lisp
heisig has quit [Quit: Leaving]
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
Khisanth has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
robotoad has joined #lisp
nicht has quit [Ping timeout: 256 seconds]
jmercouris has joined #lisp
<jmercouris>
I can't remember what is the notation (x . y) called for cons cells?
<jmercouris>
dotted pair
<jmercouris>
right
<jmercouris>
I've heard them referred to as ordered pairs as well
<jmercouris>
are both correct?
<Bike>
ordered pair is a more general concept
<jmercouris>
and what is the difference between an ordered pair and a tuple?
<Bike>
an ordered pair is a 2-tuple
Kundry_Wag has joined #lisp
<jmercouris>
I see
<jmercouris>
I have been living my whole life believing that tuples were always two elements because it sounds like "2"
<jmercouris>
s/believing/beleiving
<jmercouris>
I guess python doesn't help with this notion
<jmercouris>
it reinforced this belief...
<Bike>
the idea is octuple, nonuple, dectuple, etc -> general version is "tuple"
<jmercouris>
how does one specify a tuple of length two?
<Bike>
i'm pretty sure python has tuples of more lengths than two
<Bike>
and lisp doesn't have a structure called 'tuple'
pierpal has quit [Ping timeout: 264 seconds]
eschatologist has joined #lisp
Kundry_Wag_ has quit [Ping timeout: 240 seconds]
<jmercouris>
Bike: I've mostly seen it in reference to two element pairs
<jmercouris>
but you are right, they can be any length
bigblue has quit [Quit: Lost terminal]
<White_Flame>
I've heard the term "two-tuple" to specifically describe that length
<_death>
"twople"
<White_Flame>
or "2-tuple"
<Bike>
2-tuple is pretty normal
<jmercouris>
2-tuple it is
<jmercouris>
what is the difference between a tuple and a set?
skapata has joined #lisp
<jmercouris>
ah, the ordering
<beach>
Indeed.
<trittweiler>
A tuple may also contain an element twice
<jmercouris>
right, whereas a set may not
<jmercouris>
though I guess in Lisp we can use lists for the set operations
<jmercouris>
so that doesn't really hold true
<beach>
jmercouris: You should make sure your lists don't have duplicate elements if you want to use them to represent sets.
<jmercouris>
beach: How would one do that?
eschatologist has quit [Ping timeout: 276 seconds]
<beach>
Use a consistent set of operations that preserves this property.
<jmercouris>
I'm also guessing it is undefined behavior if there are duplicates in your set?
<jmercouris>
s/set/list
<Bike>
whether the result has duplicates is undefined
<beach>
I think that depends on the operation. You need to look in each case.
<Bike>
for union and intersection at least
nowhere_man has quit [Ping timeout: 245 seconds]
<jmercouris>
Ok, I'll keep that in mind
<jmercouris>
I'm not really ever using these operations, I'm just learning them because of this textbook
<jmercouris>
but maybe someday I will find a use for them
<Bike>
lists aren't really an efficient representation of sets, you'll want to work something else out if you're doing anything heavy
<jmercouris>
I guess you could simplify removal of a certain type of element from a list by using something like set-difference rather than iterating the list
<jmercouris>
maybe I'm just going around with a hammer all the time instead of thinking about what else is in the toolbox
<beach>
Sure, but it's the same algorithm anyway.
<trittweiler>
lists are not a good data structure to element sets (if you really need sets); the functions provided by the standard are sometimes handy though, for example when implementing macros and working on a small list of statically-defined keywords. As that list will be small, efficiency doesn't matter
shrdlu68 has quit [Ping timeout: 264 seconds]
<jmercouris>
true, it will have the same time complexity
<jmercouris>
there is no getting around the amount of comparisons you have to make
<Bike>
yeah there is
<beach>
jmercouris: "number" of comparisons. Amount of stuff, number of things.
<jmercouris>
beach: I'm sorry, english is my first language :D I still can't keep it all straight
light2yellow has joined #lisp
<beach>
I know what you mean.
<White_Flame>
hash tables are generally going to be what you want for sets in CL. having the value be the same as the key is often a handy way to implement them
brettgilio has quit [Quit: Goodbye!]
<beach>
White_Flame: Er, that really depends on the domain of the elements.
buffergn0me has joined #lisp
<White_Flame>
yeah, it's a very nebulous "generally"
<trittweiler>
jmercouris, in languages without multiple-return-values, tuples are often used instead. (Not sure what exactly the context is, just a general remark to the subject)
<jmercouris>
how does one generally imeplement a sparse matrix in CL?
<jmercouris>
a list of lists?
<White_Flame>
I think the problem would be tackled in the same way as any other language
<jmercouris>
trittweiler: I've seen that before, and I generally consider, and believe it to be an antipattern of good programming
<jmercouris>
White_Flame: so, a list of lists then?
<White_Flame>
well, depends on how you want to index them
<White_Flame>
it's certainly a speed/complexity tradeoff
<jmercouris>
e.g. (list (list x y value) (list x2 y2 value2))
<White_Flame>
for instance, some sort of tree structure which hold begin-end ranges for your sparse indexes
<trittweiler>
I don't think you would do a list of list. maybe a vector of lists but that still required a vector of the full |V| vertices. A hash-table of lists perhaps
<White_Flame>
which may or may not themselves have holes in them
<beach>
jmercouris: As White_Flame points out, you design a data structure by first determining the operations you want, and the desired complexity of those operations.
rafadc has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jmercouris>
I guess it would be very domain specific then
<jmercouris>
understanding what characterstics you want your data structure to have, and then designing it around that
<jmercouris>
its an interesting approach
<jmercouris>
I normally consider what data structures I have, and then the algorithm is shaped around the characterstics of the data structure
<beach>
That's how it is always done.
<beach>
First the operations.
<beach>
Because that's what a data structure *IS*, i.e., the set of operations on it and the complexity of those operations.
<beach>
Not necessarily asymptotic complexity of course.
<jmercouris>
data structures, at least non primitive ones, in languages I've used traditionally have always been too heavy for the kind of work that I am doing
<beach>
It could be relative to particular use cases.
<jmercouris>
hence my approach
<jmercouris>
I remember a python program I wrote to analyze digital networks, and so I made a data structure, but it was just way too heavy
<jmercouris>
took too much memory, despite fitting neatly into my algorithm
<jmercouris>
so I ended up rewriting the algorithm and using very primitive structuers
<jmercouris>
s/structuers/structures
<beach>
When I say "complexity", I include things like memory consumption.
<White_Flame>
a great beginning case is to know the API and not have any speed assumptions, to get an initial version working behind a reimplementable interface
<White_Flame>
an initial naive version, that is
<jmercouris>
right, I understand
<beach>
White_Flame: Exactly, and then you can use the simple version for random testing by comparing the result to the two versions.
<beach>
Like I do in Cluffer.
<jmercouris>
I feel like this channel has taught me a lot about programming in other languages
<beach>
I can very well believe that.
<jmercouris>
I always thought people were exaggerating, but I think there is value in every programmer learning lisp
<beach>
Totally.
<beach>
Also, many people who hang out here have knowledge in lots of other domains. I am betting that is not the case for your lambda programming language channel.
<beach>
Or at least, to a lesser degree in those channels.
<jmercouris>
Yeah, that is a huge part of it, the community contains very knowledgable people
kozy has quit [Remote host closed the connection]
<jmercouris>
I don't want to disparage others, but many other language channels are full of novice programmers, which is great, they are learning, but there is infrequently information I can learn from a first year CS student
<beach>
Right, #lisp is specifically not for newbies. They are tolerated as long as they make progress.
<_death>
a wise man once said, "Common Lisp is a language you graduate into."
* White_Flame
recalls going into javascript channels to ask advanced questions, and enters a thousand yard stare
<beach>
Heh.
<beach>
That reminds me. Who was it the other day that had totally missed the point of #lisp and thought people came here when they are bored?
<beach>
Oh, verisimilitude, wasn't it?
<beach>
So I take it that must be the norm in other channels.
<jmercouris>
It's definitely the norm in #emacs
<_death>
I think the verisimilitude guy is actually quite experienced and had good points
<Xach>
The lifecycle of many IRC channels is to start with a particular topic and change to a social channel for the people who have been discussing things with each other for years
kozy has joined #lisp
schweers has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
<jmercouris>
_death: Do you have a link still to that gist you wrote for the mini perl interpreter?
varjag has joined #lisp
lumm has quit [Quit: lumm]
rpg has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Folkol_ has quit [Ping timeout: 268 seconds]
<_death>
I don't think it was a gist.. maybe on plaster.. also, I wouldn't dare write a "mini perl interpreter" :)..
<jmercouris>
_death: It was a very special case, you wrote it for a broken perl script
<jmercouris>
could somebody theoretically implement a new language entirely using reader macros?
<jmercouris>
just transform some slightly different forms into lisp forms?
<whartung>
of course.
<_death>
yes.. I didn't keep it but maybe #lisp log has a link
smasta has joined #lisp
<Xach>
haha
<jmercouris>
Xach: are you laughing at me? or are you remember the script?
<jmercouris>
s/remember/remembering
<Xach>
jmercouris: 16 years ago whartung wrote a post about using reader macros to implement a new language to solve a hard problem nicely with lisp and it inspired me a lot. i'm laughing with delight at the memory of the post and the fact that whartung is here to confirm that it can be done.
<jmercouris>
Oh, I see
<Xach>
it was called "guerilla lisp -- the opus"
<jmercouris>
THIS IS IT!
<jmercouris>
I was asking about this essay about a year ago
<Inline>
prolog-syntax in climacs uses the package drei-syntax and so drei-syntax::update-syntax takes over, the package does not :shadow it, i put the line in the .asd package section now meh....
<makomo>
it's not that bad imo. it's a little basic but not that horrible
<jackdaniel>
given these flying ads I see everywhere and loads of JS which make my CPU scream in heat I conclude, that 20 years old *is* good
shangul has quit [Remote host closed the connection]
<whartung>
If it’s not Material Design, how can it be any good?
smasta has joined #lisp
<jackdaniel>
and moving hamburgers or whatever they're called ;)
<makomo>
whartung: hah, exactly
shangul has joined #lisp
<makomo>
but in any case, i don't care that much about the aesthetics, i care about the content.
<jmercouris>
modern design doesn't mean JS and hamburgers!
<Inline>
frigging thing, it also uses esa-utils::format-sym and some macrolet fails there because it tries to use format-sym and it's not defined anywhere and the package does not import that symbol either... so i added that too
<jmercouris>
jackdaniel: I think you should stick to programming :P
<jackdaniel>
jmercouris: and I don't think that, what now?
<jmercouris>
Well, its a stalemate I guess
<jmercouris>
We each do our own thing as it doesn't hurt each other, and the world continues on :D
<Inline>
and my version of esa-utils did not even have that format-sym defined, i'm using old and new versions of software to cross-compare too....
<Inline>
meh
<jackdaniel>
not really, because it is my pool to decide what to do (i.e not yours) so I'm at adventage here
<jackdaniel>
Inline: you fight with McCLIM auxilliary libraries?
<jackdaniel>
s/fight/play/ ;-)
shka_ has joined #lisp
<Inline>
and i found out that even when i define my trees to be taken into account and to be discarded in my asdf layout, as soon as i use quicklisp, it discards all of that
<Inline>
and i get false positives of succeeding compilations
<Inline>
only detecting something is wrong via ql:where-is-system blah
carenz has joined #lisp
<Inline>
then i see it's referencing a total different mcclim for example....
<Inline>
not the one i have in local-projects
carenz has quit [Read error: Connection reset by peer]
<Inline>
rather the one in quicklisp/dists/quicklisp/software
<Inline>
only way was to change all forma of ql:quickload to asdf:load-system
<Inline>
in my init-file
jmercouris has quit [Remote host closed the connection]
<Inline>
at least that way i get consistent results
<Xach>
If a project is accessible via asdf, it takes precedence over the quicklisp-provided one.
shrdlu68 has joined #lisp
<Xach>
If you configure asdf so it sees quicklisp/ as a tree, the results will not be great
<Xach>
quicklisp/software, even
Kaisyu has quit [Quit: Connection closed for inactivity]
<Inline>
yah
<Inline>
i think that was my problem
<Inline>
but on the other hand i have dependencies of say mcclim which live in quicklisp/software
<Inline>
so it's rather messy to not include it
<Inline>
and messy via including either
<Inline>
lol
<Xach>
Inline: quicklisp bundles might help there? but maybe not.
<Inline>
it either would force me to move all of relevant deps out of software into local-projects or so
<Inline>
or force me to use asdf:load-system just
<Inline>
no idea Xach
<Inline>
i've read the docs but quciklisp does not give into it's details much
<Inline>
and i'm not sure i have the time to grok it all from the sources for now
<Inline>
:) anyway
<Xach>
Sorry about that
<Inline>
at least one thing got clearer on the way from all of this mess
<Inline>
that i have to be careful
<Xach>
I think it would be good to make it easy to use quicklisp libraries without loading quicklisp itself, but the process is tricky.
<Inline>
yah i can imagine
<Xach>
You can get quicklisp to dump out a list of paths to systems in an index file, but making asdf use that index file is some code. (Not a lot, but more than nothing.)
<Inline>
arright, thank you for the info, i'll come back to you again because of those system.cdb files and what not
nowhere_man has joined #lisp
brettgilio has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
eschatologist has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
nickenchuggets has joined #lisp
pjb has joined #lisp
jxy has quit [Quit: leaving]
eschatologist has quit [Ping timeout: 244 seconds]
lnostdal has joined #lisp
thodg has quit [Ping timeout: 256 seconds]
surya has quit [Remote host closed the connection]
rpg has quit [Ping timeout: 268 seconds]
rumbler31 has joined #lisp
habamax has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
jxy has joined #lisp
littlelisper has joined #lisp
eschatologist has joined #lisp
shangul has quit [Quit: sudo rm -rf /usr/*]
megalography has quit [Ping timeout: 276 seconds]
littlelisper has quit [Read error: Connection reset by peer]
littleli1per has joined #lisp
Kundry_Wag_ has joined #lisp
rpg has joined #lisp
<rpg>
SLIME question -- something has happened recently so that my SLIME REPL processes no longer inherit my bash environment, meaning that lots of stuff that uses RUN-PROGRAM and RUN-SHELL-COMMAND no longer work. Any suggestions about diagnosing that?
<rpg>
My guess is that it has something to do with how the subsidiary CL runtime is launched, but I don't claim to understand SLIME that well. However, this problem does NOT occur with emacs shell mode, so it seems to be a distinctly SLIME problem.
<rpg>
mmmm..... or not. emacs-shell isn't working either. So I guess it's emacs, not SLIME.
test1600 has joined #lisp
MichaelRaskin has joined #lisp
Oddity has quit [Read error: Connection reset by peer]
cage_ has joined #lisp
<pjb>
rpg: it may be rather linked to how you start emacs.
eschatologist has quit [Ping timeout: 244 seconds]
<pjb>
If you start it from the terminal: emacs & disown, you will inherit from a different environment than if you start it from the dock!
<pjb>
Now, run-shell-command runs the command thru the shell, so it's up to you to set up correctly your shell rc files.
<White_Flame>
or if you start it from the gui startmenu thingy, who knows what you'll get
<rpg>
pjb: I think that's right. I added (exec-path-from-shell-initialize) into my init.el, and maybe that will fix this.
<White_Flame>
I never start it consistently, and always issue magic stuff to init my environment
<pjb>
For run-program, implementation dependent, you usually have a :env parameter, or a :use-shell parameter to go back to the run-shell-command case. UIOP:run-program has force-shell.
Murii_ has joined #lisp
megalography has joined #lisp
<pjb>
rpg: You could have a bunch of setenv forms in your ~/.emacs for inferior processes.
<rpg>
Yes, exec-path-from-shell-initialize fixes the problem, thanks.
<pjb>
If you keep your environment variables in a simple ~/.bash_env, you could even parse it and define the environment variables in emacs lisp from their shell syntax.
eschatologist has joined #lisp
<pjb>
I don't have symbol in my emacs-version "25.1.1".
<pjb>
this
shifty has quit [Ping timeout: 245 seconds]
light2yellow has quit [Quit: light2yellow]
Oddity has joined #lisp
paule32 has quit [Read error: Connection reset by peer]
brettgilio has quit [Read error: Connection reset by peer]
milanj has quit [Quit: This computer has gone to sleep]
_cosmonaut_ has quit [Ping timeout: 256 seconds]
CrazyEddy has quit [Remote host closed the connection]
graphene has joined #lisp
megalography has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
Kundry_Wag_ has quit [Ping timeout: 248 seconds]
eschatologist has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 256 seconds]
brettgilio has joined #lisp
paule32 has joined #lisp
terpri has quit [Ping timeout: 255 seconds]
littleli1per has quit [Read error: Connection reset by peer]
littlelisper has joined #lisp
random-nick has quit [Ping timeout: 260 seconds]
eschatologist has joined #lisp
eschatologist has quit [Client Quit]
eschatologist has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
mflem has joined #lisp
<rpg>
pjb: It seems that inheriting the right environment when starting from a GUI is a common enough problem that there's a library for it. exec-path-from-shell is available in the usual package sites.
<rpg>
I'll shut up about this now, because it turns out to be an emacs problem, not a slime problem.
<pjb>
ok. Thanks.
smasta has joined #lisp
eschatologist has quit [Ping timeout: 276 seconds]
Kundry_Wag has quit [Remote host closed the connection]
trittweiler has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
littlelisper has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
littlelisper has joined #lisp
escapist has joined #lisp
habamax has quit [Ping timeout: 264 seconds]
shrdlu68 has quit [Ping timeout: 248 seconds]
zachk has joined #lisp
zachk has quit [Changing host]
zachk has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
megalography has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
nickenchuggets has joined #lisp
eschatologist has joined #lisp
Arcaelyx has joined #lisp
iridioid has joined #lisp
test1600 has quit [Ping timeout: 260 seconds]
littlelisper has quit [Read error: Connection reset by peer]
eschatologist has quit [Ping timeout: 244 seconds]
littlelisper has joined #lisp
smasta has quit [Ping timeout: 248 seconds]
eschatologist has joined #lisp
lumm has joined #lisp
kajo has joined #lisp
Yaargh has joined #lisp
wildbartty has quit [Remote host closed the connection]
wildbartty has joined #lisp
random-nick has joined #lisp
smaster has joined #lisp
iridioid has quit [Ping timeout: 240 seconds]
littlelisper has quit [Quit: leaving]
stacksmith has joined #lisp
<stacksmith>
Good morning everyone.
eschatologist has quit [Ping timeout: 244 seconds]
ebrasca has joined #lisp
trittweiler has joined #lisp
eschatologist has joined #lisp
<stacksmith>
Q: Does the spec address how tagbody treats symbol-macrolet? Empirically, SBCL does not seem to expand these and treats them as tags. CLHS says "If a statement is a macro form and its macro expansion is an atom, that atom is treated as a statement, not a tag." Is this implementation-dependent?
<Bike>
"The determination of which elements of the body are tags and which are statements is made prior to any macro expansion of that element. "
<Bike>
what that's saying is that if a macro form, as in a cons where the car names a macro, expands into an atom, it's still treated as a statement.
<Bike>
you can of course hack it by putting in (progn symbol-macro-symbol)
<stacksmith>
Yeah.
eschatologist has quit [Ping timeout: 244 seconds]
<stacksmith>
Is CLHS saying that any symbol is considered a tag, prior to macroexpansion (in which case things deemed as tags do not get symbol-macroexpanded?)
<Bike>
yes.
<stacksmith>
In other words, inside tagbody, symbol-macrolet is effectively disabled.
<Bike>
for just bare symbols. it's still normal in compound forms.
smaster has quit [Ping timeout: 256 seconds]
<stacksmith>
Right. All bare symbols are considered tags. Is that why tagbody always returns nil? There is no way to place a bare value prior to return, unless it is returned by the last compound form, which would probably be confusing.
<Bike>
but the last form that returns a value to be executed is the addition.
<dlowe>
it returns nil by definition in the spec
<Bike>
yes, obviously.
<Bike>
i'm being all hypo-thetical here.
<dlowe>
because execution passes to END, and then there are no remaining statements
<stacksmith>
The statements in a tagbody are evaluated in order from left to right, and their values are discarded. If at any time there are no remaining statements, tagbody returns nil.
<pjb>
stacksmith: you can always wrap your "toplevel" symbol-macrolets in a progn.
<pjb>
(tagbody foo (progn foo) (go foo))
<Bike>
i mean fundamentally tagbody always returns nil because it's about weird control flow and loops and stuff.
eschatologist has joined #lisp
<Bike>
you can use prog if you want to return a value easily, and for the maximal fortran experience
smaster has joined #lisp
<pjb>
(symbol-macrolet ((foo (if (zerop (random 2)) (return) (print 'foo)))) (block nil (tagbody foo (progn foo) (go foo)))) ; will print a random number of foos.
<stacksmith>
PROG still requires an explicit return. That bit me once.
<trittweiler>
PROG is a favorite of mine! A handy tool to implement macros expressing iteration. You can often use it to ensure that you deal with declarations correctly (without having to use PARSE-DECLARATIONS, which isn't part of the standard)
eschatologist has quit [Ping timeout: 244 seconds]
<trittweiler>
declarations, implicit tagbody and implicit anonymous block. The gritty-details of a good macro expansion. :)
cage_ has quit [Quit: Leaving]
Kundry_Wag has quit [Remote host closed the connection]
eschatologist has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Kundry_Wag has joined #lisp
<aeth>
I usually use do for iteration macros (do has an implicit tagbody)
<stacksmith>
Is there a case where declarations are not handled correctly by let or some variant that establishes bindings?
<trittweiler>
stacksmith, Consider if you were to expand to `(let ((x ...)) (block nil (tagbody ... ,@body))) and body had a (declare (fixnum x))
eschatologist has quit [Ping timeout: 276 seconds]
<stacksmith>
I see what you mean. By combining let, block and tagbody any declarations wind up in the right place, as opposed to several forms deeper than expected.
<trittweiler>
Yep
brettgilio has quit [Ping timeout: 264 seconds]
paule32 has quit [Ping timeout: 260 seconds]
<stacksmith>
Enlightening as always. Thank you, amigos.
eschatologist has joined #lisp
peccu4 has quit [Ping timeout: 255 seconds]
dtornabene has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
paule32 has joined #lisp
peccu4 has joined #lisp
fikka has joined #lisp
eschatologist has quit [Ping timeout: 244 seconds]
bexx has quit [Ping timeout: 256 seconds]
eschatologist has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
rpg has quit [Ping timeout: 260 seconds]
pagnol has joined #lisp
Kundry_Wag_ has joined #lisp
megalography has quit [Remote host closed the connection]
rpg has joined #lisp
terpri has joined #lisp
milanj has joined #lisp
eschatologist has quit [Ping timeout: 244 seconds]
graphene has quit [Remote host closed the connection]
jmercouris has joined #lisp
graphene has joined #lisp
test1600 has joined #lisp
peccu4 has quit [Ping timeout: 256 seconds]
shka_ has quit [Ping timeout: 268 seconds]
eschatologist has joined #lisp
peccu4 has joined #lisp
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
igemnace has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
hhdave has joined #lisp
<jmercouris>
anyone written any scripts to bundle an executable created by SBCL on OSX?
<sjl>
jmercouris: shinmera's deploy library can create a .app
Kundry_Wag has quit [Remote host closed the connection]
<jmercouris>
sjl: any other tools you know of?
<sjl>
nope, that's the only one I've used to create a .app
<sjl>
I seem to remember a really old blog post about it, but who knows if that still works N years later
<jmercouris>
maybe I'll just do some operations in a makefile
<aeth>
I think that the easiest way to handle things is to simply change the default value of check-type in the destructuring-bind that handles the options depending on the implementation.
<aeth>
A manual specification of :check-type will override the implementation-specific default.
pierpal has quit [Ping timeout: 256 seconds]
<aeth>
I can make similar macros for let and wherever else declare might be used.
rafadc has joined #lisp
<whartung>
can you show an example of what the define-function foo example expands in to?
<aeth>
(It only took 98 lines.)
pjb has quit [Remote host closed the connection]
<aeth>
whartung: running macroexpand-1 I get: (defun foo (x y &optional (z 42)) (declare (single-float x) (double-float y) (fixnum z)) (+ x y z))
<whartung>
ok, that’s what I thought you were doing. Very nice.
<aeth>
The check-type version is: (defun foo (x y &optional (z 42)) (declare) (check-type x single-float) (check-type y double-float) (check-type z fixnum) (+ x y z))
pjb has joined #lisp
<aeth>
Since they're both supported in the same macro, I could set the default value to check-type to T on implementations that ignore type declarations.
Bike has joined #lisp
<aeth>
Getting rid of the empty (declare) in the check-type version probably isn't worth it. It'll just be ignored.
pjb has quit [Remote host closed the connection]
<aeth>
Internal bindings that could have a declare are a bit trickier. There's let, let*, do, do*, dotimes, dolist, lambda, multiple-value-bind, destructuring-bind, and probably a few that I'm forgetting. And then there's some I add like destructuring-lambda and do-destructuring-bind.
eschatologist has quit [Ping timeout: 276 seconds]
<Kundry_Wag>
Consider a function `foo` that accepts a function `bar` as argument and applies it. If `bar` produces side effects, is `foo` considered pure? Does it depend on its input?
<whartung>
well, what’s the point of a “pure” function that’s creating side effects? What does the label or measure of “pureness” matter?
<Bike>
it would help a compiler to know "pure, but calls this argument"
<Bike>
i think this is how sbcl's database works
<aeth>
More concretely, is map pure if it takes in an impure lambda? It kind of is. It's known that it won't modify the sequence(s). And it kind of isn't, because there's an impact on the outside world.
<whartung>
so, having a “pure” function with a “volatile” argument, so it can work around it?
<Kundry_Wag>
whartung: I don't know, I was just discussing with my colleagues. I abstracted a function that used side effects to a `pure` one that applies a function given as argument (and does other pure stuff)
loli has joined #lisp
LiamH has quit [Quit: Leaving.]
<whartung>
because, yea, there are assumptions that can be made for “pure” functions. For idempotent functions. For (my pooh brain lost the word for data objects that can’t change…)…
<whartung>
I would say that “no”, such a funciton is not pure.
<Bike>
if you know that it's pure but calls an argument you can make those assumptions when they're valid (like you know what function is being called, and that it's pure) and not make them when they're not
<whartung>
because by definition, any function with side effects is not pure, no matter how they manifest. Now, if you can declare the “unpure” parts, then that helps.
Kundry_Wag has quit [Remote host closed the connection]
<aeth>
whartung: But it can be better than something that makes no guarantees at all. MAPHASH is faster than looping over a hash table in LOOP because MAPHASH is less powerful than LOOP. I think this holds even if the lambda in MAPHASH has side effects.
<Bike>
what? why would maphash be faster
<aeth>
It's noticably faster. mfiano (iirc) pointed this out, we benchmarked it, and I moved my do-hash-table over from loop to maphash.
<aeth>
At least in SBCL.
<Bike>
but how is loop "more powerful"
<whartung>
Obviuosly LOOP isn’t smart enough to compile to a maphash form...
<aeth>
maphash *just* iterates over a hash table's keys and values.
<aeth>
whartung: Yes, I guess in theory a simple hash table iteration in LOOP could do so
<Bike>
what else does a loop do?
<whartung>
he’s talking the LOOP macro Bike
<Bike>
i know
<Bike>
i assume we're talking about a loop that just iterates over a hash table's keys and values
<aeth>
LOOP *could* do way more, so it's harder to optimize.
<aeth>
I guess even in the case where it doesn't
rafadc has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
loli has quit [Quit: WeeChat 2.1]
megalography has joined #lisp
<Bike>
sbcl looping over a hash table uses with-hash-table-iterator, which in sbcl involves a closure, so calling it repeatedly might be slower. but i don't think that's a deep fact about loop.
<whartung>
right, it’s an implemetaiton detail of this loop, not a limitation of LOOP in the large.
kajo has quit [Ping timeout: 265 seconds]
eschatologist has quit [Ping timeout: 244 seconds]
<aeth>
Bike: Is LOOP able to modify the hash-table while iterating over it?
<Bike>
not any more than maphash can, i don't think
Kundry_Wag has joined #lisp
<aeth>
Iirc, that was the speculation last time this came up, but it could be wrong.
<aeth>
It's not the same. "For hash table traversal operations, new elements may not be added or deleted except that the element corresponding to the current hash key may be changed or removed."
<aeth>
I don't think you can change or remove the current value in maphash
<Bike>
you can
<Bike>
it says so specifically in the description of the function
<aeth>
Ah, you're right. That's weird.
<aeth>
Well, I'm glad you're here to clear things up. You know the spec well.
<Bike>
i just know how to navigate it
megalography has quit [Quit: Leaving.]
kajo has joined #lisp
<aeth>
Bike: What do you think about my define-function macro?
megalography has joined #lisp
<aeth>
It's one of several very large macros that I've written for this game engine
<Bike>
haven't been paying attention but i'm automatically skeptical of replacements for built in things
<aeth>
It puts the type with the variable name, which basically every reader of my code has wanted.
<aeth>
Type declarations aren't very readable. It also does inlining. declaim inline is a source of errors because you have to type the name twice. declaim inline also makes M-. harder to navigate because in SLIME it makes you choose between the declaim and the defun instead of taking you to the defun when you M-. on an inline function, unless it's automatically inlined by a macro like define-function
Ukari has quit [Ping timeout: 255 seconds]
caltelt_ has quit [Ping timeout: 260 seconds]
<aeth>
The syntax of (name :inline t) even simplifies macros that generate inline functions because now it's just (,name :inline t) and there's no need for an outer progn in that macro unless there's more than one function being generated.
<aeth>
In general, I *prefer* macros that replace built-in things. Simpler, shorter code with fewer errors and the reader should be able to understand it without much trouble. e.g. I have a with-accessors* macro that simply expands (foo bar (baz quux)) to ((foo foo) (bar bar) (baz quux))
nopf has joined #lisp
<aeth>
Anything that annoys me in dozens of places mercilessly gets replaced with a macro. That's the whole point of using Lisp.
Kundry_W_ has joined #lisp
Kundry_W_ has quit [Ping timeout: 248 seconds]
robotoad has quit [Quit: robotoad]
fikka has quit [Ping timeout: 276 seconds]
Ukari has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
caltelt_ has joined #lisp
Kundry_Wag has joined #lisp
rpg has joined #lisp
kajo has quit [Ping timeout: 256 seconds]
Jesin has quit [Quit: Leaving]
<aeth>
Bike: What do you use macros for? That's my approach but I'm curious what you do
kajo has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
<Bike>
not replacing built in things.
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 25.3.2)]
<Bike>
i have my issues with standard macros and stuff, but uniformity has its advantages nonetheless.
varjag has quit [Ping timeout: 264 seconds]
Kaisyu has joined #lisp
Jesin has joined #lisp
Arcaelyx has joined #lisp
escapist has joined #lisp
fikka has joined #lisp
<aeth>
I personally think it depends on the size of the application. If it's small, it should be as close to vanilla as possible. If it's large, the gain in conciseness could be a massive maintenance advantage and the macros aren't surprising if they're all over the code.
<caltelt_>
I just downloaded the latest version of sbcl and when trying to look at function definitions in slime, it looks like it's trying to use the dir structure when sbcl is built.
<aeth>
It has always been like that for me.
<caltelt_>
Anyone know how to setup slime to point to my local sbcl?