kushal has quit [Remote host closed the connection]
kushal- has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
pierpa has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
warweasle has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Remote host closed the connection]
fikka has joined #lisp
norvic has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 268 seconds]
EvW1 has quit [Ping timeout: 246 seconds]
warweasle has joined #lisp
terpri has joined #lisp
comborico1611 has quit [Quit: Konversation terminated!]
bugrum has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
kajo has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
damke has quit [Ping timeout: 268 seconds]
bugrum has joined #lisp
warweasle has quit [Quit: Leaving]
d4ryus1 has joined #lisp
damke has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
d4ryus has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
damke_ has joined #lisp
zachk has quit [Quit: Leaving]
damke has quit [Ping timeout: 268 seconds]
vsync_ is now known as vsync
fikka has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
pfdietz has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
vhost- has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
jlarocco` has quit [Ping timeout: 240 seconds]
fraktor has joined #lisp
<fraktor>
I'm writing a program that, depending on an argument, should switch either the x or y component of a vector that I'm storing in a cons cell. What's the best way to do this? Could I pass in an atom like 'x or 'y?
vtomole has joined #lisp
<White_Flame>
it could be a boolean, too
<minion>
White_Flame, memo from jmercouris: any examples of tree based GA in Lisp that you can point me to?
<fraktor>
If I wanted to pass in an atom like 'x or 'y, how would I do that? I tried using an if and eq, but that didn't work.
<White_Flame>
that's not a sufficient enough explanation of what didn't work
<fraktor>
Fair enough. I'll post a paste.
<White_Flame>
(defun foo (var) ...) if you call it via (foo 'x), then a (if (eq var 'x) ...) should work
<White_Flame>
inside the body of foo
<fraktor>
Interesting... that's what I did.
<White_Flame>
you also need to be aware of packages
<White_Flame>
if your 'x in the caller is cl-user::x, and your 'x in FOO's source code is my-project::x or something
<fraktor>
No packages. I'm still learning basic lisp.
fikka has joined #lisp
DataLinkDroid3 is now known as DataLinkDroid
<White_Flame>
minion: memo for jmercouris: there are little examples via google, but you'd have to customize and figure out what sort of code mutations you want
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
karswell has quit [Remote host closed the connection]
<fraktor>
So I've got my program working, but it's ugly as sin.
fikka has quit [Ping timeout: 265 seconds]
<fraktor>
I've got one recursive function, and I can't really think of a good way to break it down.
<fraktor>
If I posted a paste, would you be willing to help me figure it out?
fikka has joined #lisp
elderK has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 250 seconds]
<White_Flame>
sure, but recursive functions are usually fine
<White_Flame>
often times, I end up having a recursive function inside a toplevel funcction for my loop, via LABELS
<White_Flame>
also, probably better to post in #clnoobs than here
<fraktor>
Perfect! I didn't know there was such a channel.
bugrum has quit [Remote host closed the connection]
fikka has joined #lisp
kushal- has quit [Ping timeout: 255 seconds]
clintm has joined #lisp
elderK has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
kushal has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
fikka has joined #lisp
ddd has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
qwebirc38513 has joined #lisp
qwebirc38513 has quit [Client Quit]
qwebirc36432 has joined #lisp
Beepy has joined #lisp
qwebirc36432 has quit [Client Quit]
qwebirc77181 has joined #lisp
qwebirc77181 has quit [Client Quit]
SenasOzys has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
marusich has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
vtomole has quit [Ping timeout: 260 seconds]
SenasOzys has joined #lisp
<pierpa>
fraktor: in this case I would use keywords, such as :x :y and an ECASE for discrimintating between them.
<pierpa>
discriminating, even
<clintm>
If I have a class that uses a metaclass and I want to make a subclass of it, is it correct to also set the metaclass of the subclass? Have I missed something about mop and there's a way for the metaclass to follow into subclasses?
karswell has joined #lisp
<clintm>
I guess a code example would be 100% better than that question.
damke has joined #lisp
<Bike>
you have to specify the metaclass, yes.
fraktor has quit [Ping timeout: 246 seconds]
<clintm>
ok, awesome.
<clintm>
thanks, Bike
<Bike>
this is because you can have a class with one metaclass be a subclass of a class of a different metaclass.
<clintm>
oh, of course.
<pierpa>
fraktor: also, I would represent vectors with vectors (duh). and then use an integer index instead of :x and :y
Kundry_Wag has joined #lisp
Louge has joined #lisp
damke_ has quit [Ping timeout: 268 seconds]
smurfrobot has quit [Remote host closed the connection]
fikka has joined #lisp
pierpa has quit [Quit: Page closed]
oldtopman has quit [Ping timeout: 255 seconds]
Louge has quit [Quit: Louge]
fikka has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Remote host closed the connection]
fikka has joined #lisp
SenasOzys has quit [Ping timeout: 260 seconds]
wheelsucker has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
quazimodo has joined #lisp
fikka has joined #lisp
<loke>
Hello
smurfrobot has quit [Ping timeout: 250 seconds]
<loke>
I have a design conundrum
fikka has quit [Ping timeout: 240 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
wheelsucker has quit [Ping timeout: 268 seconds]
Karl_Dscc has joined #lisp
fikka has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
quazimodo has quit [Ping timeout: 250 seconds]
quazimodo has joined #lisp
ddd has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Ping timeout: 260 seconds]
shka_ has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Beepy has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 246 seconds]
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
smurfrobot has joined #lisp
Satou has joined #lisp
fikka has joined #lisp
CrazyEddy has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
smurfrobot has quit [Remote host closed the connection]
slyrus2 has quit [Quit: slyrus2]
<phoe>
loke: hm?
fikka has joined #lisp
smurfrobot has joined #lisp
Bike has quit [Quit: Lost terminal]
rippa has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
slyrus2 has joined #lisp
Pixel_Outlaw has quit [Remote host closed the connection]
Karl_Dscc has quit [Remote host closed the connection]
Satou has quit [Quit: exit();]
fikka has joined #lisp
iqubic has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Mutex7 has quit [Quit: Leaving]
fikka has joined #lisp
<loke>
phoe: Oh hello phoe
fikka has quit [Ping timeout: 256 seconds]
<phoe>
hey loke
<loke>
My problem was that I am building a generalised configuration system, and I need a way to configure the system (like what backend provider to use, etc) before the packages have been loaded. This is because the configuration needs to go in .sbclrc for example
<loke>
So, I see two solutions: One is to set variables in CL-USER that the config system can access once it's loaded
<loke>
Or, I can use symbol-plists on some specific keywords
<loke>
I am exploring the second option right now.
<loke>
It's a bit ugly though, because in order to specify the class to use for the backend storage engine, I have to give th eclass name as two strings; package and symbol name of the class
<loke>
It's ugly, but I can't think of a better solution.
<White_Flame>
I have functions in my .sbclrc which set up config for my interactive environment
<White_Flame>
specifically via defun that I can call in slime
<White_Flame>
I also have a simple image-builder, which those scripts tend to use, which performs toplevel mutating steps (like loading in libs and changing readtables before loading more) that I can either use in SLIME or to build executable images
fikka has joined #lisp
<loke>
White_Flame: This is a generic system though, and I don't want to load packages unless you run an application that needs them.
<White_Flame>
yeah, this system is generic. It's based on a propfile which basically lists what commands to run when
<loke>
So Climaxima for example needs a way to find out what font size to use. This value should be provided by the config system.
<White_Flame>
and I specifically do not LOAD it, because that would scope some of the mutations, and I read/eval forms one by one so taht changes to the reader (like available packages) can happen between lines, allowing plain package:symbol references to work later in the file
<loke>
So somehow, in my .sbclrc I need to tell the config system what storage engine to use (i.e. plain files) and also tell that storage engine its configuration (i.e. the path where the prfs should be saved). I need to provide this configuration _before_ the pref system has been loaded
<White_Flame>
can't you just load the system and then configure it?
<loke>
White_Flame: No. You need to be able to set the configurations, but the system itself may never ben loaded.
<loke>
If it's not loaded, those values are not used of course.
<White_Flame>
what drives that requirement?
<loke>
White_Flame: The goal to make it generic. I can't force people to force load a system in their .sbclrc file just so that Climaxima can save its config.
<White_Flame>
well, I don't understand Climaxima's needs specifically
<loke>
with my current solution, all you have to put in your .sbclsrc file is this: (setf (get :lisp-pref :provider) '(:file "/foo/bar/blah")) in order to configure the system
<White_Flame>
but a (ql:quickload "climaxima") (climaxima:set-config :foo :bar) to be runnable in some init file seems to make sense to me
<loke>
White_Flame: That's the thing, ther eis no init file. The phone purpose of the prefences sytsem is to make _everything_ configurable, even the init file location
<White_Flame>
you could probably also create a custom .asd for it, which depends on climaxima and then configures it
<loke>
White_Flame: Other applications, like Second Climacs would also use the same system
<loke>
So the prefs system can't depend on climaxima
<White_Flame>
the init file doesn't have to be in any special location. You invoke it to set up your config
<loke>
White_Flame: RIght, and where do you put th eocnfig?
<loke>
"the config"
<loke>
That's my issue.
<White_Flame>
wherever you want. It defines "holding teh config"
<White_Flame>
you point your config system at that file, and it loads & configures climaxima or whatever else you need
<loke>
White_Flame: WHo is "you"? In my case, the "you" is the user, not the author of the application.
<White_Flame>
sure
<loke>
White_Flame: The config system doesn't know where the file is. There may not even be a file.
<White_Flame>
I as the user set up an image definition file, which would load & configure stuff
<loke>
I can't rely on having a single config file
<White_Flame>
not a problem
<loke>
All I can rely on is things available in the image.
<loke>
So where in the image do I store this?
<White_Flame>
I guess I don't understand the specifics of your requirements and why a simple system wouldn't suffice
<loke>
White_Flame: The requirement is this:
<loke>
You need to be able to put the basic configration (like, config file locations, etc...) in the image
<loke>
Seocnd:
<loke>
This config should not cause issues if the config system is not available
<White_Flame>
what does the "image" entail here?
<phoe>
what do you mean, "if the config system is not available"?
<loke>
Third: Whatever config has been given should used when (and if) the config system is loaded
<White_Flame>
if you have an image, that image would contain the config system, right?
<loke>
phoe: Not available, meaning it's not there. Like in a plain instalaltion of SBCL
<loke>
White_Flame: No. this needs to work without a custom image.
<loke>
So, use case:
<loke>
1) User downloads SBCL onto a blank system
<loke>
2) Upser copies his old .sbclrc from some other system
<loke>
3) User starts sbcl
<loke>
4) This should not cause a crash
<loke>
5) User loads climaxima, which has a dependency on lisp-pref
<phoe>
how do they load climaxima?
<loke>
6) Lisp-pref initialises, and uses __only_ the information in the image to load all the other config
<loke>
phoe: (ql:quickload "climaxima")
<phoe>
so they have quicklisp installed, okay
<loke>
phoe: Not necessarily
<loke>
They may have downloaded it (and lisp-pref).
<loke>
So yes, after climaxima is loaded, lisp-pref is available.
<phoe>
loke: yes, they do, because otherwise there's no packagge QL to speak of
<loke>
phoe: Sure, but you can load climaxima using asdf:load-system as well. But I that what you're getting at is that lisp-pref is available after loading climaxima, and that is a correct assessment.
<phoe>
yep, I see.
<White_Flame>
in my .sbclrc, I have (defun project () (setf *load-image-interactively* #P"....") (load #P".../image-builder.lisp"))
<loke>
The core of my issue is that you need to provide basic configuration for the system before the system is available.
<phoe>
in your .sbclrc, create a new package called CLIMAXIMA/CONFIG that exports a single DEFVAR'd symbol.
<loke>
White_Flame: And in what package does the PROJECT function live?
<White_Flame>
cl-user
<phoe>
That symbol contains a plist or alist containing your basic config.
<White_Flame>
but, what to load & config is in the interacticaly loaded prop file, which can also be used from teh cmdline to create an executable image
<loke>
White_Flame: OK, so you are basically using what I proposed to be option 1 above: To have magic stuff in CL-USER
<White_Flame>
well, everything is in the prop file
<loke>
phoe: you are proposing a third option, to create a package in .sbclrc
<White_Flame>
when the image-builder is loaded, if the interactive var is set, it assumes it's in SLIME. Else, it builds an executable image
<loke>
White_Flame: Of course, but this is about bootstrapping the system; to be able to tell it where that prop file is
<phoe>
loke: yep. that package can then be probed by CLIMAXIMA; if it does not exist yet, it is created and initialized with default values, otherwise the config is loaded from that package.
<White_Flame>
it's a parameter...
<White_Flame>
the location of the file is passed into the prop handling system
<loke>
phoe: Right. So it all comes down to having well-known information available to lisp-pref. Now we have three options:
<loke>
1) Magic stuff in CL-USER
<loke>
2) Magic stuff in keywords plists
<loke>
3) Magic stuff in a new package
<loke>
My question is:
<loke>
Out of these three options, which one is the best?
marusich has joined #lisp
<phoe>
1) sounds wrong for me because we do not want to pollute CL-USER with anything; it is a package available to the user.
<phoe>
2) symbol plists should die.
<loke>
phoe: I agree with this two assememts
<phoe>
so, well, um
<loke>
Perhaps the magic package is the best...
<loke>
I never thought of that one.
<phoe>
¯\_(ツ)_/¯
<loke>
Can you think of any other way to provide information to a nonexistent system?
<White_Flame>
magic files
<phoe>
you need a well-defined place from which that nonexistent system pulls data
<phoe>
no matter where it is, you must know where it is.
<loke>
(I guess I was thinking in terms of symbol plists because both Maxima and CLIM uses them so heavily)
<loke>
White_Flame: True... that is indeed a fourth option
<phoe>
or that
<loke>
White_Flame: It might not be a terrible one, but where wold you put it? It needs to do the right think on all OS'es
<phoe>
you could use a ~/.climaxima/ directory
<loke>
And if you want to make the file location configurable, you're back to the original question again when you decide how to confige it)
<loke>
phoe: That directly would not be popular on Windows.
<White_Flame>
there's also environment variables
<loke>
I guess some servings on #+windows, etc... one could build something that puts the config file in a reasonable lcoation on most environments.
<loke>
White_Flame: But there is no standard way to access those?
<loke>
There is commandline parameters as well
<White_Flame>
should be simple enough to support popular lisps
<White_Flame>
there aren't cmdline parameters if you're loading from slime
<loke>
White_Flame: Mmm... you have a point
<loke>
White_Flame: You are right
<White_Flame>
(well, I don't know if slime supports passing things to the inferior lisp. I'm assuming you're loading your project from an already running SLIME connection)
<loke>
I mentioned commandline paramets because jackdaniel was very fond of th eidea.
<loke>
White_Flame: Correct.
<loke>
I wanted to be able to bootstrap everything from .sbclrc
<White_Flame>
I seem to be the only one left in the universe building executable images for deployment ;)
<loke>
White_Flame: I do.
<White_Flame>
\:D/
<loke>
White_Flame: Well, for one specific project
<White_Flame>
and of course, as an application server, it wants to continue building after the image has moved to another machine, which confuses the heck out of quicklisp and such
beizhia has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
<loke>
White_Flame: Oh, I never do that. I always build the binary on the system where it'll be running.
<loke>
Or, as part of a Docker container.
<White_Flame>
yeah, we're starting to get into docker
<White_Flame>
so our system is generic, same image-builder and prop file loaded from slime to set up the environment
<White_Flame>
the image.prop does things like adds asdf dirs relative to the project, loads systems, evals toplevel stuff, etc
puchacz has quit [Quit: Konversation terminated!]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<White_Flame>
I would still recommend that your system not pull from some generic config, but that your generic config stuff pulls in systems and configures them. That way the systems don't need to be modified to benefit from the config
<flip214>
sjl: I've got a VLIME fix for you: github.com:phmarek/vlime
<flip214>
And I'm trying to accumulate all VLIME related things - if you know of other goodies in other repositories, please tell me.
<loke>
White_Flame and phoe: thanks for your insight
<otwieracz>
4
<otwieracz>
SIvtXopseYBZZg
<loke>
I think I'll go for the config file approach, and store it in a logical location based on platform. I will them provide multiple ways to override the config file location, including both a commandline option and perhaps the plist
<loke>
So in 99% of cases, you never have to provide any bootstrap information
<phoe>
otwieracz: I think you did something that you did not want to
<otwieracz>
Pro tip: do not use „terminator” terminal emulator.
quazimodo has quit [Ping timeout: 240 seconds]
<otwieracz>
Suddenly, everything I have typed in one instance ended up being typed in *every single running instance*.
<phoe>
holy cow, that's a pretty big bug
<otwieracz>
I was pretty surprised, looking into chat log with my friend „when did I typed „sudo -i” here…”… however, I apologized him, switched channels and WAT
marusich has quit [Ping timeout: 240 seconds]
jeremiah has joined #lisp
<otwieracz>
I believe this is a feature.
eSVG has joined #lisp
Quetzal2 has joined #lisp
<otwieracz>
Maybe I've enabled it with some weird keystroke.
<otwieracz>
but this is ridiculous…
Kundry_Wag has joined #lisp
SenasOzys has joined #lisp
random-nick has joined #lisp
<shka_>
scymtym: just using you flamegraphs package
<shka_>
i can't emphasis enough on how cool it is
quazimodo has joined #lisp
gogsismycity has joined #lisp
gogsismycity has quit [Client Quit]
Kundry_Wag has quit [Ping timeout: 255 seconds]
pyx has joined #lisp
pyx has quit [Client Quit]
beizhia has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
pierpal has quit [Remote host closed the connection]
vlatkoB has joined #lisp
orivej has joined #lisp
makomo has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
smurfrobot has joined #lisp
light2yellow has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
shka_ has quit [Ping timeout: 248 seconds]
kajo has joined #lisp
elfmacs has joined #lisp
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
dtornabene has joined #lisp
fikka has joined #lisp
python476 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
swflint has quit [Ping timeout: 265 seconds]
swflint has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
tomaw has quit [Ping timeout: 615 seconds]
fikka has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
damke_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
damke has quit [Ping timeout: 268 seconds]
inoperable_ has quit [Quit: ZNC 1.6.6 - http://znc.in]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
fikka has joined #lisp
pfdietz has joined #lisp
kajo has quit [Ping timeout: 264 seconds]
d4ryus1 is now known as d4ryus
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
inoperable has joined #lisp
makomo has joined #lisp
Khisanth has quit [Ping timeout: 268 seconds]
makomo has quit [Ping timeout: 260 seconds]
<LdBeth>
otwieracz (IRC): where does the „” thing come out
<pjb>
LdBeth: German typography.
Khisanth has joined #lisp
lnostdal has quit [Ping timeout: 248 seconds]
kajo has joined #lisp
<LdBeth>
Get ✔️
trocado has joined #lisp
_paul0 has quit [Remote host closed the connection]
_paul0 has joined #lisp
pfdietz has quit [Read error: Connection reset by peer]
varjag has joined #lisp
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
pierpal has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
lnostdal has joined #lisp
fikka has joined #lisp
markong has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
pfdietz has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
lnostdal has quit [Ping timeout: 246 seconds]
pierpal has joined #lisp
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 256 seconds]
BitPuffin has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
Kundry_Wag has joined #lisp
pfdietz has quit [Ping timeout: 246 seconds]
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
lnostdal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Bike has joined #lisp
stara has joined #lisp
<stara>
Hi, how compute x^3-2x^2-9x+18=0 Cardano's method?
<stara>
I computed depressed cubic, my result: t^3-31t/3+308/27=0, good?
trocado has quit [Ping timeout: 250 seconds]
juki has joined #lisp
<phoe>
stara: are you sure this is a #lisp question?
<stara>
phoe, not; but maybe somehow someo reply (will answer).
<phoe>
stara: this is off-topic. You'll have better luck asking on a math-oriented channel.
trocado has joined #lisp
fikka has joined #lisp
tomaw has joined #lisp
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
DemolitionMan has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
beach has joined #lisp
<beach>
Good afternoon everyone!
<LdBeth>
Heya
Kundry_Wag has quit [Ping timeout: 276 seconds]
<phoe>
Hey beach
<loke>
Hello beach and phoe
<loke>
beach: I've been writing your document you wanted :-)
schoppenhauer has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<phoe>
loke: your work partially overlaps with my PROTEST way of declaring configuration categories and configuration options.
warweasle has quit [Quit: Leaving]
fikka has joined #lisp
<phoe>
DEFINE-TYPE is not the best name because it directly clashes with CL:DEFTYPE. Maybe something more verbose like DEFINE-CONFIGURATION-TYPE?
<phoe>
:STRUCTURE :STRING is unclear to me. I don't yet get what it does, and also you missed a closing paren. (:
<phoe>
Using hash-tables is a better idea. Any list of non-null lists is a valid alist, and therefore you might avoid type confusion by using hashtables.
Beepy has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
<phoe>
So it is obvious that you don't want just a mere tree of valid lists, and instead you want an actual map from keys to values.
<phoe>
That's the stuff I've thought of so far.
bjorkintosh has quit [Ping timeout: 260 seconds]
easye has quit [Read error: Connection reset by peer]
smurfrobot has quit [Remote host closed the connection]
specbot has quit [Read error: No route to host]
minion has quit [Read error: No route to host]
cage_ has joined #lisp
smurfrobot has joined #lisp
specbot has joined #lisp
minion has joined #lisp
nowhere_man has quit [Ping timeout: 250 seconds]
stara has joined #lisp
stara has quit [Client Quit]
Satou has quit [Quit: exit();]
fikka has joined #lisp
djole_geo has joined #lisp
igemnace has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
damke has quit [Ping timeout: 268 seconds]
damke has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
fikka has joined #lisp
djole_geo has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
djole_geo has joined #lisp
comborico1611 has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
smurfrobot has joined #lisp
zotan has quit [Quit: ZNC 1.6.5+deb1 - http://znc.in]
zotan has joined #lisp
damke_ has joined #lisp
<shka_>
soooo, there is this successor to prove called rove
<shka_>
is it worth switching?
terpri has joined #lisp
damke has quit [Ping timeout: 268 seconds]
<comborico1611>
Which word would you use to describe the difference between a Lisp REPL to that of all the other programming language REPLs? I was thinking "memory".
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<shka_>
comborico1611: reader part
smurfrobot has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
fikka has joined #lisp
<comborico1611>
shka_: Hmm. There may be more than one difference then. I was thinking on the ability to load a function onto the REPL and then call it again.
EvW has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 248 seconds]
<shka_>
you can do it in python if you want
<shka_>
at least i think you can
<shka_>
but huge difference is that so called REPLs are not really read eval print loop
<shka_>
more like do-some-opaque-magic, eval-or-not, print, loops i think
<comborico1611>
Hmm. What word would you use instead of "do some opaque magic"?
<comborico1611>
I'm just trying to solidify this difference with a word.
rumbler31 has joined #lisp
<shka_>
comborico1611: i don't know, it just not read
<phoe>
comborico1611: integration of the REPL with the inspector, debugger, stepper and so on
<shka_>
there is no read in non-lispy languages
<phoe>
nowadays it isn't about the REPL itself, it's about how it integrates with everything else
<phoe>
^
FreeBirdLjj has quit [Remote host closed the connection]
<shka_>
anyway
<shka_>
comborico1611: try to implement REPL on your own
damke has joined #lisp
elderK has quit [Quit: WeeChat 1.9]
<shka_>
in lisp it is literally read -> eval -> print and loop over it
rumbler31 has quit [Ping timeout: 246 seconds]
<shka_>
single line of code
<shka_>
in python or php, as i said, there is no read
<shka_>
i think you are supposed to eval strings
<shka_>
but in lisp, you are evaling lists
<comborico1611>
I see. Thanks for the feedback!
<shka_>
well, more like symbolic expressions
<Beepy>
shka_, it looks like Rove is still by Eitaro Fukamachi, so it will probably replace Prove at some point.
damke_ has quit [Ping timeout: 268 seconds]
<shka_>
comborico1611: glad i could help
<shka_>
anyway, this is important characteristic of lisp
Kundry_Wag has quit [Remote host closed the connection]
<shka_>
homoiconicity starts here, really
Kundry_Wag has joined #lisp
fikka has joined #lisp
dtornabene has quit [Quit: Leaving]
<comborico1611>
Hmm.
Kundry_Wag has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 265 seconds]
trocado has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
warweasle has joined #lisp
fikka has joined #lisp
nowhere_man has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
Kundry_W` has joined #lisp
fikka has joined #lisp
Kundry_W` has quit [Remote host closed the connection]
<phoe>
Hah
<phoe>
I've only started to rewrite my old code using my new version of PROTEST and I'm already uncovering things that I should have done better back in the day
<phoe>
such as discovering that I have duplicated DEFGENERICs and I should instead create a new mixin
mflem has joined #lisp
<shka_>
hmmm
smurfrobot has quit [Ping timeout: 260 seconds]
<shka_>
phoe: yes, it is hard
quazimodo has quit [Ping timeout: 276 seconds]
<on_ion>
protest? pro+test? mixin.. ?
quazimodo has joined #lisp
<phoe>
shka_: what is?
<phoe>
on_ion: PROTEST, my not-so-WIP-anymore library for defining protocols and test cases
<on_ion>
ah cool, figured =)
<on_ion>
i mean that is what i assumed about what it could be
smurfrobot has joined #lisp
tomaw has quit [Read error: Connection reset by peer]
<shka_>
phoe: designing!
tomaw has joined #lisp
<phoe>
shka_: yep, exactly
<phoe>
now the number is up to three mixins
tomaw has quit [Read error: Connection reset by peer]
<phoe>
on_ion: a mixin is a superclass that is meant to be "mixed in" with other superclasses.
<phoe>
Geez, the Quicklisp version of BORDEAUX-THREADS is old.
nowhereman_ has joined #lisp
nowhere_man has quit [Ping timeout: 250 seconds]
warweasle is now known as warweasle_afk
tomaw has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<phoe>
We only overlap when it comes to configuration categories/entries.
<loke>
phoe: Got it
<loke>
phoe: I'll check it out
<phoe>
In PROTEST, a category is not particularly interesting - the category only really exists to be a reference for the programmer, and for having a docstring.
<loke>
(besides, protest is definitely somehting I need. Potato has already changed test frameworks once)
<phoe>
And a configuration entry is essentially what you describe - a value, accessed by a list of keywords.
<loke>
(or was it twice? :-)
<loke>
I have to go to sleep now. I'll check it later.
<phoe>
loke: PROTEST isn't an abstraction over different testing libraries. It still forces you to write tests in a given test library, but it provides mechanisms for generating test cases that are textual descriptions of tests, and therefore independent of given test implementations.
<phoe>
loke: sleep well!
<loke>
phoe: Oh i see :-)
<phoe>
loke: a library abstracting over multiple different testing framework would be a testing framework itself. And we already have enough of these.
quazimodo has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 240 seconds]
nika has quit [Quit: Leaving...]
comborico1611 has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
zaquest_ has quit [Ping timeout: 255 seconds]
ebrasca has left #lisp ["ERC (IRC client for Emacs 25.2.1)"]
comborico1611_ has quit [Ping timeout: 240 seconds]
comborico1611_ has joined #lisp
random-nick has quit [Ping timeout: 260 seconds]
random-nick has joined #lisp
Quetzal2 has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<vtomole>
Why does "(defparameter 1st '(a b c)) (nreverse 1st) (C B A) 1st " return "(A)" and not the reversed list?
Kundry_Wag has quit [Ping timeout: 246 seconds]
<Bike>
nreverse's side effects aren't particularly defined. it returns the reversed list.
trocado has joined #lisp
<sjl>
flip214: nice. haven't seen anyone else using it that I know of
light2yellow has quit [Quit: light2yellow]
bugrum has quit []
damke_ has quit [Ping timeout: 268 seconds]
LiamH has quit [Ping timeout: 250 seconds]
damke_ has joined #lisp
LiamH has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
random-nick has quit [Remote host closed the connection]
trocado has quit [Ping timeout: 240 seconds]
markong has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
margeas has joined #lisp
Kaz has joined #lisp
Mutex7 has joined #lisp
warweasle has quit [Quit: Leaving]
fikka has quit [Ping timeout: 276 seconds]
makomo has joined #lisp
cage_ has quit [Quit: Leaving]
markong has joined #lisp
margeas has quit [Ping timeout: 240 seconds]
pjb has quit [Ping timeout: 256 seconds]
comborico1611 has joined #lisp
comborico1611_ has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
attila_lendvai has joined #lisp
pjb has joined #lisp
comborico1611_ has joined #lisp
<White_Flame>
comborico1611: the Lisp REPL has the full power of source code files. Many other languages don't have that ability
comborico1611 has quit [Ping timeout: 260 seconds]
comborico1611_ is now known as comborico1611
slyrus2 has quit [Quit: slyrus2]
fikka has joined #lisp
comborico1611 has quit [Client Quit]
fikka has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
pierpa has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
random-nick has joined #lisp
fikka has joined #lisp
Pixel_Outlaw has joined #lisp
djole_geo has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
<pjb>
vtomole: it depends on the implementation.
<pjb>
vtomole: in any case, your code is not conforming twice!
<pjb>
vtomole: (defparameter 1st '(a b c)) (nreverse 1st) (equalp 1st '(c b a))
fikka has quit [Ping timeout: 240 seconds]
<pjb>
first (nreverse 1st) is not defined, because nreverse will try to mutate the literal (a b c) returned by quote.
<pjb>
then the mutation itself is not defined, so you can obtain any result for the third expression.
<pjb>
more precisely 1st will still be bound to the same cons cell, but the following cons cells (in the cdr chain), and the elements (in the cars) can be anything.
<pjb>
Notice that in clisp, (equalp 1st '(c b a)) returns true.
<pjb>
vtomole: the correct way to do something like that, if that's what you want to do, would be:
<pjb>
(defparameter *1st* (list 'a 'b 'c)) (setf *1st* (nreverse *1st*)) (equalp *1st* '(c b a))
<pjb>
1- follow the earmuff conventions ALWAYS!
<pjb>
2- don't mutate literal objects.
<pjb>
3- use the result of mutating functions ALWAYS!
marusich has joined #lisp
fikka has joined #lisp
Oladon has quit [Quit: Leaving.]
<vtomole>
pjb: I could use setf with reverse instead. When would i ever need nreverse?
fikka has quit [Ping timeout: 260 seconds]
<Bike>
i think you're confused about what nreverse does
<Bike>
it's just reverse, but also it's allowed to destroy the list
<Bike>
you use it in the same way, like (setf x (nreverse x))
<Bike>
you don't use it for its side effects
<Bike>
allowing it to destroy the list means it can be more efficient, is all
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<pjb>
vtomole: you would use nreverse when you don't need the original cons cells anymore.
<pjb>
Using nreverse then may save allocating new cons cells.
Mutex7 has quit [Quit: Leaving]
Oladon has joined #lisp
<vtomole>
Ah "more efficient". pjb Bike: Thanks
fikka has joined #lisp
<pjb>
vtomole: not more efficient. If you use them when you should not, you will spend more time debugging your code than you will be able to recover ever in processing time.
zxcvz has quit [Quit: zxcvz]
innovati has joined #lisp
fisxoj has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<pjb>
vtomole: basically, the only safe circumstances, is when you're mutating a list that you've just constructed, so you're sure there's no other references to these cons cells. If you use it on function parameters, expect pain.
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Kundry_Wag has joined #lisp
margeas has joined #lisp
markong has quit [Ping timeout: 268 seconds]
comborico1611 has joined #lisp
fikka has joined #lisp
shka_ has quit [Ping timeout: 250 seconds]
random-nick has quit [Remote host closed the connection]
TCZ has joined #lisp
<Kundry_Wag>
Hey, this question uses Clojure but I'm posting it here since it's actually applicable to any Lisp
Karl_Dscc has quit [Remote host closed the connection]
<Kundry_Wag>
I have a question about simulating certain aspects of a type system. There's a Clojure library called Schema that can (among other things) check the inputs of functions. For example, using Schema, one could define a Foo model - basically, a map that has some mandatory keys such as Bar and Baz. So if you define a function to have Foo as input, as in
<Kundry_Wag>
(defn a-function [obj :- models/Foo]
<Kundry_Wag>
(do stuff))
<Kundry_Wag>
then when a-function is called, it'll check if the input matches the declared type.
<Kundry_Wag>
So far, so good.
<Kundry_Wag>
The thing is that if you get `obj` and, say, add other key and value to it with `assoc`, Schema won't complain, as it just checks `a-function` input:
<Kundry_Wag>
That's because Schema can't just guess that the thing we are adding a key/value must remain a Foo (if that's our goal).
<Kundry_Wag>
My question is: is that assumption true? Is technically possible to create a library that if a modified obj is always a Foo inside the function? Perhaps using some magic macrology?
TCZ has quit [Quit: Leaving]
raynold has joined #lisp
<Kundry_Wag>
(sure such library could define a (typed-assoc), but that would be cheating :)
<Kundry_Wag>
(assoc is a Clojure function for adding key/value to a map)
marusich has quit [Quit: Leaving]
<Bike>
assoc /adds/ an association? that's confusing
<Bike>
(defn a-function [obj :- models/Foo] ...) means it takes one argument called obj, which is a Foo?
vlatkoB has quit [Remote host closed the connection]
<Bike>
you'd have to do some pretty fancy stuff, yeah, to essentially use a different function also named 'assoc'
<Bike>
given that you could use a nonconstant key, something would have to be prepared to check validity at runtime.
margeas is now known as markong
LiamH has quit [Ping timeout: 256 seconds]
<Kundry_Wag>
Bike: From the Clojure docs: `When applied to a map, returns a new map of the same (hashed/sorted) type, that contains the mapping of key(s) to val(s).`. So if a-map is {:key1 :value1}, then (assoc a-map :other-key :other-value) would result in {:key1 :value1 :other-key :other-value}
<Bike>
i believe you, that's just not what it's like in lisp, and probably historically.
<Kundry_Wag>
Bike: Yeap, one argument obj, which is a Foo
<Kundry_Wag>
Oh, sure, I was just curious if that would be technically possible
<Kundry_Wag>
Bike: Oh, I see. If I understand correctly, the function definition (defn) could be a macro that would replace the built-in `assoc` to a different version of it
<Bike>
something along those lines.
Jesin has joined #lisp
<Bike>
the trick is you'd have to do that for every possible way to make a new map
<Bike>
relatedly, given that clojure is actually making a new map, the assoc call isn't actually violating the restriction
<Kundry_Wag>
Bike: Yeah, that makes sense
<Bike>
you'd want to define a-function's return type, or use something like lisp's THE to type the value
Arcaelyx has joined #lisp
Arcaelyx has quit [Client Quit]
<Kundry_Wag>
Bike: That's covered by Schema (in Clojure). I didn't know CL had a built-in way to do that, though
smurfrobot has quit [Ping timeout: 264 seconds]
<Bike>
and to be quite honest, rather than having 'alist but restricted to using these keys', i'd probably rather have a class
smurfrobot has joined #lisp
<on_ion>
Classy Lisp
<Bike>
type stuff gets much easier if you restrict the possible restrictions to be easy stuff like that
LiamH has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
smurfrobot has quit [Ping timeout: 256 seconds]
Jesin has quit [Quit: Leaving]
smurfrobot has joined #lisp
<Kundry_Wag>
Bike: Sure. But it think that would be possible in CL because it can mutate the object from the class. Not sure how that would work in Clojure, where you usually apply a pure function and get a new obj, as you noted
<Bike>
does clojure not have structures or classes or something?