Skip to content

Instantly share code, notes, and snippets.

@quinnj

quinnj/output.jl

Created February 26, 2019 05:31
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save quinnj/c7a9e23c5c15abb6e6180dbdb4175e00 to your computer and use it in GitHub Desktop.
Save quinnj/c7a9e23c5c15abb6e6180dbdb4175e00 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
output.jl
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