No accounting for taste -- truer words never spoken. :)

---

Abandon all hope, ye who read further.

I try not to worry too much about making things tacit. But there's a neat trick you can play in J to find a tacit definition for a non-tacit expression (if one can be found). I don't know if there is a counterpart in any common APL distributions.

First you define an expression in terms of values named 'x' and 'y'. Your goal is to find a tacit verb -- let's say 'T' -- that you can call as 'x T y'. (X is always on the left and y is always on the right, by convention -- compare with ⍺ and ⍵, sort of.) There is a J operation, cryptically named '13 :', which will try to make such an expresssion tacit.

Here's a quick attempt at writing 'N M drop Y', which will return Y but with the N:M section deleted. Again there might be off-by ones here (you could use Increment/Decrement to fix that):

Define some 'x' and 'y' values for experimenting:

    x =: 5 10     NB. these will be our N:M indexes
    y =: 'abcdefghijklmnopqrstuv'

Here are examples of Take and Drop (these are just to help you translate between APL and J):

       5 {. y
    abcde
       10 }. y
    klmnopqrstuv

Monadically the same verbs mean First and Last:

       {. x
    5
       }. x
    10

With M and N defined as the first ({.) and last (}.) values of X, take M from Y, and join (,) it up with the result of dropping N from Y:

       (({. x) {. y ) , (}. x) }. y
    abcdeklmnopqrstuv

Close enough! Now here's where we invoke the 'make tacit' verb, '13 :'. We have to wrap the original x/y expression in quotes, to make it a string, and then call it like this:

       13 : '(({. x) {. y ) , (}. x) }. y'
    (] {.~ [: {. [) , ] }.~ [: }. [

There's the magic. The tilde (~) is like ⍨ in APL, and the bare [ and ] represent 'take left value' and 'take right value'. The [: word is called a 'cap' and is used to limit the left side of a verb fork. (Sorry, I don't know the equivalent in APL.)

And that's our tacit version. We can try it out, give it a name, and try it out again:

       x ( (] {.~ [: {. [) , ] }.~ [: }. [ ) y
    abcdeklmnopqrstuv
       drop =: (] {.~ [: {. [) , ] }.~ [: }. [
       x drop y
    abcdeklmnopqrstuv
       5 10 drop 'abcdefghijklmnopqrstuv'
    abcdeklmnopqrstuv
 

If you've truly abandoned all hope, the J vocabulary is listed here: https://code.jsoftware.com/wiki/NuVoc