text:
The handshake problem
The handshake problem is the classic problem that for n people in a room, if they all shake hands, what's the total number of handshakes that occur.
You code should take an input of any number and output the number of handshakes, both in base ten.
Also the code should not let non-integers through. You should output a falsey in this case. The only expected inputs are positive whole integers and positive real numbers - you don't need to worry about complex numbers or strings as inputs.
This should mean that you should expect n >= 0
Test cases
(N:handshakes)
0:0
10:45
20:190
10.5:0
1337:893116

Normal golfing rules apply and shortest code wins.
If your code isn't self explanatory, please explain.
Jelly and 05AB1E are the winners, both at 2 bytes

What exactly can we expect in terms of "non-integer" inputs? (having said that, I feel like the error checking might amount to more than the actual challenge)

Related.

@Sp3000 I have edited the question now. You'll only expect real and whole numbers

What about negative numbers?

@MartinEnder indeed it is, but the differ eve is that the handshake problem is slightly more real world

Might ask for some specifics if that's okay - which of the following might we expect as input?: -0, -1, 10., 10.0, .1, -.1, -10., -10.0

Please have a look at our list of things to avoid when writing challenges. Bonuses are one of them. I would suggest removing it since it doesn't really add anything to the challenge. Oh, and also check out our sandbox. That's the place to get rid of some quirks in your challenge before you post it.

@Sp3000 expect all the positive values

So... does that mean -0, 10., 10.0 and .1? (I'm assuming you mean nonnegative - sorry for being a pendant, but stuff like this does tend to matter for esoteric languages which don't have an easy number eval function :P)

If normal golfing rules apply, is there any reason you're excluding full programs?

@Sp3000 no thank you for asking. This is my first question so it's good to know how accurate I need to be in question defining. I wouldn't count -0 as some language would need to evaluate this first. So all numbers greater than 0.

Is erroring on invalid inputs allowed?

@TimmyD sorry didn't actually realise that was a set rule

@george Er... that's fine, welcome! Bit confused now though, since you said "greater than 0" in the comments but wrote "expect n>=0"

@LeakyNun if you mean that it will give an error when an invalid n in entered no.

@Sp3000 whoops, yes greater than or equal to is correct. As in the test case 0

I'm having a think about this challenge and was wondering - why does the challenge allow floats as input, out of curiosity? I'm not sure the error checking adds much to the challenge (and it also makes the challenge a lot harder and less nice for some languages)

Also, Welcome to Programming Puzzles and Code Golf! I recommend posting future challenges to the Sandbox where they can get meaningful feedback before being posted to the main site. Enjoy your stay!

@TimmyD thanks! I will do in future

@Sp3000 when I coded the question myself, it was just n*(n-1)/2 which could take any value, but in the context of the question, there will only be a whole positive number of people in the room, so although it is computable for a float number, it is not contextual

"I've searched for this question and couldn't find it" is often a strong hint that the question is really boring.

@PeterTaylor so the game is over? No more new questions except for boring ones?

@edc65, the subtext that you read should not be "Don't search to see whether your question is a dupe" but "If you think it necessary to justify posting the question, think twice about posting it. Then if you're still planning to post it, think a third time."

@PeterTaylor Aren't you suppose to check that a question has not been asked before? If one does not and it is a dupe, it was a waste of a post. Correct me if I'm wrong but that's is how I thought is worked here?

@george Yes, you should search for dupes. But if you have to start by explaining that you did, it's a good indicator that it's either 1) very trivial, or 2) so close to being a dupe you needed to justify it. Neither are promising.

@Geobits okay that's interesting. I'll keep it in mind

@DrGreenEggsandIronMan sorry I should have removed that after TimmyD's comment. It can be a full program, or just a function, unnamed or names. In PPCG any style of answer is accepted

This would be massively better if invalid input did not need to be considered. Arbitrarily overriding the defaults is a bad idea.

@Mego see my previous reply about the context of the question

Jelly, 2 bytes
c2

Try it online!

Note to others: Due to a bug in Jelly's source, this errored (and, therefore, produced the correct, empty output for non-integer arguments. This has been fixed, but the answer is valid in the penultimate revision of the Jelly interpreter.

Is an empty output falsey?

@DrGreen The empty string is falsy in Jelly, so I'd say it is.

