<phoe>
pfdietz35: offtopic question, what happened to the previous 34 pfdietzes?
<_death>
just (setf *pfdietz-counter* 0)
``Erik_ is now known as ``Erik
lucasb has quit [Quit: Connection closed for inactivity]
<pjb>
It may be more complex than that. I'd (reset-pfdietz-counter).
ManyQuestionsPer has joined #lisp
<ManyQuestionsPer>
Hi all, I am new to lisp and slime, and I am trying to do something that I thought would be simple to do but does not seem to work
<ManyQuestionsPer>
I have set a breakpoint (break) inside a function, and when I call a top-level function that calls my target function with the break, the SLDB frame correctly pops uphowever, when I go back to the repl, I am unable to evaluate expressions within my target functionI would have thought that would work easily out of the box with Emacs, SBCL and
<ManyQuestionsPer>
slimeIs there a way of doing this?
<Bike>
if you hit 'e' in sldb, you should be albe to evaluate things in a particular frame
<ManyQuestionsPer>
Woohooo! Thanks. Muchas Gracias. That worked!
sugarwren has quit [Remote host closed the connection]
<pfdietz35>
That number Is because I'm logged into freenode from a different machine under the name pfdietz. It tacks on a random two digit value to make another name.
<gendl>
if I then evaluate (try1) at the repl, it gives me an *sldb ... *
<gendl>
How should I proceed in order to evaluate a and b as bound by my let form?
Fare has joined #lisp
jackdaniel2 has joined #lisp
<gendl>
hitting 'e' next to 0: (break) or 1: (try1) gives me an `Eval in frame (<package>)> ' prompt in minibuffer - but typing a or b at that prompt results in `Attempt to take the value of unbound variable `a'. '
jackdaniel2 has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
<gendl>
yes, i prepended a or b with the package that `try1' is defined in
<phoe>
gendl: try evaling it in the (break) frame maybe
<Xach>
In SBCL, the locals are not available unless you compile with high debug. I do that with C-u C-c C-c.
<phoe>
the (try1) frame might be toplevel of try1 and that is where the local variables are not present
<phoe>
or maybe I get it all wrong, hm
Frobozz has quit [Quit: quit]
<gendl>
Xach: Ha, yep that works in SBCL after compiling with C-u C-c C-c
<gendl>
Was in Allegro previously, was not working there..
<gendl>
SBCL also gives a slightly different backtrace:
<gendl>
the actual call to (break) doesn't show up in the backtrace in SBCL. But hitting 'e' on 0: (try1) gives an 'Eval in frame' minibuffer prompt, conveniently already defaulting to the correct package, and evaluating a or b works there as expected.
<gendl>
i've been using this stuff for years and have barely scratched the surface of slime functionality.. :|
<Xach>
I have never used eval-in-frame - I only toggle the local variable view in the frame
kobain has quit [Client Quit]
<gendl>
Oh. How to toggle the local variable view?
<Xach>
t on a frame
<Xach>
In sbcl, only shows locals on high debug...
<gendl>
👍🙏
meepdeew has joined #lisp
wxie has joined #lisp
_jrjsmrtn has quit [Ping timeout: 265 seconds]
__jrjsmrtn__ has joined #lisp
karlosz has quit [Quit: karlosz]
varjag has quit [Ping timeout: 240 seconds]
lxbarbosa has joined #lisp
Oladon has joined #lisp
varjag has joined #lisp
varjag has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 240 seconds]
lavaflow has quit [Ping timeout: 240 seconds]
lavaflow has joined #lisp
meepdeew has quit [Remote host closed the connection]
wxie has quit [Ping timeout: 276 seconds]
lxbarbosa has quit [Remote host closed the connection]
slyrus_ has joined #lisp
orivej has joined #lisp
brettgilio has quit [Ping timeout: 252 seconds]
slyrus has quit [Ping timeout: 240 seconds]
lavaflow has quit [Ping timeout: 276 seconds]
Bourne has quit [Remote host closed the connection]
bitmapper has quit [Read error: Connection reset by peer]
bitmapper has joined #lisp
lavaflow has joined #lisp
orivej has quit [Ping timeout: 276 seconds]
lavaflow has quit [Ping timeout: 252 seconds]
mikecheck has quit [Remote host closed the connection]
meepdeew has joined #lisp
bitmapper has quit [Ping timeout: 240 seconds]
jackdaniel2 has joined #lisp
vsync is now known as mer0vingian
mer0vingian is now known as vsync
jackdaniel2 has quit [Read error: Connection reset by peer]
semz has quit [Ping timeout: 250 seconds]
icov0x29a has joined #lisp
ebzzry has quit [Ping timeout: 240 seconds]
brettgilio has joined #lisp
orivej has joined #lisp
ebrasca has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
icov0x29a has quit [Quit: Leaving]
dgtlcmo has quit [Quit: Lost terminal]
torbo has joined #lisp
lavaflow has joined #lisp
ravndal has quit [Quit: WeeChat 2.6]
ravndal has joined #lisp
vms14 has joined #lisp
<vms14>
guys, I want to make a function to move some character when I receive input events. I'm using clx and I'll receive one event once the player press a key and another when he relases the key.
<vms14>
the thing is, I want to create another function to stop moving once I receive the release event
<vms14>
I should make two functions inside a let sharing one symbol, using this symbols as a condition for a loop?
<vms14>
a global symbol, or how?
<vms14>
I mean, making the stop function change the value of some symbol that the move function uses as a condition of a loop
<vms14>
there is a better approach?
<vms14>
oh, I don't really need it I guess. I should receive more key events until the user releases the key, so the condition just needs to be the key events
<LdBeth>
Does it?
<vms14>
yes I receive events as long as the user is pressing a key
<vms14>
so nvm
<vms14>
xD
<vms14>
clx is much easier to use than the c xlib library <3
<drmeister>
I used displaced arrays for the first time today!
<drmeister>
I'm building a complicated state machine and I want all of the state in packed into one vector.
<drmeister>
I feel like I should get a ribbon or something. :-)
* vms14
gives a ribbon and a badge to drmeister for whatever is he doing
Oladon has quit [Quit: Leaving.]
<vms14>
Congratulations!
<LdBeth>
drmeister: then you could build a parallel version out of it
* LdBeth
Congratulations!
<drmeister>
vms14: Thank you
pfdietz35 has left #lisp [#lisp]
<vms14>
drmeister: np you deserve it :D
Lycurgus has joined #lisp
akoana has left #lisp ["Leaving"]
vlatkoB has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
<PuercoPope>
vms14: It depends on how you want to structure your main loop, a global variable works fine if its the 'main' character. You could also toggle a slot in the character class from :moving/:up/:left/etc to :stop and vice versa that controls what your main loop does with character on each tick
<PuercoPope>
phoe: Got everything the CI running using your example as a guideline. Now I need to update the test command to set its exit status according to the outcome of the test https://builds.sr.ht/~puercopop/job/110265
ebzzry has joined #lisp
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
Bike has quit [Quit: Lost terminal]
meepdeew has quit [Remote host closed the connection]
oni-on-ion has quit [Read error: Connection reset by peer]
<vms14>
I'm thinking about how I should make the main loop move the random enemies I'll have and moving objects like a bullet
<vms14>
should I have a list of those objects wanting to move? What I have in mind is to have a list of elements wanting to move and every element should say the direction it wants to move at this moment, then iterate in that list and move every object/enemy at one point, because I cannot move entirely something without blocking the loop and having to finish that movement
shifty has joined #lisp
gravicappa has joined #lisp
<PuercoPope>
Any reason why you aren't using cl-sdl2+sdl2kit instead? It seems better suited for your use case. But to answer your question yeah having a list of 'active' objects is an ok strategy. You shouldn't use event-case but instead define a more general event loop which checks for X11 events to process but also 'ticks' the game. The CLX manual has some info on how to do that iirc
<vms14>
PuercoPope: I'll look about how to retrieve events manually, I use clx because I've learned Xlib with C and clx is just the same stuff but much better, I consider sdl, but I'm not able to use it in NetBSD because I don't know how to make the library look at the correct path, since it's different from the linux one
<vms14>
also I'm masochist and I like xlib
<vms14>
xD
<PuercoPope>
vms14: the eclipse WM has an example of how to integrate CLX into your own event loop if you want to look at an example
<vms14>
PuercoPope: I didn't know it existed, thanks, I wanted to use stumpwm because it was written in lisp, but I'm used to a stacking wm and use a tiling one is a pain for me, I'll take a look at this one
<phoe>
beach: as soon as I understand how does CCL's own compiler work. I think I mostly got the part that parses Lisp code into an IR that CCL calls "acode" and that then gets stuffed into a backend for a particular platform - the latter, it's magic to me.
<phoe>
PuercoPope: I see that your test failures are because of the DISPLAY variable not being set - in that case, do set it, and set it to a meaningful value that responds to an actual X server running on your VM. That is what XFVB is for.
<beach>
Maybe you should do one step at a time, and start by replacing the CCL reader by Eclector. :)
<phoe>
s/XFVB/XVFB/
<phoe>
beach: my first step is squashing ansi-test bugs. Once that's done, I will think of that and possibly try doing it on a separate branch.
<beach>
phoe: I am half joking. It is not clear that such radical changes are feasible.
<beach>
Though, CCL is another implementation that is written mainly in Common Lisp, so it would be a better candidate for that kind of stuff than the implementations written in C or C++.
<makomo>
morning
<phoe>
makomo: morning
<makomo>
\o
ggole has joined #lisp
krid has joined #lisp
<phoe>
beach: I know you are half joking, but maybe it's possible. If anything, one could at least introduce a decent mechanism that allows one to utilize a different implementation of #'READ than the built-in one.
<beach>
phoe: Well, my goal with SICL has always been partly to cut down on the global maintenance burden for maintainers of Common Lisp implementations. But I realized from the start that these maintainers would be reluctant to ditching their code in favor of the portable one.
<beach>
phoe: Your idea *increases* rather than decreases the maintenance burden.
FreeBirdLjj has joined #lisp
<phoe>
beach: yes, I'm aware. That's exactly why I've mentioned a separate branch. (:
<beach>
I see, yes.
krid has quit [Ping timeout: 276 seconds]
agspathis has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
slarsar has joined #lisp
slarsar has quit [Remote host closed the connection]
slarsar has joined #lisp
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
jonatack has quit [Ping timeout: 250 seconds]
nika has quit [Ping timeout: 265 seconds]
nika has joined #lisp
nika has quit [Client Quit]
random-nick has joined #lisp
jackdaniel2 has joined #lisp
rgherdt has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
minion has quit [Remote host closed the connection]
specbot has quit [Remote host closed the connection]
minion has joined #lisp
specbot has joined #lisp
varjag has joined #lisp
gxt has joined #lisp
slarsar has quit [Ping timeout: 240 seconds]
frgo has quit [Remote host closed the connection]
nowhereman has joined #lisp
varjag has quit [Ping timeout: 276 seconds]
jonatack has joined #lisp
gabiruh_ has joined #lisp
gabiruh has quit [Ping timeout: 252 seconds]
frgo has joined #lisp
jackdaniel2 has joined #lisp
frgo has quit [Read error: Connection reset by peer]
jackdaniel2 has quit [Read error: Connection reset by peer]
nowhereman has quit [Ping timeout: 276 seconds]
agspathis has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<phoe>
Can a logical pathname be EQUAL to a pathname that isn't logical?
<phoe>
Or rather
gxt has quit [Ping timeout: 260 seconds]
<phoe>
Can a logical pathname be EQUAL to a physical pathname?
<MichaelRaskin>
It looks like the standard allows this.
<MichaelRaskin>
But maybe I am wrong
<phoe>
I am asking because I am fixing a pathname bug right now. (Sigh.)
MichaelRaskin has quit [Ping timeout: 245 seconds]
<easye>
I think the EQUAL correspondence will be valid for the CL:TRUENAME of the pathname, and otherwise implementation dependent.
<phoe>
Yes - I need the concrete passage from the specification though.
<phoe>
I have a CCL situation where *compile-file-pathname* is bound to a logical pathname inside the file being compiled but is a physical pathname outside it.
<easye>
Ah, man. I'm speaking as an lazy implementer here. The CLHS is a maze of twisty hyperlinks for me, all alike in different ways.
<phoe>
:D
<phoe>
And CCL tells me that the two are not equal to each other. Which fails the test.
<phoe>
So either the two should be able to be equal to each other, or they should be both logical or both physical.
<easye>
CL:*LOAD-TRUENAME* should be were the comparison is made. Or the CL:TRUENAME of CL:*COMPILE-FILE-PATHNAME* for that instance of a compilation phase.
<easye>
A logical pathname is sort of a predicate that you bind at runtime to work with "reified" CL:PATHNAMEs
<easye>
phoe: but maybe you are testing part of the compiler itself?
MichaelRaskin has joined #lisp
* easye
waves to Michael.
<phoe>
easye: I am testing ANSI-TEST compile-file.16
<phoe>
The contents of the test are inside the issue.
<easye>
Yeah, but need to SLIME it to get to compile-file-test-fun.5
<phoe>
I am lazy that way. I load ANSI-TEST, set up the proper default pathname defaults, (in-package :cl-test) and just evaluate the test body.
epony has quit [Quit: QUIT]
<easye>
Me too. But I am taking a RSS break from Emacs. Or at least my development Emacs.
frgo has joined #lisp
<easye>
Actually, they all my Emacsen are "development" versions.
clothespin has joined #lisp
<MichaelRaskin>
The issue is slightly unclear whether it is *compile-file-pathname* that is logical pathname (seems so)
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<phoe>
MichaelRaskin: the CLHS sayz,
<phoe>
The value of *compile-file-pathname* must always be a pathname or nil. The value of *compile-file-truename* must always be a physical pathname or nil.
ebzzry has quit [Ping timeout: 252 seconds]
<phoe>
so *c-f-p* is allowed to be a physical OR a logical pathname
<phoe>
BUT
<phoe>
During a call to compile-file, *compile-file-pathname* is bound to the pathname denoted by the first argument to compile-file, merged against the defaults.
<MichaelRaskin>
And the result has the same logical-ness as *defualt-pathname-defaults*, right?
<phoe>
The defaults for me are: #P"/home/phoe/Projects/Git/ansi-test/sandbox/"
<phoe>
CLHS on MERGE-PATHNAMES:
<phoe>
merge-pathnames returns a logical pathname if and only if its first argument is a logical pathname, or its first argument is a logical pathname namestring with an explicit host, or its first argument does not specify a host and the default-pathname is a logical pathname.
Posterdati has quit [Ping timeout: 240 seconds]
<phoe>
First argument is #p"foo.lsp" and therefore has no host; the default is a physical pathname.
<phoe>
So MERGE-PATHNAMES properly returns a physical pathname.
<phoe>
So, inside the compiled file, the value of *c-f-p* is incorrect.
<MichaelRaskin>
So you have physical pathname as *d-p-d* and logical for *c-f-p*
<phoe>
No, both should be physical in that case.
<phoe>
merge-pathnames returns a logical pathname only in three cases, and none of the three cases happen here.
<MichaelRaskin>
Well, should vs. have (but I guess soon to be fixed)
<phoe>
soon™
frgo has quit [Read error: Connection reset by peer]
frgo has joined #lisp
stepnem_ has quit [Ping timeout: 240 seconds]
Posterdati has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
scymtym has joined #lisp
guaqua has joined #lisp
<phoe>
annnnnnnnnnnd fixed it seems to be
epony has joined #lisp
brown121408 has joined #lisp
ljavorsk has joined #lisp
brown121407 has quit [Ping timeout: 240 seconds]
jackdaniel2 has joined #lisp
orivej has joined #lisp
ebzzry has joined #lisp
Bike has joined #lisp
Fare has joined #lisp
Fare has quit [Ping timeout: 240 seconds]
<phoe>
(coerce '(1 2 3 4 5 6) '(or (vector t 5) (vector t 10)))
<phoe>
This is supposed to fail with a TYPE-ERROR, is it not?
<Bike>
yes, but that's annoying to check
<phoe>
I see that SBCL ignores this altogether and flips the table as soon as it sees an OR type
<Bike>
and since it's "should be signaled" it only needs to be signaled in safe code
<phoe>
well then, CCL and ECL just obediently return #(1 2 3 4 5 6)
<phoe>
even in safe code
madage has quit [Ping timeout: 260 seconds]
* jjkola
had a productive weekend, was able to push fixes to a few libraries
jackdaniel2 has quit [Read error: Connection reset by peer]
jackdaniel3 has joined #lisp
<jjkola>
now I only need to wait for the fixes to be accepted :)
jackdaniel3 has quit [Read error: Connection reset by peer]
madage has joined #lisp
Fare has joined #lisp
* phoe
pushes another CCL fix
<phoe>
or let's hope it is a fix
<phoe>
oh yes, that was a majestic failure
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
dddddd has joined #lisp
_whitelogger has joined #lisp
jackdaniel2 has joined #lisp
brown121408 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
brown121407 has quit [Ping timeout: 276 seconds]
clothespin has quit [Ping timeout: 265 seconds]
stepnem has joined #lisp
<galdor>
is it me or UIOP:RUN-PROGRAM does not offer the possibility to specify the directory to use as current directory for the subprocess being created ?
pfdietz46 has joined #lisp
<ebzzry>
Is using Electron as GUI for a desktop app with SBCL inside it feasible, or not?
<ebzzry>
Or is using something like Qtools better instead?
jonatack has quit [Ping timeout: 265 seconds]
Lycurgus has joined #lisp
<loke>
ebzzry: Well, Electron is never a good idea. Regardless of what language you'r eusing.
<ebzzry>
loke: I'm leaning towards the near-native approaches, wherein Lisp controls the GUI. The way I’m desinging the system is that the GUI has access to the engine.
<loke>
Then use a proper GUI framework. Qt, GTK, CLIM, whatever. Anything but Electron
<ebzzry>
I feel like if I go with the Electron route, I lose that. I have to create a bridge that will communicate between JS and CL, which has a performance penalty.
<ebzzry>
Indeed. I tested Qtools (and CommonQT) and it works.
<beach>
ebzzry: I strongly recommend McCLIM. The people working on it are doing a fantastic job.
jackdaniel2 has quit [Read error: Connection reset by peer]
<ebzzry>
beach: In fact, I’m also considering McCLIM.
<ebzzry>
Thank you very much. I want to hear the thoughts of everyone regarding that slideshow, with emphasis on slide 29.
<dlowe>
I tried McCLIM and I couldn't wrap my head around it.
<beach>
dlowe: I am sorry to hear that.
<dlowe>
I don't have that much brain to spare, but I wasn't able to find documentation that made it clear to me.
<beach>
I am not sure what to say to that.
<pjb>
phoe: to be EQUAL two objects must be of the same type. LOGICAL-PATHNAME and PHYSICAL-PATHNAME are different types!
<dlowe>
I'm being careful in not assigning blame :p
<beach>
CLIM is different from other GUI toolkits the way Common Lisp is different from other languages.
<dlowe>
but I needed a CLIM for dummies and I didn't find such a thing.
<beach>
Lots of people can't "wrap their heads around" Common Lisp.
<beach>
dlowe: I can admit that we are behind in McCLIM documentation, and that the most complete document is still the CLIM II specification.
<phoe>
pjb: yes, I understand.
<pjb>
phoe: you may need to define a function such as RESOLVE-TO-SAME-FILE-P While TRUENAME usually follow symbolic links, there's also the question of hard links!
<pjb>
phoe: a RESOLVE-TO-EQUAL-PHYSICAL-PATHNAME-P could be practical and sufficient to your need, but while compiling (C), I've already had problems with different paths pointing to the same sources…
<phoe>
pjb: I have seemingly avoided all of this by removing two lines from CCL::%COMPILE-FILE.
jackdaniel2 has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
FreeBirdLjj has joined #lisp
dgtlcmo has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
enrio has joined #lisp
nowhereman has joined #lisp
nowhereman has quit [Ping timeout: 252 seconds]
lxbarbosa has joined #lisp
varjag has joined #lisp
lxbarbosa has quit [Remote host closed the connection]
jackdaniel2 has quit [Read error: Connection reset by peer]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
Lycurgus has quit [Ping timeout: 240 seconds]
Fare has quit [Ping timeout: 245 seconds]
lxbarbosa has joined #lisp
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
lxbarbosa has quit [Remote host closed the connection]
icov0x29a has joined #lisp
gabiruh_ has quit [Quit: ZNC - 1.6.0 - http://znc.in]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 276 seconds]
ljavorsk has quit [Ping timeout: 250 seconds]
ljavorsk has joined #lisp
boeg has joined #lisp
bars0 has joined #lisp
ljavorsk has quit [Ping timeout: 250 seconds]
sjl has joined #lisp
<phoe>
Is there any CL library or implementation function that will help me simplify types as much as possible? I have a compount type such as (not (or (not (cons (eql 0) (real 3d0 3d0))) (not (cons t (eql 0))))) and I would like to make it simpler to parse.
<pjb>
Can't you find that in implementations?
<phoe>
Yes, that's where I am looking right now. The only thing I found in CCL is something that operates on its internal ctype representation, not on CL types.
bars0 has quit [Quit: leaving]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
<pfdietz46>
SBCL has something like that also. It's notoriously opaque.
<pfdietz46>
Is the best PhD defense a good PhD offense? :)
<beach>
Heh.
<pfdietz46>
A concept that's right up there with Contact Bridge
jonatack has joined #lisp
femi has quit [Ping timeout: 268 seconds]
mooch has joined #lisp
<phoe>
Is (subtypep '(real -3.0d7 -3.0d7) '(eql -3.0d7)) supposed to be true?
* phoe
reads
<phoe>
Oh yes, this is what I was thinking of
frgo has quit []
<phoe>
Or rather, for any real number X, are types (eql X) and (real X X) equivalent?
femi has joined #lisp
<pfdietz46>
They should be the same, yes
<pfdietz46>
Excuse me, no
<pfdietz46>
Because -3 (the integer) is in that interval, but is not EQL to -3.0d7
<phoe>
Oh wait a second
<pfdietz46>
-30000000
<phoe>
REAL also includes integers
<pfdietz46>
I mean
<phoe>
Yes, I see
<pfdietz46>
And also all the different kinds of floats, and ratios
<phoe>
I see
<pfdietz46>
There are also complexities from negative zeros, which are = but not EQL to positive zeros of the same float class
<phoe>
I am digging into subtypep.cons.43 right now
<phoe>
It seems to fail on both SBCL and CCL alike.
frgo has joined #lisp
clothespin has joined #lisp
ebrasca has quit [Remote host closed the connection]
<pfdietz46>
There are open tickets on SBCL involving cons types.
jackdaniel2 has joined #lisp
<phoe>
Yes, I'll either need to fix this up on CCL or create a ticket on CCL as well.
<pfdietz46>
I have a random tester for subtypep that tries various combinations that should be equivalent. Does that repo have random/random-types.lsp?
jackdaniel2 has quit [Read error: Connection reset by peer]
femi has joined #lisp
Bourne has joined #lisp
femi has quit [Ping timeout: 252 seconds]
Jeanne-Kamikaze has joined #lisp
oxford has quit [Remote host closed the connection]
oxford has joined #lisp
femi has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
icov0x29a has quit [Quit: Leaving]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
scymtym has quit [Ping timeout: 245 seconds]
femi has quit [Ping timeout: 240 seconds]
femi has joined #lisp
shka_ has quit [Quit: Konversation terminated!]
rotty has quit [Ping timeout: 268 seconds]
rotty has joined #lisp
Oladon has joined #lisp
khisanth_ has quit [Ping timeout: 276 seconds]
shka_ has joined #lisp
makomo has quit [Quit: WeeChat 2.4]
brettgilio has quit [Ping timeout: 250 seconds]
jackdaniel2 has joined #lisp
khisanth_ has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
Fare has quit [Ping timeout: 250 seconds]
izh_ has joined #lisp
shka_ has quit [Read error: No route to host]
shka_ has joined #lisp
mooch has quit [Ping timeout: 250 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
shka_ has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
<pfdietz46>
I wonder if Newton's techniques would be useful for optima/trivia matching.
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
brown121408 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
karlosz has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
cosimone_ has joined #lisp
cosimone has quit [Ping timeout: 250 seconds]
mooch2 has joined #lisp
random-nick has quit [Ping timeout: 265 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Quit: karlosz]
jackdaniel2 has joined #lisp
bars0 has joined #lisp
hiroaki has quit [Ping timeout: 265 seconds]
jackdaniel2 has quit [Read error: Connection reset by peer]
brown121408 has joined #lisp
brown121407 has quit [Ping timeout: 240 seconds]
cosimone_ has quit [Quit: Terminated!]
clothespin has quit [Ping timeout: 240 seconds]
enrio has quit [Quit: Leaving]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
bitmapper has joined #lisp
brown121407 has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
karlosz has quit [Quit: karlosz]
ggole has quit [Quit: Leaving]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
bars0 has quit [Ping timeout: 265 seconds]
brettgilio has joined #lisp
gravicappa has quit [Ping timeout: 250 seconds]
scymtym has joined #lisp
karlosz has joined #lisp
shka_ has quit [Ping timeout: 276 seconds]
fivo has joined #lisp
karlosz_ has joined #lisp
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
lucasb has joined #lisp
karlosz has quit [Ping timeout: 265 seconds]
karlosz has joined #lisp
karlosz_ has quit [Ping timeout: 245 seconds]
<jeosol>
morning guys.
<mooch2>
hey
<jeosol>
Is any one using some CL lib for literate programming. I am trying to write some documents, but capture the output of repl -- mostly formatted output, tables, etc. No lisp code
<mooch2>
um, i'm currently trying to write a multi-system emulator in common lisp, starting with the nes. is anybody interested in maybe helping me?
vlatkoB has quit [Remote host closed the connection]
stux|RC-only has quit [Read error: Connection reset by peer]
stux|RC-only has joined #lisp
vaporatorius has quit [Quit: Leaving]
<rumbler31>
jeosol: wdym
theruran has quit [Quit: Connection closed for inactivity]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jeosol>
rumbler31: I am trying to create some blog post using markdown and export everything to html. I would like to capture output of my program that's dumped to the repl. I do that manually, but wondering if there are automated techniques like using org-model + babel (not an expert in this but seen a few videos)
<rumbler31>
well when you say automated, what do you mean
<rumbler31>
like you type up your whole post in the repl?
<Josh_2>
instead of outputting repl output to another stream?
karlosz has quit [Quit: karlosz]
<jeosol>
rumbler31: not what I mean. I mean like certain outputs just go to certain sections of the markdown documents. The example I cited (some YT tutorial) captures shell or python output from code blocks or something.
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
<rumbler31>
I must have missed what you cited, can you link me?
<pjb>
jeosol: yes, I'm using the CL library to do literate programming. The CL library contains the operator #| that introduces text, and |# that introduces code.
karlosz has joined #lisp
<pjb>
#| for example, let's define a function named square: |# (defun square #| that takes one argument: |# (x) #| and compute the square: |# (* x x)) #| note how code is brackeded with |# #| ! |#
<p_l>
mooch2: wish I could help you out, but I'm too busy with work at the moment to even write a line of code for my Ivory emulator (right now more of a dissector)
<pjb>
jeosol: also, notice how emacs knows that it should fontify only the code between |# … #| and not the text.
gxt has joined #lisp
<jeosol>
That is the link. I have no affliation with the author and watched that video after it was posted on the emacs reddit link
<pjb>
jeosol: notice how compile-file, load and read are literate-programming ready: they only process the code!
<jeosol>
pjb: Thanks for your info. I am not an expert in this at all, but noticed it will allow me to organize my files together with the examples.
gxt has quit [Client Quit]
<jeosol>
pjb: how does this work, is it using a library. I assume this can run any function
<pjb>
jeosol: yes, it uses a library included in Common Lisp.
ferada_ is now known as ferada
<pjb>
To invoke the literate programming library, you just start the file with #| and end it with |#.
<jeosol>
internal or one installed via ql
<jeosol>
Oh I see
<pjb>
internal, and implemented by all implementation: it's in the standard!
<jeosol>
You have an example I could look at.
<p_l>
jeosol: #| |# is multiline comment in CL, pretty much
<jeosol>
I am familiar with that, so I was a bit confused how it works with that
<p_l>
*if* you do some creative work with readtable you can get it to output the text and push it through some other formatter
<pjb>
#| for example, let's define a function named square: |# (defun square #| that takes one argument: |# (x) #| and compute the square: |# (* x x)) #| note how code is brackeded with |# #| ! |#
<pjb>
jeosol: ^ this is the example, you can look at!
<jeosol>
pjb: I get it now, in the context of the multiline comment. Thanks
<p_l>
not sure how well it would work for manipulating both code and text for purposes of generating printed document that had both
<jeosol>
@p_l: that sounds like what I am looking for like the linked YT video. Not sure it's possible though, I wanted to see what people are using
karlosz has quit [Ping timeout: 250 seconds]
<jeosol>
I want to type markdown, and somewhere in the document, I can have lisp code (and comments) to help me remember what cases or functions I called ( I don't have to show the lisp code), but the output gets generated into the document
<pfdietz46>
I'm more of an illiterate programming person.
<jeosol>
I mean the output of the function call at that point
cpt_nemo has quit [Read error: Connection reset by peer]
<jeosol>
The example did use org-mode + emacs, I will look into it
<PuercoPope>
jeosol: There is a erudite for literate programming although its more for writing and finding your way about the code that presenting it https://bitbucket.org/mmontone/erudite/src/master/
<jeosol>
PuercoPope: Thanks for the link. In my google search, your repo came up.
<jeosol>
Do you mean for code documentation
Fare has joined #lisp
Lycurgus has joined #lisp
<PuercoPope>
Not for documentation but to provide a superstructure to the code, outlines in this case. You can check mariano's fork of scenic to see how erudite is used.
<jeosol>
Ok. Thanks
<Josh_2>
Does anyone have a regex that works to extract urls in cl-ppcre?
<jeosol>
pjb: Checked the link and I think there is CL support and that org-mode route should work.
<Josh_2>
I have found some regex online but they don't seem to work in cl-ppcre :O
renzhi has quit [Ping timeout: 240 seconds]
bars0 has quit [Quit: leaving]
<Bike>
doesn't work how?
<Josh_2>
Okay cool I found one
<Josh_2>
Using the python one from this site http://urlregex.com/ works with two escape characters
bars0 has joined #lisp
karlosz has quit [Quit: karlosz]
<Bike>
oh, yeah, if you enter it as a lisp string you'll need more backspaces
karlosz has joined #lisp
anewuser has joined #lisp
<sjl>
probably more backslashes too, after the backspaces
<Josh_2>
Well it works
<Josh_2>
I had to add two backslashes
<Bike>
right.
<aeth>
jeosol: The reason #| ... |# works for literate programming is because you can just write a second parser and effectively you parse the file twice, once as a document and once as a program. Parsing it as a program is, well, it's just using the default reader and it will run, no magic required since it's just the comment syntax. Parsing it as a document means you read it as an extended Markdown or LaTeX or whatever.
<aeth>
Essentially, you can just preprocess it for an existing Markdown->HTML generator and invert the comments in that preprocessed step. So "|# ... #|" would become "`...`" if it's "inline" and if it's multiline it becomes "```common-lisp\n...\n```"
<jeosol>
aeth: Thanks for the explanation
<aeth>
You could probably do this with regular expressions if you're careful about the edge cases (like the first comment where there's either a "#|" that needs to be removed if it starts with a comment or a "... #|" that needs to be turned into lisp followed by markdown without having a first |#)
hiroaki has quit [Ping timeout: 240 seconds]
anewuser has quit [Read error: Connection reset by peer]
zbrown has left #lisp [#lisp]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
hiroaki has joined #lisp
X-Scale has quit [Ping timeout: 268 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
hiroaki has quit [Ping timeout: 240 seconds]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
karlosz has quit [Quit: karlosz]
Josh_2 has quit [Remote host closed the connection]
<saturn2>
where can i find examples of some of the CLtL2 features (macroexpand-all, compiler-let, variable-information, parse-macro, enclose, etc.) being used?
<saturn2>
or anything written about them besides CLtL2 itself?
<Bike>
i don't know if anyone was totally clear on compiler-let
<Bike>
other than that i don't know, the sb-cltl2 documentation? they're all fairly simple
Jeanne-Kamikaze has quit [Remote host closed the connection]
<saturn2>
the sb-cltl2 documentation seems to have pretty much the same information as CLtL2
<Bike>
what more do you want to know?
<saturn2>
examples of how they could be put together to create something useful
<saturn2>
yes i can come up with some ideas myself, but surely people smarter than me have thought about this before