It&#39;s a [Type assertion][1]. A type assertion can be used to:

- obtain a value of _concrete_ type from a value of _interface_ type
- or to obtain a value of a _different_ interface type than the initial one (an interface with a different [method set][2], practically not subset of the original one as that could simply be obtained using a simple type [conversion][3]).

Quoting from the spec:

&gt; For an expression `x` of interface type and a type `T`, the primary expression
&gt;
&gt;     x.(T)
&gt;
&gt; asserts that `x` is not `nil` and that the value stored in `x` is of type `T`. The notation `x.(T)` is called a _type assertion_.
&gt;
&gt; More precisely, if `T` is not an interface type, `x.(T)` asserts that the dynamic type of `x` is [identical][4] to the type `T`. In this case, `T` must [implement][2] the (interface) type of `x`; otherwise the type assertion is invalid since it is not possible for `x` to store a value of type `T`. If `T` is an interface type, `x.(T)` asserts that the dynamic type of `x` implements the interface `T`.

More specifically your example is a special form of it which also reports whether the type assertion holds. If not, `ok` will be `false`, and if the assertion holds, `ok` will be `true`.

This special form never panics unlike the form of:

    paxPayment = dataObject.(*entities.PassengerPayment)

Which if `dataObject` does not hold a value of type `*entities.PassengerPayment` will panic.


  [1]: https://golang.org/ref/spec#Type_assertions
  [2]: https://golang.org/ref/spec#Method_sets
  [3]: https://golang.org/ref/spec#Conversions
  [4]: https://golang.org/ref/spec#Type_identity

Is there a way to tell cURL command not to use server&#39;s side cache?
e.g; I have this curl command: 

`curl -v www.example.com`

How can I ask curl to send a fresh request to not use the cache?

**Note**: I am looking for an executable command in the terminal.

How to call cURL without using server-side cache?

I know there are other topics on this, but I can&#39;t seem to find out how to implement it.

I&#39;m trying to limit a UITextField to only five characters.

Preferably alphanumeric, `-`, `.`, and `_`.

I&#39;ve seen this code:

    func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange,
                           replacementString string: String) -&gt; Bool
    {
        let maxLength = 4
        let currentString: NSString = textField.text
        let newString: NSString =
                 currentString.stringByReplacingCharactersInRange(range, withString: string)
        return newString.length &lt;= maxLength
    }

and

    func textField(textField: UITextField, shouldChangeCharactersInRange range: NSRange, replacementString string: String) -&gt; Bool {

        let length = count(textField.text.utf16) + count(string.utf16) - range.length
        return length &lt;= 10
    }

How can I actually implement it? Which &quot;textfield&quot; should I swap out for my custom named UITextField?





Set the maximum character length of a UITextField in Swift

`paxPayment, ok = dataObject.(*entities.PassengerPayment)`

What are the brackets used for? I&#39;m not sure what is going on in this assignment operation.

Do you need any more details to answer this question?

Is this casting in golang?

<code>paxPayment, ok = dataObject.(*entities.PassengerPayment)</code>
What are the brackets used for? I'm not sure what is going on in this assignment operation.
Do you need any more details to answer this question?

I&#39;m currently pondering how to write tests that check if a given piece of code panicked? I know that Go uses [`recover`][1] to catch panics, but unlike say, Java code, you can&#39;t really specify what code should be skipped in case of a panic or what have you. So if I have a function:

    func f(t *testing.T) {
        defer func() {
            if r := recover(); r != nil {
                fmt.Println(&quot;Recovered in f&quot;, r)
            }
        }()
        OtherFunctionThatPanics()
        t.Errorf(&quot;The code did not panic&quot;)
    }

I can&#39;t really tell whether `OtherFunctionThatPanics` panicked and we recovered, or if the function did not panic at all. How do I specify which code to skip over if there is no panic and which code to execute if there is a panic? How can I check whether there was some panic we recovered from?

  [1]: https://golang.org/doc/effective_go.html#recover

How to test panics?

