I was referring to this code
func (x type []K) Sum() (r type K) {
for type switch {
case K range int64(), uint64(), float64(), complex128():
for _, v := range x {
r += v
}
case K big.Int:
for _, v := range x {
r.Add(r,v)
}
break // or return in every case instead
}
return
}
I did not understand how "// For var x []AnyType. ANY. " relates to
previous code.
for your question about the rune, i guess it d be like this
func Sum(some []K, add func(l,r K) K) (ret K) {
for _, v := range some {
ret = add(ret, v)
}
return ret
}
func addOperator(l,r Z)Z{
return l+r
}
func main(){
total := Sum([]rune("whatever"), addOperator)
}
Consider Z,K as virtual types to be inferred from the call site.
In regards to Russ Cox proposal this code is missing
their explicitly declared contracts and the function instances declaration.
On the other hand, this is so much more readable *to me*.
maybe it looks likes c++, i did not think it was a concern
as long as it respected desired behaviors of good error reporting,
good readability, ease of usage, speed of compilation,
proven useful and workable etc
in regards to all those factors Russ Cox knows way better so he s probably
right,
yet the link provided by Robert is extremely interesting, repeating it here
https://www.researchgate.net/publication/236644412_Adoption_and_Use_of_Java_Generics
This was also an interesting reading
https://www.researchgate.net/publication/273718701_The_Reaction_of_Open-Source_Projects_to_New_Language_Features_An_Empirical_Study_of_C_Generics
Just quoting from it
Frankel [Fra 9 3]found that generics were not
widely used in Ada. Later, the principal designer of Ada suggested that, if
he could,
he would eliminate parameterized types, because they were “less useful than
originally
thought” [RSB05].
Anyways, I am polluting the thread against this proposal, sorry for that.
On Tuesday, September 18, 2018 at 10:54:02 PM UTC+2, ohir wrote:
> On Tue, 18 Sep 2018 10:11:52 -0700 (PDT)
> mhh...@gmail.com <javascript:> wrote:
>
> > I agree with Robert, this is not re usable.
>
> What is not reusable? A generic Sum function allowed by
> the CGG that can sum any type of any base that accidentally
> has anything countable in it?
>
> > I much prefer this
> >
> > func Sum(some []K, add func(l,r K) K) (ret K) {
> > for _, v := range some {
> > ret = add(ret, v)
> > }
> > return ret
> > }
> >
> > func main(){
>
>
> > total := Sum([]int{1,2,3,4}, func(l,r int) int {return l+r})
> > }
>
> How clever and generic it looks. Generic, javish and cpluplusish.
> And how readable call site it gave.
>
> In CGG Go user code call is exactly the same for ANY type.
>
> total := Sum(x) // For var x []AnyType. ANY.
>
> var x []string
> total := Sum(x)
>
> may return sum of all runes in all strings and sprintf-ed to
> the resulting string.
>
> > this is not re usable.
>
> How can I call your example to get string result of sum of all
> runes? CGG's is as with any other type: `total := Sum(x)`
>
> --
> Wojciech S. Czarnecki
> << ^oo^ >> OHIR-RIPE
>
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
