07:50 <sjums> just read the first few tutorial pages, and I'm kinda hooked!

07:50 <sjums> Be prepared for a bunch of stupid questions in the following time :3

13:22 <SeanTAllen> awesome sjums

20:30 <SeanTAllen> jemc: we wrote a split_in_place ala trim_in_place, just PR it?

20:54 <jemc> SeanTAllen: what does it mean to "split in place"? the result of a split operation is an Array[String], so I don't understand how it could be "in place", which implies it mutates the original

21:49 <SeanTAllen> You only do it on a val. You get back an array of string val without allocating new memory jemc.

21:50 <SeanTAllen> Perhaps a better name?

21:50 <doublec> How does that work if strings are null terminated?

21:55 <jemc> SeanTAllen: yeah, that doesn't sound like "in place" to me

21:56 <jemc> SeanTAllen: the reason I used the term `trim` in my RFC was to differentiate from the existing `slice` method

21:56 <jemc> that is, `trim` was the zero-copy equivalent of the `slice` operation

21:57 <jemc> and `trim` is the one that operates on a `val`, while `trim_in_place` operates on a `ref`

21:58 <jemc> so following that convention, I would expect the new method you're proposing to use a different term (other than `split`) or to change the name of the current `split` method to use a different term

21:59 <jemc> I'm not totally sure what that term should be, in either case

21:59 <jemc> doublec: the resulting strings would not be null-terminated (except the last one)

22:00 <jemc> doublec: String now has methods for checking/ensuring that a String is null terminated before passing it to FFI

22:00 <doublec> jemc: ah, i'm out of date, thanks :)

22:02 <jemc> no worries - this was relatively recently added (though the RFC is kind of old)

22:02 <jemc> anyway, in practice it's not *that* often that you need to pass a String to an FFI that is not length-specified

22:03 <jemc> and we shouldn't be crippling performance of other uses of String for those needs

22:06 <SeanTAllen> jemc: so perphaps new one is split (on val) and old is "split_in_place" on ref and split_in_place creates new strings when splitting?

22:09 <jemc> I don't think "in place" makes sense when the receiver isn't mutated - to me, that's the essence of what "in place" tells you in a method name

22:09 <jemc> however, something like `split_copy` or `split_clone` could make sense

22:11 <doublec> split_view, split_shared, split_slice?

22:12 <jemc> possibly `split_trim` could be the `val` version, referencing the fact that it operates the same as if you had called `trim` a bunch of times

22:16 <SeanTAllen> we could have some fun ruby shorthand like ? ! # and what not...

22:16 <SeanTAllen> im half joking and half serious

22:16 <doublec> Coming from scheme and dylan I'm used to that and like it