Replace substring in character/string_type

[ivan-pi]

I also propose to add a few other functions that can be commonly used.

• Replace function, this can be implemented in several ways:

  • First implementation: string.replace(pos , len, new_string)
    • pos = starting position of the sub-string to be replaced.
    • len = length of the substring
    • new_string = the string that will replace the substring
  • Second implementation: string.replace(pos, old_string, new_string)
    • old_string = substring to be replaced.
    • pos = position to start the search of old_string
    • new_string = string that will replace old_substring
    • This function will replace only the first occurrence of the old_string.
  • Third implementation: string.replaceall(pos, old_string, new_string)
    • This meaning of variables is similar to the second implementation.
    • The difference is it will find and replace all the occurrences of old_string after pos and not just one.

• We already have an operator to Concat a string with another but I feel we should also implement a function for the same.

The community can have a discussion over the need for such functions and if needed also suggest some other implementation of Replace function.

Originally posted by @ChetanKarwa in #364 (comment)

[ivan-pi]

This has also been requested a few times before.

@zbeekman wrote in #69 (comment):

sub: from Ruby, replaces the first occurance of a substring with a substitution, optional argument to replace the last string
gsub: Replaces all occurrences with a substring

@jacobwilliams suggested it also in j3-fortran/fortran_proposals#96 (comment):

Back to original topic. Here's one I use all the time:

1. `string_replace`

2. Replace all occurrences of one string with another

3. Yes, Python has this:

>>> 'aaaa'.replace('a','bb')
'bbbbbbbb'

1. Something along these lines:

character(len=:),allocatable :: str
str = 'aaaa'
call string_replace(str,'a','bb')
write(*,*) str ! writes bbbbbbbb

[awvwgk]

There is also a proposal from the string thread:

Gsub

• Global substitution. Same as @jacobwilliams' string_replace as far as I can tell. Eventually it would be nice to support regular expressions like Ruby, but, for now, we should start smaller and just make it behave like:
  sed 's/<pattern>/<replacement>/g'
• Kinda Ruby, Python and sed. Behave like Python without the optional count argument
• Fortran:

gsub("hello", "l", "L") ! "heLLo"
gsub("the quick brown fox jumped over the lazy dog", "the", "a")
    ! "a quick brown fox jumped over a lazy dog"
!! Or OO approach
s = "hello"
s%sub("l","L")              ! "heLLo"

Sub

• Replace first (or last) instance of one substring with another
• Again, similarities with Python and Ruby, but not an exact match
• Fortran:

sub("hello", "l", "L") ! "heLlo"
sub("hello", "l", "L", back=.true.) ! "helLo"
sub("the quick brown fox jumped over the lazy dog", "the", "a")
    ! "a quick brown fox jumped over the lazy dog"
sub("the quick brown fox jumped over the lazy dog", "the", "a", back=.true.)
    ! "the quick brown fox jumped over a lazy dog"
!! Or OO approach
s = "hello"
s%sub("l","L")              ! "heLlo"
s%sub("l","L", back=.true.) ! "helLo"

Originally proposed by @zbeekman in #69 (comment)

[awvwgk]

We have to be a bit careful with the string related patches, because there are only a few modules and many independent features. This will likely result in many conflicting patches and will require a lot of rebasing along the way. The module to put those functions in would be stdlib_strings, which is not yet created on the default branch.

[aman-godara]

• Third implementation: string.replaceall(pos, old_string, new_string)

  • This meaning of variables is similar to the second implementation.
  • The difference is it will find and replace all the occurrences of old_string after pos and not just one.

What would we expect the function to return if the input is "qwqwqw" and we want to replace all "qwq" with let's say "abc"?
Option 1: "abcwqw"
Option 2: "abcabcw" (here length of the output is greater than the length of the input)
[EDIT]: Option 3: abcw

Option 2 is inspired from the fact that the second q is part of two occurrences of qwq. I cannot think of a particular use case where a user might want option 2 to be the output but it occurred to me so I thought it would be better to put it on the table.

[urbanjost]

features I would like would be to

• specify the Nth occurrence starting from the left or right end of the string,
• ignore case in the old string when doing a match,
• and to be a subroutine for efficiency but a function for convenience.
  For example:
  replace. Starting at the other end should probably be implemented as with INDEX() and so on. That particular routine has had feature creep over the years and could be written to be more efficient but has the basic functionality I have found useful.

