feat(stdlib): pub-mark sweep — io/math/option/result/testing (closes #508)

PR #505 closed the pub-visibility gap in stdlib/string.affine and
stdlib/collections.affine. This PR completes the sweep for the
remaining 5 modules listed in #508.

Mechanical rule (per #508 scope):
  Any `fn` immediately preceded by a `///` doc comment (allowing
  intervening contiguous `//` lines / attributes) is pub-intent and
  gets the `pub` keyword.

| Module     | pub before | pub after | now-private |
|------------|-----------:|----------:|------------:|
| io         |  0         |  15       | 0           |
| math       |  0         |  36       | 0           |
| option     |  1         |  36       | 0           |
| result     |  0         |  24       | 0           |
| testing    |  0         |  26       | 0           |

Total: 136 fns now reachable from consumers (was 1 of 137).

Verification
  dune build bin/main.exe — clean
  dune runtest             — 368/368 PASS

Estate impact (verified by running main.exe check against the idaptik
migration/ corpus before and after this change):

  before: 68 / 86 PASS, 18 FAIL (4 parse, 14 type)
  after:  same numerically — the 14 `undefined value: \`min_float\`/\`max_float\``
          failures now flip from "stdlib symbol unreachable" to "caller
          missing \`use math::{min_float, max_float};\`", which is the
          correct consumer-side closure. Companion idaptik PR adds those.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Signed-off-by: hyperpolymath <6759885+hyperpolymath@users.noreply.github.com>

Author: hyperpolymath

stdlib/io.affine

@@ -37,7 +37,7 @@ use string::{ split, join };
 ///
 /// Example:
 ///   printf("Hello, {}! You are {} years old.", ["Alice", 30])
-fn printf(format: String, args: [Any]) -> () {
+pub fn printf(format: String, args: [Any]) -> () {
   let flen = len(format);
   let mut arg_idx = 0;
   let mut i = 0;
@@ -59,23 +59,23 @@ fn printf(format: String, args: [Any]) -> () {
 }
 
 /// Print formatted string with trailing newline
-fn println_fmt(format: String, args: [Any]) -> () {
+pub fn println_fmt(format: String, args: [Any]) -> () {
   printf(format, args);
   println("");
 }
 
 /// Print debug representation of any value
-fn debug<T>(value: T) -> () {
+pub fn debug<T>(value: T) -> () {
   eprintln("DEBUG: " ++ show(value));
 }
 
 /// Print error with newline to stderr (convenience wrapper)
-fn error(msg: String) -> () {
+pub fn error(msg: String) -> () {
   eprintln("[ERROR] " ++ msg);
 }
 
 /// Print warning with newline to stderr
-fn warn(msg: String) -> () {
+pub fn warn(msg: String) -> () {
   eprintln("[WARN] " ++ msg);
 }
 
@@ -86,7 +86,7 @@ fn warn(msg: String) -> () {
 // read_file, write_file, append_file, file_exists are builtins — see module header
 
 /// Read file as a list of lines
-fn read_lines(path: String) -> Result<[String], String> {
+pub fn read_lines(path: String) -> Result<[String], String> {
   match read_file(path) {
     Ok(content) => Ok(split(content, "\n")),
     Err(msg) => Err(msg)
@@ -97,7 +97,7 @@ fn read_lines(path: String) -> Result<[String], String> {
 ///
 /// Note: this reads the entire file; a more efficient builtin would be
 /// preferable for large files once the runtime supports stat().
-fn file_size(path: String) -> Result<Int, String> {
+pub fn file_size(path: String) -> Result<Int, String> {
   match read_file(path) {
     Ok(content) => Ok(len(content)),
     Err(msg) => Err(msg)
@@ -124,7 +124,7 @@ extern fn remove_dir(path: String) -> Result<(), String>;
 // ============================================================================
 
 /// Join path components with the system separator (/)
-fn path_join(components: [String]) -> String {
+pub fn path_join(components: [String]) -> String {
   let mut result = "";
   let mut first = true;
   for component in components {
@@ -142,7 +142,7 @@ fn path_join(components: [String]) -> String {
 ///
 /// Returns None if no extension is found.
 /// Example: path_extension("file.txt") => Some("txt")
-fn path_extension(path: String) -> Option<String> {
+pub fn path_extension(path: String) -> Option<String> {
   let plen = len(path);
   let mut i = plen - 1;
   while i >= 0 {
@@ -166,7 +166,7 @@ fn path_extension(path: String) -> Option<String> {
 /// Get the filename component from a path
 ///
 /// Example: path_filename("/home/user/file.txt") => "file.txt"
-fn path_filename(path: String) -> String {
+pub fn path_filename(path: String) -> String {
   let plen = len(path);
   if plen == 0 {
     return "";
@@ -185,7 +185,7 @@ fn path_filename(path: String) -> String {
 /// Get the directory component from a path
 ///
 /// Example: path_dirname("/home/user/file.txt") => "/home/user"
-fn path_dirname(path: String) -> String {
+pub fn path_dirname(path: String) -> String {
   let plen = len(path);
   if plen == 0 {
     return ".";
@@ -207,7 +207,7 @@ fn path_dirname(path: String) -> String {
 /// Get the filename without its extension (stem)
 ///
 /// Example: path_stem("archive.tar.gz") => "archive.tar"
-fn path_stem(path: String) -> String {
+pub fn path_stem(path: String) -> String {
   let filename = path_filename(path);
   let flen = len(filename);
   let mut i = flen - 1;
@@ -239,7 +239,7 @@ extern fn chdir(path: String) -> Result<(), String>;
 // read_line is a builtin — see module header
 
 /// Read all input from stdin until EOF
-fn read_stdin() -> Result<String, String> {
+pub fn read_stdin() -> Result<String, String> {
   let mut parts = [];
   let mut done = false;
   while !done {
@@ -256,7 +256,7 @@ fn read_stdin() -> Result<String, String> {
 }
 
 /// Prompt user for input and return their response
-fn prompt(message: String) -> Result<String, String> {
+pub fn prompt(message: String) -> Result<String, String> {
   print(message);
   read_line()
 }
@@ -268,7 +268,7 @@ fn prompt(message: String) -> Result<String, String> {
 // time_now is a builtin — see module header
 
 /// Measure the wall-clock time of a function call (in seconds)
-fn timed<T>(f: () -> T) -> (T, Float) {
+pub fn timed<T>(f: () -> T) -> (T, Float) {
   let start = time_now();
   let result = f();
   let elapsed = time_now() - start;

stdlib/math.affine

@@ -47,22 +47,22 @@ const NEG_INFINITY: Float = -1.0 / 0.0;
 // ============================================================================
 
 /// Absolute value of an integer
-fn abs(x: Int) -> Int {
+pub fn abs(x: Int) -> Int {
   if x < 0 { -x } else { x }
 }
 
 /// Absolute value of a float
-fn abs_float(x: Float) -> Float {
+pub fn abs_float(x: Float) -> Float {
   if x < 0.0 { -x } else { x }
 }
 
 /// Sign of an integer: -1, 0, or 1
-fn sign(x: Int) -> Int {
+pub fn sign(x: Int) -> Int {
   if x > 0 { 1 } else if x < 0 { -1 } else { 0 }
 }
 
 /// Sign of a float: -1, 0, or 1
-fn sign_float(x: Float) -> Int {
+pub fn sign_float(x: Float) -> Int {
   if x > 0.0 { 1 } else if x < 0.0 { -1 } else { 0 }
 }
 
@@ -71,7 +71,7 @@ fn sign_float(x: Float) -> Int {
 // ============================================================================
 
 /// Integer exponentiation via repeated squaring
-fn pow(base: Int, exp: Int) -> Int {
+pub fn pow(base: Int, exp: Int) -> Int {
   if exp == 0 {
     return 1;
   }
@@ -87,12 +87,12 @@ fn pow(base: Int, exp: Int) -> Int {
 }
 
 /// Square of an integer
-fn square(x: Int) -> Int {
+pub fn square(x: Int) -> Int {
   x * x
 }
 
 /// Cube of an integer
-fn cube(x: Int) -> Int {
+pub fn cube(x: Int) -> Int {
   x * x * x
 }
 
@@ -105,12 +105,12 @@ fn cube(x: Int) -> Int {
 // floor, ceil, round, trunc are builtins — see module header
 
 /// Convert an integer to a float
-fn to_float(n: Int) -> Float {
+pub fn to_float(n: Int) -> Float {
   float(n)
 }
 
 /// Fractional part of a float (x - trunc(x))
-fn fract(x: Float) -> Float {
+pub fn fract(x: Float) -> Float {
   x - to_float(trunc(x))
 }
 
@@ -121,27 +121,27 @@ fn fract(x: Float) -> Float {
 // sin, cos, tan, asin, acos, atan, atan2 are builtins — see module header
 
 /// Convert degrees to radians
-fn deg_to_rad(degrees: Float) -> Float {
+pub fn deg_to_rad(degrees: Float) -> Float {
   degrees * PI / 180.0
 }
 
 /// Convert radians to degrees
-fn rad_to_deg(radians: Float) -> Float {
+pub fn rad_to_deg(radians: Float) -> Float {
   radians * 180.0 / PI
 }
 
 /// Hyperbolic sine
-fn sinh(x: Float) -> Float {
+pub fn sinh(x: Float) -> Float {
   (exp(x) - exp(-x)) / 2.0
 }
 
 /// Hyperbolic cosine
-fn cosh(x: Float) -> Float {
+pub fn cosh(x: Float) -> Float {
   (exp(x) + exp(-x)) / 2.0
 }
 
 /// Hyperbolic tangent
-fn tanh(x: Float) -> Float {
+pub fn tanh(x: Float) -> Float {
   sinh(x) / cosh(x)
 }
 
@@ -152,7 +152,7 @@ fn tanh(x: Float) -> Float {
 // exp, log, log10, log2 are builtins — see module header
 
 /// Logarithm with arbitrary base
-fn log_base(base: Float, x: Float) -> Float {
+pub fn log_base(base: Float, x: Float) -> Float {
   log(x) / log(base)
 }
 
@@ -161,27 +161,27 @@ fn log_base(base: Float, x: Float) -> Float {
 // ============================================================================
 
 /// Minimum of two integers
-fn min_int(a: Int, b: Int) -> Int {
+pub fn min_int(a: Int, b: Int) -> Int {
   if a < b { a } else { b }
 }
 
 /// Maximum of two integers
-fn max_int(a: Int, b: Int) -> Int {
+pub fn max_int(a: Int, b: Int) -> Int {
   if a > b { a } else { b }
 }
 
 /// Minimum of two floats
-fn min_float(a: Float, b: Float) -> Float {
+pub fn min_float(a: Float, b: Float) -> Float {
   if a < b { a } else { b }
 }
 
 /// Maximum of two floats
-fn max_float(a: Float, b: Float) -> Float {
+pub fn max_float(a: Float, b: Float) -> Float {
   if a > b { a } else { b }
 }
 
 /// Clamp an integer between min_val and max_val (inclusive)
-fn clamp_int(value: Int, min_val: Int, max_val: Int) -> Int {
+pub fn clamp_int(value: Int, min_val: Int, max_val: Int) -> Int {
   if value < min_val {
     min_val
   } else if value > max_val {
@@ -192,7 +192,7 @@ fn clamp_int(value: Int, min_val: Int, max_val: Int) -> Int {
 }
 
 /// Clamp a float between min_val and max_val (inclusive)
-fn clamp_float(value: Float, min_val: Float, max_val: Float) -> Float {
+pub fn clamp_float(value: Float, min_val: Float, max_val: Float) -> Float {
   if value < min_val {
     min_val
   } else if value > max_val {
@@ -203,7 +203,7 @@ fn clamp_float(value: Float, min_val: Float, max_val: Float) -> Float {
 }
 
 /// Linear interpolation between a and b by factor t (0.0 to 1.0)
-fn lerp(a: Float, b: Float, t: Float) -> Float {
+pub fn lerp(a: Float, b: Float, t: Float) -> Float {
   a + (b - a) * t
 }
 
@@ -212,7 +212,7 @@ fn lerp(a: Float, b: Float, t: Float) -> Float {
 // ============================================================================
 
 /// Greatest common divisor via Euclid's algorithm
-fn gcd(a: Int, b: Int) -> Int {
+pub fn gcd(a: Int, b: Int) -> Int {
   let mut x = abs(a);
   let mut y = abs(b);
 
@@ -226,25 +226,25 @@ fn gcd(a: Int, b: Int) -> Int {
 }
 
 /// Least common multiple
-fn lcm(a: Int, b: Int) -> Int {
+pub fn lcm(a: Int, b: Int) -> Int {
   if a == 0 || b == 0 {
     return 0;
   }
   abs(a * b) / gcd(a, b)
 }
 
 /// Check if n is even
-fn is_even(n: Int) -> Bool {
+pub fn is_even(n: Int) -> Bool {
   n % 2 == 0
 }
 
 /// Check if n is odd
-fn is_odd(n: Int) -> Bool {
+pub fn is_odd(n: Int) -> Bool {
   n % 2 != 0
 }
 
 /// Check if n is a prime number (trial division)
-fn is_prime(n: Int) -> Bool {
+pub fn is_prime(n: Int) -> Bool {
   if n < 2 {
     return false;
   }
@@ -265,7 +265,7 @@ fn is_prime(n: Int) -> Bool {
 }
 
 /// Integer division rounding towards negative infinity (floor division)
-fn div_floor(a: Int, b: Int) -> Int {
+pub fn div_floor(a: Int, b: Int) -> Int {
   let q = a / b;
   if (a % b != 0) && ((a < 0) != (b < 0)) {
     q - 1
@@ -275,7 +275,7 @@ fn div_floor(a: Int, b: Int) -> Int {
 }
 
 /// Modulo that always returns a non-negative result
-fn mod_positive(a: Int, b: Int) -> Int {
+pub fn mod_positive(a: Int, b: Int) -> Int {
   let r = a % b;
   if r < 0 {
     r + abs(b)
@@ -289,7 +289,7 @@ fn mod_positive(a: Int, b: Int) -> Int {
 // ============================================================================
 
 /// Factorial of n (n!)
-fn factorial(n: Int) -> Int {
+pub fn factorial(n: Int) -> Int {
   if n <= 1 {
     1
   } else {
@@ -298,7 +298,7 @@ fn factorial(n: Int) -> Int {
 }
 
 /// n-th Fibonacci number (iterative)
-fn fibonacci(n: Int) -> Int {
+pub fn fibonacci(n: Int) -> Int {
   if n <= 1 {
     n
   } else {
@@ -316,17 +316,17 @@ fn fibonacci(n: Int) -> Int {
 }
 
 /// Sum of first n natural numbers: 1 + 2 + ... + n
-fn sum_naturals(n: Int) -> Int {
+pub fn sum_naturals(n: Int) -> Int {
   n * (n + 1) / 2
 }
 
 /// Sum of first n squares: 1^2 + 2^2 + ... + n^2
-fn sum_squares(n: Int) -> Int {
+pub fn sum_squares(n: Int) -> Int {
   n * (n + 1) * (2 * n + 1) / 6
 }
 
 /// Binomial coefficient C(n, k) = n! / (k! * (n-k)!)
-fn binomial(n: Int, k: Int) -> Int {
+pub fn binomial(n: Int, k: Int) -> Int {
   if k < 0 || k > n {
     return 0;
   }
@@ -346,7 +346,7 @@ fn binomial(n: Int, k: Int) -> Int {
 // ============================================================================
 
 /// Arithmetic mean of a list of floats
-fn mean(values: [Float]) -> Float {
+pub fn mean(values: [Float]) -> Float {
   let n = len(values);
   if n == 0 {
     return 0.0;
@@ -359,7 +359,7 @@ fn mean(values: [Float]) -> Float {
 }
 
 /// Sum of a list of floats
-fn sum_float(values: [Float]) -> Float {
+pub fn sum_float(values: [Float]) -> Float {
   let mut tot = 0.0;
   for v in values {
     tot = tot + v;