Arity

You can return functions which all:

• have scope of a persistent array of previous arguments
• return a function object with a join property that takes that persistent array and joins it

Async functions in JS are syntax sugar for functions returning a Promise.

core.async does not work with Promises by default and you need to use the helper function to make them act like channels if you want to. The macro does this for you.

There are only two reasons to ever use Function#bind:

1. When you want to bind the function to a particular context object. Practically speaking, when you want to make sure ahead of time that the this keyword inside the function will refer to a particular, known object.
2. When you want to pre-define some arguments, a.k.a. "partial function application".

The second case lends itself perfectly to what function currying is all about - making an N-ary function flexibly callable like:

• fn(arg1, arg2, ..., argN), or
• fn(arg1, arg2, ...)(argN), or
• fn(arg1, arg2)(..., argN), or
• fn(arg1)(arg2)(...)(argN).

The important thing to notice here is that we need multiple separate functions for all cases but the first. Let's say you have a worker function that takes 3 arguments. You can...

1. ...pass enough arguments for the worker function, i.e. 3 or more. Then curry() calls the worker function with those 3 arguments and returns the result.
   This makes fn(arg1, arg2, arg3) possible.
2. ...pass too few arguments for the worker function. Then curry() does not call the worker, but must return a new function which takes the remaining number of arguments.
   This makes all of fn(arg1)(arg2, arg3) and fn(arg1, arg2)(arg3) and fn(arg1)(arg2)(arg3) possible.

Function#bind covers the second case: It creates a new wrapper function for the worker and pre-fills some of the worker's argument slots with the given values. The context object is irrelevant for that intention, so using null here is fine.

In order to do this you need to use the operations of the monad, typically:

As you saw, the kind of template literal types you are creating quickly blow out the compiler's ability to represent unions. If you read the pull request that implements template literal types, you'll see that union types can only have up to 100,000 elements. So you could only possibly make Sort accept up to 4 comma-separated values (which would need approx 11,110 members). And you certainly couldn't have it accept an arbitrary number, since that would mean Sort would need to be an infinite union, and infinity is somewhat larger than 100,000. So we have to give up on the impossible task of representing Sort as a specific union type.

Generally, my approach in cases like this is to switch from specific types to generic types which act as recursive constraints. So instead of Sort, we have ValidSort. If T is a valid sort string type, then ValidSort will be equivalent to T. Otherwise, ValidSort will be some reasonable candidate (or union of these) from Sort which is "close" to T.

This means that anywhere you intended to write Sort will now need to write ValidSort and add some generic type parameters to an appropriate scope. Additionally, unless you want to force someone to write const s: ValidSort<"height asc"> = "height asc";, you'll want a helper function called, something like asSort() which checks its input and infers the type. Meaning you get const s = asSort("height asc");.

It might not be perfect, but it's probably the best that we can do.

Let's see the definition:

If you remove the method add(int a, long... b) you will find that your code won't compile because the remaining method add(int a, Long b) cannot be called with add(1, 2) because 2 is an int and a primitive int cannot be boxed into a Long. Likewise, the statement Long a = 2; is invalid. Therefore the only matching candidate is add(int a, long... b).

I think you can get the desired behaviour by changing the --list option from a boolean to an array or collection of Strings.

For example:

Use na_values for convert ? to missing values:

If you'd like to accept n arguments and then apply f, you may call fmap n times. So, if g :: r -> b -> c, then