Re: [go-nuts] Missing binary operator shortcuts &&= and ||=

[Ian Lance Taylor]

On Fri, May 5, 2017 at 10:26 AM, roger peppe  wrote:
> On 5 May 2017 at 14:11, Michael Jones  wrote:
>> Just so. One cannot do boolean arithmetic with boolean variables.
>>
>> We have:
>>   EQUIVALENCE ("==")
>>   XOR ("!=")
>>   NOT ("!")  -- George Boole's NEGATION
>>
>> We lack:
>>   AND ("&") -- George Boole's CONJUNCTION
>>   OR ("|") -- George Boole's DISJUNCTION
>>
>> As it happens, one can implement all the operators from the basis of
>> NEGATION and either CONJUNCTION or DISJUNCTION, but as we lack each of the
>> last two, one must be sure to use ints where bools would be natural.
>
> I don't get it. What's the difference between a&
> and the hypothetical a for two expressions a and b,
> assuming a and b are free of side-effects ?

There is none.

But sometimes b has a side-effect.  And sometimes you want that
side-effect to be executed whether or not a is true.  Then writing `a
&& b` does not work, and the alternatives are either verbose or
require introducing a new temporary variable name.

Ian

-- 
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.

Re: [go-nuts] why received can be defined with/without pointer?

[Ian Lance Taylor]

On Sat, May 6, 2017 at 3:39 AM,   wrote:
>
> Question about the receiver of a func.
>
> It can be defined as star/no star, and consumed as star/nostar.
>
> The understanding i have so far is,
> it let the developer define the memory model he d like to use.
>
> It leads to cases such as
> - define start/nostar on a type
> - consume a stared type as a value
> - consume a value type as a pointer

You are not permitted to define a method on a named type defines as a
pointer type, so I don't understand your cases.  Can you describe them
using actual Go code rather than words?

Ian

-- 
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.

Re: [go-nuts] Re: understanding utf-8 for a newbie

[Sam Whited]

On Sat, May 6, 2017 at 7:40 PM, peterGo  wrote:
> Corrected, corrected link. I will get it right eventually!
>
> For UTF-8 to CP1252: https://play.golang.org/p/vzupJY78XB

