<no-defun-allowed>
so aeth for the subset of CL that can be easily compiled to OpenCL and is very parallel i will be very well prepared for too many cores-itis
<tko>
hey guys I'm trying to experiment with CLOS, is it possible to create something like a tagged union / variant / sum type with classes (basically, a class that sometimes has one structure, and sometimes has another; a class that has a certain set of slots at some point, and a different set of slots at another point, all while being of the same type; a class that does this WITHOUT subclassing)? Before you suspect an xy problem here and ask me what I'm trying
<tko>
to implement, no worries, I'm not trying to implement anything but this language feature itself; I am exploring the boundaries of CLOS for its own sake. Thanks so much!
<pjb>
Implement a parallel garbage collector. There several good algorithms in papers…
sjl has quit [Ping timeout: 246 seconds]
<pjb>
tko: using the MOP, it should be feasible. It's probably not a good idea. But possible.
<aeth>
tko: well, in the type system a sum type is just (deftype foo-bar () `(or foo bar))
<pjb>
tko: notice that there's already something much better.
<aeth>
(You can't method dispatch on types, though.)
<pjb>
tko: you can just change the class of an object. You can define shared-initialize and update-instance-for-different-class methods to help convert.
sjl has joined #lisp
<pjb>
tko: this mechanis is also used when you modify the definition of a class (re-evaluate defclass with different slots or options). Old objects are updated to the new class.
<pjb>
with update-instance-for-redefined-class
<tko>
thank you guys so much, one moment as I test all this
v88m has quit [Ping timeout: 268 seconds]
meepdeew has quit [Remote host closed the connection]
P0rkD__ has joined #lisp
linli has quit [Remote host closed the connection]
meepdeew has joined #lisp
X-Scale` has joined #lisp
<aeth>
tko: There's always also the possibility of using the classic alternative to inheritance, which is composition. You can have a class of one slot, which only contains something of class a or class b (and thus (or a b) since a class is also a type). You can even enforce this, although not with :type since a lot of implementations (including SBCL at the default settings) do not check the type. Fairly easy to do in the MOP by adding an assert,
<aeth>
though.
X-Scale has quit [Ping timeout: 258 seconds]
X-Scale` is now known as X-Scale
linli has joined #lisp
P0rkD_ has quit [Ping timeout: 256 seconds]
moldybits` has joined #lisp
<jcowan>
oni-on-ion: The State of Hawaii has a mixture of US and UK flags, reflecting its colonial history
<jcowan>
The elements in your draw-commands example look like structs/instances to me
<jcowan>
(there should be a generic name for structs/instances)
moldybits has quit [Ping timeout: 257 seconds]
<aeth>
tko: In case I was unclear, if you did it the composition way, you would be working with accessors or with with-accessors, and not directly with slot-value or with-slots, but you should never directly work with slots, anyway. It's not even an optimization, it apparently counterintuitively makes things slower.
rumpelszn has joined #lisp
<oni-on-ion>
jcowan, ah cool. and yeah somewhat. doing some declarative structural (geometry for sound and gfx) kind of design atm so it was in my head that way
<tko>
hmm unless I missed something the change-class example is not quite what I wanted to try, as I wanted one class whose body changes while the class stays constant, and this seems to be one identity whose body AND class changes. The composition example would work though, and I'm thinking that might be the proper, lowest level way to do this
<oni-on-ion>
oh just do (setf (class-name .... ))
_leb has quit []
<tko>
well, maybe not the lowest level way to do it
<tko>
probably the lowest level before dropping down into MOP
<tko>
hmm
P0rkD__ is now known as P0rkD
<oni-on-ion>
what is the 'body' of a class, without the rest of the class? aside from name
<oni-on-ion>
err i did not type that correctly
<pjb>
tko: you can have a common superclass for both variants, so you can still have methods dispatching on all variants at once.
<pjb>
tko: but the point again, is that it's a better and safer solution than union types.
<oni-on-ion>
could make your own object system in a couple macros, ofc. but without being clear on what a body of a class is, other than slots or instances, ..
<pjb>
tko: think that in anycase to make safe unions, you need a selector. Here the class itself is the selector.
<oni-on-ion>
as methods do not belong to classes as in traditional OO
<aeth>
tko: if a has slot foo and b has slot bar then you could (defmethod bar ((object a+b)) (etypecase (container object) (a (error "It's an a, not a b.")) (b (bar (container object)))))
<oni-on-ion>
(this is why we have defgeneric *and* defmethod)
<pjb>
tko: there's another way to do it, using structures.
<pjb>
tko: structures can use vectors (or list) to store the data.
<pjb>
tko: so you can define two structures as two variants, and access the same vector.
<aeth>
tko: my method works if you're always using accessors, never slots. In fact, you could encourage that by naming the slot %bar instead of bar.
<aeth>
(Then you'd only be exporting bar, the name of the accessor)
<pjb>
(defstruct (v (:type vector)) a b) (defstruct (u (:type vector)) x y) (let ((a (make-v :a 1 :b 2))) (u-x a)) #| --> 1 |#
<pjb>
then you can have the same bugs as in C.
<pjb>
(almost).
<pjb>
Using the MOP you would do the same, only in a more complex way, within a class.
rumpelszn has quit [Quit: ZNC 1.6.6+deb1ubuntu0.1 - http://znc.in]
<tko>
@oni right so in this case, two bodies under the name of one class is likely useless, in a way losing information; you still have two implementations to dispatch on, two variants as you would with two subclasses, but some information is lost, as both variants no longer have their own type tags, they share a tag. Of course, two structures means any function dealing with the class has two have two implementatoins and hsa to dispatch on which variant you're
<tko>
using, and since some sort of variant tag isn't explicitly stored, it still inevitably has to infer what variant exists somehow, likely from manually checking if a slot exists. But as I mentioned, there is no implementaton goal, as much as exploring CLOS
<tko>
I have been doing some psuedo research on the programming paradigms for a few years
<tko>
and I suppose this is why I would even think about this
<tko>
has to have*
<aeth>
tko: well the easiest thing to do is actually easier than my example and it would just be (defmethod bar ((object a+b)) (bar (container object))) and then if it's not defined (e.g. bar is only defined for b, and not for a) you'd get an error at that moment
makomo has quit [Ping timeout: 244 seconds]
meepdeew has quit [Remote host closed the connection]
<tko>
if that means what I'm thinking it does, that's really cool too :o
<aeth>
tko: (defclass a () ()) (defclass b () ((%bar :accessor bar :initform 42))) (defclass a+b () ((%container :accessor container :initarg :container))) (defmethod bar ((object a+b)) (bar (container object)))
<aeth>
but (bar (make-instance 'a+b :container (make-instance 'a))) is an error
<aeth>
It wouldn't automatically have an accessor for every accessor that a or b has, though, and you would also need to use the MOP to get an enforced type-check on the slot type if you want it to only hold a or b, since :type in a slot definition cannot be relied on.
<aeth>
Then I could :checked-type (or a b) in the slot definition if I add (:metaclass checked-types) at the end of the a+b class definition
q9929t has quit [Quit: q9929t]
meepdeew has quit [Remote host closed the connection]
meepdeew has joined #lisp
quazimodo has quit [Ping timeout: 258 seconds]
quazimodo has joined #lisp
<pjb>
aeth: you're just re-implementing change-class…
<tko>
I have to go for a while, I appreciate all this, I'm gonna continue thinking about some of this while I'm out. I gotta say though that after walking through it here, now I don't know if there's any point to making variants without just subclassing; in a language like haskell at least, it allows you to statically force these two .. subtypes (excuse my vocabulary abuse, I doubt they would ever be called that) together, so that when a function is defined for
<tko>
one, its always defined for the other as well, and is one way uniting two domains in this polymorphic way
<tko>
but in something hyper dynamic like this
<tko>
you just end up losing informatoin
<tko>
you just end up losing informatoin
<tko>
fuck
<tko>
ion*
shifty has joined #lisp
<tko>
at least in a language like haskell, that information is still floating around internally
<tko>
and is used by ..internal language abstractions
<aeth>
pjb: The extra layer of abstraction means that e.g. a reference to (container foo) will remain either a or b, and will not change from one to the other, even if foo changes the item that it is holding, though.
sz0 has quit [Quit: Connection closed for inactivity]
<aeth>
Assuming it's actually a binding, and not with-accessors or another use of symbol-macrolet.
<tko>
are you on here a lot aeth? I don't come on irc very often but I was on here 2 or 3 years ago and I swear your name reminds me of the last person who helped me
<tko>
or maybe it was last year when I was having installation issues
<aeth>
I've probably been here since 2012 or 2013
<tko>
ah ok
<tko>
I'm mostly a Clojure person
<tko>
but I'm still wanting to come over to clisp and experiment with these sort of ultra powerful facilities
<aeth>
CL, not clisp, clisp is an implementation, and a decreasingly popular one as ECL seems to be replacing its niche
<tko>
ah thanks
<tko>
The funny thing the abbrev OOP is strongly associated with a language like Java, but I always think of cl and always come here to explore more oop
<aeth>
static and dynamic OOP are very different things
<pjb>
aeth: superclass!
<tko>
ok I'm delaying this too much be back later
<pjb>
(defclass u () ()) (defclass a (u) ((a :initarg :a :reader u-a))) (defclass b (u) ((b :initarg :b :reader u-b))) (cl:typep (change-class (make-instance 'a :a 42) 'b) 'u) #| --> t |#
khisanth_ has quit [Ping timeout: 258 seconds]
<aeth>
pjb: the challenge was to not use inheritance iirc so that usually means composition (as in a+b has an a or a b, rather than a or b is an a+b)
<oni-on-ion>
subtyping ?
<pjb>
oni-on-ion: forget types.
<oni-on-ion>
sub"classing" sorry.
<pjb>
aeth: Why not inheritance? I didn't see that challenge, can you quote the message?
<pjb>
aeth: furthermore, how much do you think this class u costs?
<oni-on-ion>
if B can do everything A can do, and more, then B can stand in for anything requiring A.
<aeth>
pjb: < tko> hey guys I'm trying to experiment with CLOS, is it possible to create something like a tagged union / variant / sum type with classes ... a class that does this WITHOUT subclassing ...
<pjb>
oni-on-ion: you can better ensure that when you have a common superclass, and methods to do that.
<oni-on-ion>
pjb, right. thats just clarification on "subtyping".
linli has quit [Remote host closed the connection]
<pjb>
aeth: ok, I didn't notice. Sorry. Note that my first solution didn't involve subclassing.
nowhereman has joined #lisp
<pjb>
Having a common superclass is not useful, it's just to answer to some gratuituous objection.
khisanth_ has joined #lisp
<oni-on-ion>
false, it directly relates to: <aeth> pjb: the challenge was to not use inheritance iirc so that usually means composition (as in a+b has an a or a b, rather than a or b is an a+b)
<pjb>
aeth: and again, superclass! Ie. using composition like this is just re-implementing inheritance.
<oni-on-ion>
just said superclass is not useful, then saying.... oh gosh. i'll just watch.
<pjb>
aeth: this is not relevant!
<oni-on-ion>
oh hm.
P0rkD has quit [Remote host closed the connection]
<clothespin>
define a union with cffi, wrap the instance with a struct, finalize the instances, and have two functions, a and b which mem-ref two different types
<pjb>
oni-on-ion: well, it's rethorical: there is always a common superclass: T :-)
<pjb>
aeth: it's silly to avoid inheritance. This is only a problem in C++. Real OO languages don't have any problem with it.
linli has joined #lisp
<oni-on-ion>
pjb, heh =)
<oni-on-ion>
going to have to contemplate that a lil.
<oni-on-ion>
"inheritence" in classic OO is mostly based on *behavior*, not *structure*. and as said before, methods are not associated with classes.
<pjb>
For example, CLOS doesn't forces you to make deep OO hierarchies.
<oni-on-ion>
so "inherit what"
<oni-on-ion>
what is this "body" of a class being spoke of ?
<pjb>
oni-on-ion: I think tko meant the instance variables.
<pjb>
oni-on-ion: people are dumb, they confuse classes for instances.
<oni-on-ion>
pjb, hm, even simpler then -- generic accessor methods =P
<oni-on-ion>
yep! been there myself.
<tko>
yes, the body was referring to the instance variables, the data
<tko>
is that class comment directed at me?
<oni-on-ion>
coincidentally similar conversation in #prolog happening about data structures, where those of C/ML/Java generally design their program starting with the strucure of data. which is a memory layout problem more specific to C and other uninteresting pilgrimages
<pjb>
No, in general.
<tko>
ah gotcha
linli has quit [Ping timeout: 248 seconds]
<oni-on-ion>
write the behavior/code, the structure/data will follow ?
<pjb>
tko: for example, when you see the results of the EU elections, you realize that 99% of the population is dumb.
<tko>
oo are you European?
<pjb>
Yes.
<oni-on-ion>
when we design in classic OO we tend to design the behavior stemming *from* the data structure/memory layout.
<tko>
I am a language enthusiast, is it rude if I ask if you speak another language ?
<pjb>
fr en es + notions of ru pl he de
<pjb>
Once I learned some esperanto.
<oni-on-ion>
neat, shalom
<pjb>
On those elections, there was a list for Esperanto :-)
<tko>
ajajaja tambien tenia que preguntarte porque hablo espanol, y siempre busco otra gente que habla, although as you can see I'm not a native
<pjb>
Now that UK is leaving, it would be good to stop using EN in UE, since no other country has it as official language.
<tko>
I also speak some esperanto, although I've probably forgotten most
<tko>
the nice thing is its very qiuck to pick up
<tko>
especially since I speak two european languages
<oni-on-ion>
wait wait, UK leaving EU ?
<tko>
granted, I'm terrible in one of those languages
<pjb>
On October normally.
<tko>
but the point is, it makes it so easy because it feels like if sometihng isn't from english its similar to the spanish version
<oni-on-ion>
des that mean pounds
<pjb>
Otherwise the brexit party will win the next general elections and do it itself.
<pjb>
Anyways, this is #lisp, let's go back to CL.
<tko>
and @oni yea I'm coming from a functional background, even now its hard for me not to see classes as just data with a tag (the type) that can be used to both state the intention of the data, but also to dispatch on different data with multimethods
rumpelszn has joined #lisp
<tko>
also, the principle of, instead of having one big open .. "namespace" of functions, where you can use any function defined for a data type on that data type, I view OOP as having the principle of making these sort of layers of namespaces ( I am probably abusing that word as usual)
<tko>
the first layer of course are the getters and setters for the data
<tko>
then there will often be another layer where only that layer can operate with these primitives
<pjb>
lisp tends to be more orthogonal. Namespaces are defined with packages, and are totally unrelated to anything else.
<tko>
in general I like to keep all these ideas decoupled; namespaces, data, functions
<tko>
objects in other languages often feel like everything is forced to always be wrapped together
<pjb>
similarly, classes define a data structure (with accessors) but methods are not attached to classes. Instead methods are attached to generic functions.
<pjb>
tko: so you'll be happy with lisp.
<tko>
another feature often attributed to OOP i tihnk is being able to write something like "cat.meow.first"
<tko>
but to me this is just a synctactical feature
<pjb>
indeed.
<tko>
and not even a thing for a lisp
<tko>
where the syntax is fluid
<tko>
this is just composition syntax
<oni-on-ion>
tko, ease yourself in with plain lists/tuples. dont worry about complex data structures until you have to
<tko>
as I mention in particular I have been using these languages to analyze the paradigms for a few years
<oni-on-ion>
ah, you said 'from functional'
<tko>
yea I can see how that sounded
<tko>
my primary programming is still functional / clojure
<tko>
and so I often might use that as my first 'lens' for looking at sometihng
<tko>
regardless, I've been tinkering with these things for 2 decades ahaha
<tko>
for a while though what you said sounds like a big part of what I've been exploring; staying primitive and knowing exactly when you do need to add the abstractions known as OOP
<tko>
inheritance is also a big thing I've been cracking on, hence this seemingly obscure exercise
alca has quit [Ping timeout: 246 seconds]
john2x has joined #lisp
<tko>
tinkering with progrmaming* not the paradigm stuff
<tko>
I've been analyzing the paradigms on and off for about 4 years probably
moei has joined #lisp
<tko>
I've been working with simple data structures and functions again for so long now though I really want to make something meaty with CLOS
<tko>
and thankfully it doesn't bind the functions to the objects
rksm has joined #lisp
<tko>
so in some respects its already the sort of thing I like
<tko>
(ok I'm possibly going again, thanks for listening to my rambles ahahah)
t58 has quit [Quit: Night]
drainful has joined #lisp
quazimodo has quit [Ping timeout: 246 seconds]
quazimodo has joined #lisp
drainful has quit [Quit: Using Circe, the loveliest of all IRC clients]
drainful has joined #lisp
alca has joined #lisp
tko has quit [Quit: Konversation terminated!]
tko has joined #lisp
_leb has joined #lisp
tko has quit [Ping timeout: 272 seconds]
<aeth>
I actually wonder if you can get something like interfaces in a world where methods don't live with the classes. It's afaik basically just a way to ensure that e.g. a drawable class defines a draw method, but the near-trivial metaclass way can probably only really go as far as ensuring that certain accessors are defined in the defclass itself, which seems like an arbitrary, artificial restriction.
oni-on-ion has quit [Remote host closed the connection]
<aeth>
Maybe it could enforce a (closer-mop:compute-applicable-methods-using-classes #'foo (list class-name)) check in the same file of the defclass for class-name, which is stricter than necessary, but perhaps doable
oni-on-ion has joined #lisp
rksm has quit [Quit: Page closed]
pfdietz has quit [Ping timeout: 256 seconds]
zotan has quit [Ping timeout: 272 seconds]
zotan has joined #lisp
iqubic has joined #lisp
iqubic has left #lisp ["ERC (IRC client for Emacs 26.1)"]
iqubic has joined #lisp
iqubic has left #lisp ["ERC (IRC client for Emacs 26.1)"]
iqubic has joined #lisp
<iqubic>
Can anyone see this?
<ebrasca>
iqubic: what?
<iqubic>
Just testing out ERC modifications.
<no-defun-allowed>
Well, you haven't broken anything.
<pjb>
aeth: interfaces are just a set of defgeneric.
moldybits` has quit [Quit: WeeChat 2.4]
meepdeew has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 245 seconds]
iqubic has left #lisp ["ERC (IRC client for Emacs 26.1)"]
P0rkD has quit [Remote host closed the connection]
CCDelivery has joined #lisp
CCDelivery has left #lisp ["Leaving"]
meepdeew has joined #lisp
Bike has joined #lisp
P0rkD has joined #lisp
meepdeew has quit [Ping timeout: 248 seconds]
q-u-a-n2 has quit [Ping timeout: 244 seconds]
<aeth>
pjb: I think that there is some expectation of being able to verify it somewhere, though. And ideally without a satisfies type.
meepdeew has joined #lisp
<aeth>
So I'm guessing that the verification would have to happen at the compilation-unit or file level.
ebrasca has quit [Remote host closed the connection]
cronolio has left #lisp [#lisp]
tko has joined #lisp
P0rkD is now known as p0rkd
drainful has quit [Ping timeout: 246 seconds]
dacoda has joined #lisp
caltelt_ has joined #lisp
caltelt has quit [Ping timeout: 248 seconds]
dddddd has quit [Remote host closed the connection]
p0rkd has quit [Remote host closed the connection]
meepdeew has quit [Ping timeout: 268 seconds]
gravicappa has joined #lisp
p0rkd has joined #lisp
tko has quit [Ping timeout: 252 seconds]
linack has joined #lisp
meepdeew has joined #lisp
krwq has joined #lisp
meepdeew has quit [Ping timeout: 248 seconds]
Arcaelyx has quit [Ping timeout: 244 seconds]
meepdeew has joined #lisp
tko has joined #lisp
tko has quit [Client Quit]
tko has joined #lisp
meepdeew has quit [Ping timeout: 268 seconds]
tko has quit [Ping timeout: 248 seconds]
meepdeew has joined #lisp
<beach>
Good morning everyone!
meepdeew has quit [Remote host closed the connection]
meepdeew has joined #lisp
<asarch>
GLUT for C defines some keys values (GLUT_KEY_F5), when I try to use them I get: caught WARNING: Constant :KEY-F5 conflicts with its asserted type NUMBER. See also: The SBCL Manual, Node "Handling of Types". What does it mean?
dacoda has quit [Read error: No route to host]
nanoz has joined #lisp
tko has joined #lisp
tko has quit [Read error: No route to host]
v88m has joined #lisp
dacoda has joined #lisp
meepdeew has quit [Remote host closed the connection]
vlatkoB has joined #lisp
Lycurgus has joined #lisp
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
P0rkD_ has joined #lisp
p0rkd has quit [Remote host closed the connection]
P0rkD_ is now known as P0rkD
femi has quit [Quit: ZNC 1.6.6+deb1ubuntu0.1 - http://znc.in]
karlosz has joined #lisp
Bike has quit [Quit: Lost terminal]
Arcaelyx has joined #lisp
<oni-on-ion>
asarch, there may be something in cl-glut which translates :KEY_F5 to a NUMBER
karlosz has quit [Ping timeout: 250 seconds]
esrse has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
steiner has joined #lisp
caltelt_ has quit [Ping timeout: 258 seconds]
john2x has quit [Read error: Connection reset by peer]
john2x has joined #lisp
<asarch>
Actually, the problem was with the (=) function. I should use (eq key :key-f5)
<asarch>
So far, so good. I can see the wired teapod on my application
<asarch>
*teapot
<asarch>
I got answer from one of the main developers about the callback functions today
<aeth>
Essentially, fiveam can raise a condition on *every* test, so I have it do that, and then ignore them for the moment, but if it happened at all, then I return a nonzero error code, which means that the Gitlab CI will declare that the test run was a failure. SBCL only at the moment. And the file itself is a bit of a mess because it's just a script run by the CI
<aeth>
no, I think because it's a separate file uiop will probably be loaded by that point
<aeth>
If it's a dependency, at least.
<aeth>
You do have to quickload UIOP at some point even though it's already present because loading uiop gives you the new version. The old version can be very old, e.g. mine doesn't have launch-program
<aeth>
Well, at one point it didn't. It does now.
<aeth>
Although, actually, UIOP does that weird hackish upgrade thing so as long as the symbol is already present, it probably shouldn't cause problems.
_leb has quit []
meepdeew has joined #lisp
<aeth>
no-defun-allowed: hmm, yeah, I don't get an error with the symbol uiop:quit because UIOP is already present. Thanks!
<no-defun-allowed>
np
nanoz has quit [Ping timeout: 272 seconds]
meepdeew has quit [Remote host closed the connection]
shifty has quit [Remote host closed the connection]
shifty has joined #lisp
varjag has joined #lisp
JohnMS_WORK has joined #lisp
shka_ has joined #lisp
libertyprime has quit [Ping timeout: 258 seconds]
donotturnoff has joined #lisp
kajo has quit [Ping timeout: 272 seconds]
steiner has quit [Remote host closed the connection]
schweers has joined #lisp
GoldRin has quit [Ping timeout: 268 seconds]
<asarch>
What is Alexandria?
nowhereman has quit [Ping timeout: 268 seconds]
<flip214>
asarch: a library with quite a few often used functions and macros.
<no-defun-allowed>
not in CL, but it's expected to be used a lot
<asarch>
I'm trying to create the menu with (glut:create-menu). The source code say this function is actually: (defcfun ("glutCreateMenu" create-menu) :int (callback :pointer)). The C function actually is: int glutCreateMenu(void (*func)(int value));. If I try to do: (glut:create-menu 1) I get: The value 1 is not of type SB-SYS:SYSTEM-AREA-POINTER when binding SB-ALIEN::VALUE.
<asarch>
What is a SB-SYS:SYSTEM-AREA-POINTER value? Is it a constant?
<flip214>
asarch: a low-level pointer, like in C.
<flip214>
asarch: create-menu wants a :pointer CALLBACK as argument, not an integer.
<flip214>
an integer is what it returns.
<phoe>
void(*func)(int value) is a C function pointer
<phoe>
it is a pointer to a function that accepts an int and returns void
<no-defun-allowed>
You need a function that returns an int I think.
<phoe>
define a proper callback using (CFFI:DEFCALLBACK FOO ...) and pass (cffi:callback foo) to that function
<no-defun-allowed>
s-a-p is a pointer, basically.
<phoe>
^
<flip214>
^^
<no-defun-allowed>
^-^
<asarch>
How do you do a pointer in Common Lisp?
<phoe>
asarch: a pointer to what exactly?
<asarch>
#'(lambda () ...)
<phoe>
DEFCALLBACK
<asarch>
(defcallback foo () ...)?
<phoe>
You need to explicitly define a function that is callable from C. Normal Lisp functions aren't.
<jackdaniel>
(integer 0 1), (integer 0 2), (integer 0 3) – I can go on all day
<phoe>
asarch: that's the return type of the cfun
<aeth>
you can also do (or (integer 0) (integer 1) ...)
<aeth>
quite a few ways to get infinite types
P0rkD has quit [Remote host closed the connection]
P0rkD_ has joined #lisp
<phoe>
CFFI must know the type of the data that the C function returns, that's why you specify that it's an :int which means that C will return an int there
cosimone has joined #lisp
<jackdaniel>
don't get me wrong, CL has only (integer …) type, no more of them types ;-)
<asarch>
I thought that (let (foo) ...) 'foo' was like a void pointer in C (they can hold anything at all)
scymtym has joined #lisp
<jackdaniel>
asarch: in common lisp variables are not typed, only values
<jackdaniel>
foo is a binding with a value NIL
dddddd has joined #lisp
<jackdaniel>
(which is of type NULL(!))
<jackdaniel>
you can think about variables as pointers, sure, but it is just bringing confusion from C world to Lisp
<jackdaniel>
think about variables as boxes which hold values, you may put in such box anything you want and use it however you want
<no-defun-allowed>
error 5 is SSL_ERROR_SYSCALL, what the hell
sr5h has quit [Ping timeout: 246 seconds]
<flip214>
no-defun-allowed: what OS, what arch are you on?
<no-defun-allowed>
Arch Linux, x86_64
<no-defun-allowed>
apparently i can get something from errno
<flip214>
$ perl -e 'print $!=shift,"\n"' 5
<flip214>
Input/output error
P0rkD__ has joined #lisp
P0rkD_ has quit [Remote host closed the connection]
<no-defun-allowed>
and nothing from perror, great
keep_learning_M has joined #lisp
<no-defun-allowed>
maybe it's the client being silly now actually
<no-defun-allowed>
`error:140943FC:SSL routines:ssl3_read_bytes:sslv3 alert bad record mac` oh god
<no-defun-allowed>
more work for tommorow then
heisig has joined #lisp
nowhereman has joined #lisp
ricekrispie has quit [Ping timeout: 258 seconds]
tko has joined #lisp
nowhereman has quit [Ping timeout: 248 seconds]
tko has quit [Ping timeout: 276 seconds]
<schweers>
Are there established ways (libraries?) to iterate over various things? I’m thinking of vectors and lines of a file or the lines from a process output.
<jackdaniel>
schweers: series gives you magic like that
<jackdaniel>
but it is quite non-composable with anything else
<schweers>
hmm. I never really got series to work without spewing warnings all over the place, but maybe I should give it another chance.
papachan has joined #lisp
<heisig>
schweers: You can implement the Python iterator protocol with just a few lines of Lisp code.
<heisig>
But I very much prefer map-over-XYZ functions.
<schweers>
heisig: I know that it isn’t too difficult or a lot of work to do. I still wanted to know whether such a library already exists which is widely used.
<schweers>
I normally can also very well do without. But now I feel I have the need for something more abstract.
tko has joined #lisp
<heisig>
schweers: If you need the laziness, delaying the evaluation with (lambda () FORM) usually works fine.
<heisig>
Otherwise, I'd just write dedicated map-simple-vector, map-lines, etc. functions.
<schweers>
I’m actually not even sure I really need lazyness.
<jackdaniel>
delimited continuations would allow writing lazy generators
<jackdaniel>
masło maślane
<jackdaniel>
s/lazy generators/generators/
<schweers>
jackdaniel: do you actually use series?
iovec has joined #lisp
<jackdaniel>
I've used it for a week or so, then I've decided that despite how cool they are they are (as I said) hardly composable with other cl constructs
<jackdaniel>
so I've settled with other loop constructs
<schweers>
I tried using them too, but I had the problem that I couldn’t split large expressions into smaller ones without them becoming really inefficient and emitting loads of warnings.
<schweers>
So have I for the most part.
<schweers>
I’d love for loop to be portably extensible
<dim>
(cl-csv:read-csv-row "a,\"b\",\N,c" :separator #\, :quote #\" :escape "\\" :escape-mode :forward) gives ("a" "\"b\"" "N" "c") and I don't think the third column is correct, I would think it should keep the backslash in there and return \N
<p9fn>
"\N" evals to "N" though, you need "\\N" in your literal?
karayan has joined #lisp
<dim>
nope, when processing CSV files you don't usually have the luxury of picking the input format, that's where it gets “interesting”
<p9fn>
but it's not a file it's a string literal...
<p9fn>
and it just has an "N" in it.
<dim>
yeah I constructed a minimal example to make it easy to reproduce and understand
<Bike>
read-csv-row doesn't see "\N", so it can't keep it
<dim>
so you're saying that "\N" in CL is the same as "N" and I should input \N as "\\N", is that right?
<Bike>
well, yes.
<Bike>
try just putting "\N" in your repl
<dim>
ok another good ocasion for me to feel stupid ;-)
<Bike>
(equal "\N" "N") => T
<dim>
thanks guys
zigpaw has quit [Remote host closed the connection]
<dim>
(for the lesson, the feeling, that's on me)
<dim>
so it appears that my undestanding of the “bug” is totally off then
<jackdaniel>
I don't remember details but there *is* a problem in cl-csv with regard to backslash
<_death>
"If a single escape character is seen, the single escape character is discarded, the next character is accumulated, and accumulation continues."
<jackdaniel>
and it doesn't have much to do with lisp reader
<jackdaniel>
happens with input which doesn't come from it
longshi has quit [Ping timeout: 272 seconds]
<jackdaniel>
and it was introduced at some point of time (i.e older version of cl-csv does not have the problem)
<dim>
in that pgloader issue the data is a CSV file produced from MySQL, I don't know which tooling has been used
<dim>
we did some back&forth with cl-csv guys around problems I had for some pgloader users with very strange CSV specifications / needs
<dim>
CSV is quite horrible as a non-defined format bag of non-deterministic things
linli has joined #lisp
longshi has joined #lisp
linli has quit [Ping timeout: 245 seconds]
LiamH has joined #lisp
libertyprime has quit [Ping timeout: 248 seconds]
longshi has quit [Ping timeout: 268 seconds]
karayan has quit [Ping timeout: 256 seconds]
amerlyq has quit [Quit: amerlyq]
karayan has joined #lisp
cosimone has joined #lisp
lavaflow has joined #lisp
longshi has joined #lisp
<pjb>
dim: there's a RFC to fix some specific specifications of the CSV format.
<pjb>
Now, of course, you might have to read Microsoft CSV instead… Have fun.
warweasle has joined #lisp
longshi has quit [Ping timeout: 258 seconds]
P0rkD_ has joined #lisp
P0rkD__ has quit [Remote host closed the connection]
libertyprime has joined #lisp
lavaflow has quit [Ping timeout: 272 seconds]
brundleticks has joined #lisp
admich has joined #lisp
brundleticks has quit [Remote host closed the connection]
Inline has joined #lisp
kajo has quit [Ping timeout: 246 seconds]
kajo has joined #lisp
abarbosa has joined #lisp
P0rkD_ has quit [Remote host closed the connection]
amerlyq has joined #lisp
P0rkD_ has joined #lisp
grewal has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 244 seconds]
t58 has joined #lisp
lemoinem is now known as Guest13393
Guest13393 has quit [Killed (hitchcock.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
admich has quit [Quit: ERC (IRC client for Emacs 26.2)]
tko has quit [Ping timeout: 268 seconds]
v88m has quit [Ping timeout: 258 seconds]
<dim>
well my approach to CSV is a little different, I ship pgloader and people are using it with the files they have, which means I don't get to see the files, ever, and am not in a position to chosse or influence the details of the format
tko has joined #lisp
<dim>
cl-csv has grown enough parameters to read many different kinds of CSV and pgloader allows its users to tweak those, so that's pretty good, though sometimes I have issues opened on GitHub where they have strange input and there's no set of parameters that makes sense
jkordani has joined #lisp
<dim>
when you have to deal with one specific CSV files you can always hack your own specialized parser anyway, that's “easy” enough
cosimone has quit [Quit: WeeChat 2.3]
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
sjl_ has joined #lisp
sjl_ has quit [Client Quit]
heisig has quit [Quit: Leaving]
sjl_ has joined #lisp
maxxcan has joined #lisp
karayan has quit [Quit: Page closed]
jprajzne has quit [Remote host closed the connection]
grewal has joined #lisp
kajo has joined #lisp
elinow has joined #lisp
libertyprime has quit [Ping timeout: 258 seconds]
FreeBirdLjj has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
dale_ has joined #lisp
dale_ is now known as dale
maxxcan has quit [Quit: maxxcan]
rippa has joined #lisp
edgar-rft has quit [Quit: Leaving]
q9929t has joined #lisp
q9929t has quit [Quit: q9929t]
orivej has joined #lisp
t58 has quit [Quit: Leaving]
moldybits has joined #lisp
X-Scale` has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
tko has quit [Ping timeout: 272 seconds]
papachan has quit [Quit: Saliendo]
aindilis has quit [Remote host closed the connection]
tko has joined #lisp
aindilis has joined #lisp
P0rkD__ has joined #lisp
P0rkD_ has quit [Remote host closed the connection]
dpl has quit [Read error: Connection reset by peer]
longshi has joined #lisp
tko has quit [Ping timeout: 252 seconds]
tko has joined #lisp
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
<jcowan>
dim: Not so easy, I'm writing one now. You can't just read line by line; you have to parse it as a syntax.
<dim>
oh yeah most CSV files are more interesting that (loop for line = (read-line stream nil nil) for fields = (split-sequence #\Tab line) do ...)
<jcowan>
Alas, yes, unless you control the other end.
<dim>
well if you control the other end, why would you use CSV?!
<jcowan>
Does sbcl provide access to clock_gettime(), at least when it's available?
<jcowan>
Because you may wish to export your (clean) CSVs to others.
<dim>
if you need a text based format that's easy to parse and well defined, have a look at the COPY format of Postgres, it's pretty nice, very easy to parse, wekk defined and documented
<jcowan>
Easier to parse than XML, more widespread than JSON Sequence
clothespin has quit [Read error: Connection reset by peer]
<dim>
jsonlines looks good
<mfiano>
to be fair, quicklisp distinfo, system, release metadata is space separated values
FreeBirdLjj has quit [Remote host closed the connection]
<jcowan>
Okay, looks like a variant of DSV format.
keep_learning_M has quit [Quit: This computer has gone to sleep]
P0rkD__ is now known as P0rkD
<dim>
the most common separator in CSV files in Tab ;-)
iovec has joined #lisp
<jcowan>
But for a "well defined" format, it has way too many options: column delimiter, NULL representative, and character encoding. Decoding will be a pain. Also, there is no way to represent Unicode characters in non-Unicode (esp. pure ASCII) format.
<jcowan>
you can only get up to U+00FF with the escape mechanism.
hiroaki has quit [Ping timeout: 268 seconds]
<jcowan>
I grant that CSV has even more options, but still.
manualcrank has joined #lisp
rixard has joined #lisp
elinow has quit [Read error: Connection reset by peer]
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
hhdave has quit [Ping timeout: 245 seconds]
tko has quit [Quit: Konversation terminated!]
tko has joined #lisp
<aeth>
This problem was almost solved a long time ago with the 1C, 1D, 1E, and 1F ASCII characters. If they were printable as FS GS RS and US like ␜ (241C) in Unicode then they'd be an obvious choice.
hiroaki has joined #lisp
<aeth>
(Of course, that prints horribly in my IRC terminal, but if people used it, then it would have a better representation in fonts.)
nanoz has joined #lisp
ggole has quit [Quit: Leaving]
leb has joined #lisp
<aeth>
What's funny is that if you wanted nonconfigurable separator characters that are far rarer than commas, it would probably be better imo to use the characters in Unicode that stand for symbols for the separators than the actual separators
<Fade>
U+3000 is 'ideographic space', which would map semantically.
<Fade>
though I guess it'd short change chinese, japanese, and korean.
nanoz has quit [Read error: Connection reset by peer]
nowhereman has joined #lisp
lavaflow has joined #lisp
nanoz has joined #lisp
nowhereman has quit [Ping timeout: 246 seconds]
m00natic has quit [Remote host closed the connection]
tko has quit [Ping timeout: 248 seconds]
tko has joined #lisp
dkmueller has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
zigpaw has joined #lisp
<pjb>
dim: so why is it called COMMA SEPARATED VALUES?
<aeth>
It started with commas (and spaces, apparently, according to Wikipedia), but those are obviously too common to *not* make it configurable.
dkmueller has quit [Read error: Connection reset by peer]
dkmueller has joined #lisp
ricekrispie has joined #lisp
scymtym has quit [Ping timeout: 248 seconds]
dkmueller has quit [Quit: WeeChat 1.6]
abarbosa has quit [Remote host closed the connection]
dkmueller has joined #lisp
dkmueller has quit [Client Quit]
cosimone has joined #lisp
hiroaki has quit [Read error: Connection reset by peer]
hiroaki has joined #lisp
<shka_>
yo
<shka_>
i have a question regarding default values of optional and key arguments
<shka_>
what is the precise evaluation rule for those?
abarbosa has joined #lisp
<shka_>
is it always evaluated from start, or can evaluated value be shared somehow?
<jcowan>
Even Bob Bemer can't win 'em all. \, yes; xS control characters, no.
kajo has quit [Ping timeout: 252 seconds]
dkmueller has joined #lisp
rixard has quit [Quit: (eq status leaving) T]
dkmueller has quit [Client Quit]
ebrasca has joined #lisp
<Bike>
shka_: "from start"?
<Bike>
shka_: i mean, they're evaluated left to right?
<Bike>
and you can do things like (x &optional (y x))
<shka_>
Bike: i was wondering about (size &optional (vector (make-array size :adjustable t :fill-pointer 0))
pankajgodbole has quit [Ping timeout: 258 seconds]
<Bike>
yeah, that's okay.
<shka_>
ok, in that case i know where to look for my bug, thanks for help!
<Bike>
"An init-form can be any form. Whenever any init-form is evaluated for any parameter specifier, that form may refer to any parameter variable to the left of the specifier in which the init-form appears, including any supplied-p-parameter variables, and may rely on the fact that no other parameter variable has yet been bound (including its own parameter variable)."
sauvin has quit [Read error: Connection reset by peer]
cosimone has quit [Quit: WeeChat 2.3]
gareppa has joined #lisp
grewal has quit [Ping timeout: 272 seconds]
donotturnoff has quit [Ping timeout: 245 seconds]
gareppa has quit [Remote host closed the connection]
edgar-rft has joined #lisp
P0rkD has quit [Remote host closed the connection]
kajo has joined #lisp
t58 has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
nirved_ has joined #lisp
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
nirved has quit [Ping timeout: 258 seconds]
shifty has quit [Ping timeout: 268 seconds]
ravenousmoose has joined #lisp
<Xach>
/win 3
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
lnostdal has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
<makomo>
flip214: i don't think i have the permission to merge?
<makomo>
don't i have to be a maintainer or something?
grewal has joined #lisp
gareppa has joined #lisp
lnostdal has joined #lisp
grewal has quit [Ping timeout: 252 seconds]
cosimone has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
beach has quit [Ping timeout: 258 seconds]
clothespin has joined #lisp
nowhereman has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Jesin has quit [Quit: Leaving]
CEnnis91 has quit [Quit: Connection closed for inactivity]
sjl_ has quit [Quit: WeeChat 2.3-dev]
syntaxfree has joined #lisp
<dim>
pjb: I wish I knew
nanoz has quit [Ping timeout: 244 seconds]
<syntaxfree>
I'd been writing an interpreter for a small pseudolanguage in Python using a library called Lark. It's able to read an EBNF grammar format and generate a syntax tree.
<syntaxfree>
I was looking for something similar in the common lisp world, but many links I find are orphaned.
<pjb>
For example, (ql:quickload :esrap-peg) works.
<pjb>
(loads something)
<dim>
it's already in Quicklisp nowadays
<aeth>
syntaxfree: the problem here is that most small pseudolanguages in CL are embedded in CL via (non-reader) macros, so BNF is used a lot less than in other languages
<Xach>
cl-abnf is very very cool
Jesin has joined #lisp
sjl_ has joined #lisp
<dim>
thanks!
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<syntaxfree>
eh. thanks for the suggestions.
tko has quit [Ping timeout: 246 seconds]
lucasb has joined #lisp
igemnace has quit [Quit: WeeChat 2.4]
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
eschatologist has quit [Ping timeout: 258 seconds]
eschatologist has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
gareppa has quit [Quit: Leaving]
akoana has joined #lisp
kajo has joined #lisp
_death has quit [Ping timeout: 268 seconds]
nowhereman has quit [Ping timeout: 258 seconds]
shka_ has quit [Ping timeout: 268 seconds]
asarch has joined #lisp
P0rkD has joined #lisp
ym555 has joined #lisp
amerlyq has quit [Quit: amerlyq]
abarbosa has quit [Remote host closed the connection]
john2x has joined #lisp
ebrasca has quit [Remote host closed the connection]
meepdeew has joined #lisp
LiamH has quit [Quit: Leaving.]
Bike has quit []
zotan has quit [Ping timeout: 248 seconds]
_death has joined #lisp
zotan has joined #lisp
Jesin has quit [Quit: Leaving]
moei has quit [Quit: Leaving...]
abarbosa has joined #lisp
Jesin has joined #lisp
vhost- has joined #lisp
P0rkD has quit [Remote host closed the connection]
makomo has quit [Ping timeout: 248 seconds]
Lord_of_Life_ has joined #lisp
meepdeew has quit [Remote host closed the connection]
cpc26 has quit []
Lord_of_Life has quit [Ping timeout: 248 seconds]
Lord_of_Life_ is now known as Lord_of_Life
varjagg has quit [Ping timeout: 248 seconds]
sjl_ has quit [Quit: WeeChat 2.3-dev]
caltelt has joined #lisp
wxie has joined #lisp
nowhereman has joined #lisp
cpc26 has joined #lisp
hiroaki has quit [Ping timeout: 250 seconds]
nowhereman has quit [Ping timeout: 258 seconds]
Bike has joined #lisp
john2x has quit [Ping timeout: 268 seconds]
terpri has joined #lisp
asarch has quit [Quit: Leaving]
orivej has joined #lisp
cosimone has quit [Ping timeout: 252 seconds]
keep_learning_M has joined #lisp
wxie has quit [Quit: wxie]
pillton has quit [Read error: Connection reset by peer]
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
cpc26 has quit [Remote host closed the connection]