12:17 <svenskunganka> Hi! I'm getting an odd error when compiling which I'm unsure why. I have this code: fun compare(buf: Array[U8] val): Bool val ? => false

12:17 <svenskunganka> But it gives this error: function signature is marked as partial but the function body cannot raise an error

12:17 <Candle> svenskunganka: The '?' marks it as partial.

12:18 <svenskunganka> But simply returning `false` shouldn't raise an error though?

12:18 <Candle> svenskunganka: There's nowhere in the function body that can raise an error since the entire body is 'return false'

12:18 <svenskunganka> Oooh so that's what it means

12:19 <svenskunganka> So a partial function must contain code that can raise an error

12:19 <Candle> Yes.

12:22 <vaninwagen> svenskunganka: but you are able to inherit partial functions with a total function that does not raise an error

12:23 <vaninwagen> So you are flexible in that respectt

12:24 <svenskunganka> So a trait that requires implementing a partial function can be replaced with a total function and it will satisfy?

12:27 <vaninwagen> Yeah, just dont put the questionmark

12:27 <svenskunganka> Hmm that results in error "try expression never results in an error"

12:29 <svenskunganka> But it's probably a bad implementation either way so I'll just scrap that code :P

12:33 <svenskunganka> So far I really like Pony, and the performance is brilliant. The library I'm building currently does magic number checking for 31 filetypes and the benchmark says it takes 140ns to check against all of them, and 0ns to check against a specific one :D

12:33 <svenskunganka> Ill paste what I wanted to do

12:36 <svenskunganka> https://gist.github.com/Svenskunganka/7b9c39f7d2be17434af6ae99408c0af2

12:38 <svenskunganka> Basically I wanted to allow those that want to extend the library with their own matchers to not have to wrap all their code in try...end, which is just dumb magic

12:44 <svenskunganka> Anyhow, the diff between them looks like this now: https://gist.github.com/Svenskunganka/c02033e908bd0cf48c8f31c4b5da4dad

13:09 <vaninwagen> So glad you like it

13:10 <vaninwagen> So if you have an imolementation of a compare function that does not throw am error, then you can just leave out the question mark

13:14 <vaninwagen> Having a non partialapply in your case makes sense to me

13:19 <svenskunganka> I think so too. Finally got some time over to continue where I left off with this library. Got about 70 matchers left to write and tests against fixtures and it should be ready to be published

13:22 <svenskunganka> Really the only problem I've had learning Pony so far has been some words in the tutorials. As a non-native English speaker I had to look up some of them. Reference capabilities are surprisingly simple

13:25 <vaninwagen> If you have something concrete we could improve feel free to write an issue

13:25 <vaninwagen> Wow, you are the first one that didnt stumble learning refcaps, thats awesome

13:25 <vaninwagen> *the first one i met

13:28 <svenskunganka> The "Safely Sharing Data: Reference Capabilities in Pony" and "Bang, Hat and Arrow in Pony" blogposts explains refcaps really well. Without them I probably would be having making death threats at the compiler

13:30 <svenskunganka> Next library after this one for learning purposes will be trying to implement Cap'n Proto, which I'm grossly unqualified for but I want to make an attempt

13:30 <vaninwagen> I also really like them, thanks doublec

13:30 <vaninwagen> Sadly there is already https://github.com/jemc/pony-capnp

13:38 <svenskunganka> That's great though, I've been planning a project that needs something like Cap'n Proto. If I recall correctly, I think I've read that the Pony runtime will eventually be able to be distributable, or have I read wrong?

13:39 <svenskunganka> As in calling actors on remote machines

13:40 <svenskunganka> A runtime-powered RPC system of sorts

13:45 <svenskunganka> Ah, found it: https://github.com/ponylang/ponyc/issues/278

13:54 <svenskunganka> Also, I've been wondering if you have a trait that requires a function to be implemented with type restrictions, why does a type that implements that method also have to define the same type restrictions (on parameters and return types)?

13:54 <svenskunganka> function*

13:57 <svenskunganka> E.g `trait SayHello` has `fun hello(s: String): None` as type annotations, then the same function definition for `class Someone is SaysHello` also needs to annotate those types

13:58 <svenskunganka> Is it a consistency thing or technical?

14:09 <SeanTAllen> I dont understand your question svenskunganka

14:10 <SeanTAllen> the last one you asked.

14:10 <SeanTAllen> sorry, can you rephrase?

14:18 <svenskunganka> Yes of course. When you inherit a Trait that says you need to implement `fun hello(s: String)`, shouldn't you also inherit the type annotations so you only need to write `fun hello(s)`

14:22 <svenskunganka> Example: https://playground.ponylang.org/?gist=3b046c2927bd5640c9b47497e877b29a

14:35 <svenskunganka> I guess it makes the code less readable, needing to look up the trait definition to find out what types are refcaps are accepted

14:36 <svenskunganka> and*

14:45 <svenskunganka> Well, I need to leave now. Thank you vaninwagen for being so helpful and for the enjoyable chat!

17:02 <endformationage> LOL, using `Debug` in a trait/inteface is confusing. Compiler will complain about not finding `Debug` even when a `use "debug"` statement is included where the subtype is defined.

17:02 <endformationage> This will occur as many times the subtype is used throughout the code base, as any file defining types which make use of the subtype also need a `use "debug"` statement.

17:03 <endformationage> This may be normal / not limited to Debug either?

17:04 <endformationage> The confusing bit being the error messages only point to the use of Debug in the one file where the subtype is defined.

17:05 <endformationage> The hint I got was the number of duplicate error messages was the number of times the subtype was used throughout the codebase.

17:07 <endformationage> The confusing bit being ... , and that `use "debug"` was already defined there.

18:40 <vaninwagen> endformationage: there is an issue for that, that i cant find right now

18:40 <vaninwagen> Stumbled upon that myself already

18:41 <vaninwagen> Default implementations in traits are copied over without the necessary use statements

18:58 <vaninwagen> Here it is: https://github.com/ponylang/ponyc/issues/2150

19:00 <vaninwagen> svenskunganka it might be considered verbose at some point, but i think it makes sense to require fully "typed" function signatures every time. If only from a documentation standpoint, but there are other valid concerns here too

19:04 <vaninwagen> Damn, searching for it i found so many issues i'd love to have closed

19:07 <endformationage> vaninwagen: Cool.