freenode/#lisp - IRC Chatlog
Search
16:07:38
borodust
Xach: is that good enough README (i know it's not exactly very helpful) to get included into main quicklisp? https://github.com/borodust/claw#claw
16:15:20
phoe
Xach cares if your project has the author/description/license fields filled in the ASD file and if it builds on SBCL x64 Linux without errors
16:15:52
jackdaniel
actually offical requirement is that it builds on "at least on two CL implementations"
16:16:19
borodust
i'm looking at http://blog.quicklisp.org/2015/01/getting-library-into-quicklisp.html
16:16:29
phoe
jackdaniel: then it was changed, it was just SBCL before since that's what Xach can test on.
16:30:01
borodust
Xach: also, is that acceptable approach? https://github.com/borodust/chipmunk-blob
16:30:36
borodust
Xach: this is still asdf library, it's just that it doesn't really contain author/description...
16:43:33
puchacz_
hi again, I wanted to have (:shadowing-import-from #:unicode-hack :#char-equal ... etc) as symbol-macro, but it is not expanded in defpackage form
16:45:08
puchacz_
how would it work? regular macro, but in defpackage form prefix it with #. like #.(expand-unicode-hack) ?
17:02:11
scymtym
ebzzry: http://lispm.de/lisp/benchmarks.html but most of the results are not very recent to say the least
17:13:28
phoe
but I'm using SBCL 100% of the time and never had too many issues with compilation times on SBCL.
17:13:55
phoe
all I notice is, when I quickload a new system, or a system after a Quicklisp dist update, then it can take a minute or two-- this.
17:15:49
scymtym
since a few releases ago, SBCL should be substantially faster at compiling ironclad. faster than previous SBCL releases, that is. i don't know about CCL compiling ironclad
17:16:53
scymtym
also, choosing an implementation for development solely based on compilation speed seems ill-advised
17:32:44
jackdaniel
I use all three (ECL included) to ensure that I didn't rely on some implementation-specific behavior
18:31:43
malice
Some of them excel at different things (e.g. SBCL isn't very good at debugging but generates quite fast code)
18:32:06
malice
Some are more popular than other, some might work at platform you need, plus personal preference.
18:32:30
puchacz_
so areas they differ are: debugging, deployment on different platforms, anything else that is important?
18:33:46
beach
puchacz_: Some Common Lisp implementation target specific application types. For example, ECL is good for communicating with C code, and Clasp is good for communicating with C++ code.
18:34:25
beach
puchacz_: Some others are extremely portable, like CLISP because they can function with a bytecode interpreter, so do not need to be retargeted for different architectures.
18:34:26
malice
Speed, interoperability with other languages, bugs, perhaps some OS interfaces, perhaps MOP implementations, implementation-dependant things and probably bunch of other I don't remember right now
18:36:24
malice
The nice thing is that you have many different implementations, so you can just pick the one you like!
18:36:59
puchacz_
so from the benchmarks, I understand SBCL (because everybody uses it and quicklisp is checked against it AFAIK), lispworks (because it has stepper and it can deliver to many platforms) and ABCL (because you can script around java)
18:37:00
_death
you can also find hidden assumptions by trying your programs on different implementations
18:37:02
malice
Note that some implementations might be commercial and require payment, like LispWorks or Franz's compiler.
18:38:59
malice
Not really, I believe there was some effort to bring it up to date, but I'm not sure if that succeeded, though I may be wrong.
18:58:56
jackdaniel
as an example: clisp is the only CL which runs on minix3, ecl is in fact libecl.so and you may attach CL (and introduce live recompilation) to C/C++ application and mezzano is a whole operating system which provides CL as the language to communicate with it
19:10:39
malice
Is it incorrect to say that in CL you call a method? Should you say that you call a generic function instead?
19:13:16
malice
That's true. I also meant a general context; I am aware that e.g. #'call-next-method calls, in fact, a method, and not a gf.
19:14:06
phoe
you may call a method, sure, mop:method-function returns you something that you can funcall
23:41:29
Xach
Guest65797: If I were faced with that task, i would do "man 7 udp" and try to translate.
1:45:54
jmercouris
If you want to start with a "premade" emacs so you don't have to faff around with emacs in the beginning, you can look at portacle https://portacle.github.io
1:46:37
jmercouris
If you want to see a very simple lisp configuration, you can see mine: https://github.com/jmercouris/configuration/blob/master/.emacs.d/develop/_lisp.el
1:46:47
jmercouris
You can also see the hydra I use for lisp programming: https://github.com/jmercouris/configuration/blob/master/.emacs.d/hydra.el#L603
1:47:52
jmercouris
Here's the very very high level description, 1. Install a Lisp implementation of your choice 2. Install setup slime for emacs/your implementation 3. Install quicklisp 4. Install/setup Paredit 5. Install/setup Smartparens 6. Get started learning
1:49:09
jmercouris
I have this macro I use: https://github.com/next-browser/next/blob/master/next/source/command.lisp#L25
1:49:19
jmercouris
that is effectively designed for "interactive" functions (using emacs terminology)
1:50:37
jmercouris
so I was thinking wouldn't it be cool to combine some sort of ability to embed a (with-buffer) macro inside?
1:51:14
jmercouris
(defcommand some-command-name "Some-docstring of sorts" \n :with-active-buffer \n (body...))
1:51:39
jmercouris
I just don't want to have people needing to manually form closures every time they wish to work with a buffer for the duration of a function
1:52:16
Bike
well, i'm not sure i understand what this active buffer thing is, but i'd say if you're going to add options you should have a dedicated list for it in the syntax, rather than picking them out of the body
1:55:11
jmercouris
I think I should use the defcommand a lot, and see what kind of patterns emerge, and then write a macro to handle these common patterns
1:55:22
Bike
sorry i don't get the buffer thing, i don't have much context for your program and i don't do that much emacs programming
1:55:24
jmercouris
e.g. do I find myself always forming closures around the active buffer, if so, make it one of those options
2:05:21
pransmonkey
In other words, how does `(getf *some-nil-list* :random-sym)` returns a setable location if the list is empty???
2:07:51
pransmonkey
Okay, how does `(setf (getf *some-ni-list* :wtf) 1)` makes `*some-nil-list* to be `(:A 1)`?
2:09:30
zazzerino
iqubic: slime-company is available on melpa. have you followed the instructions on https://www.emacswiki.org/emacs/MELPA to set it up?
2:11:43
pransmonkey
(LET* ((#:NEW592 1)) (LET ((#:NEW1 (SB-IMPL::%PUTF *PS* :A #:NEW592))) (SETQ *PS* #:NEW1) #:NEW592))
2:13:22
Bike
getf has a setf expansion, meaning that when the setf macro gets a getf form it knows what to do with it
2:13:47
Bike
you could also try macroexpanding e.g. (setf (car x) y), which will give you something with rplaca
2:14:45
pransmonkey
Bike: I mean, what is an alternative way of getting the `(setf (getf *ps* :blah) bleh)` result, without getf.
2:17:21
pransmonkey
I fail to think of another way of doing `(setf (getf *ps* :blah) bleh)` which would help me understand the whole thing.
2:17:38
pierpa
pransmonkey: the answer is: you can't do what you are asking using standard CL. Standard CL uses macros which expand to implementation dependent things
2:17:42
pransmonkey
Bike: Thanks, after you have explained, and looking at the macro expension, I understand how it works.
2:17:55
Bike
it's perfectly possible to do the behavior of setf getf without using setf or getf, it's just list manipulation
2:18:15
pransmonkey
What I am trying to know is, whatever, that is the "standard" way of doing it, and it is often that macros map functions passed with completely different things.
2:18:57
Bike
on sbcl there's a compare-and-swap macro that works similarly to setf, in that (cas form ...) is going to macroexpand into something different based on the cas expansion
2:19:20
Bike
conceptually, in (setf (getf ...) ...) the getf form is not a function call, it is a "place"
2:20:09
pransmonkey
So a place isn't necessarily a real memory location or list reference or anything.
2:21:18
sjl
http://malisper.me/getting-places/ is an intro to places if you want a longer explanation
2:21:50
pransmonkey
Bike: I was thinking of place as some kind of pointer or reference, and so `(setf (getf *ps* :non-existence-pointer-or-reference) bleh)` didn't make sense.
2:27:45
iqubic
Quicklisp has already been installed. Load #P"/home/avi/quicklisp/setup.lisp" instead.
2:31:26
jmercouris
iqubic: I'm very ready to say, give up, install portacle, and if you like common-lisp, go ahead and set this up later
2:36:14
Bike
well, just make an .sbclrc if it doesn't exist, and put (load "wherever/quicklisp/setup.lisp") in there
2:45:15
whoman
lisp syntax highlighting should truly be contextual and depth-ual, rather than literal lettered identifiers
2:46:22
Bike
by default slime just does some dumb shit like coloring operator names beginning with "def"
2:47:56
whoman
jmercouris, the question lacks an existential word ?? like "is" or "are" or query words like "when" or "how" ....
2:50:54
jmercouris
trying to make it easier right now to write commands and to customize, then release a package manager, then some quality of life things to make it easier for noobs
3:16:06
pierpa
You should at least say which implementations you are interested in. I seem to remember thare was a library for this for lispworks, but I have not first-hand experience.