JavaScript ES6, 16
n=>n%1?0:~-n*n/2

Test

f=n=>n%1?0:~-n*n/2

function test()
{
  var i=I.value
  O.textContent=f(i)
}
<input id=I oninput=test()>

One of the shortest JavaScript answers I've seen :-)

What's the advantage of this over n=>(n-1)*n/2?

@Eterm the advantage of ~-n over (n-1) is 2 bytes less. The test of n%1 is required from the spec to detect non-integer input

Thanks edc, this is why I'm a terrible golfer, I always miss half the requirements.

05AB1E, 2 bytes
Code:
2c

Try it online!.

Oh, so 05AB1E programs are just Jelly programs backwards?

So that's how they're so short!

MATL, 3 bytes
2Xn

Try it online!
The code computes the binomial coefficient "n choose 2", where n is the input. For non-integer input no output is produced.
       % Take input implicitly
2      % Push 2
Xn     % n-choose-k
       % Display implicitly

This is a good way to crack it, I though that it was possible, but doubted any languages had a built in combination func

@george I think that's what the Jelly and 05AB1E answers do too

@Luis_Mendo Ah probably because they use c for combination rather than p which is permutation

Brainfuck, 22 21 bytes
,[-[->+>+<<]>[-<+>]<]

Try it online! Note, that brainfuck takes input and output through ASCII, so to enter a "49", you enter ascii value 49, e.g. 1. Brainfuck has no concept of non-integers, so it is impossible to enter one.

Matlab, 61 23 bytes
@(x)~mod(x,1)*x*(x-1)/2

Improvements courtesy Luis Mendo.
Old answer:
@(x)eval('if isnumeric(x) disp((mod(x,1)==0)*x*(x-1)/2);end')
An anonymous function that calls eval. Matlab considers all numbers entered to be doubles unless you explicitly tell it otherwise, so testing for integerness via built-in isn't really an option unless you want to condition your input heavily-- thus the isnumeric and the mod1.
As well, Matlab doesn't allow conditional statements in anonymous functions, so you have to kludge around that by way of an eval statement that evaluates a string. So fun.
The "falsey" output is that it doesn't print anything at all for nonnumerics and prints 0 for a non-integer numeric. For a valid input, it will print the result.

Why do you need isnumeric? The input is guaranteed to be numeric. Also, you can use ~ instead of ==0. And disp is not needed, because function output is allowed by defaut. So you could just use @(x)~mod(x,1)*x*(x-1)/2

Matlab errors on a non-numeric input to mod(), so I was coding to prevent that; I didn't realize that we'd only be expected to ever receive numeric inputs! Also I didn't realize I didn't have to disp(). Thanks!

Welcome! And very good answer BTW. We need more Matlab answers here! :-)

Python, 37 50, 46, 32, 26  bytes
lambda a:a%1==0and a*~-a/2

Making use of the fact that the solution of the handshake problem is (N-1) + (N-2) ... 2 + 1 for N people. The most problematic is the falsey value when a non-int is given.
Big thanks to Leaky Nun and Martin Ender!

Welcome to PPCG, and have fun here!

@LeakyNun Thanks a lot for the improvements and the welcome!

What does ~ mean. Is that Python 2 only?

@george ~ is bitwise not, equivalent to -n-1. It's also in Python 3.

ArnoldC, 266 bytes
ArnoldC has no concept of non-integers, so it is impossible to enter one.
LISTEN TO ME VERY CAREFULLY f
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE r
YOU SET US UP 0
GET TO THE CHOPPER r
HERE IS MY INVITATION n
GET DOWN 1
YOU'RE FIRED n
HE HAD TO SPLIT 2
ENOUGH TALK
I'LL BE BACK r
HASTA LA VISTA, BABY

Explanations:
DeclareMethod f
        MethodArguments n
        NonVoidMethod
        DeclareInt r
        SetInitialValue 0
            AssignVariable r
                   SetValue n
                   MinusOperator 1
                   MultiplicationOperator n
                   DivisionOperator 2
            EndAssignVariable
        Return r
EndMethodDeclaration

