jeosol has quit [Remote host closed the connection]
madand has joined #lisp
msk has quit [Remote host closed the connection]
msk has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
ebzzry has quit [Read error: Connection reset by peer]
msk has quit [Remote host closed the connection]
msk has joined #lisp
asdf_asdf_asdf has joined #lisp
statusf90 has quit [Quit: statusf90]
<asdf_asdf_asdf>
Hi. Which encoding (ASCII, UTF-8, etc.) return value 0xffff as one character?
<pjb>
asdf_asdf_asdf: none.
<pjb>
asdf_asdf_asdf: 0xffff is a symbol.
<pjb>
(type-of '0xffff) #| --> symbol |#
karlosz has joined #lisp
<asdf_asdf_asdf>
pjb, thank. I want in file put character, which return 0xffff value.
<pjb>
That is not possible. 0xffff is the representation of a symbol!
<pjb>
This is #lisp!
<asdf_asdf_asdf>
Yes, I put in file character and next in Common Lisp I get character from stream. Later I want get character as 0xffff. Is other fashion to do?
<vsync>
asdf_asdf_asdf: #xFFFF :-)
<aeth>
As a rule of thumb, all of that weird stuff tends to uniformly be after a # for CL, rather than having you (and the parser) guess, like with 0xffff
<asdf_asdf_asdf>
No. I parse the file, and (get character ... I want, that character was 0xffff value.
<vsync>
asdf_asdf_asdf: the joke is just you're giving the number in C syntax for hex, rather than CL syntax
<aeth>
asdf_asdf_asdf: I don't quite understand what you mean, but if you mean you want to convert between numbers and characters, you want CHAR-CODE and CODE-CHAR, depending on the direction
<vsync>
asdf_asdf_asdf: depending on your platform, $LC_CTYPE and friends may be important
gko has joined #lisp
kmeow has joined #lisp
<pjb>
asdf_asdf_asdf: utf-8 doesn't define a character set, only an encoding of some integers into sequences of bytes.
<asdf_asdf_asdf>
this character is \U+FFFF. I want, that this character was in Lisp program interpret as #xFFFF.
<pjb>
asdf_asdf_asdf: ascii defines a character set, and corresponding codes. (ie. an encoding). There is no character in ascii that has as code #xffff. The code of ASCII are values between #x00 and #x7e.
<pjb>
asdf_asdf_asdf: Unicode defines an encoding of grapheme clusters into sequences of code-points. The code-point #xffff is guaranteed by the unicode standards to NOT encode any grapheme clusters!
<aeth>
Encodings are really, really hard. SBCL uses UTF-32 internally. A lot of APIs use UTF-8 or ASCII. Windows uses UCS-16 iirc, which is probably the worst of the Unicode ones still in common use.
ccl-logbot has quit [Quit: Client terminated by server]
ccl-logbot has joined #lisp
<aeth>
You have to know exactly what you're working with or else you're going to just get noise.
<pjb>
asdf_asdf_asdf: So it is absolutely impossible to store in a text file, A unicode characters in the UTF-8 format that has the codepoint value #xffff. Totally impossible, guaranteed by 6 different versions of the unicode standard.
<asdf_asdf_asdf>
Alright. Is encoding, which encode my character in file as #xFFFF (65535)?
<aeth>
asdf_asdf_asdf: Do you want the unicode character FFFF or do you want to find out what (probably Unicode) encoding encodes some character as FFFF?
<pjb>
asdf_asdf_asdf: you could read the utf-8 file as a binary file and decode the utf-8 bytes into codepoints integers, and get the codepoint #xffff. But you couldn't do that with characters.
<pjb>
You cannot do that if the file is a text file. Only if it is a BINARY file.
<aeth>
pjb: Unfortunately, unless asdf_asdf_asdf's project changed, it involves Windows, so it's not as simple as UTF-8
<pjb>
And you have to do the utf-8 decoding yourself.
orivej has joined #lisp
<pjb>
aeth: there is no, and never will be any unicode grapheme cluster that has as codepoint the value #xffff!!! This is something that is guaranteed by the unicode standard!
<pjb>
aeth: this is what I've been explaining for ten minutes!
georgiePorgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<asdf_asdf_asdf>
I ask about other encoding outside UNICODE. Another encoding is possible, to encode character as value #xFFFF? I get character from file character by character.
<Xach>
asdf_asdf_asdf: why?
<pjb>
asdf_asdf_asdf: I told you, not in ascii!!! Not in iso-8859 and other 8-bit coding system either.
<Nilby>
UTF-16 has sixteen bit wide characters, but to literally represent #xFFFF, like with the char-int or char-code function, UTF-16 has escape codes to a second 16 bit 'character'.
<Nilby>
But lower numbered character are mostly in 16 bites.
<Nilby>
*bits.
<aeth>
asdf_asdf_asdf: It is probably (hopefully!) *a* Unicode encoding, the question is which. If it's not, you can never know for sure, and can only use heuristics.
<aeth>
If I'm understanding your question correctly.
<aeth>
Most encodings are 8-bit (like extended ASCII), though.
<pjb>
aeth: no, #xffff is NOT any unicode encoding. This is guaranteed by the 6 nope, the FUCKING 12 unicode standards so far!
<pjb>
Whether you encode it in utf-8, utf-16, ucs-32 of the fuck the format you use, there is no, and never will be any grapheme cluster encoded by #xffff. This is a fundamental property of unicode. Like it is a fundamental property of ASCII to use codes between #x00 and #x7e, and no other.
<pjb>
Now, for other encoding, it is possible that there exist one that uses the value #xffff to encode something, but it is rather improbable, because if it existed, it would probably have been integrated in unicode…
<pjb>
Also, utf-8 has been designed to be used with unicode, it is also improbable that it is used by other encodings.
<pjb>
Has anybody invented a new encoding since unicode exists?
<aeth>
pjb: so you're saying that if you're reading a file and come across #xffff (or #xff #xff) it cannot be unicode?
<pjb>
Right.
<pjb>
You cannot come across #xff #xff if it is a utf-8 file
<Nilby>
I like the unoffical UTF-8b which handles #xffff or anything.
<pjb>
Nilby: you can encode #xffff in a utf-8 file, but this codepoint doesn't represent any graphem cluster.
<pjb>
Note, you encode an integer into utf-8, not anything of any other type.
<Nilby>
That's true. But sometimes one is more concerned with preserving data, and not getting encoding errors, than displaying graphemes.
<aeth>
asdf_asdf_asdf: What context is this coming up in?
<Nilby>
For example, if you want to "cat" a file of unknown encoding, or binary data, but also use it as a Lisp stream, of maybe something you can look at, but also preserve the actual bytes, then something like UTF-8b or some equivalent is useful.
msk_ has joined #lisp
msk has quit [Read error: Connection reset by peer]
<aeth>
Nilby: I'm not entirely sure what asdf_asdf_asdf is doing because "I get character from file character by character" doesn't make sense in the context of Common Lisp terminology because characters don't get you (unsigned-byte 16)s. And if it's CFFI, afaik C chars are 8 bit?
<aeth>
s/characters don't/read-char doesn't/
<aeth>
I'm suspecting that asdf_asdf_asdf is doing some FFI, too.
msk_ has quit [Remote host closed the connection]
<aeth>
If we can get more context, we can provide a solution to the encoding mess. Maybe.
msk_ has joined #lisp
<Nilby>
If I'm right, I think it's the problem I'm familiar with of wanting to mix Lisp character and binary streams without encoding errors. Bi-valent streams are great for that, but they don't solve the encoding errors.
<aeth>
Nilby: Most of asdf_asdf_asdf's recent questions have been related to SBCL-specific FFI in #sbcl afaik, so that sort of FFI is probably involved, adding the complexity of inter-language conversion, too.
<aeth>
Nilby: i.e. I think some C function is (maybe) giving (unsigned-byte 16)s and now those need to be made sense of in CL
<aeth>
But this is just speculation without further context
<Nilby>
It it's an issue with FFI's, usually from old C, which don't care about encoding, but also just reading with Lisp streams too.
<aeth>
Turning #xFFFF from some random C or C++ API into a CL character requires further context because CODE-CHAR isn't going to be helpful. And, you know, I think this is exactly what's going on. In SBCL, (code-char #xffff) => #\UFFFF
<aeth>
close to the "this character is \U+FFFF."
<Nilby>
I think at this point, I'm actually glad that (code-char #xffff) => #\UFFFF, rather than give an encoding error.
v88m has quit [Ping timeout: 272 seconds]
<aeth>
ECL matches SBCL. CCL gives #\U+FFFF
ebzzry has joined #lisp
msk_ has quit [Read error: Connection reset by peer]
msk has joined #lisp
karlosz has quit [Quit: karlosz]
<pjb>
aeth: you cannot turn #xffff into a character, because there is no unicode grapheme cluster that has this code.
<pjb>
aeth: what you can do, as I explained above, is to decode the utf-8 sequence yourself, and obtain #xffff. see: https://termbin.com/v4r0
<pjb>
Nilby: you're assuming too much.
<pjb>
An implementation could return NIL. An implementation honest to unicode would return NIL.
<Nilby>
pjb: You're probbly right. I'm sometimes quite an over-assumer.
<Nilby>
Like it's a pretty big assumtion that someday people might use Lisp software I write.
<aeth>
pjb: well CLISP is #\UFFFF
z147 has quit [Ping timeout: 240 seconds]
<aeth>
pjb: so now I'm 4 for 4 in implementations I'm testing returning something like that
<pjb>
aeth: all implementations can be wrong.
<aeth>
pjb: if it's Windows FFI (not sure if it is, asdf_asdf_asdf was doing that a long time ago) we can't assume UTF 8
<aeth>
Windows is... crazy.
<aeth>
or, um, "backwards compatible"
dale_ has joined #lisp
shifty has joined #lisp
<pjb>
aeth: now, unicode doesn't define characters, but grapheme clusters, so implementations may define cl:character as they wish, but I still find it untasty, and untrue to unicode to have (code-char #xffff) return anything else than NIL.
<aeth>
pjb: and, yeah, they shouldn't be saying "You have the char \U+FFFF" (which is how we got into such a long discussion) they should be saying "you're doing something wrong somewhere" and now the question is where.
<pjb>
aeth: and note that it's not because (code-char #xffff) returns #\u+ffff that decoding from utf-8 won't signal an error for such a code! This is the case in ccl, IIRC.
<pjb>
Because utf-8 -> codepoints -> unicode -> cl:character, and there is no unicode grapheme cluster for #xffff!
<pjb>
also: Since RFC 3629 (November 2003), the high and low surrogate halves used by UTF-16 (U+D800 through U+DFFF) and code points not encodable by UTF-16 (those after U+10FFFF) are not legal Unicode values, and their UTF-8 encoding must be treated as an invalid byte sequence.
<aeth>
asdf_asdf_asdf: how are you getting a #xFFFF ?
dale has quit [Ping timeout: 268 seconds]
dale_ has quit [Ping timeout: 265 seconds]
dale has joined #lisp
zooey has quit [Quit: quit]
dale_ has joined #lisp
dale has quit [Disconnected by services]
dale_ is now known as dale
dale_ has joined #lisp
dale has quit [Disconnected by services]
dale_ is now known as dale
zooey has joined #lisp
EvW has joined #lisp
developernotes has joined #lisp
davepdotorg has joined #lisp
developernotes has quit [Client Quit]
developernotes has joined #lisp
developernotes has quit [Client Quit]
developernotes has joined #lisp
developernotes has quit [Client Quit]
davepdotorg has quit [Ping timeout: 240 seconds]
v88m has joined #lisp
zooey has quit [Ping timeout: 240 seconds]
zooey has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
Bike has quit [Quit: Lost terminal]
asdf_asdf_asdf has quit [Read error: Connection reset by peer]
gravicappa has joined #lisp
<loke>
aeth: Isn't Windows using a mix of native legacy encodings and UTF-16? And then a lot of software on TOP of Windows uses UTF-8, but afaik Windows itself doesn't provide any supprot for UTF-8
slyrus__ has joined #lisp
EvW has quit [Ping timeout: 245 seconds]
gabiruh_ has quit [Quit: ZNC - 1.6.0 - http://znc.in]
<aeth>
loke: you should probably address that at pjb
gabiruh has joined #lisp
slyrus_ has quit [Ping timeout: 265 seconds]
dddddd has quit [Remote host closed the connection]
lxbarbos` has quit [Ping timeout: 246 seconds]
space_otter has joined #lisp
Oladon has quit [Quit: Leaving.]
Josh_2 has quit [Ping timeout: 265 seconds]
aindilis has quit [Remote host closed the connection]
karlosz has joined #lisp
v88m has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
asarch has joined #lisp
davepdotorg has joined #lisp
aindilis has joined #lisp
vlatkoB has joined #lisp
froggey has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Ping timeout: 272 seconds]
davepdotorg has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
toorevitimirp has joined #lisp
Oladon has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
froggey has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
notzmv has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
FreeBirdLjj has quit [Read error: Connection reset by peer]
oni-on-ion has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
v88m has joined #lisp
FreeBirdLjj has joined #lisp
oxum_ has quit [Remote host closed the connection]
narimiran has joined #lisp
FreeBirdLjj has quit [Ping timeout: 265 seconds]
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
georgiePorgie has joined #lisp
notzmv has joined #lisp
_whitelogger has joined #lisp
FreeBirdLjj has joined #lisp
shrdlu68 has joined #lisp
karlosz has quit [Quit: karlosz]
Oladon has quit [Quit: Leaving.]
dale has quit [Quit: My computer has gone to sleep]
Emblemat has joined #lisp
shangul has joined #lisp
Emblemat is now known as asdf_asdf_asdf
sauvin has joined #lisp
asarch has quit [Quit: Leaving]
FreeBirdLjj has quit [Remote host closed the connection]
georgiePorgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jjong has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 268 seconds]
JohnMS_WORK has joined #lisp
oxum has joined #lisp
oxum_ has quit [Ping timeout: 260 seconds]
ebzzry has joined #lisp
brown121408 has quit [Ping timeout: 272 seconds]
JohnMS_WORK has quit [Read error: Connection reset by peer]
JohnMS_WORK has joined #lisp
brown121408 has joined #lisp
msk has quit [Read error: Connection reset by peer]
msk has joined #lisp
wxie has joined #lisp
msk_ has joined #lisp
FreeBirdLjj has joined #lisp
msk has quit [Read error: Connection reset by peer]
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 272 seconds]
X-Scale` is now known as X-Scale
davepdotorg has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
davepdotorg has quit [Ping timeout: 240 seconds]
ggole has joined #lisp
hiroaki has quit [Ping timeout: 260 seconds]
msk_ has quit [Read error: Connection reset by peer]
msk has joined #lisp
mn3m has quit [Quit: mn3m]
frgo has quit [Remote host closed the connection]
scymtym has joined #lisp
v_m_v has joined #lisp
wxie has quit [Ping timeout: 268 seconds]
jjong has quit [Remote host closed the connection]
Cymew has joined #lisp
v_m_v has quit [Ping timeout: 260 seconds]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
frgo has quit [Ping timeout: 265 seconds]
<Odin->
pjb: You are wrong. Noncharacters are _explicitly_ allowed to appear in Unicode strings and must not be mangled by text processing interfaces. It is recommended that when encountered in general interchange they be replaced by the replacement character (�), but this should not be done transparently by a Unicode-handling API.
frgo has joined #lisp
<jackdaniel>
unicode is more a text formatting declarative language than encoding
<Odin->
See, as the current example, §23.7 of Unicode 12.
<Odin->
jackdaniel: It really isn't, though, because it doesn't have any actual formatting controls. :p
<aeth>
Odin-: ������! ���� ����� �����!
<jackdaniel>
soft-newline, hard-newline, make this face brownier ,)
<aeth>
:p
<Odin->
aeth: That just puts me in mind of comic book cursing. :)
<jackdaniel>
ah, and this part of text should be rtl, but only that
<Odin->
jackdaniel: Well, in that case an awful lot of ASCII is format control, too.
mingus has joined #lisp
<aeth>
Odin-: I actually censored "Thanks! That makes sense!" But I guess 4-5 letter words when sensored do look like cursing.
<Odin->
Even if only a couple of those characters are actually used.
<Odin->
aeth: Well, in particular it puts me in mind of Lucky Luke, which sometimes used very ... embellished forms of censoring.
<aeth>
Odin-: ASCII has a whole database thing going on that no one uses.
<Odin->
Yeah, which I wish people did.
jjong has joined #lisp
<Odin->
Why the fuck use CSV when you have the seperator codes?
<Odin->
:p
<aeth>
The problem is that the editor would have to replace the unprintable database characters with the printable versions that Unicode has.
<aeth>
And at that point you might as well just use the printable versions because they're so rare you'd rarely need to escape them!
<Odin->
It mostly gets down to "it's difficult to type" terrain, which, despite the way I'm talking, I understand perfectly well.
<Odin->
There are standard ways to represent the control characters, though.
<Nilby>
I think Unicode naïvely tries to assign some semantics to characters rather than just numbers, which once humans see the diversity of galactic languages, such standardized codifying of cultural artifacts will be obviously unachievable.
<Odin->
I'll probably mess someone's client up if I send any of them, though.
<Odin->
Nilby: It ... doesn't.
<aeth>
Nilby: I think the Unicode committee is hoping that intelligent life isn't discovered elsewhere in the galaxy, more than any other group.
<Nilby>
Capitalization, Numeric value, printing width, etc.
<Nilby>
Like I said. naïve.
<Shinmera>
Can we get back Lisp here, thanks
<aeth>
Nilby: It could be worse. You could have all of that, but also automatically try to upcase everything... :p
<Odin->
Nilby: Oh, so you're not suggesting ASCII was any better?
<Odin->
(Which also assigned case semantics and numeric values.)
<Nilby>
Ok. Does any Lisp Unicode library has the current correct character widths, without call wcwidth ?
brown121408 has quit [Ping timeout: 265 seconds]
<Nilby>
Odin: No ASCII is not better.
<Odin->
aeth: Frankly, I think everyone's just glad nobody's found intelligent life on Earth yet.
milanj has joined #lisp
<Odin->
Nilby: What do you mean by "character width"?
<Nilby>
What the C wcwidth returns (if your OS ICU library is up to date), and say what character grid terminals think.
william1_ has joined #lisp
<Odin->
That has nothing to do with Unicode.
<Nilby>
I don't mean Font text rendering which is a whole other world.
<Odin->
That _is_font rendering.
<Nilby>
It does. It's in the unicode data files.
<Odin->
Because Unicode was designed to be able to round-trip any existing legacy encoding, and certain encodings for East Asian languages specified this.
ebzzry has quit [Ping timeout: 268 seconds]
<Nilby>
Not just East Asian, but every other script. What language doesn't use emoji's and technical characters?
Necktwi has joined #lisp
<Odin->
If you're not using a locale that makes a distinction between half-width and full-width, you can disregard the East_Asian_Width property.
<jackdaniel>
imo we should conclude this offtopic with: "unicode is here, there is no way back, so we need to deal with it".
<jackdaniel>
in other words, let's focus on Common Lisp
msk has quit [Read error: Connection reset by peer]
msk has joined #lisp
z147 has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
mingus has quit [Ping timeout: 265 seconds]
<shrdlu68>
How do I make slime-compile-defun compile defun in a certain package?
mingus has joined #lisp
mingus has quit [Client Quit]
toorevitimirp has quit [Ping timeout: 248 seconds]
JohnMS has joined #lisp
asdf_asdf_asdf has left #lisp ["Killed buffer"]
JohnMS_WORK has quit [Ping timeout: 265 seconds]
georgiePorgie has joined #lisp
datajerk has quit [Ping timeout: 272 seconds]
william1 has joined #lisp
william1 has quit [Client Quit]
william1 has joined #lisp
samebchase-3 has joined #lisp
hdasch has quit [Ping timeout: 265 seconds]
samebchase- has quit [Ping timeout: 260 seconds]
hdasch has joined #lisp
madrik has joined #lisp
samebchase-3 is now known as samebchase-
v_m_v has joined #lisp
kmeow has quit [Remote host closed the connection]
kmeow has joined #lisp
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
william1 has quit [Quit: WeeChat 2.6]
FreeBirdLjj has joined #lisp
datajerk has joined #lisp
<Shinmera>
put in-package before it, I guess.
msk has quit [Remote host closed the connection]
msk has joined #lisp
hhdave has quit [Ping timeout: 260 seconds]
FreeBirdLjj has quit [Ping timeout: 268 seconds]
hhdave has joined #lisp
JohnMS_WORK has joined #lisp
vlatkoB has quit [Read error: Connection reset by peer]
JohnMS has quit [Ping timeout: 260 seconds]
vlatkoB has joined #lisp
ebzzry has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
<pjb>
Odin-: I know about the replacement character, and the request for the API to do it explicitely. But the question was explicitely to obtain a character with #xffff as codepoint. He didn't want to be able to read a utf-8 sequence #(239 191 191) and obtain a replacement character or other…
<Odin->
He shouldn't.
<Odin->
This shouldn't be a replacement character ->
<pjb>
Yes, but he's particularly unreceptive to advice and questioning…
<Odin->
I'll grant you that.
ccl-logbot has quit [Quit: Client terminated by server]
<Odin->
But a UTF-8 decoder shouldn't refuse to give you U+FFFF.
ccl-logbot has joined #lisp
<Odin->
Hmm.
<pjb>
Definitely.
<pjb>
But again, I couldn't make him admit that he wanted just a codepoint, and not a character.
<Odin->
That distinction is not particularly clear to everyone. :p
<Shinmera>
It is better to just not engage when it's clear the person is unreceptive.
<pjb>
Yes. I blame C. Furthermore, unicode doesn't make things easy, by not defining characters, but grapheme clusters…
jonatack has quit [Ping timeout: 246 seconds]
cosimone has joined #lisp
<Odin->
I don't know, the exact same issue is in the Common Lisp standard.
<Odin->
A (generally-understood-to-be) single character doesn't always correspond to a single codepoint, and yet the standard mandates that.
pvaneynd has joined #lisp
hhdave has quit [Ping timeout: 265 seconds]
<pjb>
Odin-: no, the CL standard doesn't talk about codepoints. The char-code doesn't need to be equal to the codepoint.
<Odin->
A char-code needs to be a (single) non-negative integer, though.
<pjb>
And when we need to integrate galactic scripts, this grapheme cluster and combining codepoints system will have to be greatly improved…
<galdor>
pjb I'm not sure I understand your example, is there a modern CL implementations where characters are not codepoints ?
<galdor>
vector of codepoints is a very practical representation for lots of unicode transormations
<Odin->
pjb: I take it you have an example of possible variability that isn't accounted for by this system?
<galdor>
it's quite obvious when trying to do any kind of unicode-aware processing in other languages, where you end up transforming from/to byte vectors and codepoint vectors
<galdor>
characters are not integers, but characters map to character codes which are integers
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<pjb>
and the image of this map is different from the set of codepoints!
<galdor>
and while the standard does not mandate that character are unicode code points, modern CL I'm aware of make that choice, which is convenient
<galdor>
yes
<galdor>
and in the unicode standard, not all integer values are valid characters, but again, why is that a problem ?
<Odin->
pjb: That's implementation-dependent, and not mandated by the Unicode standard.
<galdor>
as long as you only consider sane CL implementations, you can implement various processing tasks such as normalization, pluralization, segmentation, etc.
<pjb>
Odin-: indeed, in addition, trying would make your code non-conforming!
<galdor>
and for CL implementations using more exotic character representations, you can either implement the mapping character <-> codepoint yourself or just ignore them
<pjb>
So why would you do such a thing?
frgo has quit [Remote host closed the connection]
<Odin->
pjb: What?
frgo has joined #lisp
<Odin->
pjb: Non-conforming to what, exactly?
<galdor>
as in C, writing a program which does not depend on non-standard features is an exercice in futility
v_m_v has left #lisp [#lisp]
<pjb>
Odin-: code that depend on an implementation-dependent feature is non-conforming by definition.
frgo has quit [Remote host closed the connection]
<pjb>
Non-conforming to the standard.
<galdor>
then all useful programs are non-conforming
<Odin->
The CL standard, then?
<galdor>
again, exercice in futility
<pjb>
This is the basis of any discussion in #lisp, yes.
frgo has joined #lisp
<pjb>
galdor: you may try #sbcl if you prefer.
malaclyps[m] has left #lisp ["Kicked by @appservice-irc:matrix.org : User has been idle for 30+ days."]
<Odin->
In that case, any code that deals with characters in terms of code points is non-conforming.
<Odin->
Ever.
<pjb>
Exactly.
<pjb>
If you want to process codepoints, use integers.
<Odin->
Can't do that.
<pjb>
Of course. You do it in any other programming language.
<pjb>
Starting with C.
<galdor>
I find it disturbing that such a large part of the CL community is more interested in a dead standard than in trying to use the language to write useful programs
<pjb>
galdor: CL has perfetly good integers.
<galdor>
so I'm supposed to use (VECTOR INTEGER) for strings ? this is insane
<pjb>
galdor: no, you're supposed to use it for vectors of codepoints.
<pjb>
strings are vectors of characters, not of codepoints.
<Odin->
pjb: Hm, no, wait. Can do that. Can't use strings at all, because reading those from a file is implementation-dependent.
<galdor>
well I'll continue to use the representation which actually works
<galdor>
ultimately not being "conforming" does not matter
<pjb>
to you.
<galdor>
to people trying to solve problems with CL
<Odin->
A conforming CL implementation can only be an incomplete implementation of Unicode anyway.
<galdor>
I get it, CL is also very interesting as a pure language research subject
<galdor>
but it's not a crime to realize people have different needs
<pjb>
Did you realize it today?
<pjb>
Sure, I won't send the police to your home… you can sleep sound.
<Odin->
pjb: Have you realised?
djeis[m] has left #lisp ["Kicked by @appservice-irc:matrix.org : User has been idle for 30+ days."]
frgo has quit [Ping timeout: 260 seconds]
<Odin->
'cause you sound like you haven't.
<pjb>
Odin-: I suggested #sbcl!
<Odin->
Just pointing it out.
<galdor>
pjb: you're being unpleasant
edgar-rft has quit [Remote host closed the connection]
jjong has quit [Remote host closed the connection]
EvW has joined #lisp
<pjb>
The fact that in CL characters are not integers may be unpleasant to you. I'd suggest you to swith to C.
<sabrac>
This unicode discussion is both fasinating and scary as I try to write a normalisation function
edgar-rft has joined #lisp
<Odin->
pjb: The only way in which the standard does not require characters to be integers is that I can't find any language in it that prevents multiple characters from having the same code.
<Odin->
Characters in Lisp are codepoints. It's just not defined how they're mapped.
<pjb>
While character attributes are purely implementation dependent, this is an open door for unicode support too.
<galdor>
the encoding used by CHAR-INT is implementation dependant, i.e. useless in the real world
<galdor>
this is the same issue than external formats
<Odin->
Same is true of CHAR-CODE, actually.
<galdor>
which is why we end up using flexi-streams instead of something standard
<Odin->
It's _all_ implementation-dependent, because there is no standard mapping of codepoints to characters.
<galdor>
CHAR-CODE returns a "character-code", i.e. character code n. 1. one of possibly several attributes of a character. 2. a non-negative integer less than the value of char-code-limit that is suitable for use as a character code[1].
<galdor>
one could argue that either though CHAR-CODE talks about the "code attribute", both 1 and 2 apply
<galdor>
but the point is moot since major CL implementations reliabily use integers corresponding to codepoints
<Odin->
galdor: The code attribute, though, is implementation-dependent.
<galdor>
what I'm trying to explain is that playing lawyer with the standard is fun and all, but it does not solve any problem for people trying to actually use the language
sysz has quit [Quit: Quit]
gxt has joined #lisp
msk has quit [Remote host closed the connection]
elimik31 has joined #lisp
msk has joined #lisp
m00natic has joined #lisp
<Odin->
galdor: My point is that nowadays it wouldn't be sane to define implementation-defined attributes that make char-int and char-code different, so under normal assumptions either both are useful or neither is.
frgo has joined #lisp
EvW has quit [Ping timeout: 248 seconds]
<galdor>
sure
elimik31 has quit [Remote host closed the connection]
<galdor>
funny thing is, Babel uses CHAR-CODE and never CHAR-INT
<Odin->
I'm not saying you should use char-int.
<Odin->
:)
EvW has joined #lisp
<galdor>
but I guess Babel is non-conformant and should not be used; I mean who needs to actually manipulate encodings
<Odin->
Yup.
jonatack has joined #lisp
<galdor>
in a way I find it funny that so many CL veterans focus that much on being "conformant" when so many things in the CL standard is implementation-defined and therefore force developers to rely on non-conformant behaviours
elimik31 has joined #lisp
<galdor>
external formats being, I believe, the most hilarious aspect
* Odin-
pokes at IEEE 754 with a long stick.
frgo has quit [Ping timeout: 260 seconds]
<galdor>
floating point numbers are a mess in every language I know so it's too easy
FreeBirdLjj has joined #lisp
<galdor>
it's not that bad in CL, as long as you do not need to actually handle NaN, +-Inf, etc.
ebzzry has quit [Ping timeout: 265 seconds]
<jackdaniel>
implementations handle them given appropriate fpe-trap settings (of course as an extension)
<Odin->
Yeah, but the interesting thing about CL is that you can have conforming implementation with different float rounding behaviour.
<Odin->
Because it doesn't specify IEEE 754.
elimik31 has quit [Read error: No route to host]
<Odin->
Like virtually all other programming languages now do.
<galdor>
which just prove my point again on the fact that conformity to the standard is virtually useless
<Odin->
Yes; my intent was to reinforce that point. :)
<jackdaniel>
standard specifies some common base, you can't specify *everything*. but having a conformant Common Lisp program is a prerequisite for possible extension unification (you don't have to look back at things, which are already specified)
<pjb>
galdor: it is not incompatible to focus on being confomant, and using the data type that correspond to what you want to process, possibly using conforming libraries.
<galdor>
extension unification won't happen, I've been told repeatedly that it's too much work, and just to use external libraries
<pjb>
galdor: so indeed, when you want to process codepoints and unicode grapheme clusters, you should instead use a conforming library with its own data types, instead of trying to use cl:character.
<jackdaniel>
also it is possible to port conforming programs, while programs which use non-conformant behavior are not
<jackdaniel>
one way of unification is creation of portability libraries. where did you use sb-thread instead of bt last time?
<galdor>
in practice, there are simply no CL implementations with maintainers interested in improving the situtation
<jackdaniel>
the latter works on all implementations
<Odin->
pjb: And if you need to deal with anything to do with encoding, you can't be conformant, because there is no non-implementation-dependent way of going between integers and characters.
<jackdaniel>
also, package local nicknames are a proof that you are plain wrong ;-)
elimik31 has joined #lisp
<galdor>
bt is nice and all; but it should have been an extension to the standard, ratified by major implementations, and available the exact same way in implementations
<pjb>
Odin-: you can write conforming code to go between integers and characters.
<jackdaniel>
so making bold claims that someone is not interested in something is just a fud (fear, uncertainity and despair) talk ;)
<galdor>
instead you just have a library you hope someone will maintain, that you have to install/load everywhere
<jackdaniel>
of course you are entitled to your opinion, but when I guage opinions with facts I usually pick the latter ,p
<Odin->
pjb: Yes. But the integers are implementation-defined, so that's useless if you need to deal with specific encodings.
<pjb>
Odin-: but at least, fixnums can store utf-16 codepoints :-)
z147 has joined #lisp
bitmapper has joined #lisp
<Odin->
pjb: So what? You can't make strings out of those in a non-implementation-dependent way.
<pjb>
not cl:string, indeed.
<pjb>
since cl:strings are vectors of characters, and direly insufficient to represent sequences of grapheme clusters.
<pjb>
only take length for example…
<Odin->
You seem to suffer from the misconception that grapheme clusters are more useful than anything else.
<galdor>
all languages I know ignore the notion of grapheme clusters for anything but graphic rendering
<galdor>
which is fine
<Odin->
Grapheme clusters aren't even good for graphic rendering.
<Odin->
You need more information than that for proper rendering. :p
<galdor>
again it's not perfect, but there is no perfect solution because of the complexity of the domain (human language and its textual representation)
<galdor>
of course
<Odin->
Text is hard.
<Odin->
Most people try to pretend it isn't.
<Odin->
Those people tend to think Unicode is overengineered.
<jackdaniel>
I feel obligated to say, that again you go down the offtopic path
<galdor>
jackdaniel: is there a irc channel which is more about interesting Lisp-related discussions and not silence beyond standard lawyer debates ?
epony has quit [Quit: sysupgrade]
<Odin->
Dunno, this used to be it.
* Odin-
went away for a couple of years, though.
<galdor>
I'm starting to understand why so many people told me they left CL because of the community
<jackdaniel>
yes, it is called #lispcafe
<galdor>
who owns #lisp on freenode ?
<jackdaniel>
does it matter? topic states the, ehm, topic.
georgiePorgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<galdor>
oh well, at some point I do not know why I still try to pretend CL is worth putting up with all of this
galdor has quit [Quit: WeeChat 2.7]
galdor has joined #lisp
galdor has left #lisp [#lisp]
<jackdaniel>
rq count for today: 1.
shrdlu68 has quit [Remote host closed the connection]
<Odin->
Exhaustion, by the look of it.
georgiePorgie has joined #lisp
flamebeard has joined #lisp
<splittist>
Let me say that it is a pleasure to work with Plump and Lquery. Thank you Shinmera.
<Shinmera>
That makes me very happy to hear! :)
<jackdaniel>
people sometimes complain, that they don't want to discuss broader topics on #lispcafe, because some people they want to discuss it with are not on this channel. they probably never bothered to ask themself, *why* they are not on that channel.
jprajzne_ has quit [Quit: jprajzne_]
jprajzne_ has joined #lisp
<Odin->
jackdaniel: Is this channel only for conversations that are relevant to immediate questions about CL code?
<pjb>
Yes, basically.
<jackdaniel>
alternatively: other topics which are related to Common Lisp. in my understanding at least
<Odin->
jackdaniel: Evidently that relation has to be very direct.
jprajzne_ has quit [Client Quit]
jprajzne_ has joined #lisp
v_m_v has joined #lisp
<jackdaniel>
Odin-: it might be that I am too strict to judge, that discussing how useful are grapheme clusters in unicode is not related to Common Lisp; I believe it is not though
<Shinmera>
You are not too strict.
<jackdaniel>
thank you:)
v_m_v has quit [Ping timeout: 246 seconds]
JohnMS has joined #lisp
<jackdaniel>
I've looked up the previous discussion; fwiw I agree with galdor, that depending on unicode being implemented in CL is a sane thing to do
<jackdaniel>
and representing strings as vectors of integers is not ,_)
frgo has joined #lisp
<Odin->
jackdaniel: Meh, fair enough. I only mentioned it because pjb seems quite insistent that having characters encode grapheme clusters would be the right thing to do in Common Lisp, and I don't see how that's really any improvement.
<jackdaniel>
I usually take pjb advices with a huge grain of salt (no offence pjb)
JohnMS_WORK has quit [Ping timeout: 260 seconds]
<jackdaniel>
s/offence/offense
<pjb>
Odin-: this choice would give consistent and unsurprising results for length, and aref…
<Odin->
jackdaniel: They're both correct spellings, though.
<splittist>
jackdaniel: no need to Americanize
<jackdaniel>
I've looked up a dictionary and they have slightly different meanings according to it
<Odin->
pjb: It really wouldn't, though.
<jackdaniel>
that's why I've corrected myself
<pjb>
Odin-: the problem might be, as some argue, that cl:string are defined as vectors of characters. Perhaps when using Unicode, you want opaque strings, and API to get grapheme clusters and codepoints.
<pjb>
But we have to start from the cl standard…
<Odin->
jackdaniel: Really? They're UK v. US spellings, as far as I've ever determined.
* jackdaniel
doesn't insist and blame a dictionary; I'll be back later
<pjb>
So just go as far as we can, and then define (and standardize) specific APIs. Such as gray-streams, flexi-streams, or unicode.
<pjb>
babel could have been a candidate if it didn't have so many problems.
<pjb>
(API problems).
<Odin->
pjb: The problem is that grapheme clusters don't really capture language-dependent perceptions of length either.
milanj has quit [Quit: This computer has gone to sleep]
<pjb>
jackdaniel: unicode:string can be something else than vectors of integers or characters. but cl:strings are vectors of characters, you cannot change that.
<Odin->
So it's "unsurprising" only as long as you're not doing anything unusual - which is true of NFC in codepoint terms.
<pjb>
Odin-: the point is that you should not use cl:string for unicode stuff. since cl:length doesn't work.
<Odin->
It doesn't?
<jackdaniel>
length returns size of the array
<pjb>
No. (length "été") #| --> 5 |#
<jackdaniel>
while in unicode one character may be composed of many elements
<Odin->
Oh, you mean you might cut across grapheme clusters if you do something arbitrary?
<pjb>
That's why you want to map grapheme clusters to characters, instead of codepoints. SO that cl:length is more useful for cl:string containing unicode stuff. (This is actually a argument in favor of galdor, but he couldn't understand it).
<Odin->
pjb: What you are proposing is literally no different from defining Unicode codepoints for all possible composed characters and using only NFC.
<pjb>
Odin-: not codepoints, char-codes.
<Odin->
pjb: No. Codepoints. Because you'd get the exact same situation if they were defined in Unicode.
<Odin->
Including the normalisation problems.
<pjb>
As for normal forms, I'm not sure, this needs more study. One problem I have is that in some normal forms, é is mapped to é.
<Odin->
Unless you remove the composing characters from Unicode.
<pjb>
But in any case, I'm saying that it doesn't matter much, once you have a good unicode library.
<Odin->
(Which isn't going to happen.)
<Odin->
Which you say can't possibly be conforming.
flamebeard has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
<pjb>
Note for example, that most unicode I/O is not done thru cl:character streams (because it's implementation dependent). So you would use binary streams, utf-8 and receive and send binary data, thing that a unicode package can do conformingly without ever touching a cl:character.
<Odin->
Yes, but that way you can't ever work with it as a string in CL.
<pjb>
For example, if you use a GUI, you cannot use CL:CHARACTER (GUI libraries don't know about cl:characters, only about codepoints or utf-8, ie. a binary API). So you go file -> utf-8 -> unicode library -> utf-8 -> GUI binary API.
<Odin->
Except by using a redefined string library working on your representation, which won't interoperate with stuff that doesn't expect that representation.
elimik31 has quit [Remote host closed the connection]
<Odin->
Because, under your terms, there is no way to go from characters to Unicode that isn't non-conforming.
<pjb>
It would probably be the best, indeed.
<Odin->
That's idiotic.
<jackdaniel>
take a huge grain of salt! ;)
<Odin->
And, incidentally, should also apply to ASCII.
<pjb>
Well, the cl:character set covers all the ASCII characters, so it's easier :-)
<Odin->
What's more, it includes a non-ASCII character.
<pjb>
ASCII encodes boths characters and control codes.
<Odin->
Wait, you exclude control codes from being characters?
<pjb>
Yes.
<Odin->
I guess I can see why you hate Unicode.
jonatack has quit [Ping timeout: 246 seconds]
<pjb>
I don't hate it.
<pjb>
On the contrary, since I'm advocating for the implementation of a good and complete unicode library in conforming CL.
jonatack has joined #lisp
<Odin->
So, despite clearly being intended to allow for extensible external encodings, what you are saying is that any Common Lisp program that expects to be able to use characters other than the graphical characters of ASCII (and the non-ASCII character 'newline') is non-conforming?
<pjb>
#\newine as you mentionned is a CL character. It not an ASCII control code. Best proof, is printing it on MS-Windows issues TWO ASCII control codes!
v_m_v has joined #lisp
<pjb>
(two codepoints if you use unicode).
<Odin->
Oh, right. Strings cannot be transferred outside the image _at all_ without implementation-defined behaviour.
rumbler31 has quit [Remote host closed the connection]
doublex_ has joined #lisp
elimik31 has left #lisp ["ERC (IRC client for Emacs 28.0.50)"]
milanj has joined #lisp
rememberYou has joined #lisp
doublex__ has quit [Ping timeout: 265 seconds]
rememberYou has quit [Client Quit]
dddddd has joined #lisp
elimik31 has joined #lisp
elimik31 has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 268 seconds]
shifty has joined #lisp
rememberYou has joined #lisp
rememberYou has quit [Remote host closed the connection]
rememberYou has joined #lisp
rememberYou has left #lisp [#lisp]
georgiePorgie has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
EvW has quit [Ping timeout: 245 seconds]
alejandrozf has joined #lisp
statusf90 has joined #lisp
georgiePorgie has joined #lisp
gko_ has joined #lisp
jjong has joined #lisp
amerlyq has joined #lisp
X-Scale` has joined #lisp
shrdlu68 has joined #lisp
X-Scale has quit [Ping timeout: 268 seconds]
X-Scale` is now known as X-Scale
FreeBird_ has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
Cymew has quit [Ping timeout: 272 seconds]
ym has quit [Remote host closed the connection]
<Xach>
stick shift and safety belts
<Xach>
(wrong channel)
<scymtym>
you misspelled CL:SHIFT while CL:SAFETY is fine. mostly on-topic i would say
<scymtym>
*CL:SHIFTF
jjongmc has joined #lisp
pfdietz has joined #lisp
cosimone has quit [Ping timeout: 248 seconds]
developernotes has joined #lisp
loke has quit [Read error: Connection reset by peer]
<ioa>
Hi! So, the "news" section in common-lisp.net has a lot of broken links... Most importantly, cl-foundation.org is broken.
cosimone has joined #lisp
<Xach>
ioa: there is a medium-activity channel for common-lisp.net called #common-lisp.net and the site admins are there
<Xach>
that's the channel i visit when i have common-lisp.net feedback
<beach>
cyberyl: Are you new here? I don't recognize your nick.
<cyberyl>
yeah, i just decided to check whether there is a lisp channel on freenode. i have not yet started to learn it but i'm interested
<beach>
Great!
<beach>
There is also #clschool for truly basic questions.
<cyberyl>
i would like to read SICP, learn emacs, and maybe check out clojure, but i'm a total noob
<cyberyl>
i mean learn to use the emacs editor
<beach>
I see. However, this channel is dedicated to Common Lisp.
<cyberyl>
ok got it, i dont have a prefered dialect of lisp, since i dont know very much yet, but i mentioned clojure because it seems to be pretty big now
<cyberyl>
in popularity
<Xach>
i think it has peaked somewhat, but fortunately useful things need not be the most popular to remain useful
sjl has quit [Quit: WeeChat 2.2-dev]
<Xach>
Common Lisp is not very popular but I find it very useful!
<cyberyl>
that's true, im not saying clojure is the best language, and im interested in commmon lisp as well, i have bookmarked the practical common lisp book
pvaneynd has quit [Remote host closed the connection]
<beach>
cyberyl: The programming style would be very different in Clojure and Common Lisp.
<beach>
cyberyl: A lot of modern Common Lisp code is object-oriented through the use of CLOS features such as classes and generic functions.
<gendl>
Zach: ioa: the cl-foundation.org issue was already brought to my attention, thanks for the reminder, I will get those sorted out ASAP.
<gendl>
Also note that we now also have cl.foundation
WorldControl has joined #lisp
WorldControl has quit [Quit: Exeunt]
<ym>
Just typed "cl.foundation" in firefox URL bar and it opened the site. "Foundation" as TLD?
<Bike>
yeah, ICANN got a little weird with those
<_death>
they should have a $$$ tld
fivo has quit [Quit: WeeChat 1.9.1]
cyberyl has left #lisp ["WeeChat 2.5"]
<Xach>
There's a .cl TLD but no .lisp.
<Xach>
So it works for Franz but not most others.
EvW1 has quit [Ping timeout: 245 seconds]
<pfdietz>
Heh
<pfdietz>
I am very old school and sometimes use .lsp
random-nick has joined #lisp
<Xach>
grew up so poor you couldn't afford vowels
<pfdietz>
Xach: I have a pull request in to fix chanl, but it hasn't been merged yet.
<Xach>
pfdietz: thanks
madage has quit [Remote host closed the connection]
madage has joined #lisp
<pfdietz>
Wait, I'm not seeing these failures in the ql daily report anymore.
<pfdietz>
Ah, it switched back to sbcl 1.5.8
<Xach>
yes
<Xach>
a new set of failures
msk has quit [Remote host closed the connection]
msk has joined #lisp
pvaneynd has joined #lisp
whiteline_ has quit [Remote host closed the connection]
msk has quit [Remote host closed the connection]
whiteline_ has joined #lisp
msk has joined #lisp
jonatack has quit [Ping timeout: 268 seconds]
pvaneynd has quit [Ping timeout: 265 seconds]
shrdlu68 has quit [Ping timeout: 260 seconds]
whiteline_ has quit [Remote host closed the connection]
whiteline_ has joined #lisp
shrdlu68 has joined #lisp
refpga has joined #lisp
jjong has quit [Remote host closed the connection]
adriano1 has joined #lisp
cosimone has quit [Quit: Terminated!]
frgo has quit [Remote host closed the connection]
pvaneynd has joined #lisp
pvaneynd_ has joined #lisp
ljavorsk has joined #lisp
pvaneynd_ has quit [Remote host closed the connection]
asdf_asdf_asdf has joined #lisp
pvaneynd_ has joined #lisp
pvaneynd has quit [Ping timeout: 260 seconds]
bitmapper has quit [Remote host closed the connection]
wsinatra has joined #lisp
jonatack has joined #lisp
wsinatra has quit [Client Quit]
wsinatra has joined #lisp
efm has joined #lisp
sjl_ has joined #lisp
frgo has joined #lisp
jmercouris has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
<Xach>
If you have not already seen it, ultralisp.org has a great new search system - it returns results from symbol names and docstrings for your search term
<Xach>
For example, I wanted to search for base64-related stuff, and it was very easy with the new search
<Xach>
That's much nicer than just looking at project or system names
frgo has quit [Ping timeout: 240 seconds]
sabrac has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 260 seconds]
<jmercouris>
so I'm using Cl-gobject-introspection, and I have no idea how to debug with it
shifty has joined #lisp
<jmercouris>
any idea on how to get messages from GTK upon failure forwarded into Lisp land?
<jmercouris>
something fails silently, and I have no idea how to approach the problem
Achylles has joined #lisp
jmercouris has quit [Remote host closed the connection]
lucus16 has joined #lisp
Necktwi has quit [Read error: Connection reset by peer]
shka_ has joined #lisp
frgo has joined #lisp
ljavorsk has quit [Ping timeout: 260 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
Necktwi has joined #lisp
clothespin has joined #lisp
notzmv has quit [Remote host closed the connection]
<gendl>
ym: yes, .foundation as TLD. cl-foundation.org should continue working as well though (and probably should redirect to cl.foundation) - i have to clear a few things off my desk before diving in to fix that.,
oni-on-ion has quit [Ping timeout: 260 seconds]
hhdave has quit [Quit: hhdave]
bitmapper has joined #lisp
davepdotorg has quit [Remote host closed the connection]
gko_ has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 248 seconds]
m00natic has quit [Remote host closed the connection]
igemnace has quit [Ping timeout: 240 seconds]
v_m_v has quit [Remote host closed the connection]
notzmv has joined #lisp
shangul has quit [Ping timeout: 260 seconds]
Gerd has quit [Quit: Gerd]
aeth has quit [Ping timeout: 260 seconds]
Gerd has joined #lisp
Gerd has quit [Client Quit]
aeth has joined #lisp
madrik has quit [Remote host closed the connection]
Gerd has joined #lisp
emphazizer has joined #lisp
emphazizer has quit [Max SendQ exceeded]
emphazizer has joined #lisp
jonatack has quit [Ping timeout: 248 seconds]
LiamH has joined #lisp
ggole has quit [Quit: Leaving]
bitmapper has quit [Ping timeout: 265 seconds]
cosimone has joined #lisp
lotuspsychje has joined #lisp
space_otter has quit [Remote host closed the connection]
EvW has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
Gerd has quit [Quit: Gerd]
cosimone has quit [Quit: Terminated!]
orivej has joined #lisp
lotuspsychje has left #lisp ["Leaving"]
cosimone has joined #lisp
emphazizer has quit [Quit: Leaving]
shka_ has quit [Ping timeout: 268 seconds]
jonatack has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
cosimone has quit [Quit: Quit.]
EvW has quit [Ping timeout: 248 seconds]
pirmino has joined #lisp
scymtym has joined #lisp
jmercouris has joined #lisp
sauvin has quit [Ping timeout: 272 seconds]
milanj has quit [Quit: This computer has gone to sleep]
fookara has quit [Remote host closed the connection]
orivej has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
adriano1 has quit [Ping timeout: 252 seconds]
adriano1 has joined #lisp
cosimone has joined #lisp
adriano1 has quit [Ping timeout: 268 seconds]
rippa has joined #lisp
msk has quit [Remote host closed the connection]
msk has joined #lisp
tux has joined #lisp
EvW1 has joined #lisp
smazga has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
kmeow has quit [Remote host closed the connection]
bitmapper has joined #lisp
jmercouris has quit [Remote host closed the connection]
msk has quit [Remote host closed the connection]
msk has joined #lisp
nckx has quit [*.net *.split]
mood has quit [*.net *.split]
mood_ has joined #lisp
nckx- has joined #lisp
nckx- is now known as nckx
notzmv has quit [Ping timeout: 268 seconds]
jhei has quit [Ping timeout: 268 seconds]
jhei has joined #lisp
<asdf_asdf_asdf>
Hi. Sorry for question, but I can't found it. If UTF-8 not encode char as 0xffff, so which encoding encode char as 0xffff without BOM?
gravicappa has quit [Ping timeout: 268 seconds]
orivej has quit [Ping timeout: 260 seconds]
narimiran has quit [Ping timeout: 268 seconds]
<asdf_asdf_asdf>
In which encoding I should file .txt, that Common Lisp read this file character by character and get 0xffff value?
msk has quit [Remote host closed the connection]
msk has joined #lisp
tux has quit [Quit: tux]
<Xach>
asdf_asdf_asdf: why?
didi has joined #lisp
<didi>
Does anyone know where can I find the sources of XLISP-STAT?
<asdf_asdf_asdf>
Xach, value 65535 after cast to (int)(unsigned char)65535 == -1. This mean's EOF (end of file).
milanj has joined #lisp
<Xach>
asdf_asdf_asdf: in what context?
Fare has joined #lisp
<Xach>
didi: i had a link but it is dead :(
<didi>
Xach: :-( Thank you.
<asdf_asdf_asdf>
I want put character about code 65535 and if I get char by char I want get EOF. Yes, Ctrl-Z Win, and Ctrl-D Linux. But I search character about code 0xffff.
<ym>
didi, archive.org maybe?
<didi>
ym: I tried, but no luck.
<Xach>
asdf_asdf_asdf: why?
<asdf_asdf_asdf>
I want, that loop stop when see -1(int)(unsigned int)(65535) == -1 (EOF).
<Xach>
asdf_asdf_asdf: it is impossible. you need a different approach.
<asdf_asdf_asdf>
Xach, it's possible maybe, because I define int as char type and should works, but I can't find character about this code.
<Xach>
asdf_asdf_asdf: no, it is impossible.
<Xach>
asdf_asdf_asdf: you need to do something different.
ebrasca has quit [Remote host closed the connection]
Josh_2 has joined #lisp
<asdf_asdf_asdf>
Xach, occur with wide characters or with ordinary characters that are as wide as int. It is true or false?
<Xach>
asdf_asdf_asdf: characters in common lisp are not integers.
<Bike>
lisp read functions do not return an EOF character because there is no EOF character. they use an out of band mechanism like signaling an error, or returning a special value you provide which is probably not a character.
<Xach>
There are no wide characters or narrow characters.
<asdf_asdf_asdf>
Yes, but I can cast most type lisp to other and I got wide character.
<Xach>
asdf_asdf_asdf: there is no casting in lisp.
<Bike>
If you want to write C just write C.
<Bike>
Although even in C I don't think EOF is exactly a character.
<asdf_asdf_asdf>
SBCL alien's have.
<Xach>
It cannot work.
<jackdaniel>
"alien" says it all, it is something not lispy ,)
<Bike>
You went to the hardware store and bought a drill and you are using it to hammer nails
<Xach>
asdf_asdf_asdf: what kind of file processing are you doing?
<asdf_asdf_asdf>
I think, that is character in CL, which occur EOF, which do premature close the read.
<asdf_asdf_asdf>
Text file (.txt).
didi has left #lisp ["O bella ciao bella ciao bella ciao, ciao, ciao."]
<Xach>
asdf_asdf_asdf: No, there is no character representing EOF in CL. Or in C.
<Xach>
asdf_asdf_asdf: since you control the text file, you can put in some special sequence to indicate to the loop to stop.
<asdf_asdf_asdf>
Yes, but should be bit-pattern to the same behavior, e.g. close the read file.
<Xach>
asdf_asdf_asdf: incorrect. it does not work that way in CL. Or in C.
<Xach>
it cannot work and you must find a different approach if you want in-band signaling.
v_m_v has joined #lisp
<Bike>
none of this says EOF is a character
<Bike>
in fact it's largely about how much effort goes into ensuring that it is not a character
<asdf_asdf_asdf>
Try press Ctrl+d in Linux or Ctrl+z in Windows. You got characters e.g. SUB in Windows. Later paste it to middle in file. Parsed it file you file not parsed to the end.
<Xach>
asdf_asdf_asdf: no, incorrect. Ctrl-d is a signal to the unix terminal driver to send all pending input.
msk has quit [Remote host closed the connection]
<Xach>
asdf_asdf_asdf: if there is no pending input, read() returns a zero-length read which means EOF.
<Bike>
in fact - IN FACT - "The C Standard feof() and ferror() functions are not subject to the problems associated with character and integer sizes and should be used to verify end-of-file and file errors for susceptible implementations"
msk has joined #lisp
<Bike>
this page specifically says to not do what you want to do
<Bike>
in C
<Xach>
if there is pending input, read() returns that input without a newline required.
<Xach>
there is no character in the returned buffer that is treated as a special EOF character. it is the length of the returned data that matters.
<asdf_asdf_asdf>
I don't know which character is equivalent to Ctrl-Z SUB from Windows. Sorry. If it is not possible, it thanks.
<Xach>
it is not possible and you need a different approach
<asdf_asdf_asdf>
I try in ##C, maybe.
Achylles has quit [Quit: Leaving]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 265 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
asdf_asdf_asdf has quit [Remote host closed the connection]
msk has quit [Remote host closed the connection]
notzmv has joined #lisp
msk has joined #lisp
<aeth>
all of this debate about Unicode encoding yesterday and it turns out asdf_asdf_asdf when providing more context just wanted an EOF value
<aeth>
and somehow read that #xffff is EOF or something
<no-defun-allowed>
asdf_asdf_asdf: If you call any function starting with READ without all the arguments, it will signal a condition when the end of the stream has been reached.
amerlyq has quit [Quit: amerlyq]
<aeth>
no-defun-allowed: Odds are that asdf_asdf_asdf is using Windows's read function directly through SBCL's FFI (not something portable like CFFI) for whatever reason and wants to detect EOF via that, rather than making it easy with READ-BYTE or READ-CHAR. This is just what I can piece together, though. asdf_asdf_asdf is bad at asking questions.
msk has quit [Remote host closed the connection]
msk has joined #lisp
<aeth>
(I mean, it took literally an entire day to figure out that asdf_asdf_asdf wanted 0xffff/#xFFFF because asdf_asdf_asdf assumes that it's an EOF value)
<aeth>
no-defun-allowed: From what I can gather, asdf_asdf_asdf is taking some sort of "introduction to writing C in Windows" tutorial and painfully slowly, over the course of at least one year, trying to translate it token-for-token directly into SBCL-specific, Windows-specific FFI.
<aeth>
But they never state things that directly.
<Shinmera>
I don't know why people continue to engage even though nothing ever comes from it except noise discussion.
<aeth>
Shinmera: because asdf is purposefully leaving out context to make the problem seem reasonable because asdf knows that if asdf provides the full context, then people won't help. asdf already asks about the FFI stuff in #sbcl after being told that only portable stuff like CFFI will be answered in here
<Shinmera>
This has been a continuous thing for months now. I would think people clue in by now.
<aeth>
not months, at least a year
<aeth>
asdf is trying to do an advanced interface (WinAPI is no joke) between CL and C while knowing neither language well.
<aeth>
Shinmera: Maybe not quite a year (although this might not be the earliest point). I did tell asdf_asdf_asdf that the whole thing could be automated away with claw (a fork of autowrap) on 2019-05-15 and borodust (the fork's author) offered to do that if asdf provided which parts of the winapi. So the whole thing could have been over "in 15 min or smth". https://irclog.tymoon.eu/freenode/%23lisp?around=1557951157#1557951157
<Shinmera>
you don't need to convince me of my own point.
<aeth>
Shinmera: This is providing a supporting point, for anyone who is reading.
v_m_v has quit [Ping timeout: 240 seconds]
<aeth>
It has been about 260 days since the whole thing could have been automated away in 15 minutes with claw...
Bike has quit [Remote host closed the connection]
Bike has joined #lisp
<Bike>
i have an indefatigable belief in the spirit of communication. but if you want to ban them i won't mind. they were, after all, already banned, and only came back because the channel banlist happened to be full at the time
random-nick has quit [Ping timeout: 240 seconds]
bitmapper has quit []
<jackdaniel>
I've been already dubbed a bad guy today, don't look at me ,)
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
developernotes has quit [Quit: leaving]
slyrus_ has joined #lisp
shifty has joined #lisp
slyrus__ has quit [Ping timeout: 268 seconds]
msk has quit [Remote host closed the connection]
msk has joined #lisp
pfdietz has quit [Remote host closed the connection]
<Xach>
i'm glad to see the end of the direct insults and attacks. that seems like a form of progress.
Fare has quit [Ping timeout: 265 seconds]
EvW1 has quit [Ping timeout: 272 seconds]
shifty has quit [Ping timeout: 240 seconds]
asdf_asdf_asdf has joined #lisp
jeosol has quit [Remote host closed the connection]
sjl_ has quit [Ping timeout: 240 seconds]
msk has quit [Remote host closed the connection]
msk has joined #lisp
ljavorsk has joined #lisp
msk has quit [Remote host closed the connection]
msk has joined #lisp
Bike has quit [Quit: Bike]
z147 has quit [Ping timeout: 240 seconds]
ljavorsk has quit [Ping timeout: 268 seconds]
msk has quit [Remote host closed the connection]
msk has joined #lisp
v_m_v has joined #lisp
rumbler31 has joined #lisp
EvW has joined #lisp
msk has quit [Remote host closed the connection]
_whitelogger has joined #lisp
zooey has joined #lisp
<asarch>
Why I can '(Lisp simply rocks!) but I can't (list lisp simply rocks!) and neither (quote lisp simply rocks!)?. What is ('...)?
<asarch>
I thought ('...) was a shortcut for (quote ...)
<no-defun-allowed>
'(foo ...) is (quote (foo ...))
<no-defun-allowed>
(list 'lisp 'simply 'rocks!) ; would create a list that is EQUAL to that quoted list
* asarch
is fixing his notes...
<asdf_asdf_asdf>
Quote is not evaluated, while `(,Lisp is evaluated.
<pjb>
asarch: you're wrong. '… is a reader macro that reads as (CL:QUOTE …)
<pjb>
('…) is read as ((CL:QUOTE …)) ; which by the way is not a lisp form.
cosimone_ has joined #lisp
cosimone_ has quit [Client Quit]
<asarch>
`(, <- Quasiquoting :-)
<pjb>
You can perfectly well do (list lisp simply rocks!): (let ((lisp 1) (simply 2) (rocks! 3)) (list lisp simply rocks!)) #| --> (1 2 3) |#
<asarch>
Flip and flops
<pjb>
and you cannot do (quote lisp simply rocks!) because CL:QUOTE takes only 1 argument.