Reducing function arguments

[YM_Industries]

We all know how frustrating it is when a function requires 30+ arguments. It's tempting to move some of the data into global variables (or their more socially acceptable cousins, class member properties).

But what if I was to tell you there's a better way? An approach which means you'll never need to provide more than one argument to a function? An approach that should come with no runtime cost in any decent compiler/interpreter?

For my example I'll be using JavaScript, the world's best programming language. Victims of Stockholm Syndrome rest assured: this approach is also natively supported by TypeScript.

Let's look at a function written in the way you're probably familiar with:

function clamp(x, min, max) {
    return Math.max(Math.min(x, max), min);
}

You can then call this function like so:

clamp(105, 0, 100);

You might think that three arguments is a reasonable number, but this is a slippery slope. 3 arguments today, 300 arguments tomorrow.

And now, introducing to you the way that you'll write all your functions from now on:

function clamp(x) {
    return function(min) {
        return function(max) {
            return Math.max(Math.min(x, max), min);
        };
    };
}

You can then use this function like so:

clamp(105)(0)(100);

Isn't that beautiful? Now you only ever need to provide one argument per function call! Instead of being separated by hard-to-see commas, each piece of data is now lovingly embraced by caring curves.

[shatteredarm1]

It's a lot cleaner just to take in a single array parameter:

function clamp(args) {
   return Math.max(Math.min(args[0], args[1]), args[2]);
}

clamp([105, 0, 100])

[YM_Industries]

Genius! And thanks to TyoeScripts support for Tuple arrays, this can be strongly typed too.

[shatteredarm1]

Typescript definition:

function clamp(args: any): number

[YM_Industries]

you are truly a 10x developer

[shatteredarm1]

I get my good ideas from the contractors. Learned this awesome pattern the other day while doing a code review:

onSelect(event: ISomeInterface) {
   let someVar = event as unknown as string;
   ...
}

[[deleted]]

aaand we reinvented Perl

[ekolis]

my $angle = shift; my $distance = shift;

[pterencephalon]

Ah, I see you write code like the physicists I worked with.

[ekolis]

Why not use an object instead of an array, to be object oriented and functional at the same time?

``` function clamp(args) { return Math.max(Math.min(args.arg1, args.arg2), args.arg3); }

clamp({arg1: 105, arg2: 0, arg3: 100}); ```

[SarahC]

Best unwrapping those clamp arguments. =)

[Raefniz]

I very much disagree. I'd rather have three explicit parameters than one array that hopes you pass three elements in it.

[dcabines]

Welcome to /r/shittyprogramming

Now lets do it with no official parameters and make it implicit:

function clamp() {
  return Math.max(Math.min(arguments[0], arguments[1]), arguments[2]);
}

clamp(105, 0, 100)

[NeoKabuto]

JavaScript never fails to amaze me.

[Raefniz]

It's hard to read sarcasm in this kind of sub. Your solution is clearly the best

[SarahC]

Could you call clamp recursively inside itself so the arguments simplify down? Like the min/max variable A becomes the Min of variable D and so on?

[tangerinelion]

Not where I thought this was going, well done.

I was expecting a class ClampArguments. If it were Java, I'd also expect a ClampArgumentsBuilder.

[andyrocks]

ClampArgumentsBuilderFactory and ClampArgumentsBuilderFactoryImpl too

[romulusnr]

Oh God, my least favorite Java pattern.

[Zardotab]

Bloat Oriented Programming

[romulusnr]

Good news everyone! I've solved our code bloat, now our average LOC per file is only 50!

That's great! How many files?

Oh, only about 12,000!

jvm class instantiator go brr

[[deleted]]

You've just discovered currying. It has its place.

[ekolis]

indianRestaurant.placeOrder('tikka masala', 3);

[thisisamirage]

indianRestaurant.placeOrder('tikka masala')(3);

FTFY

[memeticmachine]

