* scymtym
always has *PRINT-LEVEL* set to 100 when working in the repl
* sjl
sets *print-length* to 1000 in the repl for the same reason
<scymtym>
that too
<sjl>
yeah, setting them both covers most cases of runaway printing
robotoad has quit [Quit: robotoad]
<sjl>
Doesn't necessarily even have to be circular stuff -- accidentally returning an 100mb vector of bytes and having it printed is unpleasant, but not circular.
anamorphic has quit [Quit: anamorphic]
LiamH has quit [Quit: Leaving.]
anamorphic has joined #lisp
anamorphic has quit [Client Quit]
anamorphic has joined #lisp
anamorphic has quit [Client Quit]
anamorphic has joined #lisp
anamorphic has quit [Client Quit]
lieven has quit [Ping timeout: 252 seconds]
anamorphic has joined #lisp
nirved has quit [Ping timeout: 252 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
jack_rabbit has joined #lisp
lieven has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
robotoad has joined #lisp
anewuser has joined #lisp
<anamorphic>
Circular data structure sounds like a bad time
<jasom>
anamorphic: a doubly-linked list is circular.
<anamorphic>
Hmm yeah
quipa has quit [Remote host closed the connection]
fikka has joined #lisp
v0|d has joined #lisp
xkapastel has joined #lisp
<no-defun-allowed>
anything over around 10000 elements annoys emacs and me
<no-defun-allowed>
emacs and I? shrugs
anewuser has quit [Ping timeout: 268 seconds]
anamorphic has quit [Quit: anamorphic]
<sjl>
me
Essadon has quit [Quit: Qutting]
ryan_vw has joined #lisp
frgo has joined #lisp
frgo has quit [Ping timeout: 268 seconds]
frgo has joined #lisp
Kundry_Wag has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
<v0|d>
no-defun-allowed: 350 frags/hour
<no-defun-allowed>
what?
<v0|d>
insta
<no-defun-allowed>
eh?
Kundry_Wag has quit [Ping timeout: 240 seconds]
malice_ has joined #lisp
warweasle has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 272 seconds]
malice_ has quit [Ping timeout: 256 seconds]
wusticality has quit [Remote host closed the connection]
wusticality has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
Oladon has joined #lisp
djh has quit [Ping timeout: 245 seconds]
milanj has quit [Quit: This computer has gone to sleep]
ryan_vw has quit [Ping timeout: 272 seconds]
wusticality has quit [Ping timeout: 245 seconds]
robotoad has quit [Quit: robotoad]
wusticality has joined #lisp
robotoad has joined #lisp
edgar-rft has joined #lisp
dddddd has quit [Remote host closed the connection]
wusticality has quit [Ping timeout: 268 seconds]
wusticality has joined #lisp
wusticality has quit [Ping timeout: 252 seconds]
khisanth_ has quit [Ping timeout: 252 seconds]
<beach>
Good morning everyone!
ryan_vw has joined #lisp
wanz has joined #lisp
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
khisanth_ has joined #lisp
Roy_Fokker has quit [Read error: Connection reset by peer]
xkapastel has quit [Quit: Connection closed for inactivity]
pjb has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
morning beach
* fiddlerwoaroof
once loaded a 20GB or so file into a vector inside slime and then accidentally told the slime repl to print it
<fiddlerwoaroof>
that was a fun day
<fiddlerwoaroof>
SLIME is ... not optimized for printing 20GB of data in an efficient manner
<no-defun-allowed>
whew, i actually used EVAL-WHEN
jack_rabbit has quit [Ping timeout: 252 seconds]
vlatkoB has joined #lisp
<no-defun-allowed>
turns out macroexpanders with auxiliary functions prefer having the auxiliary functions compiled beforehand
ggole has joined #lisp
elderK has joined #lisp
<pillton>
It is only required if you use the macro inside the compilation unit.
<no-defun-allowed>
which i did in this case
<pillton>
Sure. I am just saying it is not universally the case.
<no-defun-allowed>
true
<elderK>
Moin all :)
<no-defun-allowed>
morning elderK
<Inline>
morning
<elderK>
Guys, is there like a reference for FORMAT directives, like, as a big list? Kind of like how some things on the CLHS has a "dictionary for objects', say
<elderK>
CLHS defines them all, but it requires me to know what I'm looking for :)
<oni-on-ion>
aeth: question
esrse has joined #lisp
<no-defun-allowed>
wtf i broke sbcl somehow
arescorpio has joined #lisp
<no-defun-allowed>
nope but it was being very unsafe with a funcall, don't remember declaiming anything
Patternmaster has joined #lisp
jack_rabbit has joined #lisp
<elderK>
jackdaniel: Interesting. Alexandria defines if-let the way I did :O
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
cylb has joined #lisp
<elderK>
Ah, when-let* is more akin to the semantics you mentioned, although they do it via recursive expansion.
cylb has quit [Ping timeout: 245 seconds]
<no-defun-allowed>
fuzz testing worked, and there's a bug handling newlines or something
wusticality has joined #lisp
<no-defun-allowed>
nope it just hates utf8
<oni-on-ion>
#\xu0000027U8
<no-defun-allowed>
great! cl-base64 is broken! fuck yes, that's what i wanted to fix this afternoon!
<oni-on-ion>
^_^ empathised. dealing with similar atrocities
<oni-on-ion>
not alone my brother
<no-defun-allowed>
thanks
<no-defun-allowed>
^-^
ryan_vw has quit [Ping timeout: 244 seconds]
<no-defun-allowed>
s-base64 is a little more verbose and requires stream handling but it looks better overall
jochens has joined #lisp
arescorpio has quit [Quit: Leaving.]
jochens has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
yay, it works now.
<oni-on-ion>
hm hmmm can it base32 ?
<no-defun-allowed>
nope
<no-defun-allowed>
my guess is that cl-base64 just does (map 'string #'code-char output-vector) and that fails for multi-byte chars
<oni-on-ion>
hmm seems like it would be a big oversight
<no-defun-allowed>
that was odd though cause it worked when i typed in emojis and it handled those fine
elfmacs has joined #lisp
<White_Flame>
base64 doesn't encode characters, it encodes bytes. So you should convert to utf8 or something first
<no-defun-allowed>
s-base64 uses streams and byte vectors which i pass through FLEXI-STREAMS:OCTETS-TO-STRING and STRING-TO-OCTETS which handles utf-8
<no-defun-allowed>
exactly
<no-defun-allowed>
cl-base64 loses at converting multiple-byte chars to bytes and back though
<White_Flame>
I'm glad that "characters are not bytes!" is a real thing nowadays
Inline has quit [Quit: Leaving]
<no-defun-allowed>
i'm glad you have C-een that.
<no-defun-allowed>
:P
<White_Flame>
it was an issue even in the DOS days
<no-defun-allowed>
lol
<White_Flame>
(at least when I started to notice the problems)
<oni-on-ion>
i only remember extended char as wchar_t in hmmm win95 i think
<oni-on-ion>
before that all was 8byte =)
<oni-on-ion>
*8bit/1byte
<White_Flame>
yeah, 64-bit chars is a bit overboard ;)
<oni-on-ion>
but dos days i was a kid
<oni-on-ion>
not that i amn't anymores; but i think something like RLE could allow them optional. ie escape codes
<oni-on-ion>
ie. dont need whole 64bits for 'A' =)
<oni-on-ion>
UCS comes to mind but that might be a diffferent thing
<White_Flame>
UCS isn't a serialization form; it's just an abstract numbering of characters
<White_Flame>
UTF is the family of serialization forms
<oni-on-ion>
ah, wrong acronym i think
<oni-on-ion>
shift-jis, perhaps is closer example \
<White_Flame>
oh, nevermind, UCS-2 and UCS-4 are serializations
<oni-on-ion>
(i've seen both terms next to each other today while research, kinda dyslexic)
<no-defun-allowed>
and now apparently there's an error about an unbound variable that is nowhere in my code
heisig has joined #lisp
<oni-on-ion>
old code loaded? =p
<no-defun-allowed>
checked that, killed all the fasls and started a new SBCL incstance
<no-defun-allowed>
morning heisig
chens has joined #lisp
<oni-on-ion>
hum. *blames lisp-2*(
<oni-on-ion>
)
anewuser has joined #lisp
arescorpio has joined #lisp
orivej has quit [Ping timeout: 244 seconds]
arescorpio has quit [Remote host closed the connection]
slyrus1 has joined #lisp
<aeth>
oni-on-ion: ?
slyrus has quit [Ping timeout: 246 seconds]
slyrus1 is now known as slyrus
ryan_vw has joined #lisp
<fiddlerwoaroof>
pillton: yeah, the problem with those variables is that I only remember that I need them after I've tried to print a huge data structure
sauvin has joined #lisp
shrdlu68 has joined #lisp
<fiddlerwoaroof>
no-defun-allowed: that sound slike a macroexpansion problem
<fiddlerwoaroof>
Is there a macro that's missing a ,
<fiddlerwoaroof>
?
<fiddlerwoaroof>
I like the 4-byte encoding of unicode because it makes it easy to calculate the position of an arbitrary code-point.
<fiddlerwoaroof>
It would be even better if there was an encoding that normalized every grapheme into a fixed number of bytes
<fiddlerwoaroof>
(I believe Perl6 does this)
<fiddlerwoaroof>
Hmm, I guess that's impossible because you can combine diacritics, etc. arbitrarily
<ggole>
So the encoding changes every time Unicode updates?
rozenglass has quit [Remote host closed the connection]
<no-defun-allowed>
fiddlerwoaroof: i do not believe so, i have two auxiliary functions ENSURE-SYMBOL and ENSURE-STRING which handle strings and symbols in the macro body so i can write somewhat neater definitions for a macro
<no-defun-allowed>
eg when i write segments, ((foo key-value)) goes in, (("foo" :key-value)) comes out
<White_Flame>
you specifically lowercase? I woudl assume "FOO" would come out instead
<White_Flame>
at least with the default reader config
<no-defun-allowed>
i do specifically downcase.
nanoz has joined #lisp
<no-defun-allowed>
once i fix this strange test, i can talk more about it
cyraxjoe has quit [Ping timeout: 260 seconds]
cyraxjoe has joined #lisp
<no-defun-allowed>
ack, two errors now
razzy has quit [Ping timeout: 272 seconds]
nly has quit [Ping timeout: 264 seconds]
JohnMS_WORK has joined #lisp
<fiddlerwoaroof>
j
ryan_vw has quit [Ping timeout: 268 seconds]
<no-defun-allowed>
well, one test now, that's one less than before
dale has quit [Quit: dale]
razzy has joined #lisp
orivej has joined #lisp
robotoad has quit [Quit: robotoad]
<no-defun-allowed>
aeth: i don't like the "use debugger hooks to kill lisp" report method very much, do you?
<no-defun-allowed>
rather just let all the tests run to the end tbh
wusticality has quit [Ping timeout: 268 seconds]
Elephant454 has quit [Quit: ERC (IRC client for Emacs 26.1)]
jochens has quit [Remote host closed the connection]
_heisig has joined #lisp
jochens has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<elderK>
jackdaniel: makomo made a good point about if-let*. :)
frodef has joined #lisp
<elderK>
Is there a way I can set the default eval-when of a file, without having to wrap everything in the file in a giant eval-when form?
milanj has joined #lisp
okflo has joined #lisp
<frodef>
elderK: Wrap it (in some sense) around the form that loads that file into your system?
wusticality has joined #lisp
wanz has quit [Quit: wanz]
sunset_NOVA has joined #lisp
Guest24308 has joined #lisp
dtornabene has joined #lisp
wusticality has quit [Ping timeout: 252 seconds]
longshi has joined #lisp
<splittist>
elderK: if everything in the file is being treated in the same way, shouldn't you be thinking about file-level compilation and loading, rather than form-level?
<elderK>
I guess. I'm just trying to understand it all.
<elderK>
Like, I have a macro. And it makes use of a bunch of helper functions to do the expansion.
<elderK>
Now, from what I understand, the compiler will evaluate the macro - expand it - as it goes about its work.
<elderK>
It will compile the functions the macro relies on - but not be able to execute them - unless I have them in an eval-when :compile-toplevel, correcT?
<elderK>
AFAIK, :load-toplevel means "All this stuff will be evaluated when we load a FASL."
<elderK>
And :execute is just... I guess, when you load the source lisp file.
datajerk has quit [Read error: Connection reset by peer]
<elderK>
Thank you :) I've been reading CLHS and PCL on the issue.
<elderK>
I forgot about CLtL2 :)
frgo has quit [Ping timeout: 268 seconds]
cranes has quit [Ping timeout: 268 seconds]
snits has quit [Ping timeout: 268 seconds]
X-Scale has quit [Ping timeout: 268 seconds]
[X-Scale] is now known as X-Scale
snits has joined #lisp
thinkpad has quit [Ping timeout: 268 seconds]
cranes has joined #lisp
<splittist>
It is common to put macro definitions in a different file which is loaded (or compiled and loaded...) before the files which use them. But I guess you know that.
datajerk has joined #lisp
thinkpad has joined #lisp
<elderK>
splittist: Aye. I'm just... wondering about the functions that the macro uses to do its expansion.
<elderK>
Like, my macro doesn't do all the expansion itself - it calls out to a bunch of helpers.
<elderK>
:) Kind of excited today. So far, at least, I feel like I'm making some progress.
<elderK>
Hopefully by the end of the night, I'll have a hand-made way to do binary things :D
<elderK>
Structures and whatnot.
ogamita has joined #lisp
<elderK>
:D Then I can do some experimenting with ext2fs!
<elderK>
The CLtL2 explanation is much clearer than CLHS'
Guest24308 has quit [Ping timeout: 246 seconds]
ogamita has quit [Ping timeout: 260 seconds]
ogamita has joined #lisp
<ogamita>
Of course. CLHS is not a tutorial, it's a reference specifciation. To avoid ambiguity, they strove to avoid any redundancy. There's no order (you need to read it entirely several time, and basically to retain everything in mind).
<ogamita>
On the other hand, CLtL2 doesn't describe the ANSI CL standard, but some preliminary version. So some explanations don't apply. If you can sort it out, it can be interesting.
Guest24308 has joined #lisp
eschatologist has joined #lisp
eschatologist_ has quit [Ping timeout: 240 seconds]
beach has quit [Ping timeout: 252 seconds]
beach has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
wanz has joined #lisp
fikka has joined #lisp
chens has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
<dtornabene>
question: does anyone have a link to publicly searchable logs for this channel?
<elderK>
So, if I have some (defun ....), and I'm compiling, is that form simply "compiled' or is it made available to the compiler for use?
<elderK>
dtornabene: I'm interested in the same as the link in the title is dead.
<dtornabene>
scratch that I found one, sorry for the noice
<dtornabene>
just make sure to select the correct lisp room you're looking for, I missed that at first and searched clasp instead of lisp
<dtornabene>
ogamita: thanks
<ogamita>
elderK: the former.
JohnMS has joined #lisp
<ogamita>
elderK: this is why you need to wrap them in eval-when (:compile-toplevel) when you want ot use those functions in macros.
<elderK>
ogamita: Okay, so, if a macro makes use of helper functions, does that mean that it cannot be correctly expanded at compile-time, unless those helper functions are eval-when'd to be included in the compile-time environment?
<ogamita>
Well, eval-when is one way, when the functions are defined in the same file as the macro in the same file where the macro is used.
<ogamita>
But it is enough that the functions be present in the compilation environment whatever the mean; for example, you can put them in a separate file and load them in the environment before compiling the files using the macro.
<elderK>
From my understanding so far, specifying both :compile-toplevel and :load-toplevel, at the top-level, and in "NCT" mode, switches us into "CTTM." In that mode, things are processed (compiled?) but also evaluated (made available to the compile-time environment?)
<ogamita>
Also good to have them in the environment before compiling the macro to avoid undefined function warnings.
<ogamita>
Yes.
JohnMS_WORK has quit [Ping timeout: 244 seconds]
<ogamita>
Now, :compile-toplevel is when you call compile-file. :load-toplevel is when you call load on the fasl. :exectue is when you call load on the source.
<elderK>
I get the feeling this is going to be one of those things I'm going to have to quiz myself daily on for awhile :)
<ogamita>
So :load-toplevel and :execute are both when you load the file into the runtime.
<ogamita>
The no brainer is just to use (eval-when (:compile-toplevel :load-toplevel :execute) (defun foo (…) …)) (defmacro moo (…) (foo …))
<ogamita>
The thing is that if foo is not used at run-time, then you could skip :load-toplevel and :execute.
razzy has quit [Ping timeout: 272 seconds]
<elderK>
Things get more complicated though when we're nesting, though, right? Like, If we have a top-level eval-when with (:compile-toplevel :load-toplevel), that switches us into CTTM and processes its body. If that body has as an eval-when of :load-top-level and :execute, it'll be processed / evaluated in the CTTM?
fikka has joined #lisp
<ogamita>
For example, you could have a very big translator from some language to lisp, load it in the compilation environment and use it thru a macro to translate the source, but you wouldn't need it at run-time.
<elderK>
Okay, that makes sense. I was wondering if I'd need the full (:compile-toplevel :load-toplevel :execute) or not.
hajovonta has joined #lisp
<ogamita>
elderK: yes. The only case normal human brains can understand, is when eval-when is toplevel. Embedded and not-toplevel needs mutant brain powers.
<hajovonta>
hi
<elderK>
The idea is, the macro will be made available for people to use at the REPL or normally.
<ogamita>
you could call the repl at compilation-time, at macro-expansion-time or at read-time too;
<hajovonta>
didn't know there is such a thing as REPL time
<elderK>
Since his helper functions are not present in the compile-time environment.
<elderK>
ogamita: Right, and if you called hte REPL at compile time, you'd be in the CT environment, right?
<elderK>
Macro-expansion could happen at compile-time, or at "normal REPL time", which I consider the same as read time?
<hajovonta>
macroexpansion time is distinct from runtime and from compile time I guess
<elderK>
Thank you for helping me, btw. I imagine this is very obvious for anyone with experience :)
<hajovonta>
and you can compile functions at runtime.
<ogamita>
No, don't confuse times. The REPL = READ EVAL PRINT LOOP, so there's a read time in the repl. Then there's EVAL. EVAL can be implemented as (funcall (compile nil `(lambda () ,expr))) so there's a compilation-time and a run-time. The compilation time must at minmium, expand the macros. So there's a macroexpansion time embedded there.
<elderK>
:P Moment, you're overloading my brain. So, if you call compile whatever, the environment you're in at the tmie that call is made, is hte "compiletime environment"?
<ogamita>
The compilation environment is forked (or the same) from the startup environment which is the runtime environment for the REPL.
<hajovonta>
I think these "times" make more sense when you think of the life cycle of a compiled functions
<hajovonta>
you compile them, and then when they are compiled, you run them
<ogamita>
elderK: good question. I have a doubt about COMPILE. It would definitely be ac ompilation environment for COMPILE-FILE. We'd have to check for COMPILE.
<elderK>
ogamita: So, if I start the REPL and do a bunch of stuff in that REPL, then use compile, the compile-time environment will be the same as the REPL at the start, ignoring all the stuff I've done in the REPL since?
<elderK>
As for the file I linked, I also find it weird that the macro is defined before its helpers.
<ogamita>
no, "startup environment" refers to the environment where the compilation starts. Not the initial environment.
<hajovonta>
yes, that's what I'm trying to say, too
<elderK>
Okay, so it'd be a copy of our REPL environment.
<elderK>
?
<hajovonta>
no
<hajovonta>
you don't travel back in time when you compile something
hajovonta has quit [Read error: Connection reset by peer]
<elderK>
What I'm trying to say, is that we start the REPL. We do a bunch of stuff, then say "compile". The compiler will use the current environment as the compile-time environment. I.e. It will be aware of all the stuff we've done.
<ogamita>
elderK: it can be a copy of the REPL environment, or it can be the REPL environment.
<elderK>
Okay, cool. That's what I was expecting.
hajovonta has joined #lisp
<ogamita>
It could also be not the REPL environment, eg. if you invoke compile-file in a batch command.
<elderK>
wb hajovonta
jkordani has quit [Read error: Connection reset by peer]
<elderK>
ogamita: Well, yup. That makes sense. If it were a batch command, it'd use the "Default" environment, right?
<elderK>
Whatever that default is.
jkordani has joined #lisp
<elderK>
I imagine you could for instance, say "I want you to compile these files, batch style, using this image."
<aeth>
no-defun-allowed: I've actually never had tests fail remotely because I always restart SLIME (to avoid stale image state, e.g. calling a function that has been renamed) and then run tests before pushing. I guess it would be possible if the remote tester runs several implementations.
<elderK>
Or something like that?
<elderK>
In which case it would use that image's environment as the compilation environment?
<ogamita>
The problem is that COMPILE only compiles lambda expressions, not toplevel forms. Only COMPILE-FILE knows how to compile toplevel forms. So when you use COMPILE, you cannot have toplevel eval-when forms…
fikka has quit [Ping timeout: 240 seconds]
<hajovonta>
ogamita: functions are just named lambdas
<ogamita>
so (compile nil '(lambda () (eval-when (:compile-toplevel) (print :compile-toplevel)) (eval-when (:load-toplevel) (print :load-toplevel)) (eval-when (:execute) (print :execute)) 42)) doesn't print anything, and (funcall *) prints :execute.
<elderK>
Right, compile-toplevel and load-toplevel don't trigger because it's not toplevel, right?
<ogamita>
so I think that COMPILE works in the current environment, whatever it is.
<elderK>
I'm surprised :execute isn't printed.
<ogamita>
elderK: it's printed when you call the function.
<no-defun-allowed>
That's fair, aeth. However it appears that without disabling the debugger, fiveam quits and the results aren't entirely printed.
<elderK>
Ah, that makes sense.
<ogamita>
non-toplevel (eval-when (:execute) …) is equivalent to (progn …).
<no-defun-allowed>
On my machine doing sbcl --load tests.lisp it just cuts out, but on CI it runs the whole way through.
<aeth>
weird
<elderK>
ogamita: So, if my macro is attaching a bunch of methods to some generics, does that mean the defgenerics themselves need to be compile-toplevel / load-toplevel?
<no-defun-allowed>
That kind of behaviour annoyed me, so I just check the return value of fiveam:run! and use an appropriate error code if the value is NIL.
<ogamita>
elderK: for this kind of question, you have to look up whether the defining operator has compilation-time or run-time effects.
<ogamita>
for example, defun doesn't define the function in the compilation environment, it only takes note that the symbol names a function.
<aeth>
no-defun-allowed: So you have to manually return the error code to get the CI to report the correct result? Not surprised, but never encountered it either way yet afaik.
<ogamita>
"defgeneric is not required to perform any compile-time side effects. In particular, the methods are not installed for invocation duringcompilation. "
<ogamita>
So if you want to add methods at compilation time from your macro, you need an eval-when.
<ogamita>
But if your macro _expands_ to the adding of methods, this will occur at run-time, so no eval-when is needed.
<elderK>
Ah, okay.
<elderK>
So, out of curiosity, if toplevel stuff only really pays attention to :compile-toplevel and :load-toplevel, why do I need to specify all three situations?
<ogamita>
(defmacro m () (at-compilation-time) `(at-run-time #.(at-read-time)))
<elderK>
Is that for the case when we're in an interpreter or something?
<ogamita>
the :execute is for when you load the source. In that case, in general you want the same as (or :compile-toplevel :load-toplevel).
<elderK>
ogamita: In that example, does the #. happen at the time hte macro is read, or at the time it's expansion is?
<no-defun-allowed>
aeth: Yes, my current script replaces the debugger hook with a call like (UIOP:QUIT -1) and GitLab picks up on it.
<elderK>
I thought :load-toplevel was for when we loaded the source?
<no-defun-allowed>
The shiny new one on my desktop quits after all the tests are run and doesn't rebind any debugger stuff.
<ogamita>
If your source is not designed to be used at the REPL, but eg. to save an executable image, then you could skip the :load-toplevel :execute situations if your functions are only used to compile it.
<no-defun-allowed>
(0=tests passed, anything nonzero is Bad)
<ogamita>
elderK: at the time the macro is read.
<elderK>
Thank you ogamita.
<ogamita>
elderK: which is either load (:execute) time, or compile-file (:compile-toplevel) time.
<ogamita>
times are embedded.
<elderK>
So, what exactly is :load-toplevel for? If :compile-toplevel is compile-file time, and :executive is "load the source" time.
<no-defun-allowed>
The shiny new one also comes with a fairly straightforward fuzz tester, which I used to find that cl-base64 bug.
<ogamita>
elderK: for example you can compile on one machine, load the fasl on another, save an executable image, and run the program on a third machine.
<ogamita>
elderK: this has implications for example on pathnames.
<ogamita>
#P"…" builds the pathname at read-time. (pathname "…") builds it at run-time (when evaluated). Some paths are known at compilation-time, some when you "link", when you load the fast to save the image, and some other paths are only known at run-time, when the user launches the program.
<elderK>
:) I think I'm going to try and do some experimenting.
<ogamita>
So you must be careful with when the paths are used. Developers often coalesce all these situations, so there's often some confusion here.
<ogamita>
bbl
<elderK>
Make a few files, have eval-whens, load the source, compilet he source, etc. See if I can learn.
<elderK>
Thank you so much for your help :)
hiroaki has quit [Ping timeout: 240 seconds]
djh has joined #lisp
Bike has joined #lisp
wanz has quit [Quit: wanz]
<elderK>
Is it idiomatic to define multiple packages in a single packages.lisp?
<elderK>
Say, I'm separating things into their own packages, for namespacing reasons. But then, I have a "unification" package, which brings in and exports just the stuff I want people to use?
milanj has quit [Quit: This computer has gone to sleep]
<shka_>
elderK: it is not wrong to do so
<beach>
elderK: It is much more idiomatic to do it the other way around. Let me explain...
<beach>
elderK: You have one package that contains symbols that you want to be visible by client code. It contains only those symbols. No code is written with an IN-PACKAGE of that package.
Guest24308 has quit [Ping timeout: 252 seconds]
<beach>
elderK: Then you have several "implementation packages". You may have one or more files that start with (IN-PACKAGE ...) of one of those implementation packages.
<beach>
In such a file, you do (defun main-package:function1 ...) (defclass main-package:class1 ..) etc.
<beach>
elderK: the COMMON-LISP package itself works like this. So does the CLIM package.
<beach>
elderK: It works, because packages contain only symbols. They are not modules so they don't contain code or definitions.
longshi has quit [Ping timeout: 260 seconds]
<elderK>
beach: I see. So, I have one "proper package", and a bunch of internal packages. Those internal packages do not need to have a defpackage form?
<beach>
They do.
<beach>
But you don't need to document those.
<elderK>
I'm not sure how to organize this. Does this mean I'd have several "package.lisp"s?
<beach>
And you can have as many as you like. Client code will only see symbols in the main package.
wanz has joined #lisp
<beach>
One is fine if that's what you want.
<beach>
I often put each "implementation module" in its own directory. Then I have a separate package.lisp file for each such module, in its directory.
<beach>
One of my "modules" typical consists of a directory, a package.lisp file, and an ASDF system definition.
<elderK>
Okay, so, I have my various packages. I have one "main" package which is to be used by people. All my internal stuff is in the internal packages, and for the things in those "internal" packages, where they define something that is meant to be in the public interface, they just define it straight into that pacage?
<beach>
That way, I can have alternative implementation for the same functionality if that's what I want.
<elderK>
This might be overkill for what I'm doing. I just want to make sure the names I've used for helpers, for one set of macros, doesn't conflict with the helpers for another macro.
<elderK>
I doubt they will but I'm curiou as to how to approach this all the same :)
<beach>
More precisely, code in one of the implementation modules uses the main package as a package prefix directly for defining functionality that is to be seen by client code.
<beach>
Fine.
<elderK>
So, why is this method preferred over the one where you import and rexport from the internal packags?
<beach>
For one thing, the home package of all client-visible symbols is the main package.
<beach>
The structure is also simpler than if you have to import and re-export every symbol explicitly.
<beach>
And client code can be sure that the main package contains only visible symbols, in case it wants to iterate over all symbols avaliable to it.
<elderK>
So, what if one of my implementation packages wants to add some new symbols to the main package, but also use some symbols from the main package?
<beach>
Implementation packages will never want to add new symbols to the main package.
<beach>
That's contrary to the very idea.
<beach>
And I just explained how implementation modules use the symbols from the main package, namely by using a package prefix.
<beach>
That way, it is much more obvious to someone reading the code for the implementation module what symbols come from the main package.
<ogamita>
You would just edit the main package definition to add the symbol.
<beach>
Plus, you can use symbols with the same name in the implementation package as the corresponding symbol in the main package without any clashes.
<ogamita>
The current style of development, where the code is stored in files that are loaded and compiled separately by a system definition system (asdf), asks for a more static declaration of some elements such as the packages.
<ogamita>
Note that this prevents circular dependencies between packages (this is good software engineering practice!). But lisp allows circular dependencies between packages, established at run-time. You can find them in legacy code, but don't do it yourself.
<beach>
elderK: I am about to take a break. I think you have food for thought.
<elderK>
I do indeed. Thank you
ogamita has quit [Ping timeout: 276 seconds]
Guest24308 has joined #lisp
ogamita has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
Guest24308 has quit [Ping timeout: 240 seconds]
jmercouris has joined #lisp
<jmercouris>
what's the naming convention for functions that return functions?
<jmercouris>
so for I have been writing (defun xyz-generator () ...)
<elderK>
What kind of functions are you generating, jmercouris?
<elderK>
make-bla-predicate?
<elderK>
make-bla-expander?
<jmercouris>
elderK: well, in this case it is a function that given a string, and a list of strings, will return a list of strings that fuzzily match
<jdz>
make-fuzzy-matcher?
<jmercouris>
so what you are saying is that the convention you use is "make-xyz"?
<jmercouris>
and then the last part is a verb since it is a function
<jmercouris>
right?
<ggole>
I don't think a convention is necessary, just a good name
<jmercouris>
in other words, there is not a strict convention as there is with something like predicates
<ggole>
eg, complement or compose
<jdz>
Not sure it's a "convention", it just makes sense.
<jmercouris>
I was just checking in case there was
<ggole>
partially-apply
<ggole>
etc
<jmercouris>
right. thanks everyone for clarifying
<jdz>
It could as well be "fuzzy-match-fn".
<jmercouris>
it could be anything of course
<jmercouris>
I was just wondering what people do in general
<jmercouris>
I think I might do something like that though, with -fn at the end suffixed, I like it
<jdz>
Right, it's a good idea to ask around.
<jdz>
There are programmers who do not give a damn about established conventions.
<jmercouris>
Those are the kinds of programmers whose source code I do not enjoy reading :D
<jmercouris>
sometimes they are brilliant, and it is worth it, but usually not
<ogamita>
I would use fuzzy-matcher or just fuzzy-match. I'd decide on the name depending on usage. (funcall (fuzzy-match foo) bar)
<elderK>
Speaking of convention, is there a convention for package nicknames?
<splittist>
Not sure I like "fn". That way lies "lst" and other Lisp-1-isms.
<elderK>
I'm trying to apply what beach explained earlier. But now, because of specifying the package name, lines are way longer.
<ogamita>
There's not a lot of convention in lisp anyways.
<ogamita>
elderK: you may choose to :use your packages.
<elderK>
What happens if a package A says it exports symbols S1, S2. And package B uses package A, and contains a definition for those S1, S2. Do those definitions wind up being the definitions for A's S1, S2?
<elderK>
Or do those definitions for S1, S2 in B shadow those from A? (Those symbols have no definition in A, though.)
<elderK>
(Only mention that they exist)
<jdz>
splittist: guilty as charged! I retract that suggesstion.
<Bike>
packages don't contain definitions
<Bike>
if you have like, a:s1, and *package* is B, and B uses A, and you read "s1" by itself, that will be a:s1
<elderK>
:( Sorry, I'm using bad terminology. The packages contain the symbols, right? That's all. But somehow, you associate a binding for that symbol, no?
<Bike>
yes, but packages don't know anything about bindings.
ogamita has quit [Ping timeout: 245 seconds]
<elderK>
Okay, so if I have a package B that uses package A, which contains the symbol S1, and I (defun S1 ...) in package B, is that function bound to the symbol S1. So, if someone later uses Package A, and calls S1, it uses the function that was defined with that name from B?
<ogamita>
elderK: otherwise, the trick is to read the operators. defpackage defpackage in-package defun defun defpackage in-package.
<elderK>
:) Roger that
runejuhl has quit [Ping timeout: 245 seconds]
Guest24308 has joined #lisp
fikka has joined #lisp
<elderK>
Out of curiosity, are asserts always present? Or are they optimized out?
<p_l>
elderK: depends on how exactly they are coded and implementation
<p_l>
I think stuff that has literal CL:ASSERT isn't compiled out, but implicit asserts (like type declarations) can be optimized out
sunset_NOVA has quit [Quit: leaving]
dddddd has quit [Remote host closed the connection]
<jcowan>
elderK: It could all be much worse: you could be trying to wrap your head around the R6RS notion of explicit phasing, with its doubly infinite tower of (in effect) eval-when situations: normal code, macros, functions used by macros, macros in the last, functions used by the last, and so on forever. Then there are negative phases, which I can only understand for brief periods before forgetting again
<jcowan>
fortunately, only one Scheme is left standing that implements this, and it will be phased out before 1.0
<jcowan>
(well, there is Racket, but that's different and consistent)
<ogamita>
elderK: you could use a feature: #-with-heavy-assert (assert (2-hours-compute-predicate-p foo))
<ogamita>
s/with/without/
<ogamita>
elderK: so you cah (push :without-heavy-assert *features*) and reread/recompile to remove the assert.
Guest24308 has quit [Ping timeout: 252 seconds]
jmercouris has quit [Ping timeout: 272 seconds]
m00natic has joined #lisp
<jdz>
No need for reader conditional, can be done with conditional shadowing of CL:ASSERT.
igemnace has quit [Quit: WeeChat 2.3]
<jcowan>
From the Vax Lisp (it's a CL) manual: "You can recover an input expression or an output value by using the following 10 unique variables: / // /// * ** *** + ++ +++". Something a bit wrong here?
quipa has joined #lisp
<splittist>
Is it written in base 9 as a compromise between base 8 and base 10 lisps?
d4ryus has quit [Quit: WeeChat 2.3]
<jcowan>
Nope
<jcowan>
I don't think base 8 made it off the PDP-10 except in the rudimentary form of *input-base*.
random-nick has joined #lisp
ogamita has quit [Read error: No route to host]
<jcowan>
I suspect a typesetting error somehow, maybe '-' was magic to the runoff program
<jcowan>
I have seen many man pages in which \ isn't in the output where it obvs should be
d4ryus has joined #lisp
runejuhl has joined #lisp
ogamita has joined #lisp
ogamita has quit [Remote host closed the connection]
cage_ has joined #lisp
Essadon has joined #lisp
v0|d has quit [Remote host closed the connection]
ggole has quit [Ping timeout: 250 seconds]
ggole has joined #lisp
<hajovonta>
re
frgo_ has quit [Remote host closed the connection]
cylb has joined #lisp
rozenglass has joined #lisp
<elderK>
Guys, is there a nice way to "discard" non-primary values returned by a function?
frgo has joined #lisp
<elderK>
I've been multiple-value-binding and returning just the one thing
frgo has quit [Read error: Connection reset by peer]
<elderK>
But that feels kind of nasty.
<Xach>
elderK: you can use nth-value
frgo has joined #lisp
<jackdaniel>
just call it like (values (form-returning-multiple-values))
frgo has quit [Remote host closed the connection]
<jackdaniel>
or nth-value, even better
<Xach>
or values, if it's the first thing
<elderK>
Ah, thank you :)
<jackdaniel>
heh
frgo has joined #lisp
<Xach>
another option is not to care
<Xach>
that is not always an option
ogamita has joined #lisp
<Xach>
sometimes i have a function that is really just a thin wrapper over gethash, for example, but i'd like to hide the extra return value
<Xach>
nobody need know it's gethashy!
<elderK>
Well, if my function is meant to return a single value, well. I'd like that to be the case :)
<ogamita>
(defun foo () (values (expression)))
igemnace has joined #lisp
LiamH has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
Inline has joined #lisp
sunshavi has quit [Ping timeout: 250 seconds]
sunshavi has joined #lisp
ggole has quit [Ping timeout: 264 seconds]
ggole has joined #lisp
cylb has quit [Ping timeout: 244 seconds]
figurelisp has joined #lisp
<elderK>
:) TIme for bed.
<elderK>
Goodnight all.
<elderK>
:) Thank you for the help.
<dim>
The standard has it that “values is the standard idiom for indicating that only one value is to be returned”
<Inline>
yeh
wanz has quit [Quit: wanz]
<Inline>
(values (+ 1 2) (* 3 4))
<Inline>
1) => 3 2) => 12
<Inline>
you get one value returned for each form ?
<Inline>
so you get multiple returns actually
<Inline>
but one value for each return
<Inline>
heh
<Xach>
Inline: the idiom is (values <form that returns multiple values>)
<Inline>
err yah
<Inline>
1 form upto n-forms
<Xach>
In this context it is only one form.
<Inline>
or one form providing all the forms
<Inline>
yes
<Xach>
e.g. (values (gethash key table))
<Inline>
ok
<ggole>
(values (values 1 2)) is an interesting snippet - the same operator doing quite different jobs
<Inline>
so (values 1-form 2-form....) or (values (form-which-expands into multiple forms))
<Xach>
it's a question of values
<Xach>
Inline: i'm not sure what the second case might be. what expands into multiple forms?
<Xach>
ah, i think i get it, though that phrasing is somewhat misleading
<Inline>
if you can please do so, i'm tired anyway.... so a little dyslexic
<Xach>
Inline: forms don't expand into multiple forms, but they may evaluate to multiple values.
<Inline>
heh :)
Bike has joined #lisp
JohnMS has quit [Read error: Connection reset by peer]
Xach has quit [Quit: leaving]
Xach has joined #lisp
rippa has joined #lisp
dtornabene has quit [Read error: Connection reset by peer]
quazimodo has quit [Ping timeout: 244 seconds]
quazimodo has joined #lisp
wanz has joined #lisp
fortitude has joined #lisp
<jackdaniel>
this is fun to read: https://bugs.launchpad.net/calibre/+bug/1714107 (some folks trying to convince calibre maintainers to migrate from python2 to python3, because the former is "retiring") [sorry for the offtopic, otoh it proves, that having standard is a nice quality]
scymtym has quit [Ping timeout: 252 seconds]
<beach>
Oh, wow.
<Bike>
"I am perfectly capable of maintaining python 2 myself." oh no
anamorphic has joined #lisp
solyd has joined #lisp
<Xach>
I think there's sometimes a simplistic view of what motivates other people to change their code for you
<beach>
This is precisely what I am talking about when I give talks to industry, urging them to use standardized languages.
<Xach>
"change this to make it conform to the standard" does not always motivate someone to make a change.
anamorphic has quit [Client Quit]
<Xach>
common lisp adherence to standards (in a thorough way) has not always been very good, and it saw a surge of improvement over the last 10 or so years
hajovonta has quit []
<beach>
That's great then!
anamorphic has joined #lisp
<Xach>
but if you rely on something standard, but your platform does not implement the standard, you cannot always rely on "change to fit the standard" to save you, without other agreements
ringer1 has quit [Ping timeout: 240 seconds]
<fade>
the incompatibility between python 2 -> 3 was what lead me to finally use CL in anger.
<fade>
"If it's going to be a different language anyway, I may as well use one that is both fast and stable."
<fade>
problem solved.
<Inline>
lol
<beach>
How long has Python 3 been around?
<fade>
Dec 3, 2008
<beach>
Wow, that long.
<ogamita>
popularity leads to legacy, legacy leads to bit rot, bit rod leads to the dark side.
<fade>
the 2 -> 3 migration has been the biggest fuckup in a language ecosystem since I've been watching such things, a period dating back to the mid 1980's.
<pfdietz>
(identity <form>) also discards all but the first value of <form>
<fade>
I've often thought that it should result in a lot of new developers for lisp, but I haven't run into too many.
<beach>
fade: Strong psychological forces are involved.
Roy_Fokker has joined #lisp
fade is now known as Fade
<Fade>
that is probably true, but I don't exactly understand them.
nixfreak has joined #lisp
<sjl_>
Porting a large Python 2 codebase to Python 3 would be painful, but much less effort than learning CL and porting it to CL. That's one possible reason.
<pfdietz>
Xach: widespread non-compliance with the standard motivated me 15 years ago or so to write ansi-tests.
xkapastel has joined #lisp
<nixfreak>
hello how can I get started to created a "HOT" folder , meaning certain files get copied to a file and a script gets executed to push those files somewhere else
<Fade>
sjl -- that's true, but once you've loaded lisp into your head, you've solved all of the problems associated with the python ecosystem permanently, if only locally.
<beach>
nixfreak: Wrong channel?
<nixfreak>
?? isn't this a lisp channel ?
<nixfreak>
you can't do that with lisp ?
<Fade>
it is, but that was not a recognizable lisp question. :)
<beach>
nixfreak: What Fade said.
<sjl_>
Fade: sure, but the first part of that (learning Lisp) is non-trivial, and the urge to "Fix the problem and move on with my life instead of learning new tools" is often strong.
<Fade>
lisp can open and append files, and with the right extension, open a socket and move data through it.
<Fade>
so your question is basic. you should look at Practical Common Lisp.
frgo has quit [Remote host closed the connection]
<nixfreak>
ok
<jackdaniel>
minion: tell nixfreak about pcl
<minion>
nixfreak: look at pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<Fade>
sjl_ : the tension between yakshaving and avoiding greenspun can be quite strong.
<fortitude>
has anybody used cffi-grovel:process-grovel-file in a while? seems to be an issue with its use of uiop:ensure-pathname, but the last relevant change was from 2015
<fortitude>
can't imagine it's been broken that long
<sjl_>
I mean, I agree with you -- Python 3 and Clojure 1.3 were a big influence on me choosing a stable language like CL. But I can understand the decision to suffer through an update rather than go through a full rewrite.
fikka has quit [Ping timeout: 268 seconds]
<Xach>
pfdietz: i hope you will finish it soon and we can achieve perfection!
<pfdietz>
I *did* discover a symbol I had neglected. So imperfect.
<shka_>
User-defined symbols are restricted to three letters or digits
<shka_>
FUN!
<shka_>
xD
quipa has quit [Remote host closed the connection]
<shka_>
Every Lisp object is a two-word cell, representing either a symbol, number, or cons.
<shka_>
copec: actually, LISP 1.0 had way more stuff in it :P
scymtym has joined #lisp
<beach>
That reminds me of a student I had in the past who wrote is C code with single letter variables only. When I asked him why, he said so that the program would execute faster.
<copec>
ahaha
<shka_>
well, ųlisp does not look all that interesting or fun for me
<shka_>
but you can check LISP 1.0 for the historic perspective
<shka_>
it is milestone of computer history
<sjl_>
uLisp is fun if you do Arduino-based stuff. I've used it for a couple things. I even hacked in floating point support, and the author eventually merged it into the main repo.
<shka_>
tremendously innovative language during its time
<sjl_>
and the three-letter symbol restriction is gone now
<shka_>
then, i would say that updating main page could be a good idea! :-)
<copec>
I have a smartos box doing all the things, and I actually just want to do rpc with them
<sjl_>
What main page?
<sjl_>
The homepage says > platforms with more than 2 Kbytes of RAM arbitrary user-defined symbol names are supported.
<anamorphic>
copec: cool - like RPC from micro controllers to your smartos box?
<shka_>
those information are outdated as it seems
<copec>
I want the actual control to be in a zone on the smartos box with the devices just acting as control bridges
<sjl_>
It literally says the restriction was removed *in the same sentence*.
<shka_>
... you are right
<shka_>
silly me
didi has joined #lisp
<copec>
anamorphic although I suppose they would send actions from 'control panels' as well
<didi>
I can't get over the fact FORMAT doesn't have a directive to print conses. It bothers me when I want to print alists.
<copec>
although, having my kids directly program some micro controller projects with this ulisp would be fun
<Bike>
what do you mean?
<Bike>
i mean ~a and ~s and such print conses
<sjl_>
I'm guessing printing (:foo . NIL) instead of (:foo)
<didi>
Bike: I want to print them as I can print lists.
ggole has quit [Ping timeout: 264 seconds]
<sjl_>
(for alists)
<Bike>
didi: do you mean that you want to be able to iterate over them?
<didi>
Bike: Yes yes.
<Bike>
right, i see
<Bike>
i guess you could map the alist to have actual lists beforehand, or use ~//, but it's not quite as smooth
* didi
nods
<anamorphic>
copec: I used mqt for rpc previously with esp8266s. I would like to try it again with ulisp
<copec>
I want to try that too
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
orivej has quit [Ping timeout: 272 seconds]
<didi>
A FORMAT directive for hash-tables would be nice too, but that I can live without.
<didi>
But alists... man, so close to a list.
<copec>
beach you should target your lispos similar to OSv http://osv.io/
<copec>
initially
ggole has joined #lisp
<beach>
copec: You mean so that it can be run remotely?
<copec>
Tie into the developers building cloud applications
<beach>
I see.
<beach>
I would have to give that some thought.
<beach>
Also, not sure I would know how to do it.
v0|d has joined #lisp
<copec>
The 'protocol for updating using semantics that follow from CL would suite it wonderfully, I think.
<copec>
Just thinking out loud after reading your papers.
<beach>
I see, yes.
fikka has quit [Ping timeout: 264 seconds]
ryan_vw has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<copec>
That thought just came to me thinking about these micro controller system images being all lisp, something something nasa doing incremental upgrades through space via lisp, and how cloud app deployment is going towards orchestration (config management) states to deploy applications
dvdmuckle has quit [Quit: Bouncer Surgery]
<copec>
Think of the C development cycle ++
<copec>
heh
robotoad has quit [Remote host closed the connection]
robotoad has joined #lisp
dvdmuckle has joined #lisp
rozenglass has quit [Remote host closed the connection]
dale_ has joined #lisp
dale_ is now known as dale
anamorphic has quit [Quit: anamorphic]
_heisig has quit [Quit: Leaving]
resttime has quit [Quit: Leaving]
v0|d has quit [Remote host closed the connection]
wkelly has joined #lisp
ryan_vw has joined #lisp
fikka has joined #lisp
m00natic has quit [Remote host closed the connection]
makomo has quit [Ping timeout: 246 seconds]
jmercouris has joined #lisp
cylb has joined #lisp
v0|d has joined #lisp
<oni-on-ion>
copec: makes me think a bit of erlang, and some of prolog
makomo has joined #lisp
<copec>
yeah, all the cool ideas that float around for which are occasionally precipitated
<oni-on-ion>
remote deploy and transparent distribution etc
<oni-on-ion>
hot code loads~
orivej has joined #lisp
nly has quit [Ping timeout: 272 seconds]
ryan_vw has quit [Ping timeout: 260 seconds]
nly has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
v0|d has quit [Remote host closed the connection]
cylb has quit [Remote host closed the connection]
cylb has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
Acanor has joined #lisp
<Acanor>
Is there a way to use reader macros in repl?
<Bike>
sure, just write them
<Bike>
(a b c) uses the ( reader macro
sauvin has quit [Remote host closed the connection]
frodef has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
<jcowan>
If you hack on the system readtable, the effect is immediate in the REPL.
random-nick has joined #lisp
<oni-on-ion>
would like to note, if continuing on this path, check out named-readtables
<oni-on-ion>
(why arent readtables part of package/namespace idk)
<makomo>
good evening
terpri has joined #lisp
<oni-on-ion>
hi sir
cage_ has quit [Quit: Leaving]
wanz has quit [Quit: wanz]
hugh_marera has joined #lisp
Acanor has quit [Ping timeout: 256 seconds]
charh has quit [Ping timeout: 268 seconds]
Mr-Potter has joined #lisp
orivej has quit [Ping timeout: 244 seconds]
vlatkoB has quit [Remote host closed the connection]
ggole has quit [Quit: ggole]
jinkies has joined #lisp
razzy has joined #lisp
mejja has joined #lisp
angavrilov has quit [Remote host closed the connection]
v0|d has joined #lisp
jmercouris has quit [Remote host closed the connection]
Kevslinger has joined #lisp
shka_ has quit [Ping timeout: 276 seconds]
<dim>
is there a guide to port CL software to ABCL? I mean the JVM comes with many libs that you can reuse without having to load CL equivalents I'm sure (jdbc for db drivers, zip, http, s3 maybe, usocket needs a replacement, json?, uuid?, base64?)
kajo has joined #lisp
jmercouris has joined #lisp
milanj has joined #lisp
longshi has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
cylb has quit [Remote host closed the connection]
cylb has joined #lisp
longshi has quit [Ping timeout: 252 seconds]
<jackdaniel>
I think that the proper way to tackle that would be defining a protocol (so the package and exported interfaces are defined) and to provide implementation for that
<jackdaniel>
example: uffi had a specification (which had implementation called uffi), and later cffi-uffi-compat iimplemented the same protocol and ecl ffi did the same
<jackdaniel>
so they are a drop-in replacements (you may use cffi-uffi-compat instead of original uffi)
<jackdaniel>
answering the original question: I'm not aware of such guide
<jackdaniel>
(nb: ecl doesn't export symbols from the "uffi" package)
dddddd has quit [Ping timeout: 264 seconds]
<dim>
in the case of PostgreSQL/MySQL/SQLite/MSSQL/Oracle/DB2 and other database protocols, CL typically has a separate specialized driver each time where the Java world uses JDBC, often with quality drivers that you'd want to benefit from when you're on the JVM anyway
<dim>
in the case of pgloader, that's a good chunk of the work anyway
<dim>
so even though I like your idea of protocols and their various implementations, well... it's not clear how much that'd be necessary for me here
dddddd has joined #lisp
<dim>
anyway, movie time, I realise I'm tired and “read-only” anyway
varjag has joined #lisp
nixfreak has quit [Ping timeout: 240 seconds]
slyrus has quit [Ping timeout: 245 seconds]
slyrus has joined #lisp
dddddd has quit [Remote host closed the connection]
dddddd has joined #lisp
okflo has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
Jesin has quit [Quit: Leaving]
jinkies has quit [Ping timeout: 264 seconds]
dddddd has joined #lisp
arbv has quit [Ping timeout: 264 seconds]
siefca has joined #lisp
<siefca>
Ehlo
<fe[nl]ix>
250 fenlix Hello siefca
LiamH has quit [Quit: Leaving.]
jack_rabbit has joined #lisp
hugh_marera has quit [Quit: hugh_marera]
sjl_ has quit [Ping timeout: 260 seconds]
pjb has joined #lisp
<v0|d>
fe[nl]ix: 550 This message was classified as SPAM.