freenode/#lisp - IRC Chatlog

21:55:52 theruran_ ** NICK theruran

22:01:28 aeth_ ** NICK aeth

22:13:32 sauvin_ ** NICK Sauvin

22:33:30 copec What .xsd viewer do people like using under *nix?

22:39:41 phoe you mean xml schema files?

22:39:45 copec yeah

22:40:27 copec I've previously only done math things in CL as a hobby, but I'm trying to interface with Plesk panels that I manage for my work

22:41:53 phoe the naïve way would be to use emacs with some sorta xml-mode since a schema is just an xml document

22:42:23 phoe a more involved way would be to try and convert that into s-expressions and/or a nested Lisp object mayhaps

22:43:24 phoe I wonder if plump can load XSD files... why wouldn't it

22:44:09 copec They have them rendered as .svg's but without a legend or anything, I guess I can look at the actual .xsd files and lookup what the tags mean in the branches

22:45:22 copec I have two initial thoughts on implementation, simple functions that wrap the stream with tags, but it would be neat to figure out a macro to write a defclass hierarchy from the xsd

0:56:11 bmansurov o/ Can anyone please explain why the following macro doesn't work?

0:56:14 bmansurov (defmacro positivep (x)

0:56:15 bmansurov (> x 0))

0:56:15 bmansurov (positivep pi)

0:56:18 bmansurov

0:58:14 bmansurov Or this:

0:58:16 bmansurov (defmacro positivep (x)

0:58:16 bmansurov `,(if (> x 0) 'Yes 'No))

0:59:45 Alfr You should use defun for that.

1:00:43 no-defun-allowed Indeed. Though I assume you would want to make sure the returned form tests X, as the macro currently tests if the symbol PI is greater than 0.

1:00:50 no-defun-allowed clhs plusp

1:00:50 specbot http://www.lispworks.com/reference/HyperSpec/Body/f_minusp.htm

1:01:50 Alfr And as for why it doesn't work, macro expansion doesn't evaluate its arguments. Thus you're passing the symbol PI, and then X is bound to it, thus you're trying to evaluate (> 'PI 0).

1:02:59 Alfr no-defun-allowed, I knew that I missed something, couldn't recall that name.

1:03:17 bmansurov Thanks both. Assuming I want to make that macro work, how do I pass the constant PI to the macro, rather than the symbol?

1:03:33 no-defun-allowed If you really wanted to, you may write (defmacro positivep (x) `(if (,x 0) 'yes 'no))

1:05:37 bmansurov I see. I guess I should share another example where the problem I'm trying to solve is more pronounced. Here it is:

1:05:38 bmansurov (defmacro seq (from to)

1:05:38 bmansurov `(loop for i from ,from

1:05:38 bmansurov ,(if (> from to) 'downto 'to) ,to

1:05:41 bmansurov collect i))

1:05:51 White_Flame the parameters passed into defmacro are source code

1:06:02 White_Flame so if you want to pass something, it has to be absolutely literal

1:06:09 bmansurov (seq 10 3) works in the above example, but (seq 10 pi) doesn't.

1:06:31 White_Flame however, in most cases, what you really want is to construct code that the compiler will collapse for you, instead of trying to fiddle stuff at this level

1:07:11 White_Flame right, because (> 10 'pi) doesn't compare

1:07:20 White_Flame the literal symbol PI is the 2nd parameter to the macro

1:07:27 White_Flame again, it's passing source code

1:07:47 White_Flame the forms themselves, long before anything is evaluated

1:08:16 no-defun-allowed You will have to decide if (> from to) at runtime, perhaps by replicating and generating (if (> from to) (loop ... to ...) (loop ... downto ...)). But this would again be better as a function.

1:08:25 White_Flame this is a runtime decision you have to make, based on the actual runtime value being passed into a call; this isn't something you can statically resolve

1:09:03 bmansurov OK, thanks. So there's no way to solve the above problem with macros other than creating two loops?

1:09:51 White_Flame if you make 2 loops, you'll have a (if (> from to) (loop ...) (loop ..)), and if FROM & TO are numeric literals, the CL compiler should constant collapse one of them away

1:10:07 White_Flame but, an inline function would be more suitable there than a macro

1:10:27 White_Flame to accomplish the same

1:10:49 bmansurov I went this rabbit hole because I didn't want to write a function with two loops. I appreciate everyone's responses.

1:10:50 White_Flame s/numeric literals/numeric constants/

1:11:46 White_Flame even if you special-cased in a test for pi, what would you think ot generate for (seq x y) ?

1:11:51 White_Flame *to

1:13:55 bmansurov I hadn't thought of variables, but you're right, it doesn't work.

1:14:27 White_Flame it's the biggest thing to mindwrap when dealing with macros

1:19:34 bmansurov My biggest gripe with Common Lisp is that at some point I got this macro stuff, but because I didn't practice writing CL, I forgot it. Learning Common Lisp is not like learning to ride a bicycle, unfortunately. I have to relearn this stuff. ;(

1:19:54 White_Flame it's like that for all programming languages

1:21:42 bmansurov I don't know. For me, unlike JavaScript, for example, Common Lisp was hard to learn (even though I already knew how to program). It's even harder to retain that knowledge.

1:24:04 White_Flame https://plaster.tymoon.eu/view/2384#2384

1:24:12 White_Flame this has the brittleness of doing equality for the exit, though

1:24:47 White_Flame but with all fixnums, this should work, even if start = end

1:25:02 White_Flame s/fixnums/integers/

1:25:27 White_Flame ugh, s/incf/+/ :-P

1:25:33 White_Flame too many edits :)

1:26:31 White_Flame and of course the reason there's upto vs downto is that the exit comparison needs to be <= or >= depending on the direction

1:27:15 bmansurov Thanks, I appreciate your help. I was more interested in getting ~to~ and ~downto~ working. As others have suggested, and as you have showed, there are many ways to skin this cat. I was after that specific way.

1:27:16 White_Flame which is why there's = in this bidirectional version

1:27:35 White_Flame ah, k

2:02:10 curtosis ** NICK curtosis[away]

3:01:50 Alfr ** NICK Guest74969

3:01:53 beach Good morning everyone!