package main
import "fmt"
type intSlice []int
func (i intSlice) collect(block func(i int) int) intSlice {
r := make(intSlice, len(i))
for j, v := range i {
r[j] = block(v)
}
return r
}
func main() {
numbers := intSlice{1, 2, 3}
squared := func(i int) int { return i * i }
fmt.Printf("%v", numbers.collect(squared))
}
Implementations of select,inject,detect are left as an excercise for the reader.
Today, I was playing with Otto and hacked together a small command-line-interface program in Go.
package main
import (
"bufio"
"fmt"
"os"
"strings"
"github.com/robertkrimen/otto"
)
var Otto = otto.New()
func main() {
fmt.Println("otto\n")
loop()
}
func dispatch(entry string) string {
if len(entry) == 0 {
return entry
}
value, err := Otto.Run(entry)
if err != nil {
return err.Error()
} else {
return fmt.Sprintf("%v", value)
}
}
func loop() {
for {
fmt.Print("> ")
in := bufio.NewReader(os.Stdin)
entered, err := in.ReadString('\n')
if err != nil {
fmt.Println(err)
break
}
entry := strings.TrimLeft(entered[:len(entered)-1], "\t ") // without tabs,spaces and newline
output := dispatch(entry)
if len(output) > 0 {
fmt.Println(output)
}
}
}
One cool feature of Otto is the ability to expose your own Go functions in the Javascript namespace. This example below adds the function log to print its arguments using the standard log package.
These are the results of exploring one aspect of the Go language; functions can return multiple values. Consider the following simple function:
func ab() (a,b int) {
a,b = 1,2
return
}
Clearly, this function cannot be used in other function calls that expect a single value.
fmt.Printf("%v\n",ab())
The compiler will help you: “multiple-value ab() in single-value context”.
Now suppose you want to take only the first value without introducing an intermediate variable. One possible solution might be to create this helper function:
Update: Based on several comments posted on the Google+ Go community, I rewrote the solution presented here. See past the Conclusion section.
Recently, I was asked to write a small program for collecting product promotion information for a large collection of products. Given an input file of product identifiers, the following tasks had to be done:
A straightforward implementation is to write a function for each task and call them in a nested loop. For this program, I created functions such that the basic flow is quite simple.
Hopwatch is an experimental tool that can help debugging Go programs. Unlike most debuggers, hopwatch requires you to insert function calls at points of interest in your program. At these program locations, you can tell Hopwatch to display variable values and suspend the program (or goroutine). Hopwatch uses Websockets to exchange commands between your program and the debugger running in a HTML5 page.
package main
import "github.com/emicklei/hopwatch"
func main() {
for i := 0; i < 6; i++ {
hopwatch.Display("i",i)
j := i * i
hopwatch.Display("i",i, "j", j ).Break(j > 10)
hopwatch.Break()
}
}
Starting your Go program that includes a Hopwatch function call waits for a connection to the debugger page. You can disable Hopwatch by passing the command line parameters -hopwatch false.
In an earlier post, I discussed an example of using plain functions as objects. Today, I investigated solutions for using Methods as objects. As I understand it, Go methods are functions that are “bound” to a named type that is not a pointer or an interface.
package main
import "fmt"
type T struct {
S string
}
func (t T) GetS1() string {
return t.S
}
func (t *T) GetS2() string {
return t.S
}
func main() {
t := T{"hello"}
f := (*T).GetS1
g := (T).GetS1
h := (*T).GetS2
// i := (T).GetS2 // invalid method expression T.GetS2 (needs pointer receiver: (*T).GetS2)
fmt.Printf("%v, %v %v, who is there?", f(&t) ,g(t), h(&t))
}
Run it yourself.
In a previous post, I discussed the design of go-restful which is a package for building REST-style WebServices using the Google Go programming language.
Today, I completed the implementation of that package which provides the basics:
package userservice
import (
"github.com/emicklei/go-restful"
"log"
)
type User struct {
Id, Name string
}
Type User represents our domain object.
Today, I played with functions as objects in the Go programming language. If functions are first class citizens in Go then it must be possible to store them in fields of a struct, pass them as arguments to other functions and use them as return values of other functions.
So I visited play.golang.org for putting together a simple program that demonstrates this.
package main
import "fmt"
func CallWith(f func(string), who string) {
f(who)
}
type FunctionHolder struct {
Function func(string)
}
func main() {
holder := FunctionHolder{ func(who string) { fmt.Println("Hello,", who) }}
CallWith(holder.Function,"ernest")
}
On play.golang.org can run this program yourself
I have been using JAX-RS for many REST-based service implementations in Java.
As part of my journey into the Google Go programming language, I am exploring designs for such REST support using the standard net/http package in Go.
JAX-RS provides a set of Annotation classes which can be used to add meta-data to classes, methods and method arguments. In JAX-RS these annotation are used to specify the mapping between a Http Request to a Java method and its arguments.
I started working on this “yet-another-web-server” project for one of the most important reasons: because its fun. I got inspired for doing this after reading about the Netty framework and all the positive reviews that people write.
My requirements for this server are
The project is hosted on googlecode. Have a look at the example project that demonstrates all the features.