Skip to content

Instantly share code, notes, and snippets.

@quinnj
Created Feb 26, 2019
Embed
What would you like to do?
julia> code_typed(DataFrame, (typeof(m),); debuginfo=:source)
1-element Array{Any,1}:
CodeInfo(
1 ─── goto #3 if not false
2 ─── nothing::Nothing
3 ┄── %3 = π (false, Const(false, false))
└──── goto #5 if not %3
4 ─── nothing::Nothing
5 ┄── %6 = (DataFrames.applicable)(DataFrames.iterate, x)::Bool
└──── goto #61 if not %6
6 ─── %8 = %new(DataFrames.:(##326#328))::Const(##326#328(), false)
%9 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
%10 = (Base.getfield)(%9, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
%11 = (Base.getfield)(%10, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
%12 = (Base.getfield)(%11, :len)::Int64
%13 = (Base.slt_int)(%12, 1)::Bool
└──── goto #8 if not %13
7 ─── goto #9
8 ─── %16 = (Base.getfield)(%11, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
└──── goto #9
9 ┄── %18 = φ (#7 => true, #8 => false)::Bool
%19 = φ (#8 => %16)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%20 = φ (#8 => 1)::Int64
%21 = φ (#8 => %16)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%22 = φ (#8 => 1)::Int64
%23 = φ (#8 => %16)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%24 = φ (#8 => 1)::Int64
└──── goto #10
10 ── goto #12 if not %18
11 ── goto #13
12 ── %28 = (getfield)(%19, :a)::Array{Float64,1}
%29 = (Base.arrayref)(true, %28, %20)::Float64
%30 = (getfield)(%21, :b)::Array{Float64,1}
%31 = (Base.arrayref)(true, %30, %22)::Float64
%32 = (getfield)(%23, :c)::Array{Float64,1}
%33 = (Base.arrayref)(true, %32, %24)::Float64
%34 = %new(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, %29, %31, %33)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└──── goto #13
13 ┄─ %36 = φ (#11 => true, #12 => false)::Bool
%37 = φ (#12 => %34)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└──── goto #14
14 ── goto #15
15 ── goto #17 if not %36
16 ── goto #18
17 ── goto #18
18 ┄─ %43 = φ (#16 => true, #17 => false)::Bool
%44 = φ (#17 => %37)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%45 = (Base.not_int)(%43)::Bool
└──── goto #20 if not %45
19 ── invoke %8(%44::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}})::Bool
└──── goto #21
20 ── goto #21
21 ┄─ %50 = φ (#19 => false, #20 => true)::Bool
└──── goto #22
22 ── goto #61 if not %50
23 ── goto #37 if not true
24 ┄─ %54 = φ (#23 => (Base.IsInfinite(), 2), #36 => %80)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
%55 = π (%54, Union{Tuple{IsInfinite,Int64}, Tuple{SizeUnknown,Int64}})
%56 = (Core.getfield)(%55, 1)::Union{IsInfinite, SizeUnknown}
%57 = (Core.getfield)(%55, 2)::Int64
%58 = (isa)(%56, IsInfinite)::Bool
└──── goto #26 if not %58
25 ── goto #29
26 ── %61 = (isa)(%56, SizeUnknown)::Bool
└──── goto #28 if not %61
27 ── goto #29
28 ── (Core.throw)(ErrorException("fatal error in type inference (type bound)"))::Union{}
└──── $(Expr(:unreachable))::Union{}
29 ┄─ %66 = (Base.sle_int)(1, %57)::Bool
└──── goto #31 if not %66
30 ── %68 = (Base.sle_int)(%57, 2)::Bool
└──── goto #32
31 ── nothing::Nothing
32 ┄─ %71 = φ (#30 => %68, #31 => false)::Bool
└──── goto #34 if not %71
33 ── %73 = (Base.getfield)((IsInfinite(), SizeUnknown()), %57, false)::Union{IsInfinite, SizeUnknown}
%74 = (Base.add_int)(%57, 1)::Int64
%75 = (Core.tuple)(%73, %74)::Tuple{Union{IsInfinite, SizeUnknown},Int64}
└──── goto #35
34 ── %77 = Base.nothing::Nothing
└──── goto #35
35 ┄─ %79 = φ (#33 => false, #34 => true)::Bool
%80 = φ (#33 => %75, #34 => %77)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
%81 = (Base.not_int)(%79)::Bool
└──── goto #37 if not %81
36 ── goto #24
37 ┄─ goto #38
38 ── goto #39
39 ── goto #40
40 ── goto #42 if not false
41 ── nothing::Nothing
42 ┄─ goto #44 if not false
43 ── nothing::Nothing
44 ┄─ %91 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
%92 = (Base.getfield)(%91, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
%93 = (Base.getfield)(%92, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
%94 = (Base.getfield)(%93, :len)::Int64
%95 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{AbstractArray{T,1} where T,1}, svec(Any, Int64), :(:ccall), 2, Array{AbstractArray{T,1} where T,1}, :(%94), :(%94)))::Array{AbstractArray{T,1} where T,1}
│ (Base.arraysize)(%95, 1)::Int64
%97 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
%98 = (Base.getfield)(%97, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
%99 = (Base.getfield)(%98, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
%100 = (Base.getfield)(%99, :len)::Int64
%101 = (Base.slt_int)(%100, 1)::Bool
└──── goto #46 if not %101
45 ── goto #47
46 ── %104 = (Base.getfield)(%99, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
└──── goto #47
47 ┄─ %106 = φ (#45 => true, #46 => false)::Bool
%107 = φ (#46 => %104)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%108 = φ (#46 => 1)::Int64
%109 = φ (#46 => %104)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%110 = φ (#46 => 1)::Int64
%111 = φ (#46 => %104)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%112 = φ (#46 => 1)::Int64
└──── goto #48
48 ── goto #50 if not %106
49 ── goto #51
50 ── %116 = (getfield)(%107, :a)::Array{Float64,1}
│ (Base.arrayref)(true, %116, %108)::Float64
%118 = (getfield)(%109, :b)::Array{Float64,1}
│ (Base.arrayref)(true, %118, %110)::Float64
%120 = (getfield)(%111, :c)::Array{Float64,1}
%121 = (Base.arrayref)(true, %120, %112)::Float64
└──── goto #51
51 ┄─ %123 = φ (#49 => true, #50 => false)::Bool
%124 = φ (#50 => %121)::Float64
└──── goto #52
52 ── goto #53
53 ── goto #55 if not %123
54 ── goto #56
55 ── goto #56
56 ┄─ %130 = φ (#54 => true, #55 => false)::Bool
%131 = φ (#55 => %124)::Float64
%132 = (Base.not_int)(%130)::Bool
└──── goto #60 if not %132
57 ── goto #59 if not false
58 ── nothing::Nothing
59 ┄─ invoke Base.setindex!(%95::Array{AbstractArray{T,1} where T,1}, %131::Float64, 1::Int64)::Union{}
└──── $(Expr(:unreachable))::Union{}
60 ┄─ %138 = %new(Generator{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6},typeof(first)}, first, x)::Generator{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6},typeof(first)}
%139 = invoke Base.collect(%138::Base.Generator{QueryOperators.EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},QueryOperators.EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},getfield(Main, Symbol("##4#6"))},typeof(first)})::Array{Float64,1}
│ (DataFrames.DataFrame)(%95, %139)::Union{}
└──── $(Expr(:unreachable))::Union{}
61 ┄─ %142 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
%143 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│ (Core._apply)(Core.apply_type, %142, %143)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
%145 = (Base.getfield)(typeof(iterate), :name)::TypeName
%146 = (Base.getfield)(%145, :mt)::Any
%147 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%146), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
%148 = (Core.sext_int)(Core.Int64, %147)::Int64
%149 = (%148 === 0)::Bool
%150 = (Base.not_int)(%149)::Bool
└──── goto #63 if not %150
62 ── (NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}} <: TableTraits.NamedTuple)::Bool
└──── goto #64
63 ── goto #64
64 ┄─ %155 = φ (#62 => true, #63 => false)::Bool
└──── goto #66 if not %155
65 ── goto #67
66 ── %158 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
%159 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│ (Core._apply)(Core.apply_type, %158, %159)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
%161 = (Base.getfield)(typeof(iterate), :name)::TypeName
%162 = (Base.getfield)(%161, :mt)::Any
%163 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%162), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
%164 = (Core.sext_int)(Core.Int64, %163)::Int64
%165 = (%164 === 0)::Bool
%166 = (Base.not_int)(%165)::Bool
└──── goto #67
67 ┄─ %168 = φ (#65 => %155, #66 => %166)::Bool
└──── goto #144 if not %168
68 ── %170 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
%171 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│ (Core._apply)(Core.apply_type, %170, %171)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
%173 = (Base.getfield)(typeof(iterate), :name)::TypeName
%174 = (Base.getfield)(%173, :mt)::Any
%175 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%174), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
%176 = (Core.sext_int)(Core.Int64, %175)::Int64
%177 = (%176 === 0)::Bool
%178 = (Base.not_int)(%177)::Bool
└──── goto #70 if not %178
69 ── (NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}} <: TableTraits.NamedTuple)::Bool
└──── goto #71
70 ── goto #71
71 ┄─ %183 = φ (#69 => true, #70 => false)::Bool
└──── goto #73 if not %183
72 ── goto #74
73 ── %186 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
%187 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│ (Core._apply)(Core.apply_type, %186, %187)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
%189 = (Base.getfield)(typeof(iterate), :name)::TypeName
%190 = (Base.getfield)(%189, :mt)::Any
%191 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%190), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
%192 = (Core.sext_int)(Core.Int64, %191)::Int64
%193 = (%192 === 0)::Bool
%194 = (Base.not_int)(%193)::Bool
└──── goto #74
74 ┄─ %196 = φ (#72 => %183, #73 => %194)::Bool
└──── goto #142 if not %196
75 ── %198 = (Core.tuple)(Base.Tuple, typeof(iterate))::Tuple{DataType,DataType}
%199 = (Base.getfield)(Tuple{EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, :parameters)::SimpleVector
│ (Core._apply)(Core.apply_type, %198, %199)::Type{Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}}
%201 = (Base.getfield)(typeof(iterate), :name)::TypeName
%202 = (Base.getfield)(%201, :mt)::Any
%203 = $(Expr(:foreigncall, :(:jl_method_exists), Int32, svec(Any, Any, UInt64), :(:ccall), 3, :(%202), Tuple{typeof(iterate),EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},##4#6}}, 0xffffffffffffffff, 0xffffffffffffffff))::Int32
%204 = (Core.sext_int)(Core.Int64, %203)::Int64
%205 = (%204 === 0)::Bool
%206 = (Base.not_int)(%205)::Bool
%207 = (Base.not_int)(%206)::Bool
└──── goto #77 if not %207
76 ── invoke IteratorInterfaceExtensions.error("Can't get iterator for non iterable source."::String)::Union{}
└──── $(Expr(:unreachable))::Union{}
77 ┄─ goto #78
78 ── (NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}} <: Tables.NamedTuple)::Bool
└──── goto #92 if not true
79 ┄─ %214 = φ (#78 => (Base.IsInfinite(), 2), #91 => %240)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
%215 = π (%214, Union{Tuple{IsInfinite,Int64}, Tuple{SizeUnknown,Int64}})
%216 = (Core.getfield)(%215, 1)::Union{IsInfinite, SizeUnknown}
%217 = (Core.getfield)(%215, 2)::Int64
%218 = (isa)(%216, IsInfinite)::Bool
└──── goto #81 if not %218
80 ── goto #84
81 ── %221 = (isa)(%216, SizeUnknown)::Bool
└──── goto #83 if not %221
82 ── goto #84
83 ── (Core.throw)(ErrorException("fatal error in type inference (type bound)"))::Union{}
└──── $(Expr(:unreachable))::Union{}
84 ┄─ %226 = (Base.sle_int)(1, %217)::Bool
└──── goto #86 if not %226
85 ── %228 = (Base.sle_int)(%217, 2)::Bool
└──── goto #87
86 ── nothing::Nothing
87 ┄─ %231 = φ (#85 => %228, #86 => false)::Bool
└──── goto #89 if not %231
88 ── %233 = (Base.getfield)((IsInfinite(), SizeUnknown()), %217, false)::Union{IsInfinite, SizeUnknown}
%234 = (Base.add_int)(%217, 1)::Int64
%235 = (Core.tuple)(%233, %234)::Tuple{Union{IsInfinite, SizeUnknown},Int64}
└──── goto #90
89 ── %237 = Base.nothing::Nothing
└──── goto #90
90 ┄─ %239 = φ (#88 => false, #89 => true)::Bool
%240 = φ (#88 => %235, #89 => %237)::Union{Nothing, Tuple{Union{IsInfinite, SizeUnknown},Int64}}
%241 = (Base.not_int)(%239)::Bool
└──── goto #92 if not %241
91 ── goto #79
92 ┄─ goto #93
93 ── goto #94
94 ── goto #95
95 ── %247 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
%248 = (Base.getfield)(%247, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
%249 = (Base.getfield)(%248, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
%250 = (Base.getfield)(%249, :len)::Int64
%251 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), :(:ccall), 2, Array{Float64,1}, :(%250), :(%250)))::Array{Float64,1}
%252 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), :(:ccall), 2, Array{Float64,1}, :(%250), :(%250)))::Array{Float64,1}
%253 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), :(:ccall), 2, Array{Float64,1}, :(%250), :(%250)))::Array{Float64,1}
%254 = %new(NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}, %251, %252, %253)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%255 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
%256 = (Base.getfield)(%255, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
%257 = (Base.getfield)(%256, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
%258 = (Base.getfield)(%257, :len)::Int64
%259 = (Base.slt_int)(%258, 1)::Bool
└──── goto #97 if not %259
96 ── goto #98
97 ── %262 = (Base.getfield)(%257, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
└──── goto #98
98 ┄─ %264 = φ (#96 => true, #97 => false)::Bool
%265 = φ (#97 => 2)::Int64
%266 = φ (#97 => %262)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%267 = φ (#97 => 1)::Int64
%268 = φ (#97 => %262)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%269 = φ (#97 => 1)::Int64
%270 = φ (#97 => %262)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%271 = φ (#97 => 1)::Int64
└──── goto #99
99 ── goto #101 if not %264
100 ─ goto #102
101%275 = (getfield)(%266, :a)::Array{Float64,1}
%276 = (Base.arrayref)(true, %275, %267)::Float64
%277 = (getfield)(%268, :b)::Array{Float64,1}
%278 = (Base.arrayref)(true, %277, %269)::Float64
%279 = (getfield)(%270, :c)::Array{Float64,1}
%280 = (Base.arrayref)(true, %279, %271)::Float64
%281 = %new(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, %276, %278, %280)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└──── goto #102
102%283 = φ (#100 => true, #101 => false)::Bool
%284 = φ (#101 => %281)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%285 = φ (#101 => %265)::Int64
└──── goto #103
103 ─ goto #104
104 ─ goto #106 if not %283
105 ─ goto #107
106 ─ goto #107
107%291 = φ (#105 => true, #106 => false)::Bool
%292 = φ (#106 => %284)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%293 = φ (#106 => %285)::Int64
└──── goto #109 if not %291
108 ─ goto #110
109 ─ invoke Base.fieldcount(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}::Any)::Any
%297 = (Base.getfield)(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, :parameters)::SimpleVector
│ invoke Base.getindex(%297::Core.SimpleVector, 1::Int64)::Tuple{Symbol,Symbol,Symbol}
%299 = (Base.getfield)(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, :parameters)::SimpleVector
│ invoke Base.getindex(%299::Core.SimpleVector, 1::Int64)::Tuple{Symbol,Symbol,Symbol}
└──── goto #110
110%302 = φ (#108 => true, #109 => false)::Bool
%303 = φ (#109 => %292)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%304 = φ (#109 => %293)::Int64
%305 = φ (#108 => true)::Bool
└──── goto #112 if not %302
111 ─ goto #113
112 ─ goto #113
113%309 = φ (#111 => %305, #112 => false)::Bool
%310 = φ (#112 => 1)::Int64
%311 = φ (#112 => %303)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%312 = φ (#112 => 2)::Int64
%313 = φ (#112 => %304)::Int64
└──── goto #114
114%315 = (Base.not_int)(%309)::Bool
└──── goto #140 if not %315
115%317 = φ (#114 => %310, #139 => %391)::Int64
%318 = φ (#114 => %311, #139 => %392)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%319 = φ (#114 => %312, #139 => %393)::Int64
%320 = φ (#114 => %313, #139 => %394)::Int64
└──── goto #121 if not true
116%322 = φ (#115 => 0, #120 => %335)::Int64
%323 = φ (#115 => 0, #120 => %336)::Int64
%324 = (Base.add_int)(1, %322)::Int64
%325 = (Base.getfield)((:a, :b, :c), %324, false)::Symbol
%326 = (getfield)(%318, %325)::Float64
%327 = (Base.add_int)(1, %322)::Int64
%328 = (Base.getfield)(%254, %327)::Array{Float64,1}
│ (Base.arrayset)(true, %328, %326, %317)::Array{Float64,1}
%330 = (%323 === 2)::Bool
└──── goto #118 if not %330
117 ─ goto #119
118%333 = (Base.add_int)(%323, 1)::Int64
└──── goto #119
119%335 = φ (#118 => %333)::Int64
%336 = φ (#118 => %333)::Int64
%337 = φ (#117 => true, #118 => false)::Bool
%338 = (Base.not_int)(%337)::Bool
└──── goto #121 if not %338
120 ─ goto #116
121 ┄ goto #122
122%342 = (Base.getfield)(x, :source)::EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}}
%343 = (Base.getfield)(%342, :source)::DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}
%344 = (Base.getfield)(%343, :x)::RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}
%345 = (Base.getfield)(%344, :len)::Int64
%346 = (Base.slt_int)(%345, %320)::Bool
└──── goto #124 if not %346
123 ─ goto #125
124%349 = (Base.getfield)(%344, :columns)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%350 = (Base.add_int)(%320, 1)::Int64
└──── goto #125
125%352 = φ (#123 => true, #124 => false)::Bool
%353 = φ (#124 => %350)::Int64
%354 = φ (#124 => %349)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%355 = φ (#124 => %320)::Int64
%356 = φ (#124 => %349)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%357 = φ (#124 => %320)::Int64
%358 = φ (#124 => %349)::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}
%359 = φ (#124 => %320)::Int64
└──── goto #127 if not %352
126 ─ goto #128
127%362 = (getfield)(%354, :a)::Array{Float64,1}
%363 = (Base.arrayref)(true, %362, %355)::Float64
%364 = (getfield)(%356, :b)::Array{Float64,1}
%365 = (Base.arrayref)(true, %364, %357)::Float64
%366 = (getfield)(%358, :c)::Array{Float64,1}
%367 = (Base.arrayref)(true, %366, %359)::Float64
%368 = %new(NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}, %363, %365, %367)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
└──── goto #128
128%370 = φ (#126 => true, #127 => false)::Bool
%371 = φ (#127 => %368)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%372 = φ (#127 => %353)::Int64
└──── goto #129
129 ─ goto #131 if not %370
130 ─ goto #132
131 ─ goto #132
132%377 = φ (#130 => true, #131 => false)::Bool
%378 = φ (#131 => %371)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%379 = φ (#131 => %372)::Int64
└──── goto #134 if not %377
133 ─ goto #135
134 ─ goto #135
135%383 = φ (#133 => true, #134 => false)::Bool
%384 = φ (#134 => %378)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%385 = φ (#134 => %379)::Int64
%386 = φ (#133 => true)::Bool
└──── goto #137 if not %383
136 ─ goto #138
137%389 = (Base.add_int)(%319, 1)::Int64
└──── goto #138
138%391 = φ (#137 => %319)::Int64
%392 = φ (#137 => %384)::NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}}
%393 = φ (#137 => %389)::Int64
%394 = φ (#137 => %385)::Int64
%395 = φ (#136 => %386, #137 => false)::Bool
%396 = (Base.not_int)(%395)::Bool
└──── goto #140 if not %396
139 ─ goto #115
140 ┄ goto #141
141 ─ goto #143
142%401 = invoke Base.print_to_string("no default `Tables.columns` implementation for type: "::String, QueryOperators.EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},QueryOperators.EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},getfield(Main, Symbol("##4#6"))}::Vararg{Any,N} where N)::String
%402 = %new(Core.ArgumentError, %401)::ArgumentError
│ (Tables.throw)(%402)::Union{}
└──── $(Expr(:unreachable))::Union{}
143%405 = invoke DataFrames.fromcolumns(%254::NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}})::DataFrame
└──── return %405
144%407 = invoke Base.print_to_string("unable to construct DataFrame from "::String, QueryOperators.EnumerableMap{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},QueryOperators.EnumerableIterable{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.DataValueRowIterator{NamedTuple{(:a, :b, :c),Tuple{Float64,Float64,Float64}},Tables.RowIterator{NamedTuple{(:a, :b, :c),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}}}},getfield(Main, Symbol("##4#6"))}::Vararg{Any,N} where N)::String
%408 = %new(Core.ArgumentError, %407)::ArgumentError
│ (DataFrames.throw)(%408)::Union{}
└──── $(Expr(:unreachable))::Union{}
) => DataFrame
julia>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment