reformatted go recipes as well

recipes/go-recipes/blob.go

@@ -21,11 +21,11 @@
 package main
 
 import (
+	"fmt"
 	"github.com/apple/foundationdb/bindings/go/src/fdb"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
-	"fmt"
 )
 
 const CHUNK_SIZE int = 5
@@ -34,10 +34,12 @@ func write_blob(t fdb.Transactor, blob_subspace subspace.Subspace, blob []byte)
 
 	_, err = t.Transact(func(tr fdb.Transaction) (interface{}, error) {
 
-		if len(blob) == 0 { return nil, nil }
+		if len(blob) == 0 {
+			return nil, nil
+		}
 
-		for i := 0; i < len(blob); i+=CHUNK_SIZE {
+		for i := 0; i < len(blob); i += CHUNK_SIZE {
-			if i + CHUNK_SIZE <= len(blob) {
+			if i+CHUNK_SIZE <= len(blob) {
 				tr.Set(blob_subspace.Pack(tuple.Tuple{i}), blob[i:i+CHUNK_SIZE])
 			} else {
 				tr.Set(blob_subspace.Pack(tuple.Tuple{i}), blob[i:])
@@ -54,7 +56,7 @@ func read_blob(t fdb.ReadTransactor, blob_subspace subspace.Subspace) ([]byte, e
 
 		var blob []byte
 
-		ri := rtr.GetRange(blob_subspace, fdb.RangeOptions{}).Iterator();
+		ri := rtr.GetRange(blob_subspace, fdb.RangeOptions{}).Iterator()
 
 		for ri.Advance() {
 

recipes/go-recipes/doc.go

@@ -21,14 +21,14 @@
 package main
 
 import (
-	"fmt"
-	"io/ioutil"
-	"math/rand"
 	"encoding/json"
+	"fmt"
 	"github.com/apple/foundationdb/bindings/go/src/fdb"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
+	"io/ioutil"
+	"math/rand"
 )
 
 func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@@ -50,14 +50,15 @@ func print_subspace(trtr fdb.Transactor, sub subspace.Subspace) {
 	})
 }
 
-
 func _pack(t interface{}) []byte {
 	return tuple.Tuple{t}.Pack()
 }
 
 func _unpack(t []byte) tuple.Tuple {
 	i, e := tuple.Unpack(t)
-	if e != nil {return nil}
+	if e != nil {
+		return nil
+	}
 	return i
 }
 
@@ -67,7 +68,9 @@ const EmptyList int = -2
 func ToTuples(item interface{}) []tuple.Tuple {
 	switch i := item.(type) {
 	case []interface{}:
-		if len(i) == 0 {return []tuple.Tuple{tuple.Tuple{EmptyList}}}
+		if len(i) == 0 {
+			return []tuple.Tuple{tuple.Tuple{EmptyList}}
+		}
 		tuples := make([]tuple.Tuple, 0)
 		for i, v := range i {
 			for _, t := range ToTuples(v) {
@@ -76,7 +79,9 @@ func ToTuples(item interface{}) []tuple.Tuple {
 		}
 		return tuples
 	case map[string]interface{}:
-		if len(i) == 0 {return []tuple.Tuple{tuple.Tuple{EmptyObject}}}
+		if len(i) == 0 {
+			return []tuple.Tuple{tuple.Tuple{EmptyObject}}
+		}
 		tuples := make([]tuple.Tuple, 0)
 		for k, v := range i {
 			for _, t := range ToTuples(v) {
@@ -92,42 +97,52 @@ func ToTuples(item interface{}) []tuple.Tuple {
 
 func FromTuples(tuples []tuple.Tuple) interface{} {
 	//fmt.Println(tuples)
-	if len(tuples) == 0 {return nil}
+	if len(tuples) == 0 {
+		return nil
+	}
 	first := tuples[0]
-	if len(first) == 1         {return first[0]}
+	if len(first) == 1 {
-	if first[0] == EmptyObject {return make(map[string]interface{}, 0)}
+		return first[0]
-	if first[0] == EmptyList   {return make([]interface{}, 0)}
+	}
+	if first[0] == EmptyObject {
+		return make(map[string]interface{}, 0)
+	}
+	if first[0] == EmptyList {
+		return make([]interface{}, 0)
+	}
 
 	group := make(map[string][]tuple.Tuple)
 
 	for _, t := range tuples {
 		k := string(_pack(t[0]))
 		_, ok := group[k]
-		if !ok {group[k] = make([]tuple.Tuple, 0)}
+		if !ok {
+			group[k] = make([]tuple.Tuple, 0)
+		}
 		group[k] = append(group[k], t[0:len(t)])
 	}
 
 	switch first[0].(type) {
-		case int64:
+	case int64:
-			res := make([]interface{}, 0)
+		res := make([]interface{}, 0)
-			for _, g := range group {
+		for _, g := range group {
-				subtup := make([]tuple.Tuple, 0)
+			subtup := make([]tuple.Tuple, 0)
-				for _, t := range g {
+			for _, t := range g {
-						subtup = append(subtup, t[1:len(t)])
+				subtup = append(subtup, t[1:len(t)])
-				}
-				res = append(res, FromTuples(subtup))
 			}
-			return res
+			res = append(res, FromTuples(subtup))
-		default:
+		}
-			res := make(map[string]interface{})
+		return res
-			for _, g := range group {
+	default:
-				subtup := make([]tuple.Tuple, 0)
+		res := make(map[string]interface{})
-				for _, t := range g {
+		for _, g := range group {
-						subtup = append(subtup, t[1:len(t)])
+			subtup := make([]tuple.Tuple, 0)
-				}
+			for _, t := range g {
-				res[g[0][0].(string)] = FromTuples(subtup)
+				subtup = append(subtup, t[1:len(t)])
 			}
-			return res
+			res[g[0][0].(string)] = FromTuples(subtup)
+		}
+		return res
 	}
 }
 
@@ -140,23 +155,23 @@ func (doc Doc) InsertDoc(trtr fdb.Transactor, docdata []byte) int {
 	json.Unmarshal(docdata, &data)
 	docid := 0
 	switch d := data.(type) {
-		case map[string]interface{}:
+	case map[string]interface{}:
-			temp, ok := d["doc_id"]
+		temp, ok := d["doc_id"]
-			if !ok {
+		if !ok {
-				docid = doc._GetNewID(trtr)
+			docid = doc._GetNewID(trtr)
-				d["doc_id"] = docid
+			d["doc_id"] = docid
-			} else {
+		} else {
-				docid = temp.(int)
+			docid = temp.(int)
+		}
+		tuples := ToTuples(d)
+		trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
+			for _, t := range tuples {
+				tr.Set(doc.DocSS.Pack(append(tuple.Tuple{d["doc_id"]}, t[0:len(t)-1]...)), _pack(t[len(t)-1]))
 			}
-			tuples := ToTuples(d)
+			return nil, nil
-			trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
+		})
-				for _, t := range tuples {
-					tr.Set(doc.DocSS.Pack(append(tuple.Tuple{d["doc_id"]}, t[0:len(t)-1]...)), _pack(t[len(t)-1]))
-				}
-				return nil, nil
-			})
 	}
-		return docid
+	return docid
 }
 
 func (doc Doc) _GetNewID(trtr fdb.Transactor) int {
@@ -165,7 +180,9 @@ func (doc Doc) _GetNewID(trtr fdb.Transactor) int {
 		for true {
 			new_id = rand.Intn(100000007)
 			rp, err := fdb.PrefixRange(doc.DocSS.Pack(tuple.Tuple{new_id}))
-			if err != nil {continue}
+			if err != nil {
+				continue
+			}
 
 			res, err := tr.GetRange(rp, fdb.RangeOptions{1, -1, false}).GetSliceWithError()
 			if len(res) == 0 {
@@ -181,14 +198,18 @@ func (doc Doc) GetDoc(trtr fdb.Transactor, doc_id int) interface{} {
 	tuples := make([]tuple.Tuple, 0)
 	trtr.ReadTransact(func(tr fdb.ReadTransaction) (interface{}, error) {
 		kr, err := fdb.PrefixRange(doc.DocSS.Pack(tuple.Tuple{doc_id}))
-		if err != nil {panic(err)}
+		if err != nil {
+			panic(err)
+		}
 
 		items := tr.GetRange(kr, fdb.RangeOptions{}).Iterator()
 
 		for items.Advance() {
 			v := items.MustGet()
 			tup, err := doc.DocSS.Unpack(v.Key)
-			if err != nil {panic(err)}
+			if err != nil {
+				panic(err)
+			}
 			tuples = append(tuples, append(tup[1:len(tup)], _unpack(v.Value)))
 		}
 		return nil, nil
@@ -203,7 +224,9 @@ func main() {
 	db := fdb.MustOpenDefault()
 
 	DocDemoDir, err := directory.CreateOrOpen(db, []string{"docdemo"}, nil)
-	if err != nil {panic(err)}
+	if err != nil {
+		panic(err)
+	}
 
 	clear_subspace(db, DocDemoDir)
 

recipes/go-recipes/graph.go

@@ -21,12 +21,12 @@
 package main
 
 import (
+	"fmt"
 	"github.com/apple/foundationdb/bindings/go/src/fdb"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
 	"log"
-	"fmt"
 )
 
 func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@@ -50,8 +50,8 @@ func (graph *Graph) NewGraph(dir subspace.Subspace, name string) {
 
 func (graph *Graph) set_edge(trtr fdb.Transactor, node, neighbor int) (inter interface{}, err error) {
 	inter, err = trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
-		tr.Set(graph.EdgeSpace.Pack( tuple.Tuple{ node, neighbor } ), []byte(""))
+		tr.Set(graph.EdgeSpace.Pack(tuple.Tuple{node, neighbor}), []byte(""))
-		tr.Set(graph.InvSpace.Pack( tuple.Tuple{  neighbor, node } ), []byte(""))
+		tr.Set(graph.InvSpace.Pack(tuple.Tuple{neighbor, node}), []byte(""))
 		return nil, nil
 	})
 	return
@@ -59,8 +59,8 @@ func (graph *Graph) set_edge(trtr fdb.Transactor, node, neighbor int) (inter int
 
 func (graph *Graph) del_edge(trtr fdb.Transactor, node, neighbor int) (inter interface{}, err error) {
 	inter, err = trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
-		tr.Clear(graph.EdgeSpace.Pack( tuple.Tuple{ node, neighbor } ))
+		tr.Clear(graph.EdgeSpace.Pack(tuple.Tuple{node, neighbor}))
-		tr.Clear(graph.InvSpace.Pack( tuple.Tuple{  neighbor, node } ))
+		tr.Clear(graph.InvSpace.Pack(tuple.Tuple{neighbor, node}))
 		return nil, nil
 	})
 	return
@@ -70,10 +70,12 @@ func (graph *Graph) get_out_neighbors(trtr fdb.Transactor, node int) ([]int, err
 
 	val, err := trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
 
-		kr, err := fdb.PrefixRange(graph.EdgeSpace.Pack( tuple.Tuple{ node } ))
+		kr, err := fdb.PrefixRange(graph.EdgeSpace.Pack(tuple.Tuple{node}))
-		if err != nil { return nil, err }
+		if err != nil {
+			return nil, err
+		}
 
-		ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator();
+		ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator()
 		neighbors := make([]int, 0)
 
 		for ri.Advance() {
@@ -81,7 +83,9 @@ func (graph *Graph) get_out_neighbors(trtr fdb.Transactor, node int) ([]int, err
 			kv := ri.MustGet()
 
 			t, err := graph.EdgeSpace.Unpack(kv.Key)
-			if err != nil { return nil, err }
+			if err != nil {
+				return nil, err
+			}
 
 			neighbors = append(neighbors, int(t[1].(int64)))
 		}
@@ -94,10 +98,12 @@ func (graph *Graph) get_out_neighbors(trtr fdb.Transactor, node int) ([]int, err
 func (graph *Graph) get_in_neighbors(trtr fdb.Transactor, node int) ([]int, error) {
 	val, err := trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
 
-		kr, err := fdb.PrefixRange(graph.InvSpace.Pack( tuple.Tuple{ node } ))
+		kr, err := fdb.PrefixRange(graph.InvSpace.Pack(tuple.Tuple{node}))
-		if err != nil { return nil, err }
+		if err != nil {
+			return nil, err
+		}
 
-		ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator();
+		ri := rtr.GetRange(kr, fdb.RangeOptions{}).Iterator()
 		neighbors := make([]int, 0)
 
 		for ri.Advance() {
@@ -105,7 +111,9 @@ func (graph *Graph) get_in_neighbors(trtr fdb.Transactor, node int) ([]int, erro
 
 			t, err := graph.InvSpace.Unpack(kv.Key)
 
-			if err != nil { return nil, err }
+			if err != nil {
+				return nil, err
+			}
 
 			neighbors = append(neighbors, int(t[1].(int64)))
 		}
@@ -121,7 +129,9 @@ func main() {
 	db := fdb.MustOpenDefault()
 
 	GraphDemoDir, err := directory.CreateOrOpen(db, []string{"Graph"}, nil)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	clear_subspace(db, GraphDemoDir)
 
@@ -134,22 +144,30 @@ func main() {
 	g.set_edge(db, 1, 2)
 
 	i, err := g.get_out_neighbors(db, 0)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	fmt.Println(i)
 
 	_, err = g.del_edge(db, 0, 2)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	i, err = g.get_in_neighbors(db, 2)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	fmt.Println(i)
 
 	clear_subspace(db, GraphDemoDir)
 
 	i, err = g.get_in_neighbors(db, 2)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	fmt.Println(i)
 }

recipes/go-recipes/indirect.go

@@ -21,12 +21,12 @@
 package main
 
 import (
-	"log"
 	"fmt"
 	"github.com/apple/foundationdb/bindings/go/src/fdb"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
+	"log"
 )
 
 func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@@ -54,19 +54,23 @@ func _pack(t interface{}) []byte {
 
 func _unpack(t []byte) tuple.Tuple {
 	i, e := tuple.Unpack(t)
-	if e != nil {return nil}
+	if e != nil {
+		return nil
+	}
 	return i
 }
 
 type Workspace struct {
 	Dir directory.Directory
-	db fdb.Database
+	db  fdb.Database
 }
 
 func (wrkspc Workspace) _Update(trtr fdb.Transactor) {
 	trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
 		_, err := wrkspc.Dir.Remove(tr, []string{"current"})
-		if err != nil {log.Fatal(err)}
+		if err != nil {
+			log.Fatal(err)
+		}
 
 		_, err = wrkspc.Dir.Move(tr, []string{"new"}, []string{"current"})
 		return nil, err
@@ -80,7 +84,9 @@ func (wrkspc Workspace) GetCurrent() (dir directory.DirectorySubspace, err error
 
 func (wrkspc Workspace) Session(foo func(directory.DirectorySubspace)) (err error) {
 	newdir, err := wrkspc.Dir.CreateOrOpen(wrkspc.db, []string{"new"}, nil)
-	if err != nil {return}
+	if err != nil {
+		return
+	}
 	foo(newdir)
 	wrkspc._Update(wrkspc.db)
 	return
@@ -92,7 +98,9 @@ func main() {
 	db := fdb.MustOpenDefault()
 
 	WorkspaceDemoDir, err := directory.CreateOrOpen(db, []string{"Workspace"}, nil)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	clear_subspace(db, WorkspaceDemoDir)
 
@@ -108,7 +116,6 @@ func main() {
 
 	print_subspace(db, current)
 
-
 	w.Session(func(dir directory.DirectorySubspace) {
 		db.Transact(func(tr fdb.Transaction) (interface{}, error) {
 			tr.Set(dir.Pack(tuple.Tuple{"b"}), _pack("World"))
@@ -116,6 +123,8 @@ func main() {
 		})
 	})
 	current, err = w.GetCurrent()
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 	print_subspace(db, current)
 }

recipes/go-recipes/multi.go

@@ -34,13 +34,13 @@ func clear_subspace(db fdb.Transactor, ss subspace.Subspace) {
 	db.Transact(func(tr fdb.Transaction) (interface{}, error) {
 		tr.ClearRange(ss)
 		return nil, nil
-})
+	})
 	return
 
 }
 
 type MultiMap struct {
-	MapSS subspace.Subspace
+	MapSS    subspace.Subspace
 	Pos, Neg []byte
 }
 
@@ -72,13 +72,17 @@ func (multi MultiMap) MultiSubtract(trtr fdb.Transactor, index, value interface{
 func (multi MultiMap) MultiGet(tr fdb.ReadTransactor, index int) (ret []interface{}, e error) {
 	_, e = tr.ReadTransact(func(tr fdb.ReadTransaction) (interface{}, error) {
 		pr, err := fdb.PrefixRange(multi.MapSS.Pack(tuple.Tuple{index}))
-		if err != nil {return nil, err}
+		if err != nil {
+			return nil, err
+		}
 		kvs := tr.GetRange(pr, fdb.RangeOptions{0, -1, false}).GetSliceOrPanic()
 		ret := make([]interface{}, len(kvs))
 		i := 0
 		for _, kv := range kvs {
 			temp, err := multi.MapSS.Unpack(kv.Key)
-			if err != nil {return nil, err}
+			if err != nil {
+				return nil, err
+			}
 			ret[i] = temp[1]
 			i++
 		}
@@ -89,8 +93,10 @@ func (multi MultiMap) MultiGet(tr fdb.ReadTransactor, index int) (ret []interfac
 
 func (multi MultiMap) MultiGetCounts(trtr fdb.Transactor, index interface{}) (map[interface{}]int, error) {
 	i, e := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
-		kr, err := fdb.PrefixRange(multi.MapSS.Pack( tuple.Tuple{}))
+		kr, err := fdb.PrefixRange(multi.MapSS.Pack(tuple.Tuple{}))
-		if err != nil {return nil, err}
+		if err != nil {
+			return nil, err
+		}
 
 		ks, err := tr.GetRange(kr, fdb.RangeOptions{}).GetSliceWithError()
 
@@ -99,10 +105,12 @@ func (multi MultiMap) MultiGetCounts(trtr fdb.Transactor, index interface{}) (ma
 		for _, v := range ks {
 			bs := v.Value
 			k, err := multi.MapSS.Unpack(v.Key)
-			if err != nil {return nil, err}
+			if err != nil {
+				return nil, err
+			}
 			counts[k[1]] = 0
 			for i, j := 0, 1; i < len(bs); i++ {
-				counts[k[1]] += int(bs[i])*j
+				counts[k[1]] += int(bs[i]) * j
 				j = j << 4
 			}
 		}
@@ -113,7 +121,7 @@ func (multi MultiMap) MultiGetCounts(trtr fdb.Transactor, index interface{}) (ma
 
 func (multi MultiMap) MultiIsElement(trtr fdb.Transactor, index, value interface{}) bool {
 	item, _ := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
-		r := tr.Get(multi.MapSS.Pack(tuple.Tuple{ index, value } )).MustGet()
+		r := tr.Get(multi.MapSS.Pack(tuple.Tuple{index, value})).MustGet()
 		if r == nil {
 			return false, nil
 		}

recipes/go-recipes/priority.go

@@ -21,13 +21,13 @@
 package main
 
 import (
-	"log"
 	"fmt"
-	"math/rand"
 	"github.com/apple/foundationdb/bindings/go/src/fdb"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
+	"log"
+	"math/rand"
 )
 
 func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@@ -44,7 +44,9 @@ func _pack(t interface{}) []byte {
 
 func _unpack(t []byte) tuple.Tuple {
 	i, e := tuple.Unpack(t)
-	if e != nil {return nil}
+	if e != nil {
+		return nil
+	}
 	return i
 }
 
@@ -61,26 +63,38 @@ func (prty Priority) Push(trtr fdb.Transactor, value interface{}, priority int)
 
 func (prty Priority) _NextCount(trtr fdb.Transactor, priority int) int {
 	res, err := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
-		kr, e := fdb.PrefixRange(prty.PrioritySS.Pack( tuple.Tuple{priority} ))
+		kr, e := fdb.PrefixRange(prty.PrioritySS.Pack(tuple.Tuple{priority}))
-		if e != nil {return nil, e}
+		if e != nil {
+			return nil, e
+		}
 
 		ks, e := tr.Snapshot().GetRange(kr, fdb.RangeOptions{1, -1, true}).GetSliceWithError()
-		if e != nil {return nil, e}
+		if e != nil {
+			return nil, e
+		}
 
-		if len(ks) == 0 {return 0, nil}
+		if len(ks) == 0 {
+			return 0, nil
+		}
 		k, e := prty.PrioritySS.Unpack(ks[0].Key)
-		return k[0].(int)+1, nil
+		return k[0].(int) + 1, nil
 	})
-	if err != nil {return 0}
+	if err != nil {
+		return 0
+	}
 	return res.(int)
 }
 
 func (prty Priority) Pop(trtr fdb.Transactor, max bool) interface{} {
 	res, _ := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
 		ks, err := tr.GetRange(prty.PrioritySS, fdb.RangeOptions{1, -1, max}).GetSliceWithError()
-		if err != nil {return nil, err}
+		if err != nil {
+			return nil, err
+		}
 
-		if len(ks) == 0 {return nil, nil}
+		if len(ks) == 0 {
+			return nil, nil
+		}
 		tr.Clear(ks[0].Key)
 		return _unpack(ks[0].Value)[0], nil
 	})
@@ -90,22 +104,27 @@ func (prty Priority) Pop(trtr fdb.Transactor, max bool) interface{} {
 func (prty Priority) Peek(trtr fdb.Transactor, max bool) interface{} {
 	res, _ := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
 		ks, err := tr.GetRange(prty.PrioritySS, fdb.RangeOptions{1, -1, max}).GetSliceWithError()
-		if err != nil {return nil, err}
+		if err != nil {
-		if len(ks) == 0 {return nil, nil}
+			return nil, err
+		}
+		if len(ks) == 0 {
+			return nil, nil
+		}
 
 		return _unpack(ks[0].Value)[0], nil
 	})
 	return res
 }
 
-
 func main() {
 	fdb.MustAPIVersion(510)
 
 	db := fdb.MustOpenDefault()
 
 	PriorityDemoDir, err := directory.CreateOrOpen(db, []string{"Priority"}, nil)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	clear_subspace(db, PriorityDemoDir)
 

recipes/go-recipes/queue.go

@@ -21,15 +21,15 @@
 package main
 
 import (
+	"fmt"
 	"github.com/apple/foundationdb/bindings/go/src/fdb"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
 	"log"
-	"fmt"
 )
 
-type EmptyQueueError struct {}
+type EmptyQueueError struct{}
 
 func (q EmptyQueueError) Error() string {
 	return "Queue is Empty"
@@ -54,7 +54,9 @@ func (q *Queue) NewQueue(ss subspace.Subspace) {
 func (q *Queue) Dequeue(trtr fdb.Transactor) (interface{}, error) {
 	i, e := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
 		item, err := q.FirstItem(tr)
-		if err != nil {return nil, err}
+		if err != nil {
+			return nil, err
+		}
 		tr.Clear(item.(fdb.KeyValue).Key)
 		return item.(fdb.KeyValue).Value, err
 	})
@@ -64,12 +66,16 @@ func (q *Queue) Dequeue(trtr fdb.Transactor) (interface{}, error) {
 func (q *Queue) Enqueue(trtr fdb.Transactor, item interface{}) (interface{}, error) {
 	i, e := trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
 		index, err := q.LastIndex(tr)
-		if err != nil {return nil, err}
+		if err != nil {
+			return nil, err
+		}
 
 		ki, err := q.QueueSS.Unpack(index.(fdb.Key))
-		if err != nil {return nil, err}
+		if err != nil {
+			return nil, err
+		}
 
-		tr.Set(q.QueueSS.Pack(tuple.Tuple{ki[0].(int64)+1}), []byte(item.(string)))
+		tr.Set(q.QueueSS.Pack(tuple.Tuple{ki[0].(int64) + 1}), []byte(item.(string)))
 
 		return nil, nil
 	})
@@ -106,7 +112,9 @@ func main() {
 	db := fdb.MustOpenDefault()
 
 	QueueDemoDir, err := directory.CreateOrOpen(db, []string{"Queue"}, nil)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	clear_subspace(db, QueueDemoDir)
 
@@ -119,7 +127,9 @@ func main() {
 	q.Enqueue(db, "test3")
 	for i := 0; i < 5; i++ {
 		item, e := q.Dequeue(db)
-		if e != nil {log.Fatal(e)}
+		if e != nil {
+			log.Fatal(e)
+		}
 
 		fmt.Println(string(item.([]byte)))
 	}

recipes/go-recipes/table.go

@@ -21,12 +21,12 @@
 package main
 
 import (
-	"log"
 	"fmt"
 	"github.com/apple/foundationdb/bindings/go/src/fdb"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/directory"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/subspace"
 	"github.com/apple/foundationdb/bindings/go/src/fdb/tuple"
+	"log"
 )
 
 func clear_subspace(trtr fdb.Transactor, sub subspace.Subspace) error {
@@ -43,7 +43,9 @@ func _pack(t interface{}) []byte {
 
 func _unpack(t []byte) tuple.Tuple {
 	i, e := tuple.Unpack(t)
-	if e != nil {return nil}
+	if e != nil {
+		return nil
+	}
 	return i
 }
 
@@ -65,7 +67,7 @@ func (tbl Table) TableSetCell(trtr fdb.Transactor, row, column int, value interf
 }
 
 func (tbl Table) TableGetCell(trtr fdb.Transactor, row, column int) interface{} {
-	item, _:= trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
+	item, _ := trtr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
 		i := rtr.Get(tbl.row.Pack(tuple.Tuple{row, column})).MustGet()
 		return i, nil
 	})
@@ -75,7 +77,9 @@ func (tbl Table) TableGetCell(trtr fdb.Transactor, row, column int) interface{}
 func (tbl Table) TableSetRow(trtr fdb.Transactor, row int, cols ...interface{}) {
 	trtr.Transact(func(tr fdb.Transaction) (interface{}, error) {
 		kr, err := fdb.PrefixRange(tbl.row.Pack(tuple.Tuple{row}))
-		if err != nil {return nil, err}
+		if err != nil {
+			return nil, err
+		}
 
 		tr.ClearRange(kr)
 
@@ -90,10 +94,14 @@ func (tbl Table) TableSetRow(trtr fdb.Transactor, row int, cols ...interface{})
 func (tbl Table) TableGetRow(tr fdb.ReadTransactor, row int) ([]interface{}, error) {
 	item, err := tr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
 		kr, e := fdb.PrefixRange(tbl.row.Pack(tuple.Tuple{row}))
-		if e != nil {return nil, e}
+		if e != nil {
+			return nil, e
+		}
 
 		slice, e := rtr.GetRange(kr, fdb.RangeOptions{0, -1, false}).GetSliceWithError()
-		if e != nil {return nil, e}
+		if e != nil {
+			return nil, e
+		}
 
 		ret := make([]interface{}, len(slice))
 
@@ -103,17 +111,23 @@ func (tbl Table) TableGetRow(tr fdb.ReadTransactor, row int) ([]interface{}, err
 
 		return ret, nil
 	})
-	if err != nil {return nil, err}
+	if err != nil {
+		return nil, err
+	}
 	return item.([]interface{}), nil
 }
 
 func (tbl Table) TableGetCol(tr fdb.ReadTransactor, col int) ([]interface{}, error) {
 	item, err := tr.ReadTransact(func(rtr fdb.ReadTransaction) (interface{}, error) {
 		kr, e := fdb.PrefixRange(tbl.col.Pack(tuple.Tuple{col}))
-		if e != nil {return nil, e}
+		if e != nil {
+			return nil, e
+		}
 
 		slice, e := rtr.GetRange(kr, fdb.RangeOptions{0, -1, false}).GetSliceWithError()
-		if e != nil {return nil, e}
+		if e != nil {
+			return nil, e
+		}
 
 		ret := make([]interface{}, len(slice))
 
@@ -123,7 +137,9 @@ func (tbl Table) TableGetCol(tr fdb.ReadTransactor, col int) ([]interface{}, err
 
 		return ret, nil
 	})
-	if err != nil {return nil, err}
+	if err != nil {
+		return nil, err
+	}
 	return item.([]interface{}), nil
 }
 
@@ -133,7 +149,9 @@ func main() {
 	db := fdb.MustOpenDefault()
 
 	TableDemoDir, err := directory.CreateOrOpen(db, []string{"Graph"}, nil)
-	if err != nil {log.Fatal(err)}
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	clear_subspace(db, TableDemoDir)