`go` starts a *goroutine*, which is managed by `golang` run-time.

It can either run on the current OS thread, or it can run on a different OS thread automatically.

You can refer to basic `golang` documents for this, for example, one item in Google search keyword `goroutine` is [golang concurrency][1].


  [1]: https://www.golang-book.com/books/intro/10

When you use the Go keyword before a func ure making that func run into a goRoutine, is like a Java Thread, and is the go way for concurrency, more info [here][1]. Good Luck


  [1]: https://gobyexample.com/goroutines

Concurrency is not well documented in the go spec and it is one of the most powerful features of the language, the ```go``` keyword is the starting point when you are building concurrent software and not procedural software in go.

You need to look at channels as well to better understand this concept.

When you removed the ```go``` keyword, you made the function call procedural.

Check out the talk by Rob Pike (Creator of Go) on concurrency in golang. 
   https://www.youtube.com/watch?v=f6kdp27TYZs&amp;t=1198s&amp;ab_channel=GoogleDevelopers

Recently I came across a class that uses `use` statement inside of the class definition.

Could someone explain what exactly does it do - as I can&#39;t find any information about it.

I understand that it might be a way of moving it away form a global scope of the given file, but does it perhaps allow the given class inherit from multiple parent classes as well - since `extends` only allows one parent class reference?

