There is no sparse slices in Go, so you could simply check the length:

    if len(mySlice) &gt; 3 {
        // ...
    }

If the length is greater than 3, you know that the index 3 and all those before that exist.

When doing a shallow clone in git (using the `--depth` option), the root commit is marked as *grafted*.

![enter image description here][1]

Googling didn&#39;t lead to any satisfacting documentation.

It doesn&#39;t seem to have anything to do with [git grafts](https://git.wiki.kernel.org/index.php/GraftPoint), which the similar terminology would imply.  
Is it just a flag to signal that this commit actually has more parents and isn&#39;t the &quot;real&quot; root commit? Or is there something more special about it?

  [1]: http://i.stack.imgur.com/dZlsX.png

What exactly is a &quot;grafted&quot; commit in a shallow clone?

I have this `printf` statement at the end of my program:

    printf(&quot;%d&quot;, total_candies);

`total_candies` is an `int`, and while I expect everything to work correctly, along with the actual number, I&#39;m getting a weird percent sign at the end.
![enter image description here][1]

Can anyone tell me why this is happening?

  [1]: http://i.stack.imgur.com/CwrDb.png

Getting a weird percent sign in printf output in terminal with C

We can easily do that with maps:

    item, ok := myMap[&quot;index&quot;]

But not with slices:
    
    item, ok := mySlice[3] // panic!

Surprised this wasn&#39;t asked before. Maybe I&#39;m on the wrong mental model with Go slices?

How to check if a slice has a given index in Go?

We can easily do that with maps:
<pre><code class="hljs language-go">item, ok := myMap["index"]
</code></pre>
But not with slices:
<pre><code class="hljs language-go">item, ok := mySlice[3] // panic!
</code></pre>
Surprised this wasn't asked before. Maybe I'm on the wrong mental model with Go slices?

I am trying to generate a map and then convert that to a yaml file like this:

    uid :
          kasi:
            cn: Chaithra
            street: fkmp
          nandan:
            cn: Chaithra
            street: fkmp
          remya:
            cn: Chaithra
            street: fkmp

I think I am missing something important while creating the map. My code is below.

    package main
    
    import (
    	&quot;fmt&quot;
    	&quot;gopkg.in/yaml.v2&quot;
    )
    
    type T struct {
    	cn     string
    	street string
    }
    
    func main() {
    	names := []string{&quot;kasi&quot;, &quot;remya&quot;, &quot;nandan&quot;}
    
    	m := make(map[string]map[string]T, len(names))
    	for _, name := range names {
    
    		//t := T{cn: &quot;Chaithra&quot;, street: &quot;fkmp&quot;}
    
    		m[&quot;uid&quot;][name] = T{cn: &quot;Chaithra&quot;, street: &quot;fkmp&quot;}
    
    	}
    	fmt.Println(m)
    
    	y, _ := yaml.Marshal(&amp;m)
    
    	fmt.Println(string(y))
    	//fmt.Println(m, names)
    }

It is giving the following error:

    panic: runtime error: assignment to entry in nil map



Runtime error: assignment to entry in nil map

Using `struct` and a function that is supposed to print out the struct&#39;s elements, I have written this simple program:

    package main
    
    import &quot;fmt&quot;
    
    type Salutation struct {
    	name     string
    	greeting string
    }
    
    func Greet(salutation Salutation) {
    	fmt.Println(salutation.name)
    	fmt.Println(salutation.greeting)
    }
    
    func main() {
    	var s = Salutation
    	s.name = &quot;Alex&quot;
    	s.greeting = &quot;Hi&quot;
    	Greet(s)
    }

When I run it I get the error `go:16: type Salutation is not an expression`. What goes wrong here?

Interestingly enough, when I change the definition of `s` to `var s = Salutation {&quot;Alex&quot;, &quot;Hi&quot;}` it works just fine. But they are basically different syntactic ways to define the same entity. That&#39;s why I don&#39;t understand the source of the error. 
 

Error: struct Type is not an expression

I am going through [&quot;A Tour of Go&quot;][1] tutorial.

I would like to check the answer to this question:

&gt; **Note:** a call to `fmt.Sprint(e)` inside the `Error` method will send
&gt; the program into an infinite loop. You can avoid this by converting
&gt; `e` first: `fmt.Sprint(float64(e))`. Why?

&lt;br&gt;
I believe this is because when the `Sprint` function is called, since the error is non-nil, the `Error function()` will again be called, and so forth, resulting in an infinite loop. 


  [1]: https://tour.golang.org/methods/20

Why would a call to fmt.Sprint(e) inside the Error() method result in an infinite loop?

I&#39;m searching for the way to get `$ go get` work with private repository, after many google try.  

