00:36 <jemc> TwoNotes: use writev instead of write

00:37 <jemc> eventually, writev will actually use a more efficient mechanism than iterating over the buffer array, so formatting your code to use it now is a good idea

00:38 <jemc> for high-performance stuff we want to avoid flattening a collection of buffers into a single one, as that is unnecessary allocations and copying

00:39 <jemc> Perelandric: I don't think you can do the equivalent with a constructor, you'd have to do something else

00:39 <jemc> with more info about what you're trying to do, maybe someone could give a recommendation

00:39 <jemc> I'm on my way out the door at the moment though

00:39 <jemc> good luck!

00:50 <Perelandric> jemc: Thank you. Overall, I'm exploring different ideas and wanted to make sure I wasn't missing something.

00:51 <Perelandric> The ctor is for a `val` class and needs to receive a stream of data to construct itself...

00:51 <Perelandric> so the stream, needing to modify itself, needs to be mutable and sendable (iso).

00:52 <Perelandric> The issue is that the ctor needs to call other ctors to populate a Array field.

00:54 <Perelandric> ...from the same stream.

01:03 <Perelandric> This part is mostly internal, so I'll get by with just calling a `fun` that does the reading/parsing...

01:03 <Perelandric> and passes the resulting data to the ctor.

12:17 <Candle> Is there a "wait for these N different events and then do something else" pattern around?

12:48 <SeanTAllen> Candle: not at the moment. We are doing that in one of our apps here at Sendence but we haven't extracted that to any sort of reusable pattern yet.

12:54 <SeanTAllen> in general what we do, is we have an actor that is responsible for receiving notification that these different events have happened and when the trigger is hit, it does whatever is needed to start the something else

12:55 <SeanTAllen> in our case that is multiple actors informing this coordinator of things happening on startup like sockets successfully opening etc and then the coordinator informs "home base" that its ready to go and everything is configured. "home base" is another app waiting for all of the processes it started up across the network to let it know they are ready and when

12:55 <SeanTAllen> they have all checked in, it triggers another app to start test runs.

13:27 <TwoNotes> Is there already a stdlib function to flatten an Array[ByteSeq] into Array[U8]?

15:43 <SeanTAllen> not that i am aware of

15:54 <Candle> SeanTAllen: Fair enough, I now have a 10? line actor to do that sort of thing.

16:25 <SeanTAllen> ours are quite a bit longer but what is being coordinated is rather complicated.

17:51 <jemc> TwoNotes, your best bet is to iterate over the `Array.values` and do `Array.append`

17:59 <TwoNotes> Sounds easy enough. I can see several applications for WriteBuffer beyond network comms.

18:51 <TwoNotes> Copying could be reduced with a version of WriteBuffer that really wrote to a single buffer istead of separating chunks.

18:53 <SeanTAllen> So an array?

18:53 <jemc> if you're just talking about writing numbers and such to a single chunk, you should be able to use WriteBuffer.reserve to make sure there is enough room for everything ahead of time

18:54 <jemc> if you're calling `WriteBuffer.write` and you want it to be in the same chunk with something else, you're going to have to make it copy at that point anyway, so you wouldn't be avoiding a copy

19:07 <TwoNotes> For example, I am a big fan of key-value databases. Using WriteBuffer seems like a good way to replicate the Erlang "external binary format" coding.

19:08 <TwoNotes> One could also use JSON for that of course, if space is not such an issue

19:49 <TwoNotes> jemc, the copy that would be avoided was the one at the end, flattening all the chunks into one buffer, to be transmitted or stored all in one piece. Especially if a reasonable preallocation of the buffer had been done.

19:58 <felixgallo> oh how I wish function argument lists weren't so tightly bound to functions

19:59 <felixgallo> or, that the type inference engine was just a little more aggressive

20:00 <felixgallo> desired: fun derp({_}: Bool): Bool

21:04 <felixgallo> just accidentally reimplemented monads in pony

21:05 <felixgallo> not sure whether to be pleased or terrified

22:24 <jemc> TwoNotes: I'm saying that you're just moving the copy to the a different point in the process, not avoiding it

22:59 <felixgallo>