The `indirect` keyword introduces a layer of indirection behind the scenes.

&gt;You indicate that an enumeration case is recursive by writing indirect before it, *which tells the compiler to insert the necessary layer of indirection*.

From [here][1]

The important part of structs and enums is that they&#39;re a constant size. Allowing recursive structs or enums directly would violate this, as there would be an indeterminable number of recursions, hence making the size non constant and unpredictable. `indirect` uses a constant size reference to refer to a constant size enum instance.

There&#39;s a different between the two code snippets you show.

 1. The first piece of code makes `BinaryTree&lt;T&gt;` stored by a reference everywhere it&#39;s used.

 2. The second piece of code makes `BinaryTree&lt;T&gt;` stored by a reference only in the case of `node`. I.e. `BinaryTree&lt;T&gt;` generally has its value stored directly, except for this explicitly `indirect` `node` case.

  [1]: https://docs.swift.org/swift-book/LanguageGuide/Enumerations.html#ID536

**Swift indirect enum**

Since Swift v2.0

Swift Enum[&lt;sup&gt;\[About\]&lt;/sup&gt;][1] is a value type[&lt;sup&gt;\[About\]&lt;/sup&gt;][2], and we assign it the value is copied that is why the size of type should be calculated at compile time.

Problem with **associated** value
```
enum MyEnum { //Recursive enum &lt;enum_name&gt; is not marked 
    case case1(MyEnum) `indirect`
}
```

it is not possible to calculate the final size because of recursion

`Indirect` says to compiler to store the associated value indirectly - by reference(instead of value)

 - `indirect enum` - is stored as reference for all cases
 - `indirect case` - is stored as reference only for this case

Also `indirect` is not applied for other value types(struct)

  [1]: https://stackoverflow.com/a/57109262/4770877
  [2]: https://stackoverflow.com/a/59219141/4770877

