el-retired/runtime/el/strings.el

// runtime/el/strings.el — the string family, redo in El.
// Replaces the C-builtin string family with El definitions.
// Redo discipline: these define the semantics; the C stubs behind the
// seam become trampolines, then nothing.

// concat lifting: the El-level join, no C library logic
fn el_join(parts: [String], sep: String) -> String {
    let n: Int = native_list_len(parts)
    let out: String = ""
    let i: Int = 0
    while i < n {
        let part: String = native_list_get(parts, i)
        let out = if i == 0 { part } else { str_concat(out, str_concat(sep, part)) }
        let i = i + 1
    }
    return out
}

// pascal-free, redone slice engine: charwise, pure El
fn el_reverse(s: String) -> String {
    let n: Int = str_len(s)
    let out: String = ""
    let i: Int = n - 1
    while i >= 0 {
        let out = str_concat(out, str_slice(s, i, i + 1))
        let i = i - 1
    }
    return out
}

// the family's centerpiece: redo of the builtin, expressed over El
fn el_ends_with(s: String, suf: String) -> Bool {
    let n: Int = str_len(s)
    let m: Int = str_len(suf)
    if m > n { return false }
    return str_eq(str_slice(s, n - m, n), suf)
}

// separator-aware split built on the above, pure El
fn el_split(s: String, sep: String) -> [String] {
    let res: [String] = native_list_empty()
    let n: Int = str_len(s)
    let m: Int = str_len(sep)
    let i: Int = 0
    let start: Int = 0
    while i <= n - m {
        if m == 0 {
            let acc: [String] = native_list_append(res, s)
            return acc
        }
        if str_eq(str_slice(s, i, i + m), sep) {
            let res = native_list_append(res, str_slice(s, start, i))
            let start = i + m
            let i = i + m
        } else {
            let i = i + 1
        }
    }
    let res = native_list_append(res, str_slice(s, start, n))
    return res
}

fn main() -> Void {
    println(el_join(["a", "b", "c"], "-"))
    println(el_reverse("hello"))
    println(el_ends_with("neuron", "ron"))
    let parts: [String] = el_split("a-b-c-d", "-")
    println(el_join(parts, ","))
}