11:37 <anqur> Hi, I'm a Pony beginner but I'm reading the source of the libponyrt for learning the actor implementation. I got some questions about *scheduling* that why an `asio` instance starts with the thread register? And why thread registering uses an empty thread-local *this_scheduler*? What for? Hope that someone could help me with that. Thanks!

11:55 <anqur> sched: thread register function https://github.com/ponylang/ponyc/blob/master/src/libponyrt/sched/scheduler.c#L456 / asio: thread function using epoll https://github.com/ponylang/ponyc/blob/master/src/libponyrt/asio/epoll.c#L166

12:01 <zevlg> hey guys, what is the best way in pony to read huge files in asynchronous way, doing bunch of file content processing in parallel ? is there any common pattern to "read huge file" ?

12:30 <zevlg> it could be recursive behaviors for reading from file! nice

14:57 <SeanTAllen> zevlg: the file library is currently synchronous. the pattern would be to have an actor that reads in the file and you can get data from that actor in some fashion.

14:59 <SeanTAllen> anqur: each scheduler is a thread. for each CPU that the pony runtime has access to, it creates a scheduler thread to run actors usin that CPU.

14:59 <SeanTAllen> so, the first step in setting up any scheduler is creating a thread for it to run on

15:00 <SeanTAllen> you can think of the asio subsystem as a special form of scheduler that only handles async io events

15:00 <SeanTAllen> there are command line options to pin schedulers to specific cpus and one for pinning the asio thread as well

15:03 <anqur> Yes I noticed that option in the start.c and main.c files. So I can say that the asio could be handled by random CPU if pinasio is not specified, right?

15:06 <SeanTAllen> i would say that it is unspecificied and liable to change

15:13 <anqur> Oh thanks for answering me! I'm gonna read something about why when `library' specified and it would as well register a thread before creating the schedulers thread...I didn't read them through so I dare not to ask...but your answer is really helpful for my further reading! :D

15:17 <zevlg> btw: is there something similar to `struct` to bind directly to C unions? Or what is the correct way to do it ?

15:26 <SeanTAllen> zevlg: i havent done anything very serious with FFI so I'm not the correct person to answer that. Jemc would be a much better person to answer.

15:27 <zevlg> jemc: hey, do you know any way in pony to bind directly to C union? something similiar to `struct` stuff

15:29 <zevlg> maybe something like https://gist.github.com/373f31b70f6a919b1765cb224b7ac4ee could do the trick ?

15:31 <jemc> hm, I've never had to bind to a C union before, and not sure if there is an established pattern for it - can you paste the definition of the C union you want to bind to, and maybe I can help figure something out

15:33 <zevlg> here is the struct with union inside I need to bind to - https://gist.github.com/0a4ef602231e9d8997f7a709daa3103d

15:49 <jemc> zevlg: hm, I'm not sure, honestly - we should probably raise this for a broader discussion - can you file an issue ticket in the rfcs repo, as a "request for RFC", and we can discuss how we want to handle unions in structs

15:50 <jemc> I suspect we should use some form of annotation, just as we do for packed structs, but it would need an RFC

15:53 <jemc> if you wanted a short term hacky solution, you could write a little C shared library to be linked with your pony program that defines a simple C function that returns its argument, and you could use that for doing a C-style "cast" of one pony type to another

15:53 <jemc> example here: https://github.com/jemc/pony-unsafe/blob/4217e0045942469ae1d7d50669cfb849b7de3cdb/lib/pony-unsafe.c#L12-L14

15:54 <jemc> example call here: https://github.com/jemc/pony-unsafe/blob/4217e0045942469ae1d7d50669cfb849b7de3cdb/unsafe/unsafe.pony#L15-L16

15:55 <jemc> so basically in your case, you could define that union field as being of type `Pointer[None]` to represent the void pointer (which is the largest in the union), then use the C call hack to cast to `I32` or `U32` as needed.

15:58 <jemc> but as I said, allowing unions to be defined in a first class way in Pony is what we really need

16:03 <zevlg> yeah, a have some not so obvious unions as well to bind to

16:05 <jemc> it would be good to give some of the not-so-obvious examples too in the issue ticket, so they can be considered when deciding if the proposed solution is general enough

19:15 <aav> can anyone explain why the following code fragment is invalid?

19:15 <aav> https://gist.github.com/aav/c7beda4b14820ce21b4155efe23df3f9

19:19 <jemc> aav: you probably want `| let r': Union =>` on line 13

19:19 <jemc> though as you probably already know, it's a rather useless match statement since you're matching for the type you already know it is

19:21 <jemc> `| Union =>` is basically short for `if r == Union.create()`

19:21 <jemc> which doesn't work, since you can't construct a union type

19:21 <jemc> that is, you can't call a constructor on one, since you wouldn't know which one to call

19:22 <jemc> `| Type1 =>` works for primitives, since `if r == Type1.create()` is a valid way to compare a value to a primitive

19:23 <aav> and what if I want to say 'if r is Union then ....'?

19:23 <jemc> but in general, for non-primitives you need to use `let`

19:24 <jemc> aav: you basically want `match f1() | let r: Union => ... end`

19:24 <jemc> that will give you a conditional block that runs if the return value of `f1` is of that union type, and it gives you access to the value under the name `r` within the block

19:25 <aav> this is clear. so effectively it means that 'is' operator cannot be used for union types?

19:31 <aav> same story with Tuple, but different error message

19:32 <aav> https://gist.github.com/aav/36766e578d7dd6f3dcf0bcfb895a9407

19:32 <jemc> > so effectively it means that 'is' operator cannot be used for union types?

19:33 <jemc> not true, but the issue is that the `is` operator doesn't do what you're thinking it does

19:33 <jemc> the `is` operator will return true if the left side and the right side are the same *object* not the same *type*

19:34 <jemc> so if I did something like `let a: Type1 = Type1; let a': Union = a`

19:34 <jemc> then `a' is a` would return true

19:35 <jemc> the two references have different types (`a'` is a `Union`, `a` is a `Type1`), but they refer to the same object (an instance of `Type1`)

19:36 <jemc> of course, because `Type1` is a primitive, every single instance of it that I "create" in any thread will be the same object

19:36 <jemc> so `a is Type1` will work for a primitive, because it translates to `a is Type1.create()`

19:36 <aav> it means 'is' actually something like '==, but without type checking'?

19:37 <aav> i can say 'if Type1 is Type2 ', but cannot say 'if Type1 == Type2 ...'

19:42 <aav> jemc: thank you for the explanation

19:42 <jemc> the best way to think about it is that `is` compares *identity*, and `==` checks *structural* equality (by delegating to the `eq` method of the class)

19:43 <jemc> but yes, identity can be compared for references of two different types

19:43 <jemc> the `==` operator could also do this, if the `eq` method implements

19:44 <jemc> for example, nothing stops me from defining `fun eq(that: Type2): Bool => ...` on `Type1` (imagining for a moment that we're talking about classes, not primitives)

19:45 <jemc> so the `==` operator can be used/abused to mean whatever you want it to mean, based on what you implement

19:45 <aav> yes, i understand

19:46 <aav> as a bottom line - the only way to check is the object is of some type is to match it with 'let ...' pattern

19:46 <aav> without 'let...' it will try to create an instance, and match on value

19:46 <aav> right?

20:01 <jemc> yep, exactly