I compared the performance of the `mean` function of the `statistics` module with the simple `sum(l)/len(l)` method and found the `mean` function to be very slow for some reason. I used `timeit` with the two code snippets below to compare them, does anyone know what causes the massive difference in execution speed? I&#39;m using Python 3.5.

    from timeit import repeat
    print(min(repeat(&#39;mean(l)&#39;,
                     &#39;&#39;&#39;from random import randint; from statistics import mean; \
                     l=[randint(0, 10000) for i in range(10000)]&#39;&#39;&#39;, repeat=20, number=10)))

The code above executes in about 0.043 seconds on my machine.

    from timeit import repeat
    print(min(repeat(&#39;sum(l)/len(l)&#39;,
                     &#39;&#39;&#39;from random import randint; from statistics import mean; \
                     l=[randint(0, 10000) for i in range(10000)]&#39;&#39;&#39;, repeat=20, number=10)))

The code above executes in about 0.000565 seconds on my machine.

Why is statistics.mean() so slow?

I know this has been an issue for a while and I found a lot of discussion about it, however I didn&#39;t get which would be finally a way to get it done: pipe both, stdout and stderr. In bash, this would be simply:

    cmd 2&gt;&amp;1 | cmd2



pipe both, stdout and stderr in the fish shell

To start off, I want to say that I&#39;m aware there are **many** articles and questions within SO that refer to the `indirect` keyword in Swift. 

The most popular explanation for the usage of `indirect` is to allow for recursive enums. 

Rather than just knowing about what `indirect` allows us to do, I would like to know **how** it allows us to use recursive enums.

## Questions:
 
Is it because enums are value types and value types do not scale well if they are built in a recursive structure? Why?

Does `indirect` modify the value type behaviour to behave more like a reference type? 

The following two examples compile just fine. What is the difference?

    indirect enum BinaryTree&lt;T&gt; {
      case node(BinaryTree&lt;T&gt;, T, BinaryTree&lt;T&gt;)
      case empty
    }
    
    enum BinaryTree&lt;T&gt; {
      indirect case node(BinaryTree&lt;T&gt;, T, BinaryTree&lt;T&gt;)
      case empty
    }

indirect enums and structs

To start off, I want to say that I'm aware there are many articles and questions within SO that refer to the <code>indirect</code> keyword in Swift.
The most popular explanation for the usage of <code>indirect</code> is to allow for recursive enums.
Rather than just knowing about what <code>indirect</code> allows us to do, I would like to know how it allows us to use recursive enums.
<h4 id="questions"><a aria-hidden="true" tabindex="-1" href="#questions"></a>Questions:</h4>
Is it because enums are value types and value types do not scale well if they are built in a recursive structure? Why?
Does <code>indirect</code> modify the value type behaviour to behave more like a reference type?
The following two examples compile just fine. What is the difference?
<pre><code class="hljs language-swift">indirect enum BinaryTree&#x3C;T> {
 case node(BinaryTree&#x3C;T>, T, BinaryTree&#x3C;T>)
 case empty
}

enum BinaryTree&#x3C;T> {
 indirect case node(BinaryTree&#x3C;T>, T, BinaryTree&#x3C;T>)
 case empty
}
</code></pre>

How to simply store a String in Keychain and load when needed.
There are several SO solution which mostly refers to Git repo. But I need the smallest and the simplest solution on latest Swift. Certainly, I don&#39;t want to add git framework for simply storing a password in my project.

There are similar solution https://stackoverflow.com/questions/30719638 , which did not work for me. Tired with compiler errors.

Save and Load from KeyChain | Swift

I need to customise the look of a back button in a Swift project.

Here&#39;s what I have:
[![Default Back Button][1]][1]


Here&#39;s what I want:
[![Custom Back Button][2]][2]

I&#39;ve tried creating my own UIBarButtonItem but I can&#39;t figure out how to get the image to be beside the text, rather than as a background or a replacement for the text.

    let backButton = UIBarButtonItem(title: &quot;Custom&quot;, style: .Plain, target: self, action: nil    )
    //backButton.image = UIImage(named: &quot;imageName&quot;) //Replaces title
    backButton.setBackgroundImage(UIImage(named: &quot;imageName&quot;), forState: .Normal, barMetrics: .Default) // Stretches image
    navigationItem.setLeftBarButtonItem(backButton, animated: false)

  [1]: http://i.stack.imgur.com/WBW7p.png
  [2]: http://i.stack.imgur.com/KaGCs.png

Swift Custom NavBar Back Button Image and Text

I have an array of `Contact` objects: 

    var contacts:[Contact] = [Contact]()

Contact class:

    Class Contact:NSOBject {
        var firstName:String!
        var lastName:String!
    }

And I would like to sort that array by `lastName` and then by `firstName` in case some contacts got the same `lastName`.

I&#39;m able to sort by one of those criteria, but not both.

    contacts.sortInPlace({$0.lastName &lt; $1.lastName})

How could I add more criteria to sort this array?

Swift - Sort array of objects with multiple criteria

I&#39;m changing the width of a UITableViewCell so that the cell is smaller but the user can still scroll along the edges of the tableview.

    override func layoutSubviews() {        
        // Set the width of the cell
        self.bounds = CGRectMake(self.bounds.origin.x, self.bounds.origin.y, self.bounds.size.width - 40, self.bounds.size.height)
        super.layoutSubviews()
    }

Then I round the corners:

    cell.layer.cornerRadius = 8
    cell.layer.masksToBounds = true

All good so far. Problem happens with the shadow. The bounds are masked, so the shadow obviously won&#39;t show up. I&#39;ve looked up other answers but can&#39;t seem to figure out how to round the corners along the bounds *and* show the shadow.

    cell.layer.shadowOffset = CGSizeMake(0, 0)
    cell.layer.shadowColor = UIColor.blackColor().CGColor
    cell.layer.shadowOpacity = 0.23
    cell.layer.shadowRadius = 4

So my question –&#160;how do I reduce the width, round the corners, and add a shadow to a UITableViewCell at the same time?

**Update:** Trying R Moyer&#39;s answer

[![Trying R Moyer&#39;s answer][1]][1]


  [1]: http://i.stack.imgur.com/Wn2Pz.png

UITableViewCell: rounded corners and shadow

There are some posts for how to write code for `static constant` and `static variable` in Swift. But it is not clear when to use `static constant` and `static variable` rather than `constant` and `variable`. Can someone explain?

When to use static constant and variable in Swift?

I&#39;m not sure which of both are better to define constants. A struct or a enum. A struct will be copied every time i use it or not? When i think about a struct with `static let` constants it makes no sense that it will  copied all the time, in my opinion. But if it won&#39;t copied then it doesn&#39;t matter what I take?

What advantages does the choice of a struct or enum?

[Francisco say use Struct&#39;s.][1]

[Ray Wenderlich say use Enum&#39;s. But I lack the justification.][2]


  [1]: https://stackoverflow.com/questions/26252233/global-constants-file-in-swift
  [2]: https://github.com/raywenderlich/swift-style-guide#constants

Swift constants: Struct or Enum

I have a slice of structs.

    type Config struct {
	    Key string
	    Value string
    }

    // I form a slice of the above struct
    var myconfig []Config 

    // unmarshal a response body into the above slice
	if err := json.Unmarshal(respbody, &amp;myconfig); err != nil {
		panic(err)
	}

	fmt.Println(config)

Here is the output of this:

    [{key1 test} {web/key1 test2}]

How can I search this array to get the element where `key=&quot;key1&quot;`?

How to search for an element in a golang slice

In Golang, we use structs with receiver methods. everything is perfect up to here.   
I&#39;m not sure what interfaces are, however. We define methods in structs and if we want to implement a method on a struct, we write it anyway again under another struct.   
This means that interfaces seem to be just method definitions, taking just extra unneeded space on our page.

Is there any example explaining why I need an interface?

Why are interfaces needed in Golang?

I investigated performance degradation and tracked it down to slow HashSets.  
I have structs with nullable values that are used as a primary key. For example:

    public struct NullableLongWrapper
    {
        private readonly long? _value;

        public NullableLongWrapper(long? value)
        {
            _value = value;
        }
    }

I noticed that creating a `HashSet&lt;NullableLongWrapper&gt;` is exceptionally slow.

Here&#39;s an example using [BenchmarkDotNet](https://github.com/PerfDotNet/BenchmarkDotNet): (`Install-Package BenchmarkDotNet`)

	using System.Collections.Generic;
	using System.Linq;
	using BenchmarkDotNet.Attributes;
	using BenchmarkDotNet.Configs;
	using BenchmarkDotNet.Jobs;
	using BenchmarkDotNet.Running;

    public class Program
    {
        static void Main()
        {
            BenchmarkRunner.Run&lt;HashSets&gt;();
        }
    }

    public class Config : ManualConfig
    {
        public Config()
        {
            Add(Job.Dry.WithWarmupCount(1).WithLaunchCount(3).WithTargetCount(20));
        }
    }

    public struct NullableLongWrapper
    {
        private readonly long? _value;

        public NullableLongWrapper(long? value)
        {
            _value = value;
        }
    
        public long? Value =&gt; _value;
    }

    public struct LongWrapper
    {
        private readonly long _value;

        public LongWrapper(long value)
        {
            _value = value;
        }

        public long Value =&gt; _value;
    }

    [Config(typeof (Config))]
    public class HashSets
    {
        private const int ListSize = 1000;

        private readonly List&lt;long?&gt; _nullables;
        private readonly List&lt;long&gt; _longs;
        private readonly List&lt;NullableLongWrapper&gt; _nullableWrappers;
        private readonly List&lt;LongWrapper&gt; _wrappers;

        public HashSets()
        {
            _nullables = Enumerable.Range(1, ListSize).Select(i =&gt; (long?) i).ToList();
            _longs = Enumerable.Range(1, ListSize).Select(i =&gt; (long) i).ToList();
            _nullableWrappers = Enumerable.Range(1, ListSize).Select(i =&gt; new NullableLongWrapper(i)).ToList();
            _wrappers = Enumerable.Range(1, ListSize).Select(i =&gt; new LongWrapper(i)).ToList();
        }

        [Benchmark]
        public void Longs() =&gt; new HashSet&lt;long&gt;(_longs);

        [Benchmark]
        public void NullableLongs() =&gt; new HashSet&lt;long?&gt;(_nullables);

        [Benchmark(Baseline = true)]
        public void Wrappers() =&gt; new HashSet&lt;LongWrapper&gt;(_wrappers);

        [Benchmark]
        public void NullableWrappers() =&gt; new HashSet&lt;NullableLongWrapper&gt;(_nullableWrappers);
    }

Result:
&lt;pre&gt;
           Method |          Median |   Scaled
----------------- |---------------- |---------
            Longs |      22.8682 us |     0.42
    NullableLongs |      39.0337 us |     0.62
         Wrappers |      62.8877 us |     1.00
 NullableWrappers | 231,993.7278 us | 3,540.34
&lt;/pre&gt;

Using a struct with a `Nullable&lt;long&gt;` compared to a struct with a `long` is 3540 times slower!  
In my case it made the difference between 800ms and &amp;lt;1ms.

Here is the environment information from BenchmarkDotNet:

&gt; OS=Microsoft Windows NT 6.1.7601 Service Pack 1  
Processor=Intel(R) Core(TM) i7-5600U CPU 2.60GHz, ProcessorCount=4  
Frequency=2536269 ticks, Resolution=394.2799 ns, Timer=TSC  
CLR=MS.NET 4.0.30319.42000, Arch=64-bit RELEASE [RyuJIT]  
GC=Concurrent Workstation  
JitModules=clrjit-v4.6.1076.0

What is the reason performance is this poor? 


Why are HashSets of structs with nullable values incredibly slow?

Working on my C muscle lately and looking through the many libraries I&#39;ve been working with its certainly gave me a good idea of what is good practice. One thing that I have NOT seen is a function that returns a struct:

    something_t make_something() { ... }
From what I&#39;ve absorbed this is the &quot;right&quot; way of doing this:

    something_t *make_something() { ... }
    void destroy_something(something_t *object) { ... }

The architecture in code snippet 2 is FAR more popular than snippet 1. So now I ask, why would I ever return a struct directly, as in snippet 1?  What differences should I take into account when I&#39;m choosing between the two options?

Furthermore, how does this option compare?

    void make_something(something_t *object)

In C, how would I choose whether to return a struct or a pointer to a struct?

In Python 3.4, we got an Enum lib in the standard library: `enum`. We can get a backport for `enum` that works with Python 2.4 to 2.7 (and even 3.1 to 3.3), [enum34][1] in pypi.

But we&#39;ve managed to get along for quite some time without this new module - so why do we now have it?

I have a general idea about the purpose of enums from other languages. In Python, it has been common to use a bare class as follows and refer to this as an enum:

    class Colors:
        blue = 1
        green = 2
        red = 3

This can be used in an API to create a canonical representation of the value, e.g.:

    function_of_color(Colors.green)

If this has any criticisms, it&#39;s mutable, you can&#39;t iterate over it (easily), and how are we to know the semantics of the integer, `2`?

Then I suppose I could just use something like a namedtuple, which would be immutable?

    &gt;&gt;&gt; Colors = namedtuple(&#39;Colors&#39;, &#39;blue green red&#39;)
    &gt;&gt;&gt; colors = Colors(&#39;blue&#39;, &#39;green&#39;, &#39;red&#39;)
    &gt;&gt;&gt; colors
    Colors(blue=&#39;blue&#39;, green=&#39;green&#39;, red=&#39;red&#39;)
    &gt;&gt;&gt; list(colors)
    [&#39;blue&#39;, &#39;green&#39;, &#39;red&#39;]
    &gt;&gt;&gt; len(colors)
    3
    &gt;&gt;&gt; colors.blue
    &#39;blue&#39;
    &gt;&gt;&gt; colors.index(colors.blue)
    0

The creation of the namedtuple is a little redundant (we have to write each name twice), and so somewhat inelegant. Getting the &quot;number&quot; of the color is also a little inelegant (we have to write `colors` twice). Value checking will have to be done with strings, which will be a little less efficient.

So back to enums.

What&#39;s the purpose of enums? What value do they create for the language? When should I use them and when should I avoid them?


  [1]: https://pypi.python.org/pypi/enum34

Python, what&#39;s the Enum type good for?

I&#39;m trying to find the best way to do a &#39;reverse lookup&#39; on an enum in Kotlin. One of my takeaways from Effective Java was that you introduce a static map inside the enum to handle the reverse lookup. Porting this over to Kotlin with a simple enum leads me to code that looks like this:

    enum class Type(val value: Int) {
        A(1),
        B(2),
        C(3);
    
        companion object {
            val map: MutableMap&lt;Int, Type&gt; = HashMap()
    
            init {
                for (i in Type.values()) {
                    map[i.value] = i
                } 
            }
    
            fun fromInt(type: Int?): Type? {
                return map[type]
            }
        }
    }

My question is, is this the best way to do this, or is there a better way? What if I have several enums that follow a similar pattern? Is there a way in Kotlin to make this code more re-usable across enums?

Effective Enums in Kotlin with reverse lookup?

Here is my model class:

    public enum Action {
        RETRY, SETTINGS
    }

    private int imageId;
    private String description;
    private String actionName;
    private Action action;

    public NetworkError(int imageId, String description, String actionName, Action action ) {
        this.imageId = imageId;
        this.description = description;
        this.actionName = actionName;
        this.action = action;
    }

    public int getImageId() {
        return imageId;
    }

    public void setImageId(int imageId) {
        this.imageId = imageId;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getActionName() {
        return actionName;
    }

    public void setActionName(String actionName) {
        this.actionName = actionName;
    }


    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(this.imageId);
        dest.writeString(this.description);
        dest.writeString(this.actionName);
    }

    protected NetworkError(Parcel in) {
        this.imageId = in.readInt();
        this.description = in.readString();
        this.actionName = in.readString();
    }

    public static final Parcelable.Creator&lt;NetworkError&gt; CREATOR = new Parcelable.Creator&lt;NetworkError&gt;() {
        @Override
        public NetworkError createFromParcel(Parcel source) {
            return new NetworkError(source);
        }

        @Override
        public NetworkError[] newArray(int size) {
            return new NetworkError[size];
        }
    };

How to read and write Enum into parcel on Android?

Are there any standard methods to get `Enumeration names by value?`

An example:

    class Example(enum.Enum):
        one = 1
        two = 2

    ex_variable = 1

Given `ex_variable`, can I obtain the string contained in Example.one.name?

Content Type	Original Author	Original Content on Stackoverflow
Question	Kelvin Lau	View Question on Stackoverflow
Solution 1 - Swift	Alexander	View Answer on Stackoverflow
Solution 2 - Swift	yoAlex5	View Answer on Stackoverflow

indirect enums and structs

Swift Problem Overview

Questions:

Swift Solutions

Solution 1 - Swift

Solution 2 - Swift

pipe both, stdout and stderr in the fish shell

Why is statistics.mean() so slow?

Attributions