feat!: add GenTypes module with T enum for GIAC expression types

BREAKING CHANGE: Legacy GIAC_* constants removed

- Add src/gen_types.jl with GenTypes submodule and T enum
- T enum has all 22 GIAC types matching C++ gen_unary_types
- giac_type() now returns T enum instead of Int32
- Remove GIAC_INT, GIAC_DOUBLE, GIAC_VECT, etc. constants
- Remove GIAC_SEQ_VECT, GIAC_SET_VECT, GIAC_LIST_VECT subtype constants
- Update introspection.jl, conversion.jl to use T enum
- Add test/test_gen_types.jl with 70 tests
- Update test_output_handling.jl for new enum API
- Update documentation for GenTypes usage

Migration: Use `using Giac.GenTypes: T, INT, VECT, SYMB, ...`
instead of GIAC_INT, GIAC_VECT, GIAC_SYMB, etc.

Author: s-celles

docs/src/api/core.md

@@ -274,29 +274,41 @@ Giac.is_string
 Giac.is_boolean
 ```
 
-### Type Constants
+### Type Enum (GenTypes)
 
-| Constant | Description |
-|----------|-------------|
-| `GIAC_INT` | Machine integer (Int64) |
-| `GIAC_DOUBLE` | Double-precision float (Float64) |
-| `GIAC_ZINT` | Arbitrary-precision integer (BigInt) |
-| `GIAC_REAL` | Extended precision real |
-| `GIAC_CPLX` | Complex number |
-| `GIAC_VECT` | Vector/list/sequence |
-| `GIAC_SYMB` | Symbolic expression |
-| `GIAC_IDNT` | Identifier/variable |
-| `GIAC_STRNG` | String value |
-| `GIAC_FRAC` | Rational fraction |
-| `GIAC_FUNC` | Function reference |
-
-### Vector Subtype Constants
-
-| Constant | Description |
-|----------|-------------|
-| `GIAC_SEQ_VECT` | Sequence (function arguments) |
-| `GIAC_SET_VECT` | Set (unordered collection) |
-| `GIAC_LIST_VECT` | List (ordered collection) |
+GIAC expression types are available via the `Giac.GenTypes` module with the `T` enum:
+
+```julia
+using Giac.GenTypes: T, INT, DOUBLE, VECT, SYMB
+
+giac_type(expr) == INT   # Check if expression is an integer
+giac_type(expr) == VECT  # Check if expression is a vector
+```
+
+| Enum Value | Int | Description |
+|------------|-----|-------------|
+| `INT` | 0 | Machine integer (Int64) |
+| `DOUBLE` | 1 | Double-precision float (Float64) |
+| `ZINT` | 2 | Arbitrary-precision integer (BigInt) |
+| `REAL` | 3 | Extended precision real |
+| `CPLX` | 4 | Complex number |
+| `POLY` | 5 | Polynomial |
+| `IDNT` | 6 | Identifier/variable |
+| `VECT` | 7 | Vector/list/sequence |
+| `SYMB` | 8 | Symbolic expression |
+| `SPOL1` | 9 | Sparse polynomial |
+| `FRAC` | 10 | Rational fraction |
+| `EXT` | 11 | Algebraic extension |
+| `STRNG` | 12 | String value |
+| `FUNC` | 13 | Function reference |
+| `ROOT` | 14 | Polynomial root |
+| `MOD` | 15 | Modular arithmetic |
+| `USER` | 16 | User-defined type |
+| `MAP` | 17 | Map/dictionary |
+| `EQW` | 18 | Equation writer data |
+| `GROB` | 19 | Graphic object |
+| `POINTER` | 20 | Raw pointer |
+| `FLOAT` | 21 | Float value |
 
 ## Component Access
 

docs/src/domains/signal/continuous_transforms.md

@@ -119,5 +119,5 @@ invoke_cmd(:ilaplace, 1/(s+a), s, t)
 ## See Also
 
 - [Discrete-Time Transforms](discrete_transforms.md) - Z-transform and inverse Z-transform
-- [Calculus Operations](../math/calculus.md) - Integration, differentiation, and limits
+- [Calculus Operations](../../mathematics/calculus.md) - Integration, differentiation, and limits
 - [GIAC Laplace Documentation](https://www-fourier.univ-grenoble-alpes.fr/~parisse/giac/doc/en/cascmd_en/cascmd_en466.html) - Official GIAC documentation

docs/src/domains/signal/discrete_transforms.md

@@ -112,5 +112,5 @@ invoke_cmd(:invztrans, z/(z-a), z, n)
 ## See Also
 
 - [Continuous-Time Transforms](continuous_transforms.md) - Laplace transforms for continuous-time signals
-- [Calculus Operations](../math/calculus.md) - Integration, differentiation, and limits
+- [Calculus Operations](../../mathematics/calculus.md) - Integration, differentiation, and limits
 - [GIAC Z-Transform Documentation](https://www-fourier.univ-grenoble-alpes.fr/~parisse/giac/doc/en/cascmd_en/cascmd_en467.html) - Official GIAC documentation

src/Giac.jl

@@ -76,6 +76,9 @@ include("macros.jl")
 include("tables.jl")
 include("substitute.jl")
 
+# GenTypes module - Scoped enum for GIAC types (041-scoped-type-enum)
+include("gen_types.jl")
+
 # Output handling (029-output-handling)
 include("introspection.jl")
 include("conversion.jl")
@@ -116,10 +119,8 @@ export commands_table, clear_commands_cache!, CommandsTable
 # Substitute function (028-substitute-mechanism)
 export substitute
 
-# Type introspection (029-output-handling)
-export GIAC_INT, GIAC_DOUBLE, GIAC_ZINT, GIAC_REAL, GIAC_CPLX, GIAC_VECT
-export GIAC_SYMB, GIAC_IDNT, GIAC_STRNG, GIAC_FRAC, GIAC_FUNC
-export GIAC_SEQ_VECT, GIAC_SET_VECT, GIAC_LIST_VECT
+# Type introspection (029-output-handling, 041-scoped-type-enum)
+# Legacy GIAC_* constants removed - use Giac.GenTypes: T, INT, DOUBLE, etc.
 export giac_type, subtype
 export is_integer, is_numeric, is_vector, is_symbolic, is_identifier
 export is_fraction, is_complex, is_string, is_boolean

src/conversion.jl

@@ -2,6 +2,9 @@
 # Provides extended to_julia functionality with vector/complex/fraction support
 #
 # Part of feature 029-output-handling, 030-to-julia-bool-conversion
+# Updated for 041-scoped-type-enum: Uses GenTypes.T enum instead of GIAC_* constants
+
+using .GenTypes: T, INT, DOUBLE, ZINT, REAL, CPLX, VECT, SYMB, IDNT, FRAC, STRNG, FUNC
 
 # ============================================================================
 # Extended to_julia Conversion
@@ -16,14 +19,14 @@ Recursively convert a GIAC expression to native Julia types.
 | GIAC Type | Julia Return Type |
 |-----------|-------------------|
 | Boolean (`true`/`false`) | `Bool` |
-| `GIAC_INT` | `Int64` |
-| `GIAC_ZINT` | `BigInt` |
-| `GIAC_DOUBLE`, `GIAC_REAL` | `Float64` |
-| `GIAC_FRAC` | `Rational{Int64}` or `Rational{BigInt}` |
-| `GIAC_CPLX` | `Complex{T}` (T promoted from parts) |
-| `GIAC_VECT` | `Vector{T}` (T narrowed from elements) |
-| `GIAC_STRNG` | `String` |
-| `GIAC_SYMB`, `GIAC_IDNT`, `GIAC_FUNC` | `GiacExpr` (unchanged) |
+| `INT` | `Int64` |
+| `ZINT` | `BigInt` |
+| `DOUBLE`, `REAL` | `Float64` |
+| `FRAC` | `Rational{Int64}` or `Rational{BigInt}` |
+| `CPLX` | `Complex{T}` (T promoted from parts) |
+| `VECT` | `Vector{T}` (T narrowed from elements) |
+| `STRNG` | `String` |
+| `SYMB`, `IDNT`, `FUNC` | `GiacExpr` (unchanged) |
 
 Note: GIAC represents booleans as integers internally, but `to_julia` detects them
 via their string representation ("true"/"false") and returns Julia `Bool` values.
@@ -69,27 +72,27 @@ function to_julia(g::GiacExpr)
 end
 
 # Internal dispatcher based on type constant
-function _convert_by_type(g::GiacExpr, t::Int32)
-    if t == GIAC_INT
+function _convert_by_type(g::GiacExpr, t::T)
+    if t == INT
         # Check for boolean before integer conversion (030-to-julia-bool-conversion)
         if is_boolean(g)
             return _convert_to_bool(g)
         end
         return _convert_to_int64(g)
-    elseif t == GIAC_DOUBLE || t == GIAC_REAL
+    elseif t == DOUBLE || t == REAL
         return _convert_to_float64(g)
-    elseif t == GIAC_ZINT
+    elseif t == ZINT
         return _convert_to_bigint(g)
-    elseif t == GIAC_FRAC
+    elseif t == FRAC
         return _convert_to_rational(g)
-    elseif t == GIAC_CPLX
+    elseif t == CPLX
         return _convert_to_complex(g)
-    elseif t == GIAC_VECT
+    elseif t == VECT
         return _convert_to_vector(g)
-    elseif t == GIAC_STRNG
+    elseif t == STRNG
         return _convert_to_string(g)
     else
-        # Symbolic types (GIAC_SYMB, GIAC_IDNT, GIAC_FUNC) - return unchanged
+        # Symbolic types (SYMB, IDNT, FUNC) - return unchanged
         return g
     end
 end
@@ -143,7 +146,7 @@ function _convert_to_rational(g::GiacExpr)
     den_type = giac_type(den_expr)
 
     # Check if either is BigInt (ZINT)
-    if num_type == GIAC_ZINT || den_type == GIAC_ZINT
+    if num_type == ZINT || den_type == ZINT
         num = to_julia(num_expr)::Union{Int64, BigInt}
         den = to_julia(den_expr)::Union{Int64, BigInt}
         return Rational{BigInt}(BigInt(num), BigInt(den))
@@ -210,7 +213,7 @@ Check if a GiacExpr can be fully converted to native Julia types
 """
 function _can_convert_fully(g::GiacExpr)::Bool
     t = giac_type(g)
-    if t == GIAC_VECT
+    if t == VECT
         # For vectors, recursively check all elements
         n = _vector_length(g)
         for i in 1:n
@@ -220,11 +223,11 @@ function _can_convert_fully(g::GiacExpr)::Bool
             end
         end
         return true
-    elseif t in (GIAC_INT, GIAC_DOUBLE, GIAC_REAL, GIAC_ZINT, GIAC_FRAC, GIAC_CPLX, GIAC_STRNG)
+    elseif t in (INT, DOUBLE, REAL, ZINT, FRAC, CPLX, STRNG)
         # Numeric and string types can be fully converted
         return true
     else
-        # GIAC_SYMB, GIAC_IDNT, GIAC_FUNC - symbolic, cannot fully convert
+        # SYMB, IDNT, FUNC - symbolic, cannot fully convert
         return false
     end
 end
@@ -302,9 +305,9 @@ Convert an integer GiacExpr to Int64.
 """
 function Base.convert(::Type{Int64}, g::GiacExpr)::Int64
     t = giac_type(g)
-    if t == GIAC_INT
+    if t == INT
         return _convert_to_int64(g)
-    elseif t == GIAC_ZINT
+    elseif t == ZINT
         big = _convert_to_bigint(g)
         if big > typemax(Int64) || big < typemin(Int64)
             throw(InexactError(:convert, Int64, big))
@@ -322,13 +325,13 @@ Convert a numeric GiacExpr to Float64.
 """
 function Base.convert(::Type{Float64}, g::GiacExpr)::Float64
     t = giac_type(g)
-    if t == GIAC_DOUBLE || t == GIAC_REAL
+    if t == DOUBLE || t == REAL
         return _convert_to_float64(g)
-    elseif t == GIAC_INT
+    elseif t == INT
         return Float64(_convert_to_int64(g))
-    elseif t == GIAC_ZINT
+    elseif t == ZINT
         return Float64(_convert_to_bigint(g))
-    elseif t == GIAC_FRAC
+    elseif t == FRAC
         r = _convert_to_rational(g)
         return Float64(r)
     else
@@ -355,11 +358,11 @@ Convert a fraction or integer GiacExpr to a Rational.
 """
 function Base.convert(::Type{Rational}, g::GiacExpr)::Rational
     t = giac_type(g)
-    if t == GIAC_FRAC
+    if t == FRAC
         return _convert_to_rational(g)
-    elseif t == GIAC_INT
+    elseif t == INT
         return Rational(_convert_to_int64(g))
-    elseif t == GIAC_ZINT
+    elseif t == ZINT
         return Rational(_convert_to_bigint(g))
     else
         throw(MethodError(convert, (Rational, g)))
@@ -373,7 +376,7 @@ Convert a complex GiacExpr to a Julia Complex.
 """
 function Base.convert(::Type{Complex}, g::GiacExpr)::Complex
     t = giac_type(g)
-    if t == GIAC_CPLX
+    if t == CPLX
         return _convert_to_complex(g)
     elseif is_numeric(g)
         # Numeric but not complex - treat as real
@@ -415,7 +418,7 @@ function Base.convert(::Type{Bool}, g::GiacExpr)::Bool
 
     # Allow integer 0/1 to convert to Bool (standard Julia behavior)
     t = giac_type(g)
-    if t == GIAC_INT
+    if t == INT
         val = _convert_to_int64(g)
         if val == 0
             return false

src/gen_types.jl

@@ -0,0 +1,123 @@
+# GenTypes module - Scoped enum for GIAC expression types
+# Feature: 041-scoped-type-enum
+# Provides type-safe enum matching C++ gen_unary_types
+
+"""
+    GenTypes
+
+A submodule containing the `T` enum for GIAC expression type constants.
+
+This module provides type-safe, scoped access to GIAC's internal type system,
+matching the C++ `gen_unary_types` enum exactly.
+
+# Usage
+
+```julia
+using Giac.GenTypes: T, INT, VECT, SYMB
+
+# Access type constants as module values
+INT     # Machine integer (0)
+DOUBLE  # Double-precision float (1)
+VECT    # Vector/list/sequence (7)
+SYMB    # Symbolic expression (8)
+
+# Or use the T type for construction from integers
+T(0)    # INT
+T(7)    # VECT
+
+# Use with giac_type()
+expr = giac_eval("42")
+giac_type(expr) == INT  # true
+
+# Convert to integer
+Int(VECT)  # 7
+```
+
+# Type Values
+
+The enum values match the C++ `gen_unary_types` enum:
+- Types 0-1 and 20-21 are "immediate" (no memory allocation)
+- Types 2-19 are "pointer" types (require memory allocation)
+
+See also: [`giac_type`](@ref)
+"""
+module GenTypes
+
+"""
+    T
+
+Enum representing GIAC expression types, matching C++ `gen_unary_types`.
+
+# Values
+
+| Value | Int | C++ Name | Description |
+|-------|-----|----------|-------------|
+| `T.INT` | 0 | `_INT_` | Machine integer |
+| `T.DOUBLE` | 1 | `_DOUBLE_` | Double-precision float |
+| `T.ZINT` | 2 | `_ZINT` | Arbitrary precision integer |
+| `T.REAL` | 3 | `_REAL` | Extended precision real |
+| `T.CPLX` | 4 | `_CPLX` | Complex number |
+| `T.POLY` | 5 | `_POLY` | Polynomial |
+| `T.IDNT` | 6 | `_IDNT` | Identifier/variable |
+| `T.VECT` | 7 | `_VECT` | Vector/list/sequence |
+| `T.SYMB` | 8 | `_SYMB` | Symbolic expression |
+| `T.SPOL1` | 9 | `_SPOL1` | Sparse polynomial |
+| `T.FRAC` | 10 | `_FRAC` | Rational fraction |
+| `T.EXT` | 11 | `_EXT` | Algebraic extension |
+| `T.STRNG` | 12 | `_STRNG` | String |
+| `T.FUNC` | 13 | `_FUNC` | Function reference |
+| `T.ROOT` | 14 | `_ROOT` | Root of polynomial |
+| `T.MOD` | 15 | `_MOD` | Modular arithmetic |
+| `T.USER` | 16 | `_USER` | User-defined type |
+| `T.MAP` | 17 | `_MAP` | Map/dictionary |
+| `T.EQW` | 18 | `_EQW` | Equation writer data |
+| `T.GROB` | 19 | `_GROB` | Graphic object |
+| `T.POINTER` | 20 | `_POINTER_` | Raw pointer |
+| `T.FLOAT` | 21 | `_FLOAT_` | Float (immediate) |
+
+# Examples
+
+```julia
+using Giac.GenTypes: T, INT, VECT, FLOAT
+
+# Check integer value
+Int(INT) == 0     # true
+Int(VECT) == 7    # true
+Int(FLOAT) == 21  # true
+
+# Create from integer
+T(0) == INT       # true
+T(7) == VECT      # true
+```
+"""
+@enum T::Int32 begin
+    INT = 0       # _INT_ - Machine integer (immediate)
+    DOUBLE = 1    # _DOUBLE_ - Double-precision float (immediate)
+    ZINT = 2      # _ZINT - Arbitrary precision integer
+    REAL = 3      # _REAL - Extended precision real
+    CPLX = 4      # _CPLX - Complex number
+    POLY = 5      # _POLY - Polynomial
+    IDNT = 6      # _IDNT - Identifier/variable
+    VECT = 7      # _VECT - Vector/list/sequence
+    SYMB = 8      # _SYMB - Symbolic expression
+    SPOL1 = 9     # _SPOL1 - Sparse polynomial
+    FRAC = 10     # _FRAC - Rational fraction
+    EXT = 11      # _EXT - Algebraic extension
+    STRNG = 12    # _STRNG - String
+    FUNC = 13     # _FUNC - Function reference
+    ROOT = 14     # _ROOT - Root of polynomial
+    MOD = 15      # _MOD - Modular arithmetic
+    USER = 16     # _USER - User-defined type
+    MAP = 17      # _MAP - Map/dictionary
+    EQW = 18      # _EQW - Equation writer data
+    GROB = 19     # _GROB - Graphic object
+    POINTER = 20  # _POINTER_ - Raw pointer (immediate)
+    FLOAT = 21    # _FLOAT_ - Float (immediate)
+end
+
+export T
+# Export all enum values for direct access after `using Giac.GenTypes`
+export INT, DOUBLE, ZINT, REAL, CPLX, POLY, IDNT, VECT, SYMB
+export SPOL1, FRAC, EXT, STRNG, FUNC, ROOT, MOD, USER, MAP, EQW, GROB, POINTER, FLOAT
+
+end # module GenTypes