[ivan-pi]

• Python

  • replace()

  str.replace(old, new[, count])
  Return a copy of the string with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced.

• Javascript

  • .replace()

  const newStr = str.replace(regexp|substr, newSubstr|function)
  The replace() method returns a new string with some or all matches of a pattern replaced by a replacement. The pattern can be a string or a RegExp, and the replacement can be a string or a function to be called for each match. If pattern is a string, only the first occurrence will be replaced.

  The original string is left unchanged.

  • .replaceAll()

  const newStr = str.replaceAll(regexp|substr, newSubstr|function)
  The replaceAll() method returns a new string with all matches of a pattern replaced by a replacement. The pattern can be a string or a RegExp, and the replacement can be a string or a function to be called for each match.

  The original string is left unchanged.

• Julia

  • Base.replace — Method

  replace(s::AbstractString, pat=>r; [count::Integer])
  Search for the given pattern pat in s, and replace each occurrence with r. If count is provided, replace at most count occurrences. pat may be a single character, a vector or a set of characters, a string, or a regular expression. If r is a function, each occurrence is replaced with r(s) where s is the matched substring (when pat is a AbstractPattern or AbstractString) or character (when pat is an AbstractChar or a collection of AbstractChar). If pat is a regular expression and r is a SubstitutionString, then capture group references in r are replaced with the corresponding matched text. To remove instances of pat from string, set r to the empty String ("").

• Perl

  • substr EXPR,OFFSET,LENGTH,REPLACEMENT

  The Perl substring is interesting in that it can be used both on the right or left side of an assignment. So you can use it to return a new string (substr on the right side), or replace a substring in place (substr on the left side). In Fortran this would require a function and subroutine, as suggested by @urbanjost.

I also support the options suggested by @urbanjost:

• count or repeat (replace only first count appearances)
• ignore_case
• occurence (if present, start changing at the Nth occurrence of the OLD string)

but I would prefer to split them into two functions.

[ChetanKarwa]

Function introduced by @urbanjost can work as an all in one pack for any kind of "replace" operation that a user wants to execute.
I support such an all in one function.

But I have a doubt, in deciding the Nth occurrence.
For eg: if the parent string is "abababababa" and the old string is "aba"

• What will be the 3rd occurrence of old in this parent
  • abab aba baba
  • abababab aba

[ivan-pi]

What will be the 3rd occurrence of old in this parent

• abab aba baba
• abababab aba

Python uses a non-overlapping count:

>>> "abababababa".replace("aba","zzz")
'zzzbzzzbzzz'
>>> "abababababa".replace("aba","zzz",1)
'zzzbabababa'
>>> "abababababa".replace("aba","zzz",2)
'zzzbzzzbaba'

which corresponds to your second bullet point.

Edit: The StringiFor library also provides a replace method matching the Python one.

[ChetanKarwa]

If everyone is fine with the idea.
I wish to start working on this issue. I can start off by implementing the function proposed by @urbanjost.

[awvwgk]

Feel free to start working on a patch, @ChetanKarwa . You can either start from the default branch and we will figure out rebasing the patch later, or you could base your feature branch on the patch in #343, which already creates the stdlib_strings module.

Let me know if you need any help with this.

[ChetanKarwa]

I wanted to ask these questions:

• Shall I implement the KMP algorithm that searches in O(N) time and O(N) space complexity or a Naive algorithm that takes O(N^2) time complexity and no extra space.
• Do we need the argument 'cmd' as given in the post by @urbanjost or just keeping old and new is fine enough.
• How should the function be accessed.
  • replace(parent_str, old_str, new_str)
  • parent_str.replace(old_str,new_str)

[ivan-pi]

• Do we need the argument 'cmd' as given in the post by @urbanjost or just keeping old and new is fine enough.

I suggest you omit cmd for now.

How should the function be accessed.

• replace(parent_str, old_str, new_str)
• parent_str.replace(old_str,new_str)

The first one. (For the second version you would need first a string class (#333) which is not available yet. Moreover, the second version would likely just call the first version.) More importantly I think replace will be a function and not a subroutine.

If KMP is not too challenging I think that would be a great start. I guess in practice there will be some trade-offs (e.g. depending on the string sizes, cache size, etc.).