| 00:52:05 | * | fowl quit (Ping timeout: 255 seconds) |
| 02:11:47 | * | fowl joined #nimrod |
| 04:26:32 | fowl | hrm the dynlib error message is broken for windows |
| 04:26:43 | fowl | it just says "could not import:" then crashes |
| 05:11:43 | * | ryderblue joined #nimrod |
| 06:30:31 | * | shevy3 quit (Ping timeout: 252 seconds) |
| 06:56:14 | * | ryderblue quit (Quit: ryderblue) |
| 06:57:43 | * | XAMPP quit (Ping timeout: 256 seconds) |
| 07:15:35 | * | shevy joined #nimrod |
| 07:24:13 | * | shevy quit (Ping timeout: 245 seconds) |
| 08:13:22 | * | Araq__ quit (Quit: ChatZilla 0.9.89 [Firefox 16.0.2/20121024073032]) |
| 11:59:19 | * | Araq_ joined #nimrod |
| 12:09:10 | * | Trix[a]r_za is now known as Trixar_za |
| 12:22:42 | * | Araq_ quit (Quit: ChatZilla 0.9.89 [Firefox 16.0.2/20121024073032]) |
| 13:31:21 | * | XAMPP joined #nimrod |
| 13:34:06 | Trixar_za | Dammit - only solution would be to implement a universal patcher |
| 13:34:15 | * | Trixar_za 's laziness field kicks in |
| 14:21:45 | * | Araq_ joined #nimrod |
| 14:26:21 | * | Araq_ quit (Client Quit) |
| 14:45:59 | Trixar_za | You know Araq. I think that post was a joke or intended to get a reaction. Thinking of it beyond that is kind of meaningless :P |
| 14:56:06 | * | q66 joined #nimrod |
| 15:31:08 | * | gradha joined #nimrod |
| 15:37:43 | * | Trixar_za is now known as Trix[a]r_za |
| 15:47:52 | * | shevy joined #nimrod |
| 18:03:40 | * | ryderblue joined #nimrod |
| 18:56:03 | Araq | so reactormonk ... Nimrod now supports a lisp like condition system |
| 18:56:15 | Araq | now don't ever bother me with it again :P |
| 19:02:40 | * | gradha quit (Quit: gradha) |
| 19:42:00 | * | fowl quit (Quit: Leaving) |
| 19:51:45 | * | gradha joined #nimrod |
| 19:53:17 | gradha | this condition system is to handle raised exceptions and continue program flow? |
| 19:54:11 | Araq | yeah it keeps raise from unwinding the stack |
| 19:55:18 | gradha | sounds like reactormonk will have fun documenting it |
| 19:55:40 | gradha | I didn't see in the manual any description of the exception hierarchy, is it ok to put it there, somewhere? |
| 19:55:53 | gradha | I would link it from the tutorial then |
| 19:56:48 | Araq | hm yeah, fine with me |
| 19:57:19 | gradha | the line "except and finally statements can also be used as stand-alone statements" is intriguing |
| 19:57:39 | gradha | I undestand that finally allows executing a one liner and implicitly starts an idented block, does it? |
| 19:57:52 | gradha | but I can't see how it's supposed for except |
| 19:58:11 | gradha | I mean, it's like writing code backwards |
| 19:58:40 | gradha | or maybe the finally statement doesn't start indentation? |
| 19:59:02 | gradha | also, is it fair to use finally statement with a block statement to put a chunk of code? |
| 20:02:12 | gradha | another line which caught my eye in the manual was the one related to methods |
| 20:02:38 | gradha | they are not explained at all, in fact, I'm not sure if the are method, or directly multi-methods, and what that means |
| 20:04:59 | Araq | sorry brb |
| 20:31:08 | Araq | hrm I guess you're right |
| 20:31:17 | Araq | they are multi-methods |
| 20:33:11 | gradha | cool |
| 20:33:18 | gradha | what are multi-methods? |
| 20:33:37 | gradha | http://en.wikipedia.org/wiki/Multiple_dispatch ? |
| 20:36:44 | gradha | ok, undestand the concept, didn't know the terminology |
| 20:36:59 | * | fowl joined #nimrod |
| 20:44:11 | Araq | var f = open("numbers.txt") |
| 20:45:22 | Araq | finally: close(f) |
| 20:45:22 | Araq | xyz |
| 20:45:22 | Araq | is transformed into: |
| 20:45:22 | Araq | var f = open("numbers.txt") |
| 20:45:22 | Araq | try: |
| 20:45:23 | Araq | xyz |
| 20:45:23 | Araq | finally: close(f) |
| 20:45:24 | Araq | 'except' is analogous |
| 20:45:24 | Araq | you can read 'except' as 'on error do' if that's of any help |
| 20:46:00 | Araq | and yeah it's "backwards" as the source code flow does not reflect the control flow |
| 20:46:05 | gradha | the statement doesn't introduce a new indentation level? |
| 20:46:30 | Araq | I don't understand your question |
| 20:46:43 | gradha | let's say |
| 20:46:47 | gradha | var f = ... |
| 20:46:51 | gradha | finally: close(f) |
| 20:46:57 | gradha | echo "1" |
| 20:46:59 | gradha | echo "2" |
| 20:47:02 | gradha | versus |
| 20:47:06 | gradha | var f = ... |
| 20:47:09 | gradha | finally: close(f) |
| 20:47:11 | gradha | echo "1" |
| 20:47:14 | gradha | echo "2" |
| 20:47:55 | gradha | also, another I'm thinking of |
| 20:48:06 | gradha | var f1 = open("file1.txt") |
| 20:48:11 | gradha | var f2 = open("file2.txt") |
| 20:48:11 | Araq | right, it doesn't introduce a new indentation level |
| 20:48:14 | gradha | finally: |
| 20:48:20 | gradha | close(f1) |
| 20:48:22 | gradha | close(f2) |
| 20:48:30 | gradha | echo "1" |
| 20:48:31 | gradha | echo "2" |
| 20:48:35 | gradha | that looks confusing |
| 20:48:55 | Araq | I don't mind it |
| 20:49:29 | Araq | the idea is that the close call belongs to the open call and so should be close to it |
| 20:50:03 | gradha | sure, I love the closing/with from python |
| 20:50:14 | Araq | for (int i = 0; i < 10; ++i) { ... } // same thing |
| 20:50:15 | gradha | this seems more flexible, as its not restricted to an informal interface |
| 20:50:37 | Araq | the '++i' is not in the loop body ... |
| 20:53:35 | gradha | somehow I feel documenting the exception hierarchy should be in the library and not the manual, as its not part of the language itself |
| 20:53:49 | Araq | oh really? |
| 20:54:12 | gradha | is E_Base part of the language? |
| 20:54:24 | gradha | or is E_Base provided by the standard library of the language? |
| 20:54:40 | Araq | why do you think the documentation is the way it is? |
| 20:54:43 | Araq | :P |
| 20:54:49 | gradha | no idea |
| 20:55:41 | Araq | " somehow I feel documenting the exception hierarchy should be in the library and not the manual, as its not part of the language itself" <-- that's why ;-) |
| 20:56:35 | Araq | but then you have to look in 3 different places and combine the language features in your head to see how myseq.add(x) works ;-) |
| 20:56:47 | gradha | your answer surprised me, so I went to check the index and yes, E_base is buried in the system module |
| 20:56:58 | gradha | quite obvious after having looked at it in system.nim |
| 20:57:27 | gradha | so the problem is hyperlinking, everything is deeply hidden, somewhere |
| 20:58:12 | gradha | nimrod buildIndex creates the idx files I presume |
| 20:58:34 | gradha | are they used by restutils? how do you integrate them? |
| 20:58:46 | Araq | buildIndex merges all the idx files |
| 21:03:02 | Araq | the problem is not really hyperlinking |
| 21:03:19 | Araq | the problem is we really need 2 documents: a tutorial and a spec |
| 21:03:56 | Araq | however there is some overlap between both |
| 21:04:33 | Araq | and so maintainance is hard |
| 21:04:33 | Araq | the tutorial should mention the common features of the stdlib |
| 21:04:36 | Araq | the spec not really |
| 21:14:00 | reactormonk | gradha, likely |
| 22:31:53 | Araq | so gradha, how about you improving the tutorials? :-) |
| 22:33:35 | gradha | i'm on it |
| 22:34:43 | Araq | oh cool |
| 22:35:46 | Araq | me writing the spec and somebody else improving the tutorials seems like a good idea |
| 22:39:41 | gradha | as long as you don't mind boring questions and pedantic discussions along the way |
| 22:40:41 | Araq | I don't :-) |
| 22:41:08 | gradha | it will take me some time because my lack of knowledge about nimrod keeps forcing me to do side quests to level up, and the main quest now is too high for my puny low level attacks |
| 22:46:24 | gradha | before tackling a generic tutorial I want to get used to the language, so my plan is to expand the the cross platform examples, then write some about networking/parsing |
| 22:55:55 | Araq | hrm alright |
| 22:56:18 | Araq | but somebody needs to add the common parts of the stdlib to the tutorial |
| 22:56:27 | Araq | it's the next step I think |
| 22:57:10 | gradha | I would need to know what "common parts of the stdlib" are |
| 23:03:57 | Araq | everything in the prelude I guess |
| 23:05:39 | gradha | by prelude you mean what's on nimrod's web frontpage or stuff referenced in the first tutorial? |
| 23:05:59 | Araq | lib/prelude.nim |
| 23:06:45 | gradha | it certainly needs documenting, hadn't noticed its existance |
| 23:16:08 | gradha | this is what I mean by "needs hyperlinking" http://pastebin.com/1wWPamWL |
| 23:16:59 | gradha | more specific symbol hyperlinking is needed, but that requires changing how the id toc is generated on the html so it doesn't need preprocessing |
| 23:17:12 | gradha | numeric html anchors are no good for humans |
| 23:19:22 | gradha | a hyperlink like system.html#E_Base is much better than system.html#160 (and durable too) |
| 23:19:55 | gradha | where/what generates the toc? |
| 23:21:52 | Araq | compiler/docgen.nim |
| 23:21:58 | gradha | ropeFormatNamedVars? |
| 23:22:10 | Araq | and yeah I noticed the IDs are stupid |
| 23:22:33 | Araq | however, it's not easy to do better because of all the overloading ;-) |
| 23:23:05 | gradha | I was expecting that was the problem, is it not possible to output the name of the proc along the types of the parameters? |
| 23:23:27 | gradha | in fact, it would help the index too |
| 23:23:58 | gradha | right now looking at all those crosses (for addition overloading) looks terrible |
| 23:24:21 | Araq | it's not hard to generate the proc header as the name |
| 23:24:34 | Araq | but it's hard to do so and keep it reasonably short ... |
| 23:26:04 | gradha | btw, does nimrod also overload on return value? |
| 23:26:12 | Araq | no |
| 23:26:30 | gradha | can't remember now which programming language does it |
| 23:26:37 | Araq | reactormonk desperately needs it, so it's planned |
| 23:26:51 | Araq | Ada does it iirc and so does Haskell |
| 23:27:29 | gradha | then that will be needed for the html ids too |
| 23:28:27 | gradha | i'll discuss this with the pillow, bye |
| 23:28:45 | * | gradha quit (Quit: gradha) |
| 23:29:54 | Araq | I should do the same, good night |