You need to use the `index` template function.

    {{index .a 2}}

to access a field on an array item as go templating in *.yaml format : 

    {{ (index .Values.fields 0).fieldItem }}

Index of zero(0) as in fields array of field as fieldItem .

I&#39;m trying to do scale animation for `UIButton` when its clicked but what I&#39;m trying to accomplish is when the button clicked I need the `UIButton` to be smaller to the inside then it comes back to its same size (like a bubble).

I tried the following:

    button.transform = CGAffineTransformMakeScale(-1, 1)
        
    UIView.animateWithDuration(0.5, animations: { () -&gt; Void in
            
        button.transform = CGAffineTransformMakeScale(1,1)
            
    })

Scale UIButton Animation- Swift

I&#39;m using the new TabLayout from the Android Design library. I managed to set the textcolor statelist using [`tabLayout.setTabTextColors(colorstatelist)`][1] 

How can i achieve the same using styles.xml? 


  [1]: https://developer.android.com/reference/android/support/design/widget/TabLayout.html#setTabTextColors%28android.content.res.ColorStateList%29

TabLayout (Android Design Library) Text Color

How do I access an array item (e.g. a[2]) in templates?

Whenever I do this I get &quot;bad character U+005B &#39;[&#39;&quot;

    {{ .a[2] }}

Go templates: How do I access array item (arr[2]) in templates?

How do I access an array item (e.g. a[2]) in templates?
Whenever I do this I get "bad character U+005B '['"
<pre><code class="hljs language-css">{{ .a[2] }}
</code></pre>

Can I use `ngIf` without an extra container element?

    &lt;tr *ngFor=&quot;...&quot;&gt;
      &lt;div *ngIf=&quot;...&quot;&gt;
        ...
      &lt;/div&gt;
      &lt;div *ngIf=&quot;!...&quot;&gt;
        ...
      &lt;/div&gt;
    &lt;/tr&gt;

It doesn&#39;t work in a table because that would make invalid HTML.

Using ngIf without an extra element in Angular 2

The following is a simple template partial specialization:
----

    // #1
    template &lt;typename T, T n1, T n2&gt;
    struct foo { 
        static const char* scenario() {
            return &quot;#1 the base template&quot;;
        }
    };
    
    // #2
    // partial specialization where T is unknown and n1 == n2
    template &lt;typename T, T a&gt;
    struct foo&lt;T, a, a&gt; { 
        static const char* scenario() {
            return &quot;#2 partial specialization&quot;;
        }
    };

The main below gets different results on `g++ (6.1)` and `clang++ (3.8.0)`:

    extern const char HELLO[] = &quot;hello&quot;;
    double d = 2.3;

    int main() {
        cout &lt;&lt;   foo&lt;int, 1, 2&gt;                    ::scenario() &lt;&lt; endl;                   
        cout &lt;&lt;   foo&lt;int, 2, 2&gt;                    ::scenario() &lt;&lt; endl;                   
        cout &lt;&lt;   foo&lt;long, 3, 3&gt;                   ::scenario() &lt;&lt; endl;                  
        cout &lt;&lt;   foo&lt;double&amp;, d, d&gt;                ::scenario() &lt;&lt; endl;               
        cout &lt;&lt;   foo&lt;double*, &amp;d, &amp;d&gt;              ::scenario() &lt;&lt; endl;             
        cout &lt;&lt;   foo&lt;double*, nullptr, nullptr&gt;    ::scenario() &lt;&lt; endl;   
        cout &lt;&lt;   foo&lt;int*, nullptr, nullptr&gt;       ::scenario() &lt;&lt; endl;      
        cout &lt;&lt;   foo&lt;nullptr_t, nullptr, nullptr&gt;  ::scenario() &lt;&lt; endl; 
        cout &lt;&lt;   foo&lt;const char*, HELLO, HELLO&gt;    ::scenario() &lt;&lt; endl;
    }

Results on `g++` and `clang++`
----

&lt;code&gt;&lt;b&gt;#&lt;/b&gt; | &lt;b&gt;The code&lt;/b&gt;                          | &lt;b&gt;g++ (6.1)&lt;/b&gt;       |  &lt;b&gt;clang++ (3.8.0)&lt;/b&gt; |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;1 | foo&amp;lt;int, 1, 2&amp;gt;                    | #1 as expected  |  #1 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;2 | foo&amp;lt;int, 2, 2&amp;gt;                    | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;3 | foo&amp;lt;long, 3, 3&amp;gt;                   | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;4 | foo&amp;lt;double&amp;, d, d&amp;gt;                | #1 -- why?      |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;5 | foo&amp;lt;double*, &amp;d, &amp;d&amp;gt;              | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;6 | foo&amp;lt;double*, nullptr, nullptr&amp;gt;    | #2 as expected  |  #1 -- why?      |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;7 | foo&amp;lt;int*, nullptr, nullptr&amp;gt;       | #2 as expected  |  #1 -- why?      |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;8 | foo&amp;lt;nullptr_t, nullptr, nullptr&amp;gt;  | #2 as expected  |  #1 -- why?      |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;9 | foo&amp;lt;const char*, HELLO, HELLO&amp;gt;    | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;