CJam, 7 bytes
ri_(*2/

Computes n*(n−1), where n is the input. For non-integer input it produces no output.
Try it online!
r     e# Read input
i     e# Convert to integer
_     e# Duplicate
(     e# Subtract 1
*     e# Multiply
2/    e# Divide by 2.
      e# Implicit display

Mathematica, 19 bytes
#(#-1)/2/._Real->0&

This first computes the result using the explicit formula n(n-1)/2 but then replaces it with 0 if the that gives a floating-point result.
Just for fun, some alternatives to computing the result (minus the input validation) are:
#~Binomial~2
Tr@Range@#-#
n~Sum~{n,#-1}
PolygonalNumber@#-#

R, 28 bytes
Returns 0 if the input, x, is not an integer
x=scan();(x%%1==0)*x*(x-1)/2

Python 3, 22 bytes
lambda z:sum(range(z))

Makes use of Python's standard library. Raises an error whenever the function is fed with a non-integer.

Welcome to PPCG! Nice first post!

Pyth, 7 bytes

?sIQ.cQ2Z
.x.cQ2Z

Test suite.

Erroring with nothing on stdout is considered falsy.

@isaacg You know, the OP said "if you mean that it will give an error when an invalid n in entered no."

CJam, 5 bytes
ri,1b

Prints nothing (except to STDERR) for non-integer input.
Try it online!
Explanation
ri  e# Read input and try to convert to integer N.
,   e# Turn into range [0 1 2 ... n-1].
1b  e# Sum the list by treating it as base-1 digits. We do this instead of
    e# a simple reduction (:+) because the latter fails for empty lists.

Desmos, 11 bytes
.5nn-.5n
n=1

Try it here
Ungolfed formula:

This does not seem to handle the non-integers case.

@ Mama Fun Roll Do you expect for there to be partial people there?

It is a test case that you have to handle. "Also the code should not let non-integers through. You should output a falsey in this case."

That's why I have the variable slider set to integers.

Oh, I was entering input through the text box. Nevermind, sorry :P

Yeah, you can always increase the upper limit

Hoon, 30 bytes
|=
n/@
(div (mul n (dec n)) 2)

Just compute (n * (n-1))/2.
Hoon is strongly typed, so you can't call this function with a float or negative number.

Python 3, 32 16 bytes
lambda n:n*~-n/2

Throws an error if n is not an integer.
Old Version:
lambda n:(0,n*~-n/2)[n==int(n)]

Uou can use bitwise operators ~- to remove the brackets. Do n*~-n/2

Welcome to Programming Puzzles & Code Golf! Unfortunately, the spec requires the output to be falsy if the input is non-integral.

dc, 18 bytes
[d/]sqdX0!=qd1-*2/

Explanation
[d/]sq

Store in register q a macro that replaces top of stack with 1 (by dividing by itself).
dX0!=q

If there are any fraction digits, then execute the macro.
d1-*2/

Compute ½n(n-1).  If we started with 1 (either as input or because a non-integer value was entered) the result will be 0.

Factor with load-all, 12 bytes
[ iota sum ]

Same as this answer.

PowerShell v2+, 33 bytes
param($n)$n*($n-1)/2*($n-is[int])

Full program. 20 bytes to compute n(n-1)/2 and 13 bytes to validate input. Uses the -is operator, so requires V2 or newer.

J, 14 8 bytes
2&!*]=<.

6 bytes saved thanks to miles!
Explaination:
2&!      NB. Binomial coefficient of 2 and the argument
   *     NB. Times...
    ]=<. NB. argument == floor(argument)

Previous solution: -:@(*<:)*(=<.)

You can use ! to calculate the binomial coefficient. Then you can shorten it to 2&!*]=<. for 8 bytes.

Dyalog APL, 9 bytes
2∘!×(|=⌊)

The chose-2 times (whether the abs equals the floor).

Java, 363 bytes
I thought I ought to make sure everybody gets a chance to meet everybody else.
Unfortunately some of the party guests do have to ask if they've met someone before, to avoid shaking someone's hand twice. Hopefully the guests are pretty good at recognizing faces.
Golfed:
import java.util.ArrayList;public class H{static int h = 0;public static void main(String[] a){int b = Integer.parseInt(a[0]);P[] e = new P[b];for(int i=0;i<b;i++){e[i] = new P();}for(P p : e){for(P o : e){p.s(o);}}System.out.print(h);}}class P {ArrayList
 l = new ArrayList
();void s(P o){if(o.equals(this)){return;}if(!o.l.contains(this)){H.h++;l.add(o);}}}

