# Query regarding type-stability of cat

**URL:** https://discourse.julialang.org/t/query-regarding-type-stability-of-cat/72003
**Category:** General Usage
**Tags:** type-stability
**Created:** [November 24, 2021, 11:39am UTC](https://discourse.julialang.org/t/query-regarding-type-stability-of-cat/72003 "2021-11-24T11:39:53Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![jishnub](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/jishnub/32/33620_2.png) [@jishnub](https://discourse.julialang.org/u/jishnub)
#### Post date: [November 24, 2021, 11:39am UTC](https://discourse.julialang.org/t/query-regarding-type-stability-of-cat/72003/1 "2021-11-24T11:39:53Z")

</div>

The function `cat` seems to internally use `cat_t`. The definition of `cat_t` that is used in my case is

```julia
@inline cat_t(::Type{T}, X...; dims) where {T} = _cat_t(dims, T, X...)

```

However, for some reason, the function `_cat_t` seems type-stable while `cat_t` isn’t.

```julia
julia> f(a...) = Base._cat_t((1,2), Float64, a...)
f (generic function with 1 method)

julia> @code_warntype f(ones(2,2))
MethodInstance for f(::Matrix{Float64})
  from f(a...) in Main at REPL[1]:1
Arguments
  #self#::Core.Const(f)
  a::Tuple{Matrix{Float64}}
Body::Matrix{Float64}
1 ─ %1 = Base._cat_t::Core.Const(Base._cat_t)
│ %2 = Core.tuple(1, 2)::Core.Const((1, 2))
│ %3 = Core.tuple(%2, Main.Float64)::Core.Const(((1, 2), Float64))
│ %4 = Core._apply_iterate(Base.iterate, %1, %3, a)::Matrix{Float64}
└── return %4

julia> f(a...) = Base.cat_t(Float64, a..., dims=(1,2))
f (generic function with 1 method)

julia> @code_warntype f(ones(2,2))
MethodInstance for f(::Matrix{Float64})
  from f(a...) in Main at REPL[3]:1
Arguments
  #self#::Core.Const(f)
  a::Tuple{Matrix{Float64}}
Body::Any
1 ─ %1 = (:dims,)::Core.Const((:dims,))
│ %2 = Core.apply_type(Core.NamedTuple, %1)::Core.Const(NamedTuple{(:dims,)})
│ %3 = Core.tuple(1, 2)::Core.Const((1, 2))
│ %4 = Core.tuple(%3)::Core.Const(((1, 2),))
│ %5 = (%2)(%4)::Core.Const((dims = (1, 2),))
│ %6 = Base.cat_t::Core.Const(Base.cat_t)
│ %7 = Core.kwfunc(%6)::Core.Const(Base.var"#cat_t##kw"())
│ %8 = Base.cat_t::Core.Const(Base.cat_t)
│ %9 = Core.tuple(%5, %8, Main.Float64)::Core.Const(((dims = (1, 2),), Base.cat_t, Float64))
│ %10 = Core._apply_iterate(Base.iterate, %7, %9, a)::Any
└── return %10

```

Perhaps the keyword argument isn’t being constant-propagated (I don’t know the internals of how this works). Could someone who is more familiar with how this works explain why `cat_t` isn’t type-stable, and if there is a way to get it to infer the return type correctly?

This is on nightly.

```julia
julia> VERSION
v"1.8.0-DEV.1060"

```