I was experiencing a strange error in my code (strange because of my fault of not reading the return type of the strip
function). strip
returns a SubString instead of a String type and this was throwing error when using Bcrypt.CompareHashAndPassword
. Is the recommended way to strip
and then use string()
function to convert it back to String type.
- The reason why
strip
returnsSubString
is to reduce allocations. - Yes, unfortunately currently you need to cast
SubString
toString
manually in your case. - In general the issue is that the Bcrypt.jl has an overly strict method signature. It is typically not recommended to require
String
as function argument. UsuallyAbstractString
should be used.
I’m not sure it’s recommended in general, you can do a lot without converting to a String, e.g. println(strip(" Hello "), " Palli")
# there , is better then *, since the latter, for concatenation, will make an actual String which is slower, and not needed.
Note, only the third version here works:
julia> p1(str::String) = println(str)
julia> p2(str::AbstractString) = println(str)
julia> p3(str::Union{AbstractString, SubString}) = println(str)
julia> p3(strip(" Palli "))
Palli
You don’t need to add types to any function definitions, it doesn’t help with speed, though can help with documentation readability? At least if you do, then using String is almost always a mistake, since there are other type of string types (in packages), and you want to be general. I thought AbstractString was better and sufficient, but it isn’t in this base, since SubString isn’t a subtype of it. Should/could it be?
Thank you. I will open an issue in Bcrypt.jl repo. Although, in general, is it better to use AbstractString
or leave the type unspecified. I believe I heard in one of the talks that use of abstract types prevent JIT compiler from optimizing the code relative to specifying concrete types. Is this true? Thank you for explaining.
Code is specialized in runtime, because it is compiled during runtime, just before a call happens, taking in consideration the concrete type of the arguments in runtime (independent of how restrictive or lax the type parameters statically defined) so I fell like this is wrong. But your question is very vague, if you are talking about struct
s with abstract fields, yes, it may impact performance, if you are talking about function signatures, no, probably not.
Thank you. I think it was in the context of structs with abstract fields. But, as you correctly point out, I am being kind of vague. I tried to find where I heard it, but could not do so yet. But it is good to know that in function signatures using an AbstractType does not create specific ineffciencies.