What does this do?

    if __name__ == &quot;__main__&quot;:
        print(&quot;Hello world!&quot;)


What does if __name__ == &quot;__main__&quot;: do?

I&#39;ve recently started maintaining someone else&#39;s JavaScript code. I&#39;m fixing bugs, adding features and also trying to tidy up the code and make it more consistent.

The previous developer used two ways of declaring functions and I can&#39;t work out if there is a reason behind it or not.

The two ways are:

    var functionOne = function() {
        // Some code
    };

&lt;!-- --&gt;

    function functionTwo() {
        // Some code
    }

What are the reasons for using these two different methods and what are the pros and cons of each? Is there anything that can be done with one method that can&#39;t be done with the other?


var functionName = function() {} vs function functionName() {}

I find myself using hash arguments to constructors quite a bit, especially when writing DSLs for configuration or other bits of API that the end user will be exposed to. What I end up doing is something like the following:

    class Example
    	
    	PROPERTIES = [:name, :age]
    	
    	PROPERTIES.each { |p| attr_reader p }
    	
    	def initialize(args)
    		PROPERTIES.each do |p|
    			self.instance_variable_set &quot;@#{p}&quot;, args[p] if not args[p].nil?
    		end
    	end
    	
    end

Is there no more idiomatic way to achieve this? The throw-away constant and the symbol to string conversion seem particularly egregious.

DRY Ruby Initialization with Hash Argument

How can I loop through a `std::map` in C++? My map is defined as:

    std::map&lt; std::string, std::map&lt;std::string, std::string&gt; &gt;

For example, the above container holds data like this:

	m[&quot;name1&quot;][&quot;value1&quot;] = &quot;data1&quot;;
	m[&quot;name1&quot;][&quot;value2&quot;] = &quot;data2&quot;;
	m[&quot;name2&quot;][&quot;value1&quot;] = &quot;data1&quot;;
	m[&quot;name2&quot;][&quot;value2&quot;] = &quot;data2&quot;;
	m[&quot;name3&quot;][&quot;value1&quot;] = &quot;data1&quot;;
	m[&quot;name3&quot;][&quot;value2&quot;] = &quot;data2&quot;;

How can I loop through this map and access the various values?

How can I loop through a C++ map of maps?

I run into this case a lot of times when doing simple text processing and print statements where I am looping over a collection and I want to special case the last element (for example every normal element will be comma separated except for the last case).

Is there some best practice idiom or elegant form that doesn&#39;t require duplicating code or shoving in an if, else in the loop.

