<no-defun-allowed>
Well, they do match so it does return both values.
<LdBeth>
If the type matches, the same number of values is returned, yes
dannyboy35 has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
afidegnum has quit [Quit: Lost terminal]
<aoeu256>
err, anybody used program synthesis? Do you guys think that program synthesis can help newbies learn Lisp or Haskell, and maybe even help right correct programs? www.youtube.com/watch?v=OyfBQmvr2Hc&t=1h20m45s
zhlyg has joined #lisp
<parjanya>
Hi all!
<parjanya>
I’m having a... conceptual problem. I want to be able to describe words with their components, like "wolves" being the word/stem "word", a noun, having the "-s", an ending, as the plural marker. So I would create objects of some kind for "wolf" and "-s", and create an object "wolves" by linking the first two to it. Not every object/morpheme has the same slots, so it seems I need to create different kinds of object
<parjanya>
s for them.
<parjanya>
In theory just a plist should do, but if I end up having /many/ of them, I fear it will be too memory-intensive. Many entries would look the same but be different, like "checks" as a verb and as a noun, so the mere surface form wouldn’t be enough to individualize them... in a hashtable, for instance. It looks like a job for CLOS, which I never used so far, but perhaps structs are good enough for these.
<parjanya>
The idea is first to be able to describe words, then parse new ones automatically, and show this as a commentary to a text, for instance. It would also be a good start for a dictionary. Any suggestions? This is bound to have been done before, but all my chasing and duckduckgoing was in vain so far.
<parjanya>
(sorry for the flooding)
dave0 has quit [Quit: dave's not here]
<LdBeth>
parjanya: you can try to figure out some popular data structures used in natural language processing such as tie or DAG
<LdBeth>
And yes you have to lookup CLOS because it’s a pain to implement complex data structures with only lists and structs
dddddd has quit [Remote host closed the connection]
dannyboy35 has quit [Remote host closed the connection]
<aoeu256>
can't you just gethash on the last few letters of each word?
<LdBeth>
I’m not an expert of English but I’m afraid there could be some case not handled by this approach
<LdBeth>
Given that English is notorious in irregular
<aoeu256>
if it fails the first gethash on the ending then it would do a gethash on a 90,000 word hash
<aoeu256>
never mind someone already implemented it
<aoeu256>
this program synthesis thing looks very interesting though, it could help with hard static functional languages like haskell...
<parjanya>
well, I’m thinking about this to describe Lithuanian... at first, and Sanskrit perhaps; it gets complicated quite fast, like "aśvayati" "aśva-" means horse, the "-aya-" makes a verb out of a noun, then -ti is the 3rd person singular for the present active tense ; )... this recursion is important, ((("aśva") "aya") "ti")
lemoinem has quit [Killed (barjavel.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
liberiga has joined #lisp
slyrus1 has joined #lisp
slyrus_ has joined #lisp
<LdBeth>
So with something like a DAG you can do sharing a lot and still get decent performance on searching
<parjanya>
and my example of "checks", the last -s as a verb is quite different from the -s as a verb
<parjanya>
will check :) tx!
slyrus2 has quit [Ping timeout: 246 seconds]
slyrus__ has quit [Ping timeout: 244 seconds]
<LdBeth>
aoeu256: about program synthesis, it’s roughly equivalent to automated theory proving and it’s still far to be adopted by general programmers
Frobozz has joined #lisp
torbo has quit [Remote host closed the connection]
liberiga has quit [Ping timeout: 260 seconds]
Bike has quit [Quit: Lost terminal]
sahara3 has quit [Ping timeout: 268 seconds]
igemnace has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<beach>
Good morning everyone!
<aoeu256>
morning
count3rmeasure has joined #lisp
sindan has quit [Remote host closed the connection]
sindan has joined #lisp
<parjanya>
morning!
aoeu256 has quit [Ping timeout: 268 seconds]
hiroaki has quit [Ping timeout: 272 seconds]
Arcaelyx has quit [Ping timeout: 245 seconds]
ltriant has quit [Ping timeout: 245 seconds]
ltriant has joined #lisp
sonologico has quit [Remote host closed the connection]
SaganMan has joined #lisp
shka_ has joined #lisp
Lord_Nightmare has quit [Ping timeout: 244 seconds]
<count3rmeasure>
good morning!
count3rmeasure has quit [Quit: Leaving]
<alexanderbarbosa>
:D
asarch has quit [Quit: Leaving]
nanoz has joined #lisp
flamebeard has joined #lisp
Lycurgus has quit [Quit: Exeunt]
slightlycyborg has joined #lisp
<slightlycyborg>
Where is the best place to define code that I always want access to, like my own std lib...?
<slightlycyborg>
Would be cool to add code to :cl
<beach>
slightlycyborg: ~/quicklisp/local-projects is good.
<slightlycyborg>
Ok. That is a good idea. Thanks beach
<beach>
Sur.e
<beach>
er, sure.
vlatkoB has joined #lisp
<beach>
I put symbolic links there myself.
varjag has joined #lisp
jprajzne has joined #lisp
kajo has joined #lisp
<beach>
slightlycyborg: What do you mean by "add code to :cl"?
<slightlycyborg>
I just wanted something that would be always included with all of my sessions. I am just defining a system called "stdlib" which I will import in all my projects. If I ever publish my projects I'll rename it to something sensible
<no-defun-allowed>
You probably shouldn't try to modify the CL package ever.
<shka_>
maybe adding something in sbclrc would work
<shka_>
no-defun-allowed: you can try, you can't
<no-defun-allowed>
Exactly.
<White_Flame>
oh, I have. But i wouldn't recommend i
<White_Flame>
(ie, you can unlock locked packages, depending on the implementation)
<beach>
slightlycyborg: The good way of doing that is to list your system in the :depends-on list in your ASDF systems.
dave0 has joined #lisp
<White_Flame>
slightlycyborg: but in any case, you tend to use packages including COMMON-LISP, so adding your own lib doesn't take any real extra effort
<shka_>
White_Flame: oh, cool, i didn't knew about that
<White_Flame>
I once redefined #'EQUAL to keep string comparisons case-sensitive, while still deeply traversing other composite types
<White_Flame>
by literally trampling the CL:EQUAL definition
<shka_>
you crazy
<White_Flame>
guilty as charged :)
<beach>
slightlycyborg: Though, I strongly recommend against :USE-ing any package other than the COMMON-LISP package. For the past several years I have started using explicit package prefixes for everything except the current package and the COMMON-LISP package. The code is much clearer that way, and it becomes easier to do code refactoring, especially given the limited power of our tools.
<slightlycyborg>
beach. I am trying to make my own lisp on top of CL, so I'm defining things like `->` to mimic obj.member syntax
<slightlycyborg>
(-> obj slot-value)
<beach>
I see.
<LdBeth>
slightlycyborg: you can just hack the token reader to accept obj.member syntax
<shka_>
slightlycyborg: it is just the matter of loading your system and using the proper package
<beach>
slightlycyborg: Then you probably don't want to use the COMMON-LISP package either.
<shka_>
but as beach said, using is not good idea
<no-defun-allowed>
I wouldn't recommend it because there are few good reasons to access slots of objects without going through an accessor generic function.
<slightlycyborg>
LdBeth :). That sounds awesome! I may at some point. My Lisp skills aren't up to hacking the reader atm
<beach>
slightlycyborg: It is interesting that you invent syntax for an operation that you basically should never use.
<shka_>
nowdays if i want some utility library, i just import individual symbols
<beach>
slightlycyborg: What no-defun-allowed said.
<shka_>
usually create separate package so i can import and reexport symbols
<slightlycyborg>
beach. hmm, why shouldn't I use that operation. I'm mostly used to java where that syntax is extreamly prevalent.
<shka_>
slightlycyborg: it is just a syntax
<beach>
Because slots are implementation details.
<LdBeth>
For me there’s no reason stick with S-exps, also there’s not reason to change that
<no-defun-allowed>
Because CL isn't Java, slightlycyborg. Slots are where values end up, but they're not what you want to get values from when writing client code.
<beach>
slightlycyborg: Define your API (called a protocol) using accessors as no-defun-allowed said.
<White_Flame>
sexprs are a reasonable general code representation, without needing 30 megabytes of pseudo-BNF to describe your code
<LdBeth>
If slightlycyborg develops his lisp
<slightlycyborg>
beach. Oh ya, it is terrible OOP isn't it. It is using the object as a struct
<shka_>
slightlycyborg: accessing slots directly is not very OOP
<slightlycyborg>
I read about that in Ucle Bob's Clean Code book
<shka_>
actually not at all
<beach>
slightlycyborg: It is usually a very bad idea to import programming styles from another language.
<no-defun-allowed>
Exactly. If you access slots from external code, your object is effectively a structure and not an object.
<shka_>
beach: well, you can import stuff from other lisps ;-)
<shka_>
and it usually works great
<beach>
shka_: There are no other Lisps.
<shka_>
zeta lisp does not count?
<shka_>
scheme is not a lisp?
<no-defun-allowed>
Some people make analogies to biology where cells are objects, and I think that summarises why working with slots isn't very pleasant: Cells tend not to shove into each other and rip material out of them.
<beach>
That's off topic.
<LdBeth>
It’s fine to write a lisp for their purpose figuring out how this works, but I don’t think it’s good too eager to design a language
<LdBeth>
shka_: you’re firing a war
<shka_>
LdBeth: eh, ok
<no-defun-allowed>
Insted they follow a protocol (not a biologist by any means by the way): one plops out a value, the other takes it in. It's a process where boundaries and purpose are drawn.
<slightlycyborg>
no-defun-allowed. nice annalogy. "Thou shalt not steal... from other holons"
<shka_>
anyway, java is actually very distant to lisp
<beach>
slightlycyborg: Before you spend too much time on this, I suggest you learn more about CLOS and its OO style.
<shka_>
there is a usually little merit importing java conventions to lisp
<White_Flame>
no-defun-allowed: they're also independent agents, not a single thread of execution
<slightlycyborg>
beach: ok. that sounds best
<LdBeth>
It’s also inspiring to learn about several other OOP models have been implemented in CL
<no-defun-allowed>
White_Flame: That's also true.
<shka_>
slightlycyborg: it is also usually a very good idea to not FIGHT lisp style
<shka_>
it may be possible, but is not advised
<no-defun-allowed>
(with-potential-for-flame "CLOS is closer to a real object-oriented...um...object system than what Java or C++ has, though it differs again from those systems by having generic functions which operate on objects, instead of one object operating on a message and some other object(s).")
<White_Flame>
of course, CLOS does forego the fairly fundamental OO notion of data hiding
shka_ has quit [Ping timeout: 246 seconds]
<White_Flame>
but generally does support what you need for OO thinking, plus a whole bunch more
<beach>
White_Flame: That i what the package system is for.
<dave0>
is scheme off-topic here/.
<beach>
yes
<White_Flame>
dave0: yeah, this is a Common Lisp channel. There's a #scheme here as well
<no-defun-allowed>
dave0: Yeah, this is just a Common Lisp room. Maybe ##lisp is better for any Lisp.
<beach>
White_Flame: It is bad design to confuse the two concepts.
<dave0>
oh ##lisp
varjag has quit [Ping timeout: 272 seconds]
<White_Flame>
beach: the package system doesn't prevent access either ;)
<beach>
White_Flame: It shouldn't. It should just make mistakes less likely.
<LdBeth>
I agree with beach, information hiding is not forbidding programmer from access the internals
ltriant has quit [Quit: leaving]
<beach>
If you can't trust the programmer, then all bets are off anyway.
<no-defun-allowed>
While I'm here, is there anyone here I could discuss a change to trivial-garbage with? I'm new to using weak pointers but a test to check if the implementation can create weak pointers (useful where they are just an optimisation or at least not absolutely required) would be very handy.
<LdBeth>
It should be performed spontaneously by the programmer
<White_Flame>
beach: I'm not saying the package system should precent access, but rather that the core OO concepts are built on the notion of data ownership that prevents access from the outside, which cl & packages don't follow
<beach>
White_Flame: Those "core OO concepts" turned out to be a bad idea. Nobody is perfect.
<LdBeth>
I don’t think that’s what Information hiding intends to mean
manualcrank has quit [Quit: WeeChat 1.9.1]
<LdBeth>
Write a function is information hiding
<White_Flame>
I don't think it's bad at its core. If there is prevention of data access, that makes threaded & distributed systems much easier, which was its point
<beach>
Was it? I have not seen that aspect referred to, neither in Simula nor in Smalltalk.
<White_Flame>
gleaned from alan kay talks, basically
<White_Flame>
"objects" were supposed to be able to be trivially distributed
<LdBeth>
Multitask system is more about referential transparency
<White_Flame>
and allow the user to throw more hardware at a problem fairly transparently
milanj has joined #lisp
jeosol has joined #lisp
<jeosol>
Good morning
<beach>
Hello jeosol.
<jeosol>
Doing great. Just back from the hell of working with python for work. Lost brain cells for sure
<beach>
jeosol: I wish you a quick recovery.
<jeosol>
Is anyone familiar with a scientific conversion library? I remember seeing something (from comp.lang.lisp days) but not sure. Basically, I am thinking of something like this: http://www.petroleumoffice.com/unitconverter/length
<jeosol>
thanks Beach. Too much syntax to remember, non-standard naming convention for read/write function. from CL-> python is painful
<beach>
I can imagine.
nowhereman has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
xkapastel has joined #lisp
<jeosol>
Just upgraded to SBCL 1.5.5, kudos to the maintainers
<jeosol>
haha. Beach, it's a nightmare. And operations can be error prone, but I admit, I am not a python expert and my CL skills >>> python skills
frgo_ has quit [Ping timeout: 268 seconds]
varjag has joined #lisp
schweers has joined #lisp
libertyprime has quit [Ping timeout: 248 seconds]
nanoz has quit [Ping timeout: 272 seconds]
slightlycyborg has quit [Ping timeout: 246 seconds]
SaganMan has quit [Ping timeout: 246 seconds]
heisig has joined #lisp
GoldRin has quit [Ping timeout: 268 seconds]
Lord_of_Life has quit [Ping timeout: 245 seconds]
frgo has joined #lisp
frgo_ has joined #lisp
frgo_ has quit [Remote host closed the connection]
frgo_ has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
Lord_of_Life has joined #lisp
frgo has quit [Ping timeout: 244 seconds]
GoldRin has joined #lisp
SN_ has joined #lisp
red-dot has quit [Read error: Connection reset by peer]
SN_ is now known as red-dot
HDurer has quit [Remote host closed the connection]
libertyprime has joined #lisp
HDurer has joined #lisp
count3rmeasure has joined #lisp
Urfin has joined #lisp
mindthelion has quit [Ping timeout: 272 seconds]
<shka__>
no-defun-allowed: i like to call CLOS post-OO system
<jackdaniel>
as in: clos is not object oriented?
<shka__>
jackdaniel: as in: it goes beyond object orientation
<shka__>
in a traditional sense of the word anyway
<jackdaniel>
terms post-something usually refer to something what is not that thing. i.e post-war, post-truth, post-trauma
krwq has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 246 seconds]
<shka__>
jackdaniel: well, it usually refers to something that superseeds the old status quo
<jackdaniel>
post-floppydisk pc
<beach>
shka__: I think jackdaniel is right.
<shka__>
for instance, terms pre-something can be defined in the same way as you did, however it clearly is very different from post prefix
<shka__>
like, pre-war is not post-war because one is placed before war, while the second happens after a war
<jackdaniel>
that does not contradict what I've said (in fact is not very relevant), but nvm that
<LdBeth>
But there’s no precise/widely applicable definition of OOP
<LdBeth>
post floppy disk pc is still pc:>
<shka__>
jackdaniel: it just highlights that your definition may be technically correct, but it is just not very usefull
<mfiano>
I prefer the term Object Reorientation, like the chapter of PCL
dale has quit [Quit: My computer has gone to sleep]
<aeth>
CL OOP is more verb-oriented than noun-oriented, which is unusual
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
amerlyq has joined #lisp
<aeth>
cow.moo() vs. (moo cow)
Ricchi has quit [Remote host closed the connection]
frgo_ has joined #lisp
frgo_ has quit [Remote host closed the connection]
frgo has quit [Ping timeout: 245 seconds]
frgo_ has joined #lisp
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
zhlyg has quit [Remote host closed the connection]
cosimone has joined #lisp
milanj has joined #lisp
Lord_Nightmare has joined #lisp
katco has quit [Write error: Connection reset by peer]
nonlinear[m] has quit [Read error: Connection reset by peer]
akanouras has quit [Read error: Connection reset by peer]
sciamano has quit [Read error: Connection reset by peer]
LdBeth has quit [Read error: Connection reset by peer]
dtw has quit [Write error: Connection reset by peer]
liambrown has quit [Read error: Connection reset by peer]
no-defun-allowed has quit [Remote host closed the connection]
djeis[m] has quit [Remote host closed the connection]
Jachy has quit [Remote host closed the connection]
iarebatman has quit [Remote host closed the connection]
Godel[m] has quit [Write error: Connection reset by peer]
colelyman has quit [Remote host closed the connection]
count3rmeasure has quit [Ping timeout: 268 seconds]
m00natic has joined #lisp
iarebatman has joined #lisp
sciamano has joined #lisp
katco has joined #lisp
LdBeth has joined #lisp
dtw has joined #lisp
colelyman has joined #lisp
Jachy has joined #lisp
djeis[m] has joined #lisp
liambrown has joined #lisp
Godel[m] has joined #lisp
nonlinear[m] has joined #lisp
no-defun-allowed has joined #lisp
orivej has quit [Ping timeout: 250 seconds]
ebrasca has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<p_l>
aeth: well, that depends on how you look at and implement OOP
<p_l>
I'd say it's very... philosophical, in that some systems make the fact about "you're sending a messsage to an object" very obvious (Smalltalk and derivatives), some don't (Java), some just play at term OOP while sniffing glue (C++)
dave0 has quit [Quit: dave's not here]
count3rmeasure has joined #lisp
antepod has joined #lisp
antepod has quit [Ping timeout: 264 seconds]
antepod has joined #lisp
nanoz has joined #lisp
frgo_ has joined #lisp
frgo has quit [Ping timeout: 268 seconds]
frgo_ has quit [Ping timeout: 246 seconds]
SaganMan has quit [Ping timeout: 276 seconds]
count3rmeasure has quit [Quit: Leaving]
frgo has joined #lisp
dgfhdfg has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
SaganMan has joined #lisp
nanoz has quit [Read error: Connection reset by peer]
aoeu256 has joined #lisp
nanoz has joined #lisp
<pjb>
p_l: note that even Smalltalk implements message sending as function call. True message sending should be asynchronous.
kolontaev has joined #lisp
<p_l>
hard to call it a function call when it's a primitive. Implementation of said primitive might be done with a function call in whatever is underlying, but it doesn't have to be
<p_l>
also, message sending might have implicit/explicit sync behaviour
<p_l>
I think L4 enforced sync? There are also ways that would implement that without "functions"
dddddd has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
<p_l>
enforced fully asynchronous systems wouldn't fall under what most people would think of as OOP
<p_l>
at that point you usually have pub/sub and your architecture is more defined in terms of message flows between opaque endpoints (example: ARINC-653 in aircraft)
<pjb>
p_l: foo ifThen: [ print 'yes' ] else: [print 'no']. is really a message send, ie. a function call. It's strictly equivalent to (if* foo (lambda () (print 'yes)) (lambda () (print 'no)) ).
<pjb>
[] = lambda.
kolontae1 has joined #lisp
kolontaev has quit [Ping timeout: 245 seconds]
lucasb has joined #lisp
ggole has joined #lisp
<p_l>
in that sense, given that function calls can also be asynchronous, there's absolutely zero difference
* p_l
bathes in the tarpit
khisanth_ has quit [Ping timeout: 272 seconds]
count3rmeasure has joined #lisp
slightlycyborg has joined #lisp
frgo has quit [Remote host closed the connection]
khisanth_ has joined #lisp
slightlycyborg has quit [Ping timeout: 245 seconds]
oni-on-ion has joined #lisp
EvW1 has joined #lisp
<pjb>
p_l: fuction calls are not asynchronous, since you have to wait to for the results.
dave0 has joined #lisp
<p_l>
I've seen enough function calls where the question of synchronicity was one of "are we talking assembly implementation details or the actual semantic of the operation you did"
<p_l>
for example in WINNT API
<pjb>
The only API that take into account the possibility of asynchronous message sent (but that still wasn't actually implemented ever), is that of OpenStep/Cocoa action/sender.
<moldybits>
(defun f (&rest keys &key &allow-other-keys) keys) seems to allow non-keywords as well. it's what the standard says, i guess, but it's a little dumb maybe?
<p_l>
pjb: underneath WINNT (not WinAPI) is a crazy async little gem
<pjb>
perhaps, I know nothing about MS-Windows.
<pjb>
moldybits: &key keywords are symbols, not keywords.
randomizeusr has joined #lisp
<moldybits>
it doesn't enforce even that, though
<moldybits>
(f 1 2 3 4) => (1 2 3 4)
<pjb>
clisp does: CLISP F: &KEY marker 1 is not a symbol
<moldybits>
(f 1 2 3) ; simple-program-error: odd number of &KEY arguments
<moldybits>
oh
<pjb>
clisp should be renamed scli: the superior CL implementation.
FreeBirdLjj has joined #lisp
jeosol has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 258 seconds]
kajo has joined #lisp
kolontaev has joined #lisp
kolontae1 has quit [Ping timeout: 248 seconds]
frgo has joined #lisp
akoana has joined #lisp
EvW1 has quit [Ping timeout: 250 seconds]
EvW has joined #lisp
Bike has joined #lisp
alexanderbarbosa has quit [Read error: Connection reset by peer]
<dlowe>
then we could stop correcting people using clisp as an abbreviation
EvW has quit [Ping timeout: 264 seconds]
dim has joined #lisp
rotty has quit [Quit: WeeChat 2.6-dev]
seok has quit [Remote host closed the connection]
nanoz has quit [Ping timeout: 245 seconds]
<p_l>
pjb: did the memory code got ripped out between ~2010 and now?
<pjb>
p_l: IIRC, there was some clean up, indeed.
<p_l>
the lightest level of cleanup acceptable would have involved nuclear explosions
<ck_>
I'll memorize the phraseology for the future
<ck_>
"That code isn't unrefined or too complicated.. it simply isn't cleaned up yet"
kolontaev has quit [Read error: Connection reset by peer]
kolontaev has joined #lisp
slightlycyborg has joined #lisp
kajo has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
kolontaev has quit [Read error: Connection reset by peer]
wxie has joined #lisp
<Bike>
obscure question: the description of how strings are printed with escape says that characters are escaped if they're single or multiple escape characters. does that mean the printing is affected by the current readtable?
<beach>
Good question.
ivansviatenko has joined #lisp
<beach>
Where do you see the reference to multiple escape characters?
<Bike>
oh, i don't. it's just single escapes. my bad.
<beach>
Whew!
<Bike>
in sbcl it doesn't check the readtable, but there's a comment saying it probably should. from 1999.
<beach>
I tend not to agree.
<ck_>
if the comment were true, how would you escape the escape-caracters?
<Bike>
you put a backslash in.
<Bike>
"If printer escaping is enabled, a double-quote is output before and after, and all double-quotes and single escapes are preceded by backslash."
<Bike>
which i guess sort of implies readtable insensitivity, since there's no reason you can't have a readtable where backslash isn't an escape character.
wxie has quit [Ping timeout: 264 seconds]
LiamH has joined #lisp
ivansviatenko has left #lisp [#lisp]
ivansviatenko has joined #lisp
nanoz has joined #lisp
Arcaelyx has joined #lisp
<pjb>
billstclair: for symbols, yes. Strings only have a single escape character;
<pjb>
#\\
<pjb>
On the other hand, there's no mechanism to declare escape characters in a readtable!
<pjb>
Which is why you will usually define both a new reader macro for strings, and a printing function. (definining a print-object method on string is not conforming).
slightlycyborg has quit [Ping timeout: 245 seconds]
<pjb>
ERROR: Unexpected end of file on #<string-input-stream :closed #x3020049B430D> |#
<pjb>
"\"b"
<Bike>
i'm asking if that's correct or not.
SaganMan has quit [Quit: WeeChat 1.6]
<pjb>
It's conforming.
<Bike>
a bare assertion is less than i was hoping for
<pjb>
Where did you find "the description of how strings are printed with escape says that characters are escaped if they're single or multiple escape characters."?
<pjb>
Printing is specified to take into account the *print-…* variaables, some *read-…* variables, and indeed the *readtable*.
<pjb>
But in the case of string, it's specified more strictly to issue double-quotes and backslash, to escape double-quotes and backslash, independently of the *readtable*, (because it would be difficult to learn just from the readtable, the exected read-syntax for strings).
<Bike>
it doesn't say to escape backslashes, it says to escape single escapes.
pfdietz has joined #lisp
<Bike>
i literally quoted this earlier
<pjb>
Yes.
<pjb>
Oh, right. I misread…
<pjb>
You want to test: (let ((*readtable* (copy-readtable))) (set-syntax-from-char #\a #\\) (read-from-string "\"aaa\"b\"")) #| --> "a\"b" ; 7 |# <-- ccl not conforming, since #\a has the single escape syntax, it should print "\a\"b"
heisig has quit [Quit: Leaving]
<pjb>
No implementation do it.
<pjb>
Congratulation, you detected a general non-conformance! :-)
Bike has quit [Ping timeout: 260 seconds]
Bike has joined #lisp
smazga has joined #lisp
antepod has quit [Ping timeout: 250 seconds]
antepod has joined #lisp
slightlycyborg has joined #lisp
chipolux has quit [Quit: chipolux]
chipolux has joined #lisp
jprajzne has quit [Quit: Leaving.]
slightlycyborg has quit [Ping timeout: 272 seconds]
warweasle has joined #lisp
chipolux has quit [Quit: chipolux]
chipolux has joined #lisp
slightlycyborg has joined #lisp
randomizeusr has left #lisp [#lisp]
cosimone has joined #lisp
rippa has joined #lisp
dave0 has quit [Quit: dave's not here]
wigust has joined #lisp
wigust- has quit [Ping timeout: 245 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
kajo has joined #lisp
schweers has quit [Ping timeout: 264 seconds]
cosimone has quit [Quit: WeeChat 2.4]
Arcaelyx has quit [Ping timeout: 272 seconds]
flamebeard has quit []
manualcrank has joined #lisp
Ni-chan has quit [Remote host closed the connection]
Lycurgus has joined #lisp
antepod has quit [Quit: WeeChat 2.3]
varjagg has joined #lisp
dgfhdfg has quit [Ping timeout: 268 seconds]
shka_ has joined #lisp
igemnace has quit [Quit: WeeChat 2.5]
xkapastel has joined #lisp
igemnace has joined #lisp
dgfhdfg has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
Arcaelyx has joined #lisp
EvW1 has joined #lisp
amerlyq has quit [Quit: amerlyq]
notzmv has quit [Ping timeout: 246 seconds]
hiroaki has joined #lisp
CloseToZero has joined #lisp
m00natic has quit [Remote host closed the connection]
noark9 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
cantstanya has quit [Remote host closed the connection]
cantstanya has joined #lisp
srji has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
pfdietz has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 272 seconds]
noark9 has quit [Quit: noark9]
oni-on-ion has quit [Ping timeout: 264 seconds]
Bike has joined #lisp
varjagg is now known as varjag
nanoz has quit [Ping timeout: 272 seconds]
dgfhdfg has quit [Read error: Connection reset by peer]
mindCrime has quit [Remote host closed the connection]
mindCrime has joined #lisp
pfdietz has joined #lisp
dgfhdfg has joined #lisp
mindCrime has quit [Max SendQ exceeded]
mindCrime has joined #lisp
shka__ has quit [Ping timeout: 268 seconds]
EvW1 has quit [Ping timeout: 250 seconds]
shka__ has joined #lisp
<varjag>
slyrus1: there?
akoana has quit [Ping timeout: 246 seconds]
akoana has joined #lisp
alexanderbarbosa has joined #lisp
keep_learning has quit [Quit: Ping timeout (120 seconds)]
smazga has joined #lisp
<alexanderbarbosa>
Steele Reference Book is still reliable? sbcl/allegro wise...
orivej has joined #lisp
notzmv has joined #lisp
vlatkoB has quit [Remote host closed the connection]
<Bike>
you mean Common Lisp The Language?
Inline has joined #lisp
<alexanderbarbosa>
yep
oni-on-ion has joined #lisp
<Bike>
it was superseded by the standard. people say it's easier to read, sometimes, but that's kind of a major problem.
<alexanderbarbosa>
fair...... up to get it...
<dlowe>
Just trust it less than the standard
<jackdaniel>
"never trust strangers on the internet" - stranger on the internet
<alexanderbarbosa>
jackdaniel: :D
<moldybits>
haha
<Bike>
you can't fail to follow that advice
hiroaki has quit [Ping timeout: 245 seconds]
<alexanderbarbosa>
^
Lycurgus has quit [Quit: Exeunt]
smazga has quit [Ping timeout: 272 seconds]
<galdor>
since the standard is an expensive pdf whose formatting makes it nearly unusable, you can't blame people from using CLTL2
hiroaki has joined #lisp
<Bike>
i'm not blaming anyone
<jackdaniel>
galdor: all standards are that way, but it is a common practice to publish free final drafts (same applies i.e to C language)
<Bike>
clhs is basically fine in my experience, though
<jackdaniel>
so you have clhs, but also you may compile your own pdf version
<galdor>
first time I see a standard made of scanned documents, so you cannot search for anything
<galdor>
all ietf/iso/3gpp I read were quite usable; the CL one, not so much
<galdor>
fortunately there is a very nice CLtL2 pdf with index :)
<jackdaniel>
random thought: maybe we should host this pdf somewhere on common-lisp.net and put a link in the topic.. thoughts?
<Bike>
wasn't there some bizarre legal reason you had to build the pdf yourself
<galdor>
what's the legal status ?
<jackdaniel>
Bike: I think there was a copyright problem with html version which is used for hyperspec
<jackdaniel>
but dpans sources are in public domain (they weren't cleaned until a few years ago though)
<Bike>
ic
<jackdaniel>
so any document built from these documents doesn't have such problems (unlike html version which was converted by Kent Pitman I think)
<jackdaniel>
unless my memory plays tricks on me, I didn't doublecheck right now
<mfiano>
an html version of dpans is not protected. only derived works of the hyperspec
<jackdaniel>
mfiano: by html version I've meant hyperspec. Is there any other version?
<mfiano>
not yet. i have started to convert dpans over to a modern html format myself. it's an ongoing effort and only about 25% there after a few months
<mfiano>
in the process i have noticed a lot of errors LW made though
<jackdaniel>
ah, OK, I thought I've missed something. Yes, I meant that the html version converted by Kent Pitman for LW (or for whomever LW bought copyrights to it from) has some legal considerations
<jackdaniel>
which does not apply to anything built from dpans
<jackdaniel>
mfiano: what kind of errors?
<mfiano>
typographical errors, glossary terms not using the correct font type and thus not linked, etc
<jackdaniel>
is your repository public or still only local?
<mfiano>
local only so far
hiroaki has quit [Ping timeout: 268 seconds]
<jackdaniel>
understood, thanks
<mfiano>
first attempt used an sexp format, but it was hindering me too much. sources probably not very useful to you now, since it's almost raw html templates (djula)
Josh_2 has joined #lisp
<Josh_2>
Is there a library to get date differences between two strings like "2019-7-29" and "2019-7-25" for example
<mfiano>
yes local-time
<Josh_2>
mfiano++
<Josh_2>
Thanks
<jackdaniel>
not incf?
<mfiano>
i think you want parse-timestring combined with timestamp-difference
gravicappa has quit [Ping timeout: 245 seconds]
<mfiano>
then perhaps format-timestamp to bring it back into string form
<dlowe>
you probably want to just (- (day-of a) (day-of b)) to get a date difference
<Josh_2>
yes mine are strings
CloseToZero has quit [Quit: WeeChat 2.5]
<mfiano>
gonna haveto add the timezone adjustment too
<mfiano>
since parsing it will put it in the offset format
<dlowe>
the timestamp will be wrong, but as long as it's consistently wrong (and it will be at 0:00:00) the number of days will be correct.
Lord_of_Life_ is now known as Lord_of_Life
hiroaki has joined #lisp
<dlowe>
fwiw, local-time is terrible for dates, even though all the functionality is in there, because it's all one big timestamp object
<dlowe>
I have a project to deal with dates seperately but it fell by the wayside
<Josh_2>
well I do save the universal time into the data
<Josh_2>
so I can use that instead
<dlowe>
that will give you the number of seconds, but not the number of days
<Josh_2>
rip
<dlowe>
You can use local-time:universal-to-timestamp if you want to skip the intermediate string step
<Josh_2>
That works and avoids the problem of utc/utc+1 right?
sonologico has joined #lisp
<Josh_2>
ah actually that doesn't work
frgo has quit []
<Josh_2>
it does work but in the case it won't work as the universal time is taken when the entry is made, but it needs to be the date when the work was done not entered in the db ¯\_(ツ)_/¯
xkapastel has quit [Quit: Connection closed for inactivity]
<Josh_2>
LiamH: thanks but I have a solution now :)
astronavt has joined #lisp
shka_ has quit [Ping timeout: 258 seconds]
xyzzy has joined #lisp
xyzzy has left #lisp ["Killed buffer"]
EvW has joined #lisp
alexanderbarbosa has quit [Ping timeout: 250 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<semz>
Man, retrofitting a connection pool or a SOCKS5 proxy onto Drakma from the outside is a PITA. If you know the implementation in advance you imitate the internals and hack together a stream that drakma can use, but when following redirects it will happily close the stream and make a new connection on its own with no way apparent way to override how...
mindCrime has quit [Ping timeout: 245 seconds]
<semz>
Is there some place besides the Github where drakma-related discussion takes place? I've found an unanswered feature request for SOCKS proxy support there from early 2018 but that's about it
milanj has joined #lisp
LiamH has quit [Quit: Leaving.]
Bike has quit [Quit: Bike]
mindthelion has joined #lisp
techquila has quit [Ping timeout: 276 seconds]
Lycurgus has joined #lisp
dpl has quit [Read error: Connection reset by peer]
slightlycyborg has quit [Ping timeout: 245 seconds]
dpl has joined #lisp
rubik has joined #lisp
Ricchi has joined #lisp
aoeu256 has quit [Ping timeout: 272 seconds]
hiroaki has quit [Ping timeout: 244 seconds]
dpl has quit [Quit: dpl]
slightlycyborg has joined #lisp
alexanderbarbosa has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
astronavt has quit [Ping timeout: 248 seconds]
patrixl has joined #lisp
astronavt has joined #lisp
ltriant has joined #lisp
slightlycyborg has quit [Ping timeout: 258 seconds]
astronavt has quit [Ping timeout: 245 seconds]
astronavt has joined #lisp
dgfhdfg has quit [Ping timeout: 245 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
cantstanya has quit [Ping timeout: 260 seconds]
sonologico has quit [Ping timeout: 248 seconds]
cantstanya has joined #lisp
Bike has joined #lisp
jack_rabbit_ has joined #lisp
Paloma has joined #lisp
ltriant has quit [Ping timeout: 272 seconds]
sonologico has joined #lisp
techquila has joined #lisp
slightlycyborg has joined #lisp
ltriant has joined #lisp
mindthelion has quit [Ping timeout: 258 seconds]
FennecCode has joined #lisp
keep_learning has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
slightlycyborg has quit [Ping timeout: 272 seconds]