| |
| |
| |
|
Page: 1 2 3 4 5 6 7 8 9
Comments:
<0> OK, thanks
<1> Xach: you don't necessarily have to write your own analyzer, you might get acceptable results with the standard one.
<2> Hi, is there a case-string-equal macro already defined?
<2> or case-arbitrary-equalityp ?
<3> puchacz: No. Google for `with-hashed-identity'.
<2> thakns
<2> adeht: ok, it works for me.
<4> puchacz: string-equal?
<5> ignas: it works for you? (:
<5> cool!
<2> rpg: I already found what I was looking for; google for equal-case and with-hashed-identity.
<5> that's great!
<4> puchacz: But why do you need those instead of just string-equal, which compares strings in a case-insensitive way?
<5> ignas: may I quote you on my blog on this? (:
<2> rpg: no, I wanted (case xxx (clause-1 ..) (clause-2 ...) (otherwise ...)) but with string-equal rather than eq.
<6> antifuchs: yes :)
<5> sweet!
<4> puchacz: Ah! Sorry. Now I see.
<2> having said that, when I have a stream open on a file, how can I (binary) copy it to another file?
<3> Google for cl-fad; see `copy-stream'.
<2> adeht: thanks, let me check
<7> Krystof: I haven't yet tried your patch, but it look more sane than my old mess
<7> (which nobody used anyway)
<6> yippie, trivial-html-parser was born
<5> may I suggest a name more in the line of realistic-html-parser? (:
<5> because I really don't think what it does is trivial (:
<6> well, if I could hack it in ~3 hours - it's trivial :)
<8> i thought trivial- was just the codename for lisp-. :)
<6> hack it off Closure that is
<5> haha
<5> disclosure, at that (:
<6> closure has so many nice things, but it depends on network, threads, CLX and McClim which renders their code very difficult to use
<5> I'd be very interested in a description of how you extracted the stuff you needed
<6> well - i took the script _deepfire posted
<5> ah
<6> converted it into asdf using library
<7> Krystof: I still think there ought to be a way to know when we've gained/lost focus at the WM level, although the only use I can think of it is for emacs-style hollow cursors.
<6> moved all the files under the same directory tree in the library
<6> removed obviously unused files
<6> then generated the dependency lisp.expr
<6> removed files not required by the html-parser.lisp
<6> cleaned up, moved files, and that's it
<6> i had to do some work to get rid of url dependency
<6> the rest was just safely and cleanly deleting code
<5> cool
<6> antifuchs: i wanted some callgraph generator, but as these were not available ... :)
<5> (:
<9> there seems to be a restriction that set-macro-character doesn't take effect until after the current form--probably because the parse tree is already generated for the current form
<9> is there a way around this, so I can use my macro character in the same form as the one I define it in?
<6> brainly-green: common-lisp reads everything in ***ps, so i'd guess that - no you can't
<10> holy circularity brainly-green!
<11> yeah even perl doesn't let you do that ;)
<9> well I want to have a function (startblock) that alters the reader temporarily until it reaches (endblock) so that in between (startblock) and (endblock) I can have my own syntax
<10> brainly-green: ok, so?
<9> and I don't want to permanently change the readtable
<9> so I thought I could set a macro character in startblock and then immediately use that macro character
<11> with-readtable ;)
<9> I'm trying to avoid having to wrap my syntax in parens
<11> hm this comes up in google: http://www.wozniak.ca/?p=77
<9> so that you can use slime-close-parens-at-point without it ending the form
<9> I mean without it ending the block of syntax
<12> brainly-green: #.(start-block-with-my-fancy-syntax)
<9> that would work but I still do resent the #.
<12> you have to do a _read-time_ eval in order to affect the _reader_
<10> rahul: unless it's a toplevel form, no?
<12> pkhuong: right, but he wants to have it affect the reader directly
<12> effect, rather
<12> affect, bleh
<12> effecting a reader would be interesting... dunno what you'd do with that reader, tho :P
<13> #. isn't really good for that. consider something like (progn #.(start) value #.(end)))
<9> why wouldn't that work jsnell?
<9> oh
<9> right
<13> it would evaluate to the value of the form that END returns, not to the value of VALUE
<12> yes
<9> well wait
<9> no, #.(start) would take the arguments "value #.(end)" and transform them into a return value
<9> it wouldn't leave the #.(end) hanging there
<12> you'd have to create your own reader syntax for that, then
<13> good luck writing that
<12> and have something to enable and disable that
<9> what do you mean enable or disable it
<12> #.(enable-wacky-syntax) (progn (f) (g) #{my%wacky-!syntax}) #.(disable-wacky-syntax)
<9> I wouldn't need to disable it if the name is #.(end)
<9> I mean #.(start)
<3> rahul: You don't need #. for that... `eval-when' will do.
<12> that makes no sense
<9> because that's just like a function name, there's not so much of a need to conserve the namespace
<10> rahul: or #.(enable-wacky-syntax) ... [magic character]
<12> adeht: right
<9> it would be enabled when loaded
<12> pkhuong: yeah, #{ was the magic character there
<9> and stay enabled
<12> "when loaded"?
<12> how would you enable it?
<9> when the package defining my syntax is loaded, it would change the readtable
<13> umm... didn't you just say that you didn't want to change the readtable?
<12> and when some other package makes a modification to the same character?
<9> I didn't want to change the readtable if I just had 1 little reader character
<9> because there aren't so many single characters
<9> but if I had something like #.(start)
<9> then there would be no conflict since that's a real name, just like anything else
<12> it would have to _do_ something, tho
<3> The enable function will copy the current readtable and set its own; the disable function will restore the readtable.
<9> hmm
<12> or it could just do nothing and we can forget this whole discussion happened :)
<9> well what I really want is to enable the readtable AND use the macro character so that I can turn the rest of the code into a stream I can work with, all in 1 function
<9> I want to combine the enabler and the macro character
<11> you could always just not put square pegs into round holes by putting your different syntax contents in a separate file
<9> I know, I thought of that
<9> now this is weird, how come when I enter ("( it adds about 10 closing parentheses every time I do C-c C-q to close-parens-at-point
<9> SLIME bug?
<9> actually it always adds a whole lot of closing parens whenever it's inside a string that's inside a form
<9> try typing (" C-c C-q
<9> it gives me ("))))))))))))))))
<9> 15 closing parens if my count is right
<9> and I just started a new SLIME so it's nothing I was doing to the buffer
<13> none of this is surprising, once you understand what C-c C-q actually does
<9> isn't it supposed to close all the open parentheses?
<9> except I only had 1 open parenthesis
<9> C-c C-q is slime-close-parens-at-point
<13> no, it's not
<13> consider C-c C-q (foo (bar^ ), with point at ^
<9> yes, it is, that is what it is bound to in my emacs
<13> it should add one paren. closing all parens would mean adding two
<9> jsnell have you tried the thing I said?
<9> I just opened a brand new SLIME, nothing in the history whatsoever, and typed (" C-c C-q and it gave me ("))))))))))))))))
<13> yes, and as I said, that is not surprising
<9> C-c C-q (foo (bar^ ) gives me (foo (bar)) as I'd expect
<9> I don't get your point
<13> yes, that's what I ****ing wrote
<14> (" is a bug, apparently.
<13> my point was that your description of what it does ("closes all parens") is wrong
<13> what C-c C-q does is add parens at the point, until the whole form is valid
<13> no amount of parens added inside an open string will do that
<14> So it should add no amount of parens. But it adds 15 of them. What gives?
<13> it tries a certain amount of times, and then gives up
<9> ah it always gives up after 15
<9> that's weird
<9> ((((((((((((((((((((((((((( C-c C-q => ((((((((((((((((((((((((((())))))))))))))))
<13> anyone doing that deserves to lose
<0> is there a standard function to transform a 1x81 array to a 9x9 one?
<13> depends on what you mean by transforming. have a look at displaced arrays
<13> for example (make-array (list 2 2) :displaced-to #(1 2 3 4))
<0> that's what I'm searching for, thanks
<13> but there are a couple of things that you should note: the 9x9 array won't be a simple-array
<13> and it'll share structure with the 1x81 array (changes to one will show up in the other)
<13> though the latter part is easy to solve
Return to
#lisp
or
Go to some related
logs:
linux gif editor debian
#debian
eggdrop please consult the default config file for info
#kde
Non-stinky keyboard
perl MSocket SOMAXCONN
/usr/lib/python2.4/site-packages/apt/__init__.py:17: FutureWarning: apt API not
#debian
#lisp
#perl
|
|