00:32 <smandy> HI all, Just trying to compile helloworld on arch. get "helloWorld.pony: couldn't locate this path"

00:32 <smandy> any ideas?

00:33 <smandy> cmd is ponyc helloWorld.pony, helloWOrld.pony is verbatim from the documentation.

00:44 <jemc> smandy: this a common trip-up for folks who are used to C compilers - Pony doesn't compile files, it compiles a directory

00:44 <jemc> so, when you do `ponyc helloWorld.pony`, it's looking for a subdirectory named `helloWorld.pony` in your current working directory

00:46 <jemc> what you probably want is to run `ponyc` without arguments to compile all files in the current directory, or something like `mkdir helloWorld && mv helloWorld.pony helloWorld/main.pony && ponyc helloWorld` if you want to put the file in its own subdirectory to isolate it from other examples you may want to have in your current working directory

00:47 <jemc> `ponyc --help` can give you info on additional options, like specifying where your output binary should go, if you care about that

14:27 <adam_> What is the correct way to turn a ByteSeq into a string? It seems I have to do a match like "match byte_seq | let s: String => s | let a: Array[U8 val] val => String.from_array(a) end"

14:27 <adam_> But that seems rather complicated for this

14:40 <Praetonus> adam_: That's the correct way. Whenever you need to downcast an object (i.e. go from a given type to a more specific subtype), you have to use a match expression

14:40 <jemc> adam_: there's not a better way currently, though it seems to me that adding `String.from_byte_seq` would be a nice addition

14:42 <jemc> though I suppose that's not as straightforward as it sounds - if it's a constructor it would be forced to allocate a *new* `String` object, which isn't what we want

14:43 <jemc> (and if it's not a constructor you'd be forced to allocate a new `String` just to be able to call the method)

14:46 <adam_> I see there is a Stringable interface, I would think the nicest way would be that both String and Array[U8] being Stringable, and that their union ByteSeq should be too by inference.

14:48 <jemc> adam_: unfortunately, we don't currently have a way to define a method for only some special cases of a generic type - so we couldn't define `Array[U8].string` without also defining it for `Array[F64]`, `Array[String]`, `Array[Foo]`, etc

14:49 <jemc> that feature is actualy on our roadmap, though even when we have it I'm not totally sure that would be the best meaning of the `string` method for `Array[U8]`

14:50 <jemc> I'd expect `Array[U8].string` to give output like: `[1; 2; 3]`, instead of converting the byte sequence to a string

14:51 <jemc> that is, I'd want to define `Array[A].string` for cases where `A <: Stringable` to print an array representation where each element is the displayed as its `string` representation

14:54 <adam_> I see, although I'd want to call that "show"

14:55 <adam_> Thanks, I just wanted to check whether I was missing something or not.

15:32 <joncfoo> just curious - is there a particular reason why Env.vars() returns an array of strings instead of a map?

15:47 <SeanTAllen> joncfoo: i'm not aware of one. that's an interesting possible change. are you familiar with the RFC process? its perfect for getting that sort of change through.

15:47 <SeanTAllen> https://github.com/ponylang/rfcs/blob/master/README.md

16:03 <jemc> joncfoo, SeanTAllen: one issue with making it a `Map` is that `Map` is in the `collections` package - we don't want anything in `builtin` to depend on another package

16:04 <jemc> however, making it an `Array[(String, String)]` instead of `Array[(String)]` would likely be a good choice, and would be easily convertible to a `Map` in a simple line

16:05 <jemc> that is, you could get a `Map` out of it with a line like: `let map = Map[String, String].concat(env.vars().values())`

16:08 <jemc> joncfoo: however, if you're just looking for a turnkey solution right now, check out the `cli.EnvVars` type, which was added recently to the stdlib: https://github.com/ponylang/ponyc/blob/master/packages/cli/env_vars.pony

16:09 <jemc> it's a nice little utility (thanks, cquinn!) for converting the `env.vars()` to a `Map`, and also includes some other nifty optional features (see the docstring)

