Grab a [scratchblocks](() + ())[/scratchblocks] block. Then click the left arrow. The block skips the one-input version of the block and retracts straight to the zero-input version. I wonder why is there 0, 2, 3 and more input versions but not 1?

Because there is no reasonable use case for it (and it saves time if a user can skip pointless options):

- If you know, at coding time, there will always be exactly 1 number as input,

coding the addition would be useless. - If, when coding, you don’t yet know how many numbers will have to be added,

you shall use an input list: - what you called the “zero-input version”.

This would also make things ambiguous, since you can't distinguish between others with only 1 input slot. Also, having only 1 input slot behaves identically to [scratchblocks]([id v] of () :: operators)[/scratchblocks] block. You can still make them by using:

It's clear what it should mean: it should add up all its inputs (all one of them), i.e., it reports its input--it's the identity function.

We don't have that as an option because Jens agrees with @qw23 that it'd be useless. We had a big argument about it because I agree with @mobility212 that the missing option, even if nobody would use it, can confuse users who are clicking the left arrowhead while counting down to zero.

I don't know why you denigrate the name "zero-input" for the block. It does just what you'd expect it to do with no inputs, namely, report the identity element for the function:

Just put:

((INPUT_A)+(0))

You'll just end up getting the value at `INPUT_A`

anyways as 0 has no value and thus nothing happens in this equation.

EDIT: Or just skip the hassle and bring out `INPUT_A`

.

If you want to make sure a value is a number, then you want to stick it in the block.

Uhhhh, I think minimum and maximum are switched.

It's a common mis-perception to make

The minimum block returns the minimum value of any of its arguments

The maximum returns the maximum value

So they are labelled correctly

But of course, most of the time we want to put a limit on a value and to do so you have adjust your approach and use the minimum block to make sure a variable value doesn't exceed a limiting value

And vice versa for the maximum block

Yeah, that would be -Infinity, not Infinity.

This one would be Infinity, not -Infinity.

The "mis-perception" was mispercepted, because I didn't make a misperception.

Sorry - I didn't realise that it was the zero slots case you were referring to - should have tracked the thread better

Noice. At least I was right. But don't be so hard on yourself.

We don't yet know if you are right or not

Don't be surprised if the current results are in fact valid

I used quotes because that's literally what @mobility212 called it, and I (perhaps wrongly) didn't agree with the term ... BTW is "deXXXXate" even PC these days?

Oh yeah huh. I never thought about its etymology. I apologize to anyone offended.

No. Everyone thinks that at first glance. But remember what "identity element" means: For any number X, `X MIN ID`

has to equal X (if we're looking at the operation MIN). So, what's `3 MIN ∞`

? (Which is smaller, 3 or ∞?) What's `3 MIN −∞`

?

Bruh, no. X MIN ID is X, but here, X MIN ID is ID, and ID is ID MIN ID, yet ID MIN ID = ID. However, in your example, 3 MIN -Infinity, the MIN is -Infinity. Hence, the lowest is -Infinity. Switch -Infinity and Infinity for MAX.

What if the id of min is infinity?

Hmmm, if you mean X MIN Infinity, then it's X.

Yeah, X MIN Infinity is X, but if there is no X, there's just MIN Infinity. It does make sense as to why snap says Infinity instead of -Infinity for MIN.

All of these functions, with variable length input list, may be interpreted as recursive functions, executed along the following pattern:

with the identity function being something like:

Some examples:

Would you understand this better in traditional function notation? min(3,∞) is 3, because 3<∞. Right? min(3,−∞) is −∞, though. Whatever the identity element is, it has to satisfy the rule that min(*anything*, ID) is the "anything." Using 3 as an example, we have that min(3,ID)=3. Which behaves that way, ∞ or −∞?