| 00:09:00 | * | Demos quit (Remote host closed the connection) |
| 00:29:16 | * | Demos joined #nim |
| 00:41:38 | * | Demos quit (Remote host closed the connection) |
| 00:45:29 | * | brson quit (Quit: leaving) |
| 00:48:51 | * | Demos joined #nim |
| 00:57:36 | * | elbow joined #nim |
| 01:04:03 | * | jaco60 quit (Ping timeout: 246 seconds) |
| 01:14:47 | * | Demos quit (Remote host closed the connection) |
| 01:24:01 | * | Jesin joined #nim |
| 01:28:48 | * | Demos joined #nim |
| 01:44:55 | * | Demos quit (Remote host closed the connection) |
| 02:36:35 | * | saml_ joined #nim |
| 02:39:55 | * | Demos joined #nim |
| 02:41:06 | * | Demos quit (Read error: Connection reset by peer) |
| 02:41:11 | * | Demos_ joined #nim |
| 02:48:48 | * | vbtt joined #nim |
| 02:49:22 | vbtt | hi, is Araq here? |
| 02:50:05 | vbtt | wondering how oscon went.. |
| 02:53:30 | * | Demos_ quit (Remote host closed the connection) |
| 02:59:20 | * | BitPuffin|osx joined #nim |
| 03:12:42 | * | saml_ quit (Ping timeout: 250 seconds) |
| 03:15:15 | * | vbtt quit (Quit: http://www.kiwiirc.com/ - A hand crafted IRC client) |
| 03:24:13 | * | pregressive quit (Remote host closed the connection) |
| 03:37:27 | * | MatrixBridge quit (Read error: Connection reset by peer) |
| 03:37:36 | * | MatrixBridge joined #nim |
| 04:06:50 | * | Demos joined #nim |
| 04:18:44 | * | strcmp1 quit (Quit: Leaving) |
| 04:25:48 | * | Demos quit (Remote host closed the connection) |
| 04:26:17 | * | Demos joined #nim |
| 04:30:17 | * | Demos quit (Ping timeout: 240 seconds) |
| 04:59:44 | * | darkf joined #nim |
| 05:33:16 | * | lokulin quit (Quit: bye!) |
| 05:33:16 | * | gmpreussner|work quit (Read error: Connection reset by peer) |
| 05:34:05 | * | gmpreussner|work joined #nim |
| 05:49:43 | * | lokulin joined #nim |
| 06:00:10 | * | Demos joined #nim |
| 06:01:58 | * | Demos quit (Remote host closed the connection) |
| 06:08:06 | * | Demos joined #nim |
| 06:09:12 | * | Demos quit (Read error: Connection reset by peer) |
| 06:09:16 | * | Demos_ joined #nim |
| 06:15:36 | * | Demos_ quit (Remote host closed the connection) |
| 06:20:17 | * | Demos joined #nim |
| 06:37:14 | * | Demos quit () |
| 06:54:40 | * | Ven_ joined #nim |
| 07:16:25 | * | Trustable joined #nim |
| 07:18:30 | * | Heartmender is now known as Quora |
| 07:31:50 | * | bcinman quit (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 07:41:24 | * | jszymanski joined #nim |
| 07:42:55 | * | gmpreussner|work quit (Read error: Connection reset by peer) |
| 07:43:46 | * | gmpreussner|work joined #nim |
| 07:46:58 | * | Ven_ quit (Quit: My MacBook has gone to sleep. ZZZzzz…) |
| 07:56:12 | * | jaco60 joined #nim |
| 08:00:26 | * | Ven joined #nim |
| 08:10:49 | * | cofeepot joined #nim |
| 08:36:49 | federico3 | right! We want the videos! \o/ |
| 09:03:52 | * | [CBR]Unspoken1 quit (Ping timeout: 256 seconds) |
| 09:10:22 | * | wirbi joined #nim |
| 09:14:57 | wirbi | Hello! How I can compile something like this https://gist.github.com/wirbi7/bcec60bfa37960e278cf ? |
| 09:15:10 | * | [CBR]Unspoken1 joined #nim |
| 09:15:57 | * | Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…) |
| 09:18:07 | * | Ven joined #nim |
| 09:18:11 | * | Ven quit (Read error: Connection reset by peer) |
| 09:19:08 | * | Kingsqueeee quit (Quit: Konversation terminated!) |
| 09:35:49 | fowl | wirbi move B to be inside A |
| 10:14:33 | * | cofeepot is now known as coffeepot |
| 10:22:00 | * | Ven joined #nim |
| 10:52:19 | baabelfish | any timeline for the recursive iterators? |
| 11:06:01 | * | NimBot joined #nim |
| 11:06:39 | * | NimBot joined #nim |
| 11:08:22 | * | strcmp1 joined #nim |
| 11:09:48 | * | gmpreussner|work quit (Read error: Connection reset by peer) |
| 11:09:55 | * | gmpreussner|work joined #nim |
| 11:11:49 | * | xcombelle joined #nim |
| 11:19:27 | fowl | r-ku are continuations in devel yet |
| 11:22:52 | r-ku | nah |
| 11:22:58 | r-ku | i dont think they gonna be there soon |
| 11:23:06 | r-ku | unless someone writes some arm asm code :D |
| 11:29:13 | r-ku | fowl if you want to test you pretty much can - https://github.com/r-ku/Nim/blob/coroutines/lib/pure/coro.nim |
| 11:29:31 | r-ku | x86/x64/linux(other unixes?)/windows should work |
| 11:29:52 | r-ku | requirement is --gc:markAndSweep |
| 11:34:36 | baabelfish | r-ku: I read it from some iterator tutorial |
| 11:37:51 | r-ku | well baabelfish i heard nothing about recursive iterators. but coroutines would be closest thing to that. |
| 11:45:28 | * | Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…) |
| 11:45:42 | * | Ven joined #nim |
| 11:49:14 | * | BitPuffin|osx quit (Ping timeout: 250 seconds) |
| 11:51:45 | * | xcombelle quit (Read error: Connection reset by peer) |
| 11:55:58 | * | [CBR]Unspoken quit (Ping timeout: 260 seconds) |
| 12:01:40 | * | woadwarrior joined #nim |
| 12:01:45 | * | boopsiesisaway is now known as boopsies |
| 12:12:30 | * | [CBR]Unspoken joined #nim |
| 12:23:35 | reactormonk | r-ku, callcc doesn't work on arm? |
| 12:24:04 | * | Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…) |
| 12:29:52 | r-ku | reactormonk not sure what callcc is |
| 12:36:08 | * | Ven joined #nim |
| 12:36:24 | * | jszymanski quit (Ping timeout: 264 seconds) |
| 12:38:49 | * | jszymanski joined #nim |
| 12:58:08 | * | askatasuna quit (Ping timeout: 244 seconds) |
| 13:17:38 | * | boopsies is now known as boopsiesisaway |
| 13:20:22 | * | askatasuna joined #nim |
| 13:22:14 | coffeepot | can i directly cast memory to a string or will only cstring work because of some kind of string header info? |
| 13:22:22 | * | insomniac left #nim (#nim) |
| 13:22:47 | coffeepot | I'm trying to read a buffer of bytes and produce a unicode string |
| 13:24:59 | coffeepot | see, with a string i think i can just do fastRuneAt. |
| 13:35:25 | * | spiceweasel joined #nim |
| 13:36:12 | * | spiceweasel left #nim (#nim) |
| 13:36:18 | * | spiceweasel joined #nim |
| 13:36:26 | * | spiceweasel left #nim (#nim) |
| 13:50:30 | * | anthgur joined #nim |
| 13:52:52 | r-ku | coffeepot cast it to cstring and convert it to string |
| 13:52:56 | * | BitPuffin|osx joined #nim |
| 13:53:09 | r-ku | like $cast[cstring](p) |
| 14:01:37 | * | FedeOmoto joined #nim |
| 14:01:38 | coffeepot | r-ku huh that's neat :) is $cast[cstring](p) the same as for c in cstr: s.add(c) |
| 14:02:26 | coffeepot | ah anyway it doesn't really matter. I prefer brevity of your approach :) |
| 14:03:53 | r-ku | coffeepot string is just byte array |
| 14:04:13 | r-ku | btw i think you can even do var s: string = cast[cstring](p) |
| 14:05:00 | coffeepot | nice, thanks :) now to deal with the horrors of unicode... :) |
| 14:14:50 | * | woadwarrior quit (Quit: Textual IRC Client: www.textualapp.com) |
| 14:30:36 | * | anthgur quit (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 14:31:53 | * | anthgur joined #nim |
| 14:33:50 | * | drewsrem joined #nim |
| 14:35:00 | * | pregressive joined #nim |
| 14:48:10 | * | darkf quit (Quit: Leaving) |
| 14:48:51 | * | bcinman joined #nim |
| 14:53:00 | * | boopsiesisaway is now known as boopsies |
| 14:55:06 | * | xcombelle joined #nim |
| 14:57:38 | * | Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…) |
| 14:59:22 | * | xificurC quit (Quit: WeeChat 1.2) |
| 14:59:44 | * | xificurC joined #nim |
| 15:00:20 | * | bcinman_ joined #nim |
| 15:01:15 | * | pregress_ joined #nim |
| 15:02:15 | * | strcmp2 joined #nim |
| 15:02:37 | * | clone1018_ joined #nim |
| 15:04:45 | drewsrem | I'm trying to find out the size of Cs basic types at compile-time, i.e. sizeof char/short/int/long/longlong etc. - AFAIS Nim only provides sizeof(int), any pointers? |
| 15:05:21 | def- | drewsrem: sizeof(cint)? |
| 15:06:05 | def- | and same with cchar, cshort, clong, clonglong |
| 15:08:39 | * | mal``` joined #nim |
| 15:09:53 | * | bcinman quit (*.net *.split) |
| 15:09:53 | * | pregressive quit (*.net *.split) |
| 15:09:53 | * | [CBR]Unspoken quit (*.net *.split) |
| 15:09:53 | * | strcmp1 quit (*.net *.split) |
| 15:09:54 | * | Jesin quit (*.net *.split) |
| 15:09:54 | * | clone1018 quit (*.net *.split) |
| 15:09:54 | * | Xe quit (*.net *.split) |
| 15:09:54 | * | k1i quit (*.net *.split) |
| 15:09:54 | * | mal`` quit (*.net *.split) |
| 15:09:55 | * | Sornaensis quit (*.net *.split) |
| 15:09:55 | * | fowl quit (*.net *.split) |
| 15:09:56 | * | huonw quit (*.net *.split) |
| 15:12:39 | * | clone1018_ is now known as clone1018 |
| 15:13:24 | drewsrem | def-, those are std c sizes |
| 15:13:44 | drewsrem | From lib/system: cint* {.importc: "int", nodecl.} = int32 |
| 15:13:57 | drewsrem | They're not native apparently |
| 15:14:21 | def- | that's strange, they're supposed to be used for interacting with C code, so they should be native size |
| 15:14:48 | drewsrem | :| |
| 15:15:23 | drewsrem | They'd have to be magic tho right? |
| 15:16:11 | * | Jesin joined #nim |
| 15:16:17 | def- | not sure how this is supposed to work. maybe sizeof can just be inaccurate for these types, hm |
| 15:16:29 | drewsrem | Any idea for a workaround? |
| 15:16:45 | def- | yes, I'm trying one with an emit |
| 15:16:51 | drewsrem | Does emit work at compile-time? |
| 15:16:55 | reactormonk | nope |
| 15:16:56 | drewsrem | e.g. in macros? |
| 15:16:58 | drewsrem | I figured |
| 15:17:06 | def- | anyway, if sizeof(cint) is ever wrong, then that's a bug and should be fixed |
| 15:17:25 | drewsrem | Well it's not wrong right, it justs uses the standardized sizes instead of native |
| 15:18:01 | def- | if you really want to know C's type sizes at compile time you might want to compile a small C program and check the output, as configure does. not really a nice solution though |
| 15:18:05 | * | Ven joined #nim |
| 15:18:22 | drewsrem | yeah I thought of that too, I can execute processes at compileTime right? |
| 15:18:38 | def- | right, staticExec |
| 15:18:41 | * | [CBR]Unspoken joined #nim |
| 15:18:44 | def- | and writing to files works too |
| 15:18:47 | drewsrem | thanks, I'll do this for now |
| 15:19:57 | wuehlmaus | https://www.youtube.com/watch?v=zKK9I-OvZng |
| 15:20:03 | wuehlmaus | first spotted nim video :) |
| 15:20:45 | def- | wuehlmaus: there's also a video of the German talk I did a year ago about Nim |
| 15:20:46 | drewsrem | def-, comment tho says "This is the same as the type ``short`` in *C*." - so it seems you're right, they were intended as to have native size |
| 15:21:26 | def- | drewsrem: right, but how can we reliably know what size C types will have? not sure how to solve this best |
| 15:22:00 | drewsrem | def-, I think this needs magic |
| 15:22:19 | wuehlmaus | def-: great, on youtube? |
| 15:23:19 | def- | wuehlmaus: not that i know, it's here: https://media.ccc.de/browse/conferences/gpn/gpn14/gpn14_-_5892_-_de_-_zkm-vortragssaal_-_201406211130_-_nimrod_-_dennis_felsing.html the slides might make sense without German: http://felsin9.de/nnis/nimrod/nimrod-gpn14.pdf |
| 15:24:38 | drewsrem | Araq, cint in lib/system is always an int32 and not native-size, I'm trying to determine native-size of a short at compile-time and it seems this is currently not possible, am I misinterpreting things? |
| 15:25:40 | renesac | drewsrem: what plataform are you trying? |
| 15:26:24 | renesac | are you cross-compiling? |
| 15:26:27 | wuehlmaus | def-: jippie Chaos Computer Club, it rules :) |
| 15:26:38 | drewsrem | renesac, x86_64, but it doesn't matter, cshort is defined as: type cshort* {.importc: "short", nodecl.} = int16 |
| 15:26:51 | drewsrem | renesac, so cshort is always int16 |
| 15:27:32 | drewsrem | renesac, same for cint etc. |
| 15:27:53 | renesac | strange |
| 15:28:22 | renesac | I use clong.sizeof here and it gives 8, as it should |
| 15:28:37 | drewsrem | renesac, devel-branch? |
| 15:28:40 | renesac | even though in the documentation it is written "clong = int32" |
| 15:28:43 | renesac | yes |
| 15:28:47 | drewsrem | me too |
| 15:29:11 | def- | renesac: there is a when defined(windows) |
| 15:29:28 | renesac | hum, so it is hardcoded |
| 15:29:32 | drewsrem | oh right |
| 15:29:47 | renesac | nim needs a way to get c values |
| 15:30:34 | def- | renesac: well, not possible at compile time without invoking the c compiler |
| 15:31:10 | def- | I think the idea is just to add more when-blocks as we notice more systems with other definitions of C types |
| 15:31:40 | renesac | not a really good solution |
| 15:31:57 | renesac | there are many other things dependent of c/plataform values |
| 15:32:16 | renesac | for example, nim still uses posix_gettimeofday() for the gc on linux |
| 15:32:38 | renesac | instead of clock_gettime(CLOCK_REALTIME, t) |
| 15:33:13 | FedeOmoto | renesac: that's because the documentation was probably generated on Win64 |
| 15:33:26 | renesac | there is an "elif defined(posixRealtime):" but this is never entered, because that value would need to be read from a C header |
| 15:33:29 | renesac | and nim don't do it |
| 15:33:36 | FedeOmoto | renesac: Win64 is LLP64 |
| 15:33:51 | renesac | FedeOmoto: yes, I understood |
| 15:34:15 | drewsrem | def-, is invoking the c compiler during compile-time a problem? - How does nim know the size of a normal int? - It's magic in lib/system |
| 15:34:15 | * | anthgur quit (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 15:34:31 | drewsrem | Normal int type does seem to be native size |
| 15:34:43 | renesac | I think those things are on https://github.com/nim-lang/Nim/blob/devel/lib/nimbase.h |
| 15:35:12 | def- | drewsrem: i consider it a problem, yes. how do you invoke the c compiler when you're just compiling to C and creating a script to build it on the target machine? |
| 15:35:30 | def- | there might not be a c compiler and it might be the wrong one |
| 15:35:34 | drewsrem | def-, good point |
| 15:35:53 | drewsrem | Araq could probably settle this in a minute or so :) |
| 15:35:58 | renesac | if you are using things depending on C, you need a C compiler |
| 15:36:03 | drewsrem | So I'm just going to work around this atm |
| 15:36:21 | renesac | or else some other way to get those C plataform information |
| 15:38:55 | FedeOmoto | drewsrem: what are you trying to achieve? |
| 15:39:36 | drewsrem | FedeOmoto, read an aligned native-sized cstruct from a binary-file |
| 15:42:43 | * | brson joined #nim |
| 15:42:46 | FedeOmoto | and so, what's the problem doing it? |
| 15:44:10 | drewsrem | Lets say I have a binary.file with 10 longs, I now want to read those 10 longs in order to do that I need to know how many bytes a long is |
| 15:44:58 | drewsrem | I mean that's easy because I know its 10 elements long and could calculate from that, but you get the point |
| 15:45:45 | wuehlmaus | |
| 15:46:11 | * | Jesin quit (Quit: Leaving) |
| 15:47:21 | wuehlmaus | sorry |
| 15:48:05 | renesac | anyway, reading the value of something defined in C is a long standing wish of mine... |
| 15:48:27 | renesac | I tried hacking something with emit, but it seems to be impossible |
| 15:49:21 | drewsrem | Isn't there something where you can query CPU architecture in Nim? |
| 15:50:53 | drewsrem | ah hostCPU, there we go |
| 15:51:05 | renesac | I wrote this a few days ago: https://github.com/nim-lang/Nim/wiki/Consts-defined-by-the-compiler |
| 15:51:25 | renesac | but unfortunatedly there is nothing on the level of http://dlang.org/phobos/core_cpuid.html |
| 15:51:41 | renesac | to discover the cache size, for example |
| 15:51:58 | drewsrem | renesac, not bad core.cpuid |
| 15:52:17 | renesac | ? |
| 15:52:53 | drewsrem | renesac, it's nice that dlang has this |
| 15:53:04 | renesac | yeah |
| 15:53:49 | renesac | however I fleed from Dlang because it's horrible GC that would leak memory like crazy, as it was not precise |
| 16:01:27 | FedeOmoto | drewsrem: how about this: http://pastebin.com/MN7aT9gC |
| 16:01:37 | FedeOmoto | :) |
| 16:06:19 | drewsrem | FedeOmoto, now you have 5 different structs with different ctypes, and you have an order in which you read them, some of them have the same total size, but different fields with different field_sizes |
| 16:07:11 | FedeOmoto | drewsrem: again, I don't see the problem reading those structs from Nim... |
| 16:07:39 | drewsrem | FedeOmoto, you have a stream of longs, and you want to read one long at a time |
| 16:08:29 | drewsrem | FedeOmoto, if you can solve this I'll tip my hat to you |
| 16:09:20 | FedeOmoto | you can use system.readBuffer to read those longs |
| 16:12:43 | drewsrem | Oh sure, how many bytes do I read? |
| 16:13:00 | drewsrem | I got this fancy bytestream here and I know it passes me native longs |
| 16:13:29 | FedeOmoto | sizeof(clong) * the number of longs you have in the stream |
| 16:13:40 | * | anthgur joined #nim |
| 16:13:48 | drewsrem | FedeOmoto, see that's the problem, you haven't read what I wrote and now we're at a point where I have to repeat myself |
| 16:13:58 | drewsrem | clong is not the size of a native long |
| 16:14:11 | FedeOmoto | yes, it's the size of a native long |
| 16:14:25 | drewsrem | If you're on windows: clong* {.importc: "long", nodecl.} = int32 |
| 16:14:33 | drewsrem | Directy from lib/system |
| 16:14:37 | FedeOmoto | that's right |
| 16:14:57 | FedeOmoto | you're the one who haven't read what I wrote ;) |
| 16:14:59 | drewsrem | So long is always 4 bytes? |
| 16:15:03 | FedeOmoto | Win64 is LLp64 |
| 16:15:14 | FedeOmoto | so a clong in Win64 y 4 bytes long |
| 16:15:23 | FedeOmoto | no |
| 16:15:29 | drewsrem | Native size |
| 16:15:33 | FedeOmoto | long y 4 bytes on LLp64 |
| 16:15:37 | FedeOmoto | yeah |
| 16:15:48 | drewsrem | So now I'm on linux |
| 16:15:59 | drewsrem | cshort is now int16 |
| 16:16:12 | drewsrem | Every short on Linux is 2 bytes native size? |
| 16:16:18 | * | boopsies is now known as boopsiesisaway |
| 16:16:32 | FedeOmoto | linux is LP64, so a clong y 8 bytes |
| 16:16:39 | FedeOmoto | drewsrem: http://www.unix.org/version2/whatsnew/lp64_wp.html |
| 16:16:54 | FedeOmoto | drewsrem: yes |
| 16:16:58 | drewsrem | Then what does native size matter if you can hardcode it depending on OS? |
| 16:17:16 | drewsrem | Maybe that's my brain misunderstanding native size and cpu architecture |
| 16:17:41 | * | unclechu joined #nim |
| 16:17:51 | FedeOmoto | that's nothing to do with cpu architectures, it's the programming model what matters |
| 16:18:08 | FedeOmoto | again, please take a look at: http://www.unix.org/version2/whatsnew/lp64_wp.html |
| 16:18:14 | drewsrem | I am |
| 16:20:09 | FedeOmoto | if you're not developing a programming language, you can forget about the different programming models (most of the time...), just use Nim's sizeof and you'll be fine :) |
| 16:24:36 | * | coffeepot quit (Quit: http://www.kiwiirc.com/ - A hand crafted IRC client) |
| 16:29:50 | * | boopsiesisaway is now known as boopsies |
| 16:30:14 | drewsrem | FedeOmoto, well that explains a lot, big thanks, the issues I were seeing then were simply because the file was written in Windows and I was reading them in Linux |
| 16:31:01 | FedeOmoto | you're welcome |
| 16:33:28 | drewsrem | FedeOmoto, but it doesn't quite adhere to "the" C standard, right |
| 16:34:24 | drewsrem | But it's fine as long as you write applications for common OSes |
| 16:34:56 | * | sparrk joined #nim |
| 16:35:29 | FedeOmoto | why do you think it doesn't adhere to the C standard? |
| 16:35:58 | sparrk | How does one write a proc that changes a string in-place? I tried looking around the Nim source code but I had trouble finding any that did. |
| 16:35:59 | drewsrem | https://en.wikipedia.org/wiki/C_data_types#Basic_types - The actual size of integer types varies by implementation. The standard only requires size relations between the data types and minimum sizes for each data type |
| 16:36:12 | FedeOmoto | exactly |
| 16:36:25 | * | Jesin joined #nim |
| 16:36:31 | FedeOmoto | the C standard only defines the minimun sizes for basic types |
| 16:36:35 | drewsrem | And lib/system just hardcodes different sizes according to the OS |
| 16:36:53 | FedeOmoto | hmmm |
| 16:37:09 | drewsrem | That's the issue we talked above |
| 16:37:15 | drewsrem | But I'm fine now :) |
| 16:37:16 | FedeOmoto | I don't think so, I think this information is extracted from C header files |
| 16:37:32 | drewsrem | FedeOmoto, it's not, that's why I quoted system.nim |
| 16:37:53 | FedeOmoto | that'd be surprising |
| 16:37:57 | drewsrem | FedeOmoto, https://github.com/nim-lang/Nim/blob/devel/lib/system.nim#L1314 |
| 16:38:07 | drewsrem | clong = int32 |
| 16:38:19 | drewsrem | ah |
| 16:38:20 | drewsrem | bad example |
| 16:38:32 | drewsrem | https://github.com/nim-lang/Nim/blob/devel/lib/system.nim#L1332 |
| 16:38:37 | drewsrem | Cshort is always int16 |
| 16:38:44 | drewsrem | # these work for most platforms: |
| 16:39:35 | drewsrem | I don't know why I keep picking on long :) |
| 16:43:10 | drewsrem | I'm not sure tho anymore, because the size might be inferred from the importc? - I need to let this sit with me for a while |
| 16:43:52 | FedeOmoto | I hope so (that size if inferred from the importc) |
| 16:43:58 | FedeOmoto | *is |
| 16:44:31 | * | sparrk quit (Ping timeout: 252 seconds) |
| 16:45:29 | drewsrem | But then it would still error out on Nims compile-time "bounds-checks" when you go above an int16? |
| 16:46:15 | drewsrem | Note a normal int works completely by magic: https://github.com/nim-lang/Nim/blob/devel/lib/system.nim#L33 |
| 16:47:29 | FedeOmoto | maybe Nim's C type should be implemented that way too |
| 16:48:37 | FedeOmoto | I still have to see a platform where a C short is not 16 bits long |
| 16:50:10 | drewsrem | mhm, it's probably no practical problem, but it doesn't adhere to the C standard and the comment e.g. "## This is the same as the type ``short`` in *C*" is thus arguably wrong |
| 16:50:22 | drewsrem | But I take there are actual issues that have more priority |
| 16:56:15 | FedeOmoto | well, IIRC Cray has a few instructions that that up to 48 bits, I wouldn't be surprising if a basic type is 48 bits long there... |
| 16:57:20 | FedeOmoto | that that = that take |
| 17:14:30 | * | fowl joined #nim |
| 17:17:14 | * | ChrisMAN quit (Read error: Connection reset by peer) |
| 17:19:55 | * | ChrisMAN joined #nim |
| 17:31:17 | * | Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…) |
| 17:34:02 | * | filcuc joined #nim |
| 17:44:27 | * | BlaXpirit joined #nim |
| 17:45:41 | * | BlaXpirit left #nim ("Konversation") |
| 17:46:39 | * | Ven joined #nim |
| 17:56:25 | * | Ven quit (Quit: My MacBook has gone to sleep. ZZZzzz…) |
| 18:11:16 | * | Sornaensis joined #nim |
| 18:14:07 | * | brson quit (Remote host closed the connection) |
| 18:14:13 | * | huonw joined #nim |
| 18:17:59 | * | brson joined #nim |
| 18:21:32 | * | yglukhov joined #nim |
| 18:33:51 | * | zaquest quit (Quit: Leaving) |
| 18:36:22 | * | zaquest joined #nim |
| 18:48:46 | * | xcombelle quit (Remote host closed the connection) |
| 19:02:01 | * | drewsrem quit (Quit: Leaving) |
| 19:08:48 | * | yglukhov quit (Read error: Connection reset by peer) |
| 19:12:20 | * | sparrk joined #nim |
| 19:14:10 | * | yglukhov joined #nim |
| 19:16:47 | * | anthgur quit (Quit: My Mac has gone to sleep. ZZZzzz…) |
| 19:17:51 | sparrk | I want to update the documentation on this webpage: http://nim-lang.org/docs/strutils.html which git repo do I do that from? |
| 19:20:42 | * | brson quit (Ping timeout: 260 seconds) |
| 19:25:26 | sparrk | :(? |
| 19:28:26 | reactormonk | sparrk, it's in the main repo, try ./lib/pure/strutils.nim |
| 19:30:45 | sparrk | Ahh, I grepped for a keyword, and it didn't show up because of parsing. Thanks. |
| 19:31:59 | sparrk | how does the extern: "nsu..." work? |
| 19:32:36 | * | yglukhov quit (Remote host closed the connection) |
| 19:44:27 | reactormonk | dunno |
| 19:44:52 | reactormonk | instead of mangling the name, you explicitly set them |
| 20:01:33 | * | xcombelle joined #nim |
| 20:02:00 | * | sparrk quit (Read error: No route to host) |
| 20:03:32 | * | ^aurora^ joined #nim |
| 20:06:34 | * | AndroUser joined #nim |
| 20:07:29 | * | brson joined #nim |
| 20:08:02 | * | AndroUser quit (Client Quit) |
| 20:09:08 | * | Matthias247 joined #nim |
| 20:10:12 | * | vendethiel joined #nim |
| 20:13:28 | * | nande joined #nim |
| 20:24:02 | * | yglukhov joined #nim |
| 20:31:32 | * | yglukhov quit (Remote host closed the connection) |
| 20:32:20 | * | xcombelle quit (Quit: Leaving) |
| 20:35:46 | * | shodan45 joined #nim |
| 20:37:18 | * | yglukhov joined #nim |
| 20:41:06 | * | anthgur joined #nim |
| 20:42:02 | * | sparrk joined #nim |
| 20:45:30 | * | elbow_jason joined #nim |
| 20:48:51 | * | yglukhov quit (Ping timeout: 255 seconds) |
| 20:50:15 | * | yglukhov joined #nim |
| 20:55:19 | baabelfish | I would like to iterate over tuple and call new(tuplefield) for each of them |
| 20:55:31 | baabelfish | just can't figure out how |
| 21:03:54 | * | yglukhov quit (Ping timeout: 272 seconds) |
| 21:05:41 | * | tmku_ is now known as tmku |
| 21:11:52 | * | Jehan_ joined #nim |
| 21:13:39 | * | pregress_ quit (Remote host closed the connection) |
| 21:16:23 | * | pregressive joined #nim |
| 21:17:30 | * | yglukhov joined #nim |
| 21:19:02 | * | jszymanski quit (Quit: computer sleeps...) |
| 21:20:39 | * | anthgur quit (Remote host closed the connection) |
| 21:22:37 | * | yglukhov quit (Remote host closed the connection) |
| 21:22:37 | * | sidoaight joined #nim |
| 21:23:39 | * | yglukhov joined #nim |
| 21:25:12 | * | yglukhov quit (Remote host closed the connection) |
| 21:25:36 | * | yglukhov joined #nim |
| 21:34:46 | wuehlmaus | def-: perhaps you could put your very fine video on youtube so that more people find it |
| 21:35:41 | * | sparrk quit (Quit: Leaving) |
| 21:37:05 | * | yglukhov quit (Ping timeout: 240 seconds) |
| 21:38:48 | * | Trustable quit (Remote host closed the connection) |
| 21:39:15 | wuehlmaus | it's really worth it and can foster nim i think. sorry folks, it's in german |
| 21:44:27 | * | Xe joined #nim |
| 21:44:50 | * | yglukhov joined #nim |
| 21:48:23 | * | yglukhov quit (Remote host closed the connection) |
| 21:56:25 | * | yglukhov joined #nim |
| 21:57:35 | * | yglukhov quit (Remote host closed the connection) |
| 21:59:06 | * | yglukhov joined #nim |
| 22:02:17 | * | Amun_Ra quit (Ping timeout: 240 seconds) |
| 22:03:36 | * | yglukhov quit (Ping timeout: 256 seconds) |
| 22:05:43 | * | onionhammer quit (Ping timeout: 252 seconds) |
| 22:07:55 | * | filcuc quit (Quit: Konversation terminated!) |
| 22:13:00 | * | r-ku quit (Ping timeout: 255 seconds) |
| 22:14:37 | * | r-ku joined #nim |
| 22:25:15 | * | yglukhov joined #nim |
| 22:26:22 | * | unclechu quit (Quit: Leaving.) |
| 22:29:53 | * | yglukhov quit (Ping timeout: 265 seconds) |
| 22:31:16 | * | pregressive quit (Remote host closed the connection) |
| 22:32:03 | * | strcmp2 quit (Quit: Leaving) |
| 22:32:44 | * | onionhammer joined #nim |
| 22:34:13 | * | _stowa quit (Ping timeout: 246 seconds) |
| 22:35:54 | * | yglukhov joined #nim |
| 22:39:25 | * | _stowa joined #nim |
| 22:41:10 | * | Jesin quit (Quit: Leaving) |
| 22:42:21 | * | bcinman_ left #nim ("Textual IRC Client: www.textualapp.com") |
| 22:44:30 | * | yglukhov quit (Ping timeout: 255 seconds) |
| 22:48:04 | Araq | hi guys |
| 22:52:30 | FedeOmoto | hey |
| 22:53:59 | Araq | so my oscon tutorial has been recorded and will be online ... eventually, as usual |
| 22:57:18 | def- | hi Araq. nice |
| 22:57:26 | * | vendethiel quit (Ping timeout: 250 seconds) |
| 22:59:58 | * | Amun_Ra joined #nim |
| 23:00:35 | * | vbtt joined #nim |
| 23:00:40 | vbtt | Hi Araq |
| 23:00:49 | Araq | hey |
| 23:00:50 | vbtt | Just saw the tutorial slides - pretty nice. |
| 23:01:05 | vbtt | had to rename slidy2 -> Slidy2 on linux here :) |
| 23:01:19 | Araq | ah ok |
| 23:02:08 | vbtt | how was it received? |
| 23:02:49 | * | vendethiel joined #nim |
| 23:02:55 | Araq | not sure, I think it was fine. Had a couple of glitches though. Mostly due to the jetlag |
| 23:03:21 | vbtt | how many people? |
| 23:03:55 | Araq | around 20 |
| 23:04:29 | Araq | which is a bit sad |
| 23:04:40 | vbtt | nice - looking forward to the video |
| 23:08:00 | Varriount | Araq: I though it was quite good! |
| 23:09:11 | Varriount | *thought |
| 23:11:21 | Araq | how was your flight? everything went fine? |
| 23:12:13 | * | yglukhov joined #nim |
| 23:17:45 | * | yglukhov quit (Remote host closed the connection) |
| 23:22:28 | Araq | so ... reading the logs. yes, Nim doesn't care about the "C standard", we care about the C implementations instead. |
| 23:23:08 | Araq | according to the C standard even memcmp for structs is impossible afaik |
| 23:24:36 | * | Matthias247 quit (Read error: Connection reset by peer) |
| 23:24:47 | * | vendethiel quit (Ping timeout: 240 seconds) |
| 23:24:53 | * | boopsies is now known as boopsiesisaway |
| 23:29:48 | * | yglukhov joined #nim |
| 23:43:23 | * | shodan45 quit (Quit: Konversation terminated!) |
| 23:48:07 | Araq | hrm ... why do we map 'void' to 'empty' ? -.- |
| 23:49:56 | * | ozra joined #nim |
| 23:49:59 | vbtt | Araq: re: which is a bit sad |
| 23:50:40 | vbtt | don't worry, honestly oscon is good but a bit 'enterprisey' |
| 23:51:03 | Araq | good choice of words |
| 23:51:20 | vbtt | so maybe not the perfect audience, but more visibility is better than less. |
| 23:52:17 | Araq | at one point I'll just do it like Jonathan Blow (did I spell that correctly?) |
| 23:52:28 | vbtt | looks right. |
| 23:52:31 | vbtt | great idea! |
| 23:52:54 | Araq | and re-invent thread local storage without noticing ;-) |
| 23:53:04 | Araq | but as a youtube video |
| 23:53:32 | vbtt | yeah, try hangouts on air - might be easy to get started without too much software fiddling. |
| 23:53:59 | vbtt | it automatically becomes a youtube video |
| 23:58:27 | vbtt | ok, now i don't know if you were joking about making the video or just about reinventing something :) |
| 23:59:17 | Araq | no, I wasn't joking about the video |