<Xach>
didi: sorry not to have a useful answer - it would be nice if there was a library for your task. but it seems pretty complicated and i don't know of one.
<didi>
Xach: Let's say 1800.
nowhereman_ has quit [Ping timeout: 260 seconds]
<didi>
Xach: Oh, OK.
dented42 has joined #lisp
<Xach>
didi: i am curious, though - what is the project in your case?
nowhereman_ has joined #lisp
<didi>
Xach: I want to be able to tell the weekday of dates before 1900.
smurfrobot has quit [Remote host closed the connection]
<Xach>
didi: why?
<didi>
Xach: Nothing in particular. Just thought of it and realized I couldn't go earlier than 1900.
<Xach>
ah
<Xach>
then perhaps investing in the great book "Calendrical Calculations" is not worth the trouble
markong has quit [Ping timeout: 240 seconds]
<Xach>
(with code in Lisp!)
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<didi>
I've heard of it. From the creator of Emacs' calendar, right?
<didi>
Anyway, nothing needing attention right now. Just a curiosity.
aindilis has joined #lisp
<Xach>
Bike: yes indeed. cut & paste error on my part.
<Bike>
i was staring at july trying to figure out the joke
Rawriful has quit [Quit: WeeChat 1.4]
<Xach>
Sorry about that.
<didi>
Heh, missing days are missing.
<Bike>
i continually get confused reading mildly old russian things and being unable to comprehend julian dates
aindilis` has joined #lisp
impulse has joined #lisp
nirved has quit [Quit: Leaving]
pagnol has quit [Ping timeout: 256 seconds]
saki has joined #lisp
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
red-dot has joined #lisp
zazzerino has quit [Remote host closed the connection]
zazzerino has joined #lisp
Chream has joined #lisp
fittestbits has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
<ym>
Is there a proof of impossibility of input (from "real-world") in FP?
DeadTrickster_ has joined #lisp
<Bike>
what would that mean?
rumbler31 has quit [Remote host closed the connection]
DeadTrickster has quit [Read error: Connection reset by peer]
DeadTrickster__ has joined #lisp
DeadTrickster_ has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 248 seconds]
DeadTrickster__ has quit [Ping timeout: 248 seconds]
pagnol has joined #lisp
<ym>
Thesis in natural language, I guess.
hvxgr has joined #lisp
randomstrangerb has quit [Ping timeout: 264 seconds]
yangby has joined #lisp
randomstrangerb has joined #lisp
malcom2073 has quit [Remote host closed the connection]
malcom2073 has joined #lisp
malcom2073 has quit [Read error: Connection reset by peer]
malcom2073 has joined #lisp
wmannis has joined #lisp
yangby has quit [Quit: Go out for a walk and buy a drink.]
<Bike>
...what?
fikka has joined #lisp
<pjb>
ym: the real world is part of the program: the universe is obviously a simulation written in your FP program!
orivej has quit [Ping timeout: 240 seconds]
<pjb>
it's God's program.
pagnol has quit [Ping timeout: 240 seconds]
<asarch>
Sorry if I insist. I promise this would be my last question but, how would you open a big file, parse its content line by line and print the third column of every line that matches with a regexp?
<pjb>
asarch: (with-open-file (stream "big-file") (loop for line = (read-line stream nil nil) while line when (regexp-match-line-p regexp line) do (print (third-column line))))
<pjb>
DUH!
thinkpad has quit [Quit: lawl]
EvW has quit [Ping timeout: 240 seconds]
<Bike>
what parsing, exactly?
<pjb>
line by line.
<asarch>
The file is from a query from a PG cluster
<asarch>
psql school -c "SELECT * FROM payments WHERE student_id = 234;"
<asarch>
THANK YOU pjb
<asarch>
THANK YOU VERY MUCH :-)
<Bike>
you're being sarcastic, right? but honestly, that's kind of what it amounts to.
<Bike>
if you need a regex matching library cl-ppcre is good.
<asarch>
I used to use Perl for that kind of operations
<asarch>
In the beginning I used the TCSH for that
z3t0 has joined #lisp
<Bike>
okay?
<asarch>
Then I moved to awk, sed, grep
<asarch>
I am not
<asarch>
Actually, in the sed time I was looking for a decent programming language with OOP support
<asarch>
And I thought Perl... well, you know
iqubic` has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
thinkpad has joined #lisp
jstypo has quit [Remote host closed the connection]
<asarch>
I will Bike
<asarch>
Thank you
<pjb>
asarch: you may try: printf '((' ; psql --tuples-only --dbname="$DB" --user="$USER" --no-align --field-separator=')(' --record-separator='))'$'\n''((' --command="$QUERY" ; printf '))\n'
<pjb>
or perhaps: printf '("' ; psql --tuples-only --dbname="$DB" --user="$USER" --no-align --field-separator='")("' --record-separator='"))'$'\n''(("' --command="$QUERY" ; printf ')\n' # you may also have to modify the readtable, in either case, if any field contains double quotes or stuff…
<asarch>
Wow! That's poetry gentlemen
z3t0 has quit [Remote host closed the connection]
<pjb>
asarch: you may also just use --html, and then parse the HTML. It may be safer, if psql escapes correctly < and > in the fields.
<asarch>
Ok
<pjb>
Anyways, the idea is to generate something easy to parse.
marusich has quit [Ping timeout: 252 seconds]
CrazyEddy has quit [Ping timeout: 264 seconds]
<asarch>
You are awesome
<asarch>
Where did you learn those kind of operations?
z3t0 has joined #lisp
<asarch>
Are you a PostgreSQL developer?
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
marusich has joined #lisp
<pjb>
asarch: psql --help !
<pjb>
asarch: we're working with unix systems. The only thing you need to know is: man
<pjb>
asarch: first type: man man RET
<pjb>
asarch: then type: ls /bin ; then type: man cmd # for cmd in /bin.
<asarch>
I know, I know. I mean the way you combine such options and their parameters
<pjb>
asarch: unfortunately, nowadays things are more complex. Youngsters can't respect nice conventions, such as writing a unix manual page. Instead, then write info page sometimes, or --help option to their commands.
<asarch>
Manuals are endless
<asarch>
In Python there are literally tons of them
<pjb>
and then, indeed, there's google…
<asarch>
Nowadays people usually gets angry with basic questions
<asarch>
For example, when I was learning Python I asked about how to put two commands in a single line
<asarch>
Since Python actually gets rid of the semi-colon punctuation mark to end a command just like Perl or C/C++ do
<asarch>
"How could I put two commands on a single line?" <- Blame on me :-(
fikka has quit [Ping timeout: 248 seconds]
<aeth>
The only thing you need to know is man unless it's a GNU project, in which case the man just tells you to use info for the real information.
<aeth>
e.g. "The primary documentation of GNU Emacs is in the GNU Emacs Manual, which you can read using Info, either from Emacs or as a standalone program. Please look there for complete and up-to-date documentation. This man page is updated only when someone volunteers to do so."
<aeth>
Oh, great, the newest Firefox (48?) or something else seems to have no audio in StumpWM. Is anyone else getting this? It tells me to install PulseAudio, which is nonsense because (1) everything else still has sound and (2) Firefox on other desktops like KDE still has sound.
randomstrangerb has quit [Ping timeout: 248 seconds]
fittestbits has joined #lisp
randomstrangerb has joined #lisp
fikka has joined #lisp
<aeth>
Looks like I now need to enable pulseaudio via systemd, even though I have never needed to do that before.
<aeth>
What's particularly strange is that the change in Firefox happened 6 versions ago but I'm only having the problem now.
EvW1 has joined #lisp
drewc has quit [Ping timeout: 240 seconds]
wmannis has quit [Quit: wmannis]
nowhere_man has joined #lisp
Cymew has joined #lisp
Devon has joined #lisp
<pjb>
aeth: well this is #lisp, we wouldn't know.
<aeth>
I assumed it was a flaw in stumpwm
nowhereman_ has quit [Ping timeout: 256 seconds]
<Bike>
there's a stumpwm channel
Cymew has quit [Ping timeout: 256 seconds]
<aeth>
Technically, I think it *is* a flaw in stumpwm because KDE has some way of working around this without me having to do something. I guess I can take it to the stumpwm channel, though.
<didi>
aeth: StumpWM is just a Window Manager. KDE is a whole desktop environment. They aren't comparable.
<didi>
Every time I use `multiple-value-bind' and I don't care about some variables, I dream of writing a macro that would discard NIL variables.
d4ryus2 has joined #lisp
smurfrobot has quit [Remote host closed the connection]
drewc has joined #lisp
<aeth>
didi: Imo, they are comparable. The main difference is the lack of a StumpWM suite of applications (which means having to use a terminal, graphical file manager, etc., intended for a different desktop environment)
<Bike>
the point here would be that stumpwm doesn't have some DE workaround deal, since it just displays windows
d4ryus1 has quit [Ping timeout: 240 seconds]
arescorpio has joined #lisp
<didi>
aeth: Taking your problem as an example, StumpWM knows nothing about sound, only windows. If you are running some kind of sound server, it wasn't StumpWM that started it.
EvW1 has quit [Ping timeout: 240 seconds]
Chream has quit [Ping timeout: 240 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fikka has quit [Ping timeout: 248 seconds]
ikopico has quit [Ping timeout: 265 seconds]
ikopico has joined #lisp
CrazyEddy has joined #lisp
red-dot has joined #lisp
Oladon has joined #lisp
fikka has joined #lisp
rumbler31 has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
rumbler31 has quit [Ping timeout: 240 seconds]
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
pierpa has joined #lisp
aindilis has quit [Remote host closed the connection]
aindilis` has quit [Remote host closed the connection]
dieggsy has quit [Ping timeout: 240 seconds]
cromachina_ has joined #lisp
aindilis has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
cromachina has quit [Ping timeout: 268 seconds]
Devon has quit [Ping timeout: 264 seconds]
iqubic has joined #lisp
<iqubic>
What does paredit do?
<iqubic>
in emacs.
fikka has quit [Ping timeout: 240 seconds]
<whoman>
it provides editing of lisp forms in an almost geometric fashion
<pjb>
iqubic: it ensures parentheses are always balanced.
<whoman>
nah
<pjb>
iqubic: actually, it's more than that: it is a structured sexp editor.
<whoman>
i wouldnt imagine writing lisp out by hand
<Bike>
you don't need it.
<whoman>
other than symbols; paredit to working with lisp in emacs is what macros are to lisp, lets say
<pjb>
iqubic: as a lisp beginner, I would 1- use the CL implementation in a terminal during 2 days. 2- use the CL implementation in emacs (without slime) during 2 days. 3- use the CL implementation in emacs with slime during 2 days. and finally 4 use CL in emacs with slime and paredit for the rest of my life.
<pjb>
iqubic: this way, you'd know what you'd lose not using them.
<whoman>
=)
<iqubic>
I'm using SLIME already.
fikka has joined #lisp
<whoman>
wrapping/unwrapping and moving left and right parens, are very nice features of paredit
<iqubic>
I did steps 1 to 3 already.
<whoman>
also kill-line works by sexp and other nice things
marusich has quit [Ping timeout: 240 seconds]
jibanes has quit [Ping timeout: 248 seconds]
jibanes has joined #lisp
<beach>
Good morning everyone!
<Colleen>
beach: drmeister said 8 hours, 22 minutes ago: Above I dumped the environment from within convert-elementary-setq (stored in cleavir-cst-to-ast::*debug-env*)
<Colleen>
beach: drmeister said 8 hours, 21 minutes ago: This is the environment when compiling one of the PUSH macros in this macro... https://github.com/drmeister/clasp/blob/cst/src/lisp/kernel/lsp/defmacro.lsp#L95 There is no mention of special-variable entries - so I think something is wrong with how the environment is being put together.
arescorpio has quit [Excess Flood]
ghostyyy has joined #lisp
<ghostyyy>
hi, i have heard a lot about lisp macros, does anyone know any useful and practical examples of their usage?
<beach>
ghostyyy: That's a very strange question.
<ghostyyy>
i googled it but i just get people talking about why macros are cool, ajnd not a lot of practical examples
<beach>
ghostyyy: But you can always read the book called "On Lisp" by Paul Graham.
<beach>
It is entirely dedicated to macros in Common Lisp.
<beach>
And it is available as a PDF.
dddddd has quit [Remote host closed the connection]
<ghostyyy>
oh, i see! are clisp macros different from hygenic scheme macros in any appreciable way? i dont know clisp well, only scheme
<beach>
ghostyyy: Basically, macros allow the programmer to introduce syntactic abstractions, thereby making it possible to cut down on a lot of boilerplate code.
<iqubic>
What is Clisp?
<iqubic>
Common Lisp?
<ghostyyy>
yes
<pjb>
nope.
<beach>
ghostyyy: CLISP is not an accepted abbreviation for Common Lisp.
<Bike>
'clisp' is the name of a common lisp implementation
<Bike>
so it's confusing to use the word to mean common lisp in general
<pjb>
clisp is a CL implementation, written in C, hence the C in CLISP.
<ghostyyy>
oh, sorry, my apologies
<Bike>
it's cool, everyone seems to do it at first
<beach>
ghostyyy: Like I said, "On Lisp" is entirely about Common Lisp macros.
<Bike>
anyway, yes, common lisp macros are different from hygenic scheme macros
<beach>
ghostyyy: Common Lisp macros have the full language at their disposal in order to transform a form to a different form.
<Bike>
the downside to simpler is that you have to think about actual symbols and worry about a bunch of stuff, but i've never had an issue with it
<Bike>
well, cond is a pretty good macro
<beach>
ghostyyy: On Lisp contains much bigger examples.
<ghostyyy>
well, i have to agree with you there Bike
<iqubic>
Why not just use gensym?
<ghostyyy>
beach, yeah, it looks good! ill have a look at it
saki has quit [Quit: saki]
<ghostyyy>
iqubic, that only solves one half of the accidental caputre problem, the problem where your macro binds a name already in its context
<beach>
iqubic: Certain ideas in programming language design want to protect the programmer from himself/herself, so the language is trying to make it impossible to introduce certain problems.
<ghostyyy>
the other half is where the macro's context binds a name which has the same name as a global
<ghostyyy>
then the macro invocation uses the local name and not the global name
saki has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Remote host closed the connection]
warweasle has quit [Read error: Connection reset by peer]
<drmeister>
Hygienic macros are more important in a Lisp-1, with a single shared namespace for function names and variable names. Common Lisp is a Lisp-2 (or more?) and problems that hygienic macros solve in a Lisp-1 are more conveniently solved with GENSYM.
<drmeister>
That was one take-home message I learned from "Let Over Lambda"
<pfdietz>
Also, there's less problem with overriding of functions by local variables in CL. Go ahead and use 'list' as a variable name, none of that schemish 'lst' stuff.
<ghostyyy>
drmeister, what about the problem i mentioned, where some code shadows a global variable, which is also used by a macro, and then that macro is invoked inside of that context?
<ghostyyy>
wont the macro use the local binding, and not the global binding?
<Bike>
yes. cl also prevents shadowing standard names, which mostly makes that not a problem, though it's not a very "clean" solution
fikka has joined #lisp
<drmeister>
I think you can get around that by declaring variables locally special?
<beach>
ghostyyy: Not sure whether you are talking about the expansion code or the expanded code.
<ghostyyy>
drmeister, im not sure what you mean by that exactly
<pfdietz>
You don't want information to be passed down into macros using special variables. Use the macro environment.
<beach>
ghostyyy: The expanded code should not use any free variables that way.
<Bike>
well "free variables" can include functions.
<ghostyyy>
pfdietz, are you supposed to just pass every function that you plan on using inside of the macro to it via macro arguments?
<ghostyyy>
or did you mean something else
<beach>
Bike: Sure, but if it only uses standard functions, the standard prevents shadowing, as you pointed out.
<ghostyyy>
ah, so the solution is "only use standard functions inside of macros"?
<Bike>
yeah. i'm just saying, pretty much any macroexpansion has free variables. it's just not usually an issue in practice.
<pfdietz>
ghostyyy: one thing to remember is that when you compile code, the macros are evaluated at compile time, not when the code they are in is run. So if that code binds a variable later, it doesn't affect the macro at all. The macro is already expanded.
<Bike>
no, the solution is don't shadow things much and it doesn't come up, really.
<ghostyyy>
pfdietz, i am aware of that
<Bike>
pfdietz: i think you're on a different issue.
<pfdietz>
Ok.
<drmeister>
Anyway Common Lisp macros are awesome - Scheme macros feel kind of "nerfed".
<beach>
ghostyyy: Also, the package system prevents a lot of accidents like that.
<drmeister>
(oh yeah - I'm going there)
<drmeister>
:-)
<Bike>
i don't think i remember the last time i shadowed a function binding
<beach>
ghostyyy: A macro that expands to the use of a globally defined function that is not standard, is typically defined in the same package as that function.
<ghostyyy>
drmeister, out of curiosity, how do you feel about type systems :^)
<ghostyyy>
beach, i see
<ghostyyy>
i find this all a bit fascinating
<beach>
ghostyyy: So to have an accident, client code would have to write (flet ((package::secret-function (....))) (macro-call ...))
<Bike>
it's like, i get that common lisp macros are dangerous in theory, and that hygenic macros are safe, but it just has not happened for me
<Bike>
i have never run into this latter situation in several years of programming and had to be introduced to the possibility by an academic paper
<Bike>
it's weird
<beach>
"dangerous" is a very strong word.
<Bike>
"in theory" is intended to neuter it
<beach>
OK.
<ghostyyy>
it honestly has never really occurred to me that someone might not think macro hygiene is an important thing to have, but i guess if its not a problem you encounter often then it makes sense
<beach>
ghostyyy: The problem never happens in fact.
<whoman>
Moreover!
<beach>
ghostyyy: Perhaps it does for newbies who don't know about GENSYM, but not for programmers with a bit of experience.
<pfdietz>
Or, if it does happen, there are so many more common ways to shoot yourself in the foot that it doesn't matter.
<ghostyyy>
in retrospect i do find it kind of amusing that people have done serious academic research on how to let people get away with shadowing basic operations like cons
<ghostyyy>
still, i do feel like its a good thing, just that it gives you a nice guarantee that nothing bad will happen, no matter how hard you try
<pfdietz>
You can shadow CONS in CL. You work in a package where the symbol CONS means something else.
<whoman>
Furthermore!
<Bike>
contrariwise
<beach>
ghostyyy: It is a matter of compromise. The more such guarantees that the language can provide, the harder it gets to use it.
<whoman>
ahah *adds to library*
<ghostyyy>
beach, yeah, i can get that
<Bike>
i do like the conceptual simplicity of it. macro function's just a function you call on some code. obviously you can do all kinds of horrible things in that framework, but programming is all about that anyway
<khrbt>
is there x86_64 cmucl?
<beach>
khrbt: Why would you like CMUCL?
<beach>
khrbt: I mean, what is it in CMUCL that you need, and that is not also in SBCL?
<khrbt>
it is mainly out of curiosity. I am just exploring things.
<beach>
I see.
* drmeister
prefers a powerful language that doesn't come with airbags, training wheels and safety rails. Wheee!
<ghostyyy>
drmeister, i thought so :p
oleo has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<pfdietz>
In a large project those get added back, layered on top of the language as social restrictions to get a large group of programmers to work well together. Things like "thou shalt not use :: on any symbols in your code".
<ghostyyy>
thou shalt prefix all of thine identifiers with the name of thine module
<whoman>
surrender or die
schoppenhauer has quit [Ping timeout: 248 seconds]
schoppenhauer has joined #lisp
brendyn has joined #lisp
dented42 has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Bike has quit [Quit: Lost terminal]
oleo has quit [Remote host closed the connection]
fikka has joined #lisp
asarch has quit [Quit: Leaving]
zazzerino has quit [Ping timeout: 248 seconds]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
marusich has joined #lisp
pierpa has quit [Quit: Page closed]
dtornabene has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
sjl has joined #lisp
marusich has quit [Remote host closed the connection]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<drmeister>
Do the declares on line 3 make any sense?
<drmeister>
I and R are variable names - not function names
<drmeister>
This is generated by the DO* macro and I'm trying to track down where they are coming from
z3t0 has quit [Ping timeout: 256 seconds]
newcup has quit [Ping timeout: 265 seconds]
cyraxjoe has joined #lisp
<drmeister>
Got it - it was a typo in the C++ code that canonicalized declarations
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
mishoo has quit [Ping timeout: 240 seconds]
dented42 has joined #lisp
pagnol has joined #lisp
ym has quit [Ping timeout: 260 seconds]
LocaMocha has joined #lisp
python476 has joined #lisp
Karl_Dscc has joined #lisp
mishoo has joined #lisp
vlatkoB has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
zaquest has quit [Read error: Connection reset by peer]
igemnace has quit [Quit: WeeChat 2.0.1]
flamebeard has joined #lisp
z3t0 has joined #lisp
z3t0 has quit [Ping timeout: 240 seconds]
zaquest has joined #lisp
nox2 has quit [Ping timeout: 256 seconds]
Karl_Dscc has quit [Remote host closed the connection]
nox2 has joined #lisp
z3t0 has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
z3t0 has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
<phoe>
drmeister: was the typo s/ftype/type/?
heurist` has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 264 seconds]
heurist` has joined #lisp
heisig has joined #lisp
raynold has quit [Quit: Connection closed for inactivity]
hiroaki has joined #lisp
z3t0 has joined #lisp
fikka has joined #lisp
kami has joined #lisp
<kami>
Good morning.
z3t0 has quit [Ping timeout: 248 seconds]
<jack_rabbit>
'morning
<stylewarning>
Are there any good tutorials about properly creating a new data type in Common Lisp? I feel as though many data types I create that are public facing are not all that good with respect to things like printing, readable representations/literals, FASL safety, etc.
<stylewarning>
It would be nice to have a checklist for creating a high quality user data type, be it a new class or structure.
<phoe>
stylewarning: I think the best idea is to start creating one, fill it with your ideas, post it here, gather comments, update the document, rinse, repeat.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<phoe>
I am not aware of any such document related to Common Lisp.
<stylewarning>
Yeah I may do that. The impetus is to redesign CL-ALGEBRAIC-DATA-TYPE which is rough around the edges in terms of things like respecting print variables.
red-dot has joined #lisp
<phoe>
shka: ^
<phoe>
stylewarning: I see. Good luck with it!
<shka>
phoe: uhhh
<phoe>
shka: data type discussion, I thought to link you up
<shka>
well, what i would know about that
<phoe>
you are defining data types within cl-df
<phoe>
cl-ds*
<phoe>
so you have some experience, I guess (:
<shka>
well, yes, but FASL safety?
<shka>
i have no clue what is safe and what is not
<shka>
but i would gladly find out
Cymew has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
z3t0 has joined #lisp
<stylewarning>
Maybe FASL safety is a poor term. What I mean is making sure your data structures can be dumped by having load forms and the like
z3t0 has quit [Ping timeout: 240 seconds]
z3t0 has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
schweers has joined #lisp
pagnol has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
z3t0 has quit [Ping timeout: 256 seconds]
Murii has joined #lisp
Murii is now known as Murii
flamebeard has quit [Quit: Leaving]
scymtym has joined #lisp
python476 has quit [Ping timeout: 248 seconds]
angelo has quit [Ping timeout: 260 seconds]
whoman has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
whoman has joined #lisp
fikka has joined #lisp
<beach>
stylewarning: You mean that instances of the type can be dumped?
z3t0 has joined #lisp
<beach>
I do that by defining a reader macro `[', so that an object is represented as [package::class :initarg1 value1 :initarg2 value2 ..]. The reader macro simply reads the list and then does (apply #'make-instance list).
<beach>
That way, I can handle arbitrary circularity through #= and ##.
<beach>
For the other aspects of data types, I would be willing to review your design.
fikka has quit [Ping timeout: 240 seconds]
angelo|2 has joined #lisp
z3t0 has quit [Ping timeout: 248 seconds]
shka has quit [Remote host closed the connection]
fikka has joined #lisp
shka has joined #lisp
z3t0 has joined #lisp
pagnol has joined #lisp
z3t0 has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 252 seconds]
damke_ has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
damke has quit [Ping timeout: 264 seconds]
visof has joined #lisp
visof has joined #lisp
visof has quit [Changing host]
zooey has quit [Ping timeout: 255 seconds]
<Shinmera>
stylewarning: You should always provide a print-object method that prints it in a usable way, and possibly a describe-object method for detailed description.
<Shinmera>
stylewarning: make-load-form is only necessary if you expect it to be useful to use your object as a literal.
<Shinmera>
which is not very often
hhdave has joined #lisp
sjl has joined #lisp
z3t0 has joined #lisp
zooey has joined #lisp
kami has quit [Remote host closed the connection]
z3t0 has quit [Ping timeout: 248 seconds]
sjl has quit [Ping timeout: 268 seconds]
attila_lendvai has joined #lisp
fikka has joined #lisp
z3t0 has joined #lisp
z3t0 has quit [Ping timeout: 276 seconds]
ninegrid has joined #lisp
whoman has quit [Remote host closed the connection]
whoman has joined #lisp
pjb has quit [Ping timeout: 256 seconds]
z3t0 has joined #lisp
z3t0 has quit [Ping timeout: 255 seconds]
Amplituhedron has quit [Read error: Connection reset by peer]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
ym has joined #lisp
_cosmonaut_ has joined #lisp
Mandus has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
randomstrangerb has quit [Ping timeout: 260 seconds]
randomstrangerb has joined #lisp
pjb has joined #lisp
wxie has joined #lisp
thijso has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Remote host closed the connection]
<loke>
Shinmera: isn't it important to use MAKE-LOAD-FORM if you have soemthing like (defconstant +foo+ (make-instance 'my-special-class))
<Shinmera>
loke: Well yeah because then it's a literal.
<Shinmera>
Anything that is dumped to a FASL.
<loke>
Right.
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
smurfrobot has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
milanj has joined #lisp
random-nick has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
pjb has quit [Ping timeout: 256 seconds]
python476 has joined #lisp
nirved has joined #lisp
damke has joined #lisp
varjag has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
damke_ has quit [Ping timeout: 264 seconds]
red-dot has joined #lisp
Cymew has quit [Remote host closed the connection]
saki has quit [Quit: saki]
smurfrobot has joined #lisp
heurist` is now known as heurist
smurfrobot has quit [Ping timeout: 264 seconds]
pagnol has quit [Ping timeout: 256 seconds]
pagnol has joined #lisp
d4ryus2 is now known as d4ryus
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 248 seconds]
Tobbi has joined #lisp
z3t0 has joined #lisp
smurfrobot has joined #lisp
MrMc has joined #lisp
z3t0 has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Ping timeout: 248 seconds]
<MrMc>
For my Bachelor Thesis I would like to write a common lisp library is eBay API worth the while
tonton has quit [Ping timeout: 268 seconds]
tonton has joined #lisp
z3t0 has joined #lisp
whoman has quit [Remote host closed the connection]
whoman has joined #lisp
z3t0 has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
markong has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
wxie has quit [Remote host closed the connection]
pagnol has quit [Ping timeout: 240 seconds]
``Erik_ is now known as ``Erik
z3t0 has joined #lisp
<cess11>
MrMc: they have twenty or so
z3t0 has quit [Ping timeout: 260 seconds]
jstypo has joined #lisp
dddddd has joined #lisp
<MrMc>
cess11: Do you mean there are 20 common lisp eBay API sdks
<drmeister>
phoe: The typo was the generation of the ftype
<drmeister>
Shinmera: Got it - I responded to the poster.
<drmeister>
Thank you very much
<cess11>
no, I mean that this company exposes about that many fairly open API:s. you'll probably want to decide which are interesting for your studies.
damke_ has joined #lisp
BitPuffin has joined #lisp
<MrMc>
cess11:I am interested in porting the ones done in the python sdk
damke has quit [Ping timeout: 264 seconds]
<cess11>
MrMc: why the python sdk?
pagnol has joined #lisp
visof has quit [Quit: Leaving]
<MrMc>
cess11: It's a guideline of what working code should look like
<cess11>
yeah but why pick python over .NET or Java?
<Shinmera>
MrMc: Do you even have anyone that would supervise such a thesis? A professor that would accept and review it?
z3t0 has joined #lisp
EvW has joined #lisp
<MrMc>
cess11:python is easy to read for me
<cess11>
doesn't sound like a particularly academic argument to me
red-dot has joined #lisp
iqubic` has joined #lisp
<MrMc>
Shinmera: I will have to sell the idea to my internet programming Prof
orivej has joined #lisp
<Shinmera>
Not just that, you need to find someone, probably an assistant of the prof, to supervise you for the duration of the thesis. I heavily doubt you'll find anyone that knows Common Lisp, so I heavily doubt you'll find anyone willing to do that.
<MrMc>
cess11: The idea is just to implement the APIs implemented in Python
<cess11>
also, the others are more verbose and less hackish in their syntax, they are very easy to understand.
z3t0 has quit [Ping timeout: 256 seconds]
<cess11>
why? who would want to use it often?
iqubic has quit [Ping timeout: 252 seconds]
<Shinmera>
Besides, what you're proposing does not sound suitable for a thesis. How would it further science? What kind of prior research would you cite? How does this present anything new? A thesis is more than just implementing a piece of code.
<cess11>
usually there's something resembling a research question in a thesis, what would yours be?
DeadTrickster__ has joined #lisp
<MrMc>
Something along the lines can a language standadised in the past millenium be used for eCommerce today
<cess11>
the answer to that one is known
ioa has joined #lisp
<cess11>
doubt anyone would say no to it
rumbler31 has joined #lisp
<ioa>
good morning
smurfrobot has joined #lisp
<cess11>
ioa: good morning
jmercouris has joined #lisp
<jmercouris>
I got this error from uiop "Program args must all be simple strings", what is a simple string?
<jmercouris>
Is there a conversion method for string --> simple string?
<cess11>
MrMc: if you were to search for something like 'common lisp ecommerce' you'll find some useful resources. if you choose a project you can express formally it will increase your chances of getting someone to grade it.
<Shinmera>
Xach: I don't think simple-string is specified to be known by coerce, right?
<jmercouris>
didn't make an error in my repl
<jmercouris>
let me try it in my actual program now
smurfrobot has quit [Ping timeout: 276 seconds]
<jmercouris>
didn't seem to like that :\
<jmercouris>
maybe I have a mistake elsewhere though
<Xach>
Shinmera: I don't know. I can't tell quickly from the rules.
<Xach>
A simple-string is a sequence, so maybe it's covered.
<Shinmera>
"If the result-type is a recognizable subtype of vector, and the object is a sequence, then the result is a vector that has the same elements as object. If result-type is a specialized type, the result has an actual array element type that is the result of upgrading the element type part of that specialized type. If no element type is specified, the element type defaults to t. If the implementation cannot
<Shinmera>
determine the element type, an error is signaled."
<Shinmera>
But that doesn't seem to guarantee simple-ness to me
<Shinmera>
Just that the element-type is proper.
<MrMc>
cess11: I will try to look for a formal way to express it
wigust has joined #lisp
<Shinmera>
I mean I see no reason for it to not be simple in an implementation, but it doesn't seem guaranteed either.
<Xach>
Shinmera: the description of /result/ suggests it to me.
<Shinmera>
Ah, right.
<jmercouris>
I was quoting the list in which there was a nested coerce...
<jmercouris>
of course it would not work
<jmercouris>
anyways, coerce works, thank you
makomo has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<jmercouris>
does uiop read $path? how does it know where a program is?
<Xach>
jmercouris: i think uiop defers to whatever the implementation provides. on sbcl run-program uses execve.
<Xach>
err, hmm, that's not quite right
<Xach>
there's an exec variant that is specified to look in the PATH...
<jmercouris>
I guess I'll try to find the ccl ones
<Xach>
execvp and execlp etc
mercourisj has joined #lisp
<mercourisj>
uiop does seem to be aware of shell specific variables
jmercouris has quit [Ping timeout: 240 seconds]
<mercourisj>
because if I execute "echo" it knows
<p_l>
it might be calling system(3)
<Xach>
The answers are a few M-.s away, except asdf's many wrapping forms might jump you to the wrong place.
<mercourisj>
Yeah, I've been looking at run-program...I'd need to spend a little bit of time to understand it
attila_lendvai has quit [Read error: Connection reset by peer]
<mercourisj>
there's some indirection
hhdave has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fikka has joined #lisp
KZiemian has joined #lisp
red-dot has joined #lisp
<pfdietz>
(coerce <sequence> 'simple-string) will give you a simple-string, since the value returned by (coerce x y) is of type y.
<KZiemian>
It looks like that Sonia Keeyne book is still outside public domain
<Xach>
That is true.
<KZiemian>
any other good material for CLOS?
<Xach>
KZiemian: practical common lisp is freely readable online
<KZiemian>
Xach: asaid ,,Succesfull Lisp'' my main source of Lisp knowledge
<KZiemian>
maybe I should try to read whole SL again?
<Xach>
KZiemian: or read practical common lisp?
<KZiemian>
Xach: I must left reading PCL for sickness of to much theory and to less programming
<Xach>
KZiemian: try again
<KZiemian>
Xach: I stuck in condition and restarts chapter
<jackdaniel>
PCL has a bare minimum of theory (imho)
<Xach>
KZiemian: go to another chapter
<Shinmera>
"practical" is in its name!
<jackdaniel>
that
<KZiemian>
jackdaniel: true
<KZiemian>
Shinmera: that show how few things to program in Lisp I now have
<KZiemian>
Shinmera: mostly is numeric in Numpy or some graphic in C++
<KZiemian>
I need more practice in CL, definietly
damke_ has joined #lisp
z3t0 has joined #lisp
deng_cn has quit [Read error: Connection reset by peer]
damke has quit [Ping timeout: 264 seconds]
m00natic has joined #lisp
deng_cn has joined #lisp
z3t0 has quit [Ping timeout: 265 seconds]
Bike has joined #lisp
z3t0 has joined #lisp
mishoo has quit [Ping timeout: 246 seconds]
z3t0 has quit [Ping timeout: 248 seconds]
rumbler31 has joined #lisp
<AeroNotix>
PCL is imho the best book to learn CL imho. It doesn't put CL on a pedestal like a lot of books do. It treats the language just as a language. Rather than trying to put a halo of mythology around it.
Cymew has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
<dlowe>
Honestly, it was the most amazing thing for a long time, but these days it's a solid middle-of-the-road language with a lot of history.
yangby has joined #lisp
<AeroNotix>
Don't know about that. I use a lot of the new fangled languages and I still find myself thinking how much easier things would be in CL.
<AeroNotix>
literally the only thing I think CL doesnt have going for it is a good standardized concurrency model. there are good libraries which are portable but still.
<rumbler31>
AeroNotix: can you expand on that last part a little?
<AeroNotix>
rumbler31: I just mean that in the CL standard it doesn't standardize any concurrency interface as far as I know (threads, actor model etc)
<Shinmera>
atomicity of operations and the memory model are good things to know for concurrency.
attila_lendvai has quit [Read error: Connection reset by peer]
<AeroNotix>
Right and if CL specified a higher level interface for say, threads and related functionality (mutexes) a lot of the atomics are implied.
<dlowe>
Yeah, the newer languages all have their own scheduler and so far only CMUCL has done this (that I know of) and it wasn't amazing.
<heisig>
AeroNotix: sometimes I have the impression that concurrency is such a blurred topic, that maybe the best approach is to leave it outside of a language standard...
<pjb>
AeroNotix: I wouldn't say that anu atomocs are implied.
<pjb>
AeroNotix: on the contrary. For example some implementation (having threads), ensure atomicity of hash-table accessess while others don't.
attila_lendvai has joined #lisp
<AeroNotix>
pjb: depends how you look at it. If it's parallel and you specify a mutex interface the implementation would require some level of atomicity
<Shinmera>
heisig: The problem with that is that it becomes very hard or impossible (under efficiency constraints) to write portable software.
<AeroNotix>
I wasn't around in them days. Were threads even a thing back then?
<pjb>
AeroNotix: even setf of a variable is not always implemented atomicly (eg. on 64-bit machines with 32-bit data bus, you could end with botched data or references!).
<AeroNotix>
that makes sense
<pjb>
AeroNotix: the alternative would be to have locks everywhere! It would be way to slow for most purposes.
<AeroNotix>
What I was meaning is that if there was a standardized concurrency interface a lot of those issues would've needed to be addressed.
<AeroNotix>
even if the standard said that it wasn't expected to be atomic
<pjb>
They would have to be addressed at this interface level.
<pjb>
On the other hand, the application developper usually know what his mutexes are, so he can add only the locks that are needed.
randomstrangerb has quit [Ping timeout: 260 seconds]
<AeroNotix>
Right, I agree with that approach. I wasn't meaning that (for example) setf would need to become atomic as part of the standard just that having a concurrency model in the standard that operations like setf would need to have their atomicity explained.
<heisig>
Shinmera: I know. On the other hand, standardizing on concurrency can also screw you at a later time if hardware capabilities change.
<Shinmera>
heisig: Of course.
warweasle has joined #lisp
<heisig>
Shinmera: Then you would have some bogus requirement in the standard.
randomstrangerb has joined #lisp
<AeroNotix>
pjb: I've had it said to me before that including a concurrency model in the standard would've been a bad idea. For example if green threads or the actor model was chosen and a new technology appeared and rendered it obsolete
<AeroNotix>
but implementations would need to include it for standard's sake.
<tfb>
AeroNotix: the LispMs had threads (which they called processes if I remember rightly)
<rumbler31>
well so... what, is the argument that languages that have concurrency friendly intrinsics may restrict implementation flexibilty?
<pjb>
AeroNotix: indeed. Imagine you're implementing CL on a GPU. You won't have the same problems at all as when implementing it on a CPU.
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
<AeroNotix>
Right. Perhaps if the API was described broadly enough #'EXECUTE-CONCURRENTLY or something. That doesn't imply any particular model.
<AeroNotix>
(obviously you would need more than that^)
<pjb>
At one time, processors didn't have cache memory and memory barriers. Now they all have it.
<Shinmera>
rumbler31: Yes, though that's only part of it. The other part is that the requirements by the spec may be too harsh or even wrong, affecting not just implementations but also users.
<AeroNotix>
yeah it'd be a poor experience if they added a model which only made sense at the time but was superseded by better technology today
deng_cn has quit [Read error: Connection reset by peer]
mishoo has joined #lisp
iqubic` has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 240 seconds]
zaquest has quit [Read error: Connection reset by peer]
deng_cn has joined #lisp
smurfrobot has joined #lisp
<dlowe>
If it were abstracted with a nice interface, the implementation could use the better technology.
<dlowe>
(in theory)
<AeroNotix>
yeah that's what I meant with #'EXECUTE-CONCURRENTLY
<dlowe>
That's a start, but the interface includes stuff to pass data around, locking, etc.
dieggsy has joined #lisp
fikka has joined #lisp
quazimodo has quit [Ping timeout: 252 seconds]
smurfrobot has quit [Ping timeout: 260 seconds]
<AeroNotix>
sure, if you kept it generic enough the underlying implementation could be whatever you needed it to be. That said, some models would need primitives for model-specific operations
<dlowe>
mgsk: if you do multiple FOR clauses, they are executed in parallel
<dlowe>
so you can just add "for start from 0" instead of WITH
Amplituhedron has joined #lisp
<mgsk>
But sbcl complains that I'm duplicating the variable START in INTO form
<dlowe>
ah, I see. Maybe you want collect (1+ (pkg-time pkg)) into start
<dlowe>
you don't want it incremented, you just want one more than the return value
<dlowe>
and actually, that makes no effing sense because collect builds a list
<mgsk>
Right, I meant to use summing, but the problem is the same
<mgsk>
Begin with start = 0, then at the end of the loop, set start to start = start + something
<dlowe>
for start = 0 then (1+ (pkg-time pkg))
<dlowe>
that will teach me to not read carefully
oleo has joined #lisp
sjl has joined #lisp
<mgsk>
dlowe: (loop for i in '(1 2 3) for start = 0 then (+ start i) do (format t "~D~%" start))
Jesin has joined #lisp
<mgsk>
Ideally this would result in => 0, 1, 3
<mgsk>
I'm not quite there yet :D
smurfrobot has joined #lisp
khisanth_ has joined #lisp
<dlowe>
uh, how?
Cymew has quit [Remote host closed the connection]
<dlowe>
you want to add the *previous* value, eh?
<dlowe>
(loop for i in '(1 2 3) with start = 0 do (format t "~d~%" start) (incf start i))
attila_lendvai has quit [Quit: Leaving.]
Jesin has quit [Remote host closed the connection]
Khisanth has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
<KZiemian>
see you
<mgsk>
dlowe: (loop for i in '(1 2 3) with start = 0 do (format t "~D~%" start) (incf start i))
KZiemian has quit [Quit: Page closed]
<dlowe>
mgsk: format directives are case-insensitive
<mgsk>
dlowe: ignore me. I don't even know why I pasted the same thing you wrote.
<mgsk>
I might be having a mental breakdown
Cymew has joined #lisp
<dlowe>
you're suffering from a parenthesis deficiency. Only more lisp can help you.
Mandus has joined #lisp
FreeBirdLjj has joined #lisp
<mercourisj>
Alright, so I have within my program something like (defvar some-system-path (calculate-default-path)), when I compile my lisp image, the path calculated on my machine is persisted into the image
<mercourisj>
I want this software to work on other users computers as well, so somehow I should defer (calculate-default-path) to when they launch the program
Cymew has quit [Ping timeout: 240 seconds]
<mercourisj>
because my defvar is a top level form, I was thinking of writing a macro that does this, does this seem like a good idea or no?
<mercourisj>
a macro that will take something like (def-deferred-var var-name var-initialization-function), and var-initialization-function will be invoked on startup to setf some defvar
<Xach>
that is all right
<AeroNotix>
mercourisj: could also setf it in your initialization function (e.g. #'MAIN)
<mercourisj>
ok, I'll go down that path then, thanks for your opinion
<mercourisj>
AeroNotix: Yeah, I was going to put them in a list of vars that will be iterated calling their initalization function
<mercourisj>
AeroNotix: Something akin to the approach for the defcommand macro which also maintains a list of commands
<AeroNotix>
That said, something something globals are bad
<AeroNotix>
mercourisj: is there no way your program could be refactored to not need the global defvar?
<mercourisj>
Yeah yeah, but compromises must be made in favor of emacsyness
<mercourisj>
well, consider *global-map* for the global key map, I guess yes, technically it is possible, but it doesn't make sense
<dlowe>
yeah, but so is threading a super-common piece of data through each and every function
<mercourisj>
also, you had to pass around references of your browser object to every command
<dlowe>
(er, is bad too)
<AeroNotix>
mercourisj: not wanting to start a war but emulating emacs style is a bad practice. Elisp is a terrible lisp and perpetuates bad style
<mercourisj>
You are correct, but, compromises must be made :D
<mercourisj>
I broke traditions already, maybe the program will evolve this away with time
<AeroNotix>
mercourisj: yep, understand. I've said my piece :)
<mercourisj>
and I'll get further from Emacs
zaquest has joined #lisp
z3t0 has joined #lisp
Murii has joined #lisp
z3t0 has quit [Ping timeout: 255 seconds]
deng_cn has quit [Read error: Connection reset by peer]
Jesin has joined #lisp
deng_cn has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
z3t0 has joined #lisp
heisig has quit [Quit: Leaving]
drewc has quit [Ping timeout: 248 seconds]
z3t0 has quit [Ping timeout: 256 seconds]
d4ryus has quit [Quit: WeeChat 2.0.1]
d4ryus has joined #lisp
khisanth_ has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
red-dot has joined #lisp
<pjb>
mgsk: with clauses are evaluated before for clauses, it would be preferable to write them first.
fikka has quit [Ping timeout: 248 seconds]
Timzi has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
EvW has joined #lisp
brendyn has quit [Ping timeout: 240 seconds]
drewc has joined #lisp
<Timzi>
does anybody here run slime on a remote machine? I'm trying to connect to the remote repl, but my /tmp/slime.* file is created on the remote machine and tramp (or swank?) isn't recognizing it's not on my local
Cymew has joined #lisp
<pjb>
Timzi: never had a problem M-x slime-connect to connect to a remote, as long as swank-server was launched.
Cymew has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
<paule32>
ö
<paule32>
pjb: hi
turkja has quit [Ping timeout: 268 seconds]
<Timzi>
oh this could be my problem, I'm trying to start it with just M-x slime
<paule32>
pjb: i done work successfull - clisp with readline and cffi
<pjb>
paule32: great.
<pjb>
paule32: cffi is not needed to compile clisp with readline.
<paule32>
pjb: slime works, too in emacs
<paule32>
no
<paule32>
but later
<pjb>
ok
<paule32>
the compilation of readline was a little bit tricky
<paule32>
the compiler source makefile run, and create a -fas and .lib file - staticaly
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<paule32>
so i solve the issue with rl_readline_state
<paule32>
i comment the line "ulong rl_readline_state" in the the readline.h header file
<paule32>
and compile with lisp, so i had the automatic created readline.c file
<paule32>
now, i go on, and do a manual compile: gcc -O2 -c readline.c
khisanth_ has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
yangby has quit [Quit: Go out for a walk and buy a drink.]
z3t0 has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
<paule32>
then doing a next "make" run, compiles all fine
<paule32>
puh
<paule32>
what a work
<paule32>
:-)
<paule32>
now, i have a working clisp standard system
<paule32>
i go to eat a little bit
<paule32>
so i am in bg
Cymew has joined #lisp
FreeBirdLjj has joined #lisp
z3t0 has quit [Ping timeout: 240 seconds]
<Timzi>
pjb: that got me up and running, thanks!
Cymew has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
Cymew has joined #lisp
FreeBirdLjj has quit [Ping timeout: 276 seconds]
<pjb>
paule32: you didn't understand at all what I meant. I said to compile CLISP itself, not some library.
<pjb>
paule32: in the build instruction of clisp, it's explained how to configure it to link with readline, so that clisp can provide history navigation in its REPL on the terminal.
Cymew has quit [Ping timeout: 268 seconds]
<pjb>
paule32: but basically, if libreadline is available it will be automatic. You can disable it with ./configure --without-readline
<pjb>
paule32: on the other hand, if libreadline is not in a standard place, you can indicate it with ./configure --with-libtermcap-prefix=DIR --with-libreadline-prefix[=DIR] search for libreadline in DIR/include and DIR/lib
<pjb>
<pjb>
why the fuck do I have to read the READMES for you?
Cymew has joined #lisp
schweers has quit [Ping timeout: 255 seconds]
FreeBirdLjj has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Cymew has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 252 seconds]
deng_cn has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
deng_cn has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
ebzzry has joined #lisp
<ebzzry>
Does CL have an equivalent of Racket’s slideshow?
<Xach>
ebzzry: what does racket's slideshow do?
<ebzzry>
Xach: they are for slideshow presentations.
smurfrobot has quit [Remote host closed the connection]
hiroaki has quit [Ping timeout: 256 seconds]
<pjb>
ebzzry: No.
<Xach>
ebzzry: I don't know of anything like that.
<Xach>
Dan Barlow had a CLX hack many, many years ago
<pjb>
ebrasca: CL is a programming language. Racket is a program, including implementations of programming languages. They don't provide anything in common.
Cymew has joined #lisp
<pjb>
ebrasca: slideshows are done in emacs…
<ebzzry>
Is there anything close to using CL as the language for displaying these slideshows? Or, really no?
<Xach>
Not that I've heard of
<antoszka>
ebzzry: I'm sure you could hack up something quick using the new GL or Qt libraries, but there's nothing ready-made for slideshows that comes to mind
<pjb>
jsfiidsf: because there's not any printing function called.
<didi>
Xach: News on the SLIME alternative front?
<Xach>
didi: none to speak of
kamog has joined #lisp
<didi>
Xach: Thanks.
Karl_Dscc has joined #lisp
<ebzzry>
ok
Cymew has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Remote host closed the connection]
Cymew has joined #lisp
drewc has quit [Ping timeout: 240 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
Amplituhedron has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
Cymew has joined #lisp
asarch has joined #lisp
mfiano has quit [Quit: WeeChat 1.9.1]
moei has joined #lisp
Cymew_ has joined #lisp
<whoman>
sigh. people will always want alternatives. what a world. but variety is the spice of life perhaps
<whoman>
i could only imagine how productive someone could be with eating/spewing lisp code with slime and paredit and emacs ; probably faster than thought. there is also a paredit alt called something like that too.
mfiano has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
randomstrangerb has quit [Ping timeout: 260 seconds]
drewc has joined #lisp
<ebzzry>
thanks
<ebzzry>
I wonder how do I load quicklisp on that thing.
Cymew_ has quit [Ping timeout: 268 seconds]
randomstrangerb has joined #lisp
Cymew has joined #lisp
<Xach>
heh
<whoman>
hmm. depends on paths. the local .app folders/dirs should be writable ...
<whoman>
not sure what it thinks about $HOME and that, tho
<ebrasca>
pjb: I thinkg you confused someone else with me.
<pjb>
jjjjjj: you have something in your cranial box. It's called a brain. You must start it up. Don't be afraid, it won't break, it won't wear. It'll be a little magical. Once you brains start working, you'll be able to think, and even to program!
<beach>
jjjjjj: If you don't care about characters that don't match, then just iterate through every character in WORD.
<pjb>
jjjjjj: writing programs has nothing to do with lisp, just reasoning.
smurfrobot has joined #lisp
<beach>
jjjjjj: Maybe if you describe what role you want the variables WORD and GUESS to have, then it might be easier to help.
<jjjjjj>
WORD - the word to be guessed, GUESS - a list of current guesses by the user
<pjb>
jjjjjj: a list or a set?
<jjjjjj>
i'm not familiar with basic lisp idioms..
<pjb>
jjjjjj: what if the users guesses twice #\a?
<jjjjjj>
a list of characters that the user has guessed are in the word
<jjjjjj>
pjb: well, a set, so duplicate guesses are ignored
<pjb>
jjjjjj: does it need to be a list, or can it be a vector or a string?
<jjjjjj>
pjb: whatever works..
<paule32>
hello
<pjb>
Ok. Now the problem is that you're approaching from the wrong direction.
<jjjjjj>
pjb: I could do it easily in python but still don't know that much lisp..
<paule32>
how can i stop output on console in init mode - the time where the packages load
<pjb>
jjjjjj: You see, you asked about that the other day, from your specifications I gave you this function in your paste. But you didn't understand it at all, since you are not able anymore than days ago, to modify to match your refined specifixations.
fikka has quit [Ping timeout: 268 seconds]
<pjb>
jjjjjj: given a specification, we can imagine algorithms, and with the rich CL libraries, we can implement those algorithms in a concise and efficient way, but in a way, it's an opaque way. If you don't know the same libraries, you cannot understand it.
<paule32>
pjb: don't worry, i read docs and found --quiet and --silent
<pjb>
jjjjjj: so my suggestion now would be to start learning Common Lisp, by reading a tutorial, learning about the data types provided by Common Lisp, and the library functions provided to manipulate those data types.
<pjb>
jjjjjj: then, when you will have that basis, we will be able to talk about algorithms and how to best implement them using those opreators.
<jjjjjj>
AeroNotix: thanks for the link
<jjjjjj>
pjb: ok thanks
<pjb>
paule32: compile, load and quickload have a :verbose (and sometimes a :print) key parameters.
<Xach>
That is a good introductory book, but you need not read the whole thing before you come back with more questions.
<pjb>
jjjjjj: cf. http:/cliki.net/Online+Tutorial
<jjjjjj>
thx
deng_cn has quit [Read error: Connection reset by peer]
<paule32>
pjb: you cross over jjjjjj ?
<pjb>
jjjjjj: this is how I learned programming originally: I took the language reference manual, and for each new operator I learned, I wrote a little program to exercise it, to see how it worked. Only after that, I started trying to implement my own programs (and games).
z3t0 has joined #lisp
<jjjjjj>
i don't know how much i can map my existing python knowledge to lisp, that could save time
<Xach>
jjjjjj: in general it will not.
deng_cn has joined #lisp
drcode has quit [Ping timeout: 248 seconds]
Murii has quit [Ping timeout: 264 seconds]
<pjb>
jjjjjj: python is quite alien to lisp. For example, it is strongly based on statements, while in lisp there are only expressions.
<pjb>
jjjjjj: python is a OO programming language, but OO is only one abstration tool in lisp, amongst many others.
fikka has joined #lisp
Denommus has joined #lisp
osune has joined #lisp
<warweasle>
pjb: I had to use python recently. It does some things well...but I can't get over the whitesapce as a delimiter.
<jjjjjj>
pjb: ok. but out of interest, how would you solve this problem in lisp: iterate each char in one string over another, returning matching chars or "-" as appropriate. I don't think I can solve it with my limited knowledge of lisp, but if I saw the solution I could learn from it..
<warweasle>
Also, we need to port blender from python to lisp.
<pjb>
jjjjjj: just as you said it in English!
<Bike>
jjjjjj: isn't that what you already did?
<Bike>
apple and qaqqq, no matches because a doesn't match q, p doesn't match a, etc.
<jjjjjj>
I mean, iterating each char over the whole of the other string. the last solution you gave me didn't do that.
<jjjjjj>
sry
<Xach>
jjjjjj: POSITION can tell you where an element occurs in a string.
<Bike>
so what would "aaa" and "aaa" return?
<pjb>
(let ((word "apple") (guesses "qa")) (loop for letter across word if (find letter guesses) collect letter else collect #\-)) #| --> (#\a #\- #\- #\- #\-) |#
<jjjjjj>
"aaa" and "aaa" -> "aaa", "apple" and "aqqq" -> "a----", "apple" and "qaqqq" -> "a----"
<jjjjjj>
pjb: thank you
milanj has quit [Quit: This computer has gone to sleep]
alexmlw has joined #lisp
<pjb>
Don't thank me: LOOP is the most complex operator in CL: you've not learned anything.
<pjb>
I told you, go read a tutorial!
<pjb>
jjjjjj: also, start up your brains, it's still shut down.
milanj has joined #lisp
Amplituhedron has joined #lisp
jjjjjj has quit [Quit: Page closed]
m00natic has quit [Remote host closed the connection]
smurfrobot has quit [Remote host closed the connection]
karswell_ has quit [Read error: Connection reset by peer]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Timzi has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
red-dot has joined #lisp
didi has left #lisp ["there are always reasons to /part"]
python476 has quit [Ping timeout: 256 seconds]
panji has joined #lisp
Cymew has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
ebzzry has quit [Ping timeout: 268 seconds]
Cymew has quit [Ping timeout: 268 seconds]
pythosnek has joined #lisp
mlf has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
fikka has joined #lisp
Cymew has joined #lisp
pythosnek has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
Cymew has quit [Ping timeout: 240 seconds]
python476 has joined #lisp
mercourisj has quit [Remote host closed the connection]
jmercouris has joined #lisp
<jmercouris>
I'm trying to determine if a symbol points to a function, I tried typep, but a functions symbol is of course just a symbol
<jmercouris>
how can I determine that 'print is a funcallable thing
<jmercouris>
and that (defvar avocado "") 'avocado is not
<White_Flame>
(symbol-function sym) ?
<White_Flame>
of course, there are also LABELS and FLETs
<jmercouris>
Okay so that will throw a condition if not a function
<jmercouris>
interesting, that could work
<jmercouris>
or "raise" a condition, not sure what the correct nomenclature is
<phoe>
"The generic function shared-initialize implements the parts of initialization shared by these four situations: (...) when re-initializing an instance, (...)"
<phoe>
What does it mean, "re-initializing an instance"?
<shka>
phoe: after redefining
<phoe>
I see. So it still is not explicit calling by user code.
kodnin has joined #lisp
<shka>
well, i've been programming in lisp for like 3 years now
Cymew has joined #lisp
<phoe>
clhs 7.1.6 might provide some insight, let me look at it...
randomstrangerb has quit [Ping timeout: 248 seconds]
<Bike>
reinitialize-instance might not "reset" an instance depending on what you mean by that, though. particularly it doesn't reinstall any initforms.
Cymew has quit [Ping timeout: 240 seconds]
<didi>
Idle thought: Isn't it interesting that #'format uses a control /string/ instead of a control /list/?
randomstrangerb has joined #lisp
<Bike>
well, consider like, ~{
Cymew has joined #lisp
<Bike>
~{~a ~} being (start-loop aesthetic " " end-loop) would be kind of weird. ((aesthetic " ")) or something, indicating the loop as part of the structure would make more sense
<Bike>
but then you might as well use actual control constructs and function calls and such
<didi>
jmercouris: Thunk all the things you want to delay computation.
<jmercouris>
didi: What is thunking?
<didi>
jmercouris: lambda without arguments.
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
Cymew has joined #lisp
<jmercouris>
didi: just to be completely clear about my objective- I want the user to be able to pass a function as they normally would with args like this: '(function any-number of arguments :including-keyword args) and then execute that call at a later time
red-dot has joined #lisp
<didi>
jmercouris: Just ask the user to pass you a thunk.
<jmercouris>
didi: does that make sense? or is my explanation not so good? I am pretty tired at the time
<jmercouris>
that seems a burden on the user though
<jmercouris>
wrapping everything in a lambda
<phoe>
no, why?
<Bike>
Shinmera: i suppose that is also the case
<phoe>
jmercouris: I'
<jmercouris>
phoe: you what?
<phoe>
I'd rather pass the function object that I control rather than an arbitrary number of forms that you need to eval at runtime.
<jmercouris>
Ah
<phoe>
and no, it's not a burden. eval-at-runtime is pretty evil in Lisp anyway, and should be avoided wherever possible.
<Bike>
there's no eval, it's just funcall
<phoe>
if you want to accept user-defined code, accept function objects.
<phoe>
Bike: if he accepts Lisp forms, then it's eval at runtime.
<jmercouris>
Yeah, but then their args must be wrapped in a closure
<phoe>
if he accepts function objects, it's funcall
<jmercouris>
it's not a huge deal I guess, but it is a consideration
<phoe>
jmercouris: and?
<jmercouris>
I just don't like the syntax
<jmercouris>
It's a stupid reason really
<Bike>
okay i'm just looking at this here
<jmercouris>
so a thunk is just a lambda without arguments then?
<phoe>
either a lambda without arguments *OR* a lambda with specified arguments that you will pass to it.
<Bike>
i think this is a bit incoherent
<jmercouris>
Yeah, I would agree with that
nowhereman_ has joined #lisp
<Bike>
why can you not just do (push (lambda () (setf ,variable ,value)) *deferred-variables*)
<phoe>
like, if you want to execute user code that will do some things with object FOO, then you will want to accept functions like (lambda (foo) (user-code foo))
Cymew has quit [Ping timeout: 240 seconds]
nowhere_man has quit [Ping timeout: 256 seconds]
<Bike>
(incidentally, that's a thunk right there. you already understand this concept, hooray)
<jmercouris>
Bike: ,value may be a function, that is why
<jmercouris>
and ,value must be evaluated to get the "value"
<phoe>
or you can go the around route and define *foo* as a dynavar, and expect your users to grab its value that way.
Denommus has quit [Ping timeout: 252 seconds]
<Bike>
no
<phoe>
this way, you can "work around" the issue with function arguments. you just hide them in dynamic variables, which is ugly in its own way.
<Bike>
say you have (deferredvar fishes-count (count-fishes :type "salmon")), which i believe was what you wanted your example to be
fikka has quit [Ping timeout: 248 seconds]
<Bike>
this will macroexpand into (push (lambda () (setf fishes-count (count-fishes :type "salmon"))) *deferred-variables*)
<jmercouris>
Yeah, it was, but I changed it for simplicity half way, missed a few spots I guess :D
<Bike>
so, count-fishes won't actually be called until that thunk is called
<jmercouris>
ah shit, yes
<jmercouris>
that makes a lot of sense
<Bike>
the nature of the value form is totally irrelevant, you just wrap it in a thunk
<shka>
heh, good night all
<jmercouris>
I wasn't thinking straight, I was thinking of it as multiple values, but it is just a single list
<jmercouris>
which is just one value within the macro
<Xach>
Bike: graham crackers feller has a persuasive case for default initargs
<Bike>
it can take a bit to wrap your head around.
<Xach>
riesbeck
<Bike>
Xach: is it part of graham crackers?
milanj has quit [Quit: This computer has gone to sleep]
Chream has quit [Ping timeout: 255 seconds]
<jmercouris>
Bike: Thank you for your insight
Cymew has joined #lisp
<_death>
I use :default-initargs to.. pass defaults for initargs :).. if a slot has no initarg, then I use :initform
<Bike>
no problemo
smurfrobot has quit [Remote host closed the connection]
<Xach>
Bike: no
<Xach>
maybe? hmm
<Xach>
can't remember. i linked to it some time ago
<jasom>
_death: implementing the out macro seems like it would require code walking?
<jmercouris>
Ah, nvm, I do see how it is possible, sorry for the interruption, I should probably just go to sleep
z3t0_ has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
eivarv has quit [Quit: Sleep]
z3t0 has quit [Ping timeout: 240 seconds]
eivarv has joined #lisp
Cymew has joined #lisp
shka has quit [Ping timeout: 248 seconds]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
scymtym has joined #lisp
jmercouris has quit [Ping timeout: 248 seconds]
Cymew has quit [Ping timeout: 248 seconds]
vlatkoB has quit [Remote host closed the connection]
pierpa has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
nowhere_man has joined #lisp
fikka has joined #lisp
Karl_Dscc has joined #lisp
jmercouris has joined #lisp
Cymew has joined #lisp
nowhereman_ has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 248 seconds]
Cymew has quit [Ping timeout: 240 seconds]
warweasle has quit [Quit: later]
Cymew has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
<_death>
jasom: if you mean the one in ytools, it doesn't.. for my own, I use an old trick to pass context around
<_death>
phoe: it's available in ytools, which can be found in clocc
hhdave has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
<_death>
my own is in the constantia library
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
crsc has joined #lisp
Cymew has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
crsc has quit [Quit: leaving]
crsc has joined #lisp
antismap has joined #lisp
<crsc>
hi
red-dot has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
jmercouris has quit [Ping timeout: 268 seconds]
josemanuel has quit [Quit: leaving]
osune has quit [Remote host closed the connection]
EvW1 has joined #lisp
<phoe>
hey crsc
mishoo has quit [Ping timeout: 256 seconds]
<Xach>
A new Quicklisp update is upon us this day! Hip hip hurrah!
<phoe>
omg!!!1
<phoe>
how many projects did you need to remove?
eivarv has quit [Quit: Sleep]
<pjb>
with the new release of sbcl…
zaquest has quit [Read error: Connection reset by peer]
zaquest__ has joined #lisp
<_death>
pjb: having spent the day in {}, I recalled your (old?) signature..
z3t0_ has quit [Remote host closed the connection]
<Xach>
phoe: not too many
zaquest__ is now known as zaquest
Cymew has joined #lisp
<phoe>
Xach: good.
fikka has quit [Ping timeout: 240 seconds]
<Xof>
*phew*
dddddd has quit [Ping timeout: 240 seconds]
<Xof>
Xach: the slippery-chicken repo owner (Daniel Ross) is a colleague of mine
Baggers has joined #lisp
<Xof>
in one of those Small World kind of things. "What do you do?" "Oh, really, what lisp do you use?" "Oh, really, do you want to know something funny?"
fikka has joined #lisp
<Xach>
Xof: nice! i was surprised/not surprised to see how old the project is
<Xach>
Lisp music software seems to exist in its own world (much like every other piece of the lisp world)
<Xof>
yeah, I'd never heard of it before a year or so ago either
<Xach>
With a name like slippery chicken it should be more known!
dddddd has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
deng_cn has quit [Read error: Connection reset by peer]
pmetzger has joined #lisp
deng_cn has joined #lisp
nox2 has quit [Ping timeout: 248 seconds]
nullman has quit [Ping timeout: 260 seconds]
nullman has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
random-nick has quit [Quit: quit]
random-nick has joined #lisp
moei has quit [Quit: Leaving...]
papachan has quit [Quit: WeeChat 2.0.1]
jmercouris has joined #lisp
jonh has left #lisp ["WeeChat 0.4.2"]
damke_ has joined #lisp
damke has quit [Ping timeout: 264 seconds]
Karl_Dscc has quit [Remote host closed the connection]
openthesky has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
oleo has quit [Ping timeout: 265 seconds]
fluke`` has quit [Remote host closed the connection]
<stylewarning>
One exercise in Scheme is learning how to do macros that capture name. One such exercise is writing a macro with-degrees (&body) which lexically captures sin/cos/tan and defines them as functions of degrees. In Common Lisp, you can't lexically shadow symbols in the CL package.
<stylewarning>
Nonetheless, I'm curious how someone might actually solve this. Code walk and replace? Does anyone have a simple example of how to do it with current libraries?
z3t0 has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
QualityAddict has quit [Quit: Leaving]
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
fluke` has joined #lisp
<p_l>
I'd love a "trivial-codewalker" that would just hook into compiler innards of the implementation in layerable way :<
<Shinmera>
p_l: I thought that's what macroexpand-dammit! was trying to be, sort of.
z3t0 has quit [Remote host closed the connection]
raynold has joined #lisp
z3t0 has joined #lisp
Jesin has quit [Quit: Leaving]
pagnol has joined #lisp
epony has quit [Quit: QUIT]
nowhere_man has joined #lisp
nirved has quit [Quit: Leaving]
z3t0 has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
sjl has quit [Ping timeout: 252 seconds]
pmetzger has quit [Remote host closed the connection]
jmercouris has quit [Ping timeout: 248 seconds]
pmetzger has joined #lisp
varjagg has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
<jasom>
stylewarning: just shadow the symbols in your current package, and set their fdefinition to be the CL: equivalent
pmetzger has quit [Ping timeout: 268 seconds]
<stylewarning>
jasom: of course you can do that; the idea of the exercise was to just provide a small convenience without extra packages and the like
<stylewarning>
and of course it's not possible, with a macro, to change the package over the lexical scope of the macro
z3t0 has joined #lisp
<jasom>
stylewarning: short of walking the entire tree and replacing the symbols, I can't think of a way. If it were easy that would violate a core part of lisp's macro hygiene
Cymew_ has joined #lisp
<stylewarning>
jasom: Sometimes I do wish it were possible to selectively turn that stuff off.
<jasom>
stylewarning: sbcl lets you disable package locks, so you can on at least one specific implementation
z3t0 has quit [Read error: Connection reset by peer]
z3t0 has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
<stylewarning>
jasom: I guess I meant it would be nice to selectively turn it off
<stylewarning>
to e.g. write a macro like WITH-DEGREES
<jasom>
stylewarning: you can disable it for the lexical scope of a declaration
<stylewarning>
oh, that I didn't know
<stylewarning>
Lexical or dynamic scope?
<jasom>
stylewarning: there is one of each
<stylewarning>
How do I do that
<jasom>
declaration enable/disable-package-locks is lexical
<jasom>
macro with-unlocked-packages is dynamic
Cymew_ has quit [Ping timeout: 240 seconds]
<stylewarning>
jasom: I didn't know about that. Awesome!
<jasom>
(locally (declare (sb-ext:disable-package-locks sin cos tan)) ...)
<stylewarning>
jasom: I need to learn more about these neat features of SBCL. I usually scan the manual every so often, but I guess I missed/forgot this.
<scymtym>
stylewarning: speaking of which: we just made the manual look a little nicer and documented the different kinds of timeouts in SBCL
<stylewarning>
scymtym: even better news! I'll check it out
EvW1 has quit [Ping timeout: 252 seconds]
LiamH has quit [Quit: Leaving.]
pmetzger has joined #lisp
Bike has joined #lisp
<didi>
scymtym: Please, keep the Info manual!
<scymtym>
didi: we just applied a different stylesheet to the HTML version. does that alleviate your concerns?
<didi>
scymtym: It does. Thank you.
varjagg has joined #lisp
EvW has joined #lisp
<stylewarning>
The most useful lisp implementation manual has been LispWorks' collection.
pmetzger has quit [Remote host closed the connection]