FWIW, if you do need CP1252 (you probably don't) it already exists in
Go-land as one of the encodings specified in this package:
https://godoc.org/golang.org/x/text/encoding/charmap

—Sam

-- 
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.

[go-nuts] Proposal: Tags on Interface types

[Glen Newton]

I would like to propose allowing annotations (tags) on Interface types. 
Only a subset of an Interfaces methods could be tagged. This subset is 
defined as methods that have a single return type and take no parameters 
(as a best practice, these methods should not change any state and be 
thread safe...). 

So let's use the 'Go by example Interface', found here:
https://gobyexample.com/interfaces
and
https://play.golang.org/p/313UebA3rD

I have an altered version of this, where I have capitalized the methods of 
interest and added tags: https://play.golang.org/p/50oEQHeWVZ

// _Interfaces_ are named collections of method
// signatures.

package main

import "fmt"
import "math"

// Here's a basic interface for geometric shapes.
type geometry interface {
Area() float64 `json:"area"`
Perim() float64 `json:"perimeter"`
}

// For our example we'll implement this interface on
// `rect` and `circle` types.
type rect struct {
width, height float64
}
type circle struct {
radius float64
}

// To implement an interface in Go, we just need to
// implement all the methods in the interface. Here we
// implement `geometry` on `rect`s.
func (r rect) Area() float64 {
return r.width * r.height
}
func (r rect) Perim() float64 {
return 2*r.width + 2*r.height
}

// The implementation for `circle`s.
func (c circle) Area() float64 {
return math.Pi * c.radius * c.radius
}
func (c circle) Perim() float64 {
return 2 * math.Pi * c.radius
}

// If a variable has an interface type, then we can call
// methods that are in the named interface. Here's a
// generic `measure` function taking advantage of this
// to work on any `geometry`.
func measure(g geometry) {
fmt.Println(g)
fmt.Println(g.Area())
fmt.Println(g.Perim())
}

func main() {
r := rect{width: 3, height: 4}
c := circle{radius: 5}

// The `circle` and `rect` struct types both
// implement the `geometry` interface so we can use
// instances of
// these structs as arguments to `measure`.
measure(r)
measure(c)
}

What happens? When a tag processor is engaged on an interface containing 
tags, instead of using value of the fields of a struct that are tagged, it 
takes the value returned by the invocation of the methods that are tagged 
(it invokes the method and uses the (single) value returned). 

So what does this give us? It means I can have a list of type geometry 
(interface) that contains both circle and square structs under the hood, 
and I can walk through the list and (for example) serialize them, using the 
serialization defined in the interface

It gives a bit of generic feel to things, at least from a tags perspective. 
[Sorry, I said the 'G' word]

I guess reflect.Method  would need 
a Tag StructTag  like that in 
reflect.StructField. 

I think this would be backward compatible, and just a handful of things 
would need to be updated in reflect (from my limited knowledge) as well as 
some minor changes to the compiler (??) and likely other things I don't 
know about, like various tool chain stuff, etc, ??.

Thanks,
Glen

-- 
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.

Re: [go-nuts] understanding utf-8 for a newbie

[Sam Whited]

On Fri, May 5, 2017 at 8:11 PM, rob solomon  wrote:
> I decided to first change ", ' and emdash characters.  Using hexdump -C in
> Ubuntu, the runes in the file are:
>
> open quote = 0xE2809C
>
> close quote = 0xE2809D
>
> apostrophe = 0xE28099
>
> emdash = 0xE28094

The output of hexdump will be the actual bytes of the file; these are
the UTF-8 encoded values.

> However, when I write a simple program to display these runes from the file,
> using the routines in unicode/utf8, I get very different values.  I do not
> understand this.
>
> open quote = 0x201C
>
> close quote = 0x201D
>
> apostrophe = 0x2019
>
> emdash = 0x2014.

These are called Unicode codepoints. In Unicode lots of different
things like letters, numbers, emoji, etc. are assigned numbers  (Go's
type for storing codepoints is called "rune"). These numbers are then
encoded using an encoding such as UTF-8 to make the final output which
you saw when you used hexdump. The Unicode codepoint of an em dash is
always U+2014 (sometimes they're written this way, prefixed by `U+'),
but the encoding might be different depending on what system you're on
or what file format you're using.

Here is an example of encoding a rune with the value 0x2014 as UTF-8,
which gives the number you observed in your hexdump output:
https://play.golang.org/p/ddIfzobKD4

—Sam

-- 
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.

[go-nuts] Re: json with comments

[C Banning]

https://godoc.org/github.com/clbanning/checkjson#ReadJSONFile and 
ReadJSONReader will process JSON files or streams that have comments - 
however, no block comments.  More importantly the package provides 
functions that check for potentially misspelled keys in the JSON object and 
to identify structure member values that won't be set by unmarshaling the 
JSON object.


-- 
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.

Re: [go-nuts] Re: [ANN] gos2: S2 geometry library in Go

[Robert Snedegar]

Are you using the C++ or Go libraries?

On Fri, May 5, 2017 at 1:09 PM, mhoggan via golang-nuts <
golang-nuts@googlegroups.com> wrote:

> I am trying to find a group associated with https://code.google.com/
> archive/p/s2-geometry-library/. This is the only post that comes up when
> searching groups.
>
> My question on the library is, Do the bounding polygons associated with a
> cell id include the boundaries or sides of the polygon? If so what sides
> (top, left), (bottom, left)... etc?
>
> Thanks,
> Matthew Hoggan
>
>
> On Wednesday, March 13, 2013 at 8:37:35 PM UTC-6, David Symonds wrote:
>>
>> I'm pleased to announce the initial open source release of the Go port
>> of the S2 geometry library:
>>
>> https://code.google.com/p/gos2/
>> http://godoc.org/code.google.com/p/gos2/s2
>>
>> (or "go get code.google.com/p/gos2/s2".)
>>
>> /*
>> Package s2 implements types and functions for working with geometry in
>> S² (spherical geometry).
>>
>> Its related packages, parallel to this one, are s1 (operates on S¹),
>> r1 (operates on ℝ¹) and r3 (operates on ℝ³).
>>
>> This package provides types and functions for the S2 cell hierarchy
>> and coordinate systems. The S2 cell hierarchy is a hierarchical
>> decomposition of the surface of a unit sphere (S²) into “cells”; it is
>> highly efficient, scales from continental size to under 1 cm² and
>> preserves spatial locality (nearby cells have close IDs).
>>
>> A presentation that gives an overview of S2 is
>> https://docs.google.com/presentation/d/1Hl4KapfAENAOf4gv-
>> pSngKwvS_jwNVHRPZTTDzXXn6Q/view.
>> */
>>
>>
>> Note that it is not as complete as the C++ version it is based on, but
>> it works well for what it does support, and is sufficient for geo
>> indexing and the like.
>>
> --
> 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.
>

-- 
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.

[go-nuts] Re: understanding utf-8 for a newbie

[peterGo]

rob,

Why are you converting UTF-8 to ASCII for Windows 10? Convert UTF-8 to 
CP1252 (Windows-1252) or UTF16.

Corrected link.

For UTF-8 to CP1252: https://play.golang.org/p/vzupJY78XB 


Peter

On Friday, May 5, 2017 at 9:11:16 PM UTC-4, rob solomon wrote:
>
> Hi.  I decided to write a small program in Go to convert utf8 to simple 
> ASCII.  This need arose by my copying a file created in Ubuntu 16.04 
> amd64, and used on a win10 computer. 
>
> I decided to first change ", ' and emdash characters.  Using hexdump -C 
> in Ubuntu, the runes in the file are: 
>
> open quote = 0xE2809C 
>
> close quote = 0xE2809D 
>
> apostrophe = 0xE28099 
>
> emdash = 0xE28094 
>
>
> However, when I write a simple program to display these runes from the 
> file, using the routines in unicode/utf8, I get very different values.   
> I do not understand this. 
>
> open quote = 0x201C 
>
> close quote = 0x201D 
>
> apostrophe = 0x2019 
>
> emdash = 0x2014. 
>
>
> Why are the runes returned by utf8.DecodeRuneInString different from 
> what hexdump shows when inspecting the file directly? 
>
> --rob solomon 
>
>

-- 
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.

[go-nuts] Re: understanding utf-8 for a newbie

[peterGo]

rob,

Why are you converting UTF-8 to ASCII for Windows 10? Convert UTF-8 to 
CP1252 (Windows-1252) or UTF16.

For UTF-8 to CP1252: https://play.golang.org/p/BBiN2ihc02

Peter

On Friday, May 5, 2017 at 9:11:16 PM UTC-4, rob solomon wrote:
>
> Hi.  I decided to write a small program in Go to convert utf8 to simple 
> ASCII.  This need arose by my copying a file created in Ubuntu 16.04 
> amd64, and used on a win10 computer. 
>
> I decided to first change ", ' and emdash characters.  Using hexdump -C 
> in Ubuntu, the runes in the file are: 
>
> open quote = 0xE2809C 
>
> close quote = 0xE2809D 
>
> apostrophe = 0xE28099 
>
> emdash = 0xE28094 
>
>
> However, when I write a simple program to display these runes from the 
> file, using the routines in unicode/utf8, I get very different values.   
> I do not understand this. 
>
> open quote = 0x201C 
>
> close quote = 0x201D 
>
> apostrophe = 0x2019 
>
> emdash = 0x2014. 
>
>
> Why are the runes returned by utf8.DecodeRuneInString different from 
> what hexdump shows when inspecting the file directly? 
>
> --rob solomon 
>
>

-- 
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.

[go-nuts] Re: download link - 400 error code

[mhhcbon]

hi,

you are referring to the downloads available here 
https://golang.org/dl/?

Here the linux one works.

i can t find mirror of them.
Have you searched for yourself ?

Maybe we might try to host it over bt if no one come up with a mirror.

Do you know a host that works for you?

On Saturday, May 6, 2017 at 2:12:05 PM UTC+2, Abbas Naghdi wrote:
>
> hi.
>
> Yes, I am an Iranian.
> Error number 403 download for my queries.
> Then I use VPN to my display error number 400.
> Where is problem?
>

-- 
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.

[go-nuts] Re: json with comments

[mhhcbon]

awesome package :) The syntax looks great!

