existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi) # this is wrong, since depending on the return value # of type-inference is very brittle (as

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi) # this is wrong, since depending on the return value # of type-inference is very brittle (as

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi) # this is wrong, since depending on the return value # of type-inference is very brittle (as

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi) # this is wrong, since depending on the return value # of type-inference is very brittle (as

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi)CHAPTER 13. METHODS 173 # this is wrong, since depending on the return value # of type-inference

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * biCHAPTER 12. METHODS 163 ## this is insufficient because it assumes `one(eltype(a))` `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi) # this is wrong, since depending on the return value # of type-inference is very brittle (as

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * biCHAPTER 12. METHODS 163 ## this is insufficient because it assumes `one(eltype(a))` `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi) # this is wrong, since depending on the return value # of type-inference is very brittle (as

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi)CHAPTER 13. METHODS 172 # this is wrong, since depending on the return value # of type-inference

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi)CHAPTER 13. METHODS 172 # this is wrong, since depending on the return value # of type-inference

existing global variable. This addresses both issues while preserving the "programming at scale" benefits of the 1.0 behavior: global variables have no spooky effect on the meaning of code that may be pseudo-code might look like: function matmul(a::AbstractMatrix, b::AbstractMatrix) op = (ai, bi) -> ai * bi + ai * bi ## this is insufficient because it assumes `one(eltype(a))` is constructable: # R `+` calls `promote_type` ## but this is not true for some types, such as Bool: # R = promote_type(ai, bi)CHAPTER 13. METHODS 172 # this is wrong, since depending on the return value # of type-inference