A word to remove n items from the stack: ndrop or dropn

[ruv]

Many systems/libraries define a word that drops a specified number of items from the data stack.
This word has a stack diagram ( +n.cnt*x +n.cnt -- ).

In the wild, the names «ndrop» and «dropn» are found for this word. Maybe something else?

The question is what is a better name for this word.

Among the standard words, a word that consumes and/or produce a different data type than some base word is typically named after the base word by adding a short prefix to its name. This rule is also used when parameters are passed indirectly, only formally (like in fdepth), or only somehow associated (like in falign).

Some examples:

Basic word name	Derived names
abs	dabs, fabs
+	d+, f+
<	u<, f<
aligned	faligned
depth	fdepth
drop	fdrop
>r	n>r
r>	nr>

So I think the name ndrop is more appropriate for the word in question.

A portable (not efficient) implementation for this word looks like this:

: ndrop ( +n.cnt*x +n.cnt -- ) 0 ?do drop loop ;

A similar word that removes a specified number of items from the floating point stack should probably be named as nfdrop, after fdrop:

: nfdrop ( F: +n.cnt*r -- ; S: +n.cnt -- ) 0 ?do fdrop loop ;

Are you agree or disagree?

[SirWumpus]

I'm not fussed much. Though I would have named things like drop2 instead of 2drop (its a count, not a type), while fdrop gives a type and instead of 2drop for consistency I would have thought ddrop (which could be aliased to drop2).

For me, I more naturally think dropn and dropall, given how I write functions in C, Java (obj.dropn()), Erlang, etc.

But Forth naming style has always seemed rather odd to me. Its probably what makes it hard to understand for some. Cryptic names vs descriptive.

[ruv]

Though I would have named things like drop2 instead of 2drop
(its a count, not a type)

Still, conceptually it's a data type.

The prefix 2 in the word names like 2drop, 2@, 2!, 2swap denotes 2*x, that is a data type, namely the unspecified cell-pair.

The prefix 3 in the word names like 3drop, 3@, 3!, 3swap denotes the data type 3*x, which is a 3-tuple of unspecified cells.

The missing prefix 1 (a default) in the word names like drop, @, ! denotes the data type 1*x, which is the unspecified cell.

The prefix 0 in the word name 0! denotes the data type 0*x — note that this word consumes the address and no other value from the stack.

The prefix c in the word names like c@, c! denotes the data type char.

In the word names like ndrop, n>r, nr>, n denotes a data type too, namely the data type ( +n.cnt*x +n.cnt ), which is a dependent coproduct. This data type is a union: ( 0 | x 1 | x x 2 | x x x 3 | ... ), which can be also written as ( 0*x 0 | 1*x 1 | 2*x 2 | 3*x 3 | ... ) . Note that each element of this union is a pair of a tuple (of unspecified cells) and the length of this tuple (at the top) — that's why this type is a dependent coproduct (namely, dependent pair) type.

Examples of this data type members: 0, 10 1, 0 1, 22 33 2, 3 2 1 3, 1 1 1 1 4.

Update: n in the names n>r, nr> does not denote the signed single-cell integer, (this does not make sense for these words), — this may be confusing at first, but should become clear after learning.

---

I more naturally think dropn and dropall, given how I write functions in C, Java (obj.dropn()), Erlang, etc.

In C you would write obj.dropn( 3 ), in Forth — 3 ndrop.

[ruv]

Derivatives of pick and roll

In the word pick ( x.param +n.cnt*x +n.cnt -- x.param +n.cnt*x x.param ), the top value +n.cnt is the length of the next tuple, and the parameter following that tuple is taken and copied on the top (consuming +n.cnt). The copied parameter x.param is an unspecified cell, assuming the default 1*x.

Therefore, a derived word 2pick should take a parameter of the type 2*x following the tuple and copy it on the top (consuming +n.cnt). Similar for 2roll. They can be defined as follows:

: 2pick (  xd.param  +n.cnt*x +n.cnt -- xd.param  +n.cnt*x  xd.param )
  1+ dup 1+ pick swap pick
;
: 2roll (  xd.param  +n.cnt*x +n.cnt -- +n.cnt*x  xd.param )
  1+ dup 1+ roll swap roll
;

[larsbrinkhoff]

To expand a little on @ruv's comment, I have always taken the 2 prefix to mean two unspecified cells, whereas the d prefix indicates a double-length integer.

[MitchBradley]

DROPS

Especially useful in the phrase DO I DROPS LOOP

[ruv]

@MitchBradley wrote:

DROPS

Conceptually, the English word «drop» in the Forth word name drop is used as a verb. Then, drops means the third-person singular form of the verb «to drop». But it seems, this is not you want the name drops to mean. You probably mean the plural of the noun «a drop». But this noun does not makes sense for the Forth word drop. So the name drops is confusing, I think.

By the way, I see ndrop in your Open Firmware repository:

