[go-nuts] Printing slice without the '[' ']'

http://play.golang.org/p/sk6JKiN6qQ

helper function which could be modified to specify formatting

http://play.golang.org/p/-OBvk2VVv0

http://play.golang.org/p/qeI6AJ74-E

David

My aim is to reduce the number of calls to fmt.----

I think that should reduce the number of i/o events and context switches
which is the real aim

printing in a loop doesn't address the original question of a Go syntax,
which it seems there isn't one. I was hoping something of the varidic
variety existed

Those two operations sound unrelated. Do you need to use a buffered writer ?

calls to printf and scanf involve asking the operating system to do
something on your behalf as I recall. I don't see how Go could do it
otherwise.

Imagine printing 1MM floats with 1MM printf's...

I'd guess there is some buffering going on somewhere,
but I recall it being faster to build large strings in memory
and then print that out with one call to printf

Anyhow, I was originally looking for some sweet gopher magic on the syntax
side of this.

btw, I heard that Go's syntax is in part based on the Limbo scripting
language from Inferno

I haven't looked at the implementation of Printf, but there's usually
buffering in between. It's entirely possible that Printf buffers the entire
output in memory and then makes one Write call. Or maybe it buffers in 32k
chunks or something. And at a higher level, the output streams might buffer
in memory before writing to the OS's streams.

I think you're over-optimizing. Do it in a way that makes sense to you,
then if it's too slow you can profile it and find out where the bottlenecks
are. As David said, formatted IO is pretty CPU-intensive to begin with.

--Jens

anything you do with fmt (and consequently reflection) will be much
more computationally expensive than reslicing the result to
[1:len()-1] to remove the square brackets.

btw, limbo is not a scripting language.

cheers!

It's not documented but yes, Printf etc. do a single write system call for
each call, which means they buffer it all up first. (I have been bothered
too many times in the past by C's printf intertwingling my output.)

Perhaps this should be documented, or perhaps it should not, so we can
flush partial results to avoid blowups.

-rob

Calling to fmt.Printxxxx is always expensive. For most of the time, you
needn't optimize it.

David