Un-golfed:
import java.util.ArrayList;

public class PartyHost {
    static int shakes = 0;
    public static void main(String[] args){
        int amount = Integer.parseInt(args[0]);
        Person[] people = new Person[amount];
        for(int i=0; i<amount;i++){
            people[i] = new Person();
            // welcome to the party!
        }
        // well, we gotta get this party rockin'. hey, have you met my friend...
        for(Person p : people){
            for(Person other : people){
                p.handshake(other);
            }
        }
        System.out.print(shakes);
    }
}

class Person {
    ArrayList<Person> already_shook = new ArrayList<Person>();
    void handshake(Person other){
        // hmm, have we met already?
        if(other.equals(this)){
            // I mean, I guess I could shake hands with myself... maybe later.
            return;
        }
        if(!other.already_shook.contains(this)){
            // it seems not!
            // *firm grasp. maintain eye contact*
            // uh oh don't hold on too long
            // hope he doesn't grab too early or too late
            PartyHost.shakes++;
            already_shook.add(other);
        }
    }
}

Perl 5, 25 bytes
A subroutine:
{($_=pop)*!/\D/*($_-1)/2}

See it in action:
perl -e'print sub{($_=pop)*!/\D/*($_-1)/2}->(3.14)'

\. would work as well as \D.

, 5 chars / 7 bytes
МƦ⁽ï2

Try it here (ES6 browsers only).
Builtins are pretty cool.

RETURN, 8 bytes
[$1-×2÷]

Try it here.
Anonymous lambda that leaves result as top of stack. Usage:
10[$1-×2÷]!

Explanation
[      ]  lambda
 $1-      n-1
    ×     *n
     2÷   /2

Google Sheets, 17 14 bytes
=((B1^2)-B1)/2

Cell B1 is the input.

Haskell, 15 bytes
f x=sum[1..x-1]

[x..y] ranges are inclusive...
Oh and I don't know how to handle the non-integers...

Golisp, 18 bytes
{(n)~[+range[1n]]}

Python equivalent: lambda n: sum(range(1, n)).
Oh and Golisp don't have floating point number (for now)


text:
Are the two sets equal
{}is the empty set. You may use () or [] if you choose.
We aren't going to rigorously define "set", but sets all satisfy the following properties:
Sets follow the usual mathematical structure. Here are some important points:

Sets are not ordered.
No set contains itself.
Elements are either in a set or not, this is boolean. Therefore set elements cannot have multiplicities (i.e. an element cannot be in a set multiple times.)
Elements of a set are also sets and {} is the only primitive element.

Task
Write a program/function that determines whether two sets are equal.
Input
Two valid sets via stdin or function argument.  The input format is loose within reason.
Some valid inputs are:
{} {{}}
{{},{{}}} {{{{{},{{}}}}}}
{{},{{},{{}}}} {{{},{{}}},{{{{{},{{}}}}}}}

Invalid inputs:
{{} {}              Brackets will always be balanced.
{{},{}} {}          Set contains the same element twice

Output
A truthy value if the inputs are equal, falsy otherwise.
Test cases
Your submission should answer correctly for all valid inputs, not just for the test cases. These may be updated at any point.
Truthy:
{} {}
{{},{{}}} {{{}},{}}
{{},{{},{{{}},{}}}} {{{{},{{}}},{}},{}}

Falsy:
{} {{}}
{{},{{},{{{}},{}}}} {{{{}}},{},{{}}}
{{},{{}},{{{}}},{{},{{}}}} {}

Scoring
code-golf
Additional Rules
An additional rule has been added banning unordered iterable types altogether. They are too common and trivialize this challenge far too much. Feel free to leave answers that violate this in place, please just make an indication that they were made before the rule change.

Can a language with a nestable set type just check equality?

@xnor Built-ins should be fair game, yes

Does that mean I can write a function that accepts two sets as input? That seems to defeat the purpose of the challenge since {{},{{}}} and {{{}},{}} are literally the same set.

@Dennis well, even though this is a "balanced-string" challenge, I never really thought of it as a parsing challenge. But, now that I think about it, by assuming that all input is valid, I've kind of made it a parsing challenge. So I think you're right. Enough languages probably have the idea of a an un-ordered list that would trivialize this.

I'll be fine with whatever decision you make. Personally, while I think that using sets somehow can still be creative without trivializing the challenge (like my Julia answer, which recursively converts a nested array into a nested set), allowing nested sets as input makes the whole thing a bit too simple (== in Julia, 2 bytes; frozenset.__eq__ in Python, 16 bytes; etc.).

@Dennis My original solution used recursion, which is why I thought it might be interesting, so I think using similar built-in type equality checks shouldn't be allowed (despite what I said to xnor).

OK, rolling back my Julia answer. The cleanest approach would probably be to ban unordered iterable types altogether. For example, converting two sets to lists and comparing the results technically doesn't use a set equality test.

See the comments for an explanation. Please don't do this. Comments are volatile and go away very easily, so important sutff goes in the post body

@cat the rule is the important part, and that is in the text body. I felt that the explanation was too cumbersome (because it was really a conversation) to put in the text body. If you think it is truly necessary, I will ask Dennis to move the conversation to chat and link that from the body. As it stands, I have added a brief summary to the body and removed the reference to the comments (which is what I should have done in the first place, whoops!).

APL (NARS2000), 4 bytes
≡⍦

⍦ is the multiset operator, which modifies functions to treat their arguments as sets instead of lists
≡ is the equivalence function, which returns a Boolean indicating if the arguments are completely equivalent in value and shape
Regarding the additional rule: Note that this answer does not use any unordered set datatype, but just normal lists (which may contain multiple identical elements). It just treats them as sets.
The byte count is 4 because NARS2000 uses UCS-2 exclusively.

CJam, 11 bytes
q']/"]$"*~=

Try it here.
CJam, 13 bytes
q~L{{j}%$}j:=

Try it here.

Jelly, 6 bytes
ß€Ṣ
ÇE

Try it online! or verify all test cases.
How it works
ÇE   Main link. Argument: [s, t] (pair of set arrays)

Ç    Apply the helper link to [s, t].
 E   Check if the elements of the resulting pair are equal.

ß€Ṣ  Helper link. Argument: u (set array)

ß€   Recursively map this link over u.
  Ṣ  Sort the result.

Brachylog, 8 bytes
{p:1a.}.

This expects brackets in Input and Output.
For example:
?- run_from_atom('{p:1a.}.', [[]:[[]]], [[[]]:[]]).
true .

Explanation
{     }.   True if the predicate inside brackets is true with input Input and output Output

 p          Unify an implicit variable with a permutation of Input
  :1a       Apply this same predicate to each element of that implicit variable
     .      True if Output can be unified with the resulting list

Prolog (SWI), 37 bytes
X+Y:-permutation(X,Z),maplist(+,Z,Y).

Try it online!
Takes input as nested lists, i.e. with square brackets instead of braces. Originally, this was X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N)., but then I tried translating Fatalize's Brachylog v1 answer and it turned out 3 bytes shorter.
X+Y :-                    X+Y succeeds when
    permutation(X, Z),    for some permutation Z of X
    maplist(+, Z, Y).     + succeeds for every pair in Z zipped with Y.
                          (where maplist will succeed without the recursive call to + for
                          two empty lists, and fail if the lists have different lengths)

It actually can handle curly braces instead, for 23 more bytes:
Prolog (SWI), 60 bytes
{A}*C:-A=..[,|B],sort(B,C).
X+Y:-X=Y;X*M,Y*N,maplist(+,M,N).

Try it online!
* here converts a (nonempty, hence the X=Y;) brace term on its right side to a list of the term's elements then sorts it to its left side.
{A}*C :-            X*C succeeds when X is the brace term containing A
    A =.. [,|B],    where A is a comma-tuple and B is a list of its elements,
    sort(B, C).     and C is B sorted.

Since both arguments to + are going through * already, putting a sort in * saves 7 bytes over using permutation in +.
And finally, here's a version which handles the input lists possibly having duplicate elements, which is what inspired me to write a solution in Prolog to begin with:
Prolog (SWI), 57 bytes
X+Y:-X/Y,Y/X.
X/Y:-maplist(-(Y),X).
Y-E:-member(F,Y),E+F.

Try it online!
X+Y :-                   X+Y succeeds when
    X/Y, Y/X.            X/Y and Y/X succeed.
X/Y :-                   X/Y succeeds when
    maplist(-(Y), X).    for every element E of X, Y-E succeeds
                         (or when X is empty).
Y-E :-                   Y-E succeeds when
    member(F, Y),        there exists some element F of Y
    E+F.                 such that E+F succeeds.

Essentially, X/Y declares that X is a subset of Y, by declaring that for every element of X, there's an equal element of Y, so X/Y,Y/X declares that X and Y are equal sets.

And now I need sleep

JavaScript (ES6), 42 bytes
f=(a,b,g=a=>0+a.map(g).sort()+1)=>g(a)==g(b)

Accepts input using []s e.g. f([[],[[]]],[[[]],[]]). Works by converting the arrays to strings and then sorting them from the inside out. 0 and 1 are used because they're shorter than '[' and ']', so for example g([[[]],[]]) is 001,00111 which represents [[],[[]]].

You don't use recursion, so you can make it anonym

Why is that 0+ there?

@Bálint Because without the 0+ and +1 all I'd get is commas.

@Bálint I don't know why I forgot to remove the f=, I didn't include it in the byte count and I'm too lazy to edit the post just for that.

Pyth, 9 bytes
LSyMbqyEy

Input format: use [] instead of {}.
Test suite

Python 2, 49 bytes
f=lambda x:sorted(map(f,x))
lambda a,b:f(a)==f(b)

For example, calling the anonymous function g:
>>> g( [[],[[]]] , [[[]],[]] )
True

g([[],[[],[]],[[],[[]]],[[]],[[[]]]], [[[],[]],[[[]],[]],[[]],[[[]]],[]]) returns False, but the sets are equal. That should be fixed by mapping before sorting.

Mathematica, 16 bytes
Equal@@Sort//@#&

An unnamed function which expects a list containing both sets, e.g.
Equal@@Sort//@#& @ {{{}, {{}}}, {{{}}, {}}}

We use //@ (MapAll) to sort the sets at every level and then assert at the results are equal.

SETL, 1 byte
=

Takes sets as left and right arguments.
Note that this does NOT adhere the added rule which prohibits unordered set datatypes.

Julia, 36 35 32 bytes
u*v=(sort(u.*v)...)
s%t=s*s==t*t

Input is a nested array either either the (deprecated) {} syntax or Any[].
Try it online!

Brachylog v2, 3 bytes
p↰ᵐ

Try it online!
Takes one set through the input variable and the other set through the output variable. Succeeds if the sets are equal and fails if they aren't.
Like my main Prolog answer, a translation of Fatalize's Brachylog v1 answer (which I think could be golfed down to p:0a?).
       The input
p      can be re-ordered so that
 ↰     when this predicate is applied again to
  ᵐ    all of its elements,
       it is the output.

Vyxal, 1 byte
⊍

Try it Online!
Outputs a non-nested empty list if truthy, anything else is falsey. In Vyxal, the empty list is falsey but a list containing only an empty list is truthy.

Haskell, 77 bytes
import Data.List
data S=L[S]deriving(Eq,Ord)
f(L x)=L$sort$f<$>x
a!b=f a==f b

Out of interest, why did you need to define your own list type here? (Are == and < not defined by default for lists?)

the datatype is recursive: I define S as a (wrapped-in-L) list of Ses. Haskell has no built-in type that can represent lists of lists of lists of …

, 7 chars / 9 bytes
ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).
Explanation
         // implicit: î=input1,í=input2
  Ꞩî,Ꞩí // apply the Set method to both inputs
Ѩƾ      // check if the Sets are equal
        // implicit output

Perl 6, 55 bytes
my&f=->\a,\b {a==b&&all map {f(|$_)},(a.sort Z,b.sort)}

Takes input with [].
Try it online!

Some things: you don't need the space after the arguments to the code block, it's often shorter to use the $^ syntax instead, and I don't think the [] input works, since all of [[]],[[[]]],[[[[]]]] etc evaluate to []

Wolfram Language (Mathematica), 20 bytes
Sort//@#==Sort//@#2&

Try it online!
Pure function that takes each set as an argument.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes