timholy

-- isequal(REPL.LineEdit.Prompt, REPL.LineEdit.Prompt)
-- isequal(Method, Method)
-- isequal(Distributed.RemoteChannel{Base.Channel{Any}}, WeakRef)
-- isequal(Distributed.RemoteChannel{Base.Channel{Any}}, Distributed.RemoteChannel{Base.Channel{Any}})
-- isequal(Core.TypeName, Core.TypeName)
-- isequal(Symbol, Symbol)
-- isequal(String, Int64)
-- isequal(String, Char)
-- isequal(String, String)
-- isequal(Char, Char)

timholy

function nspecializations(m::Method)
    return isdefined(m, :specializations) ? nspecializations(m.specializations) : 0
end
nspecializations(::Nothing) = 0
function nspecializations(tme::Core.TypeMapEntry)
    n = 0
    while tme !== nothing
        n += 1
        tme = tme.next
    end

timholy

using Base.Meta: isexpr

# Grabbing the inferred code

function disable_pass!(src)
    for (line, stmt) in enumerate(src.code)
        if isexpr(stmt, :meta, 1)
            a = stmt.args[1]
            if isexpr(a, :external_pass)
                mode = a.args[1]

timholy

using ImageFiltering, ImageCore, OffsetArrays
using ImageFiltering: safehead, safetail, safe_for_prod
using LoopVectorization

function old!(out, A, kern, R=CartesianIndices(out), z=zero(eltype(out)))
    Rk = CartesianIndices(axes(kern))
    for I in safetail(R), i in safehead(R)
        tmp = z
        @inbounds for J in safetail(Rk), j in safehead(Rk)
            tmp += safe_for_prod(A[i+j,I+J], tmp)*kern[j,J]

timholy

using FixedPointNumbers, ColorTypes, Test
AbstractAGrayT{T} = AlphaColor{C,T,2} where C<:AbstractGray{T}  # Like AbstractAGray but having just an eltype type-parameter
AbstractGrayAT{T} = ColorAlpha{C,T,2} where C<:AbstractGray{T}
using ColorTypes: TwoColorTypeError

const all_colorants = map(s->getfield(ColorTypes,s),
                          filter(names(ColorTypes, all=false)) do s
                              isdefined(ColorTypes, s) || return false
                              t = getfield(ColorTypes, s)
                              isa(t, Type) && t <: Colorant && !isabstracttype(t)

timholy

module NaNIntegers

import Base: <, <=, +, -, *, ~, &, |, <<, >>, >>>, xor

export NInt16, NInt32, NInt64, NInt128, NInt
export NaNI16, NaNI32, NaNI64, NaNI128

abstract type NSigned   <: Signed end

primitive type NInt16 <: NSigned 16 end

timholy

# This file is machine-generated - editing it directly is not advised

[[AbstractFFTs]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "051c95d6836228d120f5f4b984dd5aba1624f716"
uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c"
version = "0.5.0"

[[ArgCheck]]
deps = ["Random"]

timholy

# This file is machine-generated - editing it directly is not advised

[[ATK_jll]]
deps = ["Glib_jll", "Libdl", "Pkg"]
git-tree-sha1 = "7129d58ed99d42032cefe21bcd14171a878143d2"
uuid = "7b86fcea-f67b-53e1-809c-8f1719c154e8"
version = "2.34.1+2"

[[AbstractFFTs]]
deps = ["LinearAlgebra"]

timholy

Tuple{getfield(Core, Symbol("#Type##kw")), Any, Type{Base.GenericIOBuffer{Array{UInt8, 1}}}}
Tuple{Type{Base.GenericIOBuffer{Array{UInt8, 1}}}}
Tuple{typeof(Base.:(^)), T, T} where T<:Integer
Tuple{typeof(Base.isempty), Tuple}
Tuple{typeof(Base.:(==)), T, T} where T<:Number
Tuple{typeof(Base.convert), Type{T}, T} where T<:Number
Tuple{typeof(Base.getproperty), Any, Symbol}
Tuple{Type{Float32}, Float64}
Tuple{getfield(Base, Symbol("##IOBuffer#311")), Union{Nothing, Bool}, Union{Nothing, Bool}, Union{Nothing, Bool}, Union{Nothing, Bool}, Integer, Union{Nothing, Integer}, Type{Base.GenericIOBuffer{Array{UInt8, 1}}}}
Tuple{typeof(Base.print), IO, Char}

timholy

function traverse(val, mod::Module, visiting=Set{Module}())
    push!(visiting, mod)
    val = increment(val, mod)
    for nm in names(mod; all=true)
        if isdefined(mod, nm)
            obj = getfield(mod, nm)
            if isa(obj, Module)
                obj in visiting && continue
                val = traverse(val, obj, visiting)
            else