00:40 <ada[m]> I've been trying to think about how I'd model different kinds of data using pony, and I haven't yet figured this one out yet. How would you implement an append-only log that needs to be readable from multiple actors? For example, a data-structure holding the history for a chat application.

00:42 <ada[m]> The best way I've come up with is just a ref holder object filled with val objects representing each individual method, but then you have to have an actor that gets queried for any data other actors are looking for. It seems like there might be a more elegant method.

01:44 <doublec> ada[m]: an actor representing the log, the readers have a reference to that actor?

01:45 <doublec> ada[m]: the readers can then call behaviours on the actor to get information

01:58 <ada[m]> for clarity, above where i said "individual method" I meant "individual message"

22:18 <adam_> Hello, this is all new and confusing. Need enlightenment.

22:19 <adam_> Attempted to modify examples/httpget to print the headers of request before being sent

22:20 <adam_> So, line 111, put "for (k, v) in req.headers().pairs() do _env.out.print(k + ": " + v) end"

22:21 <adam_> Which is what the code that deals with the response does. This fails to compile, and I don't really get how to fix.

22:21 <adam_> Error: /home/adam/ponyc/examples/httpget/httpget.pony:111:42: receiver type is not a subtype of target type for (k, v) in req.headers().pairs() do ^ Info: /home/adam/ponyc/examples/httpget/httpget.pony:111:34: receiver type: HashMap[String val, String val, HashEq[String val] val] tag for (k, v) in req.headers().pairs() do ^ /u

22:22 <adam_> That paste didn't work too well. Errors are

22:22 <adam_> Error: /home/adam/ponyc/examples/httpget/httpget.pony:111:42: receiver type is not a subtype of target type for (k, v) in req.headers().pairs() do

22:23 <adam_> Error: /home/adam/ponyc/examples/httpget/httpget.pony:111:9: cannot infer type of for loop iterator for (k, v) in req.headers().pairs() do

22:23 <adam_> Error: /home/adam/ponyc/examples/httpget/httpget.pony:112:37: cannot infer type of v _env.out.print(k + ": " + v)

22:23 <adam_> Error: /home/adam/ponyc/examples/httpget/httpget.pony:112:26: cannot infer type of k _env.out.print(k + ": " + v)

22:24 <adam_> Given that this is the same loop as used lower down, I presume that the latter errors are just artifacts of the initial error. However I don't understand the initial error at all. Could someone please help me start out here?

22:32 <jemc> adam_: welcome!

22:33 <jemc> the issue you're hitting has to do with reference uniqueness - just to set a baseline, are you already familiar with the uniqueness requirements of the `iso` and `trn` rcaps in Pony?

22:35 <adam_> I've read the tutorial, so I get what the ideas behind it are, but not sure how this works at all in practice

22:37 <jemc> great, thanks

22:37 <adam_> I think I need "recover" here, but my attempts to do so don't compile

22:38 <jemc> so, in this case, the details of what the rcaps are at any point in the snippet you're working with are hidden by type inference - which is good for succinctness and reducing clutter, but sometimes bad for understanding the rcap transitions involved

22:38 <jemc> so, let's start with `let req = Payload.request("GET", url)`

22:39 <jemc> without type inference, this would be expressed as: `let req: Payload iso = Payload.request("GET", url)`, because the `Payload.request` constructor is defined as `new iso request(method': String = "GET", url': URL = URL)`

22:40 <jemc> an `iso` reference is read-and-write-unique

22:41 <jemc> after the payload is built, it gets sent to the `HTTPClient`, with the line that reads `let sentreq = client(consume req, dumpMaker)`

22:42 <jemc> if we look at the definition of the `HTTPClient.apply` method, we can see that it accepts a `Payload trn`

22:43 <adam_> following so far...

22:44 <jemc> this means that when we `consume req`, we're saying - destroy this `Payload iso` reference, and return it as a `Payload trn` ephemeral reference (`trn^`), so it can be sent as the first argument to the `HTTPClient.apply` method

22:44 <jemc> later in the code, you'll notice that the `for (k, v) in response.headers().pairs() do` line is operating on a `Payload val`

22:46 <jemc> the way that loop works, it needs to create further references to data in the `Payload` that it can read from, in order to print out the data while the `response` reference continues to exist

22:47 <jemc> this would violate the read-uniqueness requirement imposed by `iso`, so you get a compiler telling you so (in admittedly indirect terms)

22:47 <jemc> `val` has no uniqueness requirements, and you can freely create `box` aliases of it to read from as much as you like

22:48 <jemc> `trn` has only write-uniqueness (not read-uniqueness) requirements, so you can also create `box` aliases of a `trn`

22:49 <jemc> Any aliases of an `iso` reference must be `tag` (neither readable nor writable) - `box` aliases are not allowed

22:49 <adam_> What is an alias here?

22:50 <jemc> another reference to the same object

22:51 <adam_> Very roughly, you mean I can use an 'iso' where a 'tag' is expected, but not where 'box' is?

22:52 <jemc> yes, exactly - with the additional detail that you can use `iso` as any other rcap *if you destroy your reference in the process* (using `consume`)

22:52 <adam_> got it

22:52 <adam_> From what I read, I thpught that I would want to lift the 'iso' reference to 'val' say, which I could then use in the loop

22:52 <jemc> so in this case, you can pretty easily make your snippet work by converting the `iso` to a `trn`, just before you need to read from it

22:53 <jemc> two quick comments on what you just said:

22:53 <jemc> 1) `iso` to `val` isn't a "lift" - it's actually dropping capabilities - the opposite direction from a lift

22:54 <jemc> 2) you wouldn't be able to use `val` in this context, since the call to `HTTPClient.apply` is expecting a `trn`, which you cannot get to from a `val`

22:55 <jemc> that is, if you dropped all the way down to `val`, you wouldn't be able to get back up to `trn`

22:55 <jemc> so instead, you just want to drop to `trn`, because that provides all you need in this case - being able to create readable (`box`) aliases

22:57 <jemc> you could do it like this: `let req' = consume trn req`

22:57 <jemc> (then use `req'` instead of `req` in all subsequent code)

22:58 <jemc> you could also say `let req': Payload trn = consume req`

22:58 <jemc> which would evaluate to the same thing

22:58 <jemc> just with inference happening in the other direction of the assignment

22:58 <adam_> Ok, that all makes sense, thanks

22:58 <jemc> no problem!

22:58 <endformationage> You might also note that the client returns the request as val. Of course you wouldn't get any rcap practice in. :P

23:00 <jemc> endformationage: ah, you're right - I didn't notice that detail of the API :D

23:00 <jemc> adam_: so you could simply move your printing snippet to after the call to `HTTPClient.apply`, and use `sentreq` instead of `req` or req'` :D

23:01 <endformationage> I was going to say earlier on but new you'd have a much more informative explaination! Always great as usual.

23:02 <jemc> heh, thanks

23:02 <endformationage> Maybe some day it'll cement enough in my head to provide one as well :/