00:01:18 | BitPuffin | Araq: don't |
00:08:32 | * | Matthias247 quit (Quit: Matthias247) |
00:09:19 | fowl | just fix all the issues and call it 1.0 :p |
00:09:36 | fowl | by all the issues i mean the most important ones (mine) |
00:13:41 | Araq | but but but |
00:13:57 | Araq | all the cool features are still missing |
00:36:49 | * | DAddYE quit (Ping timeout: 240 seconds) |
00:37:17 | BitPuffin | Araq: you probably want the extra headroom of 0.9.6 and 0.9.8 first |
00:37:33 | BitPuffin | if not you could jut go from 0.9.6 to 1.0 |
00:37:39 | Araq | true lol |
00:37:56 | BitPuffin | so better do it then than doing it now and be sorry later :P |
00:40:24 | fowl | this should pass right: |
00:41:01 | fowl | type tc = generic Z; Z of TObject type X = object of TObject; x is tc |
00:44:04 | BitPuffin | fowl: no |
00:44:16 | BitPuffin | because it's not allegro |
00:44:29 | BitPuffin | well I*m not even sure I*ll do the LD at all |
00:51:36 | BitPuffin | I wanna get rid of this damn ordinal type expected bug :( |
00:54:01 | Araq | good night |
00:54:03 | OrionPK | wasnt someone working on a filesystem watcher thing for n imrod |
00:54:24 | * | EXetoC quit (Quit: WeeChat 0.4.3) |
00:54:37 | OrionPK | ah,,, http://nimrod-lang.org/fsmonitor.html |
00:54:41 | OrionPK | only for linux |
01:05:12 | BitPuffin | OrionPK: well I was wishing to make a file system with nimrod lol |
01:05:14 | BitPuffin | but too much work |
01:05:17 | BitPuffin | but you know |
01:05:20 | reactormonk | OrionPK, should work on windows too, you can also try a few of the ruby tools and see what bindings they use |
01:05:21 | BitPuffin | got infinite time :P |
01:05:52 | * | holly_ joined #nimrod |
01:08:50 | * | q66 quit (Quit: Leaving) |
01:12:20 | holly_ | can anyone help, when i compile latest with useffi i get an error in vm.nim when it passes a seq[TFullReg] to callForeignFunction in evalffi.nim, which expects a TNodeSeq |
01:13:00 | fowl | holly_, useffi is broken atm, its a known issue |
01:15:40 | fowl | holly_, ffi isnt used to interface with c btw, its for the VM |
01:16:28 | * | holly_ quit (Ping timeout: 245 seconds) |
01:50:00 | fowl | BitPuffin, ugly: AL_FUNC(bool, al_resize_display, (ALLEGRO_DISPLAY *display, int width, int height)); |
01:56:51 | Demos | is there a way to say, apply whatever explicit conversions you need to make this compile?, I have a literal '1' that I want to convert to like "T.T" but I can not just go and name T.T due to a compiler bug |
01:59:29 | OrionPK | reactormonk it wont work on windows |
01:59:36 | OrionPK | look at the fsmonitor doc |
01:59:51 | OrionPK | ## Windows support is not yet implemented. |
01:59:58 | OrionPK | https://github.com/Araq/Nimrod/blob/devel/lib/pure/fsmonitor.nim |
02:01:21 | Demos | I am 100% in support of implicit conversions being applied to literals |
02:37:33 | fowl | Demos, what type? some distinct type? |
02:37:46 | Demos | any type |
02:37:51 | Demos | or wait |
02:38:01 | fowl | this works: var x: GLint = 4 |
02:38:03 | Demos | just like an integer literal to a float32 in this case |
02:38:22 | fowl | :float32=4 works |
02:42:57 | * | xenagi quit (Quit: Leaving) |
02:43:31 | * | wolfspaw joined #nimrod |
02:43:38 | * | wolfspaw left #nimrod (#nimrod) |
02:44:01 | fowl | Demos, what context is it not working in |
02:45:12 | Demos | a[i,i] = 1 where `[]=`(self: var TMatrix; i,j: int; val: TMatrix.T) |
02:45:42 | * | DAddYE joined #nimrod |
02:45:59 | Demos | HOLY SHIT |
02:47:01 | fowl | ? |
02:48:05 | Demos | I was having an issue where my 2x2 matrices were being "converted" to 4x1 matrices when I used []= on them, but when I stop importing unittest the problem goes away |
02:49:53 | Demos | wait never mind |
02:58:49 | Demos | https://github.com/Araq/Nimrod/issues/1018 that was annoying to track down :D |
02:58:52 | Demos | I thought I was seeing things |
03:05:56 | Demos | is there a way to tell nimrod not to reuse generics? |
03:08:55 | * | BitPuffin quit (Ping timeout: 264 seconds) |
03:12:20 | fowl | Demos, in your example is "Tmat2f is tvec4f" true? |
03:13:19 | Demos | yes it is |
03:13:43 | fowl | well |
03:13:51 | fowl | 2*2-1 == 4*1-1 |
03:14:37 | fowl | i think that is your issue |
03:14:39 | Demos | right, but the size of the array has nothing to do with the type |
03:14:49 | Demos | if it does then it is totally insane semantics |
03:15:08 | Demos | it prevents phantom types from ever being useful |
03:15:41 | Demos | and if I just stick another phantom on the end it works |
03:16:13 | Demos | or actually it still crashes but TVec4f is TMat2f returns false |
03:16:47 | Demos | but if I change the phantom to P: static[int] `is` returns false |
03:16:53 | fowl | its trying to access index 4 in an array of size 4 |
03:16:53 | Demos | erm true |
03:16:57 | Demos | I know |
03:17:05 | Demos | but it should be trying to access index 2 |
03:17:23 | Demos | except TMatrix.N returns the wrong number |
03:17:56 | Demos | I have a thing of type TMatrix[2,2,float32]. Saying TMatrix.N in `[]=` should in no reasonable universe return 4 |
03:17:58 | fowl | i dont get how TMatrix.N is supposed to be the TMatrix "self" |
03:18:12 | Demos | that is the syntax |
03:19:12 | Demos | http://build.nimrod-lang.org/docs/manual.html#generics |
03:20:43 | fowl | so it specifically refers to the first parameter? |
03:21:31 | Demos | no, any param of type TMatrix, if you have multiple implicit generic params with different types you need to do like type(self).T or whatever |
03:21:59 | Demos | result = exprStructuralEquivalent(a.n, b.n) and sameFlags(a, b) for tyStatic params |
03:22:28 | fowl | btw when you do an issue put ```nimrod so its highlighted right |
03:23:28 | Demos | sorry |
03:23:45 | Demos | there |
03:24:20 | fowl | i see what ur talking about tho (sry im slow tonight) |
03:25:17 | Demos | no problem |
03:26:56 | fowl | i ran into a problem when i used pos = tuple[x,y: float] and velocity = tuple[x,y: float] as components because velocity was matching for pos but indeed your types should be different |
03:58:31 | Demos | hmm it gets to typeRel in sigmatch.nim and the generic params seem to be compared as tyInt, where the comparison is just a.kind == b.kind |
03:58:36 | Demos | nothing with values at all |
04:27:48 | * | DAddYE quit (Remote host closed the connection) |
04:28:15 | * | DAddYE joined #nimrod |
04:28:46 | Demos | hm opengl.nim seems unaware of frameworks |
04:31:56 | Skrylar | I get the impression OpenGL.nim is quite bad :> |
04:32:52 | * | DAddYE quit (Ping timeout: 265 seconds) |
04:51:27 | Demos | not so bad, I just made a PR to fix it a bit |
04:51:37 | Demos | it does the job |
05:11:12 | reactormonk | OrionPK, sad |
05:25:02 | Skrylar | I wonder when decentralized DNS is going to become a thing |
05:25:17 | Skrylar | something built off DHT maybe? |
05:26:18 | reactormonk | Skrylar, sounds interesting |
05:27:04 | Skrylar | I just came across this http://online.wsj.com/news/articles/SB10001424052702303563304579447362610955656?mod=trending_now_3 which goes on about how apparently ICANN is getting dropped as a US asset and Russia wants to take it over (.. and disallow certain people to make domains) |
05:27:21 | Skrylar | Wondering if the netizens will interpret that as damage and route around it :) |
05:28:48 | * | DAddYE joined #nimrod |
05:33:46 | * | DAddYE quit (Ping timeout: 265 seconds) |
05:37:56 | Demos | wow trying to figure out quaternions at 2AM is probably not a great idea |
06:12:49 | * | brson quit (Ping timeout: 240 seconds) |
06:15:09 | * | Demos quit (Quit: Textual IRC Client: www.textualapp.com) |
06:18:42 | * | Skrylar quit (Ping timeout: 264 seconds) |
06:21:13 | * | DAddYE joined #nimrod |
06:23:44 | * | Demos joined #nimrod |
07:06:29 | * | Demos quit (Ping timeout: 240 seconds) |
07:29:18 | * | nande quit (Read error: Connection reset by peer) |
08:25:46 | * | DAddYE quit (Remote host closed the connection) |
08:26:53 | * | fowl quit (Quit: Derogatory terms for gynecomastia can include moobs (for male boobs) and bitch tits.[34]) |
08:30:11 | * | fowl joined #nimrod |
09:31:56 | * | q66 joined #nimrod |
10:13:26 | * | BitPuffin joined #nimrod |
10:21:35 | BitPuffin | fowl: err, is that even in the API? or is it in the source |
10:21:42 | BitPuffin | because I don't see it |
10:22:34 | BitPuffin | ah I see |
10:22:42 | BitPuffin | it's how they create the functions |
10:23:32 | BitPuffin | fowl: I don't think that counts as ugly API since you never call AL_FUNC, so your point is invalid |
10:27:24 | BitPuffin | fowl: does make it impossible for c2nim to do it automatically |
10:27:33 | BitPuffin | so it becomes a by-hand sort of deal |
10:32:56 | BitPuffin | and they probably have a good reason for doing so, it's not like they are like "Hey, I don't know how to put a function is a C header, so I need to create my own macro for doing that!!!" |
10:43:06 | BitPuffin | fowl: yep, like I thought, it's to deal with compiler specific ways to declare library procs |
10:43:56 | BitPuffin | https://gist.github.com/BitPuffin/9661175 |
10:44:02 | BitPuffin | that should make it clear |
11:00:31 | * | CARAM joined #nimrod |
11:11:00 | BitPuffin | fowl: anyways if you don't wanna wrap it I might do it myself instead, even if I might skip the jam. It's just dandy |
11:12:40 | * | EXetoC joined #nimrod |
11:49:18 | * | jennings joined #nimrod |
11:49:36 | * | jennings left #nimrod (#nimrod) |
11:50:17 | * | b_jennings joined #nimrod |
11:52:08 | Araq | hi b_jennings welcome |
11:52:44 | Araq | zahary, zahary_ I wonder if tyStatic is a mistake |
11:53:00 | BitPuffin | why? |
11:53:14 | Araq | we're using the type system for a constraint that has nothing to do with the type |
11:53:29 | Araq | quite like C's "volatile" |
11:54:11 | Araq | is the following true? static[int] is int |
11:55:02 | Araq | does static[int] match static[int] better than int in overloading resolution? |
11:56:13 | Araq | is static[static[int]] the same as static[int]? (yes.) |
11:57:05 | BitPuffin | hmm |
11:57:06 | BitPuffin | good point |
11:57:14 | BitPuffin | maybe it should be some kind of compile time effect thingy |
11:57:21 | EXetoC | isn't this a type vs value thing? |
11:57:49 | Araq | is typedesc[static[int]] the same as static[typedesc[int]]? (no.) |
11:58:09 | Araq | but typedesc[int] is the same as static[typedesc[int]] |
11:59:23 | Araq | btw 3's type is int(iteral(3)) not static[int(literal(3)] |
12:01:20 | EXetoC | I suppose you could resolve it somehow, but would it make sense? |
12:09:27 | EXetoC | apparently you can specify only the major version when qualifying libs on linux, so it doesn't seem so bad anymore |
12:09:52 | Araq | well let's see what zahary thinks about it |
12:10:17 | Araq | I think it should be another AST contraint instead |
12:12:49 | zahary_ | "static[int] is int" should be true; int is not static[int] on the other hand; typedesc[static[int]] is not even close to static[typedesc[int]]; I personally think that int(literal(3)) should go as it is just a single purpose construct |
12:16:08 | zahary_ | tyStatic is very much like tyVar, when it comes to overload resolution (the "more specific" overload matching should affect both in a good way) |
12:17:12 | zahary_ | I'm not particularly happy with AST constraints attached to node kinds, because they don't let you do things like the semistatic[T] type or the new predicated statics that I used in the latest swizzle commit |
12:22:40 | * | renesac quit (Quit: Leaving) |
12:26:35 | Araq | semistatic[T] is a workaround for a missing .specialize pragma/macro afaict |
12:28:43 | BitPuffin | EXetoC: I'm pretty sure I'm gonna use allegro for the 3d stuff too actually haha. Just because it's nice to not have to deal with a million different libfontformat, libcontainerformat, libaudiocodec, libimageformat, libsoundoutput, libcreateopenglcontext etc |
12:30:23 | Araq | zahary_: so now we have to skipTypes(foo, {tyStatic}) everywhere because most of the time nobody cares about static[T] vs T |
12:30:26 | zahary_ | that would be another kludgy single-purpose solution (it will produce more confusing "non of the overload matches" messages and it will require special single-purpose API to carry out the isStatic check in the body). |
12:31:15 | zahary_ | and we are discussion just overload resolution here. attaching AST contraints to the parameters leaves you completely in the cold in semtypinst and generateInstances |
12:31:50 | Araq | static means a different thing for generic parameters |
12:32:33 | zahary_ | well, as I said, tyStatic is very similar to tyVar - both have to be skipped in a lot of places |
12:33:00 | EXetoC | BitPuffin: ok |
12:33:33 | BitPuffin | EXetoC: and ofter the 3d rendering pass is done I can use the 2d stuff in allegro for rendering UI :P |
12:34:14 | Araq | well you can add tyStatic to types.abstractInst et al and hope for the best |
12:34:20 | zahary_ | the skip categories should help with that |
12:34:36 | Araq | or you can through the whole compiler and check every single skipTypes call |
12:34:45 | Araq | and decide what it needs to do with tyStatic |
12:36:11 | zahary_ | do we have bugs likes this at the moment? I have already fought such problems |
12:37:26 | Araq | I don't know |
12:37:40 | EXetoC | BitPuffin: your API won't be any good for UI's? |
12:37:58 | BitPuffin | EXetoC: my API will yes |
12:38:03 | BitPuffin | but this is not for making my API |
12:38:16 | Araq | it just feels like you're fighting bug after bug when it comes to 'tyStatic' and so I wonder whether it's flawed by design :P |
12:38:19 | BitPuffin | I want a bit more experience before I start designing the API |
12:38:26 | BitPuffin | like for example having made a physics engine etc |
12:39:31 | Araq | I mean just write it down: "semistatic[T] is a type that causes specialization for an instantiation if the passed expression is a constant value or otherwise it simply means T" |
12:39:48 | zahary_ | the hardest part so far is to get the interaction between tyStatic and tyRange used as array index |
12:40:25 | zahary_ | since people want to be able to say array[5, int] ,where 5 got computed in some weird way from a static type |
12:40:41 | Araq | "and so semistatic[int] introduces an implicit generic as otherwise there would be no instantiation context to begin with" |
12:41:23 | Araq | that's not a type, that's a side-effect in the compilation pipeline masked as a type ... |
12:43:04 | zahary_ | I don't see how replacing semistatic[T] in that sequence with any other type class like tuple|object is different |
12:45:05 | zahary_ | *in that sentence* |
12:45:44 | zahary_ | I also plan other similar types like fwd[T] = var T | T btw |
12:46:21 | zahary_ | proc foo(x: fwd[MyType]): fwdas(x, int) = x.value |
12:47:13 | zahary_ | again, just to show how var T and static[T] are so similar |
12:52:33 | Araq | well 'var T' is another kludge but apart from that |
12:53:14 | Araq | object|tuple means "any object or tuple here", semistatic[int] means "int as a type, but potentially static" |
12:53:23 | * | zielmicha quit (Quit: Connection closed for inactivity) |
12:53:38 | Araq | which describes exactly the same set of values as 'int' |
12:53:54 | Araq | the difference is quite big, in my opinion |
12:54:09 | Araq | types are primilariy to specify the set of valid values |
12:54:49 | zahary_ | I understand your point, but and/or types also serve the purpose of a "ordered choice" construct |
12:55:01 | zahary_ | not just type set semantics |
12:56:01 | zahary_ | I find this property useful - obviously it has practical value here, because "potentially static" means that you can exploit that information in the body of the proc |
12:56:54 | Araq | what's another use case apart from specialization? |
12:57:27 | zahary_ | well, the forward type I posted is another example |
12:57:55 | zahary_ | RandomAccessibleIterator | Iterator is used in C++ |
12:59:21 | Araq | I'm still talking about static/semistatic not about | |
12:59:35 | Araq | | is a very clear type construction |
13:01:21 | Araq | in fact, I think whenever somebody uses the type system to not directly refer to the 'valid set of values' interpretation the trouble begins |
13:01:22 | zahary_ | for hypolang I wanted to have this hidden duality to turn some ifs into when statements |
13:01:51 | Araq | C++ const, volatile come to mind |
13:01:58 | Araq | or D's immutable |
13:02:17 | Araq | immutability is not a property of a type, it's an orthogonal concept |
13:03:39 | Araq | it's modelled as C[T] where it should be MetaInformation[C, T] instead |
13:05:41 | zahary_ | did you get my remark about turning ifs into whens or does it need more explaining? |
13:06:01 | Araq | I think I got it |
13:06:08 | zahary_ | if MetaInfromation[C, T] is something that you propagate in the program in a metaInformation field, how is that different than a type? |
13:07:29 | Araq | well I propose to use MetaInformation instead of the 'typ' field for nodes indeed |
13:07:46 | Araq | and in that sense it's not different |
13:07:58 | zahary_ | in my thinking, I appreaciate that we are introducing types that are not entered by the user, but rather computed from the definition (i.e. write tracking determines that a type is immutable or lent, etc) |
13:08:13 | zahary_ | but still, this is type information in my book |
13:08:21 | Araq | but it models *orthogonality* properly |
13:08:38 | Araq | and so I can do if n.meta.typ.kind == tyInt |
13:08:49 | Araq | whithout bothering about skiptypes |
13:10:40 | Araq | much like we use (T, F) for the effect system and not F[T] |
13:11:30 | Araq | but I gotta go, see you later |
13:13:16 | zahary_ | well, I'm interested in tacking one of your to-do list items (make implicitStatic the default) - my plans involve some similar reforms, but this will come later and we need tyStatic now |
13:13:26 | BitPuffin | hmm |
13:13:30 | BitPuffin | when I export what I import |
13:13:36 | BitPuffin | do I still have to specify full path? |
13:13:50 | BitPuffin | like import path/to/foo; export path/to/foo, or can I just do export foo? |
13:14:02 | EXetoC | full path last time I checked |
13:17:45 | BitPuffin | well |
13:17:46 | BitPuffin | do I even need to import to export? |
13:19:29 | * | EXetoC quit (Write error: Broken pipe) |
13:19:58 | * | EXetoC joined #nimrod |
13:20:23 | OrionPK | well guys.... |
13:20:32 | OrionPK | i ordered the new oculus rift devkit |
13:24:39 | BitPuffin | OrionPK: awesoooome |
13:25:51 | OrionPK | maybe have the dev kit ported to nimrod ;) |
13:26:20 | BitPuffin | do it |
13:30:54 | Trixar_za | VR gear is back in fashion? Oo |
13:33:59 | BitPuffin | err, does include work in the same forms as import? |
13:34:04 | BitPuffin | or does it have to be a string with the file name |
13:34:16 | BitPuffin | like include "allegro5/comalleg.nim" |
13:41:50 | BitPuffin | a char** is a cstring in nimrod right? |
13:42:03 | BitPuffin | or rather an array of cstrings |
13:43:45 | EXetoC | pointer to array? |
13:43:50 | EXetoC | anyway, there are relevant helpers in system.nim |
13:44:17 | BitPuffin | yeah |
13:44:26 | BitPuffin | so for an argument that's probably an openarray[cstring] |
14:01:12 | BitPuffin | bah |
14:01:25 | * | Demos joined #nimrod |
14:01:32 | BitPuffin | I really don't like the convention in nimrod that the case for constants are the same as for procedures |
14:01:37 | BitPuffin | can't we agree on something else xD |
14:04:20 | Demos | prefix them withe a c |
14:06:08 | * | darkf quit (Quit: Leaving) |
14:06:30 | * | zahary_ left #nimrod (#nimrod) |
14:06:57 | EXetoC | "Constant" is the convention |
14:07:14 | BitPuffin | I personally prefer the CONSTANT_VALUE way |
14:07:14 | EXetoC | but it's not always consistent |
14:07:21 | BitPuffin | EXetoC: not the last time I asked Araq |
14:07:32 | * | zahary_ joined #nimrod |
14:07:42 | EXetoC | ok so it's not, but is still inconsistent |
14:07:53 | EXetoC | BitPuffin: apparently that's too much "shouting" |
14:07:59 | EXetoC | but I see it just as another variation |
14:08:28 | BitPuffin | I dunno I quite like that naming convention |
14:08:49 | BitPuffin | actually I like bla_bla_bla for variables, BLA_BLA_BLA for constants, blaBlaBla for procs |
14:08:53 | BitPuffin | that way they are different |
14:08:58 | BitPuffin | right now they are all the same |
14:09:01 | EXetoC | I think it's fine. Sure, it might remind you of C macros, but big deal |
14:09:01 | BitPuffin | and BlaBla for types |
14:09:42 | Demos | well for CONSTANT_VALUE you may want to say cCONSTANT_VALUE since CONSTANT_VALUE will clash with a proc called constantValue |
14:09:47 | BitPuffin | I'm fine with the T and P prefix |
14:10:13 | BitPuffin | Demos: sure, but that's got nothing to do with just how they differ in style |
14:10:16 | Demos | true |
14:10:18 | BitPuffin | but yeah that might be a pretty good idea |
14:10:32 | BitPuffin | or even CCONSTANT_VALUE |
14:10:33 | EXetoC | Demos: that's rarely an issue though, and any collisions can be resolved with module qualifiers |
14:10:47 | BitPuffin | since that's more alike TFoo |
14:10:50 | BitPuffin | we don't do tFoo |
14:11:04 | EXetoC | we don't do TFOO either |
14:11:11 | BitPuffin | I didn't say that |
14:11:25 | BitPuffin | TFOO would be a const with what I suggested |
14:11:33 | EXetoC | no, but it's uglier, and CCONSTANT_VALUE is pretty similar |
14:11:42 | Demos | right, it is sometimes a good idea, like in the openGL header with some of the consts |
14:12:03 | EXetoC | well in that case you have no choice because they're in the same module |
14:12:07 | BitPuffin | it's not like we prefix all procs with proc either |
14:12:28 | BitPuffin | usually you might prefix things with something like the library name |
14:12:45 | BitPuffin | so allegro for example has the ALLEGRO_ prefix on consts, and al_ on procs |
14:12:57 | BitPuffin | although in my binding that's just alTheProc |
14:13:06 | BitPuffin | because that's nimrod convention |
14:13:26 | BitPuffin | I could have just made it theProc but they are not all in an "al" module |
14:14:38 | Demos | yeah I meant within the same module |
14:14:39 | EXetoC | what difference does that make? qualify if necessary |
14:15:23 | * | psquid joined #nimrod |
14:15:29 | * | Guest79651 quit (Ping timeout: 270 seconds) |
14:15:47 | BitPuffin | EXetoC: guess it lowers the risk of something clashing at all? |
14:17:02 | * | io2 joined #nimrod |
14:20:39 | BitPuffin | is it really required to import before you export? It would seem like that shouldn't be necessary |
14:21:33 | * | Trimsty joined #nimrod |
14:21:36 | Demos | is it really that hard to write a macro that does what you want? |
14:21:40 | Demos | :D |
14:21:43 | EXetoC | so you're then forced to specify the prefix all the time, which would negate the time saved by not resolving collisions |
14:21:44 | Trimsty | Hi :D |
14:22:38 | BitPuffin | EXetoC: not realy, if you are a half decent typist you should be able to deal with the prefix |
14:22:46 | BitPuffin | without many extra milliseconds |
14:22:56 | BitPuffin | and writing the prefix doen't interrupt brainflow |
14:23:07 | BitPuffin | whereas going and seeing like oh shit name collision gotta fix that does |
14:24:45 | EXetoC | go against the grain if you want, but there's a reason why we have a module system |
14:25:30 | BitPuffin | :P |
14:25:59 | * | Demos quit (Ping timeout: 241 seconds) |
14:26:26 | BitPuffin | a tuple is the best equivalent to a struct amirite? |
14:26:48 | Trimsty | Hey, guys, how easy is it in Nimrod to create a GUI? As easy as in C, or is there a built-in lib? :P |
14:26:54 | Trimsty | Kinda new to Nimrod |
14:26:57 | EXetoC | objects are more strongly typed |
14:27:19 | EXetoC | but both are basically like structs, so it's up to you to choose the right abstraction |
14:27:45 | BitPuffin | well I'm thinking that structs don't have information hiding in C |
14:27:49 | EXetoC | my vector types are all tuples, and the same goes or my matrix type I think |
14:27:54 | BitPuffin | so tuple seems like the equivalent |
14:28:24 | EXetoC | you can export every field if you want |
14:29:30 | BitPuffin | I know |
14:29:44 | BitPuffin | but it's like why bother when there is a construct that does that by default :P |
14:32:53 | EXetoC | I would use an object for more complex abstractions |
14:33:04 | BitPuffin | this is not particularly complex |
14:33:18 | BitPuffin | it's altime.h |
14:33:20 | BitPuffin | ez |
14:34:01 | BitPuffin | are __foo__ names disallowed? |
14:34:16 | EXetoC | I think __foo__ == foo |
14:34:46 | BitPuffin | ah |
14:34:55 | BitPuffin | yeah that's just what I renamed it to |
14:35:01 | BitPuffin | but it errored with __foo__ |
14:35:04 | BitPuffin | which is strange |
14:35:53 | EXetoC | no, you can only do foo_bar apparently |
14:36:45 | EXetoC | and then you can reference it using one of the ~4 popular variations |
14:37:36 | BitPuffin | it's not ~4 |
14:38:07 | BitPuffin | it could be f_O_o_bA_r |
14:38:15 | BitPuffin | many possibilities |
14:38:23 | BitPuffin | guess that doesn't count as popular |
14:38:31 | EXetoC | f_O_o_bA_r is popular? :p |
14:38:35 | EXetoC | right |
14:44:53 | * | Demos joined #nimrod |
14:46:52 | Demos | objects are closer to structs than tuples |
14:47:03 | Demos | since tuples can be structurally typed |
14:47:40 | BitPuffin | which means? |
14:47:46 | Demos | Trimsty, not wonderful. We do wrap GTK+ but that is hardly ideal. |
14:48:21 | Demos | it means that as long as the types are in the right order the tuples are the same, even if they are declared with different names |
14:49:00 | BitPuffin | hmm |
14:49:06 | BitPuffin | good point |
14:49:11 | Demos | not sure exactly what the semantics are, but still |
14:49:50 | Demos | objects that do not derive from anything have the same memory layout as a C struct |
14:50:22 | BitPuffin | alright good |
14:52:35 | BitPuffin | is _foo == foo? |
14:52:51 | EXetoC | _foo = error |
14:52:56 | EXetoC | let me try again to be sure |
14:53:08 | EXetoC | yep |
14:54:32 | BitPuffin | AH |
14:54:34 | BitPuffin | oops |
14:54:36 | BitPuffin | capsurs |
14:56:47 | * | Trimsty quit (Quit: Trimsty) |
15:09:23 | BitPuffin | hmm |
15:09:40 | BitPuffin | can individual possible values in an enum be optionally exported? |
15:20:54 | * | jbe_ joined #nimrod |
15:22:18 | BitPuffin | something like this should work right? https://gist.github.com/BitPuffin/9666225 |
15:23:31 | Demos | what is nimrod's policy on sequence points? |
15:28:37 | * | hoppecl joined #nimrod |
15:36:34 | jbe_ | i wrote an html template lib where you nest templates to produce a proc with a bunch of write calls. but the generated c code becomes obese with the nested nimrod template invocations, even with -d:release.. ideas? |
15:43:50 | BitPuffin | err, the recommended thing by Araq when a C proc returns an int is to just set it to int right? rather than cint |
15:44:41 | Demos | BitPuffin cint and int are DIFFERENT data types |
15:44:51 | BitPuffin | I know |
15:45:40 | Demos | so why would you use the wrong type? |
15:46:17 | BitPuffin | I dunno |
15:46:28 | BitPuffin | I think I remember someone saying Araq told people to do that |
15:46:59 | Demos | I mean I guess it may cast on the return type, but I prefer to just match the type |
15:49:09 | BitPuffin | yeah |
15:49:14 | BitPuffin | I guess I'll do that to be safe or something |
15:58:05 | * | psquid quit (Quit: work) |
15:59:05 | * | Demos quit (Quit: Textual IRC Client: www.textualapp.com) |
16:21:42 | * | Demos joined #nimrod |
16:29:19 | * | flaviu joined #nimrod |
16:30:40 | * | io2 quit () |
16:41:01 | * | DAddYE joined #nimrod |
16:48:17 | Varriount | jbe_: Could you be a bit more specific? |
16:51:28 | * | Endy joined #nimrod |
16:55:33 | jbe_ | Varriount: I have a template `%`(tag_and_params: expr, body:stmt), and use it to describe html templates, like this: %html: %body("lang", "en"): %p: template_print("Hello") |
16:55:40 | jbe_ | it works, but the generated c seems to grow exponentially with the size of the template |
16:57:30 | Varriount | jbe_: Could you use a term-rewriting macro? |
16:59:14 | Varriount | jbe_: What *should* the C code look like? |
16:59:57 | jbe_ | that's what i was thinking too, but i still don't see how the c code can grow that large. i'll look into it a bit more though. i'm still new to macros and the ast |
17:01:07 | jbe_ | i mean, it was feeding gcc several hundred thousand lines |
17:02:08 | * | Demos quit (Ping timeout: 246 seconds) |
17:02:20 | Varriount | jbe_: Well, without something concrete to analyze, I can't do much but guess. |
17:02:53 | jbe_ | ok, thanks anyway |
17:03:36 | BitPuffin | if a C funciton takes pointers to ints |
17:03:39 | * | Demos joined #nimrod |
17:03:47 | BitPuffin | is it safe to make the nimrod version take var cint's ? |
17:04:06 | Demos | BitPuffin: probably not |
17:04:18 | BitPuffin | :/ |
17:04:25 | Demos | I would not use var params on a proc with the {.importc.} pragma |
17:04:49 | Demos | if you want em that bad write a seperate nimrod interface that uses the C wrapper |
17:05:11 | BitPuffin | yeah I might write an alternative or something |
17:05:20 | BitPuffin | to create a tuple do I have to put it in a type section |
17:05:35 | BitPuffin | or can I do return type as tuple[x, y, width, height: cint] ? |
17:05:43 | Demos | that said var cint on a imported function will /probably/ end up as int* in C |
17:06:01 | Demos | you can do that |
17:06:05 | BitPuffin | cool |
17:06:14 | Varriount | BitPuffin: FYI, in C, an "int" is a "cint" in nimrod |
17:06:36 | Demos | Varriount: or an int32... usually |
17:06:55 | Varriount | Demos: And a cint is an int32 |
17:07:49 | Demos | gaagh the way varargs work is totally strange, I am doing the olde copy and paste varargs but it is annoying because it means I will have to implemnet perf improvements like 4 times |
17:08:13 | Varriount | copy and paste varargs? |
17:08:28 | Demos | proc func(a,b) |
17:08:32 | Demos | proc func(a,b,c) |
17:08:35 | Demos | proc func(a,b,c,d) |
17:08:53 | Varriount | Demos: Is it possible to use a dirty template. |
17:09:31 | BitPuffin | Varriount: yeah, that's why I said cint, what is your point? |
17:09:35 | Demos | maybe but I found it hard figure it out, since I want to return a value. Also I need variadic iterators |
17:09:57 | Varriount | Demos: Could I see the code in question? |
17:10:01 | Demos | I want something like template<typename... T> ...... from c++ |
17:10:27 | Varriount | Demos: Array of typedesc? |
17:11:16 | Demos | no, because each element is a typedesc of a different type |
17:11:24 | Demos | https://gist.github.com/barcharcraz/d6cd3fc46d44c141b529 |
17:12:04 | Demos | and if I say varargs[typedesc] than the name() of each element is "none" |
17:12:43 | Demos | doing varargs[expr] does not work either, since I need to get a type out of the expr. |
17:13:45 | Demos | in addition the iterator on line 19 fails with an internal error |
17:14:11 | Demos | so I am stuck with reimplementing everything like it is 1989 |
17:17:34 | EXetoC | bacon |
17:17:45 | BitPuffin | VNUG so empty |
17:18:14 | Demos | all I want for christmas is shift @_ |
17:18:20 | EXetoC | Demos: varargs[typedesc] or something? |
17:18:31 | Demos | noooope, tried several ways of doing that |
17:18:38 | Demos | I do not get the "real" type |
17:19:31 | Demos | is varargs actually an array? or is it some sort of other construct (tupleish thing) |
17:20:22 | EXetoC | it's like openarray, but with an optional syntactic difference |
17:20:30 | EXetoC | foo(1, 2, 3...) |
17:21:03 | Demos | but then writing something where I can call it as foo(1, "foo", 5.0) or foo("foo", "foooooo", "bbar") is hard |
17:21:30 | Demos | like how can one write printf? |
17:22:15 | * | nolan_d joined #nimrod |
17:23:55 | EXetoC | Demos: what do you mean? echo for example takes varargs |
17:24:10 | Demos | and for templates I am just not sure how to write them in a way where they have a return value like a function |
17:24:20 | EXetoC | but echo relies on the auto-conversion feature as you can see |
17:24:21 | Demos | echo takes vararg[string] though right? |
17:24:25 | Demos | yeah |
17:24:31 | EXetoC | varargs[T, `$`]? |
17:24:31 | Demos | oh wait |
17:25:18 | Varriount | BitPuffin: I could be on VNUG, however I would only be able to communicate via text chat. |
17:25:27 | Varriount | I'm in class at the moment. |
17:25:33 | BitPuffin | Varriount: ah |
17:25:33 | Demos | same Varriount |
17:25:35 | BitPuffin | I see |
17:25:40 | BitPuffin | well then it's like irc anyway haha |
17:25:52 | EXetoC | so it's like a type vararg, but I don't know if it's specifically for the two-argument version |
17:25:54 | BitPuffin | except that I could talk I guess |
17:25:56 | BitPuffin | but meh :P |
17:26:10 | Demos | I could do varargs[string, name] then use a macro to convert the string back into a type identifier |
17:26:45 | Varriount | why doesn't varargs[typedesc] work again? |
17:27:08 | Demos | because each typedesc in there needs to be of a different type |
17:27:17 | Demos | like typedesc[int], typedesc[string] or whatever |
17:27:26 | Varriount | But they are all of type typedesc? |
17:27:37 | Demos | I end up getting a bunch of like typedesc[none]. Right Varriount but that is not a generic type |
17:27:39 | EXetoC | typedesc[T]? |
17:27:51 | Demos | sorry it is not a concrete type |
17:28:03 | Varriount | Hm. |
17:28:10 | Demos | but then I would have like varargs[typedesc[int]] as my concrete type which is wrong |
17:28:24 | Demos | treating varargs as an array is super problematic |
17:29:23 | Varriount | Demos: What about the typeinfo module? |
17:29:42 | Varriount | Can you leverage run-time type info, instead of compile time type info? |
17:30:19 | Demos | no. My types are plain objects |
17:30:38 | Demos | and I would rather keep it to compile time anyways |
17:32:30 | Demos | I think what I want can be done with a template or macro, but I dont know how to go about doing it. Every time I try I get tricky compile errors and wierdness reguardeing how exprs and typedescs flow through my code |
17:32:45 | EXetoC | about 9000 people have asked about variadic generics, but has anyone actually created a ticket? |
17:33:08 | Demos | I don't think so. It should be an RFC |
17:35:31 | Demos | should I make some |
17:35:44 | Demos | anyone know of any other languages that have them, so far I can see c++ and D |
17:35:45 | Varriount | Demos: Typetraits? |
17:35:49 | Demos | nope |
17:35:56 | Demos | typetraits has like 2 functions |
17:35:59 | Demos | and does not help much |
17:36:32 | Demos | like I said, this may be possible with like a template that takes varargs[expr] but it is harder to write than the copy-paste version |
17:36:43 | Demos | anyway, should I start the RFC |
17:36:48 | Varriount | Yes |
17:38:35 | Varriount | It's funny, one of the most recent tickets reminds me of a feature I proposed a while back - partial argument application via generic parameters |
17:45:40 | Demos | OK posted. I dont know how to tag it RFC though |
17:48:31 | Varriount | Demos: Done. Tagged it as "Feature" and "RFC" |
17:49:10 | Demos | sweet, added in a link to a similar ticket for rust |
17:50:40 | Demos | I can not find anyone else that has variadic generics |
17:51:48 | Demos | even haskell just lists out all the different versions |
17:52:48 | Demos | I think agada and idris can do them, but they hardly count |
17:52:51 | Demos | *agda |
18:03:23 | * | Demos quit (Ping timeout: 246 seconds) |
18:03:25 | * | q66 quit (Quit: Leaving) |
18:05:45 | * | q66 joined #nimrod |
18:07:08 | * | DAddYE_ joined #nimrod |
18:07:14 | * | DAddYE quit (Ping timeout: 246 seconds) |
18:08:07 | * | Demos joined #nimrod |
18:10:18 | * | DAddYE joined #nimrod |
18:12:05 | BitPuffin | that's a weird error |
18:12:16 | * | DAddYE quit (Read error: Connection reset by peer) |
18:12:19 | BitPuffin | color.nim(11, 46) Error: identifier expected, but found '= ' |
18:12:24 | * | DAddYE__ joined #nimrod |
18:12:47 | BitPuffin | https://gist.github.com/BitPuffin/9670251#file-gistfile1-nim-L8 |
18:13:12 | BitPuffin | it's supposed to say (11, 46) I just tried a thing |
18:13:13 | EXetoC | is it because of the commas? |
18:13:32 | BitPuffin | nope |
18:13:35 | BitPuffin | Don't think so |
18:13:35 | * | DAddYE_ quit (Ping timeout: 265 seconds) |
18:13:44 | BitPuffin | or hm |
18:13:52 | * | DAddYE joined #nimrod |
18:13:55 | reactormonk | cint(0) ? |
18:13:59 | BitPuffin | there is supposed to be commas |
18:14:17 | BitPuffin | reactormonk: then why wouldn't it whine on the first one? |
18:14:17 | reactormonk | sometimes the lexer does strange things |
18:14:24 | reactormonk | no idea :-/ |
18:14:49 | reactormonk | BitPuffin, remove the 15 on live 10 and see what happens |
18:15:04 | reactormonk | s/live/line/ |
18:15:04 | EXetoC | shouldn't you use int literals and then specify the size pragma? |
18:15:15 | BitPuffin | nope changed when I did cint(num) style instead |
18:15:55 | BitPuffin | still same error :/ |
18:15:58 | EXetoC | enum {.size: T.} |
18:16:22 | EXetoC | *T.sizeof |
18:16:37 | * | DAddYE__ quit (Read error: Connection reset by peer) |
18:16:39 | * | DAddYE_ joined #nimrod |
18:18:09 | Demos | does https://gist.github.com/barcharcraz/f5278b275a4d758d4685 look like valid code? |
18:18:35 | BitPuffin | EXetoC: we didn't use nimrod int literals in portaudio |
18:19:13 | BitPuffin | adding the size pragma didn't help |
18:19:21 | EXetoC | omit cint? |
18:19:32 | BitPuffin | no why |
18:19:37 | BitPuffin | we used cint in portaudio |
18:19:46 | BitPuffin | https://bitbucket.org/BitPuffin/nim-portaudio/src/b34b9f179734753c4ed23ad0bd28ac0b817e7d58/src/portaudio.nim?at=default#cl-25 |
18:20:00 | BitPuffin | brb |
18:20:10 | * | DAddYE quit (Ping timeout: 246 seconds) |
18:20:13 | Demos | try just using 4 instead of 4.cint, casts may just happen |
18:20:16 | Demos | not ideal but still |
18:20:18 | EXetoC | yeah but I don't know why it is failing |
18:26:37 | * | DAddYE joined #nimrod |
18:29:01 | EXetoC | Demos: I think the type always is that of the enumerators for the current C compiler |
18:29:47 | Demos | most C compilers let you select the type |
18:29:54 | Demos | actually I think that is a standard c++ feature |
18:29:59 | * | DAddYE_ quit (Ping timeout: 240 seconds) |
18:31:09 | EXetoC | yes but it's not standard C is it? |
18:31:55 | Demos | I dont think so |
18:32:15 | Demos | but I am sure GCC, clang, and MSVC all have extensions for it |
18:34:51 | * | seubert is now known as SPOONMAN |
18:35:09 | * | SPOONMAN is now known as seubert |
18:38:15 | * | flaviu quit (Ping timeout: 265 seconds) |
18:40:34 | * | brson joined #nimrod |
18:40:44 | EXetoC | Demos: I guess you can't use enums then for now, but that doesn't seem too common |
18:40:54 | EXetoC | but it's a minor issue |
18:44:10 | * | io2 joined #nimrod |
18:45:20 | EXetoC | BitPuffin: those cint invocations for TErrorCode don't really do anything I think. but that doesn't matter because TErrorCode isn't being used anywhere |
18:45:44 | * | Demos quit (Ping timeout: 246 seconds) |
18:47:28 | BitPuffin | EXetoC: in PA? |
18:48:09 | * | DAddYE_ joined #nimrod |
18:48:36 | BitPuffin | removed like the first half of the .cint stuff, and the error still happens on the same line |
18:49:41 | BitPuffin | so it's not that |
18:50:14 | EXetoC | BitPuffin: works for me |
18:51:06 | * | DAddYE quit (Ping timeout: 264 seconds) |
18:51:14 | BitPuffin | EXetoC: the whole thing? |
18:51:36 | BitPuffin | maybe it's that it wants to count up on its own or something |
18:51:43 | BitPuffin | and doesn't want me to set every value |
18:51:51 | BitPuffin | that's the only thing I can think of that would make sense with the error |
18:52:52 | * | BitPuffin wonders where Araq went |
18:53:44 | * | Demos joined #nimrod |
18:54:01 | BitPuffin | removing all the .cint didn't work either |
18:54:03 | BitPuffin | same error |
18:54:04 | EXetoC | BitPuffin: only the type section |
18:54:05 | BitPuffin | the fuck is this |
18:54:14 | EXetoC | is the included file syntactically correct? |
18:54:52 | EXetoC | exporting would be a better idea, but then you have to specify every symbol |
18:55:31 | BitPuffin | it should be |
18:55:37 | BitPuffin | didn't have problems with it with other modules |
18:55:46 | BitPuffin | https://gist.github.com/BitPuffin/9671196 |
18:55:55 | BitPuffin | it's included because nothing is and shouldn't be exported |
18:57:06 | * | BitPuffin quit (Quit: WeeChat 0.4.3) |
18:57:19 | * | BitPuffin joined #nimrod |
19:01:49 | BitPuffin | this is driving me cray cray |
19:01:58 | EXetoC | how about just importing then? |
19:02:16 | EXetoC | BitPuffin: what if you remove everything except the type section? |
19:02:30 | BitPuffin | same thing |
19:02:33 | BitPuffin | just tried it |
19:03:01 | EXetoC | my compiler version isn't too outdated, but I'll upgrade anyway and see if it changes the outcome |
19:03:15 | BitPuffin | errr |
19:03:17 | BitPuffin | okay |
19:03:25 | BitPuffin | so when I copied and pasted it from github it worked |
19:03:27 | BitPuffin | what the fuck |
19:03:31 | BitPuffin | some kind of encoding thing or what? |
19:03:54 | EXetoC | are you using vim? |
19:04:28 | BitPuffin | yeah |
19:04:32 | BitPuffin | what is this |
19:04:34 | BitPuffin | seriously |
19:04:56 | EXetoC | :set list |
19:05:14 | EXetoC | are the newlines identical? |
19:05:29 | BitPuffin | well now I removed the stuff that wasn't working lol |
19:05:37 | BitPuffin | and I don't feel like messing it up again xD |
19:05:43 | BitPuffin | how do I unset list? |
19:06:20 | EXetoC | actually that's not all you have to do. stackoverflow accept fail |
19:06:47 | BitPuffin | however it just happened in another file too |
19:06:49 | EXetoC | :set nolist |
19:07:32 | BitPuffin | and the newlines look fine |
19:09:49 | BitPuffin | and pasting to github and adding it again solves the problem |
19:09:51 | BitPuffin | what the actual fuck |
19:10:58 | EXetoC | how do you view the newlines? that advice was wrong like I said |
19:11:26 | BitPuffin | bah there is no "or" for cint |
19:12:05 | * | Demos quit (Ping timeout: 265 seconds) |
19:12:07 | EXetoC | still dealing with enumerators? |
19:13:02 | BitPuffin | no I solved it by pasting to github and copying lol |
19:13:14 | BitPuffin | but same thing will probably happen soon enough |
19:13:48 | BitPuffin | Error: undeclared identifier: '‚' -____- |
19:14:06 | BitPuffin | result = (x[]‚ y[], w[], h[]) |
19:15:34 | EXetoC | :o |
19:18:09 | EXetoC | I just tried something similar that works. got a test case? |
19:18:53 | BitPuffin | no? |
19:18:57 | BitPuffin | but I can give you the proc |
19:18:59 | * | gXen joined #nimrod |
19:19:20 | gXen | I am looking at learnign a new language |
19:19:44 | EXetoC | so how did you determine that the newlines are uniform? try a hex editor :p |
19:19:45 | BitPuffin | https://gist.github.com/BitPuffin/9671711 |
19:19:58 | gXen | when I stumbled upon nimrod, I was surpirsed I hear alot about scala, go, rust,.. lately, but howcome nimrod isnt more popular? |
19:20:02 | BitPuffin | gXen: you've come to the right place |
19:20:04 | EXetoC | but Nimrod is pretty lenient in this regard I think |
19:20:06 | gXen | concise as python, fast as c? |
19:20:14 | BitPuffin | gXen: because no corporate backing |
19:20:16 | BitPuffin | gXen: yes |
19:20:40 | * | nande joined #nimrod |
19:20:43 | gXen | but that means its the best language there is.. |
19:20:50 | BitPuffin | gXen: correct |
19:21:07 | EXetoC | hm. check the syntax coloring |
19:21:08 | gXen | accept low level languages, hardly anything beats c in speed, nothing beats python in pruductivity... |
19:21:21 | gXen | so... whats the catch? |
19:21:30 | gXen | (serious q) |
19:21:30 | BitPuffin | gXen: immature compiler? |
19:21:37 | BitPuffin | with a few bugs here and there |
19:21:39 | EXetoC | instability? lack of industry support? |
19:21:55 | BitPuffin | still in development |
19:22:12 | gXen | how does nimrod deal with concurrency? |
19:22:22 | BitPuffin | gXen: I'll link to a blog post |
19:22:37 | BitPuffin | http://nimrod-lang.org/blog/concurrency.html |
19:22:42 | BitPuffin | http://nimrod-lang.org/blog/concurrency2.html |
19:22:46 | BitPuffin | two actually :P |
19:24:10 | gXen | I am looking at the code on the nimrod website ... and this is as easy to write as python... benchmark websites show this often beats c in speed... I am spinning in my chair... |
19:25:06 | BitPuffin | hard to see how it can beat C in speed when it compiles to C lol. But I guess if it makes it easier to write better code I guess it will produce wizard C that nobody would write :P |
19:25:33 | EXetoC | C written by human beings maybe |
19:25:43 | BitPuffin | yeah |
19:25:46 | BitPuffin | exactly |
19:25:49 | gXen | sorry I meant C++ |
19:25:49 | BitPuffin | our compiler writes better C :P |
19:26:17 | * | io2 quit () |
19:26:55 | EXetoC | gXen: it can also compile to C++ (4 languages in total) |
19:28:05 | gXen | if I didnt know better.. I'd say the makers wanted fast python :) |
19:28:44 | BitPuffin | actually the syntax has more of a heritage from algol :P |
19:28:56 | gXen | how does memory management work? |
19:29:00 | * | hoppecl quit (Quit: leaving) |
19:29:04 | BitPuffin | gXen: there is an optional GC |
19:29:11 | BitPuffin | otherwise you can use alloc and free etc |
19:29:19 | * | OrionPK quit (Ping timeout: 264 seconds) |
19:29:22 | BitPuffin | there is docs on how tho GC works |
19:29:37 | BitPuffin | http://build.nimrod-lang.org/docs/gc.html |
19:29:41 | EXetoC | BitPuffin: I did create type-safe alloc alternatives before, in case your still interested in that |
19:29:49 | EXetoC | it's in system.nim |
19:29:59 | gXen | is there any big company using it? or a known application made in it? |
19:30:44 | gXen | how about libraries? web frameworks,...? |
19:31:06 | EXetoC | https://github.com/dom96/jester |
19:31:08 | BitPuffin | gXen: we got quite a few libraries |
19:31:11 | BitPuffin | and yeah |
19:31:17 | BitPuffin | jester is the only web framework atm |
19:31:40 | BitPuffin | when I get something done there will officially be a company using it |
19:31:56 | gXen | I am not so much interest in webframeworks, just wondering why this isnt more popular |
19:32:31 | EXetoC | gXen: no known apps yet, but a big part of the infrastructure is written in it (compiler, IDE, test reporter..) |
19:32:33 | BitPuffin | well if you wanna write a larger web framework that would be nice |
19:32:59 | EXetoC | I think at least one company uses it, and that's all I know really |
19:33:14 | gXen | I am more interested in scientific computing, and most of all cryptography |
19:33:24 | BitPuffin | we could use some of that |
19:33:46 | gXen | how about crypto libs? I see md5 is there... any other hashing algos? |
19:35:08 | BitPuffin | gXen: yes |
19:35:25 | BitPuffin | https://bitbucket.org/BitPuffin/scrypt.nim |
19:37:24 | * | DAddYE_ quit (Remote host closed the connection) |
19:39:34 | gXen | is sha1 and the like available? |
19:40:57 | Varriount | gXen: I think so, there's a hashes module |
19:41:14 | BitPuffin | gXen: yes it's available in babel |
19:42:35 | * | DAddYE joined #nimrod |
19:53:26 | gXen | I guess I am sold: "I think someone is currently writing software for a real business that Java couldn't handle (memory and performance constraints)" |
19:53:27 | reactormonk | BitPuffin, IIRC you can't deposit stuff in tuples by position |
19:54:35 | reactormonk | gXen, yup, babel install sha1 |
19:55:44 | BitPuffin | reactormonk: you can, look at the manual |
19:56:10 | reactormonk | BitPuffin, sap |
19:56:22 | reactormonk | BitPuffin, but it expects an identifier there :-/ |
19:59:55 | gXen | is scrypt and bcrypt in nimrod? |
19:59:56 | EXetoC | BitPuffin: I think the first comma is a unicode comma |
20:00:40 | BitPuffin | gXen: I linked you to scrypt |
20:00:43 | BitPuffin | https://bitbucket.org/BitPuffin/scrypt.nim |
20:00:47 | EXetoC | BitPuffin: value 8218 |
20:01:17 | EXetoC | http://www.fileformat.info/info/unicode/char/201a/index.htm |
20:01:20 | EXetoC | :-) |
20:01:29 | * | bbodi joined #nimrod |
20:01:44 | bbodi | Hi all! |
20:01:54 | EXetoC | bbodi: morning |
20:01:58 | EXetoC | or something |
20:02:10 | bbodi | its night here |
20:03:37 | bbodi | let me ask you a question guys: what is your opinion about the_syntax_with_undercores? Nowadays i think about it a log. I am a Java programmer, and hell it, I think this underlined syntax helps much more the initial understanding of the source code than camelCase |
20:04:05 | BitPuffin | EXetoC: what is your point |
20:04:24 | EXetoC | BitPuffin: that it's not the ASCII comma, hence why the compilation fails |
20:04:50 | BitPuffin | so I'm not allowed to use unicode? |
20:04:51 | EXetoC | ‚ != , ... :p |
20:04:52 | BitPuffin | that's bull |
20:05:34 | EXetoC | isn't that a lot of work to support? there are other variations of other ASCII symbols that you have to take care of |
20:06:14 | BitPuffin | I dunno |
20:06:27 | BitPuffin | haven't had any similar issue in any other programming language |
20:06:33 | BitPuffin | and it's not like I'm doing it on purpose |
20:06:35 | BitPuffin | it's probably fucking mac |
20:06:48 | BitPuffin | or is it like |
20:06:53 | BitPuffin | vim setting or what |
20:07:51 | EXetoC | :E |
20:08:13 | * | vbtt joined #nimrod |
20:08:17 | * | Demos joined #nimrod |
20:08:28 | BitPuffin | :/ |
20:08:36 | BitPuffin | and it's been working otherwise |
20:08:41 | BitPuffin | like for proc parameters |
20:08:50 | BitPuffin | it's not like I have been writing procs with only one parameter |
20:08:55 | BitPuffin | so I hardly think that's the problem |
20:09:17 | EXetoC | but that's the only non-ascii comma |
20:09:59 | * | DAddYE quit (Remote host closed the connection) |
20:10:03 | BitPuffin | dafuq |
20:10:08 | EXetoC | in that snippet |
20:10:11 | BitPuffin | what the hell is going on |
20:10:18 | BitPuffin | wait |
20:10:19 | EXetoC | and I guess you managed to insert such a comma in that enum code as well |
20:10:26 | BitPuffin | could it be like if I accidentally do ‚ |
20:10:30 | BitPuffin | with alt comma |
20:10:33 | BitPuffin | check |
20:10:41 | BitPuffin | is left one unicode and right one ascii now |
20:10:45 | BitPuffin | ‚ , |
20:11:01 | BitPuffin | or could it be caps lock |
20:11:03 | EXetoC | BitPuffin: alt gr? |
20:11:03 | BitPuffin | , , |
20:11:09 | BitPuffin | mac doesn't have alt gr :P |
20:11:37 | EXetoC | it's altgr on my system apparently |
20:11:59 | * | Demos quit (Read error: Operation timed out) |
20:12:10 | BitPuffin | wll |
20:12:16 | BitPuffin | was any of the commas I wrote unicode |
20:12:19 | BitPuffin | :P |
20:12:52 | EXetoC | yes, those that triggered the error messages |
20:13:00 | BitPuffin | no but I meant here in irc |
20:13:47 | EXetoC | some of them |
20:13:53 | BitPuffin | the ones to the left? |
20:14:03 | EXetoC | can you see a different with your font? |
20:14:11 | EXetoC | ¸¸¸¸¸¸¸,,,,,,,,¸¸¸¸¸¸,¸,¸¸¸¸,¸¸¸,,, |
20:14:24 | BitPuffin | isn't that periods and commas? :P |
20:14:32 | BitPuffin | ,,,,,,,,,,‚‚‚‚‚‚‚‚‚‚‚‚‚‚,,,,,,,,,,,,‚‚‚‚‚‚‚‚‚‚ |
20:14:35 | BitPuffin | one of them looks a bit thicker |
20:14:42 | BitPuffin | ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, |
20:15:24 | * | Demos joined #nimrod |
20:15:42 | EXetoC | your commas: ‚‚‚‚‚‚‚‚‚‚‚ the commas that I managed to generate: ,,,,,,,¸¸¸¸¸,,,¸¸¸¸,,,,¸¸ |
20:16:04 | EXetoC | I think it should be reported, because that's very subtle in some cases |
20:16:41 | BitPuffin | well the ones you generated looked different sometimes |
20:16:53 | EXetoC | but how exactly should it be handled? consider this: "var åäö = 3; echo åäö" |
20:17:18 | EXetoC | BitPuffin: that's two different commas, none of which looks like yours |
20:17:32 | BitPuffin | hrm |
20:17:37 | BitPuffin | then how did this even appear in my source |
20:17:40 | BitPuffin | I'm confussled |
20:17:56 | BitPuffin | IT IS 2014! |
20:18:02 | BitPuffin | ._____: |
20:18:11 | * | bbodi quit (Remote host closed the connection) |
20:18:14 | EXetoC | apparently you typed it here |
20:18:31 | EXetoC | so why are you asking? |
20:19:39 | EXetoC | unless you just pasted it, but you did mention alt+, |
20:21:09 | EXetoC | BitPuffin: you need to stop doing weird stuff, so that you can focus on important stuff instead :> |
20:21:13 | EXetoC | ok enough spamming. later |
20:28:58 | BitPuffin | EXetoC: well I tried if maybe alt+comma would result in that unicode comma looking thing but it didn't |
20:29:03 | BitPuffin | EXetoC: what do you mean weird stuff xD |
20:46:07 | * | DAddYE joined #nimrod |
20:59:35 | EXetoC | BitPuffin: weird characters, generic types; that kind of stuff |
21:00:49 | * | Matthias247 joined #nimrod |
21:07:28 | BitPuffin | EXetoC: okay I'll just ignore the benefits of nimrod then and just use it as if it was C with a nice syntax :P |
21:07:55 | vbtt | all commas are unicode, btw |
21:07:57 | BitPuffin | or like who needs to redirect in a webapp :P |
21:12:37 | NimBot | Araq/Nimrod devel c3597f4 Zahary Karadjov [+0 ±1 -0]: fix #1018... 4 more lines |
21:12:37 | NimBot | Araq/Nimrod devel b8f44f3 Zahary Karadjov [+0 ±2 -0]: fix the handling of "msg" tests |
21:12:49 | EXetoC | vbtt: ok, not(0x2c) commas |
21:14:14 | EXetoC | BitPuffin: are you going to edit your ticket now that we've established the cause? |
21:14:49 | EXetoC | I'll just submit a reply |
21:16:03 | BitPuffin | EXetoC: try first if it compiles if you fix it |
21:16:08 | BitPuffin | like replace it with a real comma |
21:16:15 | BitPuffin | just forward declare the proc that you don't have |
21:18:04 | EXetoC | no problems there. gonna upgrade the compiler now |
21:18:43 | * | skyfex joined #nimrod |
21:24:38 | NimBot | Araq/Nimrod devel c82a04e Zahary Karadjov [+0 ±1 -0]: fix #1016 |
21:28:49 | * | Endy quit (Ping timeout: 245 seconds) |
21:37:26 | skyfex | Araq: Do you know if the packed pragma might affect the GC? Does it assume that pointers are word-aligned? |
21:44:16 | skyfex | (for the docs) |
21:45:40 | NimBot | Araq/Nimrod devel 875c8d6 Zahary Karadjov [+1 ±1 -0]: fix #1015 |
21:52:04 | * | brson quit (Ping timeout: 252 seconds) |
21:53:54 | * | brson joined #nimrod |
22:03:04 | Araq | skyfex: yes, that is assumed |
22:03:32 | Araq | but I can't see anyone using 'packed' on a type containing refs ... |
22:03:52 | fowl | zahary, ty! |
22:03:58 | Araq | well it's a good point, added it to my todo |
22:04:10 | skyfex | Araq: Yeah, me neither, just figure it's good to get in the docs.. you never know what people will try |
22:04:18 | skyfex | "it'll save memory!" |
22:04:40 | Araq | there are lots of other type properties that prevent GC'ed memory |
22:04:57 | Araq | we can easily make the compiler check packed is not used improperly |
22:06:35 | * | gXen quit (Quit: gXen) |
22:07:26 | Araq | hi vbtt welcome back |
22:09:02 | vbtt | hi Araq, thanks. how are things? |
22:09:59 | Araq | could be worse |
22:10:25 | Demos | Araq, I gotta go, but you should merge my pull request into the opengl wrapper |
22:10:39 | Araq | Demos: ok |
22:11:35 | Araq | ping Varriount |
22:11:43 | fowl | BitPuffin, what means this "my allegro binding" |
22:12:16 | * | Demos quit (Quit: Leaving) |
22:13:16 | skyfex | Araq: Btw, I held a small presentation for some fellow engineers (just 5 people) yesterday. They seemed really interested. |
22:13:39 | skyfex | I also got a little further with my HDL idea |
22:14:26 | skyfex | I think the BitVector type can perhaps be completely defined as I want in devel |
22:15:26 | Araq | should be possible yeah |
22:15:27 | skyfex | And I made a proof of concept of a type which has a "now" value and a "next" value, which is essential for digital circuit simulation |
22:15:39 | skyfex | It was surprisingly easy |
22:16:09 | Araq | not sure if your approach is the right one though :P |
22:17:07 | Araq | you could also think about a #!hdl syntax/grammar |
22:17:19 | * | cark joined #nimrod |
22:17:37 | skyfex | My current approach is to define Bit = range[0..1] and BitArray[I] = array[I, Bit] .. and work from there |
22:18:59 | * | cark2 quit (Ping timeout: 240 seconds) |
22:19:14 | skyfex | I was surprised that I managed to create a literal syntax for hex-values which generated a type of the right width (4 times the number of hex digits).. and the syntax is actually identical to VHDL: X"CAFEBABE" |
22:20:04 | skyfex | But I also think it makes sense to do 0xCAFEBABE[0..31] |
22:20:36 | skyfex | Araq: Good point about #!hdl .. I knew about the feature, but I hadn't thought about using it |
22:20:47 | BitPuffin | fowl: yeah I'm binding allegro |
22:21:10 | fowl | BitPuffin, im almost done with mine bro |
22:21:19 | BitPuffin | waaaAAAAaaat |
22:21:27 | BitPuffin | you're killing me xD |
22:21:32 | fowl | lol >_> |
22:21:41 | BitPuffin | you didn't seem like you wanted to do it |
22:22:02 | BitPuffin | so the whole full thing? |
22:22:04 | fowl | BitPuffin, i should say im done with the interesting stuff, the rest is function headers i have to port, that code of yours in the issue is wrong btw |
22:22:19 | BitPuffin | why? |
22:22:35 | fowl | BitPuffin, you're giving the function nil pointers |
22:22:46 | BitPuffin | yeah I was wondering if I had to allocate or it would do it for me |
22:22:51 | fowl | noo bp |
22:22:57 | BitPuffin | but I guess it wouldn't be able to set the address now that I think about it |
22:23:09 | fowl | all you have to do is alFunc(result[0].addr, result[1].addr, ...) no clean-up neccessary |
22:23:31 | BitPuffin | true |
22:23:36 | fowl | BitPuffin, thats why i import functions like that (that take a pointer to something to be filled up) as var |
22:24:03 | BitPuffin | yeah I was asking earlier if it will work if I make it var |
22:24:15 | BitPuffin | but it didn't seem certain |
22:24:19 | fowl | BitPuffin, also, check it: https://gist.github.com/fowlmouth/9675245 |
22:24:58 | BitPuffin | oh so you are nimrodifying it? |
22:25:11 | BitPuffin | thought you were the close to the metal guy :P |
22:25:37 | fowl | this isnt nimrodifying |
22:25:54 | BitPuffin | anyways, I have done base, altime, bitmap, bitmap_draw, bitmap_io and color :P |
22:26:10 | BitPuffin | well I mean TEvent |
22:26:15 | BitPuffin | instead of TAllegroEvent |
22:26:36 | fowl | howd you do TEvent? i have a feeling variant type will work here btw |
22:27:00 | BitPuffin | haven't done it yet |
22:27:11 | BitPuffin | but someone in #allegro was mentioning it I think |
22:27:20 | BitPuffin | and that it would seem like you'd do a variant type |
22:27:29 | BitPuffin | a Varriount type hurr hurr |
22:27:44 | NimBot | Araq/Nimrod devel ca255fe Zahary Karadjov [+0 ±4 -0]: msg -> errmsg |
22:27:51 | fowl | BitPuffin, tbh it is better to use a union |
22:28:04 | BitPuffin | believe he said variant union |
22:28:11 | BitPuffin | but wtf is a union in nimrod anyway :P |
22:28:34 | Araq | nimrod has .union now as a pragma |
22:28:43 | Araq | which makes wrapping much easier |
22:28:55 | Araq | btw c2nim already knows about it |
22:30:21 | fowl | Araq, else: discard doesnt work in variant type |
22:30:24 | fowl | only else: nil |
22:31:04 | Araq | yeah I know |
22:31:07 | Araq | it's not a bug |
22:31:16 | fowl | ok |
22:31:22 | Araq | I haven't made up my mind about this detail |
22:31:51 | Araq | both are kind of ugly in this context |
22:31:56 | BitPuffin | fowl: are you gonna do all of it? |
22:32:00 | fowl | i also have a problem where {.push importc: "al_$1".} sometimes doesnt work |
22:34:12 | fowl | BitPuffin, i dont want to repeat the parts you've done |
22:34:30 | BitPuffin | well you can have it if you want |
22:34:31 | fowl | you should add your stuff to mine |
22:34:36 | fowl | ok |
22:34:39 | BitPuffin | but we wrap things differently |
22:34:43 | BitPuffin | so I'm not sure how useful it is |
22:34:57 | fowl | different how |
22:35:12 | BitPuffin | well like I change the style of names |
22:35:17 | BitPuffin | so to alDrawBitmap |
22:35:20 | BitPuffin | instead of al_draw_bitmap |
22:35:22 | fowl | thats a PITA though |
22:35:26 | BitPuffin | yeah |
22:35:31 | fowl | with draw_bitmap i can do importc:"al_$1" |
22:35:32 | BitPuffin | that's why I haven't done more xD |
22:35:52 | BitPuffin | sure |
22:35:54 | BitPuffin | but yeah |
22:35:58 | BitPuffin | did you use c2nim? |
22:36:01 | BitPuffin | I didn't |
22:36:03 | fowl | no |
22:36:05 | BitPuffin | I could have though |
22:36:08 | fowl | all the functions are wrapped in AL_FUNC() |
22:36:13 | BitPuffin | just run the headers through the pre processor first |
22:36:33 | BitPuffin | ez |
22:36:34 | fowl | c2nim has a preprocessor |
22:36:38 | BitPuffin | but I didn't wanna do that |
22:36:54 | BitPuffin | because I thought I would do it better by hand |
22:36:57 | fowl | dunno if #def AL_FUNC(a,b,c) a b c would work |
22:37:01 | BitPuffin | with c2nim there is always fun stuff that happens |
22:37:24 | BitPuffin | well I mean run it through gcc or clang but only do pre processor steps |
22:37:31 | BitPuffin | then you'd get the C style names |
22:37:46 | * | jbe_ quit (Quit: Leaving) |
22:38:14 | fowl | i may have judged allegros api harshly |
22:41:13 | * | nolan_d left #nimrod (#nimrod) |
22:42:32 | BitPuffin | yes |
22:42:37 | BitPuffin | they do it for a good reason |
22:42:53 | BitPuffin | fowl: by the way do you know how the al_run_main stuff works? |
22:43:01 | fowl | no |
22:43:11 | Araq | isn't allegro dead for years now? |
22:43:25 | BitPuffin | it basically helps with getting it working on osx without having to change code |
22:43:32 | BitPuffin | Araq: not at all, what are you on? crack? |
22:43:45 | Araq | beer |
22:44:04 | BitPuffin | fowl: in C/C++ the main name is mangled automatically by the preprocessor but in other languages you have to use al_run_main |
22:44:39 | BitPuffin | so what you could do to make it nice is to wrap it so that you can just do alMain: and then your code in there and take the body of that and put it in a proc that is passed to al_run_main |
22:44:41 | BitPuffin | got it? |
22:44:59 | fowl | no |
22:45:04 | fowl | where is this function even defined |
22:48:45 | fowl | BitPuffin, someone who uses os x will have to figure out how to deal with that |
22:49:06 | BitPuffin | hmmm |
22:49:09 | BitPuffin | don't know anybody |
22:49:10 | fowl | BitPuffin, SDL does the same thing, someone got around it by setting an environment variable |
22:49:15 | BitPuffin | but you are supposed to use it everywhere |
22:49:20 | BitPuffin | because it makes it so no cade change is required :P |
22:49:28 | BitPuffin | fowl: I think it's defined in base iirc |
22:49:41 | fowl | the function doesnt return |
22:50:03 | BitPuffin | lol |
22:50:06 | BitPuffin | yes it does |
22:50:10 | fowl | its not as simple as wrapping main code in alMain:, main code may define global variables that are suddenly not global anymore |
22:50:11 | BitPuffin | when your function returns :P |
22:50:43 | BitPuffin | are you also on beer? |
22:50:49 | * | zahary quit (Ping timeout: 240 seconds) |
22:50:56 | fowl | im quoting someone on the forums |
22:51:07 | fowl | Yes, al_run_main. It will never return, but you pass it a C function which we be called from another thread. Call al_init and so on from that other function then as if it was your main() function. |
22:51:26 | fowl | BitPuffin, this is the domain of someone who can actually test it (an OS X developer) |
22:51:29 | fowl | not me |
22:52:17 | BitPuffin | I am on osx |
22:52:19 | BitPuffin | but the point is |
22:52:22 | BitPuffin | you should use it not only on osx |
22:52:25 | BitPuffin | everywhere |
22:52:34 | BitPuffin | so that the code will still work on other platforms |
22:52:38 | fowl | ok the job is yours |
22:52:42 | fowl | make it work |
22:52:52 | BitPuffin | sure |
22:52:56 | BitPuffin | when you publish your wrapper |
22:52:58 | BitPuffin | and please god |
22:53:03 | BitPuffin | don't tell me it is in fawltek |
22:53:11 | fowl | ur in fowltek |
22:53:17 | BitPuffin | ur mom's in fowltek |
22:53:21 | fowl | import fowltek/bitbuffin |
22:53:30 | BitPuffin | import fowltek/fowlsmom |
22:53:53 | * | brson quit (Ping timeout: 246 seconds) |
22:55:55 | * | brson joined #nimrod |
22:56:11 | fowl | BitPuffin, i just wanted my name to appear in the code of others :( |
23:02:26 | BitPuffin | lol |
23:02:48 | BitPuffin | fowl: anyways, if the al_run_main stuff works as it should on one platform, chances are it will work on others too |
23:02:49 | BitPuffin | but yes |
23:02:52 | BitPuffin | I'll test it |
23:02:57 | BitPuffin | obviously |
23:02:59 | BitPuffin | since you know |
23:03:03 | BitPuffin | I plan to use allegro :P |
23:04:18 | * | skyfex quit (Quit: Computer has gone to sleep.) |
23:04:26 | fowl | BitPuffin, it should run now |
23:05:38 | * | skyfex joined #nimrod |
23:06:05 | * | Demos joined #nimrod |
23:07:55 | BitPuffin | you're done? :P |
23:10:33 | BitPuffin | keep in mind that it IS useful to wrap errthin. Even if some of it are stdlib things |
23:10:45 | BitPuffin | because it makes it work on platforms where the stdlib hasn't been ported |
23:10:51 | BitPuffin | such as mobile |
23:10:59 | fowl | no im not done but i have a window openning and closing, do the run_main thing |
23:12:34 | BitPuffin | ah awesome |
23:12:36 | BitPuffin | good work |
23:12:42 | BitPuffin | are you gonna wrap it in a template |
23:12:56 | BitPuffin | so that you don't have to do like in your code like var main = procah,ur,huras, uauhsacr |
23:12:59 | BitPuffin | or whatever you'd do |
23:13:01 | BitPuffin | :P |
23:13:11 | * | psquid joined #nimrod |
23:14:10 | fowl | no |
23:14:25 | fowl | BitPuffin, i think you should just look at al_run_main and copy the osx portion out of it |
23:16:40 | Araq | Demos: the GLHandle change might break code |
23:17:02 | Araq | not sure about the "framework" full path stuff |
23:17:56 | * | xenagi joined #nimrod |
23:22:03 | BitPuffin | fowl: that would be retarded |
23:22:16 | * | OrionPK joined #nimrod |
23:22:46 | fowl | BitPuffin, this whole situation is retarded |
23:22:55 | BitPuffin | the whole point is that you shouldn't have to change your code |
23:23:00 | BitPuffin | whether you made it in windows, osx or linux |
23:23:08 | fowl | ikr |
23:23:09 | BitPuffin | it should really just be something like |
23:23:17 | fowl | why cant i just call install_system on os x? retarded os x |
23:23:37 | BitPuffin | template alMain(e: expr) = |
23:24:10 | BitPuffin | var main = proc(argc: cint, argv: openarray[cstring]) = expr |
23:24:18 | BitPuffin | al_run_main(main) |
23:24:23 | BitPuffin | or something along those lines |
23:24:27 | BitPuffin | simple ass hat :D |
23:24:31 | fowl | nimrod has its own main |
23:24:36 | BitPuffin | yes |
23:24:41 | BitPuffin | and that's what this thing solves |
23:24:54 | fowl | well then do it |
23:25:00 | BitPuffin | it deals with languages who likes to steal main |
23:25:10 | BitPuffin | which some operating systems don't like |
23:25:13 | fowl | no, it deals with broken OS |
23:25:28 | BitPuffin | well yeah osx sucks but it can't be the only one that does this |
23:25:34 | BitPuffin | same thing probably happens on some mobile os too |
23:25:48 | BitPuffin | which is why you shouldn't "just copy the osx part" |
23:26:02 | BitPuffin | doing this makes it more maintainable for any forseeable os :P |
23:26:08 | fowl | BitPuffin, well then figure out how to make it automatic and invisible to the user |
23:26:13 | BitPuffin | but yeah I can implement it when you have done the binding |
23:26:32 | BitPuffin | fowl: the easiest is to just have them put everything inside alMain |
23:26:36 | BitPuffin | so they do alMain: |
23:26:38 | BitPuffin | indent their code |
23:26:39 | fowl | BitPuffin, im having trouble finding anything that uses this function |
23:26:40 | BitPuffin | and go |
23:26:42 | BitPuffin | ez |
23:26:47 | fowl | then do it |
23:26:54 | fowl | if its so ez stop talking to me |
23:27:08 | fowl | i looked at allegro5 binding for rust, D |
23:27:09 | BitPuffin | L39 |
23:27:14 | BitPuffin | https://github.com/SiegeLord/DAllegro5/blob/master/example.d#L39 |
23:27:28 | BitPuffin | they did almost the samet hing there |
23:27:38 | fowl | yea i couldnt find where al_run_allegro was defined |
23:27:40 | BitPuffin | just that they made it so that you pass a function |
23:27:43 | BitPuffin | in base |
23:27:46 | BitPuffin | I even told you |
23:27:48 | BitPuffin | you drunk :P |
23:28:05 | fowl | great |
23:28:27 | fowl | im wasting time talking about this since you already said you would figure it out |
23:28:35 | fowl | bbl, smoking w33d |
23:28:41 | BitPuffin | https://github.com/SiegeLord/DAllegro5/blob/936a94c4a593a1594c70b53029f4efbeec252837/allegro5/system.d#L27 |
23:28:49 | BitPuffin | that's how he implemented the run_allegro thing |
23:28:51 | BitPuffin | lol |
23:28:53 | BitPuffin | drugface :D |
23:29:01 | fowl | yes |
23:29:04 | BitPuffin | but yeah |
23:29:04 | fowl | fun with threads |
23:29:07 | fowl | good luck with that |
23:29:15 | BitPuffin | if you bind the library |
23:29:17 | BitPuffin | all of it |
23:29:20 | BitPuffin | I'll deal with this part |
23:29:22 | BitPuffin | ez |
23:29:24 | BitPuffin | EZ!!! |
23:29:28 | fowl | upload what you have so far |
23:29:32 | BitPuffin | why |
23:29:37 | BitPuffin | we bind things differently anyway |
23:29:45 | BitPuffin | I didn't get far because I did everything so manually |
23:30:04 | fowl | because changing a bunch of stuff from alFooBar to foo_bar will be easier than from AL_FUNC(void, alFooBar, (..))) |
23:30:28 | BitPuffin | ok |
23:30:30 | BitPuffin | it's up |
23:30:49 | BitPuffin | https://bitbucket.org/BitPuffin/nim-allegro5 |
23:31:18 | * | eigenlicht quit (Ping timeout: 264 seconds) |
23:31:20 | fowl | cool thx |
23:31:57 | BitPuffin | probably plenty of mistakes haha |
23:32:07 | BitPuffin | just because sometimes you type what you are reading etc |
23:32:09 | BitPuffin | brains |
23:32:12 | BitPuffin | who need em amirite |
23:33:50 | fowl | this is good, they're in separate files that will help a lot |
23:34:05 | fowl | c&p |
23:37:27 | BitPuffin | you aren't doing it in separate files? -_____- |
23:37:42 | BitPuffin | you do realize that some stuff is addons etc? |
23:37:49 | BitPuffin | it shouldn't be in the same file :P |
23:37:56 | BitPuffin | it was split up in the headers for a reason |
23:37:59 | EXetoC | you're an addon |
23:38:01 | BitPuffin | you might only use one part of the lib |
23:38:03 | BitPuffin | OH NO HE DIDN*T |
23:38:42 | Varriount | MEEEP |
23:39:00 | BitPuffin | I guess we have the DCE, but still, increased compile time :P |
23:41:16 | fowl | BitPuffin, no |
23:41:31 | fowl | its not nice to have all these module names |
23:41:32 | BitPuffin | fowl: yes |
23:41:47 | BitPuffin | well what about the addons? |
23:42:09 | fowl | thats different |
23:44:22 | Varriount | Whats DCE? |
23:44:55 | Varriount | Also, is anyone on VNUG? I want to know if I should switch from my desktop to my laptop. |
23:45:42 | BitPuffin | I'm on but I'll probably not talk, playing metroid |
23:47:45 | * | askatasuna joined #nimrod |
23:49:31 | * | darkf joined #nimrod |
23:59:28 | * | q66 quit (Quit: Leaving) |