<< 26-01-2018 >>
00:02:47Guest20619Are the imports private? For example, if I import module sets in a.nim, if I import a into b.nim, will b.nim be able to access module sets?
00:06:19*dddddd quit (Remote host closed the connection)
00:27:44*xkapastel quit (Quit: Connection closed for inactivity)
00:33:39*devdri quit ()
00:34:49FromGitter<barcharcraz> No. Imports are not transitive
00:35:05FromGitter<barcharcraz> B won’t have access to sets
00:39:02*dunny joined #nim
00:39:17*dunny left #nim ("WeeChat 2.0.1")
00:50:53*MJCaley joined #nim
01:11:30*radagast joined #nim
01:12:21*Guest20619 quit (Ping timeout: 264 seconds)
01:25:19FromGitter<Sud0nim> However, you can make it available to b by having "export sets" in a I believe
01:28:43*tinAndi joined #nim
01:31:09*MJCaley quit (Quit: MJCaley)
01:34:35*tinAndi quit (Ping timeout: 268 seconds)
01:45:05*MJCaley joined #nim
01:47:51*MJCaley_ joined #nim
01:49:40*MJCaley quit (Ping timeout: 240 seconds)
01:49:40*MJCaley_ is now known as MJCaley
01:51:51*saml_ joined #nim
02:18:25*saml_ quit (Remote host closed the connection)
02:18:35*chemist69 quit (Disconnected by services)
02:18:40*chemist69_ joined #nim
02:32:38radagastI have to parse complex arithmatic expressions. So it includes stuff like sin(, log(10)(, sqrt(, ..eN etc in a string. If I have to split these nodes, should I use regular expressions? I am looking at the nre module.
02:33:21FromGitter<Quelklef> !!!
02:33:40FromGitter<Quelklef> @radagast if you don't mind a self-plug, I'm currently developing something that could help you with this
02:34:09radagastI'm more than happy to look for options!
02:34:20FromGitter<Quelklef> if you want to use it that'd be awesome so I have an actual user supplying feedback. It's in very early stages so I understand if you choose something else
02:34:25FromGitter<Quelklef> here you go: https://github.com/quelklef/lilt
02:34:38FromGitter<Quelklef> Feel free to PM me if you have any questions :)
02:36:47*vlad1777d quit (Ping timeout: 248 seconds)
02:49:55*vivus quit (Quit: Leaving)
02:56:51radagastThat looks like a bit too broad for my use case. Or I am missing something. A short example of how this library help me get @[3, +, sin, ( 45, +, 45, ), ^, log, (, 10, ), 100] from "3 + sin(45 + 45)^log(10)100" would be nice :)
02:58:00FromGitter<Quelklef> ah, wait, you're looking for a tokenizer rather than a parser it looks like
02:58:10FromGitter<Quelklef> although this can also do that, so gimme a sec
03:05:58FromGitter<Quelklef> untested, but something like this should work:
03:06:00FromGitter<Quelklef> https://gist.github.com/Quelklef/222928b1683b91be6b28ff88a9408a59
03:07:09FromGitter<Quelklef> what's your use case exactly?
03:11:57*gokr quit (Ping timeout: 240 seconds)
03:12:10FromGitter<zacharycarter> dom96: I'll fix the playground tomorrow, I still need to move it to the server, sorry I haven't been around lately, I intend to return soon
03:12:45FromGitter<zacharycarter> @mratsim I want to do some ML for a hackathon at work
03:13:17FromGitter<zacharycarter> if I explained to you at a high level what I want to do, could you tell me if I could leverage arraymancer to do it?
03:13:31FromGitter<zacharycarter> or at least include it in my solution
03:18:03radagastQuelklef, I was making a calculator app
03:22:45FromGitter<Quelklef> @radagast ah. I think it does fit your use-case then, just parsing rather than tokenizing : P
03:25:35*tinAndi joined #nim
03:27:00radagastAh thanks. I'll definately look into it :)
03:31:16FromGitter<Quelklef> Thanks! Any feedback is appreciated
03:33:16*tinAndi quit (Ping timeout: 252 seconds)
03:40:54*radagast quit (Quit: radagast)
03:53:14*marenz_ joined #nim
03:54:10*Snircle quit (Quit: Textual IRC Client: www.textualapp.com)
03:56:22*marenz__ quit (Ping timeout: 252 seconds)
04:05:09*leorize joined #nim
04:11:35*marenz_ quit (Ping timeout: 256 seconds)
04:24:57*MJCaley quit (Quit: MJCaley)
04:46:21*c0ntribut0r joined #nim
04:48:18*c0ntribut0r quit (Read error: Connection reset by peer)
04:49:06*c0ntribut0r joined #nim
04:58:18*c0ntribut0r quit (Ping timeout: 240 seconds)
05:01:53*leorize quit (Quit: WeeChat 2.0.1)
05:02:10*c0ntribut0r joined #nim
05:06:52*c0ntribut0r quit (Ping timeout: 256 seconds)
05:07:26*c0ntribut0r joined #nim
05:19:18*c0ntribut0r quit (Ping timeout: 240 seconds)
05:20:17*c0ntribut0r joined #nim
05:42:23*c0ntribut0r quit (Ping timeout: 248 seconds)
05:42:35*c0ntribut0r joined #nim
06:09:47*leorize joined #nim
06:16:01*nsf joined #nim
06:34:10*c0ntribut0r quit (Ping timeout: 240 seconds)
06:35:13*c0ntribut0r joined #nim
06:44:10*c0ntribut0r quit (Ping timeout: 240 seconds)
06:44:54*c0ntribut0r joined #nim
06:58:41*solitudesf joined #nim
06:59:10*federico3 quit (Remote host closed the connection)
07:00:19*federico3 joined #nim
07:04:28*codenoid joined #nim
07:09:48*c0ntribut0r quit (Read error: Connection reset by peer)
07:10:57*c0ntribut0r joined #nim
07:11:11FromGitter<survivorm> @Quelklef what parser algorithm do you implement?
07:11:43FromGitter<survivorm> LR,LL, recursive descent, something else?
07:12:12FromGitter<Quelklef> No clue. I'm not a man of theory
07:12:28FromGitter<Quelklef> It is recursion-based, so I'm guessing the latter
07:12:38FromGitter<survivorm> Ah
07:13:05FromGitter<survivorm> that's the broadest, but also the most consuming one
07:13:36FromGitter<survivorm> though i'm not sure of ambiguosities handling
07:13:43FromGitter<Quelklef> Sounds about right. I'm mostly concerned with flexibility and less so with efficiency, so works for me
07:13:49FromGitter<Quelklef> oh uh
07:13:53FromGitter<Quelklef> there's an issue about that
07:14:16FromGitter<Quelklef> currently the only ambiguity is in choices (`|`s), and it's fixed by just returning the first matching rule
07:14:51FromGitter<survivorm> Also, i'm currently writing an observation article on parsing. You may benefit of it when it's finished and i'll translate it in english
07:15:17FromGitter<survivorm> but for now i recommend you reading about Brent-naur form
07:15:22FromGitter<Quelklef> Sure! Sounds iteresting
07:15:35FromGitter<Quelklef> and I'll look that up rn
07:15:43FromGitter<survivorm> It's wery similar to your rule definition language
07:15:55FromGitter<survivorm> but it's STANDARD
07:16:08FromGitter<Quelklef> hmmm
07:16:38FromGitter<survivorm> so, if you're at least a little concerned about compatibility - you'd better implement it
07:16:51FromGitter<Quelklef> I really dislike it, but I get your point
07:16:59FromGitter<Quelklef> I can add it as an alternative syntax
07:17:19FromGitter<Quelklef> activated by something at the top of the file
07:17:28FromGitter<survivorm> it will give you at least a benefit of reusing the most common languages bnf (json, postgresql, yaml, etc)
07:17:56FromGitter<survivorm> And no need to re-writing it at every time
07:18:41FromGitter<Quelklef> Right. It's a good call
07:18:49FromGitter<Quelklef> Gives me something to work on, too =]
07:18:57FromGitter<survivorm> Good luck on your task, anyways
07:19:40FromGitter<survivorm> It's a great idea, as nim doesn't have any decent parser implementations so far, AFAIK
07:20:23FromGitter<Quelklef> Not general, anyway
07:20:32FromGitter<Quelklef> I know there's the json module but that's json only obviously
07:23:15avsejis upcoming.asyncdispatch going to replace pure.asyncdispatch at some point?
07:25:06FromGitter<survivorm> Yeah, my mistake. No decent parser factory, that is
07:31:35FromGitter<Quelklef> until now! (i hope)
07:51:52*PMunch joined #nim
07:53:48*vlad1777d joined #nim
07:59:51*gokr joined #nim
08:00:30*Ven`` joined #nim
08:05:52FromGitter<dom96> Avsej: already has
08:12:42avsejdom96, so why it still has pure.asyncdispatch in devel branch?
08:12:51*avsej left #nim (#nim)
08:12:55*avsej joined #nim
08:15:05*Ven`` quit (Read error: Connection reset by peer)
08:20:16*Ven`` joined #nim
08:30:55*Arrrr joined #nim
08:38:59*floppydh joined #nim
08:52:40*devdri joined #nim
08:54:48*devdri quit (Client Quit)
09:02:34*yglukhov joined #nim
09:04:00*gmpreussner quit (Ping timeout: 252 seconds)
09:04:42*gmpreussner joined #nim
09:21:13*Trustable joined #nim
09:38:34dom96avsej: upcoming asyncdispatch was merged into `asyncdispatch`
09:40:19avsejhaving two files confuses: https://github.com/nim-lang/Nim/blob/devel/lib/upcoming/asyncdispatch.nim https://github.com/nim-lang/Nim/blob/devel/lib/pure/asyncdispatch.nim
09:40:27avsejare they both necessary?
09:40:41dom96no, I just forgot to remove the former
09:41:40avsej"There Can Be Only One"
09:46:49*leorize quit (Quit: WeeChat 2.0.1)
09:52:53*Vladar joined #nim
09:55:56codenoidyeah
10:02:13*j_rod_s quit (Quit: j_rod_s)
10:02:27*j_rod_s joined #nim
10:06:44*j_rod_s quit (Client Quit)
10:06:57*j_rod_s joined #nim
10:11:10*prOne joined #nim
10:11:10*prOne quit (Client Quit)
10:11:47*prOne joined #nim
10:17:06*prOne quit (Quit: WeeChat 2.0.1)
10:17:23*prOne joined #nim
10:18:57*sendell joined #nim
10:19:47*prOne quit (Client Quit)
10:23:19*codenoid quit (Ping timeout: 256 seconds)
10:27:12*codenoid joined #nim
10:31:20*radagast joined #nim
10:33:37PMunchshashlick, did you upload your editor to GitHub?
10:42:48*codenoid quit (Ping timeout: 240 seconds)
10:45:35*alexday joined #nim
10:47:01floppydhare pegs still encouraged?
10:47:45*codenoid joined #nim
10:48:07FromGitter<mratsim> @zacharycarter yes feel free. The main issue in Arraymancer is reading/outputting data though but I can give you pointers in Python anyway
10:49:11PMunchfloppydh, I guess so. But they don't work on compile-time
10:50:03floppydhPMunch: so the benefit compared to regexes is ... easier to understand?
10:50:10floppydh... once you grok them?
11:00:06*abeaumont quit (Remote host closed the connection)
11:01:37*abeaumont joined #nim
11:03:18PMunchWell they are a bit easier to understand
11:03:29PMunchAnd more flexible
11:03:59PMunchYou can for example create a group and say "if this group, then something else, then the group again" and not have to repeat everything
11:04:24PMunchhttps://nim-lang.org/docs/pegs.html#peg-syntax-and-semantics-examples < Third example
11:10:16*dddddd joined #nim
11:13:35*alexday quit (Remote host closed the connection)
11:14:15PMunchI think survivorm is working on making PEGs better though
11:14:30PMunchAnd I'm working on a parser combinator library
11:18:30*tinAndi joined #nim
11:19:17dom96the advantage of PEGs is that they are implemented natively in Nim
11:19:25dom96nitely is working on a native regex implementation though
11:19:29dom96so we should have that soon
11:20:27PMunchOooh, interesting
11:21:19dom96So I'm doing a module on VDM-SL at Uni. Tempted to implement this for Nim but I wonder how useful it actually is, anyone use it? https://en.wikipedia.org/wiki/Vienna_Development_Method
11:23:13PMunchHmm, interesting
11:24:16*tinAndi quit (Ping timeout: 256 seconds)
11:24:45FromGitter<data-man> Anyway scanf faster. :)
11:25:02*Ven`` quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
11:25:48PMunchdom96, I've never heard of VDM-SL before. Might be useful though, but I don't see myself using it for hobby projects :P
11:32:04dom96of course, but what programmer doesn't eventually need to code the software on an airplane? :)
11:32:50PMunchGood point :P I'm currently working with satellites but same-same
11:33:12PMunchI work on the "boring" part though. the ground segment
11:33:23PMunchSo not like the satellite would crash and burn if I mess up :P
11:34:02PMunchBut it could give Nim another possibility to grab a niche, which is always good.
11:42:10*codenoid quit (Ping timeout: 260 seconds)
11:56:22FromGitter<Bennyelg> Hey, what is the easiest way to implement lazy evaluation on nim?
11:56:22*leorize joined #nim
11:56:44FromGitter<Bennyelg> create().change().apply() which will only create and change when I will write apply
11:57:29dom96probably in a similar way you would implement it in Python: research how others do it in Python
11:58:02FromGitter<Bennyelg> Ill check for it now
12:02:07*Snircle joined #nim
12:02:25PMunchWell, you could return procedures instead of a result
12:02:43PMunchAnd apply could run the procedure (which would run the other procedures)
12:03:08FromGitter<Bennyelg> This is what im thinking.
12:03:40PMunchOf course you could include some wrapper structure as well
12:04:02PMunchFor example something that holds a proc and a sequence which would be the result of a map call
12:04:08FromGitter<Bennyelg> yea DataFrame is an example but I am really need something very seily
12:04:25PMunchSo if you wanted the third element of a sequence that was mapped you would apply the proc to that element
12:04:44PMunchBut you might also want a cache of values in case the procedure is heavy
12:05:11PMunchSo maybe a bitmask the size of the seq to indicate if the value in that position is the real value or the cached result
12:05:51PMunchThis would of course mean that each of the entries in the seq would need to be a Cache object with one of two different types internally so the sequence could be all the same type
12:06:02PMunchIn case you wanted to map say $ to a sequence of ints
12:06:37PMunchHmm, but then the bitmask isn't much use
12:07:16PMunchYou could of course use linked lists instead
12:07:35PMunchBut that would be a performance hit
12:07:51*vlad1777d quit (Ping timeout: 246 seconds)
12:08:18PMunchOr you could of course use a persistent vector: https://peterme.net/scraps/clojures-persistent-vectors-in-nim.html
12:08:31FromGitter<Bennyelg> Thanks I'll read about them
12:12:28FromGitter<data-man> @Bennyelg: See NimData package
12:20:59*Ven`` joined #nim
12:21:46dom96pins are here: https://imgur.com/a/qKyJ7 :D
12:23:52cremwow they are huge. Are they 10x10cm?
12:24:02dom96lol, they're tiny
12:24:27FromGitter<Bennyelg> @dom96 nice
12:25:29dom962.5cm x 2.5cm IIRC
12:28:11Arrrrcool pins
12:28:25dom96yeah, they actually came out better than I thought they would
12:28:34PMunchBennyelg, you might also be interested in this: https://github.com/alehander42/zero-functional
12:28:45PMunchOoh, square ones
12:32:23dom96yeah :D
12:32:32dom96got 60, gonna sell them at €0.5
12:34:06dom96getting change might be tough though
12:35:38PMunchDon't you have change machines at banks?
12:35:58PMunchHere you can go in and get change in those neat paper rolls
12:36:09dom96yeah, but I live in the UK :)
12:36:33dom96maybe others will be able to do that
12:37:07PMunchOh right, would be a bad idea to show up with a bunch of change in Pounds :P
12:37:29PMunchWell you could probably find a bank in Brussels
12:50:06dom96wouldn't be surprised if some people want to pay with different currencies though :)
12:50:16dom96I'll happily accept it as long as they don't mind no change
12:53:17*Ven`` quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
12:57:01PMunchI'll bring some Norwegian kroners and hold you to that :P
12:58:48*gokr left #nim (#nim)
13:07:43*marenz_ joined #nim
13:11:57*dddddd quit (Ping timeout: 240 seconds)
13:13:53*dddddd joined #nim
13:15:31*Ven`` joined #nim
13:16:42*Ven` joined #nim
13:19:42*Yardanico joined #nim
13:19:59*Ven`` quit (Ping timeout: 248 seconds)
13:22:13*j_rod_s quit (Quit: j_rod_s)
13:22:29*j_rod_s joined #nim
13:23:28FromGitter<survivorm> @PMunch finally, I've translated a "stable" block of the article :) ⏎ Anyone's welcome to read and participate in cleanup ⏎ And, of cause, in commenting the article itself ⏎ English: https://docs.google.com/document/d/109ITPXUi1ywUHkEb7K_FMv6sMjBAXZgcrE2CuFPnWGA/edit?usp=sharing ⏎ Russian(the original, a little more text, not all stable): https://docs.google.com/document
13:23:28FromGitter... /d/1o20XXXBzR4_R81ihENVyAfACF7Vp599Kb90hR3JdewI/edit?usp=sharing [https://gitter.im/nim-lang/Nim?at=5a6b2bd00ad3e04b1b6fa638]
13:26:44*j_rod_s quit (Client Quit)
13:26:57*j_rod_s joined #nim
13:29:44FromGitter<alehander42> @survivorm is bekus naur really standard tho? I've seen many different "dialects" of it in different libraries
13:29:58FromGitter<data-man> @survivorm: For habrahabr? :)
13:30:16FromGitter<survivorm> @data-man Yeah
13:30:17FromGitter<alehander42> also I don't like that it only specifies when something is valid, but it doesn't give you tools to specify the shape of the resulting tree
13:30:59FromGitter<survivorm> @alehander42 Later in article i talk about variants too
13:31:17FromGitter<survivorm> in fact, all tools have different dialects
13:32:06FromGitter<survivorm> some support regexp, some not, some use :, some =, some ;, some ., and the list goes indefinetly
13:32:13FromGitter<alehander42> I have a similar lang-agnostic parser generator based on a bit different grammar syntax laying somewhere, I have to finish a version of it one day in nim (the generated parsers themselves are pretty naive, but the dsl seems useful to me)
13:32:50FromGitter<alehander42> exactly, that's why it seems hard to me to "support" it in a library, everybody has his own idea how it should look
13:33:15FromGitter<survivorm> The idea, really, is quite simple
13:34:01FromGitter<survivorm> You use most generalized version, and then only "convert" syntax to the tool's (via search and replace)
13:34:22FromGitter<survivorm> It's not very hard :)
13:35:20FromGitter<alehander42> also, I am not sure how useful it is, I've seen repo-s with ANTLR grammars of many existing languages, but not with BNF
13:35:20FromGitter<survivorm> And as of the tree shape - that depends on parser algorithm, not only grammar
13:35:48FromGitter<survivorm> ANTLR is a form of BNF
13:35:53FromGitter<alehander42> That's true, but your parser generator can convert its raw final tree to your wished shape
13:36:26FromGitter<survivorm> Though the antlr is a bit complicated
13:37:09FromGitter<alehander42> yeah, it's still a dialect in the best case
13:37:51FromGitter<alehander42> but yeah, it's a bit of a shame, no very standardized impl/format for grammars has been established similar to regexps
13:38:19FromGitter<alehander42> regexp dialects have way less differences (which usually don't matter in 90% of daily cases)
13:40:32*Yardanico_ joined #nim
13:41:41FromGitter<data-man> Ragel & Colm very interesting (www.colm.net)
13:43:03*Yardanico_ quit (Client Quit)
13:43:37*Yardanico quit (Quit: Leaving)
13:43:46*Yardanico joined #nim
13:44:58*tankfeeder_ joined #nim
13:45:04*tankfeeder_ left #nim (#nim)
13:47:19*Ven` quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
13:56:50*Arrrr quit (Read error: Connection reset by peer)
13:59:14*Yardanico quit (Remote host closed the connection)
14:01:28*Ven`` joined #nim
14:02:33*Yardanico joined #nim
14:09:16PMunchsurvivorm, cool I'll give it a read when I get home :)
14:09:44FromGitter<survivorm> ok
14:10:46FromGitter<survivorm> Ragel and colm... from the first glance - they're strange
14:11:01FromGitter<survivorm> from the site to ragel example
14:11:28FromGitter<survivorm> As i look at their structures, all i may is shudder
14:11:39FromGitter<survivorm> i mean the definitions
14:13:06FromGitter<survivorm> that may be well the matematicians programming
14:13:26FromGitter<survivorm> not the programming of maths, i mean the style
14:13:31FromGitter<survivorm> of thinking
14:15:11Araqisn't this the best style of thinking?
14:16:12FromGitter<survivorm> for programmers?
14:16:19FromGitter<survivorm> Don't think so
14:16:49FromGitter<data-man> http://re2c.org :)
14:17:04FromGitter<survivorm> mathematicians all too love complex VS simple :)
14:17:39Araqmath has the downside of only support one letter identifiers
14:17:51Araqleading to bad readability IMO.
14:18:06Araqand yes, I recognize how ironic this is when I say it
14:18:20Araqwho wrote a full compiler all with one letter variables
14:18:38FromGitter<survivorm> @data-man now THAT looks interesting
14:19:39FromGitter<survivorm> @Araq the complexity is not only about naming. Overall style too
14:20:05FromGitter<survivorm> though i've not seen the compiler's source
14:21:03FromGitter<survivorm> And i don't think the single-letter identifiers are restriction in maths. More like tradition
14:22:30*gokr joined #nim
14:23:47*skelett joined #nim
14:33:50FromGitter<data-man> @survivorm: https://github.com/skvadrik/comp_langs in Russian
14:35:58FromGitter<survivorm> @data-man And? That is?
14:37:27FromGitter<survivorm> no docs, no readme. Looks like something in process to me
14:37:41*BitPuffin joined #nim
14:38:24FromGitter<data-man> From the author of re2c. I thought you would be interested.
14:41:23FromGitter<survivorm> Maybe. That is - if i'll understand, what's this :)
14:41:55*Ven`` quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
14:41:58Araqre2c is cool but if somebody took over lexim we had something very similar
14:42:06Araq*we would have
14:50:27*Ven`` joined #nim
14:50:48FromGitter<data-man> Ragel is used in the gumbo-parser. Maybe that's why it's so fast. :)
14:52:17Araqgumbo-parser?
14:53:41FromGitter<data-man> https://github.com/google/gumbo-parser
14:54:43FromGitter<survivorm> and there did you find about its connection to ragel?
14:55:22FromGitter<data-man> But for C I'm using https://github.com/lexborisov/myhtml & https://github.com/lexborisov/Modest
14:57:22FromGitter<data-man> @survivorm: https://github.com/google/gumbo-parser/blob/master/src/char_ref.rl
14:58:29*Snircle quit (Quit: Textual IRC Client: www.textualapp.com)
14:59:31Araqwhat does that mean "for C I'm using" ...? you should use Nim instead.
14:59:54Araqalways use the right tool for the job. and Nim is the only right tool.
15:00:22Araqlike the Democracy in Ankh-Morpork
15:00:50Araqthe patrician is only one who is allowed to vote.
15:01:13Araqbbl
15:01:56*floppydh quit (Quit: WeeChat 2.0.1)
15:03:32FromGitter<data-man> Nim generates C-code :)
15:06:45*miran quit (Ping timeout: 260 seconds)
15:12:39FromGitter<data-man> @Araq: You do not mind against adding all html tags to the htmlgen module?
15:17:01*PMunch quit (Quit: Leaving)
15:17:08FromGitter<mratsim> Lol Terry Pratchett and the Discworld, lovely reference
15:17:26*endragor joined #nim
15:19:32FromGitter<mratsim> @BennyElg for your create().change().apply(), that's called a computation graph.
15:20:28FromGitter<mratsim> You can either store a list of closures in a seq and pop them.
15:21:43FromGitter<mratsim> Or build a tree of objects during "change" with an "apply"/"call" method that do the actual computation
15:23:36FromGitter<mratsim> Here is an example of the first way: https://github.com/mratsim/nim-rmad
15:25:01FromGitter<mratsim> For the second way you can look there: https://github.com/mratsim/Arraymancer/tree/master/src/autograd
15:26:23*gokr left #nim (#nim)
15:27:27*c0ntribut0r quit (Ping timeout: 240 seconds)
15:27:39*c0ntribut0r joined #nim
15:28:28FromGitter<alehander42> @survivorm if this is too math-y, you wont like math notation for typing rules at all :D
15:29:14FromGitter<alehander42> but I agree that sometimes its hard to hit the sweet spot for declarativeness
15:30:12*Ven`` quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
15:36:59*Ven`` joined #nim
15:51:21*Yardanico quit (Remote host closed the connection)
15:51:37*Yardanico joined #nim
15:59:41*c0ntribut0r quit (Read error: Connection reset by peer)
16:02:13*c0ntribut0r joined #nim
16:08:48*Ven`` quit (Ping timeout: 240 seconds)
16:09:01FromGitter<Varriount> @mratsim "Ankh-Morpork had dallied with many forms of government and had ended up with that form of democracy known as One Man, One Vote. The Patrician was the Man; he had the Vote."
16:11:38*miran joined #nim
16:13:03*Yardanico quit (Remote host closed the connection)
16:14:14*Yardanico joined #nim
16:22:13*j_rod_s quit (Quit: j_rod_s)
16:22:28*j_rod_s joined #nim
16:26:44*j_rod_s quit (Client Quit)
16:26:58*j_rod_s joined #nim
16:28:48*c0ntribut0r quit (Ping timeout: 240 seconds)
16:29:50*Ven`` joined #nim
16:31:47*c0ntribut0r joined #nim
16:36:56*skrylar joined #nim
16:46:25*Ven`` quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
16:49:54*Jesin joined #nim
17:11:16*sendell quit (Remote host closed the connection)
17:23:30*yglukhov quit (Remote host closed the connection)
17:25:36*codenoid joined #nim
17:25:57*c0ntribut0r quit (Ping timeout: 240 seconds)
17:27:54*Vindaar quit (Remote host closed the connection)
17:29:43*yglukhov joined #nim
17:31:46*endragor quit (Remote host closed the connection)
17:31:58*Trustable quit (Remote host closed the connection)
17:33:57*yglukhov quit (Ping timeout: 240 seconds)
17:38:56*endragor joined #nim
17:39:22*codenoid quit (Read error: Connection reset by peer)
17:43:22*endragor quit (Ping timeout: 256 seconds)
17:53:22*codenoid joined #nim
18:12:55*yglukhov joined #nim
18:15:05*devdri joined #nim
18:17:10*yglukhov quit (Ping timeout: 240 seconds)
18:21:59*codenoid quit (Quit: Leaving)
18:27:49*vivus joined #nim
19:02:23*marenz_ quit (Ping timeout: 256 seconds)
19:04:37*Vladar quit (Remote host closed the connection)
19:10:33*Vladar joined #nim
19:30:46*Trustable joined #nim
19:59:19*clyybber joined #nim
20:11:47*couven92 quit (Quit: Client disconnecting)
20:17:15*Yardanico quit (Remote host closed the connection)
20:24:50*clyybber quit (Ping timeout: 276 seconds)
20:37:48*endragor joined #nim
20:39:45FromGitter<nitely> @floppydh the benefit of PEGs over regex is they can match nested structures of text (i.e: `log(sin(...))`). That's mainly why it's not possible to *parse* things, like HTML with regex.
20:42:42FromGitter<nitely> 1) arbitrary number of nested structures anyway
20:42:55*endragor quit (Ping timeout: 260 seconds)
20:43:59*couven92 joined #nim
20:54:36*Trustable quit (Remote host closed the connection)
21:01:25*Trustable joined #nim
21:05:05*yglukhov joined #nim
21:10:09*Vladar quit (Quit: Leaving)
21:12:59*yglukhov quit (Read error: Connection reset by peer)
21:13:37*yglukhov joined #nim
21:19:06*solitudesf quit (Quit: solitudesf)
21:47:27*Jesin quit (Ping timeout: 240 seconds)
21:56:56*miran quit (Quit: Konversation terminated!)
21:58:49*solitudesf joined #nim
22:09:27*BitPuffin quit (Remote host closed the connection)
22:15:03skrylarso it turns out pratt parsers are surprisingly simple
22:19:54*arecaceae joined #nim
22:20:47arecaceaehow to not merge stderr and stdout in lib/pure/osproc and capture both stderr and stdout separately?
22:24:15*vlad1777d joined #nim
22:30:06*solitudesf quit (Ping timeout: 256 seconds)
22:31:57*devdri quit (Ping timeout: 240 seconds)
22:34:09*devdri joined #nim
22:35:03dom96arecaceae: https://nim-lang.org/docs/osproc.html#startProcess,string,string,openArray[string],StringTableRef,set[ProcessOption]
22:35:11dom96set the options to {}
22:37:03arecaceaedom96: that captures stdout and stderr? - how do I access those then?
22:37:29dom96https://nim-lang.org/docs/osproc.html#outputHandle,Process
22:37:34*Jesin joined #nim
22:38:17arecaceaedom96: I have to select on stderr/stdout tho? - I can't block on either if I don't know what gets written to first no?
22:38:29dom96indeed
22:38:39*Jesin quit (Client Quit)
22:38:48arecaceaeIIRC python just spawns two threads and reads in those or so
22:39:27dom96You may wish to use https://github.com/cheatfate/asynctools/blob/master/asynctools/asyncproc.nim
22:39:44dom96you can do that too
22:40:49arecaceaecan I use the parallel block for that?
22:41:13arecaceaenever tried the threadpool
22:42:30dom96you should use 'spawn' I think
22:42:41dom96I would recommend using asyncproc though
22:47:40*couven92 quit (Ping timeout: 240 seconds)
22:49:48*rauss quit (Quit: WeeChat 2.0.1)
22:58:53*MJCaley joined #nim
23:02:58*skelett quit (Ping timeout: 256 seconds)
23:03:27arecaceaeI assume I can't use a timeout with awaitAny?
23:07:29arecaceaeguess I'll check out asynctools, I hope they don't cause shaky cross plattform errors that will be a pain to debug
23:24:10*nsf quit (Quit: WeeChat 2.0.1)
23:57:51*yglukhov quit (Remote host closed the connection)