Merge branch 'main' into migrate-to-dependabot

Author: ChrisRackauckas

.github/dependabot.yml

@@ -6,6 +6,9 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "weekly"
+    ignore:
+      - dependency-name: "crate-ci/typos"
+        update-types: ["version-update:semver-patch", "version-update:semver-minor"]
   - package-ecosystem: "julia"
     directories:
       - "/"

Project.toml

@@ -5,10 +5,12 @@ version = "0.1.4"
 
 [deps]
 FunctionWrappers = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e"
+PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 TruncatedStacktraces = "781d530d-4396-4725-bb49-402e4bee1e77"
 
 [compat]
 FunctionWrappers = "1"
+PrecompileTools = "1"
 TruncatedStacktraces = "1"
 julia = "1.6"
 

src/FunctionWrappersWrappers.jl

@@ -3,7 +3,7 @@ module FunctionWrappersWrappers
 using FunctionWrappers
 import TruncatedStacktraces
 
-export FunctionWrappersWrapper
+export FunctionWrappersWrapper, unwrap, wrapped_signatures, wrapped_return_types
 
 struct FunctionWrappersWrapper{FW, FB}
     fw::FW
@@ -48,4 +48,106 @@ function FunctionWrappersWrapper(
     FunctionWrappersWrapper{typeof(fwt), FB}(fwt)
 end
 
+"""
+    unwrap(fww::FunctionWrappersWrapper)
+
+Return the original function that was wrapped. This is useful for debugging
+wrapped functions - you can use the returned function with debugging tools
+like Debugger.jl or Infiltrator.jl.
+
+# Example
+
+```julia
+using FunctionWrappersWrappers
+
+# Create a wrapped function
+fww = FunctionWrappersWrapper(sin, (Tuple{Float64},), (Float64,))
+
+# Get the original function for debugging
+f = unwrap(fww)  # Returns sin
+
+# Now you can debug with Debugger.jl:
+# using Debugger
+# @enter f(0.5)
+
+# Or use Infiltrator.jl in your original function definition
+```
+
+See also: [`wrapped_signatures`](@ref), [`wrapped_return_types`](@ref)
+"""
+unwrap(fww::FunctionWrappersWrapper) = first(fww.fw).obj[]
+
+"""
+    wrapped_signatures(fww::FunctionWrappersWrapper)
+
+Return a tuple of the argument type signatures that the `FunctionWrappersWrapper`
+can dispatch on. Each element is a `Tuple` type representing the argument types.
+
+# Example
+
+```julia
+using FunctionWrappersWrappers
+
+fww = FunctionWrappersWrapper(+, (Tuple{Float64, Float64}, Tuple{Int, Int}), (Float64, Int))
+wrapped_signatures(fww)  # Returns (Tuple{Float64, Float64}, Tuple{Int, Int})
+```
+
+See also: [`unwrap`](@ref), [`wrapped_return_types`](@ref)
+"""
+function wrapped_signatures(fww::FunctionWrappersWrapper)
+    map(fw -> typeof(fw).parameters[2], fww.fw)
+end
+
+"""
+    wrapped_return_types(fww::FunctionWrappersWrapper)
+
+Return a tuple of the return types for each wrapped function signature.
+
+# Example
+
+```julia
+using FunctionWrappersWrappers
+
+fww = FunctionWrappersWrapper(+, (Tuple{Float64, Float64}, Tuple{Int, Int}), (Float64, Int))
+wrapped_return_types(fww)  # Returns (Float64, Int64)
+```
+
+See also: [`unwrap`](@ref), [`wrapped_signatures`](@ref)
+"""
+function wrapped_return_types(fww::FunctionWrappersWrapper)
+    map(fw -> typeof(fw).parameters[1], fww.fw)
+end
+
+using PrecompileTools
+
+@setup_workload begin
+    @compile_workload begin
+        # Precompile common use cases with Float64 and Int types
+        # These are the most common type combinations for numerical computations
+
+        # Binary operation with multiple type combinations (common pattern)
+        fw_binary = FunctionWrappersWrapper(
+            +,
+            (Tuple{Float64, Float64}, Tuple{Int, Int}),
+            (Float64, Int)
+        )
+        fw_binary(1.0, 2.0)
+        fw_binary(1, 2)
+
+        # Unary operation with multiple types (common pattern)
+        fw_unary = FunctionWrappersWrapper(
+            abs,
+            (Tuple{Float64}, Tuple{Int}),
+            (Float64, Int)
+        )
+        fw_unary(1.0)
+        fw_unary(1)
+
+        # Precompile introspection functions
+        unwrap(fw_unary)
+        wrapped_signatures(fw_binary)
+        wrapped_return_types(fw_binary)
+    end
+end
+
 end

test/runtests.jl

@@ -13,3 +13,56 @@ using Test
     @test fwexp2(4.0f0) === 16.0f0
     @test fwexp2(4) === 16.0
 end
+
+@testset "Introspection functions" begin
+    # Test with a simple function
+    fwsin = FunctionWrappersWrapper(sin, (Tuple{Float64},), (Float64,))
+
+    @testset "unwrap" begin
+        f = unwrap(fwsin)
+        @test f === sin
+        @test f(0.5) == sin(0.5)
+    end
+
+    @testset "wrapped_signatures" begin
+        sigs = wrapped_signatures(fwsin)
+        @test sigs == (Tuple{Float64},)
+    end
+
+    @testset "wrapped_return_types" begin
+        rets = wrapped_return_types(fwsin)
+        @test rets == (Float64,)
+    end
+
+    # Test with multiple signatures
+    fwplus = FunctionWrappersWrapper(+, (Tuple{Float64, Float64}, Tuple{Int, Int}), (
+        Float64, Int))
+
+    @testset "unwrap with multiple signatures" begin
+        f = unwrap(fwplus)
+        @test f === +
+        @test f(1, 2) == 3
+    end
+
+    @testset "wrapped_signatures with multiple signatures" begin
+        sigs = wrapped_signatures(fwplus)
+        @test sigs == (Tuple{Float64, Float64}, Tuple{Int, Int})
+    end
+
+    @testset "wrapped_return_types with multiple signatures" begin
+        rets = wrapped_return_types(fwplus)
+        @test rets == (Float64, Int)
+    end
+
+    # Test with a custom function
+    my_func(x) = x^2
+    fwcustom = FunctionWrappersWrapper(my_func, (Tuple{Float64}, Tuple{Int}), (
+        Float64, Int))
+
+    @testset "unwrap with custom function" begin
+        f = unwrap(fwcustom)
+        @test f === my_func
+        @test f(3) == 9
+        @test f(2.5) == 6.25
+    end
+end