Especially the forgiving one.



On Saturday, May 6, 2017 at 2:01:26 PM UTC+2, Michael Gross wrote:
>
> Hi,
>
> even tough json is a data exchange format I find it sometimes useful to 
> use these files as configs. 
> Then after a while you would like to add a comment or some other person 
> has forgotten to format the file and the formatter you are using messes the 
> file up. also when it gets bigger its sometimes very unreadable.
>
> A solution to this could be to use a file format with comments which 
> extends json. Something like
> YAML or http://hjson.org/
>
> If I did know about hjson earlier I would probably just try to have people 
> use the same formatter in project I take part. Since I did not, here is a 
> proposal for a json extension with a formatter which tries to mimic the 
> behavior of gofmt.
>
> https://komkom.github.io/
>
> This is all in early development - any feedback would be greatly 
> appreciated!
>
> Best Michael
>

-- 
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.

Re: [go-nuts] Missing binary operator shortcuts &&= and ||=

[Jesper Louis Andersen]

Finding evidence among programmers can be tricky. You may be up against a
considerable selection bias in a lot of cases:

* You pick among experts in the field. Newcomers are unlikely to have the
same problems as experts.
* The set of people who wants a certain feature tend to be more vocal about
it. The set of people who doesn't really care can be far larger, but since
they are not vocal, you don't get any response.
* Languages with dynamic types tend to be more "operator heavy" since they
have to. You need an operator for certain pairings of different types,
where a language with static types can overload them and figure out what to
do based on the input types (implicitly).

