Text statistics

use text_stats.qweruse text_stats, text_word_count from text_stats      // Quillo 0.6: only these

// An editor's sidebar: a draft's length, reading time and how easy it is to read.////   quillo run text_stats.qwe      then open http://localhost:8080/draftuse "text_stats.qwer"let easy = "The cat sat on the mat. It was a sunny day. The cat was happy."let hard = "Notwithstanding the aforementioned considerations, the committee's deliberations necessitated comprehensive reevaluation of institutional responsibilities."route GET /draft = { easy: text_stats(easy)?, hard: text_stats(hard)?, label: text_reading_time(easy) }route POST /stats = text_stats(request.body)?route GET /syllables ? { word: str } = { word, syllables: text_syllables(word) }

//! Counts of a text for writers and editors: words, sentences, syllables, reading time, and how easy it is to read (Flesch reading ease and grade level).//! version: 1.0.0//!//! [dependencies]use serde_json::{json, Value};/// Syllables in an English word, by its vowel groups: close for most words, never 0.fn syllables(word: &str) -> usize {    let w: Vec<char> = word.to_lowercase().chars().filter(|c| c.is_alphabetic()).collect();    if w.is_empty() {        return 0;    }    if w.len() <= 3 {        return 1;    }    let vowel = |c: char| "aeiouy".contains(c);    let mut n = 0;    let mut prev = false;    for &c in &w {        let v = vowel(c);        if v && !prev {            n += 1;        }        prev = v;    }    let s: String = w.iter().collect();    // A silent e at the end ("make"), but not "-le" after a consonant ("table").    if s.ends_with('e') && !s.ends_with("le") && !s.ends_with("ee") && n > 1 {        n -= 1;    }    if (s.ends_with("ed") && !s.ends_with("ted") && !s.ends_with("ded")) && n > 1 {        n -= 1;    }    n.max(1)}fn words(text: &str) -> Vec<&str> {    text.split(|c: char| c.is_whitespace() || "—–/".contains(c))        .map(|w| w.trim_matches(|c: char| !c.is_alphanumeric()))        .filter(|w| !w.is_empty())        .collect()}fn sentences(text: &str) -> usize {    let mut n = 0;    let mut in_sentence = false;    for c in text.chars() {        if ".!?…".contains(c) || c == '\n' {            if in_sentence {                n += 1;            }            in_sentence = false;        } else if c.is_alphanumeric() {            in_sentence = true;        }    }    n + in_sentence as usize}fn round(x: f64, places: i32) -> f64 {    let p = 10f64.powi(places);    (x * p).round() / p}/// The counts of `text`: `{ characters, letters, words, sentences, paragraphs, syllables, reading_seconds, speaking_seconds, flesch_ease, grade_level, avg_words_per_sentence }`. Reading is at 238 words a minute, speaking at 150. `flesch_ease` runs from about 0 (hard: law) to 100 (easy: comics), 60 to 70 being plain English; `grade_level` is the Flesch-Kincaid US school grade. Syllables are counted for English. Up to 5 MB.pub fn text_stats(text: &str) -> Result<Value, String> {    if text.len() > 5_000_000 {        return Err("text up to 5 MB".into());    }    let ws = words(text);    let w = ws.len();    let s = sentences(text).max(if w > 0 { 1 } else { 0 });    let syl: usize = ws.iter().map(|x| syllables(x)).sum();    let paragraphs = text.split("\n\n").filter(|p| !p.trim().is_empty()).count();    let (ease, grade) = if w == 0 {        (0.0, 0.0)    } else {        let wps = w as f64 / s as f64;        let spw = syl as f64 / w as f64;        (206.835 - 1.015 * wps - 84.6 * spw, 0.39 * wps + 11.8 * spw - 15.59)    };    Ok(json!({        "characters": text.chars().count(),        "letters": text.chars().filter(|c| c.is_alphanumeric()).count(),        "words": w,        "sentences": s,        "paragraphs": paragraphs,        "syllables": syl,        "reading_seconds": ((w as f64) * 60.0 / 238.0).ceil() as i64,        "speaking_seconds": ((w as f64) * 60.0 / 150.0).ceil() as i64,        "flesch_ease": round(ease, 1),        "grade_level": round(grade.max(0.0), 1),        "avg_words_per_sentence": if s == 0 { 0.0 } else { round(w as f64 / s as f64, 1) },    }))}/// How many words `text` has, as a word processor counts them.pub fn text_word_count(text: &str) -> i64 {    words(text).len() as i64}/// "4 min read" for `text`, at 238 words a minute; at least "1 min read".pub fn text_reading_time(text: &str) -> String {    let m = ((words(text).len() as f64) / 238.0).ceil().max(1.0) as i64;    format!("{} min read", m)}/// The syllables of one English word, estimated from its vowels: "readability" is 5.pub fn text_syllables(word: &str) -> i64 {    syllables(word) as i64}