fix(stdlib): builtins.map multi-iterable binding + add coverage for untested builtins (#292)

* test(stdlib): add coverage for untested builtins - abs, chr/ord, len, map, type conversions, isinstance, bytes

Adds 15 new [<Fact>] tests for builtins that were bound in Builtins.fs
but had no test coverage:
- abs (int and float)
- chr / ord (and round-trip)
- len (list and string)
- map (single and two-iterable overloads)
- str / int / float type conversions
- isinstance / type
- bytes (from byte array and from string with encoding)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* test(stdlib): fix len/map cases that hit binding limits

`len` on an F# `int list` fails because FSharpList has no `__len__`;
convert via `builtins.list` instead. Drop the two-iterable `map` case —
the binding's `'T1 * 'T2 -> 'T3` signature compiles to a tuple-input
function but Python's `map` calls `f(a, b)` positionally.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(stdlib): builtins.map multi-iterable overloads use System.Func

The 2- and 3-iterable overloads typed the function as `'T1 * 'T2 -> 'T3`
(tuple-input), which Fable compiles to a Python function expecting a
single tuple arg. But Python's `map(f, it1, it2)` calls `f(a, b)`
positionally, so calls failed with "takes 1 positional argument but 2
were given". Switching to `System.Func<...>` produces a Python function
with the correct positional arity. Restores the two-iterable test and
adds a three-iterable test.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Dag Brattli <dag@brattli.net>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: 4 people

src/stdlib/Builtins.fs

@@ -186,11 +186,12 @@ type IExports =
 
     /// Make an iterator that computes the function using arguments from each
     /// of the iterables.  Stops when the shortest iterable is exhausted.
-    abstract map: ('T1 * 'T2 -> 'T3) * IEnumerable<'T1> * IEnumerable<'T2> -> IEnumerable<'T3>
+    abstract map: System.Func<'T1, 'T2, 'T3> * IEnumerable<'T1> * IEnumerable<'T2> -> IEnumerable<'T3>
 
     /// Make an iterator that computes the function using arguments from each
     /// of the iterables.  Stops when the shortest iterable is exhausted.
-    abstract map: ('T1 * 'T2 * 'T3 -> 'T4) * IEnumerable<'T1> * IEnumerable<'T2> * IEnumerable<'T3> -> IEnumerable<'T4>
+    abstract map:
+        System.Func<'T1, 'T2, 'T3, 'T4> * IEnumerable<'T1> * IEnumerable<'T2> * IEnumerable<'T3> -> IEnumerable<'T4>
 
     /// Return the Unicode code point for a one-character string.
     abstract ord: char -> int

test/TestBuiltins.fs

@@ -120,3 +120,107 @@ let ``test pyNone is None`` () =
     builtins.bool pyNone |> equal false
     // None has type NoneType, so isinstance(None, type(None)) holds
     builtins.isinstance (pyNone, builtins.``type`` pyNone) |> equal true
+
+[<Fact>]
+let ``test abs with int works`` () =
+    builtins.abs -5 |> equal 5
+    builtins.abs 0 |> equal 0
+    builtins.abs 42 |> equal 42
+
+[<Fact>]
+let ``test abs with float works`` () =
+    builtins.abs -3.14 |> equal 3.14
+    builtins.abs 0.0 |> equal 0.0
+    builtins.abs 2.72 |> equal 2.72
+
+[<Fact>]
+let ``test chr and ord round-trip works`` () =
+    builtins.chr 65 |> equal 'A'
+    builtins.chr 97 |> equal 'a'
+    builtins.ord 'A' |> equal 65
+    builtins.ord 'a' |> equal 97
+
+[<Fact>]
+let ``test chr ord round-trip preserves value`` () =
+    let code = 9731 // snowman ☃
+    builtins.ord (builtins.chr code) |> equal code
+
+[<Fact>]
+let ``test len with list works`` () =
+    // F# `int list` compiles to FSharpList (no __len__); convert via builtins.list.
+    builtins.len (builtins.list (seq { 1..3 })) |> equal 3
+    builtins.len (builtins.list Seq.empty<int>) |> equal 0
+
+[<Fact>]
+let ``test len with string works`` () =
+    builtins.len ("hello" |> box) |> equal 5
+    builtins.len ("" |> box) |> equal 0
+
+[<Fact>]
+let ``test map with single iterable works`` () =
+    builtins.map ((fun x -> x * 2), [ 1; 2; 3 ])
+    |> Seq.toList
+    |> equal [ 2; 4; 6 ]
+
+[<Fact>]
+let ``test map with two iterables works`` () =
+    builtins.map ((fun a b -> a + b), [ 1; 2; 3 ], [ 10; 20; 30 ])
+    |> Seq.toList
+    |> equal [ 11; 22; 33 ]
+
+[<Fact>]
+let ``test map with three iterables works`` () =
+    builtins.map ((fun a b c -> a + b + c), [ 1; 2; 3 ], [ 10; 20; 30 ], [ 100; 200; 300 ])
+    |> Seq.toList
+    |> equal [ 111; 222; 333 ]
+
+[<Fact>]
+let ``test str conversion works`` () =
+    builtins.str 42 |> equal "42"
+    builtins.str true |> equal "True"
+
+[<Fact>]
+let ``test int conversion works`` () =
+    builtins.int "42" |> equal 42
+    builtins.int 3.9 |> equal 3
+    // Python's int() truncates toward zero, not floor
+    builtins.int -3.9 |> equal -3
+
+[<Fact>]
+let ``test float conversion works`` () =
+    builtins.float "3.14" |> equal 3.14
+    builtins.float 42 |> equal 42.0
+
+[<Fact>]
+let ``test isinstance works`` () =
+    let pyIntVal: obj = emitPyExpr () "42"
+    let pyStrVal: obj = emitPyExpr () "'hello'"
+    builtins.isinstance (pyStrVal, pyStr) |> equal true
+    builtins.isinstance (pyIntVal, pyInt) |> equal true
+
+[<Fact>]
+let ``test isinstance returns false for wrong type`` () =
+    let pyIntVal: obj = emitPyExpr () "42"
+    builtins.isinstance (pyIntVal, pyStr) |> equal false
+
+[<Fact>]
+let ``test type returns type object`` () =
+    let pyStrVal: obj = emitPyExpr () "'hello'"
+    let pyIntVal: obj = emitPyExpr () "42"
+    let t = builtins.``type`` pyStrVal
+    builtins.isinstance (pyStrVal, t) |> equal true
+    builtins.isinstance (pyIntVal, t) |> equal false
+
+[<Fact>]
+let ``test bytes from byte array works`` () =
+    let b = builtins.bytes [| 72uy; 101uy; 108uy; 108uy; 111uy |]
+    builtins.len b |> equal 5
+    b.[0] |> equal 72uy
+    b.[4] |> equal 111uy
+
+[<Fact>]
+let ``test bytes from string with encoding works`` () =
+    let b = builtins.bytes ("ABC", "utf-8")
+    builtins.len b |> equal 3
+    b.[0] |> equal 65uy
+    b.[2] |> equal 67uy