<< 25-08-2018 >>
00:09:36*xet7 quit (Quit: Leaving)
00:18:53FromGitter<timotheecour> @dom96 any other concerns for https://github.com/nim-lang/Nim/pull/8555 ? I’ve removed `FAKEFILE` and tests are green
00:20:56*krux02 quit (Remote host closed the connection)
00:21:55FromGitter<gogolxdong> the first time configure nginx https settings, got 403 Forbidden.
00:23:42FromGitter<gogolxdong> and 400 Bad request if use jester.
00:24:53FromGitter<gogolxdong> nginx reverse proxy , pricisely.
00:33:50*bung quit (Quit: Page closed)
00:35:10*zachcarter quit (Ping timeout: 252 seconds)
00:41:14*ftsf joined #nim
00:45:30*mr_yogurt quit (Ping timeout: 264 seconds)
00:54:50FromGitter<gogolxdong> firefox got more specific reason
00:54:52FromGitter<gogolxdong> Cross-Origin Request Blocked: The Same Origin Policy disallows reading the remote resource at https://www.bafang.cloud:8081/cmpprotocol. (Reason: CORS request did not succeed).
01:00:53FromGitter<gogolxdong> Should this be https ? ⏎ ⏎ ```location / { ⏎ proxy_pass http://localhost:8000; ⏎ }``` [https://gitter.im/nim-lang/Nim?at=5b80aa45e5b40332abf4d70e]
01:03:00FromGitter<timotheecour> happy Friday and here’s a friday present for you all: universal toSeq: works with UFCS; works with inline & closure iterators, and with iterables #8711
01:18:47*nixologist joined #nim
01:19:43*nixologist left #nim (#nim)
01:25:39FromGitter<gogolxdong> How to replace this `var routeTable = @["routeTableName":"\"<script>alert(1);</script>"]` to make it can be parsed by parseJson?
01:32:17*zachk quit (Quit: Leaving)
01:37:00FromGitter<gogolxdong> and notice there might be multiple like "\"\"...
01:46:24*ftsf quit (Ping timeout: 268 seconds)
01:48:52*nickoe26 joined #nim
01:48:58*nickoe26 quit (Remote host closed the connection)
01:53:23FromGitter<gogolxdong> `var routeTable = @["""{\"routeTableName\":"\"<script>alert(1);</script>\"}"""]`
02:00:52*Death916 quit (Changing host)
02:00:52*Death916 joined #nim
02:00:52*Death916 quit (Changing host)
02:00:52*Death916 joined #nim
02:09:27*ftsf joined #nim
02:25:56FromGitter<gogolxdong> ok, I just simply replace("\\\"").
02:43:46FromGitter<DanielSokil> @dom96 Thanks for fixing Jester.
02:48:33*dddddd quit (Remote host closed the connection)
03:06:22FromGitter<gogolxdong> I still got bad request.
03:27:20*ftsf quit (Ping timeout: 244 seconds)
03:31:04*zachcarter joined #nim
03:32:25*kapil___ joined #nim
03:35:33*zachcarter quit (Ping timeout: 252 seconds)
05:32:27*mr_yogurt_ joined #nim
05:38:23*mr_yogurt_ quit (Ping timeout: 252 seconds)
05:40:25*liteIRC joined #nim
05:40:37*mr_yogurt joined #nim
05:43:03*liteIRC quit (Client Quit)
05:44:17*zachcarter joined #nim
05:49:22*zachcarter quit (Ping timeout: 268 seconds)
06:04:21*zachcarter joined #nim
06:08:35*Yujian joined #nim
06:10:49*Yujian quit (Client Quit)
06:29:50*leorize quit (Quit: WeeChat 2.2)
06:30:11*stefanos82 joined #nim
06:30:16*leorize joined #nim
06:32:29*NimBot joined #nim
06:54:36FromGitter<Bennyelg> @Araq Where I can find the db infering in ornim ?
06:54:58FromGitter<Bennyelg> @Araq ormin*
08:03:08*gmpreussner quit (Quit: kthxbye)
08:04:06*gmpreussner joined #nim
08:22:43*Yujian joined #nim
08:23:19*Yujian quit (Client Quit)
08:29:51*Trustable joined #nim
08:35:46*krux02 joined #nim
08:36:43FromGitter<bung87> ```code paste, see link``` [https://gitter.im/nim-lang/Nim?at=5b81151aff44515616364d3f]
08:37:02FromGitter<bung87> how to pass the method?
08:44:00stefanos82can you provide a better example?
08:45:44leorizebung87: pass the method like this: atexit(delpid)
08:46:08*wildlander_ joined #nim
08:46:28leorizeif parameter is necessary, try passing a closure.
08:46:31FromGitter<bung87> found there is a `addQuitProc( )` ⏎ ⏎ now ⏎ ⏎ ``` ⏎ method delpid(self:Daemon) = ⏎ ⏎ addQuitProc( self.delpid ) ⏎ ``` [https://gitter.im/nim-lang/Nim?at=5b8117664be56c591892d5e0]
08:47:02leorizeI think you should use `defer:` instead
08:47:36*wildlander quit (Ping timeout: 272 seconds)
08:48:36stefanos82does anyone knows a way to measure a tuple's number of elements?
08:50:50FromGitter<bung87> @leorize thanks! let me try it
08:52:01leorizestefanos82: it's rather weird that `[]` exists for tuples but not `len()`
08:52:16stefanos82leorize: I know
08:52:35stefanos82I'm trying to figure out a way to measure its element size and cannot find one!
08:53:03leorizeuse the fields() iterator?
08:53:16stefanos82let me try it
08:53:58stefanos82which module is it part of?
08:54:02leorizesystem
08:55:22stefanos82can you provide an example to test it? I get an error when I'm trying to use it
08:55:49stefanos82Nim desperately needs a cleaner documentation :/
08:56:03stefanos82I cannot easily find things that should be obvious to the end-user
08:56:37*wildlander_ quit (Quit: Konversation terminated!)
08:58:47leorizewhat exactly are you trying to do?
08:59:26stefanos82to get the element size of a tuple and loop over it to get its values
08:59:36stefanos82much like we get with PHP's associative arrays
08:59:43FromGitter<bung87> ` <proc (){.closure.}>` that type mismatch`proc ()`
09:02:17leorizebung87: looks like closure won't cut it. Is there any reason you would need to use `addQuitProc()`?
09:03:46FromGitter<bung87> to delete pid file when process exit
09:04:08leorizemaybe use `defer:`?
09:06:48leorizedoes the create gist button on Nim playground actually work?
09:07:13*druonysus quit (Ping timeout: 260 seconds)
09:07:15leorizestefanos82: https://ptpb.pw/e6Op
09:07:32leorizefor element size, I think you'd need a macro
09:07:47stefanos82thank you leorize
09:13:44FromGitter<GULPF> you can use the arity proc from the typetraits module to get the number of elements in a tuple type
09:22:56*krux02 quit (Remote host closed the connection)
10:04:59FromGitter<gogolxdong> What's the common nginx reverse proxy configuration ? ⏎ we got `Cross-Origin Request Blocked: The Same Origin Policy disallows reading the remote resource at https://wwww.bafang.cloud:8081/cmpprotocol. (Reason: CORS request did not succeed).`
10:08:05*krux02 joined #nim
10:12:21*Vladar joined #nim
10:17:26FromGitter<bung87> https://github.com/bung87/moto-moe/blob/master/conf/moto-moe.conf you can check this
10:19:16FromGitter<bung87> also you can check many open source web project that using nginx
10:20:42FromGitter<gogolxdong> ok, wonder whether it's out of ⏎ proxy_pass_header Server; ⏎ ⏎ ```code paste, see link``` [https://gitter.im/nim-lang/Nim?at=5b812d7a38a12915e4f3d19c]
10:22:22FromGitter<gogolxdong> ours is simply as ⏎ location ~ ^/~(.+?)(/.*)?$ { ⏎ ⏎ ```code paste, see link``` [https://gitter.im/nim-lang/Nim?at=5b812ddef86b741b05bec85f]
10:23:38FromGitter<dom96> https://github.com/nim-lang/nimforum/blob/master/setup.md#nginx
10:24:02FromGitter<dom96> CORS is unrelated to this. Read up on it.
10:24:26FromGitter<bung87> if it's that simple ,you may doing thing
10:25:09FromGitter<bung87> you backend program may not get enough information about request.
10:26:06FromGitter<bung87> also you can try proxy_pass with ip:port or socket address
10:28:35*tiorock joined #nim
10:28:35*tiorock quit (Changing host)
10:28:35*tiorock joined #nim
10:28:35*rockcavera is now known as Guest57803
10:28:35*Guest57803 quit (Killed (sinisalo.freenode.net (Nickname regained by services)))
10:28:35*tiorock is now known as rockcavera
10:31:36*tiorock joined #nim
10:31:36*tiorock quit (Changing host)
10:31:37*tiorock joined #nim
10:31:37*rockcavera quit (Killed (wilhelm.freenode.net (Nickname regained by services)))
10:31:37*tiorock is now known as rockcavera
10:35:12FromGitter<alehander42> is there a way to get the current exe name ?
10:35:34leorizegetAppFilename()?
10:36:11FromGitter<gogolxdong> if X-Real_IP $remote_addr is ip address ,what is $host should be?
10:40:52*Trustable quit (Remote host closed the connection)
10:41:43FromGitter<bung87> the variable is taken care by nginx , you dont need edit it
10:42:13FromGitter<bung87> and it's not your host ip
10:44:00FromGitter<bung87> I think the best way is read the document from your web framework site,which may has a minimal config file for nginx.
10:47:59FromGitter<alehander42> thanks leorize !
10:48:08FromGitter<alehander42> it works for me
10:53:43*dddddd joined #nim
10:59:52FromGitter<gogolxdong> Please take a look at our nginx.conf .
10:59:54FromGitter<gogolxdong> http://ix.io/1lcm
11:03:31FromGitter<bung87> `proxy_pass http://localhost:8000;` change it to ip:port ,since your server host 80 and 443
11:05:23FromGitter<bung87> I can't sure it's wrong but it is misleading.right?
11:07:34*SenasOzys quit (Ping timeout: 268 seconds)
11:08:21*kapil___ quit (Quit: Connection closed for inactivity)
11:09:33FromGitter<bung87> and another question your program can serve both http https through one port?
11:09:39FromGitter<gogolxdong> changed to 0.0.0.0:8000, no difference.
11:11:42FromGitter<gogolxdong> web framework listen on http://*:8000
11:13:20FromGitter<gogolxdong> ```code paste, see link``` [https://gitter.im/nim-lang/Nim?at=5b8139cffd3c641b0609452e]
11:13:42FromGitter<bung87> I think your http server works fine
11:16:27*ftsf joined #nim
11:16:59FromGitter<bung87> if you config server both 80 443 port ,you may need write condition in config file about which port you will proxy_pass to
11:19:16FromGitter<gogolxdong> I can comment it out but got the same error.
11:20:05FromGitter<gogolxdong> comment http out
11:23:08FromGitter<bung87> I dont like further disscus about this, nothing related to Nim.
11:28:05FromGitter<bung87> I checked https://www.bafang.cloud/cmpprotocol seems works fine now, your problem gone.
11:28:32*SenasOzys joined #nim
11:29:12FromGitter<gogolxdong> you mean I shouldn't add https://www.bafang.cloud:8081/cmpprotocol?
11:30:58FromGitter<bung87> you should not add port to your url.
11:32:29FromGitter<bung87> the most wrong parts is your backend serve 0.0.0.0 that client can directly access to it ,right? then why you config a nginx file,and why you config cert file on nginx?
11:34:47FromGitter<gogolxdong> because of ⏎ ⏎ ##This HTTP server has not been designed to be used in production, but ⏎ ⏎ ##for testing applications locally. Because of this, when deploying your ... [https://gitter.im/nim-lang/Nim?at=5b813ed6ac25fd11b5913c14]
11:35:09FromGitter<gogolxdong> asynchttpserver.nim
11:36:16FromGitter<bung87> so this description prove mine.
11:36:46FromGitter<bung87> you dont read carefully
11:37:33FromGitter<bung87> that's *0.0.0.0* that you allow client access dirctly
11:41:46FromGitter<gogolxdong> listen on its ip address now , got 405
11:43:16FromGitter<gogolxdong> oh, it's a virtual IP which cannot be listen on . failed to listen.
12:16:00*ftsf quit (Ping timeout: 252 seconds)
12:39:25FromGitter<dom96> Once again: look at the config I sent you, that's all you need
12:39:43FromGitter<dom96> Don't expose jester to the internet
12:40:41FromGitter<dom96> You're probably requesting your site on port 8081 when you're on port 80
12:40:56FromGitter<dom96> That's a CORS violation as far as I know
12:48:54*dorelix joined #nim
13:14:10stefanos82@dom96: when we use magic pramas, where are they implemented exactly?
13:15:27leorizethey're implemented in the compiler
13:16:25leorizesearch for m<Magic name> in the compiler source IIRC
13:17:04stefanos82I will, thank you leorize
13:24:18stefanos82leorize: it's an enum value
13:24:46leorizeyep, looks for where it's used, then you will figure out how the compiler generate code for them
13:32:42*Yujian joined #nim
13:33:37*Yujian quit (Client Quit)
13:47:42*mrshu quit (Ping timeout: 260 seconds)
13:47:43*rockcavera quit (Read error: Connection reset by peer)
14:12:47FromGitter<gogolxdong> xhr.js:178 POST https://www.bafang.cloud/cmpprotocol 405 (Method Not Allowed)
14:13:45*endragor joined #nim
14:16:00stefanos82is there any list with built-in pragmas and any with templated pragmas?
14:18:27*endragor quit (Remote host closed the connection)
14:18:30leorizewhat do you mean?
14:19:46stefanos82templates give you the right to implement your own prama
14:20:21stefanos82so I was wondering; is there any list with actual built-in pragmas and other list for templated ones?
14:20:30leorizefor a list of built-in pragmas, check the Manual
14:20:46stefanos82I'm reading it, but it's not always clear
14:21:19leorizefor the purpose of a list, it's there
14:32:15stefanos82yeah, so basically it's impossible to distinguish which is built-in and which is user-defined
14:32:17stefanos82oh well...
14:33:02leorizewell it's user-defined when you can't find it in the Manual :P
14:34:45stefanos82obviously; also, I meant template-defined by saying user-defined
14:34:49stefanos82anyway
14:42:45pqflx3[m]Is it possible to test runnableExamples on local docs?
14:49:16leorizeI think it's tested automatically when you run `nim doc`
14:51:14pqflx3[m]Didn't there used to be a button to 'Run' the examples looking at the html? or am I misremembering
14:54:18*SenasOzys quit (Ping timeout: 272 seconds)
14:59:59FromGitter<ephja> stefanos82: are you talking about the recent addition to user-defined pragmas?
15:00:03*SenasOzys joined #nim
15:02:35FromGitter<ephja> in any case, user-defined pragmas applied to types seem to serve only as tags atm, IINM. I'm sure it'll be possible to modify the AST eventually. it would be a little less hairy than applying a user-defined pragma to a whole type section rather than types in a type section
15:06:35FromGitter<ephja> will more generalized macro constructs take us closer to a statically typed lisp? :p
15:09:38FromDiscord_<exelotl> is it possible to do async proc forward declartion?
15:09:44FromDiscord_<exelotl> *declaration
15:12:48stefanos82@ephja: the documentation does not state anything about being recently added; all I'm doing is reading the manual and experimenting as much as possible to figure out how to use Nim *the right way*, that's all
15:14:23*echotangoecho joined #nim
15:18:35*xet7 joined #nim
15:18:57*mrshu joined #nim
15:25:20*mrshu quit (Ping timeout: 268 seconds)
16:19:06*mrshu joined #nim
16:21:54*echotangoecho quit (Quit: Lost terminal)
16:36:40FromGitter<mratsim> Oh, I just realised, Nim is allowed on HackerRank: https://www.hackerrank.com/environment
16:37:43*Jesin joined #nim
16:39:56*Jesin quit (Remote host closed the connection)
16:43:44FromGitter<rayman22201> So is BrainF*ck...
16:43:49FromGitter<rayman22201> Lol
16:45:14*Jesin joined #nim
16:53:32*kapil___ joined #nim
17:03:40*xet7 quit (Quit: Leaving)
17:03:59*xet7 joined #nim
17:07:57*linuxdaemon24 joined #nim
17:09:08*linuxdaemon24 quit (Remote host closed the connection)
17:19:41krux02ephja: Nim is already a statically typed lisp
17:20:02*dorelix quit (Ping timeout: 268 seconds)
17:20:09krux02it is just that the macros are ugly here and there
17:21:26FromGitter<mratsim> I just checked, no Nim lang, it’s a trap
17:22:54ldleworknim isn't really a lisp
17:23:14FromGitter<alehander42> i don't really dig homoiconity so much anymore
17:23:22FromGitter<alehander42> it's neat, but I think it's actually worse for users
17:23:22ldleworklisp is all about homoiconic antiquoting
17:23:36*Vladar quit (Remote host closed the connection)
17:23:36FromGitter<alehander42> because after all macros are not your #1 solution
17:23:41ldleworkquoting can make things extremely expressive
17:23:47FromGitter<alehander42> yep, for macros
17:23:51ldleworki use macros all the time in my lisp
17:23:54FromGitter<alehander42> but nim does have quoting too
17:23:56FromGitter<data-man> https://github.com/alehander42/breeze ;)
17:24:23FromGitter<alehander42> and in cases when you need a more complicated macro, lisp does win, but I'd argue those macros are not so common
17:24:31ldleworknot really on the same level of expressitivty and succinctness
17:24:34FromGitter<alehander42> or if they are, that's not good for maintainability
17:24:37FromGitter<alehander42> but that's good
17:24:40FromGitter<alehander42> that's the point
17:24:53ldleworki literally use macros all over the place
17:24:56FromGitter<alehander42> I prefer it being a little bit harder
17:25:00ldleworki refactor my code so each unit is small
17:25:15ldleworklisp excells at refactorability
17:25:25FromGitter<alehander42> well, doesn't it lead to harder to maintain code for teams?
17:25:25ldlework(i can't believe i'm defending lisp at all lol)
17:25:28FromGitter<alehander42> don't get me wrong
17:25:32ldleworkbut you guys were getting out of hand lol
17:25:32FromGitter<alehander42> I am using a lot of macros too
17:25:43FromGitter<alehander42> but often I feel bad about it
17:25:51FromGitter<alehander42> every macros is its own custom dsl
17:26:04FromGitter<alehander42> and if you have too many in the same project, this can get weird
17:26:38FromGitter<alehander42> Idlework look, I am not saying lisp is bad, I am just saying homoiconity has pro-s and con-s
17:26:41ldleworki don't think there is much difference between macros and functions in lisp
17:27:01ldleworka function call in lisp is pretty much a macro where you know all the arguments are evaluated
17:27:05FromGitter<alehander42> but that's an illusion
17:27:10ldleworkbeyond that you don't know what either will do with their arguments
17:27:12FromGitter<alehander42> because a macro can do wtf stuff with its args
17:27:20ldleworkyes and so can a function
17:27:26FromGitter<alehander42> well, function calls are more obvious
17:27:32ldleworkthe only difference is that a function always evaluates the arguments
17:27:36ldleworkbut pass a data structure to a function
17:27:38ldleworkomg!
17:27:40ldleworkwhat will it do?
17:27:46ldleworkit can do anything with that data structure!
17:27:49FromGitter<alehander42> but that's not a function
17:27:51ldleworkinterpret it in any way it wants.
17:27:53FromGitter<alehander42> you now have
17:27:53ldleworkwhat
17:28:01FromGitter<alehander42> "compile" time and run time
17:28:06FromGitter<alehander42> and you run code on both
17:28:11FromGitter<alehander42> which complicates things
17:28:16FromGitter<alehander42> ok, there is a reason why
17:28:20ldleworkit doesn't matter at all
17:28:23FromGitter<alehander42> if you can do something with a function
17:28:31FromGitter<alehander42> you try that first
17:28:36FromGitter<alehander42> and only after you do a macro
17:28:40ldleworklook
17:28:45ldleworkit is the other way around
17:28:52ldleworktake any macro and function that do the same
17:28:55ldleworkthe only difference between them
17:29:03ldleworkis that for the function you'll quote all your arguments
17:29:09ldleworkbeyond that they can both do all the same things
17:29:13FromGitter<alehander42> I know how it works, all I am saying is
17:29:18FromGitter<alehander42> when I read somebody else's code
17:29:25FromGitter<alehander42> following normal calls is a bit easier
17:29:35FromGitter<alehander42> it's hard to talk without concrete examples
17:29:43FromGitter<alehander42> but a lot of the macro dsl-s I do
17:29:52FromGitter<alehander42> are actually very "powerful"
17:29:52ldleworklots of code in melpa uses macros
17:29:55FromGitter<alehander42> like, you write a spec
17:29:56ldleworki use tons of macros
17:30:01FromGitter<alehander42> and I do all kinds of shit in the background
17:30:02ldleworki debug elisp all the time
17:30:11ldleworki just don't agree with the waving
17:30:18FromGitter<alehander42> ok, are those macros closer to nim's templates
17:30:27FromGitter<alehander42> I mean, is it more like "quoting and unquoting"
17:30:34FromGitter<alehander42> or more complicated ast walking and creation?
17:30:46ldleworki sometimes functionally generate list structures which i evaluate or inject into an accumulated form
17:30:56FromGitter<alehander42> I think it's good to differentiate between both
17:31:01FromGitter<alehander42> because most macros are the first kinds
17:31:01ldleworkthe point is api design
17:31:08ldleworkyou can'tk now what a function or macro does
17:31:22FromGitter<alehander42> and nim already is good enough at them
17:31:26ldleworkhere's the thing
17:31:28ldleworkhere's the one thing
17:31:32FromGitter<alehander42> templates are exactly as easy as lisp quotes
17:31:34ldleworkif evaluation has side-effects
17:31:48FromGitter<alehander42> now, macros are harder, but what they do is also way more opaque
17:31:52ldleworkno it really doesn't
17:32:08ldleworktemplates are not the same lisp quoting/antiquoting
17:32:19ldleworkyou can quote and antiquote arbitrarily anywhere in any code
17:32:25ldleworkyou don't need to define a template and use it
17:32:40ldleworkquoting/antiquoting is syntax and can be used anywhere
17:32:47ldleworkand is also a useful way to make data
17:32:49ldleworknot just code
17:33:11FromGitter<mratsim> That really sounds like #firstWorldLanguage problem
17:33:14ldleworki think the truism that nim and lisp macros are similar in that they are compile time code that works on an ast
17:33:15FromGitter<alehander42> yeah, but I don'\t like that
17:33:21ldleworkis being conflated though culture
17:33:27ldleworkto be more than that
17:33:35ldleworkbecause that's as far as their similarity really goes
17:33:38FromGitter<alehander42> like, it's cool that your ast is data
17:33:45FromGitter<alehander42> and you can use the same syntax on all
17:33:55FromGitter<alehander42> but look, this is all the pro-s and con-s of macros
17:33:58ldleworkit is absurdly useful and expressive at the same time
17:34:01FromGitter<alehander42> and then we have "normal syntax"
17:34:04FromGitter<alehander42> and it sucks
17:34:08FromGitter<alehander42> come on `(+ 2 3)`
17:34:18FromGitter<alehander42> there is a reason no other language
17:34:23FromGitter<alehander42> uses prefix notation
17:34:30ldleworki think you're stuck attacking lisp
17:34:32FromGitter<alehander42> or is so homoiconic
17:34:36FromGitter<alehander42> mate i love lisp
17:34:48FromGitter<alehander42> i've implemented minilisps several times
17:34:51FromGitter<mratsim> Well you have Polish Notation and Reverse Polish Notation and finance people love their HP-12C
17:34:53FromGitter<alehander42> for a long time
17:34:58FromGitter<alehander42> I thought homoiconity is great
17:35:11FromGitter<alehander42> but if you ignore macros for a second
17:35:18FromGitter<alehander42> from purely syntactic viewpoint
17:35:29FromGitter<mratsim> in RPN you would use (2 3 +) ;)
17:35:39FromGitter<alehander42> you have 90% of languages using a different syntax, with more special cases
17:35:49ldleworkits hardly "prefix" notation
17:35:51ldleworkfoo(bar)
17:35:51FromGitter<alehander42> and I just think that's closer to the balance
17:35:54ldleworkis this prefix notation?
17:35:56FromGitter<alehander42> not only prefix
17:36:03ldlework`+`(2, 3)
17:36:03FromGitter<alehander42> the homoiconicity thing too
17:36:10FromGitter<mratsim> https://en.wikipedia.org/wiki/Polish_notation <--
17:36:12FromGitter<alehander42> having several syntactic constructs
17:36:12ldleworkhomoioncicity has no negatives
17:36:14FromGitter<alehander42> is not bad
17:36:19FromGitter<alehander42> I don't agree
17:36:24FromGitter<alehander42> it limits you just so
17:36:31ldleworkwhat
17:36:32FromGitter<alehander42> your source code looks like the ast
17:36:40ldleworklol ok
17:36:41*Yujian joined #nim
17:36:54FromGitter<alehander42> well that's the obvious + of it
17:36:54ldleworkanyway probably #nim-offtopic material
17:37:09FromGitter<mratsim> Discussing Nim syntax is not offtopic
17:37:38FromGitter<alehander42> and there is no reason you can't have 60-80% of the macro power with a more "classical" syntax
17:37:47FromGitter<alehander42> nim might not have it so deeply
17:37:54FromGitter<alehander42> like quoting and quasiquoting everywhere
17:38:00FromGitter<alehander42> but you could write such a language
17:38:58*Yujian quit (Client Quit)
17:40:40FromGitter<alehander42> basically my point is that you have ⏎ "standard code" "macro code" and homoiconic syntax optimizes the second case too much hurting the first case when the first usecase is still bigger
17:41:24FromGitter<alehander42> also, take a look at io's homoiconity, it's pretty cool too
17:55:31*abm joined #nim
18:10:35krux02ldlework, what do you program mostly in lisp?
18:11:05krux02All lisp I know is emacs lisp, and the introduction course to scheme in my first lecture in computer scince that I attended.
18:27:14ldleworkkrux02: I have been coding for like 20 years, but I have been writing a lot of lisp lately as I've gone crazy with emacs customization.
18:27:29ldleworkI have written a number of elisp packages for working with Org-mode and other things.
18:27:37ldleworkBut I am a Python professional.
18:28:36FromGitter<alehander42> what do you think of clojure (if you have tried it)
18:36:14*zachk joined #nim
18:43:46krux02ldlework, so most of your lisp experience is elip.
18:45:02ldleworkkrux02: and cl
18:45:07*wildlander joined #nim
18:48:41*druonysus joined #nim
18:48:42*druonysus quit (Changing host)
18:48:42*druonysus joined #nim
18:51:41*rockcavera joined #nim
18:59:24krux02I never wrote cl, but there is a lot of cl-xxx macros in elisp
18:59:47krux02seems like a lot of emacs people want elisp to be more like cl
19:00:22krux02ldlework: I wonder, are there some el-xxx macros in common lisp, to make it more like emacs lisp?
19:04:45FromGitter<timotheecour> any one with commit access here?
19:06:01*qwertfisch is now known as qwertforelle
19:08:54*zachk quit (Changing host)
19:08:54*zachk joined #nim
19:08:57*stefanos82 quit (Quit: Quitting for now...)
19:09:49*Zord20 joined #nim
19:13:51*Zord20 quit (K-Lined)
19:23:37FromGitter<bung87> https://github.com/serverdensity/python-daemon/blob/master/daemon.py#L113 I'm porting a python package but dont know why he change `daemon_alive` to false next to exit()
19:27:51*krux02 quit (Remote host closed the connection)
19:28:43*krux02 joined #nim
19:45:13*Vladar joined #nim
20:24:56*Vladar quit (Remote host closed the connection)
20:31:05FromGitter<timotheecour> @araq thanks for merging the 2 PRs; how about these other 2: https://github.com/nim-lang/Nim/pull/8680 and https://github.com/nim-lang/Nim/pull/8682 ?
20:49:50FromGitter<Araq> see my remarks
21:16:45FromGitter<timotheecour> thanks, will fix 8682; regarding the `Space after the colon` thing: since nimpretty is not quite ready yet, how about a `nimpretty —safe` that does a safe subset of checks that can be safely run on code without messing it; ie, it wouldn’t deal with comment reflowing etc but at the very least could handle the `space after the colon` + other simple things
21:20:29*arecaceae quit (Remote host closed the connection)
21:20:47*arecaceae joined #nim
21:28:10FromGitter<Araq> that's far more work than making you type a space
21:28:26FromGitter<timotheecour> PR accepted?
21:30:00FromGitter<Araq> how so? the reviewer still need to review every line in the patch
21:31:06FromGitter<timotheecour> of course; but it will save a lot of back and forth time ; eg when a PR is only halted because of style nits that would’ve been caught byt `nimpretty —safe`
21:33:36FromGitter<Araq> needs a serious cost-benefit analysis based on the percentage of PRs that are only halted because of style nitpicks
21:37:34FromGitter<timotheecour> here’s one non-quantitative data point: at google, when this was introduced (via `clang-format —style=google`), it saved a lot of time on reviews
21:44:35*qwertforelle is now known as qwertfisch
21:48:03FromGitter<Araq> yeah I can imagine, but Nim is not Google and yet I bet nobody at G did a cost-benefit analysis for the `-style=google` feature
21:48:37FromGitter<timotheecour> (unrelated: PTAL on https://github.com/nim-lang/Nim/pull/8682 ; addressed all ur comments)
21:48:45FromGitter<Araq> because frankly, programmers are downright terrible at this and programmers turn into managers etc ;-)
21:50:09FromGitter<kayabaNerve> Everyone competent will be promoted until they are no longer competent, meaning the highest jobs in society will be filled with incompetent workers.
21:50:29FromGitter<kayabaNerve> --Some law I paraphrased and probably butchered the wording of.
21:50:51FromGitter<timotheecour> everyone gets promoted to their highest level of incompetence ; lol
21:51:59FromGitter<kayabaNerve> https://en.wikipedia.org/wiki/Peter_principle
21:52:01FromGitter<kayabaNerve> Found it.
21:52:34FromGitter<kayabaNerve> The idea is that once they become incompetent, they are no longer promoted, but they're not demoted back.
21:52:56FromGitter<kayabaNerve> So not really their highest level of incompetence; more their level of incompetence.
21:59:51FromGitter<mratsim> @Araq, I think that’s mostly a problem in Europe, at least it is in France: the only way to progress in your career is to become a team lead then manager then director and managing people is completely different from managing machines
22:00:05FromGitter<mratsim> and some jut don’t want to deal with people
22:00:53FromGitter<mratsim> thankfully that’s changing in startups and you get an expert track and a management track with the similar pay and recognition
22:02:44FromGitter<mratsim> Also Luke and Timothee, due to labor law and firing being super difficult, in big French company you also have what is dubbed the “closet promotion”. If you’re doing nothing or even preventing things from working as it should, instead of firing you, the company will promote you in the middle of nowhere where you harmless. Why promotion? because otherwise you wouldn’t accept. >_>
22:12:35*kapil___ quit (Quit: Connection closed for inactivity)
22:16:24*brainproxy quit (Quit: WeeChat 2.2)
22:21:47FromGitter<timotheecour> yup, I’m all too familiar with that aspect in France.. I thought it improved quite a bit though ?
22:23:12*leorize quit (Ping timeout: 252 seconds)
22:30:36*rockcavera quit (Remote host closed the connection)
22:32:30*Ben648 joined #nim
22:34:35*nsf joined #nim
22:36:49*Ben648 quit (Remote host closed the connection)
22:54:33*krux02 quit (Remote host closed the connection)
23:13:54*nsf quit (Quit: WeeChat 2.2)
23:20:49FromGitter<timotheecour> is there a commonly accepted term for proc|template|func|macro (and maybe iterator) ? is that `routine` ?
23:54:41FromGitter<data-man> "My routine returns the strange result..." ⏎ "What you mean? The proc? The func? The macro?" ⏎ "No! The template!"
23:55:22FromGitter<timotheecour> what I meant is in a context where it would apply to any of these
23:56:42FromGitter<data-man> As in D? :-D
23:57:12FromGitter<timotheecour> sorry I don’t see how D is related.