Is there any workaround for `split`?

[i-am-the-slime]

Thanks for this nice library!

I'm using this library from another language that can compile to Golang. I've now finally hit the case where I use a library that needs split on regex. You mention in the README that this you're still working on this. Do you happen to have a draft or other unfinished code that can do some splitting (maybe slow, maybe wrong in edge cases)?

[dlclark]

I had written a split function (based on C#) for the code-gen version of the library. I suspect it'll work with the main version as well, but there are probably edge cases:

// Split splits the given input string using the pattern and returns
// a slice of the parts. Count limits the number of matches to process.
// If Count is -1, then it will process the input fully.
// If Count is 0, returns nil. If Count is 1, returns the original input.
// The only expected error is a Timeout, if it's set.
//
// If capturing parentheses are used in the Regex expression, any captured
// text is included in the resulting string array
// For example, a pattern of "-" Split("a-b") will return ["a", "b"]
// but a pattern with "(-)" Split ("a-b") will return ["a", "-", "b"]
func (re *Regexp) Split(input string, count int) ([]string, error) {
    if count < -1 {
        return nil, errors.New("count too small")
    }
    if count == 0 {
        return nil, nil
    }
    if count == 1 {
        return []string{input}, nil
    }
    if count == -1 {
        // no limit
        count = math.MaxInt64
    }

    // iterate through the matches
    priorIndex := 0
    var retVal []string
    var txt []rune

    m, err := re.FindStringMatch(input)

    for ; m != nil && count > 0; m, err = re.FindNextMatch(m) {
        txt = m.text
        // if we have an m, we don't have an err
        // append our match
        retVal = append(retVal, string(txt[priorIndex:m.Index]))
        // append any capture groups, skipping group 0
        gs := m.Groups()
        for i := 1; i < len(gs); i++ {
            retVal = append(retVal, gs[i].String())
        }
        priorIndex = m.Index + m.Length
        count--
    }

    if err != nil {
        return nil, err
    }

    if txt == nil {
        // we never matched, return the original string
        return []string{input}, nil
    }

    // append our remainder
    retVal = append(retVal, string(txt[priorIndex:]))

    return retVal, nil
}

It uses the m.txt private field, but I'm sure it could be written without it for your purposes. Let me know if you run into any issues. I could look at adding this to the main library version.

[dlclark]

@i-am-the-slime did this help?