For example I have a list of strings that I want to print in a comma separated list. (the do while solution already assumes the list has 2 or more elements otherwise it&#39;d be just as bad as the more correct for loop with conditional).

e.g. List&lt;String&gt; = (&quot;dog&quot;, &quot;cat&quot;, &quot;bat&quot;)

I want to print &quot;[dog, cat, bat]&quot;

I present 2 methods the

 1. For loop with conditional



        public static String forLoopConditional(String[] items) {

        String itemOutput = &quot;[&quot;;
    
        for (int i = 0; i &lt; items.length; i++) {
            // Check if we&#39;re not at the last element
            if (i &lt; (items.length - 1)) {
                itemOutput += items[i] + &quot;, &quot;;
            } else {
                // last element
                itemOutput += items[i];
            }
        }
        itemOutput += &quot;]&quot;;
    
        return itemOutput;
         }


 2. do while loop priming the loop


        public static String doWhileLoopPrime(String[] items) {
        String itemOutput = &quot;[&quot;;
        int i = 0;

        itemOutput += items[i++];
        if (i &lt; (items.length)) {
            do {
                itemOutput += &quot;, &quot; + items[i++];
            } while (i &lt; items.length);
        }
        itemOutput += &quot;]&quot;;

        return itemOutput;
        }
Tester class:

    
        public static void main(String[] args) {
            String[] items = { &quot;dog&quot;, &quot;cat&quot;, &quot;bat&quot; };
    
            System.out.println(forLoopConditional(items));
            System.out.println(doWhileLoopPrime(items));
    
        }

In the Java AbstractCollection class it has the following implementation (a little verbose because it contains all edge case error checking, but not bad).

    public String toString() {
        Iterator&lt;E&gt; i = iterator();
	if (! i.hasNext())
	    return &quot;[]&quot;;

	StringBuilder sb = new StringBuilder();
	sb.append(&#39;[&#39;);
	for (;;) {
	    E e = i.next();
	    sb.append(e == this ? &quot;(this Collection)&quot; : e);
	    if (! i.hasNext())
		return sb.append(&#39;]&#39;).toString();
	    sb.append(&quot;, &quot;);
	}
    }


Best Loop Idiom for special casing the last element

How would you initialise a static `Map` in Java?

Method one: static initialiser &lt;br&gt;
Method two: instance initialiser (anonymous subclass)
or
some other method?

What are the pros and cons of each?

Here is an example illustrating the two methods:

    import java.util.HashMap;
    import java.util.Map;
    
    public class Test {
        private static final Map&lt;Integer, String&gt; myMap = new HashMap&lt;&gt;();
        static {
            myMap.put(1, &quot;one&quot;);
            myMap.put(2, &quot;two&quot;);
        }
    
        private static final Map&lt;Integer, String&gt; myMap2 = new HashMap&lt;&gt;(){
            {
                put(1, &quot;one&quot;);
                put(2, &quot;two&quot;);
            }
        };
    }

How can I initialise a static Map?

I am trying to reverse an int array in Java.

This method does not reverse the array.  

    for(int i = 0; i &lt; validData.length; i++)
    {
    	int temp = validData[i];
    	validData[i] = validData[validData.length - i - 1];
    	validData[validData.length - i - 1] = temp;
    }

What is wrong with it?

How do I reverse an int array in Java?

I&#39;d like to know the best way (more compact and &quot;pythonic&quot; way) to do a special treatment for the last element in a for loop. There is a piece of code that should be called only *between* elements, being suppressed in the last one.

Here is how I currently do it:

    for i, data in enumerate(data_list):
        code_that_is_done_for_every_element
        if i != len(data_list) - 1:
            code_that_is_done_between_elements

Is there any better way?

Note: I don&#39;t want to make it with hacks such as using `reduce`. `;)`


What is the pythonic way to detect the last element in a &#39;for&#39; loop?

I&#39;m just wondering should I use `std::size_t` for loops and stuff instead of `int`?
For instance:

&lt;pre&gt;&lt;code&gt;#include &amp;lt;cstdint&gt;

int main()
{
    for (std::size_t i = 0; i &amp;lt; 10; ++i) {
        // std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}&lt;/code&gt;&lt;/pre&gt;

In general, what is the best practice regarding when to use `std::size_t`?


When to use std::size_t?

How do you calculate the union of two `dict` objects in Python, where a `(key, value)` pair is present in the result iff `key` is `in` either dict (unless there are duplicates)?

For example, the union of `{&#39;a&#39; : 0, &#39;b&#39; : 1}` and `{&#39;c&#39; : 2}` is `{&#39;a&#39; : 0, &#39;b&#39; : 1, &#39;c&#39; : 2}`.

Preferably you can do this without modifying either input `dict`. Example of where this is useful: https://stackoverflow.com/questions/1041639/get-a-dict-of-all-variables-currently-in-scope-and-their-values

Union of dict objects in Python

What is the most idiomatic way to do the following?

    def xstr(s):
        if s is None:
            return &#39;&#39;
        else:
            return s

    s = xstr(a) + xstr(b)

**update:** I&#39;m incorporating Tryptich&#39;s suggestion to use str(s), which makes this routine work for other types besides strings.  I&#39;m awfully impressed by Vinay Sajip&#39;s lambda suggestion, but I want to keep my code relatively simple.

    def xstr(s):
        if s is None:
            return &#39;&#39;
        else:
            return str(s)


Python: most idiomatic way to convert None to empty string?

What is this &quot;Execute Around&quot; idiom (or similar) I&#39;ve been hearing about? 
Why might I use it, and why might I not want to use it?

What is the &quot;Execute Around&quot; idiom?

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?

Is there anything more idiomatic than the following?

    foo.class == String


Check whether a variable is a string in Ruby

Often enough, I&#39;ve found the need to process a list by pairs. I was wondering which would be the pythonic and efficient way to do it, and found this on Google:

    pairs = zip(t[::2], t[1::2])

I thought that was pythonic enough, but after a recent discussion involving [idioms versus efficiency][1], I decided to do some tests:

    import time
    from itertools import islice, izip
    
    def pairs_1(t):
        return zip(t[::2], t[1::2]) 
    
    def pairs_2(t):
        return izip(t[::2], t[1::2]) 
    
    def pairs_3(t):
        return izip(islice(t,None,None,2), islice(t,1,None,2))
    
    A = range(10000)
    B = xrange(len(A))
    
    def pairs_4(t):
        # ignore value of t!
        t = B
        return izip(islice(t,None,None,2), islice(t,1,None,2))
    
    for f in pairs_1, pairs_2, pairs_3, pairs_4:
        # time the pairing
        s = time.time()
        for i in range(1000):
            p = f(A)
        t1 = time.time() - s
    
        # time using the pairs
        s = time.time()
        for i in range(1000):
            p = f(A)
            for a, b in p:
                pass
        t2 = time.time() - s
        print t1, t2, t2-t1

These were the results on my computer:

    1.48668909073 2.63187503815 1.14518594742
    0.105381965637 1.35109519958 1.24571323395
    0.00257992744446 1.46182489395 1.45924496651
    0.00251388549805 1.70076990128 1.69825601578

If I&#39;m interpreting them correctly, that should mean that the implementation of lists, list indexing, and list slicing in Python is very efficient. It&#39;s a result both comforting and unexpected.

**Is there another, &quot;better&quot; way of traversing a list in pairs?**

Note that if the list has an odd number of elements then the last one will not be in any of the pairs. 

**Which would be the right way to ensure that all elements are included?**

I added these two suggestions from the answers to the tests:

    def pairwise(t):
        it = iter(t)
        return izip(it, it)
    
    def chunkwise(t, size=2):
        it = iter(t)
        return izip(*[it]*size)


These are the results:  

    0.00159502029419 1.25745987892 1.25586485863
    0.00222492218018 1.23795199394 1.23572707176

## Results so far ##

Most pythonic and very efficient:

    pairs = izip(t[::2], t[1::2])

Most efficient and very pythonic:

    pairs = izip(*[iter(t)]*2)

It took me a moment to grok that the first answer uses two iterators while the second uses a single one.

To deal with sequences with an odd number of elements, the suggestion has been to augment the original sequence adding one element (`None`) that gets paired with the previous last element, something that can be achieved with `itertools.izip_longest()`.

## Finally ##

Note that, in Python 3.x, `zip()` behaves as `itertools.izip()`, and `itertools.izip()`  is gone.

  [1]: https://stackoverflow.com/questions/4619367/avoid-object-aliasing-in-python/4619575#4619575











Pairs from single list

I have a question about idioms and readability, and there seems to be a clash of Python philosophies for this particular case:

I want to build dictionary A from dictionary B. If a specific key does not exist in B, then do nothing and continue on.

Which way is better?

    try:
        A[&quot;blah&quot;] = B[&quot;blah&quot;]
    except KeyError:
        pass

or 

    if &quot;blah&quot; in B:
        A[&quot;blah&quot;] = B[&quot;blah&quot;]


&quot;Do and ask for forgiveness&quot; vs. &quot;simplicity and explicitness&quot;.

Which is better and why?






`if key in dict` vs. `try/except` - which is more readable idiom?

What is the best (idiomatic) way to concatenate Strings in Groovy?

Option 1:

    calculateAccountNumber(bank, branch, checkDigit, account) {
        bank + branch + checkDigit + account
    }


Option 2:

    calculateAccountNumber(bank, branch, checkDigit, account) {
        &quot;$bank$branch$checkDigit$account&quot;
    }

I&#39;ve founded an interesting point about this topic in the old Groovy website: Things you can do but better leave undone.

&gt; As in Java, you can concatenate Strings with the &quot;+&quot; symbol. But Java
&gt; only needs that one of the two items of a &quot;+&quot; expression to be a
&gt; String, no matter if it&#39;s in the first place or in the last one. Java
&gt; will use the toString() method in the non-String object of your &quot;+&quot;
&gt; expression. But in Groovy, you just should be safe the first item of
&gt; your &quot;+&quot; expression implements the plus() method in the right way,
&gt; because Groovy will search and use it. In Groovy GDK, only the Number
&gt; and String/StringBuffer/Character classes have the plus() method
&gt; implemented to concatenate strings. To avoid surprises, always use
&gt; GStrings.


String concatenation with Groovy

How to implement Named Parameter idiom in Java? (especially for constructors)

I am looking for an Objective-C like syntax and not like the one used in JavaBeans.

A small code example would be fine.

Named Parameter idiom in Java

I have seen a few mentions of this idiom (including [on SO][1]):

    // Deliberately empty subscriber
    public event EventHandler AskQuestion = delegate {};

The upside is clear - it avoids the need to check for null before raising the event.

**However, I am keen to understand if there are any downsides.**  For example, is it something that is in widespread use and is transparent enough that it won&#39;t cause a maintenance headache?  Is there any appreciable performance hit of the empty event subscriber call?


  [1]: https://stackoverflow.com/questions/9033/hidden-features-of-c#9282

Is there a downside to adding an anonymous empty delegate on event declaration?

I am looking for a concise way to check a value to see if it is nil or zero.  Currently I am doing something like:

    if (!val || val == 0)
      # Is nil or zero
    end

But this seems very clumsy.

Best ruby idiom for &quot;nil or zero&quot;

If I have a Python dictionary, how do I get the key to the entry which contains the minimum value?

I was thinking about something to do with the `min()` function...

Given the input:

    {320:1, 321:0, 322:3}

It would return `321`.


Get the key corresponding to the minimum value within a dictionary

Everyone encounters this issue at some point:

    for(const auto&amp; item : items) {
        cout &lt;&lt; item &lt;&lt; separator;
    }

... and you get an extra separator you don&#39;t want at the end. Sometime it&#39;s not printing, but, say, performing some other action, but such that consecutive actions of the same type require some separator action - but the last doesn&#39;t.

Now, if you work with old-school for loops and an array, you would do

    for(int i = 0; i &lt; num_items; i++)
        cout &lt;&lt; items[i];
        if (i &lt; num_items - 1) { cout &lt;&lt; separator; }
    }

(or you could special-case the last item out of the loop.) If you have anything that admits non-destructive iterators, even if you don&#39;t know its size, you can do:

    for(auto it = items.cbegin(); it != items.cend(); it++) {
        cout &lt;&lt; *it;
        if (std::next(it) != items.cend()) { cout &lt;&lt; separator; }
    }

I dislike the aesthetics of the last two, and like ranged for loops. Can I obtain the same effect as with the last two but using more spiffy C++11ish constructs?

&lt;hr&gt;
To expand the question further (beyond, say, [this one](https://stackoverflow.com/questions/27585021)), I&#39;ll say I would also like not to expressly have special-case the first or the last element. That&#39;s an &quot;implementation detail&quot; which I don&#39;t want to be bothered with. So, in imaginary-future-C++, maybe something like:

    for(const auto&amp; item : items) {
        cout &lt;&lt; item;
    } and_between {
        cout &lt;&lt; separator;
    }




Idiom for iterating &quot;between each consecutive pair of elements&quot;

I see the phrase &quot;programming idiom&quot; thrown around as if it is commonly understood. Yet, in search results and stackoverflow I see everything...

From micro:

  - Incrementing a variable
  - Representing an infinite loop
  - Swapping variable values

To medium:

  - [PIMPL][1]
  - [RAII][2]
  - [Format, comments, style...][3]

To macro:

  - [Programming paradigm or common library features as idiom][4]
  - [Process model as idiom][5]
  - [A collection of idioms equals a new paradigm][6]

Is there a single, common definition for &quot;programming idiom&quot;? Since &quot;programming idiom&quot; is used in many scopes:

  - Micro: syntactic nuance or common syntax
  - Medium: common style and patterns
  - Macro: programming paradigms as idiom

Is it valid to use the phrase in any of these scopes? The answers so far focus on syntactic idioms. Are the others valid as well?

  [1]: http://aszt.inf.elte.hu/~gsd/halado_cpp/ch09s03.html
  [2]: http://www.hackcraft.net/raii/
  [3]: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html
  [4]: http://pschombe.wordpress.com/2006/05/06/the-next-big-programming-idiom/
  [5]: http://blogs.msdn.com/g/archive/2008/06/07/a-finding-from-an-architecture-review-of-a-product-with-components-that-originated-on-unix.aspx
  [6]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.48.7793 

What is a programming idiom?

I was recently teaching myself Python and discovered the LBYL/EAFP idioms with regards to error checking before code execution. In Python, it seems the accepted style is EAFP, and it seems to work well with the language.



LBYL (***L**ook **B**efore **Y**ou **L**eap*):

    def safe_divide_1(x, y):
        if y == 0:
            print &quot;Divide-by-0 attempt detected&quot;
            return None
        else:
            return x/y

EAFP (*it&#39;s **E**asier to **A**sk **F**orgiveness than **P**ermission*):

    def safe_divide_2(x, y):
        try:
            return x/y
        except ZeroDivisionError:  
            print &quot;Divide-by-0 attempt detected&quot;
            return None

My question is this: I had never even heard of using EAFP as the primary data validation construct, coming from a Java and C++ background. Is EAFP something that is wise to use in Java? Or is there too much overhead from exceptions? I know that there is only overhead when an exception is actually thrown, so I&#39;m unsure as to why the simpler method of EAFP is not used. Is it just preference?

LBYL vs EAFP in Java?

I&#39;m calling a bunch of methods that return a list.  The list may be empty.  If the list is non-empty, I want to return the first item; otherwise, I want to return `None`.  This code works:

```py
def main():
    my_list = get_list()
    if len(my_list) &gt; 0:
        return my_list[0]
    return None
```

but it seems to me that there should be a simple one-line idiom for doing this. Is there?

Python idiom to return first item or None

There&#39;s this one thing in C++ which has been making me feel uncomfortable for quite a long time, because I honestly don&#39;t know how to do it, even though it sounds simple:

**How do I implement Factory Method in C++ correctly?**
==

Goal: to make it possible to allow the client to instantiate some object using factory methods instead of the object&#39;s constructors, without unacceptable consequences and a performance hit. 

By &quot;Factory method pattern&quot;, I mean both static factory methods inside an object or methods defined in another class, or global functions. Just generally &quot;the concept of redirecting the normal way of instantiation of class X to anywhere else than the constructor&quot;.

Let me skim through some possible answers which I have thought of.


---
0) Don&#39;t make factories, make constructors.
----------------------------------------

This sounds nice (and indeed often the best solution), but is not a general remedy. First of all, there are cases when object construction is a task complex enough to justify its extraction to another class. But even putting that fact aside, even for simple objects using just constructors often won&#39;t do.

The simplest example I know is a 2-D Vector class. So simple, yet tricky. I want to be able to construct it both from both Cartesian and polar coordinates. Obviously, I cannot do:

    struct Vec2 {
        Vec2(float x, float y);
        Vec2(float angle, float magnitude); // not a valid overload!
        // ...
    };

My natural way of thinking is then:

    struct Vec2 {
        static Vec2 fromLinear(float x, float y);
        static Vec2 fromPolar(float angle, float magnitude);
        // ...
    };

Which, instead of constructors, leads me to usage of static factory methods... which essentially means that I&#39;m implementing the factory pattern, in some way (&quot;the class becomes its own factory&quot;). This looks nice (and would suit this particular case), but fails in some cases, which I&#39;m going to describe in point 2. Do read on.

*another case: trying to overload by two opaque typedefs of some API (such as GUIDs of unrelated domains, or a GUID and a bitfield), types semantically totally different (so - in theory - valid overloads) but which actually turn out to be the same thing - like unsigned ints or void pointers.*

---

1) The Java Way
---------------

Java has it simple, as we only have dynamic-allocated objects. Making a factory is as trivial as:

    class FooFactory {
        public Foo createFooInSomeWay() {
            // can be a static method as well,
            //  if we don&#39;t need the factory to provide its own object semantics
            //  and just serve as a group of methods
            return new Foo(some, args);
        }
    }

In C++, this translates to:

    class FooFactory {
    public:
        Foo* createFooInSomeWay() {
            return new Foo(some, args);
        }
    };

Cool? Often, indeed. But then- this forces the user to only use dynamic allocation. Static allocation is what makes C++ complex, but is also what often makes it powerful. Also, I believe that there exist some targets (keyword: embedded) which don&#39;t allow for dynamic allocation. And that doesn&#39;t imply that the users of those platforms like to write clean OOP.

Anyway, philosophy aside: In the general case, I don&#39;t want to force the users of the factory to be restrained to dynamic allocation.

------------------
2) Return-by-value
------------------

OK, so we know that 1) is cool when we want dynamic allocation. Why won&#39;t we add static allocation on top of that?

    class FooFactory {
    public:
        Foo* createFooInSomeWay() {
            return new Foo(some, args);
        }
        Foo createFooInSomeWay() {
            return Foo(some, args);
        }
    };

What? We can&#39;t overload by the return type? Oh, of course we can&#39;t. So let&#39;s change the method names to reflect that. And yes, I&#39;ve written the invalid code example above just to stress how much I dislike the need to change the method name, for example because we cannot implement a language-agnostic factory design properly now, since we have to change names - and every user of this code will need to remember that difference of the implementation from the specification.

    class FooFactory {
    public:
        Foo* createDynamicFooInSomeWay() {
            return new Foo(some, args);
        }
        Foo createFooObjectInSomeWay() {
            return Foo(some, args);
        }
    };

OK... there we have it. It&#39;s ugly, as we need to change the method name. It&#39;s imperfect, since we need to write the same code twice. But once done, it works. Right?

Well, usually. But sometimes it does not. When creating Foo, we actually depend on the compiler to do the return value optimisation for us, because the C++ standard is benevolent enough for the compiler vendors not to specify when will the object created in-place and when will it be copied when returning a temporary object by value in C++. So if Foo is expensive to copy, this approach is risky.

And what if Foo is not copiable at all? Well, doh. (*Note that in C++17 with guaranteed copy elision, not-being-copiable is no problem anymore for the code above*)

Conclusion: Making a factory by returning an object is indeed a solution for some cases (such as the 2-D vector previously mentioned), but still not a general replacement for constructors.

-------------------------
3) Two-phase construction
-------------------------

Another thing that someone would probably come up with is separating the issue of object allocation and its initialisation. This usually results in code like this:

    class Foo {
    public:
        Foo() {
            // empty or almost empty
        }
        // ...
    };

    class FooFactory {
    public:
        void createFooInSomeWay(Foo&amp; foo, some, args);
    };

    void clientCode() {
        Foo staticFoo;
        auto_ptr&lt;Foo&gt; dynamicFoo = new Foo();
        FooFactory factory;
        factory.createFooInSomeWay(&amp;staticFoo);
        factory.createFooInSomeWay(&amp;dynamicFoo.get());
        // ...
    }

One may think it works like a charm. The only price we pay for in our code...

Since I&#39;ve written all of this and left this as the last, I must dislike it too. :) Why?

First of all... I sincerely dislike the concept of two-phase construction and I feel guilty when I use it. If I design my objects with the assertion that &quot;if it exists, it is in valid state&quot;, I feel that my code is safer and less error-prone. I like it that way.

Having to drop that convention AND changing the design of my object just for the purpose of making factory of it is.. well,  unwieldy.

I know that the above won&#39;t convince many people, so let&#39;s me give some more solid arguments. Using two-phase construction, you cannot:

- initialise `const` or reference member variables,
- pass arguments to base class constructors and member object constructors.

And probably there could be some more drawbacks which I can&#39;t think of right now, and I don&#39;t even feel particularly obliged to since the above bullet points convince me already.
 
So: not even close to a good general solution for implementing a factory.

---


Conclusions:
------------

We want to have a way of object instantiation which would: 

- allow for uniform instantiation regardless of allocation,
- give different, meaningful names to construction methods (thus not relying on by-argument overloading),
- not introduce a significant performance hit and, preferably, a significant code bloat hit, especially at client side,
- be general, as in: possible to be introduced for any class.

I believe I have proven that the ways I have mentioned don&#39;t fulfil those requirements.

Any hints? Please provide me with a solution, I don&#39;t want to think that this language won&#39;t allow me to properly implement such a trivial concept.

How to implement the factory method pattern in C++ correctly

Suppose we have this code:

    class QuickExample {

        fun function(argument: SomeOtherClass) {
            if (argument.mutableProperty != null ) {
                doSomething(argument.mutableProperty)
            } else {
                doOtherThing()
            }
        }
    
        fun doSomething(argument: Object) {}

        fun doOtherThing() {}
    }

    class SomeOtherClass {
        var mutableProperty: Object? = null
    }

Unlike in Java, where you could be left alone to worry about null dereferencing at runtime, this doesn&#39;t compile - quite rightly. Of course, `mutableProperty` may no longer be null once within the &#39;if&#39;.

My question is what&#39;s the best way to handle this?

A few options are apparent. Without using any new Kotlin language features, the simplest way is obviously to copy the value to a method-scope one that won&#39;t subsequently change.

There&#39;s this:

    fun function(argument: SomeOtherClass) {
        argument.mutableProperty?.let {
            doSomething(it)
            return
        }
        doOtherThing()
    }

This has the obvious disadvantage that you need to return early or otherwise avoid executing the subsequent code - OK in certain, small contexts, but has a smell to it.

Then there&#39;s this possibility:

    fun function(argument: SomeOtherClass) {
        argument.mutableProperty.let {
            when {
                it != null -&gt; {
                    doSomething(it)
                }
                else -&gt; {
                    doOtherThing()
                }
            }
        }
    }

but whilst it has greater clarity of purpose, arguably it&#39;s more unwieldy and verbose than the Java-style way of dealing with this.

Am I missing anything, and is there a preferred idiom with which to achieve this?

Kotlin and idiomatic way to write, &#39;if not null, else...&#39; based around mutable value

One thing I love about ruby is that mostly it is a very readable language (which is great for self-documenting code)

However, inspired by this question: https://stackoverflow.com/questions/609612/ruby-code-explained
and the description of how `||=` works in ruby, I was thinking about the ruby idioms I don&#39;t use, as frankly, I don&#39;t fully grok them.

So my question is, similar to the example from the referenced question, what common, but not obvious, ruby idioms do I need to be aware of to be a truly proficient ruby programmer?

By the way, from the referenced question

    a ||= b 

is equivalent to

    if a == nil || a == false
      a = b
    end

(Thanks to Ian Terrell for the correction)

**Edit:** It turns out this point is not totally uncontroversial. The correct expansion is in fact

    (a || (a = (b))) 

See these links for why:

 - http://DABlog.RubyPAL.Com/2008/3/25/a-short-circuit-edge-case/
 - http://DABlog.RubyPAL.Com/2008/3/26/short-circuit-post-correction/
 - http://ProcNew.Com/ruby-short-circuit-edge-case-response.html 

Thanks to J&#246;rg W Mittag for pointing this out.


Common Ruby Idioms

Powershell&#39;s array notation has rather bizarre, albeit documented, behavior for slicing the end of arrays.  This section from [the official documentation](https://technet.microsoft.com/en-us/library/hh847882.aspx) sums up the bizarreness rather well:

&gt; Negative numbers count from the end of the array. For example, &quot;-1&quot; 
&gt; refers to the last element of the array. To display the last three
&gt; elements of the array, type:
&gt; 
&gt;     $a[-3..-1]
&gt; 
&gt; However, be cautious when using this notation.
&gt; 
&gt;     $a[0..-2]
&gt; 
&gt; This command does not refer to all the elements of the array, except
&gt; for  the last one. It refers to the first, last, and second-to-last
&gt; elements in the array.

The following code confirms the bizarreness:

    $a = 0,1,2,3
    $a[1..-1]

Which indeed outputs this bizarre result:

    1
    0
    3

So, the question is, what _is_ the idiomatic way to slice with one index relative the start and another relative the end of the array?  

Please tell me it&#39;s something better than this ugly mess:

    $a[1..($a.Count-1)]

------------

Edit:

Another way to describe what I&#39;m looking for is this: The idiomatic Powershell equivalent of this python expression:

    a=1,2,3,4
    a[1:-1]

Which, of course, evaluates to `(2,3)`

What is the idiomatic way to slice an array relative to both of its ends?

I have a container class that holds data. When the container is created, there are different methods to pass data.

 1. Pass a file which contains the data
 2. Pass the data directly via arguments
 3. Don&#39;t pass data; just create an empty container

In Java, I would create three constructors. Here&#39;s how it would look like if it were possible in Python:

    class Container:
    
        def __init__(self):
            self.timestamp = 0
            self.data = []
            self.metadata = {}
    
        def __init__(self, file):
            f = file.open()
            self.timestamp = f.get_timestamp()
            self.data = f.get_data()
            self.metadata = f.get_metadata()
    
        def __init__(self, timestamp, data, metadata):
            self.timestamp = timestamp
            self.data = data
            self.metadata = metadata

In Python, I see three obvious solutions, but none of them is pretty:


**A**: Using keyword arguments:

    def __init__(self, **kwargs):
        if &#39;file&#39; in kwargs:
            ...
        elif &#39;timestamp&#39; in kwargs and &#39;data&#39; in kwargs and &#39;metadata&#39; in kwargs:
            ...
        else:
            ... create empty container


**B**: Using default arguments:

    def __init__(self, file=None, timestamp=None, data=None, metadata=None):
        if file:
            ...
        elif timestamp and data and metadata:
            ...
        else:
            ... create empty container

**C**: Only provide constructor to create empty containers. Provide methods to fill containers with data from different sources.

    def __init__(self):
        self.timestamp = 0
        self.data = []
        self.metadata = {}

    def add_data_from_file(file):
        ...

    def add_data(timestamp, data, metadata):
        ...

Solutions A and B are basically the same. I don&#39;t like doing the if/else, especially since I have to check if all arguments required for this method were provided. A is a bit more flexible than B if the code is ever to be extended by a fourth method to add data.

Solution C seems to be the nicest, but the user has to know which method he requires. For example: he cant do `c = Container(args)` if he doesn&#39;t know what `args` is.

Whats the most Pythonic solution?


Multiple constructors: the Pythonic way?

I&#39;m trying to search a scala collection for an item in a list that matches some predicate. I don&#39;t necessarily need the return value, just testing if the list contains it.

In Java, I might do something like:

    for ( Object item : collection ) {
        if ( condition1(item) &amp;&amp; condition2(item) ) {
           return true;
        }
    }
    return false;

In Groovy, I can do something like:

    return collection.find { condition1(it) &amp;&amp; condition2(it) } != null

What&#39;s the idiomatic way to do this in Scala? I could of course convert the Java loop style to Scala, but I feel like there&#39;s a more functional way to do this.

All Idioms Solutions on Gang of Coders

Total of 31 Idioms Solutions

What does if name == "main": do?