Chop optional number of characters

[bramtayl]

Not urgent, just a handy feature

[tkelman]

signature needs to be updated in the rst, then run make docs to populate the docstring content and commit that too

also i should have single backticks around it in the text of the docstring below

[omus]

Since i tends to refer to an index maybe n or len would be a better choice for the variable name?

[bramtayl]

I can change if you really want but I like the consistency of using s for string and i for integer.

[bramtayl]

P.S. with all these non traditional indexing changes, does it still make sense to annotate i as a integer?

[ararslan]

I agree that i should be changed, but len sounds like it would be the desired length of the resulting string rather than the length of the section to remove. I think n would be the more natural choice.

[bramtayl]

This is going to sound stupid, but how do I run make docs?

[tkelman]

if you don't have a source build, you can just make the change below. though rst has different formatting than markdown so the i will need double backticks in the rst file

[bramtayl]

Ok, I think I did it?

[omus]

Should probably be Integer rather than Int

[omus]

I'm curious: what is your use case for this? I feel like you may want to be using rstrip

I believe Perl is the origin of the chop function (Julia / Perl) which has the sister function chomp(Julia / Perl). Both of these functions both deal with removing a single character from the end of a string. I feel that this change isn't necessary and there already exist better functions to deal with removing multiple trailing characters.

[bramtayl]

I've included my current code below.

chopn(s, n) = s[1:(end - n)]

function remove_suffix(f, suffix)
  f_string = string(f)
  if !(endswith(f_string, suffix))
    error("f must end in $suffix")
  end
  symbol(chopn(f_string, length(suffix)))
end

nonstandard_1(f) =
  quote
    macro $f(args...)
      esc($f(args...) )
    end
  end

function multiblock(f)
  f_chop = remove_suffix(f, "_1")
  quote
    function $f_chop(fs...)
      Expr(:block, map($f, fs)...)
    end
  end
end

function safe_1(f)
  f_chop = remove_suffix(f, "!")
  quote
    $f_chop(x, args...; kwargs...) =
      $f(copy(x), args...; kwargs...)
  end
end

copykw(kw) = (kw[1], copy(kw[2]) )

function allsafe_1(f)
  f_chop = remove_suffix(f, "!")
  quote
     $f_chop(args...; kwargs...) =
       $f(map(copy, args)...;
          map(copykw, kwargs)...)
  end
end

eval(nonstandard_1(:nonstandard_1))
@nonstandard_1 multiblock
@multiblock nonstandard_1 safe_1 allsafe_1
@nonstandard_1 nonstandard
@nonstandard safe allsafe

[simonster]

This approach does not work for removing multiple Unicode characters:

julia> "🐵🐵🐵"[1:end-2]
"🐵🐵"

[bramtayl]

Is there a way to fix that? Maybe there should be a special unicode indexing function where "🐵🐵🐵"u[1:end-2] == "🐵"?

[vtjnash]

hm. it seems that existing function should have been defined as x[1:prevind(x, end)] (or equivalently endof(x) instead of end)

[simonster]

I think the existing function works because the endof the string is the start of the last character.

[bramtayl]

PS I'm sure someone has already thought about this but negative indexing of strings would be handy. Like s[1:-3] == chop(s, 2) where -3 means the third character from the end

[tkelman]

We wouldn't do negative indexing for strings and nowhere else. We're unlikely to do negative indexing for general arrays, at least not without custom range types that could be defined in packages.

[bramtayl]

Ok, I've thought a bit more about unicode subsetting, and I don't see how what julia has makes sense. Who would want to subset part of a character? I think if you really wanted to do that, one syntax could be "🐵🐵🐵"[3][1] to return the first part of the third monkey (presumably some animal pictograph marker?)

[stevengj]

String indices are a partial function, for performance reasons; see that section of the manual. That is, the user is responsible for ensuring that only valid indices are passed. One option we've discussed is that a special StringIndex type could be used for indexing, rather than an integer (although it would just be an opaque wrapper around an integer, or similar), to prevent the user from naively plugging in arbitrary numbers or doing index + 1 instead of nextindex etcetera (#9297).

[stevengj]

But for now, you need to call nextind and prevind rather than + 1 and - 1 on string indices.

[stevengj]

I agree with @omus, however, that we should have a clear use case for this function. Do Python or Perl or Ruby have such a function? If not, why should we?

[bramtayl]

Thanks for the explanation about the partial indexing. I added a unicode warning to the chop documentation, which seems like best I can do efficiently? I'm not too invested in this PR, and I don't have a use-case outside of the one above.

[stevengj]

@bramtayl, if we decide we want that functionality, giving a warning like that is not acceptable. A correct implementation would be something like:

function chop(s::String, len::Integer=1)
   len < 0 && throw(BoundsError())
   i = endof(s)
   while len > 0 && i > 0
       i = prevind(s, i)
       len -= 1
   end
   return s[1:i]
end

This will chop up to len Unicode characters off the end of s.

[bramtayl]

Ok, I put in @stevengj 's code and used @ararslan 's suggestion of n as an argument name

[kshyatt]

Hi @bramtayl, looks like this needs a rebase. Are you still interested in working on this feature?

[bramtayl]

No, I guess not? I think this feature won't really be useful until string subsetting and unicode characters start getting along better?

[StefanKarpinski]

Why not? With the fixes to work correctly with Unicode, this functionality is totally workable.

[bramtayl]

Ok! Well I guess I'm not sure what the next steps are?