Added more documentation for queries that take callbacks

Author: dancannon

query_aggregation.go

@@ -7,8 +7,15 @@ import (
 // Aggregation
 // These commands are used to compute smaller values from large sequences.
 
-// Produce a single value from a sequence through repeated application of a
-// reduction function
+// Reduce produces a single value from a sequence through repeated application
+// of a reduction function
+//
+// It takes one argument of type `func (r.Term, r.Term) interface{}`, for
+// example this query sums all elements in an array:
+//
+//     r.Expr([]int{1,3,6}).Reduce(func (left, right r.Term) interface{} {
+//         return left.Add(right)
+//     })
 func (t Term) Reduce(args ...interface{}) Term {
 	return constructMethodTerm(t, "Reduce", p.Term_REDUCE, funcWrapArgs(args), map[string]interface{}{})
 }

query_control.go

@@ -220,7 +220,14 @@ func Branch(args ...interface{}) Term {
 	return constructRootTerm("Branch", p.Term_BRANCH, args, map[string]interface{}{})
 }
 
-// Loop over a sequence, evaluating the given write query for each element.
+// ForEach loops over a sequence, evaluating the given write query for each element.
+//
+// It takes one argument of type `func (r.Term) interface{}`, for
+// example clones a table:
+//
+//     r.Table("table").ForEach(func (row r.Term) interface{} {
+//         return r.Table("new_table").Insert(row)
+//     })
 func (t Term) ForEach(args ...interface{}) Term {
 	return constructMethodTerm(t, "Foreach", p.Term_FOR_EACH, funcWrapArgs(args), map[string]interface{}{})
 }

query_transformation.go

@@ -2,7 +2,15 @@ package gorethink
 
 import p "github.com/dancannon/gorethink/ql2"
 
-// Transform each element of the sequence by applying the given mapping function.
+// Map transform each element of the sequence by applying the given mapping
+// function. It takes two arguments, a sequence and a function of type
+// `func (r.Term) interface{}`.
+//
+// For example this query doubles each element in an array:
+//
+//     r.Map([]int{1,3,6}, func (row r.Term) interface{} {
+//         return row.Mul(2)
+//     })
 func Map(args ...interface{}) Term {
 	if len(args) > 0 {
 		args = append(args[:len(args)-1], funcWrapArgs(args[len(args)-1:])...)
@@ -11,7 +19,14 @@ func Map(args ...interface{}) Term {
 	return constructRootTerm("Map", p.Term_MAP, funcWrapArgs(args), map[string]interface{}{})
 }
 
-// Transfor >m each element of the sequence by applying the given mapping function.
+// Map transforms each element of the sequence by applying the given mapping
+// function. It takes one argument of type `func (r.Term) interface{}`.
+//
+// For example this query doubles each element in an array:
+//
+//     r.Expr([]int{1,3,6}).Map(func (row r.Term) interface{} {
+//         return row.Mul(2)
+//     })
 func (t Term) Map(args ...interface{}) Term {
 	return constructMethodTerm(t, "Map", p.Term_MAP, funcWrapArgs(args), map[string]interface{}{})
 }