Personal opinion:

I'm hesitant when people suggest syntactic sugar in programming languages,
because it adds very little expressive power for convenience saved when
typing. After all, because it is sugar, there is a way to write it without
said construct in the language. Granted, it is nice you can save some
keystrokes. But it has to be weighed against how often those keystrokes are
saved. If it is just an argument of less typing, you could argue more
keystrokes would be saved by changing func to fn and while to whl.

A construction such as =&& may help if the language you are looking at has
a less sophisticated optimization engine. It becomes a "macro" which can be
expanded easily by the compiler into a "faster variant". Yet, once you have
optimizations in place and you have propagation of values, the benefit of
the "macro" can disappear.

Another point worth mentioning is that whenever you add more grammar to a
language, you make it harder to add more grammar later. We have an
artificial limit in our keyboards and which characters are easy to type on
keyboards by default. So languages tend to pick amongst those characters.
Whenever you build up a digram or trigram, you may reap yourself of later
extension. It is a bit more involved because lexers and parsers have
limitations in what language they can easily recognize. A seemingly
innocent addition can wreak havoc down the road.

Finally, since grammar is limited, using it for syntactic sugar removes
your ability to use it for other constructions later. C++ 11 seems to have
some reference semantics around the && operator in overloaded form, and
thus =&& may have a different meaning. If you had used it for boolean
values, you might reject the new construction on grounds of it being
confusing.

Productivity in a programming language is weird and non-linear. Often, it
is not the code itself that provides a limit, but rather the idea and
solution you are cooking up in your mind. Slightly paraphrasing Peter
Naur[0], programmers have a built-up knowledge in their brain of what they
are working on, but the program is merely a projection of that knowledge.
Crucially, we tend to value simple elegant programs, so the program is
almost always a well-chosen subset of the built-up knowledge. Especially
when the programmer is highly skilled, since they are able to cut off parts
which are not important to the problem solution. We revel in the short and
elegant program, but the real amazement to the seasoned programmer is every
code line not written, but still accounted for. Thus, we value emergent
behaviors of software.

In this light, productivity tend to be less tied to the verbosity of the
written code. After all, most of the time should be conducted by thinking
about the problem to solve, not typing it up. If you find yourself
furiously typing away at the keyboard for a given problem, chances are the
problem has a better solution[1]

[0] http://pages.cs.wisc.edu/~remzi/Naur.pdf

[1] Aside: the reason we often end up doing lots of mundane stuff is
because people who came before decided on other abstractions, which turn
out to be slightly less optimal for our cause. A rather innocuous choice
between JSON and protobufs, for example, can have far-reaching consequences
for the quality of the software in the long run, because the dynamic nature
and weak type classification of JSON tend to virally infect a code base.
This can only be solved by additional mundane typing, debugging and bug
fixing.


On Sat, May 6, 2017 at 1:07 AM  wrote:

