text.truncate

pub fn truncate(value: &str, max_length: i64, ellipsis: &str) -> String

fune!(text.truncate@^1);  // then call truncate(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

/// The Unicode White_Space property, spelled out so all three languages agree.
/// It happens to match `char::is_whitespace`, but JavaScript's \s and Python's
/// str.isspace draw the line differently, so the list is explicit everywhere.
fn is_whitespace(ch: char) -> bool {
    let cp = ch as u32;
    (0x09..=0x0d).contains(&cp)
        || cp == 0x20
        || cp == 0x85
        || cp == 0xa0
        || cp == 0x1680
        || (0x2000..=0x200a).contains(&cp)
        || cp == 0x2028
        || cp == 0x2029
        || cp == 0x202f
        || cp == 0x205f
        || cp == 0x3000
}

/// Punctuation that reads badly directly before an ellipsis.
fn is_trailing_punctuation(ch: char) -> bool {
    matches!(ch, ',' | ';' | ':' | '-' | '.')
}

/// Shorten `value` to at most `max_length` code points, ellipsis included,
/// cutting at a word boundary where there is one.
///
/// # Panics
/// Panics if `max_length` is negative or shorter than the ellipsis.
pub fn truncate(value: &str, max_length: i64, ellipsis: &str) -> String {
    if max_length < 0 {
        panic!("maxLength must be 0 or greater, received {}", max_length);
    }
    let chars: Vec<char> = value.chars().collect();
    let mark_len = ellipsis.chars().count() as i64;
    if mark_len > max_length {
        panic!(
            "maxLength must be at least the length of the ellipsis, received {}",
            max_length
        );
    }
    if chars.len() as i64 <= max_length {
        return value.to_string();
    }

    let budget = (max_length - mark_len) as usize;
    let mut end = budget;
    // A cut just before whitespace is already a clean boundary.
    if !is_whitespace(chars[budget]) {
        // No boundary to move back to (none, or only at position 0): one long
        // word is cut hard rather than reduced to a bare ellipsis.
        if let Some(last_space) = (0..budget).rev().find(|&i| is_whitespace(chars[i])) {
            if last_space > 0 {
                end = last_space;
            }
        }
    }

    while end > 0 && (is_whitespace(chars[end - 1]) || is_trailing_punctuation(chars[end - 1])) {
        end -= 1;
    }
    let mut out: String = chars[..end].iter().collect();
    out.push_str(ellipsis);
    out
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Str(truncate(args[0].as_str(), args[1].as_i64(), args[2].as_str()))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Rust package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add text.truncate

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./text.truncate-1.0.0-rust.fune, or fetch it from a terminal with fune pull text.truncate@1.0.0:rust.

The whole function, every language, is one file too: text.truncate-1.0.0.fune, 14,096 bytes, sha256 b7ad085ce8cf8efc872eace07a79adef908cc5061bb91d369cc64baf1819ae77. It installs into a project of any language.

// fune: before text.truncate

// fune: after text.truncate

// fune: step text.truncate after <n|label>

More from the author

1. If the text already fits in `maxLength`, it is returned unchanged, with no ellipsis. Nothing is trimmed or normalised. 2. Otherwise the text is cut to leave room for the ellipsis inside the limit: the result, ellipsis included, is never longer than `maxLength`. 3. If the cut lands exactly before whitespace, that is a clean word boundary and the cut stands. Otherwise it moves back to the last whitespace inside the kept part, so no word is split. 4. If there is no whitespace to move back to (one very long word, a URL, text in a script written without spaces), the word is cut hard at the limit. Splitting a word is better than returning nothing but an ellipsis. 5. Trailing whitespace and the trailing punctuation `, ; : - .` are removed from the cut before the ellipsis goes on, so "Hello, world" gives "Hello..." and not "Hello,...".

Whitespace is the Unicode White_Space set, spelled out character by character (tab, line feed, vertical tab, form feed, carriage return, space, U+0085, U+00A0, U+1680, U+2000-U+200A, U+2028, U+2029, U+202F, U+205F, U+3000) so all three languages agree; each language's built-in notion of "space" differs.

## Counting: code points, not graphemes

Length is counted in Unicode code points in all three languages. JavaScript's `.length` counts UTF-16 units, so a naive TypeScript version would count an emoji as two and disagree with Python; this one does not.

Code points are still not what a reader sees as one character. An accented letter written as a base letter plus a combining accent ("e" + U+0301) is two code points and a hard cut can separate them; a flag or a family emoji is several code points and can be cut in the middle. Getting that right needs the Unicode grapheme cluster rules (UAX #29), which none of the three standard libraries provides the same way, so this capability does not attempt it. If your text may contain such sequences, normalise it to NFC first (which fixes the accented letters) and leave some slack in `maxLength`.

## Errors

`maxLength` must be 0 or more, and at least the length of the ellipsis, since otherwise no truncated result can fit.

Files