I'm trying to figure out the proper way to write code in a type-stable manner.
I know that some limitations, such as ::Function and ::Val{} arguments are an issue, and so I'm trying to figure out the best way of going around those.
I'm still deep into the learning phase, so please feel free to provide as much information and comments as you feel like.

我正在试图找出以类型稳定的方式编写代码的正确方法。我知道一些限制，如：：Function和：：val{}参数是一个问题，所以我正在尝试找出绕过这些限制的最佳方法。我仍在深入学习阶段，所以请随时提供您想要的信息和评论。

As part of that, I was trying to create an SVector that is type-stable, however I keep getting it wrong. here is a MWE (and pardon the stupid names for functions and variables, I tried to maitain the actual structure of the code while removing meaningful content), where the output is SVector{_A, Float64} where _A. How do I get a proper SVector here? Feel free to modify the code as you please, as long as the function order and structure remains.

作为其中的一部分，我试图创建一个类型稳定的SVector，但我总是弄错。这里有一个MWE(请原谅函数和变量的愚蠢名称，我试图在删除有意义的内容的同时保持代码的实际结构)，其中输出是SVector{_A，Float64}where_A。我如何在这里获得一个合适的SVector？只要函数顺序和结构保持不变，您可以随意修改代码。

Supporting functions:

支持功能：

using StaticArrays
@inline function HyperTanDistribSymm(α::T,Lx::T=one(T)) where T<:AbstractFloat
    return x -> convert(T,0.5)*Lx*( one(T) - tanh( α*(one(T)-convert(T,2.0)*x) ) / tanh(α) )
end

function GenerateVec(L::TF, indxrng::AbstractUnitRange{TI}, ntotal::TI=length(indxrng), Stretchfun::Function=x::TF->x::TF, nghost::TI=1) where {TI<:Integer, TF<:AbstractFloat}
    nterms::TI=2*nghost+length(indxrng)+one(TI)
    return SVector{nterms,TF}( map( Stretchfun,L*convert.(TF, indxrng[1]-one(TI)-nghost:indxrng[end]+nghost)/convert(TF, ntotal)  ) )
end


function madness(varD::TF, indx::AbstractUnitRange{TI}, varN::TI, stretch::Function, nghost::TI) where {TF<:AbstractFloat, TI<:Integer}
    testvar=GenerateVec(varD, indx, varN, stretch, nghost)
    nterms::TI=length(testvar)-one(TI)
    diffvar=SVector{nterms,TF}( diff(testvar) )
end

And running examples:

和运行示例：

using Cthulhu
@descend_code_warntype madness(1.0, 1:6, 6, x->x, 1)
@descend_code_warntype madness(2.0, 2:8, 10, HyperTanDistribSymm(2.20,6.0), 2)

as GenerateVec returns SVector{nterms::Int64,TF::Type{Float64}}::Type{SVector{_A, Float64}} where _A.
I will comment that I tried other versions, including the use of Val approach on something on the lines of:

当GenerateVec返回SVector{nTerms：：Int64，tf：：type{Float64}}：：type{SVector{_A，Float64}}where_A时，我会评论说我尝试过其他版本，包括对以下代码行的内容使用Val方法：

@inline CreateSVector(input::Base.AbstractVecOrTuple{T}) where {T<:Number} = CreateSVector(Val(length(input)), input)
@inline CreateSVector(::Val{N}, input::Base.AbstractVecOrTuple{T}) where {N,T<:Number} = SVector{N,T}( input )

this is just one example, I also tried using N just as a regular N<:Integer input and such. All result in the same issue.

这只是一个例子，我还尝试使用N作为常规的N<：整数输入等等。所有这些都会导致相同的问题。

Note: I have read around and figured that possibly the use of Tuples pass arguments and set sizes might be a solution - if that is the case, why?

注意：我已经仔细阅读过，并认为使用元组传递参数和集大小可能是一种解决方案--如果是这样，为什么？

You might find a text I wrote useful in your quest for understanding type stability:
https://www.juliabloggers.com/writing-type-stable-julia-code/

您可能会发现我写的一篇文章对您了解类型稳定性很有用：https://www.juliabloggers.com/writing-type-stable-julia-code/

But the short version is as follows:
a) the type of a StaticVector depends on its length.
b) type stability means that types (and so StaticVectors') length are defined at compile time
c) so the length must be either hard coded, or be given as a type parameter. Examples, where the parameter is called VecLen:

但简短的版本如下：a)StaticVector的类型取决于它的长度。B)类型稳定性意味着类型(以及StaticVectors)长度是在编译时定义的c)，因此长度必须是硬编码的，或者作为类型参数给出。示例，其中该参数称为VecLen：

... ::Val{VecLen}}...) where {VecLen} 

or

或

... v::StaticArray{VecLen,Float64}...) where {VecLen}

You want type stability 'cause you want speed 'cause you're in a loop. If you can compute VecLen outside the loop (see the concept of barrier function) and pass it down to your function (using Val, or other technique) you win.

你想要类型稳定性，因为你想要速度，因为你在循环中。如果你能在循环外计算VecLen(参见屏障函数的概念)并将其传递给你的函数(使用val或其他技术)，你就赢了。

If you cannot precompute VecLen (e.g. because it changes at each iteration) then we are busted, you will not get type stability. You would then StaticArrays are not for you today.

如果您不能预先计算VecLen(例如，因为它在每次迭代时都会改变)，那么我们就失败了，您将无法获得类型稳定性。那么你就会发现StaticArray今天不适合你。

I hope this helps!

我希望这能帮到你!

: )

：)

Philippe

菲利普