16:11 <joncfoo> thanks jemc, for now I simply hacked up the following: https://is.gd/LPMOCE

16:12 <joncfoo> I think perhaps changing Env.vars() to return Array[(String, String)] would be reasonable

16:12 <joncfoo> SeanTAllen: I'm not familiar with the RFC proceess but will have a look. Thanks!

16:22 <adam_> Elapsed time, 18 hours

16:22 <adam_> src/libponyc/pass/scope.c:19: set_scope: Assertion `ast_id(name) == TK_ID` failed.

16:23 <adam_> Does this really happen that often?

16:29 <adam_> The following crashes the compiler

16:29 <adam_> use "itertools"

16:29 <adam_> actor Main new create(env: Env) => let plop = Filter[(F64 | None)](Array[(F64|None)].create().values(), {(x) => match x | (let f: F6 4) => true | (let n:None) => false end})

16:30 <adam_> oops, that has some extra spaces, should read:

16:30 <adam_> actor Main new create(env: Env) => let plop = Filter[(F64 | None)](Array[(F64|None)].create().values(), {(x) => match x | (let f: F64) => true | (let n:None) => false end})

16:31 <adam_> 0.14.0-f70dba0 [release] compiled with: llvm 3.9.1 -- cc (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609

16:34 <adam_> Shorter:

16:34 <adam_> actor Main new create(env: Env) => Filter[F64](Array[F64].create().values(), {(x) => match x end})

16:37 <endformationage> adam_: I'll defer debuging of your example to the experts, though it looks like a compiler bug to me. You may find http://playground.ponylang.org/ helpful for sharing code, it's great!

16:38 <Praetonus> Compiler assertion failures definitely are bugs

16:39 <Praetonus> adam_: Can you open a Github issue with the minimal case and the backtrace printed by the compiler on the assertion failure?

16:41 <joncfoo> Is there a collection of publicly available libraries for pony posted somewhere?

16:44 <adam_> Praetonus, done. Minimal example is indeed rather minimal

16:44 <adam_> https://github.com/ponylang/ponyc/issues/1990

16:45 <Praetonus> Thank you

16:45 <SeanTAllen> @joncfoo not really. im planning on adding to the website. there's the wiki on ponyc repo but its not really up todate. you can also check the "pony language" label on github

16:50 <jemc> joncfoo: here's how to see all repos on github with that "topic" label: https://github.com/search?q=topic%3Apony-language&type=Repositories

16:51 <adam_> If I have an Array[(X | None)], what's a sensible way to get an Array[X] of non-none entries?

16:54 <jemc> adam_: the "simple" way would be something like `let array' = Array[X]; for x in array.values() do try array'.push(x as X) end end`

16:55 <adam_> Ok. I was trying to do this in a functional fashion, and couldn't work it out. That, though slightly yucky, seems the better approach

16:56 <jemc> if you want something more functional in style, you could probably put together something using the `itertools` package

17:00 <adam_> I can filter out those entries which are None, so I have an Array[(X|None)] where I know every entry is in-fact X. But how do I map (X|None) to X, swallowing those errors that I know will not occur. The compiler insisted I need a try block, which would then need a default value, which I would prefer not to have.

17:06 <jemc> adam_: you're talking about the `itertools` package now?

17:08 <jemc> yeah, looking through that API, it looks like it needs another API method, or a modification of the `filter` method that knows how to filter by type and produce an iterator of the refined type

17:17 <adam_> and it would have to do that by the iterative pushing back on an array?

17:18 <jemc> adam_: sorry, not sure what you're asking

17:32 <jemc> adam_: actually, a correction - I'm not very familiar with the itertools API, but there is actually already a way to do it

17:35 <jemc> `iter.map[X]({(x: (X | None)): X ? => x as X }` should do it

22:07 <adam_> At runtime, given some value of a union type, is there a way to print it's type without manually writing a case statement?

22:49 <SeanTAllen> adam_: nope