Which one is right?
----

Code: https://godbolt.org/z/4GfYqxKn3

---
&lt;sub&gt;**EDIT, Dec-2021:**&lt;/sub&gt;

&lt;sub&gt;Along the years since the original post, the results have changed, [and were even identical for `gcc` and `clang` at a certain point in time][1], but checking again, `g++ (11.2)` and `clang++ (12.0.1)` [changed their results on references (case 4), but still differ on it][2]. It seems that currently `gcc` is getting it all right and `clang` is wrong on the reference case. &lt;/sub&gt;

&lt;code&gt;&lt;b&gt;#&lt;/b&gt; | &lt;b&gt;The code&lt;/b&gt;                          | &lt;b&gt;g++ (11.2)&lt;/b&gt;      | &lt;b&gt;clang++ (12.0.1)&lt;/b&gt; |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;1 | foo&amp;lt;int, 1, 2&amp;gt;                    | #1 as expected  |  #1 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;2 | foo&amp;lt;int, 2, 2&amp;gt;                    | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;3 | foo&amp;lt;long, 3, 3&amp;gt;                   | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;4 | foo&amp;lt;double&amp;, d, d&amp;gt;                | #2 as expected  |  #1 -- why?      |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;5 | foo&amp;lt;double*, &amp;d, &amp;d&amp;gt;              | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;6 | foo&amp;lt;double*, nullptr, nullptr&amp;gt;    | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;7 | foo&amp;lt;int*, nullptr, nullptr&amp;gt;       | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;8 | foo&amp;lt;nullptr_t, nullptr, nullptr&amp;gt;  | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;
&lt;code&gt;9 | foo&amp;lt;const char*, HELLO, HELLO&amp;gt;    | #2 as expected  |  #2 as expected  |&lt;/code&gt;&lt;br/&gt;


  [1]: https://godbolt.org/z/sadnWrsb9
  [2]: https://godbolt.org/z/97ajTMc3e

Template partial specialization for integral non-type parameters and non-integral non-types, difference between g++ and clang

What are the advantages of `auto` in template parameters that will (possibly) be introduced with C++17?

Is it just a natural extension of `auto` when I want to instantiate template code?

    auto v1 = constant&lt;5&gt;;      // v1 == 5, decltype(v1) is int
    auto v2 = constant&lt;true&gt;;   // v2 == true, decltype(v2) is bool
    auto v3 = constant&lt;&#39;a&#39;&gt;;    // v3 == &#39;a&#39;, decltype(v3) is char

What else do I gain from this language feature?




Advantages of auto in template parameters in C++17

[P0292R1 constexpr if][1] has been [included][2], on track for C++17. It seems useful (and can replace use of SFINAE), but a comment regarding `static_assert` being *ill-formed, no diagnostic required* in the false branch scares me:

    Disarming static_assert declarations in the non-taken branch of a
    constexpr if is not proposed.

    void f() {
      if constexpr (false)
        static_assert(false);   // ill-formed
    }
    
    template&lt;class T&gt;
    void g() {
      if constexpr (false)
        static_assert(false);   // ill-formed; no 
                   // diagnostic required for template definition
    }

I take it that it&#39;s completely forbidden to use `static_assert` inside constexpr if (at least the false / non-taken branch, but that in practice means it&#39;s not a safe or useful thing to do).

How does this come about from the standard text? I find no mentioning of `static_assert` in the proposal wording, and C++14 constexpr functions do allow `static_assert` (details at cppreference: [constexpr][3]).

Is it hiding in this new sentence (after 6.4.1) ? : 

&gt;    When a constexpr if statement appears in a templated entity, 
&gt;    during an instantiation of the enclosing template or generic lambda, 
&gt;    a discarded statement is not instantiated.

From there on, I assume that it is also forbidden, no diagnostic required, to call other constexpr (template) functions which *somewhere* down the call graph may call `static_assert`. 

**Bottom line:** 

If my understanding is correct, doesn&#39;t that put a quite hard limit on the safety and usefulness of `constexpr if` as we would have to know (from documentation or code inspection) about any use of `static_assert`? Are my worries misplaced?


  [1]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0292r1.html
  [2]: https://herbsutter.com/2016/06/30/trip-report-summer-iso-c-standards-meeting-oulu/
  [3]: http://en.cppreference.com/w/cpp/language/constexpr

**Update:**