The example I saw was in the User model of the original installation of Laravel:

    &lt;?php
    
    use Illuminate\Auth\UserTrait;
    use Illuminate\Auth\UserInterface;
    use Illuminate\Auth\Reminders\RemindableTrait;
    use Illuminate\Auth\Reminders\RemindableInterface;
    
    class User extends Eloquent implements UserInterface, RemindableInterface {
    
    	use UserTrait, RemindableTrait;
    
    	/**
    	 * The database table used by the model.
    	 *
    	 * @var string
    	 */
    	protected $table = &#39;users&#39;;
    
    	/**
    	 * The attributes excluded from the model&#39;s JSON form.
    	 *
    	 * @var array
    	 */
    	protected $hidden = array(&#39;password&#39;, &#39;remember_token&#39;);
    
    }

and I&#39;ve seen some examples of this model actually using methods included within the `UserTrait` class - hence my suspicion, but would really like to find out more about the meaning of the enclosed `use` statements.

[PHP documentation][1] says:

&gt; The use keyword must be declared in the outermost scope of a file (the
&gt; global scope) or inside namespace declarations. This is because the
&gt; importing is done at compile time and not runtime, so it cannot be
&gt; block scoped. The following example will show an illegal use of the
&gt; use keyword:

followed by the example:

    namespace Languages;
    
    class Greenlandic
    {
        use Languages\Danish;
    
        ...
    }

which would indicate that it is an incorrect use of the `use` keyword - any clues?


  [1]: http://php.net/manual/en/language.namespaces.importing.php

PHP : &#39;use&#39; inside of the class definition

Going through Haskell&#39;s documentation is always a bit of a pain for me, because all the information you get about a function is often nothing more than just: `f a -&gt; f [a]` which could mean any number of things.

As is the case of the `&lt;|&gt;` function.

All I&#39;m given is this: `(&lt;|&gt;) :: f a -&gt; f a -&gt; f a` and that it&#39;s an _&quot;associative binary operation&quot;_...

Upon inspection of `Control.Applicative` I learn that it does seemingly unrelated things depending on implementation.

    instance Alternative Maybe where
        empty = Nothing
        Nothing &lt;|&gt; r = r
        l       &lt;|&gt; _ = l

Ok, so it returns right if there is no left, otherwise it returns left, gotcha.. This leads me to believe it&#39;s a &quot;left or right&quot; operator, which kinda makes sense given its use of `|` and `|`&#39;s historical use as &quot;OR&quot;
    
    instance Alternative [] where
        empty = []
        (&lt;|&gt;) = (++)

Except here it just calls list&#39;s concatenation operator... Breaking my idea down...

So what exactly is that function? What&#39;s its use? Where does it fit in in the grand scheme of things?

What does Haskell&#39;s &lt;|&gt; operator do?

I was going through an example of a TCP server. They defined a function and called it with:

    go handleRequest(conn)

I thought it was weird seeing the `go` keyword, so I tried it without:

    handleRequest(conn)

To my surprise, this worked!

 - If both work the same way, why use the `go` keyword at all?
 - If they work differently, what is the difference?
 - Is there a certain style guideline to use, or should you just use personal preference?

Why use the `go` keyword when calling a function?

I was going through an example of a TCP server. They defined a function and called it with:
<pre><code class="hljs language-scss">go handleRequest(conn)
</code></pre>
I thought it was weird seeing the <code>go</code> keyword, so I tried it without:
<pre><code class="hljs language-scss">handleRequest(conn)
</code></pre>
To my surprise, this worked!
<ul>
<li>If both work the same way, why use the <code>go</code> keyword at all?</li>
<li>If they work differently, what is the difference?</li>
<li>Is there a certain style guideline to use, or should you just use personal preference?</li>
</ul>

I&#39;m familiar with the fact that, in Go, interfaces define functionality, rather than data.  You put a set of methods into an interface, but you are unable to specify any fields that would be required on anything that implements that interface.

For example: 

    // Interface
    type Giver interface {
        Give() int64
    }
    
    // One implementation
    type FiveGiver struct {}
    
    func (fg *FiveGiver) Give() int64 {
        return 5
    }
    
    // Another implementation
    type VarGiver struct {
        number int64
    }
    
    func (vg *VarGiver) Give() int64 {
        return vg.number
    }

Now we can use the interface and its implementations:
    
    // A function that uses the interface
    func GetSomething(aGiver Giver) {
        fmt.Println(&quot;The Giver gives: &quot;, aGiver.Give())
    }
    
    // Bring it all together
    func main() {
        fg := &amp;FiveGiver{}
        vg := &amp;VarGiver{3}
        GetSomething(fg)
        GetSomething(vg)
    }
    
    /*
    Resulting output:
    5
    3
    */

Now, what you *can&#39;t* do is something like this:

    type Person interface {
        Name string
        Age int64
    }
    
    type Bob struct implements Person { // Not Go syntax!
        ...
    }
    
    func PrintName(aPerson Person) {
        fmt.Println(&quot;Person&#39;s name is: &quot;, aPerson.Name)
    }
    
    func main() {
        b := &amp;Bob{&quot;Bob&quot;, 23}
        PrintName(b)
    }

However, after playing around with interfaces and embedded structs, I&#39;ve discovered a way to do this, after a fashion:

    type PersonProvider interface {
        GetPerson() *Person
    }
    
    type Person struct {
        Name string
        Age  int64
    }
    
    func (p *Person) GetPerson() *Person {
        return p
    }
    
    type Bob struct {
        FavoriteNumber int64
        Person
    }

Because of the embedded struct, Bob has everything Person has.  It also implements the PersonProvider interface, so we can pass Bob into functions that are designed to use that interface.

    func DoBirthday(pp PersonProvider) {
        pers := pp.GetPerson()
        pers.Age += 1
    }
    
    func SayHi(pp PersonProvider) {
        fmt.Printf(&quot;Hello, %v!\r&quot;, pp.GetPerson().Name)
    }
    
    func main() {
        b := &amp;Bob{
            5,
            Person{&quot;Bob&quot;, 23},
        }
        DoBirthday(b)
        SayHi(b)
        fmt.Printf(&quot;You&#39;re %v years old now!&quot;, b.Age)
    }

[Here is a Go Playground][1] that demonstrates the above code.

Using this method, I can make an interface that defines data rather than behavior, and which can be implemented by any struct just by embedding that data.  You can define functions that explicitly interact with that embedded data and are unaware of the nature of the outer struct.  And everything is checked at compile time!  (The only way you could mess up, that I can see, would be embedding the interface `PersonProvider` in `Bob`, rather than a concrete `Person`.  It would compile and fail at runtime.)

Now, here&#39;s my question: is this a neat trick, or should I be doing it differently?


  [1]: http://play.golang.org/p/s9A8M7eT3i

Go Interface Fields

I have a test suite for a Go package that implements a dozen tests. Sometimes, one of the tests in the suite fails and I&#39;d like to re-run that test individually to save time in debugging process. Is this possible or do I have to write a separate file for this every time?

Just run single test instead of the whole suite?

I have two files `main.go` which is under `package main`, and another file with some functions in the package called functions.

My question is: How can I call a function from `package main`?

**File 1: main.go (located in MyProj/main.go)**

    package main

    import &quot;fmt&quot;
    import &quot;functions&quot; // I dont have problem creating the reference here

    func main(){
        c:= functions.getValue() // &lt;---- this is I want to do
    }

**File 2: functions.go (located in MyProj/functions/functions.go)**

    package functions

    func getValue() string{
        return &quot;Hello from this another package&quot;
    }


Call a function from another package in Go

How can I look up the value of a map by using a variable key without iterating? 

So one can lookup a constant key on variable map $x with `$x.key1`, but is it possible to do `amap.$key`?
 

Access a map value using a variable key in a Go template

I&#39;m newbie in Go. This issue is driving me nuts. How do you init array of structs in Go?

    type opt struct {
    	shortnm      char
    	longnm, help string
    	needArg      bool
    }
    
    const basename_opts []opt { 
        	opt {
                shortnm: &#39;a&#39;, 
                longnm: &quot;multiple&quot;, 
                needArg: false, 
                help: &quot;Usage for a&quot;}
            },
            opt {
                shortnm: &#39;b&#39;, 
                longnm: &quot;b-option&quot;, 
                needArg: false, 
                help: &quot;Usage for b&quot;}
        }

The compiler said it expecting `;` after `[]opt`.

Where should I put the braces `{` to init my array of struct?

Content Type	Original Author	Original Content on Stackoverflow
Question	hmatt1	View Question on Stackoverflow
Solution 1 - Go	WiSaGaN	View Answer on Stackoverflow
Solution 2 - Go	Eefret	View Answer on Stackoverflow
Solution 3 - Go	Margach Chris	View Answer on Stackoverflow

Why use the `go` keyword when calling a function?

Go Problem Overview

Go Solutions

Solution 1 - Go

Solution 2 - Go

Solution 3 - Go

What does Haskell's <|> operator do?

PHP : 'use' inside of the class definition

Attributions