ToSlice dose not re-empty the dist slice about go-linq

[ahmetb]

In this case, I think the documentation is good enough but since apparently people can easily do this mistake, we can just say it does not clear the existing slice.

[ahmetb]

cc: @kalaninja any ideas?

[kalaninja]

Yes, it is not a bug. The idea is that the go-linq user prepares the storage and decides whether to clean it or not. I thought that it is quite obvious from the doc, since here is nothing about cleaning the result slice:

ToSlice iterates over a collection and populates result slice

But If it is not, I may document this behaviour. what do you think @ahmetalpbalkan ?

[ahmetb]

This is like pre-populating a struct's fields and then saying json.Unmarshal(b, &v) is not clearing the fields which were set previously and missing from the unmarshaled json object. I think our design is just fine.

[cleitonmarx]

What about to add a new method AppendToSlice (with same behavior of actual ToSlice function) and change the ToSlice behavior to set the result pointer to a new slice pointer as proposed here #46?

[ahmetb]

@cleitonmarx I can't think of a case of why someone would pass us a slice to be replaced with a new slice instance. What would be a good use case for that?

[aisk]

@ahmetalpbalkan Hi I have a question, if I have a list of whatever, I want to order them "in place" like this:

l := []string{"foo", "bar", "baz"}
l = linq.From(l).Results()

then go will complains:

cannot use linq.From(l).Results() (type []interface {}) as type []string in assignment

So I added the .([]string) like this:

l := []string{"foo", "bar", "baz"}
l = linq.From(l).Results().([]string)

but go still complains:

invalid type assertion: linq.From(l).Results().([]string) (non-interface type []interface {} on left)

So I need the ToSlice function to do this, or is there some way to do this better which I am missing?

[cleitonmarx]

@ahmetalpbalkan As a ".NET LINQ-like" library, I think that the behavior of ToSlice should be the same as the original LINQ ToList. In ToList implementation the return is always a new instance.
A good use case is ordering a slice using linq (example found here):

using C#:

options = options.OrderBy(o => o.Position).ToList();

using Go:

From(options).OrderBy(func(o interface{}) interface{}{
  return o.(Option).Position
}).ToSlice(&options)

Currently, the code in Go will not have the same result of the C# code. My Pull Request tries to fix that.

[kalaninja]

@aisk Yes, you have to use ToSlice function.

result := []string{}
l := []string{"foo", "bar", "baz"}
linq.From(l).OrderBy(func(a interface{}) interface{}{
  return true;
}).ToSlice(&result)

[aisk]

@kalaninja Yes I am writing codes like what you pasted, and then this pull request is created ...

Now I am created a new slice to receive the result. But as you know, naming a variable is hard in software engineering... So I think is more convenient if we had a new method (or change the ToSlice's behavior).

[kalaninja]

@aisk I understand your concerns, here is what I offer.

[ahmetb]

BTW the work to redefine ToSlice() is actively ongoing at #46. @aisk we now empty the passed slice and shrink/grow it based on the result size. It'll be available in v3.0 release.

[aisk]

@ahmetalpbalkan great!

[ahmetb]

Fixed in v3-dev branch.