code ndrop  ( n1 .. nN #N -- )

[CCurl]

Since it is non-standard, you can name it anything you want. It's your word; name it whatever is most clear to you.

If it was up to me, I'd name it "drop-n" ... I append a "-n" to the name if I want to have the word do it some number of times. That is my style. Yours may very well be different, and that is 100% OK.

I wouldn't stress out over it. :)

[ruv]

@CCurl wrote:

Since it is non-standard, you can name it anything you want.

I think, this word is provided by systems and used by programs often enough to be standardized.

The idea behind standardizing such a word is to reserve its name in the FORTH word list. That is, if a standard Forth system provides a word with a certain name, then this word shall behave as specified in the standard. This allows standard programs to test whether this word is provided and implement it if it is not.

I'd name it "drop-n" ... I append a "-n" to the name if I want to have the word do it some number of times.

Reasonable.

But still, it seems better to follow the naming pattern of the existing words n>r and nr> and the proposed words f>r, fr>.

[Bushmills]

I asked chatgpt for a short word, meaning "drop multiple items", and it came up with:

How about "spill"? It’s short, conveys the idea of dropping multiple items, and has a natural, versatile usage.

While I tend to name the implementation of such a word "ndrop", I dislike its non-orthogonality with, say, roll vs. rot - according the same pattern, roll should be nrot, rotn, or rots, but instead, a genuine word was chosen, rather than such a synthetical strung together word creation. But I didn't care much about it, due to my very infrequent use: if a word benefits from "ndrop", there may be better ways to write it, either by better factoring (in case a constant count of many items needs to be dropped) or by avoiding stack effects which require keeping track of variable item counts.
Maybe the question could be "why would one use such a word" rather than "how should it be named".

Asking chatgpt for an alternative suggestion, it came up with "shed":

"Shed" could work! It's concise and suggests releasing or letting go of multiple items.

I like that one.

[ruv]

@Bushmills wrote:

I asked chatgpt for a short word, meaning "drop multiple items", and it came up with:

How about "spill"?

Interesting. Although it does not have the connotation of decreasing (like drop).

In LLM, the result largely depends on your prompt. If you provide ChatGPT with a more detailed prompt, with examples and other patterns, it could suggest you even ndrop or dropn. For example, it explained me why one is better than another: The advantage of ndrop over dropn is that it aligns more closely with the common Forth style of placing the argument (the number) before the word (the action) 😂

---

While I tend to name the implementation of such a word "ndrop", I dislike its non-orthogonality with, say, roll vs. rot - according the same pattern, roll should be nrot, rotn, or rots,

If we suppose that n in these names denotes a data type, the pattern is different. Have a look.

n>r, nr> , ndrop

These words operate on a parameter of the data type ( +n.len*x +n.len ) , which less formally can be written as ( x.m x.m-1 x.m-2 ... x.2 x.1 +n.len ) where m = +n.len.

Generalization of swap

• swap operates on two 1*x parameters: ( 1*x 1*x -- 1*x 1*x )
• 2swap operates on two 2*x parameters: ( xd xd -- xd xd )
• 3swap should operate on two 3*x parameters: ( 3*x 3*x -- 3*x 3*x )

Thus, nswap should operate on two parameters too, each of which has the data type ( +n.len*x +n.len ). Let this data type be denoted by the symbol qtupl. This data type means a qualified tuple — a pair of a tuple and its length in cells at the top.

• nswap ( qtupl.2 qtupl.1 -- qtupl.1 qtupl.2 )
• t{ 200 100 2 30 20 10 3 nswap -> 30 20 10 3 200 100 2 }t

Generalization of rot

• rot operates on three 1*x parameters: ( x x x -- x x x )
• 2rot operates on three 2*x parameters: ( xd xd xd -- xd xd xd )
• 3rot should operate on three 3*x parameters: ( 3*x 3*x 3*x -- 3*x 3*x 3*x )

Thus, nrot should operate on three qtupl parameters.

• nrot ( qtupl.3 qtupl.2 qtupl.1 -- qtupl.2 qtupl.1 qtupl.3 )
• t{ 0 200 100 2 30 20 10 3 nrot -> 200 100 2 30 20 10 3 0 }t

So the basic idea is that the number of parameters for rot, 2rot, 3rot, nrot is always 3, but the type of parameters for each of these words is different.

From this should be clear that nrot is very different from roll. See generalization or roll and pick in my other comment.

---

Maybe the question could be "why would one use such a word" rather than "how should it be named".

The words nswap and nroll (in the version described above) are not needed in practice.

The words ndrop, n>r, nr>, pick, roll are used in practice.
The reasons are as follows.

1. Some system-defined data types have unknown size.
2. In meta-programming you have to deal with these data types
   • for example, see rec:
3. In combinators and higher-order functions, it sometimes happens that the number of parameters is statically unknown.
   • for example, see apply-recognizer-filter
4. In some rare cases it is far simpler to use pick or roll than the return stack or variables for temporary moving parameters.
   • for example, see the definitions for equals