Go has first-class functions, so you could write a library do the same thing with, yes, a few more declarations around it. In your example, .map { |i| i + 9 } is .map( func(i int) int { return i + 9 }), or .map(myFuncDefinedElsewhere) in most real-world scenarios.

As a commenter upthread pointed out, Go and serverside Javascript are aimed at very different use cases and audiences.

If you're looking for more elegant methods of expressing this in a higher performance runtime, here are two examples.

Erlang: [I+9 || I <- lists:seq(1,5), I >= 3] Haskell: [i+9 | i <- [1..5], i >= 3]

Like go, both Erlang and Haskell both have strong concurrency stories. For an I/O bound server in a production environment, Erlang is a very safe choice.

Compared to these list comprehensions, that ruby example looks unwieldy.

Go does not have the fascination with one-liners that Ruby has. Which is why I like Go.

In my experience, people who write in Go value code clarity over terseness.

Go's lack of type parametrisation makes many higher order functions really awkward. I'm no expert on Go, but below is my attempt at writing a generic Map function. As you can see, the code of the Map function itself isn't so bad (though there's a lot of noise in the declaration). Using that function however is really annoying, as you need to convert from the slice you have ([]string, []int, etc.) to an empty interface slice, and in the function you give to Map, you need to dispatch on the element's dynamic type. I think this is why Go people prefer to just use for loops and not do the whole higher-order combinators stuff.

    package main
    
    import (
	    "fmt"
    )
    
    
    func Map(fn func(interface{}) interface{}, xs []interface{}) []interface{} {
	    res := make([]interface{}, len(xs))
	    for i, x := range(xs) {
		    res[i] = fn(x)
	    }
	    return res
    }
    
    func main() {
	    words := []string{"foo", "bar", "baz"};
    
	    // First we need to create a version of words that has the []interface{} type.
	    interface_words := make([]interface{}, len(words))
	    for i, w := range(words) {
		    interface_words[i] = interface{}(w)
	    }
	    
	    fmt.Printf("%v\n", Map(
		    func(x interface{}) interface{} {
			    switch s := x.(type) {
			    case string:
				    return s + "!!"
			    }
			    return interface{}(0) // Need to please the compiler.
		    }, interface_words))
    }