The first try:

    $ go get -v gitlab.com/secmask/awserver-go
    Fetching https://gitlab.com/secmask/awserver-go?go-get=1
    https fetch failed.
    Fetching http://gitlab.com/secmask/awserver-go?go-get=1
    Parsing meta tags from http://gitlab.com/secmask/awserver-go?go-get=1 (status code 200)
    import &quot;gitlab.com/secmask/awserver-go&quot;: parse http://gitlab.com/secmask/awserver-go?go-get=1: no go-import meta tags
    package gitlab.com/secmask/awserver-go: unrecognized import path &quot;gitlab.com/secmask/awserver-go

Yep, it did not see the meta tags because I could not know how to provide login information.

The second try:

Follow [https://gist.github.com/shurcooL/6927554][1]. Add config to .gitconfig.

    [url &quot;ssh://git@gitlab.com/&quot;]
    	insteadOf = https://gitlab.com/
    $ go get -v gitlab.com/secmask/awserver-go --&gt; not work
    $ go get -v gitlab.com/secmask/awserver-go.git --&gt; work but I got src/gitlab.com/secmask/awserer-go.git

Yes it work but with `.git` extension with my project name, I can rename it to original but do it everytime `$ go get` is not so good, is there an otherway?

  [1]: https://gist.github.com/shurcooL/6927554

What&#39;s the proper way to &quot;go get&quot; a private repository?

I imported the math library in my program, and I was trying to find the minimum of three numbers in the following way:

`v1[j+1] = math.Min(v1[j]+1, math.Min(v0[j+1]+1, v0[j]+cost))`

where v1 is declared as:

    t := &quot;stackoverflow&quot;
    v1 := make([]int, len(t)+1)
    

However, when I run my program I get the following error:

    ./levenshtein_distance.go:36: cannot use int(v0[j + 1] + 1) (type int) as type float64 in argument to math.Min

I thought it was weird because I have another program where I write

`fmt.Println(math.Min(2,3))`

and that program outputs `2` without complaining.


so I ended up casting the values as float64, so that `math.Min` could work:

    v1[j+1] = math.Min(float64(v1[j]+1), math.Min(float64(v0[j+1]+1), float64(v0[j]+cost)))


With this approach, I got the following error:

    ./levenshtein_distance.go:36: cannot use math.Min(int(v1[j] + 1), math.Min(int(v0[j + 1] + 1), int(v0[j] + cost))) (type float64) as type int in assignment

so to get rid of the problem, I just casted the result back to `int`

I thought this was extremely inefficient and hard to read:

    v1[j+1] = int(math.Min(float64(v1[j]+1), math.Min(float64(v0[j+1]+1), float64(v0[j]+cost))))

I also wrote a small `minInt` function, but I think this should be unnecessary because the other programs that make use of `math.Min` work just fine when taking integers, so I concluded this has to be a problem of my program and not the library per se.

Is there anything that I&#39;m doing terrible wrong? 

Here&#39;s a program that you can use to reproduce the issues above, line 36 specifically:
package main

    import (
    	&quot;math&quot;
    )
    
    func main() {
    	LevenshteinDistance(&quot;stackoverflow&quot;, &quot;stackexchange&quot;)
    }
    
    func LevenshteinDistance(s string, t string) int {
    	if s == t {
    		return 0
    	}
    	if len(s) == 0 {
    		return len(t)
    	}
    	if len(t) == 0 {
    		return len(s)
    	}
    
    	v0 := make([]int, len(t)+1)
    	v1 := make([]int, len(t)+1)
    
    	for i := 0; i &lt; len(v0); i++ {
    		v0[i] = i
    	}
    
    	for i := 0; i &lt; len(s); i++ {
    		v1[0] = i + 1
    		for j := 0; j &lt; len(t); j++ {
    			cost := 0
    			if s[i] != t[j] {
    				cost = 1
    			}
    			v1[j+1] = int(math.Min(float64(v1[j]+1), math.Min(float64(v0[j+1]+1), float64(v0[j]+cost))))
    		}
    
    		for j := 0; j &lt; len(v0); j++ {
    			v0[j] = v1[j]
    		}
    	}
    	return v1[len(t)]
    }



What is the correct way to find the min between two integers in Go?

I often work with slices of structs. Here&#39;s an example for such a struct:

	type MyStruct struct {
		val1, val2, val3    int
		text1, text2, text3 string
		list                []SomeType
	}

So I define my slices as follows:

    []MyStruct

Let&#39;s say I have about a million elements in there and I&#39;m working heavily with the slice:

* I append new elements often. (The total number of elements is unknown.)
* I sort it every now and then.
* I also delete elements (although not as much as adding new elements).
* I read elements often and pass them around (as function arguments).
* The content of the elements themselves doesn&#39;t get changed.

My understanding is that this leads to a lot of shuffling around of the actual struct. The alternative is to create a slice of pointers to the struct:

    []*MyStruct

Now the structs remain where they are and we only deal with pointers which I assume have a smaller footprint and will therefore make my operations faster. But now I&#39;m giving the garbage collector a lot more work.

* Can you provide general guidelines of when to work with structs directly vs. when to work with pointers to structs?
* Should I worry about how much work I leave to the GC?
* Is the performance overhead of copying a struct vs. copying a pointer negligible?
* Maybe a million elements is not much. How does all of this change when the slice gets much bigger (but still fits in RAM, of course)?

Slices of structs vs. slices of pointers to structs

I need to convert `&amp;[u8]` to a hex representation. For example `[ A9, 45, FF, 00 ... ]`.

The trait `std::fmt::UpperHex` is not implemented for slices (so I can&#39;t use `std::fmt::format`). Rust has the `serialize::hex::ToHex` trait, which converts `&amp;[u8]` to a hex String, but I need a representation with separate bytes.

I can implement trait `UpperHex` for `&amp;[u8]` myself, but I&#39;m not sure how canonical this would be. What is the most canonical way to do this?

Show u8 slice in hex representation

In Go, copying slices is standard-fare and looks like this:

&lt;!-- language: go --&gt;

    # It will figure out the details to match slice sizes
    dst = copy(dst[n:], src[:m])

In Rust, I couldn&#39;t find a similar method as replacement. Something I came up with looks like this:

    fn copy_slice(dst: &amp;mut [u8], src: &amp;[u8]) -&gt; usize {
        let mut c = 0;
        for (&amp;mut d, &amp;s) in dst.iter_mut().zip(src.iter()) {
            d = s;
            c += 1;
        }
        c
    }

Unfortunately, I get this compile-error that I am unable to solve:

&lt;!-- language: none --&gt;

    error[E0384]: re-assignment of immutable variable `d`
     --&gt; src/main.rs:4:9
      |
    3 |     for (&amp;mut d, &amp;s) in dst.iter_mut().zip(src.iter()) {
      |               - first assignment to `d`
    4 |         d = s;
      |         ^^^^^ re-assignment of immutable variable

How can I set `d`? Is there a better way to copy a slice?

How to idiomatically copy a slice?

Powershell&#39;s array notation has rather bizarre, albeit documented, behavior for slicing the end of arrays.  This section from [the official documentation](https://technet.microsoft.com/en-us/library/hh847882.aspx) sums up the bizarreness rather well:

&gt; Negative numbers count from the end of the array. For example, &quot;-1&quot; 
&gt; refers to the last element of the array. To display the last three
&gt; elements of the array, type:
&gt; 
&gt;     $a[-3..-1]
&gt; 
&gt; However, be cautious when using this notation.
&gt; 
&gt;     $a[0..-2]
&gt; 
&gt; This command does not refer to all the elements of the array, except
&gt; for  the last one. It refers to the first, last, and second-to-last
&gt; elements in the array.

The following code confirms the bizarreness:

    $a = 0,1,2,3
    $a[1..-1]

Which indeed outputs this bizarre result:

    1
    0
    3

So, the question is, what _is_ the idiomatic way to slice with one index relative the start and another relative the end of the array?  

Please tell me it&#39;s something better than this ugly mess:

    $a[1..($a.Count-1)]

------------

Edit:

Another way to describe what I&#39;m looking for is this: The idiomatic Powershell equivalent of this python expression:

    a=1,2,3,4
    a[1:-1]

Which, of course, evaluates to `(2,3)`

What is the idiomatic way to slice an array relative to both of its ends?

    package main

    import (
	&quot;fmt&quot;
	&quot;strings&quot;
    )

    func main() {
    reg := [...]string {&quot;a&quot;,&quot;b&quot;,&quot;c&quot;}
    fmt.Println(strings.Join(reg,&quot;,&quot;))
    }

gives me an error of:
&gt;prog.go:10: cannot use reg (type [3]string) as type []string in argument to strings.Join

Is there a more direct/better way than looping and adding to a var?

Content Type	Original Author	Original Content on Stackoverflow
Question	marcio	View Question on Stackoverflow
Solution 1 - Go	laurent	View Answer on Stackoverflow

How to check if a slice has a given index in Go?

Go Problem Overview

Go Solutions

Solution 1 - Go

Getting a weird percent sign in printf output in terminal with C

What exactly is a "grafted" commit in a shallow clone?

Attributions