> Le jeudi 4 mai 2017 22:44:58 UTC+2, Ian Lance Taylor a écrit :
>>
>> I assert without evidence that for many people it would be confusing
>> to see a function call alone on the right hand side of an `=` when
>> that function may or may not be called.
>>
>
> Various languages like Perl, PHP, Ruby & zsh have the two operators I
> propose.  If you can find no evidence among programmers of those, your
> point seems moot. Also there is discussion (e.g. on Stackoverflow) about
> this for various languages like C, C++, C# & Java, so people do want this!
>
> regards – Da
>
>
> --
> 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 

[go-nuts] Re: download link - 400 error code

[abbasnaghdix]

hi.

Yes, I am an Iranian.
Error number 403 download for my queries.
Then I use VPN to my display error number 400.
Where is problem?

-- 
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.

[go-nuts] json with comments

[Michael Gross]

Hi,

even tough json is a data exchange format I find it sometimes useful to use 
these files as configs. 
Then after a while you would like to add a comment or some other person has 
forgotten to format the file and the formatter you are using messes the 
file up. also when it gets bigger its sometimes very unreadable.

A solution to this could be to use a file format with comments which 
extends json. Something like
YAML or http://hjson.org/

If I did know about hjson earlier I would probably just try to have people 
use the same formatter in project I take part. Since I did not, here is a 
proposal for a json extension with a formatter which tries to mimic the 
behavior of gofmt.

https://komkom.github.io/

This is all in early development - any feedback would be greatly 
appreciated!

Best Michael

-- 
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.

Re: [go-nuts] Re: pure-Go MATLAB file I/O package ?

[Sebastien Binet]

Elia,

On Fri, May 5, 2017 at 8:31 PM,  wrote:

> Hi Sebastien, I'm writing a program that needs to do the exact same thing
> you were asking, have you by any chance developed that library? :P
>

I started it:
https://github.com/sbinet/matfio

but had to put it a bit on the back burner.
it's also a candidate for migration to a hypothetical github.com/gonum/io
package...

PRs accepted :)

-s

>
>
> On Thursday, 7 July 2016 11:27:36 UTC+2, Sebastien Binet wrote:
>>
>> hi there,
>>
>> before I go ahead and implement it, has anyone released a pure-Go
>> read/write package for MATLAB files ?
>>
>> https://www.mathworks.com/help/pdf_doc/matlab/matfile_format.pdf
>>
>> I've found:
>>  https://github.com/ready-steady/mat
>>
>> but that package is actually using the C-API exposed by a MATLAB
>> installation...
>>
>> -s
>>
> --
> 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.
>

-- 
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.

[go-nuts] why received can be defined with/without pointer?

[mhhcbon]

Hi,

Question about the receiver of a func.

It can be defined as star/no star, and consumed as star/nostar.

The understanding i have so far is,
it let the developer define the memory model he d like to use.

It leads to cases such as 
- define start/nostar on a type
- consume a stared type as a value
- consume a value type as a pointer

Which is quiet confusing for beginners, and me.

While i understand that someone would like to declare
a type is consumed by value, I do not understand the last two cases.
when why they might happen.

Can you explain their value added ?

Thinking further more,

Not speaking about dereferencing a pointer,
but initialization of a type in a way that is undesired to the provider.

The way a type is consumed by value or reference,
is an act of design rules (i add a property on the type that make sure it 
is never copied/referenced)
or an act of consumption, 
the designer did not enforce any rule on the type, i might initialize it as 
star/nostar at convenience.

The fact it is let possible today 
- to not enforce the way a type is manipulated, 
   leads to confusion and error (famous one is https://godoc.org/sync)
- to define at both declaration / usage the star/nostar,
   is confusing, again

so yeah, wondering quiet a lot about that,
and given the fact i do not understand few use cases,
i think this could be better handled.

For example, 

if a new keyword appear to ensure a type is 
consumed by value, that might be helpful to provide
a function to make sure that type won t exceed the stack size
and escape to the heap.
that keyword would help api designer to avoid consumption problems.
nop ?

If a new keyword would appear to ensure a type is initialized by reference,
might help to detect value copy and warn/error when that case is met.
That would helped consumers to avoid problems.
nop ?

If the receiver type was not able to be star/nostar,
that d probably help to get ride of confusion,
nop ?

-- 
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.