<< 07-09-2026 >>
00:07:06*Mister_Magister quit (Quit: bye)
00:08:58*Mister_Magister joined #nim
01:39:50*SchweinDeBurg joined #nim
01:47:50*Balls joined #nim
01:48:16BallsHey there, why still no working debug tooling ?
01:54:59*jkl__ joined #nim
01:55:21*def-- joined #nim
01:55:45*jkl quit (Ping timeout: 242 seconds)
01:55:45*def- quit (Ping timeout: 242 seconds)
01:55:45*def-- is now known as def-
02:03:01FromDiscord<_timurski> ?
02:03:21FromDiscord<_timurski> Nim compiles to C. just compile with debug symbols on and everything works great
02:04:08FromDiscord<_timurski> i personally don't really find myself needing more than that, it's pretty easy to follow
02:08:17*jkl joined #nim
02:11:47*jkl__ quit (*.net *.split)
02:11:48*tokyovigilante quit (*.net *.split)
02:11:48*noeontheend quit (*.net *.split)
02:11:48*redj quit (*.net *.split)
02:11:48*Jhonny2x4 quit (*.net *.split)
02:13:14*Balls quit (Quit: Client closed)
02:27:10*noeontheend joined #nim
02:27:14*Jhonny2x4 joined #nim
02:27:15*tokyovigilante joined #nim
02:27:19*redj joined #nim
04:04:22*KawaiiSelbst quit (Remote host closed the connection)
04:05:09*KawaiiSelbst joined #nim
04:13:11FromDiscord<joetroll> sent a long message, see https://paste.rs/zhgQs
04:48:11FromDiscord<_timurski> In reply to @joetroll "not sure where to": you should be able to pretty easily have zero overhead currying with macros
04:49:15FromDiscord<_timurski> also your `add` doesn't need to be a closure
04:49:25FromDiscord<_timurski> (edit) "closure" => "closure, can be just a nimcall"
04:50:44FromDiscord<joetroll> In reply to @_timurski "you should be able": how so? right now it needs to create closures for each step, and i guess i could try some template stuff but i'm not sure if it's worth it in the end↵overhead is around 1.75x slower anyways on real world usage, the problem is more so immediate currying that's SUPER slow
04:55:18FromDiscord<_timurski> sent a code paste, see https://paste.rs/NcHma
04:55:25FromDiscord<_timurski> In reply to @joetroll "how so? right now": you should not be using `{.closure.}` btw
04:55:37FromDiscord<_timurski> `{.closure.}` implies it captures an environment variable
04:55:42FromDiscord<_timurski> which your `add` doesn't need to
04:55:48FromDiscord<_timurski> In reply to @_timurski "`{.closure.}` implies it captures": this adds some overhead
04:56:47FromDiscord<_timurski> that probably accounts for your performance loss
04:58:19FromDiscord<joetroll> sent a code paste, see https://paste.rs/9WEat
04:58:27FromDiscord<joetroll> (edit) "https://paste.rs/klx0i" => "https://paste.rs/hFXcD"
04:58:34FromDiscord<_timurski> sent a code paste, see https://paste.rs/wkEQC
04:59:39FromDiscord<_timurski> it's just too fun designing ncie interfaces
04:59:43FromDiscord<_timurski> (edit) "ncie" => "nice"
05:01:36FromDiscord<_timurski> it's kinda funny, i've been inspired to start learning graph theory because of this orchestration project ive been working on just because so much of it is graph-related
05:02:11FromDiscord<_timurski> and i think there might even be some research potential in graph-generators, so if i learn enough maybe ill talk to a professor about it
05:06:46FromDiscord<joetroll> In reply to @_timurski "when i was like": this is very cool! so `lift` takes just an ordinary function and adapts it to operate inside whatever computational structure `so[...]` is using?
05:06:54FromDiscord<DetermiedNim1> In reply to @joetroll "not sure where to": do you have this on github/codeberg/smth đź‘€
05:07:08FromDiscord<joetroll> In reply to @determiedmech1 "do you have this": not yet, will post soon probably though!
05:07:20FromDiscord<DetermiedNim1> 🔥
05:11:08FromDiscord<joetroll> In reply to @_timurski "which your `add` doesn't": also hm i checked, the pragma doesnt seem to affect much. a + b captures nothing so no environment is allocated↵it DOES fail, however, on something like `typeof(add1) is typeof(add2)` (when add2 is a nimcall), prob because the pragma pins the type to the closure
05:13:31FromDiscord<_timurski> sent a code paste, see https://paste.rs/f0fER
05:15:27FromDiscord<_timurski> so if you have a tuple `(A, B, A)` and `f : A -> C`, then `lift[(here, _, here](f)` would be of type `(A, B, A) -> (C, B, C)` where `f` is applied independently to the first and third slots of the incoming tuple
05:15:55FromDiscord<_timurski> In reply to @_timurski "when i was like": so here it's used to apply `fix` to `(code, audit.issues)` but not the other field
05:17:13FromDiscord<_timurski> you could also write like `decompose >>> lift[seq[here]](solve) >>> synthesize` and it would apply `solve` to each element of the `seq` outputted by `decompose`
06:35:30*Skippy8 joined #nim
06:53:19*Skippy8 quit (Ping timeout: 247 seconds)