初步想法，我希望有一个大概的设计,Linq是什么，这部分先不考究。
type User struct{
Id int
Name string
Birthday time.Time
}
From(userArr).Where(func(c interface{}) bool{
return c.Birthday > FormatBirthday("1989-01-17")
}).Select(func(c interface{}) interface{} {
return c.Name
})
假设From，Where，Select返回都是Queryable 一个struct；为了实现类似泛型的效果，Queryable 里面的值是interface{}；
type Queryable struct {
values []interface{}
}
From方法 构建这个Queryable
func From(input []interface{}) Queryable{
return Queryable{
values: input,
}
}
Where方法，传递一个用于比较的方法，而Golang没有lambda（例如 x=>x.A > 100），就用匿名函数代替，使得Where方法跟具体类型无关,此匿名方法返回bool；跟From返回的Queryable组成一条方法链。
func (in Queryable) Where(condition func(interface{})(bool)) (r Queryable){
for _,i := range in.values{
ok := condition(i)
if ok {
r.values = append(r.values,i)
}
}
return r
}
Select方法，跟Where类似，但返回值不是bool，而是Queryable。
func (in Queryable) Select(sel func(interface{}) interface{}) (r Queryable){
for _,i := range in.values{
r.values = append(r.values,sel(i))
}
return r
}
如果需要组合一个新的数据组合，需要匿名类型。
.Select(func(s interface{}) interface{} {
return struct{
Id int
Name string}{s.(User).Id, s.(User).Name}
})
这样就大致实现了 from p in list where p.A > 100 select p.Id的模式了，还少了一个orderby。
撇开Linq不谈，Golang对由特定用户类型组成的数组的某个（暂时仅仅1个字段）字段的排序，是需要为此用户类型实现Len,Less,Swap方法的，结合interface{},就很容易想到以下结构
type SortableQuery struct{
values []interface{}
}
func (list SortableQuery) Len() int{
return len(list.values)
}
func (list SortableQuery) Swap(i,j int){
list.values[i], list.values[j] = list.values[j], list.values[i]
}
//当写到Less方法的时候要考虑OrderBy方法的设计
func (list SortableQuery) Less(i,j int) bool
想想我们要实现OrderBy方法是让数组按内在元素的某个字段排序，使用的时候大概是
OrderBy(func(o interface) SortableQuery) SortableQuery{
return o.(User).Id
}
也就是说OrderBy的方法要传入一个方法：f。
f(values[i]) 获得上面代码的o.(User).Id，但这个返回值是不确定的，可能是string，暂时先实现int和string两种情况
func (in Queryable) OrderByDesc2(f func(interface{}) interface{}) (r SortableQuery) {
less := func(i,j int) bool{
switch reflect.ValueOf(f(in.values[i])).Kind(){
case reflect.Int:
o1 := f(in.values[i]).(int)
o2 := f(in.values[j]).(int)
return o1 > o2
case reflect.String:
o1 := f(in.values[i]).(string)
o2 := f(in.values[j]).(string)
return strings.Compare(o1,o2) == 1
default:
return false
}
return false;
}
r.less = less
r.values = in.values
sort.Sort(r)
return r
}
另外，如果不想把类型的变化封装到OrderByDesc函数，可以sort.less方法作为用户输入，在orderby方法里面实现；暂时认为这样灵活度是更高一点。
现在留下一些问题，例如延迟计算，待续。。。
最后，参考一下开源的实现
GitHub - ahmetalpbalkan/go-linq: .NET LINQ-like query methods for Go
