How to check if a variable is scalar in julia

Question

I would like to check if a variable is scalar in julia, such as Integer, String, Number, but not AstractArray, Tuple, type, struct, etc. Is there a simple method to do this (i.e. isscalar(x))

Answer 1

The notion of what is, or is not a scalar is under-defined without more context. Mathematically, a scalar is defined; (Wikipedia)

A scalar is an element of a field which is used to define a vector space.

That is to say, you need to define a vector space, based on a field, before you can determine if something is, or is not a scalar (relative to that vector space.). For the right vector space, tuples could be a scalar.

Of-course we are not looking for a mathematically rigorous definition. Just a pragmatic one.

Base it off what Broadcasting considers to be scalar

I suggest that the only meaningful way in which a scalar can be defined in julia, is of the behavior of broadcast. As of Julia 1:

using Base.Broadcast

isscalar(x::T) where T = isscalar(T)
isscalar(::Type{T}) where T = BroadcastStyle(T) isa Broadcast.DefaultArrayStyle{0}

See the docs for Broadcast.

In julia 0.7, Scalar is the default. So it is basically anything that doesn't have specific broadcasting behavior, i.e. it knocks out things like array and tuples etc.: using Base.Broadcast

isscalar(x::T) where T = isscalar(T)
isscalar(::Type{T}) where T = BroadcastStyle(T) isa Broadcast.Scalar

In julia 0.6 this is a bit more messy, but similar:

isscalar(x::T) where T = isscalar(T)
isscalar(::Type{T}) where T = Base.Broadcast._containertype(T)===Any

The advantage of using the methods for Broadcast to determine if something is scalar, over using your own methods, is that anyone making a new type that is going to act in a scalar way must make sure it works with those methods correctly (or actually nonscalar since scalar is the default.)

---

Structs are not not scalar

That is to say: sometimes structs are scalar and sometimes they are not and it depends on the struct.

Note however that these methods do not consider struct to be non-scalar. I think you are mistaken in your desire to.

Julia structs are not (necessarily or usually) a collection type. Consider that: BigInteger, BigFloat, Complex128 etc etc are all defined using structs

I was tempted to say that having a start method makes a type nonscalar, but that would be incorrect as start(::Number) is defined. (This has been debated a few times)

Answer 2

For completeness, I am copying Tasos Papastylianou's answer from the comments to here. If all you want to do is distinguish scalars from arrays you can use:

isa(x, Number)

This will output true if x is a Number (like a float or an int), and output false if x is an Array (vector, matrix, etc.)

Answer 3

I found myself needing to capture the notion of if something was scalar or not recently in MultiResolutionIterators.jl.

I found the boardcasting based rules from the other answer, did not meet my needs.

In particular I wanted to consider strings as nonscalar.

I defined a trait, bases on method_exists(start, (T,)), with some exceptions as mentioned e.g. for Number.

abstract type Scalarness end
struct Scalar <: Scalarness end
struct NotScalar <: Scalarness end

isscalar(::Type{Any}) = NotScalar() # if we don't know the type we can't really know if scalar or not
isscalar(::Type{<:AbstractString}) = NotScalar() # We consider strings to be nonscalar
isscalar(::Type{<:Number}) = Scalar() # We consider Numbers to be scalar
isscalar(::Type{Char}) = Scalar() # We consider Sharacter to be scalar
isscalar(::Type{T}) where T = method_exists(start, (T,)) ? NotScalar() : Scalar()

Something similar is also done by AbstractTrees.jl

isscalar(x) == applicable(start, x) && !isa(x, Integer) && !isa(x, Char) && !isa(x, Task)