Go 实现Linq的探索-1

初步想法，我希望有一个大概的设计,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