Returning values from sync.Once.Do
Archos
returned from there, why?
***
var once sync.Once
func foo() os.Error {
once.Do(func() { return bar(arg1) })
}
***
In change, I've to do:
***
func foo() (e os.Error) {
once.Do(func() { e = bar(arg1) })
return e
}
***
jimmy frasche
What would it return the second time it's called?
roger peppe
it's an easy change to make.
Archos
On Sep 16, 11:01 am, jimmy frasche <soapboxcic...@gmail.com> wrote:
Andrew Gerrand
>> What would it return the second time it's called?
> In my case, could return different values
This raises a lot of questions, the answers to which are non-obvious
(to me at least). The semantics of sync.Once is very simple; I'd go so
far as to say it's beautiful. Why complicate it, when you can get the
behaviour you need with easy-to-read code?
Andrew
Archos
On Sep 16, 11:28 am, Andrew Gerrand <a...@golang.org> wrote:
>
> >> What would it return the second time it's called?
> > In my case, could return different values
>
> This raises a lot of questions, the answers to which are non-obvious
> (to me at least). The semantics of sync.Once is very simple; I'd go so
> far as to say it's beautiful. Why complicate it, when you can get the
> behaviour you need with easy-to-read code?
roger peppe
>> What would it return the second time it's called?
> In my case, could return different values
how could it return different values? surely the whole
point of "once" is that the function is called once only.
so there's only one value to return.
your function foo() will always return nil the second
time it's called.
Rob 'Commander' Pike
> it could return the same thing every time.
> it's an easy change to make.
the spec would require it to return an interface{}. it seems like
special pleading to me. better to use the function it calls to write
down the value with the type you want. then after any call to
once.Do(f), that value is available, safely.
-rob
Archos
***
/* Gets the password-file entry for the given UID. */
func GetpwByUid(uid uint32) (f *fieldPasswd, err os.Error) {
//once.Do(func() { return parsePasswd(pwUID, uid) })
oncePasswd.Do(func() { f, err = parsePasswd(pwUID, uid) })
return f, err
}
// Searchs the value into the field of each line
func parsePasswd(name field, value interface{}) (*fieldPasswd,
os.Error) {
...
}
***
When is used a different argument for "GetpwByUid()" then will be
returned a different value.
On Sep 16, 11:48 am, roger peppe <rogpe...@gmail.com> wrote:
jimmy frasche
Do you want a function that returns the same output for the same input
without having to redo the calculations? That's not what once.Do is
for.
roger peppe
> That is not always true, e.g. on this code snippet:
>
> ***
>
> /* Gets the password-file entry for the given UID. */
> func GetpwByUid(uid uint32) (f *fieldPasswd, err os.Error) {
> //once.Do(func() { return parsePasswd(pwUID, uid) })
> oncePasswd.Do(func() { f, err = parsePasswd(pwUID, uid) })
> return f, err
> }
> When is used a different argument for "GetpwByUid()" then will be
> returned a different value.
have you tried it?
assuming oncePasswd remains the same, the argument to oncePasswd.Do
will be evaluated only once - i.e. the value of f and err will be
changed only once, on the first call to GetpwByUid. on subsequent
calls, even though a new closure is created, it will not be called.
roger peppe
yes, that's definitely better.
i said it was an easy change to make - i wasn't trying to imply
that i wanted it to happen.