Package evaluation to load CESFunctions on Julia 1.14.0-DEV.2226 (797a5ef2b0*) started at 2026-05-23T19:22:17.327 ################################################################################ # Set-up # Set-up completed after 0.11s ################################################################################ # Installation # Installing CESFunctions... Resolving package versions... Installed DocStringExtensions ─ v0.9.5 Installed StaticArraysCore ──── v1.4.4 Installed Preferences ───────── v1.5.2 Installed ArgCheck ──────────── v2.5.0 Installed StaticArrays ──────── v1.9.18 Installed PrecompileTools ───── v1.3.4 Installed CESFunctions ──────── v0.2.0 Updating `~/.julia/environments/v1.14/Project.toml` [41fc9631] + CESFunctions v0.2.0 Updating `~/.julia/environments/v1.14/Manifest.toml` [dce04be8] + ArgCheck v2.5.0 [41fc9631] + CESFunctions v0.2.0 [ffbed154] + DocStringExtensions v0.9.5 [aea7be01] + PrecompileTools v1.3.4 [21216c6a] + Preferences v1.5.2 [90137ffa] + StaticArrays v1.9.18 [1e83bf80] + StaticArraysCore v1.4.4 [56f22d72] + Artifacts v1.11.0 [ade2ca70] + Dates v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.13.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [fa267f1f] + TOML v1.0.3 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.1+0 [4536629a] + OpenBLAS_jll v0.3.33+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Installation completed after 5.89s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Project No packages added to or removed from `~/.julia/environments/pkgeval/Project.toml` Manifest No packages added to or removed from `~/.julia/environments/pkgeval/Manifest.toml` Precompiling package dependencies... Precompiling project... 0.9 s ✓ StaticArraysCore 0.8 s ✓ ArgCheck 1.0 s ✓ DocStringExtensions 2.3 s ✓ Preferences 2.4 s ✓ PrecompileTools 300.1 s ✓ StaticArrays ┌ Info: JuliaLowering threw given input: │ code = │ :(struct CESProduction{N, T} │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:22 =# │ "elasticity of substitution" │ σ::T │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:24 =# │ "share parameters, >0, sum to 1" │ A::NTuple{N, T} │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =# @doc "$(SIGNATURES)\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n" function CESProduction(σ::T, A::NTuple{N, T}) where {N, T <: Real} │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:55 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =# @argcheck N > 0 │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =# @argcheck all((a->begin │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =# │ a > 0 │ end), A) │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =# @argcheck sum(A) ≈ 1 │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =# @argcheck σ > 0 │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:60 =# │ new{N, T}(σ, A) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [struct] │ │ false :: Value │ │ [curly] │ │ CESProduction :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ [block] │ │ "elasticity of substitution" :: Value │ │ [::] │ │ σ :: Identifier │ │ T :: Identifier │ │ "share parameters, >0, sum to 1" :: Value │ │ [::] │ │ A :: Identifier │ │ [curly] │ │ NTuple :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =#) :: Value │ │ [string] │ │ SIGNATURES :: Identifier │ │ "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ CESProduction :: Identifier │ │ [::] │ │ σ :: Identifier │ │ T :: Identifier │ │ [::] │ │ A :: Identifier │ │ [curly] │ │ NTuple :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ N :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [block] │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ N :: Identifier │ │ 0 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) :: Value │ │ [call] │ │ all :: Identifier │ │ [->] │ │ a :: Identifier │ │ [block] │ │ [call] │ │ > :: Identifier │ │ a :: Identifier │ │ 0 :: Value │ │ A :: Identifier │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) :: Value │ │ [call] │ │ ≈ :: Identifier │ │ [call] │ │ sum :: Identifier │ │ A :: Identifier │ │ 1 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ σ :: Identifier │ │ 0 :: Value │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ σ :: Identifier │ │ A :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [struct] │ │ false :: Value │ │ [curly] │ │ CESProduction :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ "elasticity of substitution" :: Value │ │ [::] │ │ σ :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ "share parameters, >0, sum to 1" :: Value │ │ [::] │ │ A :: Identifier │ scope_layer=1 │ [curly] │ │ NTuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [function] │ │ [where] │ │ [call] │ │ CESProduction :: Identifier │ scope_layer=1 │ [::] │ │ σ :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [::] │ │ A :: Identifier │ scope_layer=1 │ [curly] │ │ NTuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [block] │ │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #1###calle#998 :: Identifier │ scope_layer=1 │ > :: Identifier │ scope_layer=1 │ [=] │ │ #2###arg#996 :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [=] │ │ #3###arg#997 :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=83 │ [if] │ │ [call] │ │ #1###calle#998 :: Identifier │ scope_layer=1 │ #2###arg#996 :: Identifier │ scope_layer=1 │ #3###arg#997 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ > :: Identifier │ │ N :: Identifier │ │ 0 :: Value │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:>, :N, 0] :: Value │ │ [vect] │ │ #1###calle#998 :: Identifier │ scope_layer=1 │ #2###arg#996 :: Identifier │ scope_layer=1 │ #3###arg#997 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #4###calle#1001 :: Identifier │ scope_layer=1 │ all :: Identifier │ scope_layer=1 │ [=] │ │ #5###arg#999 :: Identifier │ scope_layer=1 │ [->] │ │ a :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ > :: Identifier │ scope_layer=1 │ a :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=83 │ [=] │ │ #6###arg#1000 :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ #4###calle#1001 :: Identifier │ scope_layer=1 │ #5###arg#999 :: Identifier │ scope_layer=1 │ #6###arg#1000 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ all :: Identifier │ │ [->] │ │ a :: Identifier │ │ [block] │ │ [call] │ │ > :: Identifier │ │ a :: Identifier │ │ 0 :: Value │ │ A :: Identifier │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:all, :(a->begin │ a > 0 │ end), :A] :: Value │ │ [vect] │ │ #4###calle#1001 :: Identifier │ scope_layer=1 │ #5###arg#999 :: Identifier │ scope_layer=1 │ #6###arg#1000 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #7###calle#1004 :: Identifier │ scope_layer=1 │ ≈ :: Identifier │ scope_layer=1 │ [=] │ │ #8###arg#1002 :: Identifier │ scope_layer=1 │ [call] │ │ sum :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [=] │ │ #9###arg#1003 :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=83 │ [if] │ │ [call] │ │ #7###calle#1004 :: Identifier │ scope_layer=1 │ #8###arg#1002 :: Identifier │ scope_layer=1 │ #9###arg#1003 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ ≈ :: Identifier │ │ [call] │ │ sum :: Identifier │ │ A :: Identifier │ │ 1 :: Value │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:≈, :(sum(A)), 1] :: Value │ │ [vect] │ │ #7###calle#1004 :: Identifier │ scope_layer=1 │ #8###arg#1002 :: Identifier │ scope_layer=1 │ #9###arg#1003 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #10###calle#1007 :: Identifier │ scope_layer=1 │ > :: Identifier │ scope_layer=1 │ [=] │ │ #11###arg#1005 :: Identifier │ scope_layer=1 │ σ :: Identifier │ scope_layer=1 │ [=] │ │ #12###arg#1006 :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=83 │ [if] │ │ [call] │ │ #10###calle#1007 :: Identifier │ scope_layer=1 │ #11###arg#1005 :: Identifier │ scope_layer=1 │ #12###arg#1006 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ > :: Identifier │ │ σ :: Identifier │ │ 0 :: Value │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:>, :σ, 0] :: Value │ │ [vect] │ │ #10###calle#1007 :: Identifier │ scope_layer=1 │ #11###arg#1005 :: Identifier │ scope_layer=1 │ #12###arg#1006 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ σ :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=83 │ CESFunctions :: Value │ macro_source=83 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=83 │ CESFunctions :: Value │ │ [inert] │ jl_source=L65 │ CESProduction :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=83 │ [call] │ │ Core.svec :: Value │ macro_source=83 │ [call] │ │ DocStringExtensions.interpolation :: Value │ macro_source=83 │ SIGNATURES :: Identifier │ scope_layer=1 │ [inert] │ │ [function] │ │ [where] │ │ [call] │ │ CESProduction :: Identifier │ │ [::] │ │ σ :: Identifier │ │ T :: Identifier │ │ [::] │ │ A :: Identifier │ │ [curly] │ │ NTuple :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ N :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [block] │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ N :: Identifier │ │ 0 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) :: Value │ │ [call] │ │ all :: Identifier │ │ [->] │ │ a :: Identifier │ │ [block] │ │ [call] │ │ > :: Identifier │ │ a :: Identifier │ │ 0 :: Value │ │ A :: Identifier │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) :: Value │ │ [call] │ │ ≈ :: Identifier │ │ [call] │ │ sum :: Identifier │ │ A :: Identifier │ │ 1 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ σ :: Identifier │ │ 0 :: Value │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ σ :: Identifier │ │ A :: Identifier │ │ "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n" :: Value │ macro_source=83 │ [call] │ macro_source=83 │ Dict{Symbol, Any} :: Value │ macro_source=83 │ :path => "/home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl" :: Value │ macro_source=83 │ :linenumber => 26 :: Value │ macro_source=83 │ :module => CESFunctions :: Value │ macro_source=83 │ [where] │ │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ NTuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl" │ line = 21 └ mod = CESFunctions ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =# - assignment syntax in structure fields is reserved Expression:  (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> (tuple a) (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A)))) Containing expressions:  (struct false (curly CESProduction N T) (block "elasticity of substitution" (:: σ T) "share parameters, >0, sum to 1" (:: A (curly NTuple N T)) (block (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> (tuple a) (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A)))) (call Base.Docs.doc! CESFunctions (call Base.Docs.Binding CESFunctions :CESProduction) (call Base.Docs.docstr (call Core.svec (call DocStringExtensions.interpolation SIGNATURES (inert (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) (call > N 0)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) (call all (-> a (block (call > a 0))) A)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) (call ≈ (call sum A) 1)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) (call > σ 0)) (call (curly new N T) σ A))))) "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl" :linenumber => 26 :module => CESFunctions)) (where (where (curly Union (curly Tuple T (curly NTuple N T)) (curly Tuple T) (curly Tuple N)) (<: T Real)) (<: N Any))) val)))  Detailed provenance:  (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> (tuple a) (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A))))  └─ (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> a (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A))))  └─ (= val (escape (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> a (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A)))))  ├─ @ /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =#) (string SIGNATURES "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n") (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) (call > N 0)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) (call all (-> a (block (call > a 0))) A)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) (call ≈ (call sum A) 1)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) (call > σ 0)) (call (curly new N T) σ A))))  └─ @ /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26  Stacktrace:  [1] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3184  [2] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3181  [3] expand_struct_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3754  [4] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4336  [5] Dict{Int64, Int64}()  @ Base /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]  [6] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4469  [7] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [8] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [9] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base ./loading.jl:3271  [10] top-level scope  @ stdin:5  [11] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [12] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [13] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [14] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [15] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:1 in expression starting at stdin:5 ✗ CESFunctions 6 dependencies successfully precompiled in 346 seconds. 4 already precompiled. Precompilation completed after 363.98s ################################################################################ # Loading # Loading CESFunctions... ┌ Info: JuliaLowering threw given input: │ code = │ :(struct CESProduction{N, T} │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:22 =# │ "elasticity of substitution" │ σ::T │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:24 =# │ "share parameters, >0, sum to 1" │ A::NTuple{N, T} │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =# @doc "$(SIGNATURES)\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n" function CESProduction(σ::T, A::NTuple{N, T}) where {N, T <: Real} │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:55 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =# @argcheck N > 0 │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =# @argcheck all((a->begin │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =# │ a > 0 │ end), A) │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =# @argcheck sum(A) ≈ 1 │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =# │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =# @argcheck σ > 0 │ #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:60 =# │ new{N, T}(σ, A) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [struct] │ │ false :: Value │ │ [curly] │ │ CESProduction :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ [block] │ │ "elasticity of substitution" :: Value │ │ [::] │ │ σ :: Identifier │ │ T :: Identifier │ │ "share parameters, >0, sum to 1" :: Value │ │ [::] │ │ A :: Identifier │ │ [curly] │ │ NTuple :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ [macrocall] │ │ @doc :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =#) :: Value │ │ [string] │ │ SIGNATURES :: Identifier │ │ "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ CESProduction :: Identifier │ │ [::] │ │ σ :: Identifier │ │ T :: Identifier │ │ [::] │ │ A :: Identifier │ │ [curly] │ │ NTuple :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ N :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [block] │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ N :: Identifier │ │ 0 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) :: Value │ │ [call] │ │ all :: Identifier │ │ [->] │ │ a :: Identifier │ │ [block] │ │ [call] │ │ > :: Identifier │ │ a :: Identifier │ │ 0 :: Value │ │ A :: Identifier │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) :: Value │ │ [call] │ │ ≈ :: Identifier │ │ [call] │ │ sum :: Identifier │ │ A :: Identifier │ │ 1 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ σ :: Identifier │ │ 0 :: Value │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ σ :: Identifier │ │ A :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [struct] │ │ false :: Value │ │ [curly] │ │ CESProduction :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ "elasticity of substitution" :: Value │ │ [::] │ │ σ :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ "share parameters, >0, sum to 1" :: Value │ │ [::] │ │ A :: Identifier │ scope_layer=1 │ [curly] │ │ NTuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [function] │ │ [where] │ │ [call] │ │ CESProduction :: Identifier │ scope_layer=1 │ [::] │ │ σ :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [::] │ │ A :: Identifier │ scope_layer=1 │ [curly] │ │ NTuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [block] │ │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #1###calle#998 :: Identifier │ scope_layer=1 │ > :: Identifier │ scope_layer=1 │ [=] │ │ #2###arg#996 :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [=] │ │ #3###arg#997 :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=83 │ [if] │ │ [call] │ │ #1###calle#998 :: Identifier │ scope_layer=1 │ #2###arg#996 :: Identifier │ scope_layer=1 │ #3###arg#997 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ > :: Identifier │ │ N :: Identifier │ │ 0 :: Value │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:>, :N, 0] :: Value │ │ [vect] │ │ #1###calle#998 :: Identifier │ scope_layer=1 │ #2###arg#996 :: Identifier │ scope_layer=1 │ #3###arg#997 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #4###calle#1001 :: Identifier │ scope_layer=1 │ all :: Identifier │ scope_layer=1 │ [=] │ │ #5###arg#999 :: Identifier │ scope_layer=1 │ [->] │ │ a :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ > :: Identifier │ scope_layer=1 │ a :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=83 │ [=] │ │ #6###arg#1000 :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ #4###calle#1001 :: Identifier │ scope_layer=1 │ #5###arg#999 :: Identifier │ scope_layer=1 │ #6###arg#1000 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ all :: Identifier │ │ [->] │ │ a :: Identifier │ │ [block] │ │ [call] │ │ > :: Identifier │ │ a :: Identifier │ │ 0 :: Value │ │ A :: Identifier │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:all, :(a->begin │ a > 0 │ end), :A] :: Value │ │ [vect] │ │ #4###calle#1001 :: Identifier │ scope_layer=1 │ #5###arg#999 :: Identifier │ scope_layer=1 │ #6###arg#1000 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #7###calle#1004 :: Identifier │ scope_layer=1 │ ≈ :: Identifier │ scope_layer=1 │ [=] │ │ #8###arg#1002 :: Identifier │ scope_layer=1 │ [call] │ │ sum :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [=] │ │ #9###arg#1003 :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=83 │ [if] │ │ [call] │ │ #7###calle#1004 :: Identifier │ scope_layer=1 │ #8###arg#1002 :: Identifier │ scope_layer=1 │ #9###arg#1003 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ ≈ :: Identifier │ │ [call] │ │ sum :: Identifier │ │ A :: Identifier │ │ 1 :: Value │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:≈, :(sum(A)), 1] :: Value │ │ [vect] │ │ #7###calle#1004 :: Identifier │ scope_layer=1 │ #8###arg#1002 :: Identifier │ scope_layer=1 │ #9###arg#1003 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [meta] │ │ begin_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [block] │ │ [=] │ │ #10###calle#1007 :: Identifier │ scope_layer=1 │ > :: Identifier │ scope_layer=1 │ [=] │ │ #11###arg#1005 :: Identifier │ scope_layer=1 │ σ :: Identifier │ scope_layer=1 │ [=] │ │ #12###arg#1006 :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=83 │ [if] │ │ [call] │ │ #10###calle#1007 :: Identifier │ scope_layer=1 │ #11###arg#1005 :: Identifier │ scope_layer=1 │ #12###arg#1006 :: Identifier │ scope_layer=1 │ [block] │ │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [call] │ │ throw_check_error :: Identifier │ mod,scope_layer=1 │ [call] │ │ CallErrorInfo :: Identifier │ mod,scope_layer=1 │ [inert] │ │ [call] │ │ > :: Identifier │ │ σ :: Identifier │ │ 0 :: Value │ │ ArgCheck.ArgCheckFlavor() :: Value │ macro_source=83 │ [inert] │ │ Any[:>, :σ, 0] :: Value │ │ [vect] │ │ #10###calle#1007 :: Identifier │ scope_layer=1 │ #11###arg#1005 :: Identifier │ scope_layer=1 │ #12###arg#1006 :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=83 │ [meta] │ │ end_optional :: Identifier │ scope_layer=1 │ ArgCheck.LabelArgCheck() :: Value │ macro_source=83 │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ σ :: Identifier │ scope_layer=1 │ A :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=83 │ CESFunctions :: Value │ macro_source=83 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=83 │ CESFunctions :: Value │ │ [inert] │ jl_source=L65 │ CESProduction :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=83 │ [call] │ │ Core.svec :: Value │ macro_source=83 │ [call] │ │ DocStringExtensions.interpolation :: Value │ macro_source=83 │ SIGNATURES :: Identifier │ scope_layer=1 │ [inert] │ │ [function] │ │ [where] │ │ [call] │ │ CESProduction :: Identifier │ │ [::] │ │ σ :: Identifier │ │ T :: Identifier │ │ [::] │ │ A :: Identifier │ │ [curly] │ │ NTuple :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ N :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [block] │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ N :: Identifier │ │ 0 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) :: Value │ │ [call] │ │ all :: Identifier │ │ [->] │ │ a :: Identifier │ │ [block] │ │ [call] │ │ > :: Identifier │ │ a :: Identifier │ │ 0 :: Value │ │ A :: Identifier │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) :: Value │ │ [call] │ │ ≈ :: Identifier │ │ [call] │ │ sum :: Identifier │ │ A :: Identifier │ │ 1 :: Value │ │ [macrocall] │ │ @argcheck :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) :: Value │ │ [call] │ │ > :: Identifier │ │ σ :: Identifier │ │ 0 :: Value │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ N :: Identifier │ │ T :: Identifier │ │ σ :: Identifier │ │ A :: Identifier │ │ "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n" :: Value │ macro_source=83 │ [call] │ macro_source=83 │ Dict{Symbol, Any} :: Value │ macro_source=83 │ :path => "/home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl" :: Value │ macro_source=83 │ :linenumber => 26 :: Value │ macro_source=83 │ :module => CESFunctions :: Value │ macro_source=83 │ [where] │ │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ NTuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl" │ line = 21 └ mod = CESFunctions ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =# - assignment syntax in structure fields is reserved Expression:  (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> (tuple a) (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A)))) Containing expressions:  (struct false (curly CESProduction N T) (block "elasticity of substitution" (:: σ T) "share parameters, >0, sum to 1" (:: A (curly NTuple N T)) (block (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> (tuple a) (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A)))) (call Base.Docs.doc! CESFunctions (call Base.Docs.Binding CESFunctions :CESProduction) (call Base.Docs.docstr (call Core.svec (call DocStringExtensions.interpolation SIGNATURES (inert (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) (call > N 0)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) (call all (-> a (block (call > a 0))) A)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) (call ≈ (call sum A) 1)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) (call > σ 0)) (call (curly new N T) σ A))))) "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n") (call Dict{Symbol, Any} :path => "/home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl" :linenumber => 26 :module => CESFunctions)) (where (where (curly Union (curly Tuple T (curly NTuple N T)) (curly Tuple T) (curly Tuple N)) (<: T Real)) (<: N Any))) val)))  Detailed provenance:  (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> (tuple a) (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (block (meta :begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta :end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A))))  └─ (= val (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> a (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A))))  └─ (= val (escape (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #1###calle#998 >) (= #2###arg#996 N) (= #3###arg#997 0) (if (call #1###calle#998 #2###arg#996 #3###arg#997) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > N 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :N, 0]) (vect #1###calle#998 #2###arg#996 #3###arg#997) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #4###calle#1001 all) (= #5###arg#999 (-> a (block (call > a 0)))) (= #6###arg#1000 A) (if (call #4###calle#1001 #5###arg#999 #6###arg#1000) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call all (-> a (block (call > a 0))) A)) ArgCheck.ArgCheckFlavor() (inert Any[:all, :(a->begin  a > 0  end), :A]) (vect #4###calle#1001 #5###arg#999 #6###arg#1000) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #7###calle#1004 ≈) (= #8###arg#1002 (call sum A)) (= #9###arg#1003 1) (if (call #7###calle#1004 #8###arg#1002 #9###arg#1003) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call ≈ (call sum A) 1)) ArgCheck.ArgCheckFlavor() (inert Any[:≈, :(sum(A)), 1]) (vect #7###calle#1004 #8###arg#1002 #9###arg#1003) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (block (meta begin_optional ArgCheck.LabelArgCheck()) (block (= #10###calle#1007 >) (= #11###arg#1005 σ) (= #12###arg#1006 0) (if (call #10###calle#1007 #11###arg#1005 #12###arg#1006) (block nothing) (block (call throw_check_error (call CallErrorInfo (inert (call > σ 0)) ArgCheck.ArgCheckFlavor() (inert Any[:>, :σ, 0]) (vect #10###calle#1007 #11###arg#1005 #12###arg#1006) (tuple)))))) (meta end_optional ArgCheck.LabelArgCheck())) (call (curly new N T) σ A)))))  ├─ @ /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26 =#) (string SIGNATURES "\n\nA constant elasticity of substitution production function of the form\n\n```math\nY = (A_1 X_2^{(σ-1)/σ} + A_2 X_2^{(σ-1)/σ} + ...)^{σ/(σ-1)}\n```\nwhere ``σ``, the *elasticity of substitution*, is required to be positive.\n\nAlternative parametrizations use a substitution parameter ``ρ = (σ - 1)/σ``.\n\n# About the type\n\nFields `σ` and `A` of the result are part of the public API.\n\n`Base.length` can be used to query the length on both values and types.\n\n```jldoctest\njulia> F = CESProduction(0.1, (0.2, 0.8))\nCESProduction{2, Float64}(0.1, (0.2, 0.8))\n\njulia> length(F)\n2\n\njulia> length(typeof(F))\n2\n```\n") (function (where (call CESProduction (:: σ T) (:: A (curly NTuple N T))) N (<: T Real)) (block (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:56 =#) (call > N 0)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:57 =#) (call all (-> a (block (call > a 0))) A)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:58 =#) (call ≈ (call sum A) 1)) (macrocall @argcheck :(#= /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:59 =#) (call > σ 0)) (call (curly new N T) σ A))))  └─ @ /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:26  Stacktrace:  [1] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3184  [2] _collect_struct_fields(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, field_names::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_types::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_attrs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, field_docs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, inner_defs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, exs::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3181  [3] expand_struct_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3754  [4] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4336  [5] Dict{Int64, Int64}()  @ Base /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]  [6] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4469  [7] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:30  [8] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [9] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base ./loading.jl:3271  [10] top-level scope  @ stdin:5  [11] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [12] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [13] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [14] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [15] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/CESFunctions/5t6xR/src/CESFunctions.jl:1 in expression starting at stdin:5 1 dependency had output during precompilation: ┌ CESFunctions │ [Output was shown above] └ ERROR: The following 1 package failed to precompile: CESFunctions Failed to precompile CESFunctions [41fc9631-8896-47d9-8244-cfbf74589b0a] to "/home/pkgeval/.julia/compiled/v1.14/CESFunctions/jl_TLbHOw" (ProcessExited(1)). Loading failed after 48.2s ERROR: LoadError: failed process: Process(`/opt/julia/bin/julia -C native -J/opt/julia/lib/julia/sys.so -g1 --check-bounds=yes --inline=yes --check-bounds=yes --pkgimages=existing -e 'using CESFunctions'`, ProcessExited(1)) [1] Stacktrace: [1] spawn_opts_inherit() @ Base ./process.jl:612 [inlined] [2] run(::Cmd; wait::Bool) @ Base ./process.jl:525 [3] run(::Cmd) @ Base ./process.jl:522 [4] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:197 [5] include(mod::Module, _path::String) @ Base ./Base.jl:326 [6] exec_options(opts::Base.JLOptions) @ Base ./client.jl:355 [7] _start() @ Base ./client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:188 PkgEval failed after 438.5s: package fails to precompile