This code compiles without warning (clang head 3.9.0) but is to my understanding *ill-formed*, no diagnostic required. Valid or not?

    template&lt; typename T&gt;
    constexpr void other_library_foo(){
        static_assert(std::is_same&lt;T,int&gt;::value);
    }
    
    template&lt;class T&gt;
    void g() {
      if constexpr (false)
        other_library_foo&lt;T&gt;(); 
    }
    
    int main(){
        g&lt;float&gt;();
        g&lt;int&gt;();
    }

constexpr if and static_assert

The [jinja API document at pocoo.org](http://jinja.pocoo.org/docs/dev/api/#) states:

&lt;blockquote&gt;The simplest way to configure Jinja2 to load templates for your application looks roughly like this:&lt;/blockquote&gt;

    from jinja2 import Environment, PackageLoader
    env = Environment(loader=PackageLoader(&#39;yourapplication&#39;, &#39;templates&#39;))

&lt;blockquote&gt;This will create a template environment with the default settings and a loader that looks up the templates in the &lt;i&gt;templates&lt;/i&gt; folder inside the &lt;i&gt;yourapplication&lt;/i&gt; python package.&lt;/blockquote&gt;

As it turns out, this isn&#39;t so simple because you have to make/install a python package with your templates in it, which introduces a lot of needless complexity, especially if you have no intention of distributing your code.  You can refer to SO questions on the topic [here](https://stackoverflow.com/questions/38617900/need-to-package-jinja2-template-for-python) and [here](https://stackoverflow.com/questions/29150156/how-to-make-a-python-package-containing-only-jinja-templates), but the answers are vague and unsatisfying.

What a naive newbie wants to do, obviously, is just load the template directly from the filesystem, not as a resource in a package.  **How is this done?**

How to load jinja template directly from filesystem

I am pulling and installing a package with dependencies, and a compilation fails, in this case not finding a file, `magic.h`.   How do I see what the compilation commands and flags were? The `-v` option does not help. (I do NOT want ideas about where to get magic.h from, this is just an example.)

&lt;!-- language: lang-bash --&gt;

    $ go get -u github.com/presbrey/magicmime
    # github.com/presbrey/magicmime
    ../../../src/github.com/presbrey/magicmime/magicmime.go:20:11: fatal error:   &#39;magic.h&#39; file not found
    #include &lt;magic.h&gt;

How can I find, for example, where it was looking for include files, what source *exactly* it was compiling? (In this case the source file I see in `$GO_PATH/src` has that `#include` commented out, and a `/usr/local/include/match.h` exists anyway.)

How can I see the internal compile commands which fail in a &quot;go get&quot; installation?

I want to test a few functions that are included in my main package, but my tests don&#39;t appear to be able to access those functions.

My sample main.go file looks like:

    package main
    
    import (
    	&quot;log&quot;
    )
    
    func main() {
    	log.Printf(foo())
    }
    
    func foo() string {
    	return &quot;Foo&quot;
    }

and my main_test.go file looks like:

    package main
    
    import (
    	&quot;testing&quot;
    )
    
    func Foo(t testing.T) {
    	t.Error(foo())
    }

when I run `go test main_test.go` I get

    # command-line-arguments
    .\main_test.go:8: undefined: foo
    FAIL    command-line-arguments [build failed]

As I understand, even if I moved the test file elsewhere and tried importing from the main.go file, I couldn&#39;t import it, since it&#39;s `package main`.

What is the correct way of structuring such tests? Should I just remove everything from the `main` package asides a simple main function to run everything and then test the functions in their own package, or is there a way for me to call those functions from the main file during testing?

How to test the main package functions in golang?

In Go, is there a way to satisfy an interface anonymously? It doesn&#39;t seem like there is, but this was my best attempt.

(In the [Playground][1])

    package main

    import &quot;fmt&quot;

    type Thing interface {
        Item() float64
        SetItem(float64)
    }

    func newThing() Thing {
        item := 0.0
        return struct {
            Item (func() float64)
            SetItem (func(float64))
        }{
            Item: func() float64 { return item },
            SetItem: func(x float64) { item = x },
        }
    }

    func main() {
        thing := newThing()
        fmt.Println(&quot;Hello, playground&quot;)
        fmt.Println(thing)
    }


  [1]: http://play.golang.org/p/4i-8o087dg

Anonymous interface implementation in Golang

`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?

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

Content Type	Original Author	Original Content on Stackoverflow
Question	Glstunna	View Question on Stackoverflow
Solution 1 - Templates	Ken Bloom	View Answer on Stackoverflow
Solution 2 - Templates	Sandeep Jain	View Answer on Stackoverflow

Go templates: How do I access array item (arr[2]) in templates?

Templates Problem Overview

Templates Solutions

Solution 1 - Templates

Solution 2 - Templates

TabLayout (Android Design Library) Text Color

Scale UIButton Animation- Swift

Attributions