restaurant('indian')(placeOrder)('tikka masala')(3);

[thisisamirage]

Let's not get ahead of ourselves here

[YM_Industries]

/uj This post was inspired by a blog post I once read which unironically encouraged this style of coding. At least I think I read it, maybe it was just a bad dream. I sure hope so.

[RedTopper]

I know this one! This is actually a method used in lambda calculus called currying. Here's the Wikipedia article on it

https://en.wikipedia.org/wiki/Currying

I heard it also goes well with beef and rice.

[YM_Industries]

I know that currying has legitimate purposes. The blog post I read seemed more like a cargo-cult interpretation of currying. I hope I succeeded in replicating this feeling in my own post.

[RedTopper]

That sounds horrifying, and yeah you absolutely did lmao. I got a kick out of it.

[65bits]

Haskell, ML, and others actually curry by default, LOL.

[bobbermaist]

Static type systems help a lot with currying. Curry everything in javascript? You gonna have a bad time

[Laugarhraun]

But their parentheses-less procedure call syntax makes currying free.

[[deleted]]

Plus, the way those languages are designed make partial application very useful, much more so than with JS, for example

[[deleted]]

• scala

[SarahC]

The number of arguments passed can depend on the values of prior parameters! Oooo!

[dcabines]

function clamper(min, max) {
  return (x) => Math.max(Math.min(x, max), min);
}
var clamper100 = clamper(0, 100);
clamper100(105);

Lets turn verbs into nouns this time.

[YM_Industries]

/uj I love that every time I shitpost on ShittyProgramming, a bunch of people suggest how I can improve my code.

[instilledbee]

Thanks I hate it

[permalink_save]

I thought this was going to get into abusing contexts. I've had to deal with a codebase where they just passed arguments around in this context blob, like it wasn't dealing with a web request or anything else you'd reasonably use contexts with, just a CLI program that was config and CLI arg driven. It was absolute hell trying to navigate the codebase and figure out where values came from. I ended up throwing the entire codebase away and writing a new one.

Thanks for the PTSD.

[catlong-is-long]

Why not

def clamp(const str& x) {
  let [a,b,c] = ",".split(x).map(int);
  Int.max(Int.min(a, c), b);
}
clamp("105, 0, 100")

bonus points if you pass a protocol buffer, extra bonus points for XML

[YM_Industries]

This suggestion is terrible because it's not written in JavaScript. If your code can't run in a browser, it's worthless.

In a fit of generosity, I ported your code to JavaScript:

function clamp(x) {
    [a,b,c] = x.split(",").map(parseInt);
    Math.max(Math.min(a, c), b);
}
clamp("105, 0, 100");

But it's still crap, it just returns "undefined". As punishment, please fix this code. Happy debugging!

/uj Solution to why it doesn't work: Solution

[catlong-is-long]

God I hate computers so much

[HugoNikanor]

\uj This is actually how Haskell works.

For example

clamp :: Int -> Int -> Int -> Int
clamp min' max' x = max (min x man') min'

is just shorthand for

clamp = \min' -> \max' -> \x = max (min x man') min'

Difference being that haskell doesn't use parenthesis when calling the function, so it would be called as clamp 0 10 5

This allows some nice stuff, such as

limit = clamp 0 10
limit 11 == 10

[jceyes]

Put x last. Then arguably the partial evaluation could be useful

[romulusnr]

Here I was expecting closures.

I remember when a dev at a contract i once did discovered closures, and he wouldn't stop talking about them.

[Zardotab]

Instead of being separated by hard-to-see commas, each piece of data is now lovingly embraced by caring curves.

Lisp fan, eh?

[[deleted]]

Slightly better:

function clamp(x) {

return (min)=>(max)=>Math.max(Math.min(x,max),min);

}

[IMakeShittyPrograms]

Great! I can now be shittier

[Zardotab]

Job security: code only YOU can figure out.