Replace RecursiveApply interface with MathWrapper

Author: dennisYatunin

docs/src/APIs/utilities_api.md

@@ -9,6 +9,19 @@ Utilities.PlusHalf
 Utilities.half
 ```
 
+## Utilities.MathMapper
+
+```@docs
+Utilities.MathMapper
+Utilities.supports_math_mapper
+Utilities.nested_math_mapper
+Utilities.math_mapper_broadcast
+Utilities.reduce_math_mapper_broadcast
+Utilities.math_mapper_type_broadcast
+Utilities.reduce_math_mapper_type_broadcast
+Utilities.@math_mapper_method
+```
+
 ## Utilities.Cache
 
 ```@docs

src/Utilities/Utilities.jl

@@ -1,5 +1,6 @@
 module Utilities
 
+include("math_mapper.jl")
 include("plushalf.jl")
 include("cache.jl")
 
@@ -60,5 +61,47 @@ function unionall_type(::Type{T}) where {T}
     return T.name.wrapper
 end
 
+"""
+    inferred_result_type(f, types...)
+
+The type of result generated by calling `f` with arguments of the given types.
+An error is thrown if the compiler is unable to infer a concrete type, or if
+there is no method available for the specified argument types.
+"""
+function inferred_result_type(f::F, types...) where {F}
+    if unrolled_any(==(Union{}), types)
+        union_index = findfirst(==(Union{}), types)
+        throw(ArgumentError("Cannot infer type of argument $union_index to $f"))
+    end
+    hasmethod(f, Tuple{types...}) || throw(MethodError(f, Tuple{types...}))
+    inferred_type = Core.Compiler.return_type(f, Tuple{types...})
+    if !isconcretetype(inferred_type)
+        types_string = join(map(Base.Fix1(*, "::"), types), ", ")
+        throw(ArgumentError("Cannot infer concrete type of $f($types_string)"))
+    end
+    return inferred_type
+end
+
+"""
+    inferred_result_value(f, types...)
+
+The result of calling `f` with arguments of the given types, computed by using
+[`inferred_result_type`](@ref) in conjunction with a `Val` wrapper. The value
+returned by a function can only be inferred when it is a compile-time constant
+(i.e., when it is marked as a `Core.Const` in the output of `@code_warntype`).
+"""
+function inferred_result_value(f::F, types...) where {F}
+    inferred_result_type(f, types...) # First check whether the type is inferred
+    inferred_val_type = Core.Compiler.return_type(Val ∘ f, Tuple{types...})
+    if !isconcretetype(inferred_val_type)
+        types_string = join(map(Base.Fix1(*, "::"), types), ", ")
+        throw(ArgumentError("Cannot infer constant value of $f($types_string)"))
+    end
+    return val_type_parameter(inferred_val_type)
+end
+
+# Wrap values passed between functions in Vals to guarantee constant-propagation
+val_parameter(::Val{constant}) where {constant} = constant
+val_type_parameter(::Type{Val{constant}}) where {constant} = constant
 
 end # module