No, Go switch statements do not fall through by default. If you *do* want it to fall through, you must explicitly use a `fallthrough` statement. From the [spec](https://go.dev/ref/spec#Expression_switches):

&gt; In a case or default clause, the last non-empty statement may be a
&gt; (possibly labeled) &quot;fallthrough&quot; statement to indicate that control
&gt; should flow from the end of this clause to the first statement of the next clause. Otherwise control flows to the end of the &quot;switch&quot;
&gt; statement. A &quot;fallthrough&quot; statement may appear as the last statement of all but the last clause of an expression switch.

For example (sorry, I could not for the life of me think of a real example):

	switch 1 {
	case 1:
		fmt.Println(&quot;I will print&quot;)
		fallthrough
	case 0:
		fmt.Println(&quot;I will also print&quot;)
	}

Outputs:

```lang-none
I will print
I will also print
```

https://play.golang.org/p/va6R8Oj02z

Break is kept as a default but not fallthrough. If you want to get onto the next case for a match, you should explicitly mention fallthrough. 

    switch choice {
    case &quot;optionone&quot;:
        // some instructions 
        fallthrough // control will not come out from this case but will go to next case.
    case &quot;optiontwo&quot;:
       // some instructions 
    default: 
       return 
    }

I have a DataFrame with some (hundreds of) million of rows. And I want to convert datetime to timestamp effectively. How can I do it?

My sample `df`:

    df = pd.DataFrame(index=pd.DatetimeIndex(start=dt.datetime(2016,1,1,0,0,1),
        end=dt.datetime(2016,1,2,0,0,1), freq=&#39;H&#39;))\
        .reset_index().rename(columns={&#39;index&#39;:&#39;datetime&#39;})

which looks like:

                 datetime
    0 2016-01-01 00:00:01
    1 2016-01-01 01:00:01
    2 2016-01-01 02:00:01
    3 2016-01-01 03:00:01
    4 2016-01-01 04:00:01

Now I convert datetime to timestamp value-by-value with `.apply()` but it takes a very long time (some hours) if I have some (hundreds of) million rows:

    df[&#39;ts&#39;] = df[[&#39;datetime&#39;]].apply(lambda x: x[0].timestamp(), axis=1).astype(int)

Output:

                 datetime          ts
    0 2016-01-01 00:00:01  1451602801
    1 2016-01-01 01:00:01  1451606401
    2 2016-01-01 02:00:01  1451610001
    3 2016-01-01 03:00:01  1451613601
    4 2016-01-01 04:00:01  1451617201

The above result is what I want.

If I try to use the `.dt` accessor of `pandas.Series` then I get error message:

    df[&#39;ts&#39;] = df[&#39;datetime&#39;].dt.timestamp

&gt; AttributeError: &#39;DatetimeProperties&#39; object has no attribute
&gt; &#39;timestamp&#39;

If I try to create eg. the date parts of datetimes with the `.dt` accessor then it is much faster then using `.apply()`:

    df[&#39;date&#39;] = df[&#39;datetime&#39;].dt.date

Output:

                 datetime          ts        date
    0 2016-01-01 00:00:01  1451602801  2016-01-01
    1 2016-01-01 01:00:01  1451606401  2016-01-01
    2 2016-01-01 02:00:01  1451610001  2016-01-01
    3 2016-01-01 03:00:01  1451613601  2016-01-01
    4 2016-01-01 04:00:01  1451617201  2016-01-01

I want something similar with timestamps...

But I don&#39;t really understand the official documentation: it talks about &quot;[Converting to Timestamps][1]&quot; but I don&#39;t see any timestamps there; it just talks about converting to datetime with `pd.to_datetime()` but not to timestamp...

`pandas.Timestamp` constructor also doesn&#39;t work (returns with the below error):

    df[&#39;ts2&#39;] = pd.Timestamp(df[&#39;datetime&#39;])

&gt; TypeError: Cannot convert input to Timestamp

[`pandas.Series.to_timestamp`][2] also makes something totally different from what I want:

    df[&#39;ts3&#39;] = df[&#39;datetime&#39;].to_timestamp

Output:

                 datetime          ts                                                ts3
    0 2016-01-01 00:00:01  1451602801  &lt;bound method Series.to_timestamp of 0    2016...
    1 2016-01-01 01:00:01  1451606401  &lt;bound method Series.to_timestamp of 0    2016...
    2 2016-01-01 02:00:01  1451610001  &lt;bound method Series.to_timestamp of 0    2016...
    3 2016-01-01 03:00:01  1451613601  &lt;bound method Series.to_timestamp of 0    2016...
    4 2016-01-01 04:00:01  1451617201  &lt;bound method Series.to_timestamp of 0    2016...



  [1]: http://pandas.pydata.org/pandas-docs/stable/timeseries.html#converting-to-timestamps
  [2]: http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.to_timestamp.html

Python pandas convert datetime to timestamp effectively through dt accessor

According to Scott Meyers, one area where C++ shines over C is that function objects are faster than function pointers. He says this is because function objects are inlined, which increases speed.

I have two questions about this:

 1. How can we verify that function objects are, in fact, inlined? Can we verify this in practice?

 2. Does the inlining of function objects depend on the compiler we use, or do all compilers behave like this?


Are functors actually faster than pointers to functions?

What happens when you reach the end of a Go case, does it fall through to the next, or assume that most applications don&#39;t want to fall through?

Do Go switch/cases fallthrough or not?

<p>What happens when you reach the end of a Go case, does it fall through to the next, or assume that most applications don't want to fall through?</p>


There are already several Q&amp;As on this &quot;*X does not implement Y (... method has a pointer receiver)*&quot; thing, but to me, they seems to be talking about different things, and not applying to my specific case.

So, instead of making the question very specific, I&#39;m making it broad and abstract -- Seems like there are several different cases that can make this error happen, can someone summary it up please?

I.e., how to avoid the problem, and if it occurs, what are the possibilities? Thx.

X does not implement Y (... method has a pointer receiver)

I am passing an uuid in using the `Context` and `WithValue` to subsequent functions that handle this `*http.request`. This uuid is was passed in the authorization header to a REST call to identify a person. The authorization token is verified and needs to accessible to check if the call is itself is authorized.

I used:

    ctx := context.WithValue(r.Context(), string(&quot;principal_id&quot;), *id)

But golint complains: 

    should not use basic type string as key in context.WithValue
 
What is the best option that could be used to retrieve this key that is not a basic type like a simple string? 



Fix &quot;should not use basic type string as key in context.WithValue&quot; golint

In golang&#39;s template/html package, I can use `{{ if .loggedIn }}` to check if logged in is true.

How do I check if .loggedIn is false without using ne or eq?


----------


For example, I am looking for something like

    {{ if !.loggedIn }}
    &lt;h1&gt;Not logged in&lt;/h1&gt;
    {{ end }}

If not true (!true)

I am using go-ping ( https://github.com/sparrc/go-ping )library of golang for unprivileged ICMP ping.

    timeout := time.Second*1000
    interval := time.Second
    count := 5
    host := p.ipAddr
    pinger, cmdErr := ping.NewPinger(host)

    pinger.Count = count
    pinger.Interval = interval
    pinger.Timeout = timeout
    pinger.SetPrivileged(false)
    pinger.Run()
    stats := pinger.Statistics()

    latency = stats.AvgRtt  // stats.AvgRtt is time.Duration type
    jitter = stats.StdDevRtt// stats.StdDevRtt is time.Duration type

        
From running this, I am getting latency in milliseconds and jitter in microseconds. I want same unit for both let&#39;s say millisecond so when I am doing `jitter = stats.StdDevRtt/1000` or `jitter = jitter/1000` (to convert microseconds to milliseconds), what I am getting is jitter in nanoseconds :(. Is there any way to get same unit milliseconds for both latency and jitter.


Conversion of time.Duration type microseconds value to milliseconds

What is the difference between cap and len of a slice in golang?

According to definition:

A slice has both a length and a capacity.

The length of a slice is the number of elements it contains.

The capacity of a slice is the number of elements in the underlying array, counting from the first element in the slice.

    x := make([]int, 0, 5) // len(b)=0, cap(b)=5

Does the len mean non null values only?

cap vs len of slice in golang

Through a little typo, I accidentally found this construct:

    int main(void) {
    	char foo = &#39;c&#39;;
     
    	switch(foo)
    	{
    		printf(&quot;Cant Touch This\n&quot;);   // This line is Unreachable

    		case &#39;a&#39;: printf(&quot;A\n&quot;); break;
    		case &#39;b&#39;: printf(&quot;B\n&quot;); break;
    		case &#39;c&#39;: printf(&quot;C\n&quot;); break;
    		case &#39;d&#39;: printf(&quot;D\n&quot;); break;
    	}
     
    	return 0;
    }

It seems that the `printf` at the top of the `switch` statement is valid, but also completely unreachable.

I got a clean compile, without even a warning about unreachable code, but this seems pointless.

Should a compiler flag this as unreachable code?&lt;br&gt;
Does this serve any purpose at all?

Valid, but worthless syntax in switch-case?

What&#39;s the difference between:

    switch (expression) {
        case:
          somethings;
          break;
    }

and

    switch (expression) {
        case: {
          somethings;
          break;
        }
    }

At first I thought that I could return an object literal like so, but it turns out it&#39;s a syntax error. What&#39;s the difference actually?

Example from another question:
https://stackoverflow.com/questions/42475118/how-to-pass-switch-statement-as-function-argument-in-javascript-es6/42475344#42475344

What do the curly braces do in switch statement after case in es6?

Given the following code:

    string someString = null;
    switch (someString)
    {
        case string s:
            Console.WriteLine(&quot;string s&quot;);
            break;
        case var o:
            Console.WriteLine(&quot;var o&quot;);
            break;
        default:
            Console.WriteLine(&quot;default&quot;);
            break;
    }

Why is the switch statement matching on `case var o`?

It is my understanding that `case string s` does not match when `s == null` because (effectively) `(null as string) != null` evaluates to false. IntelliSense on VS Code tells me that `o` is a `string` as well. Any thoughts?

---

Similiar to: https://stackoverflow.com/questions/42950833/c-sharp-7-switch-case-with-null-checks

switch with var/null strange behavior

In the following piece of code, I use the standard [`[[fallthrough]]`](http://en.cppreference.com/w/cpp/language/attributes) attribute from C++1z to document that a fallthrough is desired:

    #include &lt;iostream&gt;

    int main() {
        switch (0) {
            case 0:
                std::cout &lt;&lt; &quot;a\n&quot;;
                [[fallthrough]]
            case 1:
                std::cout &lt;&lt; &quot;b\n&quot;;
                break;
        }
    }

With GCC 7.1, the code compiles without an error. However, the compiler still warns me about a fallthrough:

    warning: this statement may fall through [-Wimplicit-fallthrough=]
        std::cout &lt;&lt; &quot;a\n&quot;;
        ~~~~~~~~~~^~~~~~~~

Why?


Why is GCC warning me about a fallthrough even when I use [[fallthrough]]?

We are catching warnings from GCC 7 for implicit fall through in a switch statement. Previously, we cleared them under Clang (that&#39;s the reason for the comment seen below):

    g++ -DNDEBUG -g2 -O3 -std=c++17 -Wall -Wextra -fPIC -c authenc.cpp
    asn.cpp: In member function ‘void EncodedObjectFilter::Put(const byte*, size_t)’:
    asn.cpp:359:18: warning: this statement may fall through [-Wimplicit-fallthrough=]
        m_state = BODY;  // fall through
                      ^
    asn.cpp:361:3: note: here
       case BODY:
       ^~~~

The [GCC manual](https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html) states to use `__attribute__ ((fallthrough))`, but its not portable. The manual also states *&quot;... it is also possible to add a fallthrough comment to silence the warning&quot;*, but it only offer `FALLTHRU` (is this really the only choice?):

    switch (cond)
      {
      case 1:
        bar (0);
        /* FALLTHRU */
      default:
        …
      }

Is there a portable way to clear the fall through warning for both Clang and GCC? If so, then what is it?

Content Type	Original Author	Original Content on Stackoverflow
Question	mcandre	View Question on Stackoverflow
Solution 1 - Go	Sam Whited	View Answer on Stackoverflow
Solution 2 - Go	Milind Dhoke	View Answer on Stackoverflow

Do Go switch/cases fallthrough or not?

Go Problem Overview

Go Solutions

Solution 1 - Go

Solution 2 - Go

Are functors actually faster than pointers to functions?

Python pandas convert datetime to timestamp effectively through dt accessor

Attributions