**Question:** Currently I&#39;m printing out my response in the `func Index`
like this `fmt.Fprintf(w, string(response))` **however, how can I send JSON properly in the request so that it maybe consumed by a view?** 

    package main
    
    import (
    	&quot;fmt&quot;
    	&quot;github.com/julienschmidt/httprouter&quot;
    	&quot;net/http&quot;
    	&quot;log&quot;
    	&quot;encoding/json&quot;
    )
    
    type Payload struct {
    	Stuff Data
    }
    type Data struct {
    	Fruit Fruits
    	Veggies Vegetables
    }
    type Fruits map[string]int
    type Vegetables map[string]int
    
    
    func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    	response, err := getJsonResponse();
    	if err != nil {
    		panic(err)
    	}
    	fmt.Fprintf(w, string(response))
    }
    
    
    func main() {
    	router := httprouter.New()
    	router.GET(&quot;/&quot;, Index)
    	log.Fatal(http.ListenAndServe(&quot;:8080&quot;, router))
    }
    
    func getJsonResponse()([]byte, error) {
    	fruits := make(map[string]int)
    	fruits[&quot;Apples&quot;] = 25
    	fruits[&quot;Oranges&quot;] = 10
    
    	vegetables := make(map[string]int)
    	vegetables[&quot;Carrats&quot;] = 10
    	vegetables[&quot;Beets&quot;] = 0
    
    	d := Data{fruits, vegetables}
    	p := Payload{d}
    
    	return json.MarshalIndent(p, &quot;&quot;, &quot;  &quot;)
    }

How to serve up a JSON response using Go?

Is there a way how to set that certain flags are mandatory, or do I have to check for their presence on my own?

Can command line flags in Go be set to mandatory?

I am writing a utility function for my unit tests which is used by unit tests in multiple packages. This utility function must read a particular file (always the same file). Here are three solutions which do not work, to explain what I am looking for and why.

1. Hardcode the absolute path. This fails because another user who is trying to test the project might have a different prefix on the absolute path.

2. Hardcode a relative path from the path of the file which defines the utility function. This fails because packages which import and use this function are not necessarily at the same level of the file hierarchy as the file that defines the utility function, and relative paths are interpreted relative to the importer, not the imported.

3. Pass in the relative path to the file from every caller relative to the caller&#39;s package. This actually works but seems to be very verbose because now every caller must be changed to pass one file.

I see a fourth solution, whereby I can hardcode a path in the utility function which is relative to the root directory of the top-level package. However, I have not been able to find a way to get the root directory in code, although I suspect there is one because imports can be resolved from the root.

**Thus, how might I get the sought-after root directory?**

I&#39;ve looked over various Go documents but have so far failed to find a solution. I have also seen [this question](https://stackoverflow.com/questions/17071286/how-can-i-open-files-using-relative-paths-in-go) but the solution there is equivalent to #3 above.

Is it possible to get the current root of package structure as a string in golang test?

Golang newbie here. 

Is there a functional difference between

    func randomNumberGenerator() &lt;-chan int {

and 

    func randomNumberGenerator() chan int {

I&#39;ve tried using both and they seem to work fine for me.

I&#39;ve seen the former used by Rob Pike (one of Go creators) in his Go Concurrency Patterns talk at Google IO 2012. I&#39;ve also seen it used in Go&#39;s official website. Why add 2 extra characters (&quot;&lt;-&quot;) when you can omit it? I&#39;ve tried looking for the difference on the web, but couldn&#39;t find it.

What&#39;s the difference between &quot;&lt;-chan&quot; and &quot;chan&quot; as a function return type?

    function f([a,b,c]) {
      // this works but a,b and c are any
    }
it&#39;s possible write something like that?

    function f([a: number,b: number,c: number]) {
      // being a, b and c typed as number 
    }



Types when destructuring arrays

In [this question](https://stackoverflow.com/q/32053402/155423), an issue arose that could be solved by changing an attempt at using a generic type parameter into an associated type. That prompted the question &quot;Why is an associated type more appropriate here?&quot;, which made me want to know more.

The [RFC that introduced associated types](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md) says:

&gt; This RFC clarifies trait matching by:
&gt;
&gt; * Treating all trait type parameters as *input types*, and
&gt; * Providing associated types, which are *output types*.

The RFC uses a graph structure as a motivating example, and this is also used in [the documentation](https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#specifying-placeholder-types-in-trait-definitions-with-associated-types), but I&#39;ll admit to not fully appreciating the benefits of the  the associated type version over the type-parameterized version. The primary thing is that the `distance` method doesn&#39;t need to care about the `Edge` type. This is nice, but seems a bit shallow of a reason for having associated types at all.

I&#39;ve found associated types to be pretty intuitive to use in practice, but I find myself struggling when deciding where and when I should use them in my own API.

When writing code, when should I choose an associated type over a generic type parameter, and when should I do the opposite?

When is it appropriate to use an associated type versus a generic type?

I&#39;m puzzled by how the haskell compiler sometimes infers types that are less
polymorphic than what I&#39;d expect, for example when using point-free definitions.

It seems like the issue is the &quot;monomorphism restriction&quot;, which is on by default on
older versions of the compiler.

Consider the following haskell program:

    {-# LANGUAGE MonomorphismRestriction #-}

    import Data.List(sortBy)

    plus = (+)
    plus&#39; x = (+ x)

    sort = sortBy compare

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus 1.0 2.0
      print $ sort [3, 1, 2]


If I compile this with `ghc` I obtain no erros and the output of the executable is:

    3.0
    3.0
    [1,2,3]

If I change the `main` body to:

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus (1 :: Int) 2
      print $ sort [3, 1, 2]

I get no compile time errors and the output becomes:

    3.0
    3
    [1,2,3]

as expected. However if I try to change it to:

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus (1 :: Int) 2
      print $ plus 1.0 2.0
      print $ sort [3, 1, 2]

I get a type error:

&lt;!-- language: lang-none --&gt;

    test.hs:13:16:
        No instance for (Fractional Int) arising from the literal ‘1.0’
        In the first argument of ‘plus’, namely ‘1.0’
        In the second argument of ‘($)’, namely ‘plus 1.0 2.0’
        In a stmt of a &#39;do&#39; block: print $ plus 1.0 2.0

The same happens when trying to call `sort` twice with different types:

    main = do
      print $ plus&#39; 1.0 2.0
      print $ plus 1.0 2.0
      print $ sort [3, 1, 2]
      print $ sort &quot;cba&quot;

produces the following error:

&lt;!-- language: lang-none --&gt;

    test.hs:14:17:
        No instance for (Num Char) arising from the literal ‘3’
        In the expression: 3
        In the first argument of ‘sort’, namely ‘[3, 1, 2]’
        In the second argument of ‘($)’, namely ‘sort [3, 1, 2]’


 - Why does `ghc` suddenly think that `plus` isn&#39;t polymorphic and requires an `Int` argument?
   The only reference to `Int` is in *an application* of `plus`, how can that matter
   when the definition is clearly polymorphic?
 - Why does `ghc` suddenly think that `sort` requires a `Num Char` instance?

Moreover if I try to place the function definitions into their own module, as in:

    {-# LANGUAGE MonomorphismRestriction #-}

    module TestMono where

    import Data.List(sortBy)

    plus = (+)
    plus&#39; x = (+ x)

    sort = sortBy compare

I get the following error when compiling:

&lt;!-- language: lang-none --&gt;

    TestMono.hs:10:15:
        No instance for (Ord a0) arising from a use of ‘compare’
        The type variable ‘a0’ is ambiguous
        Relevant bindings include
          sort :: [a0] -&gt; [a0] (bound at TestMono.hs:10:1)
        Note: there are several potential instances:
          instance Integral a =&gt; Ord (GHC.Real.Ratio a)
            -- Defined in ‘GHC.Real’
          instance Ord () -- Defined in ‘GHC.Classes’
          instance (Ord a, Ord b) =&gt; Ord (a, b) -- Defined in ‘GHC.Classes’
          ...plus 23 others
        In the first argument of ‘sortBy’, namely ‘compare’
        In the expression: sortBy compare
        In an equation for ‘sort’: sort = sortBy compare

 - Why isn&#39;t `ghc` able to use the polymorphic type `Ord a =&gt; [a] -&gt; [a]` for `sort`?
 - And why does `ghc` treat `plus` and `plus&#39;` differently? `plus` should have the
  polymorphic type `Num a =&gt; a -&gt; a -&gt; a` and I don&#39;t really see how this is different
  from the type of `sort` and yet only `sort` raises an error.

Last thing: if I comment the definition of `sort` the file compiles. However
if I try to load it into `ghci` and check the types I get:

&lt;!-- language: lang-none --&gt;

    *TestMono&gt; :t plus
    plus :: Integer -&gt; Integer -&gt; Integer
    *TestMono&gt; :t plus&#39;
    plus&#39; :: Num a =&gt; a -&gt; a -&gt; a

Why isn&#39;t the type for `plus` polymorphic?


----

&lt;sup&gt;
This is the canonical question about monomorphism restriction in Haskell
as discussed in [the meta question](https://meta.stackoverflow.com/questions/294053/can-we-provide-a-canonical-questionanswer-for-haskells-monomorphism-restrictio).
&lt;/sup&gt;

What is the monomorphism restriction?

How do I pythonicly do:

```py
var = 7.0
var_is_good = isinstance(var, classinfo1) or isinstance(var, classinfo2) or isinstance(var, classinfo3) or ... or  isinstance(var, classinfoN)
```

It seems silly I can&#39;t just pass in a list of classinfo&#39;s:

```py
var_is_good = isinstanceofany( var, [classinfo1, classinfo2, ... , classinfoN] )
```

So what is the `isinstanceofany` function?


Python check if isinstance any type in list?

I use c++11, but also some libraries that are not configured for it, and need some type conversion. In particular I need a way to convert `std::__cxx11::string` to regular `std::string`, but googling I can&#39;t find a way to do this and putting `(string)` in front does not work.

If I do not convert I get linker errors like this:

    undefined reference to `H5::CompType::insertMember(std::__cxx11::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt; const&amp;, unsigned long, H5::DataType const&amp;) const&#39;


Converting std::__cxx11::string to std::string

I need to convert a `Decimal` value to `float` in Python. Is there any method available for this type conversion?

How to do Decimal to float conversion in Python?

During a recent job interview process, I submitted some sample Perl code which used the so-called &quot;secret&quot; `!!` [operator](http://search.cpan.org/dist/perlsecret/lib/perlsecret.pod#Bang_bang).  Later, when discussing the code, one of the interviewers asked me why I chose to use that, and indicated that it was considered bad form. He didn&#39;t elaborate as to why.

My team and I have been using this operator for years, without ever realizing it was considered &quot;bad form.&quot;

Does the &quot;bang bang&quot; operator have side-effects or other unexpected behavior? Why is it, or might it be, considered &quot;bad form&quot; by some? Is there an idiomatic alternative?

Below are a few examples where I would have considered `!!` acceptable and/or desirable.

1. The actual code in the coding exercise, which is an example of adding booleans:

        while (my $line = &lt;$F&gt;) {
            # snip
            exists $counts{lines} and $counts{lines} += !! chomp $line;
        }

2. Using a boolean value as a hash key (clearly a simplified example):

        sub foo {
            my ($input) = @_;
            my %responses = ( &#39;&#39; =&gt; &quot;False&quot;, 1 =&gt; &quot;True&quot; );
            return $responses{ !! $input };
        }

3. Using a boolean in a bitwise operation, or even `pack()`:

        sub foo {
            my ( $a, $b, $c ) = @_;
            my $result = !!$a + (!! $b)&lt;&lt;1 + (!! $c)&lt;&lt;2;
            return $result;
        }

4. You need to do a typecast for use by an external library/process, such as a database, which only considers certain values to be truthy:

        my $sth = $dbh-&gt;prepare(&quot;INSERT INTO table (flag,value) VALUES (?,?)&quot;)
        $sth-&gt;execute(&quot;i_haz_cheeseburger&quot;, !! $cheeseburger_string)




Why is &quot;!!&quot; considered bad form in Perl?

I can convert `Vec&lt;String&gt;` to `Vec&lt;&amp;str&gt;` this way:

    let mut items = Vec::&lt;&amp;str&gt;::new();
    for item in &amp;another_items {
        items.push(item);
    }

Are there better alternatives?

How do I convert a Vec&lt;String&gt; to Vec&lt;&amp;str&gt;?

I&#39;m currently working on an encryption/decryption program and I need to be able to convert bytes to an integer. I know that:

    bytes([3]) = b&#39;\x03&#39;

Yet I cannot find out how to do the inverse. What am I doing terribly wrong?


Convert bytes to int?

In C# I can convert doubles to floats by a cast `(float)` or by `Convert.ToSingle()`.

	double x = 3.141592653589793238463;
	float a = (float)x;
	float b = Convert.ToSingle(x);

`a` and `b` become equal.

Are there any differences between both techniques? Which one should I prefer and why?

Content Type	Original Author	Original Content on Stackoverflow
Question	Varun Patro	View Question on Stackoverflow
Solution 1 - Go	icza	View Answer on Stackoverflow

Is this casting in golang?

Go Problem Overview

Go Solutions

Solution 1 - Go

Set the maximum character length of a UITextField in Swift

How to call cURL without using server-side cache?

Attributions