update and enable precompiles

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.0.14"
+version = "0.29.9"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -22,7 +22,6 @@ Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
-RecipesPipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 Showoff = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
@@ -43,12 +42,11 @@ NaNMath = "0.3"
 PGFPlotsX = "1.2.0"
 PlotThemes = "1"
 PlotUtils = "0.6.5"
-RecipesBase = "1"
-RecipesPipeline = "0.1.1"
+RecipesBase = "0.8"
 Reexport = "0.2"
 Requires = "0.5, 1"
 Showoff = "0.3.1"
-StatsBase = "0.32, 0.33"
+StatsBase = "0.32"
 julia = "1"
 
 [extras]

src/Plots.jl

@@ -1,9 +1,5 @@
 module Plots
 
-if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@optlevel"))
-    @eval Base.Experimental.@optlevel 1
-end
-
 const _current_plots_version = VersionNumber(split(first(filter(line -> occursin("version", line), readlines(normpath(@__DIR__, "..", "Project.toml")))), "\"")[2])
 
 using Reexport
@@ -167,8 +163,9 @@ using .PlotMeasures
 import .PlotMeasures: Length, AbsoluteLength, Measure, width, height
 # ---------------------------------------------------------
 
-import RecipesPipeline
-import RecipesPipeline: SliceIt,
+include("RecipePipeline/RecipePipeline.jl")
+import .RecipePipeline
+import .RecipePipeline: SliceIt,
     DefaultsDict,
     Formatted,
     AbstractSurface,
@@ -177,15 +174,12 @@ import RecipesPipeline: SliceIt,
     is3d,
     is_surface,
     needs_3d_axes,
-    group_as_matrix, # for StatsPlots
+    group_as_matrix,
     reset_kw!,
     pop_kw!,
     scale_func,
     inverse_scale_func,
-    unzip,
-    dateformatter,
-    datetimeformatter,
-    timeformatter
+    unzip
 
 include("types.jl")
 include("utils.jl")

src/RecipePipeline/RecipePipeline.jl

@@ -0,0 +1,97 @@
+module RecipePipeline
+
+import RecipesBase
+import RecipesBase: @recipe, @series, RecipeData, is_explicit
+import PlotUtils # tryrange and adapted_grid
+
+export recipe_pipeline!
+# Plots relies on these:
+export SliceIt,
+    DefaultsDict,
+    Formatted,
+    AbstractSurface,
+    Surface,
+    Volume,
+    is3d,
+    is_surface,
+    needs_3d_axes,
+    group_as_matrix,
+    reset_kw!,
+    pop_kw!,
+    scale_func,
+    inverse_scale_func,
+    unzip
+# API
+export warn_on_recipe_aliases,
+    splittable_attribute,
+    split_attribute,
+    process_userrecipe!,
+    get_axis_limits,
+    is_axis_attribute,
+    type_alias,
+    plot_setup!,
+    slice_series_attributes!
+
+include("api.jl")
+include("utils.jl")
+include("series.jl")
+include("group.jl")
+include("user_recipe.jl")
+include("type_recipe.jl")
+include("plot_recipe.jl")
+include("series_recipe.jl")
+
+
+"""
+    recipe_pipeline!(plt, plotattributes, args)
+
+Recursively apply user recipes, type recipes, plot recipes and series recipes to build a
+list of `Dict`s, each corresponding to a series. At the beginning `plotattributes`
+contains only the keyword arguments passed in by the user. Add all series to the plot
+bject `plt` and return it.
+"""
+function recipe_pipeline!(plt, plotattributes, args)
+    plotattributes[:plot_object] = plt
+
+    # --------------------------------
+    # "USER RECIPES"
+    # --------------------------------
+
+    # process user and type recipes
+    kw_list = _process_userrecipes!(plt, plotattributes, args)
+
+    # --------------------------------
+    # "PLOT RECIPES"
+    # --------------------------------
+
+    # The "Plot recipe" acts like a series type, and is processed before the plot layout
+    # is created, which allows for setting layouts and other plot-wide attributes.
+    # We get inputs which have been fully processed by "user recipes" and "type recipes",
+    # so we can expect standard vectors, surfaces, etc.  No defaults have been set yet.
+
+    kw_list = _process_plotrecipes!(plt, kw_list)
+
+    # --------------------------------
+    # Plot/Subplot/Layout setup
+    # --------------------------------
+
+    plot_setup!(plt, plotattributes, kw_list)
+
+    # At this point, `kw_list` is fully decomposed into individual series... one KW per
+    # series. The next step is to recursively apply series recipes until the backend
+    # supports that series type.
+
+    # --------------------------------
+    # "SERIES RECIPES"
+    # --------------------------------
+
+    _process_seriesrecipes!(plt, kw_list)
+
+    # --------------------------------
+    # Return processed plot object
+    # --------------------------------
+
+    return plt
+end
+
+end

src/RecipePipeline/api.jl

@@ -0,0 +1,142 @@
+## Warnings
+
+"""
+    warn_on_recipe_aliases!(plt, plotattributes, recipe_type, args...)
+
+Warn if an alias is dedected in `plotattributes` after a recipe of type `recipe_type` is
+applied to 'args'. `recipe_type` is either `:user`, `:type`, `:plot` or `:series`.
+"""
+function warn_on_recipe_aliases!(plt, plotattributes, recipe_type, args...) end
+
+
+## Grouping
+
+"""
+    splittable_attribute(plt, key, val, len)
+
+Returns `true` if the attribute `key` with the value `val` can be split into groups with
+group provided as a vector of length `len`, `false` otherwise.
+"""
+splittable_attribute(plt, key, val, len) = false
+splittable_attribute(plt, key, val::AbstractArray, len) =
+    !(key in (:group, :color_palette)) && length(axes(val, 1)) == len
+splittable_attribute(plt, key, val::Tuple, n) = all(splittable_attribute.(key, val, len))
+
+
+"""
+    split_attribute(plt, key, val, indices)
+
+Select the proper indices from `val` for attribute `key`.
+"""
+split_attribute(plt, key, val::AbstractArray, indices) =
+    val[indices, fill(Colon(), ndims(val) - 1)...]
+split_attribute(plt, key, val::Tuple, indices) =
+    Tuple(split_attribute(key, v, indices) for v in val)
+
+
+## Preprocessing attributes
+
+"""
+    preprocess_attributes!(plt, plotattributes)
+
+Any plotting package specific preprocessing of user or recipe input happens here.
+For example, Plots replaces aliases and expands magic arguments.
+"""
+function preprocess_attributes!(plt, plotattributes) end
+
+# TODO: should the Plots version be defined as fallback in RecipePipeline?
+"""
+    is_subplot_attribute(plt, attr)
+
+Returns `true` if `attr` is a subplot attribute, otherwise `false`.
+"""
+is_subplot_attribute(plt, attr) = false
+
+# TODO: should the Plots version be defined as fallback in RecipePipeline?
+"""
+    is_axis_attribute(plt, attr)
+
+Returns `true` if `attr` is an axis attribute, i.e. it applies to `xattr`, `yattr` and
+`zattr`, otherwise `false`.
+"""
+is_axis_attribute(plt, attr) = false
+
+
+## User recipes
+
+"""
+    process_userrecipe!(plt, attributes_list, attributes)
+
+Do plotting package specific post-processing and add series attributes to attributes_list.
+For example, Plots increases the number of series in `plt`, sets `:series_plotindex` in
+attributes and possible adds new series attributes for errorbars or smooth.
+"""
+function process_userrecipe!(plt, attributes_list, attributes)
+    push!(attributes_list, attributes)
+end
+
+"""
+    get_axis_limits(plt, letter)
+
+Get the limits for the axis specified by `letter` (`:x`, `:y` or `:z`) in `plt`. If it
+errors, `tryrange` from PlotUtils is used.
+"""
+get_axis_limits(plt, letter) = ErrorException("Axis limits not defined.")
+
+
+## Plot recipes
+
+"""
+    type_alias(plt, st)
+
+Return the seriestype alias for `st`.
+"""
+type_alias(plt, st) = st
+
+
+## Plot setup
+
+"""
+    plot_setup!(plt, plotattributes, kw_list)
+
+Setup plot, subplots and layouts.
+For example, Plots creates the backend figure, initializes subplots, expands extrema and
+links subplot axes.
+"""
+function plot_setup!(plt, plotattributes, kw_list) end
+
+
+## Series recipes
+
+"""
+    slice_series_attributes!(plt, kw_list, kw)
+
+For attributes given as vector with one element per series, only select the value for
+current series.
+"""
+function slice_series_attributes!(plt, kw_list, kw) end
+
+
+"""
+    series_defaults(plt)
+
+Returns a `Dict` storing the defaults for series attributes.
+"""
+series_defaults(plt) = Dict{Symbol, Any}()
+
+# TODO: Add a more sensible fallback including e.g. path, scatter, ...
+"""
+    is_seriestype_supported(plt, st)
+
+Check if the plotting package natively supports the seriestype `st`.
+"""
+is_seriestype_supported(plt, st) = false
+
+"""
+    add_series!(plt, kw)
+
+Adds the series defined by `kw` to the plot object.
+For example Plots updates the current subplot arguments, expands extrema and pushes the
+the series to the series_list of `plt`.
+"""
+function add_series!(plt, kw) end

src/RecipePipeline/group.jl

@@ -0,0 +1,122 @@
+"A special type that will break up incoming data into groups, and allow for easier creation of grouped plots"
+mutable struct GroupBy
+    group_labels::Vector                # length == numGroups
+    group_indices::Vector{Vector{Int}}  # list of indices for each group
+end
+
+# this is when given a vector-type of values to group by
+function _extract_group_attributes(v::AVec, args...; legend_entry = string)
+    group_labels = sort(collect(unique(v)))
+    n = length(group_labels)
+    if n > 100
+        @warn("You created n=$n groups... Is that intended?")
+    end
+    group_indices = Vector{Int}[filter(i -> v[i] == glab, eachindex(v)) for glab in group_labels]
+    GroupBy(map(legend_entry, group_labels), group_indices)
+end
+
+legend_entry_from_tuple(ns::Tuple) = join(ns, ' ')
+
+# this is when given a tuple of vectors of values to group by
+function _extract_group_attributes(vs::Tuple, args...)
+    isempty(vs) && return GroupBy([""], [axes(args[1],1)])
+    v = map(tuple, vs...)
+    _extract_group_attributes(v, args...; legend_entry = legend_entry_from_tuple)
+end
+
+# allow passing NamedTuples for a named legend entry
+legend_entry_from_tuple(ns::NamedTuple) =
+    join(["$k = $v" for (k, v) in pairs(ns)], ", ")
+
+function _extract_group_attributes(vs::NamedTuple, args...)
+    isempty(vs) && return GroupBy([""], [axes(args[1],1)])
+    v = map(NamedTuple{keys(vs)}∘tuple, values(vs)...)
+    _extract_group_attributes(v, args...; legend_entry = legend_entry_from_tuple)
+end
+
+# expecting a mapping of "group label" to "group indices"
+function _extract_group_attributes(idxmap::Dict{T,V}, args...) where {T, V<:AVec{Int}}
+    group_labels = sortedkeys(idxmap)
+    group_indices = Vector{Int}[collect(idxmap[k]) for k in group_labels]
+    GroupBy(group_labels, group_indices)
+end
+
+filter_data(v::AVec, idxfilter::AVec{Int}) = v[idxfilter]
+filter_data(v, idxfilter) = v
+
+function filter_data!(plotattributes::AKW, idxfilter)
+    for s in (:x, :y, :z)
+        plotattributes[s] = filter_data(get(plotattributes, s, nothing), idxfilter)
+    end
+end
+
+function _filter_input_data!(plotattributes::AKW)
+    idxfilter = pop!(plotattributes, :idxfilter, nothing)
+    if idxfilter !== nothing
+        filter_data!(plotattributes, idxfilter)
+    end
+end
+
+function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1])
+    y_mat = Array{promote_type(eltype(y), typeof(def_val))}(
+        undef,
+        length(keys(x_ind)),
+        length(groupby.group_labels),
+    )
+    fill!(y_mat, def_val)
+    for i in eachindex(groupby.group_labels)
+        xi = x[groupby.group_indices[i]]
+        yi = y[groupby.group_indices[i]]
+        y_mat[getindex.(Ref(x_ind), xi), i] = yi
+    end
+    return y_mat
+end
+
+groupedvec2mat(x_ind, x, y::Tuple, groupby) =
+    Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y)
+
+group_as_matrix(t) = false
+
+# split the group into 1 series per group, and set the label and idxfilter for each
+@recipe function f(groupby::GroupBy, args...)
+    plt = plotattributes[:plot_object]
+    group_length = maximum(union(groupby.group_indices...))
+    if !(group_as_matrix(args[1]))
+        for (i, glab) in enumerate(groupby.group_labels)
+            @series begin
+                label --> string(glab)
+                idxfilter --> groupby.group_indices[i]
+                for (key, val) in plotattributes
+                    if splittable_attribute(plt, key, val, group_length)
+                        :($key) := split_attribute(plt, key, val, groupby.group_indices[i])
+                    end
+                end
+                args
+            end
+        end
+    else
+        g = args[1]
+        if length(g.args) == 1
+            x = zeros(Int, group_length)
+            for indexes in groupby.group_indices
+                x[indexes] = eachindex(indexes)
+            end
+            last_args = g.args
+        else
+            x = g.args[1]
+            last_args = g.args[2:end]
+        end
+        x_u = unique(sort(x))
+        x_ind = Dict(zip(x_u, eachindex(x_u)))
+        for (key, val) in plotattributes
+            if splittable_kw(key, val, group_length)
+                :($key) := groupedvec2mat(x_ind, x, val, groupby)
+            end
+        end
+        label --> reshape(groupby.group_labels, 1, :)
+        typeof(g)((
+            x_u,
+            (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)...,
+        ))
+    end
+end

src/RecipePipeline/plot_recipe.jl

@@ -0,0 +1,46 @@
+"""
+    _process_plotrecipes!(plt, kw_list)
+
+Grab the first in line to be processed and pass it through `apply_recipe` to generate a
+list of `RecipeData` objects.
+If we applied a "plot recipe" without error, then add the returned datalist's KWs,
+otherwise we just add the original KW.
+"""
+function _process_plotrecipes!(plt, kw_list)
+    still_to_process = kw_list
+    kw_list = KW[]
+    while !isempty(still_to_process)
+        next_kw = popfirst!(still_to_process)
+        _process_plotrecipe(plt, next_kw, kw_list, still_to_process)
+    end
+    return kw_list
+end
+
+
+function _process_plotrecipe(plt, kw, kw_list, still_to_process)
+    if !isa(get(kw, :seriestype, nothing), Symbol)
+        # seriestype was never set, or it's not a Symbol, so it can't be a plot recipe
+        push!(kw_list, kw)
+        return
+    end
+    try
+        st = kw[:seriestype]
+        st = kw[:seriestype] = type_alias(plt, st)
+        datalist = RecipesBase.apply_recipe(kw, Val{st}, plt)
+        warn_on_recipe_aliases!(plt, datalist, :plot, st)
+        for data in datalist
+            preprocess_attributes!(plt, data.plotattributes)
+            if data.plotattributes[:seriestype] == st
+                error("Plot recipe $st returned the same seriestype: $(data.plotattributes)")
+            end
+            push!(still_to_process, data.plotattributes)
+        end
+    catch err
+        if isa(err, MethodError)
+            push!(kw_list, kw)
+        else
+            rethrow()
+        end
+    end
+    return
+end

src/RecipePipeline/series.jl

@@ -0,0 +1,170 @@
+const FuncOrFuncs{F} = Union{F, Vector{F}, Matrix{F}}
+const MaybeNumber = Union{Number, Missing}
+const MaybeString = Union{AbstractString, Missing}
+const DataPoint = Union{MaybeNumber, MaybeString}
+
+_prepare_series_data(x) = error("Cannot convert $(typeof(x)) to series data for plotting")
+_prepare_series_data(::Nothing) = nothing
+_prepare_series_data(t::Tuple{T, T}) where {T <: Number} = t
+_prepare_series_data(f::Function) = f
+_prepare_series_data(ar::AbstractRange{<:Number}) = ar
+function _prepare_series_data(a::AbstractArray{<:MaybeNumber})
+    f = isimmutable(a) ? replace : replace!
+    a = f(x -> ismissing(x) || isinf(x) ? NaN : x, map(float, a))
+end
+_prepare_series_data(a::AbstractArray{<:Missing}) = fill(NaN, axes(a))
+_prepare_series_data(a::AbstractArray{<:MaybeString}) =
+    replace(x -> ismissing(x) ? "" : x, a)
+_prepare_series_data(s::Surface{<:AMat{<:MaybeNumber}}) =
+    Surface(_prepare_series_data(s.surf))
+_prepare_series_data(s::Surface) = s  # non-numeric Surface, such as an image
+_prepare_series_data(v::Volume) =
+    Volume(_prepare_series_data(v.v), v.x_extents, v.y_extents, v.z_extents)
+
+# default: assume x represents a single series
+_series_data_vector(x, plotattributes) = [_prepare_series_data(x)]
+
+# fixed number of blank series
+_series_data_vector(n::Integer, plotattributes) = [zeros(0) for i in 1:n]
+
+# vector of data points is a single series
+_series_data_vector(v::AVec{<:DataPoint}, plotattributes) = [_prepare_series_data(v)]
+
+# list of things (maybe other vectors, functions, or something else)
+function _series_data_vector(v::AVec, plotattributes)
+    if all(x -> x isa MaybeNumber, v)
+        _series_data_vector(Vector{MaybeNumber}(v), plotattributes)
+    elseif all(x -> x isa MaybeString, v)
+        _series_data_vector(Vector{MaybeString}(v), plotattributes)
+    else
+        vcat((_series_data_vector(vi, plotattributes) for vi in v)...)
+    end
+end
+
+# Matrix is split into columns
+function _series_data_vector(v::AMat{<:DataPoint}, plotattributes)
+    if is3d(plotattributes)
+        [_prepare_series_data(Surface(v))]
+    else
+        [_prepare_series_data(v[:, i]) for i in axes(v, 2)]
+    end
+end
+
+# --------------------------------------------------------------------
+# Fillranges & ribbons
+
+
+_process_fillrange(range::Number, plotattributes) = [range]
+_process_fillrange(range, plotattributes) = _series_data_vector(range, plotattributes)
+
+_process_ribbon(ribbon::Number, plotattributes) = [ribbon]
+_process_ribbon(ribbon, plotattributes) = _series_data_vector(ribbon, plotattributes)
+# ribbon as a tuple: (lower_ribbons, upper_ribbons)
+_process_ribbon(ribbon::Tuple{S, T}, plotattributes) where {S, T} = collect(zip(
+    _series_data_vector(ribbon[1], plotattributes),
+    _series_data_vector(ribbon[2], plotattributes),
+))
+
+
+# --------------------------------------------------------------------
+
+_compute_x(x::Nothing, y::Nothing, z) = axes(z, 1)
+_compute_x(x::Nothing, y, z) = axes(y, 1)
+_compute_x(x::Function, y, z) = map(x, y)
+_compute_x(x, y, z) = x
+
+_compute_y(x::Nothing, y::Nothing, z) = axes(z, 2)
+_compute_y(x, y::Function, z) = map(y, x)
+_compute_y(x, y, z) = y
+
+_compute_z(x, y, z::Function) = map(z, x, y)
+_compute_z(x, y, z::AbstractMatrix) = Surface(z)
+_compute_z(x, y, z::Nothing) = nothing
+_compute_z(x, y, z) = z
+
+_nobigs(v::AVec{BigFloat}) = map(Float64, v)
+_nobigs(v::AVec{BigInt}) = map(Int64, v)
+_nobigs(v) = v
+
+@noinline function _compute_xyz(x, y, z)
+    x = _compute_x(x, y, z)
+    y = _compute_y(x, y, z)
+    z = _compute_z(x, y, z)
+    _nobigs(x), _nobigs(y), _nobigs(z)
+end
+
+# not allowed
+_compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F <: Function} =
+    error("If you want to plot the function `$y`, you need to define the x values!")
+_compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F <: Function} =
+    error("If you want to plot the function `$z`, you need to define x and y values!")
+_compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all nothing!")
+
+# --------------------------------------------------------------------
+
+
+# we are going to build recipes to do the processing and splitting of the args
+
+# --------------------------------------------------------------------
+# The catch-all SliceIt recipe
+# --------------------------------------------------------------------
+
+# ensure we dispatch to the slicer
+struct SliceIt end
+
+# TODO: Should ribbon and fillrange be handled by the plotting package?
+
+# The `SliceIt` recipe finishes user and type recipe processing.
+# It splits processed data into individual series data, stores in copied `plotattributes`
+# for each series and returns no arguments.
+@recipe function f(::Type{SliceIt}, x, y, z)
+
+    # handle data with formatting attached
+    if typeof(x) <: Formatted
+        xformatter := x.formatter
+        x = x.data
+    end
+    if typeof(y) <: Formatted
+        yformatter := y.formatter
+        y = y.data
+    end
+    if typeof(z) <: Formatted
+        zformatter := z.formatter
+        z = z.data
+    end
+
+    xs = _series_data_vector(x, plotattributes)
+    ys = _series_data_vector(y, plotattributes)
+    zs = _series_data_vector(z, plotattributes)
+
+    fr = pop!(plotattributes, :fillrange, nothing)
+    fillranges = _process_fillrange(fr, plotattributes)
+    mf = length(fillranges)
+
+    rib = pop!(plotattributes, :ribbon, nothing)
+    ribbons = _process_ribbon(rib, plotattributes)
+    mr = length(ribbons)
+
+    mx = length(xs)
+    my = length(ys)
+    mz = length(zs)
+    if mx > 0 && my > 0 && mz > 0
+        for i in 1:max(mx, my, mz)
+            # add a new series
+            di = copy(plotattributes)
+            xi, yi, zi = xs[mod1(i, mx)], ys[mod1(i, my)], zs[mod1(i, mz)]
+            di[:x], di[:y], di[:z] = _compute_xyz(xi, yi, zi)
+
+            # handle fillrange
+            fr = fillranges[mod1(i, mf)]
+            di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr
+
+            # handle ribbons
+            rib = ribbons[mod1(i, mr)]
+            di[:ribbon] = isa(rib, Function) ? map(rib, di[:x]) : rib
+
+            push!(series_list, RecipeData(di, ()))
+        end
+    end
+    nothing  # don't add a series for the main block
+end

src/RecipePipeline/series_recipe.jl

@@ -0,0 +1,62 @@
+"""
+    _process_seriesrecipes!(plt, kw_list)
+
+Recursively apply series recipes until the backend supports the seriestype
+"""
+function _process_seriesrecipes!(plt, kw_list)
+    for kw in kw_list
+        # in series attributes given as vector with one element per series,
+        # select the value for current series
+        slice_series_attributes!(plt, kw_list, kw)
+
+        series_attr = DefaultsDict(kw, series_defaults(plt))
+        # now we have a fully specified series, with colors chosen. we must recursively
+        # handle series recipes, which dispatch on seriestype. If a backend does not
+        # natively support a seriestype, we check for a recipe that will convert that
+        # series type into one made up of lower-level components.
+        # For example, a histogram is just a bar plot with binned data, a bar plot is
+        # really a filled step plot, and a step plot is really just a path. So any backend
+        # that supports drawing a path will implicitly be able to support step, bar, and
+        # histogram plots (and any recipes that use those components).
+        _process_seriesrecipe(plt, series_attr)
+    end
+end
+
+# this method recursively applies series recipes when the seriestype is not supported
+# natively by the backend
+function _process_seriesrecipe(plt, plotattributes)
+    # replace seriestype aliases
+    st = Symbol(plotattributes[:seriestype])
+    st = plotattributes[:seriestype] = type_alias(plt, st)
+
+    # shapes shouldn't have fillrange set
+    if plotattributes[:seriestype] == :shape
+        plotattributes[:fillrange] = nothing
+    end
+
+    # if it's natively supported, finalize processing and pass along to the backend,
+    # otherwise recurse
+    if is_seriestype_supported(plt, st)
+        add_series!(plt, plotattributes)
+    else
+        # get a sub list of series for this seriestype
+        x, y, z = plotattributes[:x], plotattributes[:y], plotattributes[:z]
+        datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, x, y, z)
+        warn_on_recipe_aliases!(plt, datalist, :series, st)
+
+        # assuming there was no error, recursively apply the series recipes
+        for data in datalist
+            if isa(data, RecipeData)
+                preprocess_attributes!(plt, data.plotattributes)
+                if data.plotattributes[:seriestype] == st
+                    error("The seriestype didn't change in series recipe $st. This will cause a StackOverflow.")
+                end
+                _process_seriesrecipe(plt, data.plotattributes)
+            else
+                @warn("Unhandled recipe: $(data)")
+                break
+            end
+        end
+    end
+    nothing
+end

src/RecipePipeline/type_recipe.jl

@@ -0,0 +1,94 @@
+# this is the default "type recipe"... just pass the object through
+@recipe f(::Type{T}, v::T) where {T} = v
+
+# this should catch unhandled "series recipes" and error with a nice message
+@recipe f(::Type{V}, x, y, z) where {V <: Val} =
+    error("The backend must not support the series type $V, and there isn't a series recipe defined.")
+
+"""
+    _apply_type_recipe(plotattributes, v::T, letter)
+
+Apply the type recipe with signature `(::Type{T}, ::T)`.
+"""
+function _apply_type_recipe(plotattributes, v, letter)
+    _preprocess_axis_args!(plotattributes, letter)
+    rdvec = RecipesBase.apply_recipe(plotattributes, typeof(v), v)
+    warn_on_recipe_aliases!(plotattributes[:plot_object], plotattributes, :type, typeof(v))
+    _postprocess_axis_args!(plotattributes, letter)
+    return rdvec[1].args[1]
+end
+
+# Handle type recipes when the recipe is defined on the elements.
+# This sort of recipe should return a pair of functions... one to convert to number,
+# and one to format tick values.
+function _apply_type_recipe(plotattributes, v::AbstractArray, letter)
+    plt = plotattributes[:plot_object]
+    _preprocess_axis_args!(plotattributes, letter)
+    # First we try to apply an array type recipe.
+    w = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1]
+    warn_on_recipe_aliases!(plt, plotattributes, :type, typeof(v))
+    # If the type did not change try it element-wise
+    if typeof(v) == typeof(w)
+        isempty(skipmissing(v)) && return Float64[]
+        x = first(skipmissing(v))
+        args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args
+        warn_on_recipe_aliases!(plt, plotattributes, :type, typeof(x))
+        _postprocess_axis_args!(plotattributes, letter)
+        if length(args) == 2 && all(arg -> arg isa Function, args)
+            numfunc, formatter = args
+            return Formatted(map(numfunc, v), formatter)
+        else
+            return v
+        end
+    end
+    _postprocess_axis_args!(plotattributes, letter)
+    return w
+end
+
+# special handling for Surface... need to properly unwrap and re-wrap
+_apply_type_recipe(plotattributes, v::Surface{<:AMat{<:DataPoint}}) = v
+function _apply_type_recipe(plotattributes, v::Surface)
+    ret = _apply_type_recipe(plotattributes, v.surf)
+    if typeof(ret) <: Formatted
+        Formatted(Surface(ret.data), ret.formatter)
+    else
+        Surface(ret.data)
+    end
+end
+
+# don't do anything for datapoints or nothing
+_apply_type_recipe(plotattributes, v::AbstractArray{<:DataPoint}, letter) = v
+_apply_type_recipe(plotattributes, v::Nothing, letter) = v
+
+# axis args before type recipes should still be mapped to all axes
+function _preprocess_axis_args!(plotattributes)
+    plt = plotattributes[:plot_object]
+    for (k, v) in plotattributes
+        if is_axis_attribute(plt, k)
+            pop!(plotattributes, k)
+            for l in (:x, :y, :z)
+                lk = Symbol(l, k)
+                haskey(plotattributes, lk) || (plotattributes[lk] = v)
+            end
+        end
+    end
+end
+function _preprocess_axis_args!(plotattributes, letter)
+    plotattributes[:letter] = letter
+    _preprocess_axis_args!(plotattributes)
+end
+
+# axis args in type recipes should only be applied to the current axis
+function _postprocess_axis_args!(plotattributes, letter)
+    plt = plotattributes[:plot_object]
+    pop!(plotattributes, :letter)
+    if letter in (:x, :y, :z)
+        for (k, v) in plotattributes
+            if is_axis_attribute(plt, k)
+                pop!(plotattributes, k)
+                lk = Symbol(letter, k)
+                haskey(plotattributes, lk) || (plotattributes[lk] = v)
+            end
+        end
+    end
+end

src/RecipePipeline/user_recipe.jl

@@ -0,0 +1,330 @@
+"""
+    _process_userrecipes(plt, plotattributes, args)
+
+Wrap input arguments in a `RecipeData' vector and recursively apply user recipes and type
+recipes on the first element. Prepend the returned `RecipeData` vector. If an element with
+empy `args` is returned pop it from the vector, finish up, and it to vector of `Dict`s with
+processed series. When all arguments are processed return the series `Dict`.
+"""
+function _process_userrecipes!(plt, plotattributes, args)
+    still_to_process = _recipedata_vector(plt, plotattributes, args)
+
+    # for plotting recipes, swap out the args and update the parameter dictionary
+    # we are keeping a stack of series that still need to be processed.
+    # each pass through the loop, we pop one off and apply the recipe.
+    # the recipe will return a list a Series objects... the ones that are
+    # finished (no more args) get added to the kw_list, the ones that are not
+    # are placed on top of the stack and are then processed further.
+    kw_list = KW[]
+    while !isempty(still_to_process)
+        # grab the first in line to be processed and either add it to the kw_list or
+        # pass it through apply_recipe to generate a list of RecipeData objects
+        # (data + attributes) for further processing.
+        next_series = popfirst!(still_to_process)
+        # recipedata should be of type RecipeData.
+        # if it's not then the inputs must not have been fully processed by recipes
+        if !(typeof(next_series) <: RecipeData)
+            error("Inputs couldn't be processed... expected RecipeData but got: $next_series")
+        end
+        if isempty(next_series.args)
+            _finish_userrecipe!(plt, kw_list, next_series)
+        else
+            rd_list =
+                RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...)
+            warn_on_recipe_aliases!(plt, rd_list, :user, next_series.args...)
+            prepend!(still_to_process, rd_list)
+        end
+    end
+
+    # don't allow something else to handle it
+    plotattributes[:smooth] = false
+    kw_list
+end
+
+
+# TODO Move this to api.jl?
+
+function _recipedata_vector(plt, plotattributes, args)
+    still_to_process = RecipeData[]
+    # the grouping mechanism is a recipe on a GroupBy object
+    # we simply add the GroupBy object to the front of the args list to allow
+    # the recipe to be applied
+    if haskey(plotattributes, :group)
+        args = (_extract_group_attributes(plotattributes[:group], args...), args...)
+    end
+
+    # if we were passed a vector/matrix of seriestypes and there's more than one row,
+    # we want to duplicate the inputs, once for each seriestype row.
+    if !isempty(args)
+        append!(still_to_process, _expand_seriestype_array(plotattributes, args))
+    end
+
+    # remove subplot and axis args from plotattributes...
+    # they will be passed through in the kw_list
+    if !isempty(args)
+        for (k, v) in plotattributes
+            if is_subplot_attribute(plt, k) || is_axis_attribute(plt, k)
+                reset_kw!(plotattributes, k)
+            end
+        end
+    end
+
+    still_to_process
+end
+
+function _expand_seriestype_array(plotattributes, args)
+    sts = get(plotattributes, :seriestype, :path)
+    if typeof(sts) <: AbstractArray
+        reset_kw!(plotattributes, :seriestype)
+        rd = Vector{RecipeData}(undef, size(sts, 1))
+        for r in axes(sts, 1)
+            dc = copy(plotattributes)
+            dc[:seriestype] = sts[r:r, :]
+            rd[r] = RecipeData(dc, args)
+        end
+        rd
+    else
+        RecipeData[RecipeData(copy(plotattributes), args)]
+    end
+end
+
+
+function _finish_userrecipe!(plt, kw_list, recipedata)
+    # when the arg tuple is empty, that means there's nothing left to recursively
+    # process... finish up and add to the kw_list
+    kw = recipedata.plotattributes
+    preprocess_attributes!(plt, kw)
+    # if there was a grouping, filter the data here
+    _filter_input_data!(kw)
+    process_userrecipe!(plt, kw_list, kw)
+end
+
+
+# --------------------------------
+# Fallback user recipes
+# --------------------------------
+
+# These call `_apply_type_recipe` in type_recipe.jl and finally the `SliceIt` recipe in
+# series.jl.
+
+# handle "type recipes" by converting inputs, and then either re-calling or slicing
+@recipe function f(x, y, z)
+    wrap_surfaces!(plotattributes, x, y, z)
+    did_replace = false
+    newx = _apply_type_recipe(plotattributes, x, :x)
+    x === newx || (did_replace = true)
+    newy = _apply_type_recipe(plotattributes, y, :y)
+    y === newy || (did_replace = true)
+    newz = _apply_type_recipe(plotattributes, z, :z)
+    z === newz || (did_replace = true)
+    if did_replace
+        newx, newy, newz
+    else
+        SliceIt, x, y, z
+    end
+end
+@recipe function f(x, y)
+    wrap_surfaces!(plotattributes, x, y)
+    did_replace = false
+    newx = _apply_type_recipe(plotattributes, x, :x)
+    x === newx || (did_replace = true)
+    newy = _apply_type_recipe(plotattributes, y, :y)
+    y === newy || (did_replace = true)
+    if did_replace
+        newx, newy
+    else
+        SliceIt, x, y, nothing
+    end
+end
+@recipe function f(y)
+    wrap_surfaces!(plotattributes, y)
+    newy = _apply_type_recipe(plotattributes, y, :y)
+    if y !== newy
+        newy
+    else
+        SliceIt, nothing, y, nothing
+    end
+end
+
+# if there's more than 3 inputs, it can't be passed directly to SliceIt
+# so we'll apply_type_recipe to all of them
+@recipe function f(v1, v2, v3, v4, vrest...)
+    did_replace = false
+    newargs = map(
+        v -> begin
+            newv = _apply_type_recipe(plotattributes, v, :unknown)
+            if newv !== v
+                did_replace = true
+            end
+            newv
+        end,
+        (v1, v2, v3, v4, vrest...),
+    )
+    if !did_replace
+        error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))")
+    end
+    newargs
+end
+
+
+# helper function to ensure relevant attributes are wrapped by Surface
+function wrap_surfaces!(plotattributes, args...) end
+wrap_surfaces!(plotattributes, x::AMat, y::AMat, z::AMat) = wrap_surfaces!(plotattributes)
+wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::AMat) = wrap_surfaces!(plotattributes)
+function wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::Surface)
+    wrap_surfaces!(plotattributes)
+end
+function wrap_surfaces!(plotattributes)
+    if haskey(plotattributes, :fill_z)
+        v = plotattributes[:fill_z]
+        if !isa(v, Surface)
+            plotattributes[:fill_z] = Surface(v)
+        end
+    end
+end
+
+
+# --------------------------------
+# Special Cases
+# --------------------------------
+
+# --------------------------------
+# 1 argument
+
+@recipe function f(n::Integer)
+    if is3d(plotattributes)
+        SliceIt, n, n, n
+    else
+        SliceIt, n, n, nothing
+    end
+end
+
+# return a surface if this is a 3d plot, otherwise let it be sliced up
+@recipe function f(mat::AMat)
+    if is3d(plotattributes)
+        n, m = axes(mat)
+        m, n, Surface(mat)
+    else
+        nothing, mat, nothing
+    end
+end
+
+# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface
+@recipe function f(fmt::Formatted{<:AMat})
+    if is3d(plotattributes)
+        mat = fmt.data
+        n, m = axes(mat)
+        m, n, Formatted(Surface(mat), fmt.formatter)
+    else
+        nothing, fmt, nothing
+    end
+end
+
+# assume this is a Volume, so construct one
+@recipe function f(vol::AbstractArray{<:MaybeNumber, 3}, args...)
+    seriestype := :volume
+    SliceIt, nothing, Volume(vol, args...), nothing
+end
+
+# Dicts: each entry is a data point (x,y)=(key,value)
+@recipe f(d::AbstractDict) = collect(keys(d)), collect(values(d))
+
+# function without range... use the current range of the x-axis
+@recipe function f(f::FuncOrFuncs{F}) where {F <: Function}
+    plt = plotattributes[:plot_object]
+    xmin, xmax = if haskey(plotattributes, :xlims)
+        plotattributes[:xlims]
+    else
+        try
+            get_axis_limits(plt, :x)
+        catch
+            xinv = inverse_scale_func(get(plotattributes, :xscale, :identity))
+            xm = PlotUtils.tryrange(f, xinv.([-5, -1, 0, 0.01]))
+            xm, PlotUtils.tryrange(f, filter(x -> x > xm, xinv.([5, 1, 0.99, 0, -0.01])))
+        end
+    end
+    f, xmin, xmax
+end
+
+
+# --------------------------------
+# 2 arguments
+
+# if functions come first, just swap the order (not to be confused with parametric
+# functions... as there would be more than one function passed in)
+@recipe function f(f::FuncOrFuncs{F}, x) where {F <: Function}
+    F2 = typeof(x)
+    @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function))
+    # otherwise we'd hit infinite recursion here
+    x, f
+end
+
+
+# --------------------------------
+# 3 arguments
+
+# surface-like... function
+@recipe function f(x::AVec, y::AVec, zf::Function)
+    x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
+end
+
+# surface-like... matrix grid
+@recipe function f(x::AVec, y::AVec, z::AMat)
+    if !is_surface(plotattributes)
+        plotattributes[:seriestype] = :contour
+    end
+    x, y, Surface(z)
+end
+
+# parametric functions
+# special handling... xmin/xmax with parametric function(s)
+@recipe function f(f::Function, xmin::Number, xmax::Number)
+    xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)]
+    _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
+end
+@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where {F <: Function}
+    xscale, yscale = [get(plotattributes, sym, :identity) for sym in (:xscale, :yscale)]
+    unzip(_scaled_adapted_grid.(fs, xscale, yscale, xmin, xmax))
+end
+@recipe f(
+    fx::FuncOrFuncs{F},
+    fy::FuncOrFuncs{G},
+    u::AVec,
+) where {F <: Function, G <: Function} = _map_funcs(fx, u), _map_funcs(fy, u)
+@recipe f(
+    fx::FuncOrFuncs{F},
+    fy::FuncOrFuncs{G},
+    umin::Number,
+    umax::Number,
+    n = 200,
+) where {F <: Function, G <: Function} = fx, fy, range(umin, stop = umax, length = n)
+
+function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
+    (xf, xinv), (yf, yinv) = ((scale_func(s), inverse_scale_func(s)) for s in (xscale, yscale))
+    xs, ys = PlotUtils.adapted_grid(yf ∘ f ∘ xinv, xf.((xmin, xmax)))
+    xinv.(xs), yinv.(ys)
+end
+
+# special handling... 3D parametric function(s)
+@recipe function f(
+    fx::FuncOrFuncs{F},
+    fy::FuncOrFuncs{G},
+    fz::FuncOrFuncs{H},
+    u::AVec,
+) where {F <: Function, G <: Function, H <: Function}
+    _map_funcs(fx, u), _map_funcs(fy, u), _map_funcs(fz, u)
+end
+@recipe function f(
+    fx::FuncOrFuncs{F},
+    fy::FuncOrFuncs{G},
+    fz::FuncOrFuncs{H},
+    umin::Number,
+    umax::Number,
+    numPoints = 200,
+) where {F <: Function, G <: Function, H <: Function}
+    fx, fy, fz, range(umin, stop = umax, length = numPoints)
+end
+
+# list of tuples
+@recipe f(v::AVec{<:Tuple}) = unzip(v)
+@recipe f(tup::Tuple) = [tup]

src/RecipePipeline/utils.jl

@@ -0,0 +1,220 @@
+const AVec = AbstractVector
+const AMat = AbstractMatrix
+const KW = Dict{Symbol, Any}
+const AKW = AbstractDict{Symbol, Any}
+
+# --------------------------------
+# DefaultsDict
+# --------------------------------
+
+struct DefaultsDict <: AbstractDict{Symbol, Any}
+    explicit::KW
+    defaults::KW
+end
+
+function Base.getindex(dd::DefaultsDict, k)
+    return haskey(dd.explicit, k) ? dd.explicit[k] : dd.defaults[k]
+end
+Base.haskey(dd::DefaultsDict, k) = haskey(dd.explicit, k) || haskey(dd.defaults, k)
+Base.get(dd::DefaultsDict, k, default) = haskey(dd, k) ? dd[k] : default
+function Base.get!(dd::DefaultsDict, k, default)
+    v = if haskey(dd, k)
+        dd[k]
+    else
+        dd.defaults[k] = default
+    end
+    return v
+end
+function Base.delete!(dd::DefaultsDict, k)
+    haskey(dd.explicit, k) && delete!(dd.explicit, k)
+    haskey(dd.defaults, k) && delete!(dd.defaults, k)
+end
+Base.length(dd::DefaultsDict) = length(union(keys(dd.explicit), keys(dd.defaults)))
+function Base.iterate(dd::DefaultsDict)
+    exp_keys = keys(dd.explicit)
+    def_keys = setdiff(keys(dd.defaults), exp_keys)
+    key_list = collect(Iterators.flatten((exp_keys, def_keys)))
+    iterate(dd, (key_list, 1))
+end
+function Base.iterate(dd::DefaultsDict, (key_list, i))
+    i > length(key_list) && return nothing
+    k = key_list[i]
+    (k => dd[k], (key_list, i + 1))
+end
+
+Base.copy(dd::DefaultsDict) = DefaultsDict(copy(dd.explicit), dd.defaults)
+
+RecipesBase.is_explicit(dd::DefaultsDict, k) = haskey(dd.explicit, k)
+isdefault(dd::DefaultsDict, k) = !is_explicit(dd, k) && haskey(dd.defaults, k)
+
+Base.setindex!(dd::DefaultsDict, v, k) = dd.explicit[k] = v
+
+# Reset to default value and return dict
+reset_kw!(dd::DefaultsDict, k) = is_explicit(dd, k) ? delete!(dd.explicit, k) : dd
+# Reset to default value and return old value
+pop_kw!(dd::DefaultsDict, k) = is_explicit(dd, k) ? pop!(dd.explicit, k) : dd.defaults[k]
+pop_kw!(dd::DefaultsDict, k, default) =
+    is_explicit(dd, k) ? pop!(dd.explicit, k) : get(dd.defaults, k, default)
+# Fallbacks for dicts without defaults
+reset_kw!(d::AKW, k) = delete!(d, k)
+pop_kw!(d::AKW, k) = pop!(d, k)
+pop_kw!(d::AKW, k, default) = pop!(d, k, default)
+
+
+# --------------------------------
+# 3D types
+# --------------------------------
+
+abstract type AbstractSurface end
+
+"represents a contour or surface mesh"
+struct Surface{M <: AMat} <: AbstractSurface
+    surf::M
+end
+
+Surface(f::Function, x, y) = Surface(Float64[f(xi, yi) for yi in y, xi in x])
+
+Base.Array(surf::Surface) = surf.surf
+
+for f in (:length, :size, :axes)
+    @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
+end
+Base.copy(surf::Surface) = Surface(copy(surf.surf))
+Base.eltype(surf::Surface{T}) where {T} = eltype(T)
+
+
+struct Volume{T}
+    v::Array{T, 3}
+    x_extents::Tuple{T, T}
+    y_extents::Tuple{T, T}
+    z_extents::Tuple{T, T}
+end
+
+default_extents(::Type{T}) where {T} = (zero(T), one(T))
+
+function Volume(
+    v::Array{T, 3},
+    x_extents = default_extents(T),
+    y_extents = default_extents(T),
+    z_extents = default_extents(T),
+) where {T}
+    Volume(v, x_extents, y_extents, z_extents)
+end
+
+Base.Array(vol::Volume) = vol.v
+for f in (:length, :size)
+    @eval Base.$f(vol::Volume, args...) = $f(vol.v, args...)
+end
+Base.copy(vol::Volume{T}) where {T} =
+    Volume{T}(copy(vol.v), vol.x_extents, vol.y_extents, vol.z_extents)
+Base.eltype(vol::Volume{T}) where {T} = T
+
+
+# --------------------------------
+# Formatting
+# --------------------------------
+
+"Represents data values with formatting that should apply to the tick labels."
+struct Formatted{T}
+    data::T
+    formatter::Function
+end
+
+# -------------------------------
+# 3D seriestypes
+# -------------------------------
+
+# TODO: Move to RecipesBase?
+"""
+    is3d(::Type{Val{:myseriestype}})
+
+Returns `true` if `myseriestype` represents a 3D series, `false` otherwise.
+"""
+is3d(st) = false
+for st in (
+    :contour,
+    :contourf,
+    :contour3d,
+    :heatmap,
+    :image,
+    :path3d,
+    :scatter3d,
+    :surface,
+    :volume,
+    :wireframe,
+)
+    @eval is3d(::Type{Val{Symbol($(string(st)))}}) = true
+end
+is3d(st::Symbol) = is3d(Val{st})
+is3d(plt, stv::AbstractArray) = all(st -> is3d(plt, st), stv)
+is3d(plotattributes::AbstractDict) = is3d(get(plotattributes, :seriestype, :path))
+
+
+"""
+    is_surface(::Type{Val{:myseriestype}})
+
+Returns `true` if `myseriestype` represents a surface series, `false` otherwise.
+"""
+is_surface(st) = false
+for st in (:contour, :contourf, :contour3d, :image, :heatmap, :surface, :wireframe)
+    @eval is_surface(::Type{Val{Symbol($(string(st)))}}) = true
+end
+is_surface(st::Symbol) = is_surface(Val{st})
+is_surface(plt, stv::AbstractArray) = all(st -> is_surface(plt, st), stv)
+is_surface(plotattributes::AbstractDict) =
+    is_surface(get(plotattributes, :seriestype, :path))
+
+
+"""
+    needs_3d_axes(::Type{Val{:myseriestype}})
+
+Returns `true` if `myseriestype` needs 3d axes, `false` otherwise.
+"""
+needs_3d_axes(st) = false
+for st in (
+    :contour3d,
+    :path3d,
+    :scatter3d,
+    :surface,
+    :volume,
+    :wireframe,
+)
+    @eval needs_3d_axes(::Type{Val{Symbol($(string(st)))}}) = true
+end
+needs_3d_axes(st::Symbol) = needs_3d_axes(Val{st})
+needs_3d_axes(plt, stv::AbstractArray) = all(st -> needs_3d_axes(plt, st), stv)
+needs_3d_axes(plotattributes::AbstractDict) =
+    needs_3d_axes(get(plotattributes, :seriestype, :path))
+
+
+# --------------------------------
+# Scales
+# --------------------------------
+
+const SCALE_FUNCTIONS = Dict{Symbol, Function}(:log10 => log10, :log2 => log2, :ln => log)
+const INVERSE_SCALE_FUNCTIONS =
+    Dict{Symbol, Function}(:log10 => exp10, :log2 => exp2, :ln => exp)
+
+scale_func(scale::Symbol) = x -> get(SCALE_FUNCTIONS, scale, identity)(Float64(x))
+inverse_scale_func(scale::Symbol) =
+    x -> get(INVERSE_SCALE_FUNCTIONS, scale, identity)(Float64(x))
+
+
+# --------------------------------
+# Unzip
+# --------------------------------
+
+for i in 2:4
+    @eval begin
+        unzip(v::AVec{<:Tuple{Vararg{T, $i} where T}}) =
+            $(Expr(:tuple, (:([t[$j] for t in v]) for j in 1:i)...))
+    end
+end
+
+
+# --------------------------------
+# Map functions on vectors
+# --------------------------------
+
+_map_funcs(f::Function, u::AVec) = map(f, u)
+_map_funcs(fs::AVec{F}, u::AVec) where {F <: Function} = [map(f, u) for f in fs]

src/args.jl

@@ -86,10 +86,10 @@ const _surface_like = [:contour, :contourf, :contour3d, :heatmap, :surface, :wir
 
 like_histogram(seriestype::Symbol) = seriestype in _histogram_like
 like_line(seriestype::Symbol)      = seriestype in _line_like
-like_surface(seriestype::Symbol)   = RecipesPipeline.is_surface(seriestype)
+like_surface(seriestype::Symbol)   = is_surface(seriestype)
 
-RecipesPipeline.is3d(series::Series) = RecipesPipeline.is3d(series.plotattributes)
-RecipesPipeline.is3d(sp::Subplot) = string(sp.attr[:projection]) == "3d"
+is3d(series::Series) = is3d(series.plotattributes)
+is3d(sp::Subplot) = string(sp.attr[:projection]) == "3d"
 ispolar(sp::Subplot) = string(sp.attr[:projection]) == "polar"
 ispolar(series::Series) = ispolar(series.plotattributes[:subplot])
 
@@ -264,7 +264,6 @@ const _series_defaults = KW(
     :bar_edges         => false,
     :xerror            => nothing,
     :yerror            => nothing,
-    :zerror            => nothing,
     :ribbon            => nothing,
     :quiver            => nothing,
     :arrow             => nothing,   # allows for adding arrows to line/path... call `arrow(args...)`
@@ -566,18 +565,17 @@ add_aliases(:bins, :bin, :nbin, :nbins, :nb)
 add_aliases(:ribbon, :rib)
 add_aliases(:annotations, :ann, :anns, :annotate, :annotation)
 add_aliases(:xguide, :xlabel, :xlab, :xl)
-add_aliases(:xlims, :xlim, :xlimit, :xlimits, :xrange)
+add_aliases(:xlims, :xlim, :xlimit, :xlimits)
 add_aliases(:xticks, :xtick)
 add_aliases(:xrotation, :xrot, :xr)
 add_aliases(:yguide, :ylabel, :ylab, :yl)
-add_aliases(:ylims, :ylim, :ylimit, :ylimits, :yrange)
+add_aliases(:ylims, :ylim, :ylimit, :ylimits)
 add_aliases(:yticks, :ytick)
 add_aliases(:yrotation, :yrot, :yr)
 add_aliases(:zguide, :zlabel, :zlab, :zl)
 add_aliases(:zlims, :zlim, :zlimit, :zlimits)
 add_aliases(:zticks, :ztick)
 add_aliases(:zrotation, :zrot, :zr)
-add_aliases(:guidefontsize, :labelfontsize)
 add_aliases(:fill_z, :fillz, :fz, :surfacecolor, :surfacecolour, :sc, :surfcolor, :surfcolour)
 add_aliases(:legend, :leg, :key)
 add_aliases(:legendtitle, :legend_title, :labeltitle, :label_title, :leg_title, :key_title)
@@ -592,7 +590,6 @@ add_aliases(:color_palette, :palette)
 add_aliases(:overwrite_figure, :clf, :clearfig, :overwrite, :reuse)
 add_aliases(:xerror, :xerr, :xerrorbar)
 add_aliases(:yerror, :yerr, :yerrorbar, :err, :errorbar)
-add_aliases(:zerror, :zerr, :zerrorbar)
 add_aliases(:quiver, :velocity, :quiver2d, :gradient, :vectorfield)
 add_aliases(:normalize, :norm, :normed, :normalized)
 add_aliases(:show_empty_bins, :showemptybins, :showempty, :show_empty)
@@ -681,14 +678,10 @@ function default(k::Symbol, v)
 end
 
 function default(; kw...)
-    if isempty(kw)
-        reset_defaults()
-    else
-        kw = KW(kw)
-        RecipesPipeline.preprocess_attributes!(kw)
-        for (k,v) in kw
-            default(k, v)
-        end
+    kw = KW(kw)
+    preprocess_attributes!(kw)
+    for (k,v) in kw
+        default(k, v)
     end
 end
 
@@ -939,11 +932,11 @@ function _add_markershape(plotattributes::AKW)
 end
 
 "Handle all preprocessing of args... break out colors/sizes/etc and replace aliases."
-function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
+function preprocess_attributes!(plotattributes::AKW)
     replaceAliases!(plotattributes, _keyAliases)
 
     # handle axis args common to all axis
-    args = RecipesPipeline.pop_kw!(plotattributes, :axis, ())
+    args = pop_kw!(plotattributes, :axis, ())
     for arg in wraptuple(args)
         for letter in (:x, :y, :z)
             process_axis_arg!(plotattributes, arg, letter)
@@ -952,7 +945,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     # handle axis args
     for letter in (:x, :y, :z)
         asym = Symbol(letter, :axis)
-        args = RecipesPipeline.pop_kw!(plotattributes, asym, ())
+        args = pop_kw!(plotattributes, asym, ())
         if !(typeof(args) <: Axis)
             for arg in wraptuple(args)
                 process_axis_arg!(plotattributes, arg, letter)
@@ -970,7 +963,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     end
 
     # handle grid args common to all axes
-    args = RecipesPipeline.pop_kw!(plotattributes, :grid, ())
+    args = pop_kw!(plotattributes, :grid, ())
     for arg in wraptuple(args)
         for letter in (:x, :y, :z)
             processGridArg!(plotattributes, arg, letter)
@@ -979,13 +972,13 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     # handle individual axes grid args
     for letter in (:x, :y, :z)
         gridsym = Symbol(letter, :grid)
-        args = RecipesPipeline.pop_kw!(plotattributes, gridsym, ())
+        args = pop_kw!(plotattributes, gridsym, ())
         for arg in wraptuple(args)
             processGridArg!(plotattributes, arg, letter)
         end
     end
     # handle minor grid args common to all axes
-    args = RecipesPipeline.pop_kw!(plotattributes, :minorgrid, ())
+    args = pop_kw!(plotattributes, :minorgrid, ())
     for arg in wraptuple(args)
         for letter in (:x, :y, :z)
             processMinorGridArg!(plotattributes, arg, letter)
@@ -994,14 +987,14 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     # handle individual axes grid args
     for letter in (:x, :y, :z)
         gridsym = Symbol(letter, :minorgrid)
-        args = RecipesPipeline.pop_kw!(plotattributes, gridsym, ())
+        args = pop_kw!(plotattributes, gridsym, ())
         for arg in wraptuple(args)
             processMinorGridArg!(plotattributes, arg, letter)
         end
     end
     # handle font args common to all axes
     for fontname in (:tickfont, :guidefont)
-        args = RecipesPipeline.pop_kw!(plotattributes, fontname, ())
+        args = pop_kw!(plotattributes, fontname, ())
         for arg in wraptuple(args)
             for letter in (:x, :y, :z)
                 processFontArg!(plotattributes, Symbol(letter, fontname), arg)
@@ -1011,7 +1004,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     # handle individual axes font args
     for letter in (:x, :y, :z)
         for fontname in (:tickfont, :guidefont)
-            args = RecipesPipeline.pop_kw!(plotattributes, Symbol(letter, fontname), ())
+            args = pop_kw!(plotattributes, Symbol(letter, fontname), ())
             for arg in wraptuple(args)
                 processFontArg!(plotattributes, Symbol(letter, fontname), arg)
             end
@@ -1019,7 +1012,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     end
     # handle axes args
     for k in _axis_args
-        if haskey(plotattributes, k) && k !== :link
+        if haskey(plotattributes, k)
             v = plotattributes[k]
             for letter in (:x, :y, :z)
                 lk = Symbol(letter, k)
@@ -1032,14 +1025,14 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
 
     # fonts
     for fontname in (:titlefont, :legendfont, :legendtitlefont)
-        args = RecipesPipeline.pop_kw!(plotattributes, fontname, ())
+        args = pop_kw!(plotattributes, fontname, ())
         for arg in wraptuple(args)
             processFontArg!(plotattributes, fontname, arg)
         end
     end
 
     # handle line args
-    for arg in wraptuple(RecipesPipeline.pop_kw!(plotattributes, :line, ()))
+    for arg in wraptuple(pop_kw!(plotattributes, :line, ()))
         processLineArg(plotattributes, arg)
     end
 
@@ -1053,7 +1046,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
         processMarkerArg(plotattributes, arg)
         anymarker = true
     end
-    RecipesPipeline.reset_kw!(plotattributes, :marker)
+    reset_kw!(plotattributes, :marker)
     if haskey(plotattributes, :markershape)
         plotattributes[:markershape] = _replace_markershape(plotattributes[:markershape])
         if plotattributes[:markershape] == :none && plotattributes[:seriestype] in (:scatter, :scatterbins, :scatterhist, :scatter3d) #the default should be :auto, not :none, so that :none can be set explicitly and would be respected
@@ -1067,7 +1060,7 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
     for arg in wraptuple(get(plotattributes, :fill, ()))
         processFillArg(plotattributes, arg)
     end
-    RecipesPipeline.reset_kw!(plotattributes, :fill)
+    reset_kw!(plotattributes, :fill)
 
     # handle series annotations
     if haskey(plotattributes, :series_annotations)
@@ -1216,7 +1209,7 @@ function slice_arg!(plotattributes_in, plotattributes_out,
         v
     end
     if remove_pair
-        RecipesPipeline.reset_kw!(plotattributes_in, k)
+        reset_kw!(plotattributes_in, k)
     end
     return
 end
@@ -1477,7 +1470,7 @@ end
 
 # update a subplots args and axes
 function _update_subplot_args(plt::Plot, sp::Subplot, plotattributes_in, subplot_index::Int, remove_pair::Bool)
-    anns = RecipesPipeline.pop_kw!(sp.attr, :annotations)
+    anns = pop_kw!(sp.attr, :annotations)
 
     # # grab those args which apply to this subplot
     for k in keys(_subplot_defaults)

src/axes.jl

@@ -85,7 +85,7 @@ function attr!(axis::Axis, args...; kw...)
     end
 
     # then preprocess keyword arguments
-    RecipesPipeline.preprocess_attributes!(KW(kw))
+    preprocess_attributes!(KW(kw))
 
     # then override for any keywords... only those keywords that already exists in plotattributes
     for (k,v) in kw
@@ -129,7 +129,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
 
     # scale the limits
     scale = axis[:scale]
-    sf = RecipesPipeline.scale_func(scale)
+    sf = scale_func(scale)
 
     # If the axis input was a Date or DateTime use a special logic to find
     # "round" Date(Time)s as ticks
@@ -139,7 +139,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
     # rather than on the input format
     # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime
     if ticks === nothing && scale == :identity
-        if axis[:formatter] == RecipesPipeline.dateformatter
+        if axis[:formatter] == dateformatter
             # optimize_datetime_ticks returns ticks and labels(!) based on
             # integers/floats corresponding to the DateTime type. Thus, the axes
             # limits, which resulted from converting the Date type to integers,
@@ -150,7 +150,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
                 k_min = 2, k_max = 4)
             # Now the ticks are converted back to floats corresponding to Dates.
             return ticks / 864e5, labels
-        elseif axis[:formatter] == RecipesPipeline.datetimeformatter
+        elseif axis[:formatter] == datetimeformatter
             return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4)
         end
     end
@@ -174,11 +174,11 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
             # chosen  ticks is not too much bigger than amin - amax:
             strict_span = false,
         )
-        axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
+        axis[:lims] = map(inverse_scale_func(scale), (viewmin, viewmax))
     else
         scaled_ticks = map(sf, (filter(t -> amin <= t <= amax, ticks)))
     end
-    unscaled_ticks = map(RecipesPipeline.inverse_scale_func(scale), scaled_ticks)
+    unscaled_ticks = map(inverse_scale_func(scale), scaled_ticks)
 
     labels = if any(isfinite, unscaled_ticks)
         formatter = axis[:formatter]
@@ -283,7 +283,7 @@ function get_minor_ticks(sp, axis, ticks)
     minorticks = typeof(ticks[1])[]
     for (i,hi) in enumerate(ticks[2:end])
         lo = ticks[i]
-        if isfinite(lo) && isfinite(hi) && hi > lo
+        if isfinite(lo) && hi > lo
             append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
         end
     end
@@ -378,7 +378,7 @@ function expand_extrema!(sp::Subplot, plotattributes::AKW)
     if fr === nothing && plotattributes[:seriestype] == :bar
         fr = 0.0
     end
-    if fr !== nothing && !RecipesPipeline.is3d(plotattributes)
+    if fr !== nothing && !is3d(plotattributes)
         axis = sp.attr[vert ? :yaxis : :xaxis]
         if typeof(fr) <: Tuple
             for fri in fr
@@ -423,7 +423,7 @@ end
 
 # push the limits out slightly
 function widen(lmin, lmax, scale = :identity)
-    f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
+    f, invf = scale_func(scale), inverse_scale_func(scale)
     span = f(lmax) - f(lmin)
     # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10))
     eps = NaNMath.max(1e-16, 0.03span)
@@ -462,12 +462,11 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
     lims = axis[:lims]
     has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
     if has_user_lims
-        lmin, lmax = lims
-        if lmin != :auto && isfinite(lmin)
-            amin = lmin
+        if isfinite(lims[1])
+            amin = lims[1]
         end
-        if lmax != :auto && isfinite(lmax)
-            amax = lmax
+        if isfinite(lims[2])
+            amax = lims[2]
         end
     end
     if amax <= amin && isfinite(amin)
@@ -493,7 +492,7 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
         amin, amax
     end
 
-    if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || RecipesPipeline.is3d(:sp))
+    if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || is3d(:sp))
         aspect_ratio = isa(sp[:aspect_ratio], Number) ? sp[:aspect_ratio] : 1
         plot_ratio = height(plotarea(sp)) / width(plotarea(sp))
         dist = amax - amin
@@ -627,8 +626,8 @@ function axis_drawing_info(sp::Subplot)
             sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2), (xmax, y2)) # top spine
         end
         if !(xaxis[:ticks] in (:none, nothing, false))
-            f = RecipesPipeline.scale_func(yaxis[:scale])
-            invf = RecipesPipeline.inverse_scale_func(yaxis[:scale])
+            f = scale_func(yaxis[:scale])
+            invf = inverse_scale_func(yaxis[:scale])
             tick_start, tick_stop = if sp[:framestyle] == :origin
                 t = invf(f(0) + 0.012 * (f(ymax) - f(ymin)))
                 (-t, t)
@@ -681,8 +680,8 @@ function axis_drawing_info(sp::Subplot)
             sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin), (x2, ymax)) # right spine
         end
         if !(yaxis[:ticks] in (:none, nothing, false))
-            f = RecipesPipeline.scale_func(xaxis[:scale])
-            invf = RecipesPipeline.inverse_scale_func(xaxis[:scale])
+            f = scale_func(xaxis[:scale])
+            invf = inverse_scale_func(xaxis[:scale])
             tick_start, tick_stop = if sp[:framestyle] == :origin
                 t = invf(f(0) + 0.012 * (f(xmax) - f(xmin)))
                 (-t, t)
@@ -773,8 +772,8 @@ function axis_drawing_info_3d(sp::Subplot)
             sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2, z2), (xmax, y2, z2)) # top spine
         end
         if !(xaxis[:ticks] in (:none, nothing, false))
-            f = RecipesPipeline.scale_func(yaxis[:scale])
-            invf = RecipesPipeline.inverse_scale_func(yaxis[:scale])
+            f = scale_func(yaxis[:scale])
+            invf = inverse_scale_func(yaxis[:scale])
             tick_start, tick_stop = if sp[:framestyle] == :origin
                 t = invf(f(0) + 0.012 * (f(ymax) - f(ymin)))
                 (-t, t)
@@ -848,8 +847,8 @@ function axis_drawing_info_3d(sp::Subplot)
             sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin, z2), (x2, ymax, z2)) # right spine
         end
         if !(yaxis[:ticks] in (:none, nothing, false))
-            f = RecipesPipeline.scale_func(xaxis[:scale])
-            invf = RecipesPipeline.inverse_scale_func(xaxis[:scale])
+            f = scale_func(xaxis[:scale])
+            invf = inverse_scale_func(xaxis[:scale])
             tick_start, tick_stop = if sp[:framestyle] == :origin
                 t = invf(f(0) + 0.012 * (f(xmax) - f(xmin)))
                 (-t, t)
@@ -923,8 +922,8 @@ function axis_drawing_info_3d(sp::Subplot)
             sp[:framestyle] in (:semi, :box) && push!(zborder_segs, (x2, y2, zmin), (x2, y2, zmax))
         end
         if !(zaxis[:ticks] in (:none, nothing, false))
-            f = RecipesPipeline.scale_func(xaxis[:scale])
-            invf = RecipesPipeline.inverse_scale_func(xaxis[:scale])
+            f = scale_func(xaxis[:scale])
+            invf = inverse_scale_func(xaxis[:scale])
             tick_start, tick_stop = if sp[:framestyle] == :origin
                 t = invf(f(0) + 0.012 * (f(ymax) - f(ymin)))
                 (-t, t)

src/backends.jl

@@ -104,7 +104,7 @@ end
 # Set the (left, top, right, bottom) minimum padding around the plot area
 # to fit ticks, tick labels, guides, colorbars, etc.
 function _update_min_padding!(sp::Subplot)
-    # TODO: something different when `RecipesPipeline.is3d(sp) == true`
+    # TODO: something different when `is3d(sp) == true`
     leftpad   = tick_padding(sp, sp[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
     toppad    = sp[:top_margin]    + title_padding(sp)
     rightpad  = sp[:right_margin]
@@ -211,7 +211,7 @@ const _base_supported_args = [
     :seriestype,
     :seriescolor, :seriesalpha,
     :smooth,
-    :xerror, :yerror, :zerror,
+    :xerror, :yerror,
     :subplot,
     :x, :y, :z,
     :show, :size,

src/backends/gr.jl

@@ -67,11 +67,6 @@ const gr_font_family = Dict(
     "palatino" => 26
 )
 
-const gr_vector_font = Dict(
-    "serif-roman" => 232,
-    "sans-serif" => 233
-)
-
 # --------------------------------------------------------------------------------------
 
 gr_color(c) = gr_color(c, color_type(c))
@@ -395,8 +390,6 @@ function gr_set_font(f::Font; halign = f.halign, valign = f.valign,
     GR.setcharup(sind(-rotation), cosd(-rotation))
     if haskey(gr_font_family, family)
         GR.settextfontprec(100 + gr_font_family[family], GR.TEXT_PRECISION_STRING)
-    elseif haskey(gr_vector_font, family)
-        GR.settextfontprec(gr_vector_font[family], 3)
     end
     gr_set_textcolor(color)
     GR.settextalign(gr_halign[halign], gr_valign[valign])
@@ -435,7 +428,7 @@ function gr_viewport_from_bbox(sp::Subplot{GRBackend}, bb::BoundingBox, w, h, vi
     viewport[3] = viewport_canvas[4] * (1.0 - bottom(bb) / h)
     viewport[4] = viewport_canvas[4] * (1.0 - top(bb) / h)
     if hascolorbar(sp)
-        viewport[2] -= gr_colorbar_ratio * (1 + RecipesPipeline.is3d(sp) / 2)
+        viewport[2] -= gr_colorbar_ratio * (1 + is3d(sp) / 2)
     end
     viewport
 end
@@ -443,8 +436,8 @@ end
 # change so we're focused on the viewport area
 function gr_set_viewport_cmap(sp::Subplot)
     GR.setviewport(
-        viewport_plotarea[2] + (RecipesPipeline.is3d(sp) ? 0.07 : 0.02),
-        viewport_plotarea[2] + (RecipesPipeline.is3d(sp) ? 0.10 : 0.05),
+        viewport_plotarea[2] + (is3d(sp) ? 0.07 : 0.02),
+        viewport_plotarea[2] + (is3d(sp) ? 0.10 : 0.05),
         viewport_plotarea[3],
         viewport_plotarea[4]
     )
@@ -822,7 +815,6 @@ end
 
 function _update_min_padding!(sp::Subplot{GRBackend})
     dpi = sp.plt[:thickness_scaling]
-    ENV["GKS_ENCODING"] = "utf8"
     if !haskey(ENV, "GKSwstype")
         if isijulia()
             ENV["GKSwstype"] = "svg"
@@ -841,7 +833,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
         toppad += h
     end
 
-    if RecipesPipeline.is3d(sp)
+    if is3d(sp)
         xaxis, yaxis, zaxis = sp[:xaxis], sp[:yaxis], sp[:zaxis]
         xticks, yticks, zticks = get_ticks(sp, xaxis), get_ticks(sp, yaxis), get_ticks(sp, zaxis)
         # Add margin for x and y ticks
@@ -1061,7 +1053,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
     # fill in the plot area background
     bg = plot_color(sp[:background_color_inside])
-    RecipesPipeline.is3d(sp) || gr_fill_viewport(viewport_plotarea, bg)
+    is3d(sp) || gr_fill_viewport(viewport_plotarea, bg)
 
     # reduced from before... set some flags based on the series in this subplot
     # TODO: can these be generic flags?
@@ -1132,7 +1124,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     gr_set_font(tickfont(xaxis))
     GR.setlinewidth(sp.plt[:thickness_scaling])
 
-    if RecipesPipeline.is3d(sp)
+    if is3d(sp)
         zmin, zmax = axis_limits(sp, :z)
         GR.setspace(zmin, zmax, round.(Int, sp[:camera])...)
 
@@ -1143,7 +1135,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         plot_area_x = [xmin, xmin, xmin, xmax, xmax, xmax, xmin]
         plot_area_y = [ymin, ymin, ymax, ymax, ymax, ymin, ymin]
         plot_area_z = [zmin, zmax, zmax, zmax, zmin, zmin, zmin]
-        x_bg, y_bg = RecipesPipeline.unzip(GR.wc3towc.(plot_area_x, plot_area_y, plot_area_z))
+        x_bg, y_bg = unzip(GR.wc3towc.(plot_area_x, plot_area_y, plot_area_z))
         GR.fillarea(x_bg, y_bg)
 
         # draw the grid lines
@@ -1432,16 +1424,14 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         end
 
         # border
-        intensity = sp[:framestyle] == :semi ? 0.5 : 1
+        intensity = sp[:framestyle] == :semi ? 0.5 : 1.0
         if sp[:framestyle] in (:box, :semi)
-            GR.setclip(0)
             gr_set_line(intensity, :solid, xaxis[:foreground_color_border])
             gr_set_transparency(xaxis[:foreground_color_border], intensity)
             gr_polyline(coords(xborder_segs)...)
             gr_set_line(intensity, :solid, yaxis[:foreground_color_border])
             gr_set_transparency(yaxis[:foreground_color_border], intensity)
             gr_polyline(coords(yborder_segs)...)
-            GR.setclip(1)
         end
     end
     # end
@@ -1464,7 +1454,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         GR.settextalign(halign, GR.TEXT_VALIGN_TOP)
         gr_text(xpos, viewport_subplot[4], sp[:title])
     end
-    if RecipesPipeline.is3d(sp)
+    if is3d(sp)
         if xaxis[:guide] != ""
             gr_set_font(
                 guidefont(xaxis),
@@ -1721,7 +1711,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
             # draw markers
             if st == :scatter3d || series[:markershape] != :none
-                x2, y2 = RecipesPipeline.unzip(map(GR.wc3towc, x, y, z))
+                x2, y2 = unzip(map(GR.wc3towc, x, y, z))
                 gr_draw_markers(series, x2, y2, clims)
             end
 
@@ -1818,7 +1808,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         if sp[:legend] == :inline && should_add_to_legend(series)
             gr_set_font(legendfont(sp))
             gr_set_textcolor(plot_color(sp[:legendfontcolor]))
-            if sp[:yaxis][:mirror]
+            if sp[:yaxis][:mirror] 
                 (_,i) = sp[:xaxis][:flip] ? findmax(x) : findmin(x)
                 GR.settextalign(GR.TEXT_HALIGN_RIGHT, GR.TEXT_VALIGN_HALF)
                 offset = -0.01
@@ -1837,7 +1827,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     hascolorbar(sp) && gr_draw_colorbar(cbar, sp, get_clims(sp))
 
     # add the legend
-    if !(sp[:legend] in(:none, :inline))
+    if !(sp[:legend] in(:none, :inline)) 
         GR.savestate()
         GR.selntran(0)
         GR.setscale(0)
@@ -1920,7 +1910,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     end
     for ann in sp[:annotations]
         x, y, val = locate_annotation(sp, ann...)
-        x, y = if RecipesPipeline.is3d(sp)
+        x, y = if is3d(sp)
             gr_w3tondc(x, y, z)
         else
             GR.wctondc(x, y)
@@ -1946,7 +1936,6 @@ gr_set_output(wstype::String) = (_gr_wstype[] = wstype)
 
 for (mime, fmt) in _gr_mimeformats
     @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
-        ENV["GKS_ENCODING"] = "utf8"
         GR.emergencyclosegks()
         filepath = tempname() * "." * $fmt
         env = get(ENV, "GKSwstype", "0")
@@ -1965,7 +1954,6 @@ for (mime, fmt) in _gr_mimeformats
 end
 
 function _display(plt::Plot{GRBackend})
-    ENV["GKS_ENCODING"] = "utf8"
     if plt[:display_type] == :inline
         GR.emergencyclosegks()
         filepath = tempname() * ".pdf"

src/backends/pgfplots.jl

@@ -166,7 +166,7 @@ function pgf_series(sp::Subplot, series::Series)
     # function args
     args = if st == :contour
         plotattributes[:z].surf, plotattributes[:x], plotattributes[:y]
-    elseif RecipesPipeline.is3d(st)
+    elseif is3d(st)
         plotattributes[:x], plotattributes[:y], plotattributes[:z]
     elseif st == :straightline
         straightline_data(series)
@@ -271,7 +271,7 @@ function pgf_fillrange_series(series, i, fillrange, args...)
         push!(style, _pgf_series_extrastyle[st])
     end
     kw[:style] = join(style, ',')
-    func = RecipesPipeline.is3d(series) ? PGFPlots.Linear3 : PGFPlots.Linear
+    func = is3d(series) ? PGFPlots.Linear3 : PGFPlots.Linear
     return func(pgf_fillrange_args(fillrange, args...)...; kw...)
 end
 
@@ -444,7 +444,7 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
 
         # add to style/kw for each axis
         for letter in (:x, :y, :z)
-            if letter != :z || RecipesPipeline.is3d(sp)
+            if letter != :z || is3d(sp)
                 axisstyle, axiskw = pgf_axis(sp, letter)
                 append!(style, axisstyle)
                 merge!(kw, axiskw)
@@ -494,7 +494,7 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
         if any(s[:seriestype] == :contour for s in series_list(sp))
             kw[:view] = "{0}{90}"
             kw[:colorbar] = !(sp[:colorbar] in (:none, :off, :hide, false))
-        elseif RecipesPipeline.is3d(sp)
+        elseif is3d(sp)
             azim, elev = sp[:camera]
             kw[:view] = "{$(azim)}{$(elev)}"
         end

src/backends/pgfplotsx.jl

@@ -104,20 +104,14 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
         end
 
         for sp in plt.subplots
-            bb1 = sp.plotarea
-            bb2 = bbox(sp)
-            sp_width = width(bb2)
-            sp_height = height(bb2)
-            dx, dy = bb2.x0
-            lpad = leftpad(sp) + sp[:left_margin]
-            rpad = rightpad(sp) + sp[:right_margin]
-            tpad = toppad(sp) + sp[:top_margin]
-            bpad = bottompad(sp) + sp[:bottom_margin]
-            dx += lpad
-            dy += tpad
-            axis_height = sp_height - (tpad + bpad)
-            axis_width = sp_width - (rpad + lpad)
-
+            bb = bbox(sp)
+            sp_width = width(bb)
+            sp_height = height(bb)
+            dx, dy = bb.x0
+            # TODO: does this hold at every scale?
+            if sp[:legend] in (:outertopright, nothing)
+                dx *= 1.2
+            end
             cstr = plot_color(sp[:background_color_legend])
             a = alpha(cstr)
             fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
@@ -170,9 +164,9 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 "xshift" => string(dx),
                 "yshift" => string(-dy),
             )
-            sp_width > 0 * mm ? push!(axis_opt, "width" => string(axis_width)) :
+            sp_width > 0 * mm ? push!(axis_opt, "width" => string(sp_width)) :
             nothing
-            sp_height > 0 * mm ? push!(axis_opt, "height" => string(axis_height)) :
+            sp_height > 0 * mm ? push!(axis_opt, "height" => string(sp_height)) :
             nothing
             # legend position
             if sp[:legend] isa Tuple
@@ -180,12 +174,13 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 push!(axis_opt["legend style"], "at={($x, $y)}")
             else
                 push!(
-                    axis_opt["legend style"],
-                        get(_pgfplotsx_legend_pos, sp[:legend], ("at" => string((1.02, 1)), "anchor" => "north west"))...
+                    axis_opt,
+                    "legend pos" =>
+                        get(_pgfplotsx_legend_pos, sp[:legend], "outer north east"),
                 )
             end
             for letter in (:x, :y, :z)
-                if letter != :z || RecipesPipeline.is3d(sp)
+                if letter != :z || is3d(sp)
                     pgfx_axis!(axis_opt, sp, letter)
                 end
             end
@@ -224,11 +219,11 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 axis_opt,
                 "colorbar style" => PGFPlotsX.Options(
                     "title" => sp[:colorbar_title],
+                    "point meta max" => get_clims(sp)[2],
+                    "point meta min" => get_clims(sp)[1],
                 ),
-                "point meta max" => get_clims(sp)[2],
-                "point meta min" => get_clims(sp)[1],
             )
-            if RecipesPipeline.is3d(sp)
+            if is3d(sp)
                 azim, elev = sp[:camera]
                 push!(axis_opt, "view" => (azim, elev))
             end
@@ -240,16 +235,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 PGFPlotsX.Axis
             end
             axis = axisf(axis_opt)
-            if sp[:legendtitle] !== nothing
-                push!(axis, PGFPlotsX.Options("\\addlegendimage{empty legend}" => nothing))
-                push!(
-                    axis,
-                    PGFPlotsX.LegendEntry(
-                        string("\\hspace{-.6cm}{\\textbf{", sp[:legendtitle], "}}"),
-                        false,
-                    ),
-                )
-            end
             for (series_index, series) in enumerate(series_list(sp))
                 # give each series a uuid for fillbetween
                 series_id = uuid4()
@@ -261,7 +246,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     "color" => single_color(opt[:linecolor]),
                     "name path" => string(series_id),
                 )
-                if RecipesPipeline.is3d(series) || st == :heatmap
+                if is3d(series) || st == :heatmap
                     series_func = PGFPlotsX.Plot3
                 else
                     series_func = PGFPlotsX.Plot
@@ -367,6 +352,17 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                             series_index,
                         )
                     end
+                    # add series annotations
+                    anns = series[:series_annotations]
+                    for (xi, yi, str, fnt) in EachAnn(anns, series[:x], series[:y])
+                        pgfx_add_annotation!(
+                            axis,
+                            xi,
+                            yi,
+                            PlotText(str, fnt),
+                            pgfx_thickness_scaling(series),
+                        )
+                    end
                     # add to legend?
                     if sp[:legend] != :none
                         leg_entry = if opt[:label] isa AVec
@@ -392,26 +388,15 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                         end
                     end
                 end # for segments
-                # add series annotations
-                anns = series[:series_annotations]
-                for (xi, yi, str, fnt) in EachAnn(anns, series[:x], series[:y])
+                # add subplot annotations
+                for ann in sp[:annotations]
                     pgfx_add_annotation!(
                         axis,
-                        xi,
-                        yi,
-                        PlotText(str, fnt),
-                        pgfx_thickness_scaling(series),
+                        locate_annotation(sp, ann...)...,
+                        pgfx_thickness_scaling(sp),
                     )
                 end
             end # for series
-            # add subplot annotations
-            for ann in sp[:annotations]
-                pgfx_add_annotation!(
-                    axis,
-                    locate_annotation(sp, ann...)...,
-                    pgfx_thickness_scaling(sp),
-                )
-            end
             push!(the_plot, axis)
             if length(plt.o.the_plot.elements) > 0
                 plt.o.the_plot.elements[1] = the_plot
@@ -420,7 +405,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             end
         end # for subplots
         pgfx_plot.is_created = true
-        pgfx_plot.was_shown = false
     end # if
     return pgfx_plot
 end
@@ -432,7 +416,7 @@ end
         opt[:x], opt[:y], Array(opt[:z])'
     elseif st in (:heatmap, :surface, :wireframe)
         surface_to_vecs(opt[:x], opt[:y], opt[:z])
-    elseif RecipesPipeline.is3d(st)
+    elseif is3d(st)
         opt[:x], opt[:y], opt[:z]
     elseif st == :straightline
         straightline_data(series)
@@ -620,22 +604,22 @@ const _pgfplotsx_markers = KW(
 )
 
 const _pgfplotsx_legend_pos = KW(
-    :top => ("at" => string((0.5, 0.98)), "anchor" => "north"),
-    :bottom => ("at" => string((0.5, 0.02)), "anchor" => "south"),
-    :left => ("at" => string((0.02, 0.5)), "anchor" => "west"),
-    :right => ("at" => string((0.98, 0.5)), "anchor" => "east"),
-    :bottomleft => ("at" => string((0.02, 0.02)), "anchor" => "south west"),
-    :bottomright => ("at" => string((0.98, 0.02)), "anchor" => "south east"),
-    :topright => ("at" => string((0.98, 0.98)), "anchor" => "north east"),
-    :topleft => ("at" => string((-0.02, 0.98)), "anchor" => "north west"),
-    :outertop => ("at" => string((0.5, 1.02)), "anchor" => "south"),
-    :outerbottom => ("at" => string((0.5, -0.02)), "anchor" => "north"),
-    :outerleft => ("at" => string((-0.02, 0.5)), "anchor" => "east"),
-    :outerright => ("at" => string((1.02, 0.5)), "anchor" => "west"),
-    :outerbottomleft => ("at" => string((-0.02, -0.02)), "anchor" => "north east"),
-    :outerbottomright => ("at" => string((1.02, -0.02)), "anchor" => "north west"),
-    :outertopright => ("at" => string((1.02, 1)), "anchor" => "north west"),
-    :outertopleft => ("at" => string((-0.02, 1)), "anchor" => "north east"),
+    :top => "north",
+    :bottom => "south",
+    :left => "west",
+    :right => "east",
+    :bottomleft => "south west",
+    :bottomright => "south east",
+    :topright => "north east",
+    :topleft => "north west",
+    :outertop => "north",
+    :outerbottom => "outer south",
+    :outerleft => "outer west",
+    :outerright => "outer east",
+    :outerbottomleft => "outer south west",
+    :outerbottomright => "outer south east",
+    :outertopright => "outer north east",
+    :outertopleft => "outer north west",
 )
 
 const _pgfx_framestyles = [:box, :axes, :origin, :zerolines, :grid, :none]
@@ -768,7 +752,7 @@ function pgfx_marker(plotattributes, i = 1)
     a_stroke = alpha(cstr_stroke)
     mark_size =
         pgfx_thickness_scaling(plotattributes) *
-        0.75 *
+        0.5 *
         _cycle(plotattributes[:markersize], i)
     return PGFPlotsX.Options(
         "mark" =>
@@ -780,7 +764,7 @@ function pgfx_marker(plotattributes, i = 1)
             "fill" => cstr,
             "fill opacity" => a,
             "line width" =>
-                pgfx_thickness_scaling(plotattributes) * 0.75 *
+                pgfx_thickness_scaling(plotattributes) *
                 _cycle(plotattributes[:markerstrokewidth], i),
             "rotate" => if shape == :dtriangle
                 180
@@ -884,7 +868,7 @@ function pgfx_fillrange_series!(axis, series, series_func, i, fillrange, rng)
     fillrange_opt = merge(fillrange_opt, pgfx_marker(series, i))
     push!(fillrange_opt, "forget plot" => nothing)
     opt = series.plotattributes
-    args = RecipesPipeline.is3d(series) ? (opt[:x][rng], opt[:y][rng], opt[:z][rng]) :
+    args = is3d(series) ? (opt[:x][rng], opt[:y][rng], opt[:z][rng]) :
         (opt[:x][rng], opt[:y][rng])
     push!(
         axis,
@@ -916,15 +900,6 @@ function pgfx_sanitize_string(s::AbstractString)
     s = replace(s, r"\\?\%" => "\\%")
     s = replace(s, r"\\?\_" => "\\_")
     s = replace(s, r"\\?\&" => "\\&")
-    s = replace(s, r"\\?\{" => "\\{")
-    s = replace(s, r"\\?\}" => "\\}")
-end
-@require LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" begin
-    using .LaTeXStrings
-    function pgfx_sanitize_string(s::LaTeXString)
-        s = replace(s, r"\\?\#" => "\\#")
-        s = replace(s, r"\\?\%" => "\\%")
-    end
 end
 function pgfx_sanitize_plot!(plt)
         for (key, value) in plt.attr
@@ -1023,8 +998,6 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
     # ticks on or off
     if axis[:ticks] in (nothing, false, :none) || framestyle == :none
         push!(opt, "$(letter)majorticks" => "false")
-    elseif framestyle in (:grid, :zerolines)
-        push!(opt, "$letter tick style" => PGFPlotsX.Options("draw" => "none"))
     end
 
     # grid on or off
@@ -1040,7 +1013,6 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
     push!(opt, string(letter, :min) => lims[1], string(letter, :max) => lims[2])
 
     if !(axis[:ticks] in (nothing, false, :none, :native)) && framestyle != :none
-        # ticks
         ticks = get_ticks(sp, axis)
         #pgf plot ignores ticks with angle below 90 when xmin = 90 so shift values
         tick_values =
@@ -1106,37 +1078,6 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
                 axis[:gridstyle],
             ),
         )
-
-        # minor ticks
-        # NOTE: PGFPlots would provide "minor x ticks num", but this only places minor ticks
-        #       between major ticks and not outside first and last tick to the axis limits.
-        #       Hence, we hack around with extra ticks. Unfortunately this conflicts with
-        #       `:zerolines` framestyle hack. So minor ticks are not working with
-        #       `:zerolines`.
-        minor_ticks = get_minor_ticks(sp, axis, ticks)
-        if minor_ticks !== nothing
-            minor_ticks =
-                ispolar(sp) && letter == :x ? [rad2deg.(minor_ticks)[3:end]..., 360, 405] :
-                minor_ticks
-            push!(
-                opt,
-                string("extra ", letter, " ticks") => string("{", join(minor_ticks, ","), "}"),
-            )
-            push!(opt, string("extra ", letter, " tick labels") => "")
-            push!(
-                opt,
-                string("extra ", letter, " tick style") => PGFPlotsX.Options(
-                    "grid" => axis[:minorgrid] ? "major" : "none",
-                    string(letter, " grid style") => pgfx_linestyle(
-                        pgfx_thickness_scaling(sp) * axis[:minorgridlinewidth],
-                        axis[:foreground_color_minor_grid],
-                        axis[:minorgridalpha],
-                        axis[:minorgridstyle],
-                    ),
-                    "major tick length" => typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 || axis[:minorticks] ? "0.1cm" : "0"
-                ),
-            )
-        end
     end
 
     # framestyle
@@ -1158,7 +1099,7 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
             opt,
             string("extra ", letter, " tick style") => PGFPlotsX.Options(
                 "grid" => "major",
-                string(letter, " grid style") => pgfx_linestyle(
+                "major grid style" => pgfx_linestyle(
                     pgfx_thickness_scaling(sp),
                     axis[:foreground_color_border],
                     1.0,
@@ -1188,12 +1129,12 @@ end
 # Set the (left, top, right, bottom) minimum padding around the plot area
 # to fit ticks, tick labels, guides, colorbars, etc.
 function _update_min_padding!(sp::Subplot{PGFPlotsXBackend})
-    leg = sp[:legend]
-    if leg in (:best, :outertopright, :outerright, :outerbottomright) || (leg isa Tuple && leg[1] >= 1)
-        sp.minpad = (0mm, 0mm, 5mm, 0mm)
-    else
-        sp.minpad = (0mm, 0mm, 0mm, 0mm)
-    end
+    # TODO: make padding more intelligent
+    # TODO: how to include margins properly?
+    # sp.minpad = (50mm + sp[:left_margin],
+    #              0mm + sp[:top_margin],
+    #              50mm + sp[:right_margin],
+    #              0mm + sp[:bottom_margin])
 end
 
 function _create_backend_figure(plt::Plot{PGFPlotsXBackend})

src/backends/plotly.jl

@@ -162,7 +162,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
 
     if letter in (:x,:y)
         ax[:domain] = plotly_domain(sp, letter)
-        if RecipesPipeline.is3d(sp)
+        if is3d(sp)
             # don't link 3d axes for synchronized interactivity
             x_idx = y_idx = sp[:subplot_index]
         else
@@ -176,7 +176,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
     lims = axis_limits(sp, letter)
 
     if axis[:ticks] != :native || axis[:lims] != :auto
-        ax[:range] = map(RecipesPipeline.scale_func(axis[:scale]), lims)
+        ax[:range] = map(scalefunc(axis[:scale]), lims)
     end
 
     if !(axis[:ticks] in (nothing, :none, false))
@@ -263,8 +263,8 @@ function plotly_layout(plt::Plot)
         # set to supported framestyle
         sp[:framestyle] = _plotly_framestyle(sp[:framestyle])
 
-        # if any(RecipesPipeline.is3d, seriesargs)
-        if RecipesPipeline.is3d(sp)
+        # if any(is3d, seriesargs)
+        if is3d(sp)
             azim = sp[:camera][1] - 90 #convert azimuthal to match GR behaviour
             theta = 90 - sp[:camera][2] #spherical coordinate angle from z axis
             plotattributes_out[:scene] = KW(
@@ -748,11 +748,11 @@ function plotly_colorbar_hack(series::Series, plotattributes_base::KW, sym::Symb
     plotattributes_out = deepcopy(plotattributes_base)
     cmin, cmax = get_clims(series[:subplot])
     plotattributes_out[:showlegend] = false
-    plotattributes_out[:type] = RecipesPipeline.is3d(series) ? :scatter3d : :scatter
+    plotattributes_out[:type] = is3d(series) ? :scatter3d : :scatter
     plotattributes_out[:hoverinfo] = :none
     plotattributes_out[:mode] = :markers
     plotattributes_out[:x], plotattributes_out[:y] = [series[:x][1]], [series[:y][1]]
-    if RecipesPipeline.is3d(series)
+    if is3d(series)
         plotattributes_out[:z] = [series[:z][1]]
     end
     # zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)

src/backends/plotlyjs.jl

@@ -40,9 +40,11 @@ _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standal
 
 _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 
-function PlotlyJS.WebIO.render(plt::Plot{PlotlyJSBackend})
-    plt_html = sprint(show, MIME("text/html"), plt)
-    return PlotlyJS.WebIO.render(PlotlyJS.WebIO.dom"div"(innerHTML=plt_html))
+@require WebIO = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" begin
+    function WebIO.render(plt::Plot{PlotlyJSBackend})
+        plt_html = sprint(show, MIME("text/html"), plt)
+        return WebIO.render(dom"div"(innerHTML=plt_html))
+    end
 end
 
 function closeall(::PlotlyJSBackend)

src/backends/pyplot.jl

@@ -229,6 +229,11 @@ function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
     end
 end
 
+py_linecolor(series::Series)          = py_color(series[:linecolor])
+py_markercolor(series::Series)        = py_color(series[:markercolor])
+py_markerstrokecolor(series::Series)  = py_color(series[:markerstrokecolor])
+py_fillcolor(series::Series)          = py_color(series[:fillcolor])
+
 py_linecolormap(series::Series)       = py_colormap(series[:linecolor])
 py_markercolormap(series::Series)     = py_colormap(series[:markercolor])
 py_fillcolormap(series::Series)       = py_colormap(series[:fillcolor])
@@ -443,7 +448,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             #         :norm => pycolors["Normalize"](; extrakw...)
             #     )
             #     lz = _cycle(series[:line_z], 1:n)
-            #     handle = if RecipesPipeline.is3d(st)
+            #     handle = if is3d(st)
             #         line_segments = [[(x[j], y[j], z[j]) for j in rng] for rng in segments]
             #         lc = pyart3d["Line3DCollection"](line_segments; kw...)
             #         lc[:set_array](lz)
@@ -473,7 +478,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             # end
 
             a = series[:arrow]
-            if a !== nothing && !RecipesPipeline.is3d(st)  # TODO: handle 3d later
+            if a !== nothing && !is3d(st)  # TODO: handle 3d later
                 if typeof(a) != Arrow
                     @warn("Unexpected type for arrow: $(typeof(a))")
                 else
@@ -481,8 +486,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                         :arrowstyle => "simple,head_length=$(a.headlength),head_width=$(a.headwidth)",
                         :shrinkA => 0,
                         :shrinkB => 0,
-                        :edgecolor => py_color(get_linecolor(series)),
-                        :facecolor => py_color(get_linecolor(series)),
+                        :edgecolor => py_linecolor(series),
+                        :facecolor => py_linecolor(series),
                         :linewidth => py_thickness_scale(plt, get_linewidth(series)),
                         :linestyle => py_linestyle(st, get_linestyle(series)),
                     )
@@ -528,19 +533,16 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             handle = []
             x,y = xyargs
             shapes = series[:markershape]
-            msc = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series))
+            msc = py_markerstrokecolor(series)
             lw = py_thickness_scale(plt, series[:markerstrokewidth])
             for i=eachindex(y)
-                if series[:marker_z] !== nothing
-                    extrakw[:c] = [py_color(get_markercolor(series, i), get_markercoloralpha(series, i))]
-                end
+                extrakw[:c] = _cycle(markercolor, i)
 
                 push!(handle, ax."scatter"(_cycle(x,i), _cycle(y,i);
                     label = series[:label],
                     zorder = series[:series_plotindex] + 0.5,
                     marker = py_marker(_cycle(shapes,i)),
                     s =  py_thickness_scale(plt, _cycle(series[:markersize],i) .^ 2),
-                    facecolors = py_color(get_markercolor(series, i), get_markercoloralpha(series, i)),
                     edgecolors = msc,
                     linewidths = lw,
                     extrakw...
@@ -580,7 +582,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                   zorder = series[:series_plotindex] + 0.5,
                   marker = prev_marker,
                   s = cur_scale_list,
-                  edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),  # Do we need include i?
+                  edgecolors = py_markerstrokecolor(series),
                   linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                   facecolors = cur_color_list,
                   extrakw...
@@ -601,7 +603,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex] + 0.5,
                 marker = prev_marker,
                 s = cur_scale_list,
-                edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
+                edgecolors = py_markerstrokecolor(series),
                 linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                 facecolors = cur_color_list,
                 extrakw...
@@ -616,7 +618,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex] + 0.5,
                 marker = py_marker(series[:markershape]),
                 s = py_thickness_scale(plt, series[:markersize] .^ 2),
-                edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
+                edgecolors = py_markerstrokecolor(series),
                 linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                 extrakw...
             )
@@ -630,7 +632,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             zorder = series[:series_plotindex],
             gridsize = series[:bins],
             linewidths = py_thickness_scale(plt, series[:linewidth]),
-            edgecolors = py_color(get_linecolor(series)),
+            edgecolors = py_linecolor(series),
             cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             extrakw...
         )
@@ -703,7 +705,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 rstride = series[:stride][1],
                 cstride = series[:stride][2],
                 linewidth = py_thickness_scale(plt, series[:linewidth]),
-                edgecolor = py_color(get_linecolor(series)),
+                edgecolor = py_linecolor(series),
                 extrakw...
             )
             push!(handles, handle)
@@ -729,7 +731,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex],
                 cmap = py_fillcolormap(series),
                 linewidth = py_thickness_scale(plt, series[:linewidth]),
-                edgecolor = py_color(get_linecolor(series)),
+                edgecolor = py_linecolor(series),
                 extrakw...
             )
             push!(handles, handle)
@@ -1048,7 +1050,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
         end
 
         # framestyle
-        if !ispolar(sp) && !RecipesPipeline.is3d(sp)
+        if !ispolar(sp) && !is3d(sp)
             ax.spines["left"]."set_linewidth"(py_thickness_scale(plt, 1))
             ax.spines["bottom"]."set_linewidth"(py_thickness_scale(plt, 1))
             if sp[:framestyle] == :semi
@@ -1101,23 +1103,13 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 ticks[2][ticks[1] .== 0] .= ""
             end
             axis[:ticks] != :native ? py_set_ticks(ax, ticks, letter) : nothing
-
-            intensity = 0.5  # This value corresponds to scaling of other grid elements
-            pyaxis."set_tick_params"(direction = axis[:tick_direction] == :out ? "out" : "in", width=py_thickness_scale(plt, intensity))
-
+            pyaxis."set_tick_params"(direction = axis[:tick_direction] == :out ? "out" : "in")
             getproperty(ax, Symbol("set_", letter, "label"))(axis[:guide])
             if get(axis.plotattributes, :flip, false)
                 getproperty(ax, Symbol("invert_", letter, "axis"))()
             end
             pyaxis."label"."set_fontsize"(py_thickness_scale(plt, axis[:guidefontsize]))
             pyaxis."label"."set_family"(axis[:guidefontfamily])
-
-            if (letter == :y && !RecipesPipeline.is3d(sp))
-                pyaxis."label"."set_rotation"(axis[:guidefontrotation] + 90)
-            else
-                pyaxis."label"."set_rotation"(axis[:guidefontrotation])
-            end
-
             for lab in getproperty(ax, Symbol("get_", letter, "ticklabels"))()
                 lab."set_fontsize"(py_thickness_scale(plt, axis[:tickfontsize]))
                 lab."set_family"(axis[:tickfontfamily])
@@ -1169,7 +1161,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
         end
 
         #camera/view angle
-        if RecipesPipeline.is3d(sp)
+        if is3d(sp)
             #convert azimuthal to match GR behaviour
             #view_init(elevation, azimuthal) so reverse :camera args
             ax."view_init"((sp[:camera].-(90,0))[end:-1:1]...)
@@ -1306,29 +1298,25 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
             if should_add_to_legend(series)
                 clims = get_clims(sp, series)
                 # add a line/marker and a label
-                push!(handles,
-                    if series[:seriestype] == :shape || series[:fillrange] !== nothing
-                        pypatches."Patch"(
-                            edgecolor = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
-                            facecolor = py_color(single_color(get_fillcolor(series, clims)), get_fillalpha(series)),
-                            linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
-                            linestyle = py_linestyle(series[:seriestype], get_linestyle(series))
-                        )
-                    elseif series[:seriestype] in (:path, :straightline, :scatter)
-                        PyPlot.plt."Line2D"((0,1),(0,0),
-                            color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
-                            linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
-                            linestyle = py_linestyle(:path, get_linestyle(series)),
-                            marker = py_marker(_cycle(series[:markershape], 1)),
-                            # markersize = py_thickness_scale(plt, series[:markersize]), # In case we decide that markersize needs to be scaled in the legend too
-                            markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
-                            markerfacecolor = py_color(single_color(get_markercolor(series, clims)), get_markeralpha(series)),
-                            markeredgewidth = py_thickness_scale(plt, series[:markerstrokewidth])
-                        )
-                    else
-                        series[:serieshandle][1]
-                    end
-                )
+                push!(handles, if series[:seriestype] == :shape || series[:fillrange] !== nothing
+                    pypatches."Patch"(
+                        edgecolor = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
+                        facecolor = py_color(single_color(get_fillcolor(series, clims)), get_fillalpha(series)),
+                        linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
+                        linestyle = py_linestyle(series[:seriestype], get_linestyle(series))
+                    )
+                elseif series[:seriestype] in (:path, :straightline, :scatter)
+                    PyPlot.plt."Line2D"((0,1),(0,0),
+                        color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
+                        linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
+                        linestyle = py_linestyle(:path, get_linestyle(series)),
+                        marker = py_marker(first(series[:markershape])),
+                        markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
+                        markerfacecolor = py_color(single_color(get_markercolor(series, clims)), get_markeralpha(series))
+                    )
+                else
+                    series[:serieshandle][1]
+                end)
                 push!(labels, series[:label])
             end
         end
@@ -1344,7 +1332,6 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 facecolor = py_color(sp[:background_color_legend]),
                 edgecolor = py_color(sp[:foreground_color_legend]),
                 framealpha = alpha(plot_color(sp[:background_color_legend])),
-                fancybox = false  # makes the legend box square
             )
             frame = leg."get_frame"()
             frame."set_linewidth"(py_thickness_scale(plt, 1))

src/backends/unicodeplots.jl

@@ -126,7 +126,7 @@ function addUnicodeSeries!(o, plotattributes, addlegend::Bool, xlim, ylim)
     color = plotattributes[:linecolor] in UnicodePlots.color_cycle ? plotattributes[:linecolor] : :auto
 
     # add the series
-    x, y = RecipesPipeline.unzip(collect(Base.Iterators.filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y))))
+    x, y = Plots.unzip(collect(Base.Iterators.filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y))))
     func(o, x, y; color = color, name = label)
 end
 

src/components.jl

@@ -29,7 +29,7 @@ end
 
 Construct a polygon to be plotted
 """
-Shape(verts::AVec) = Shape(RecipesPipeline.unzip(verts)...)
+Shape(verts::AVec) = Shape(unzip(verts)...)
 Shape(s::Shape) = deepcopy(s)
 
 get_xs(shape::Shape) = shape.x

src/examples.jl

@@ -934,78 +934,23 @@ const _examples = PlotExample[
             end,
         ],
     ),
-    PlotExample(
-        "Linked axes",
-        "",
-        [
-            quote
-                begin
-                    x = -5:0.1:5
-                    plot(plot(x, x->x^2), plot(x, x->sin(x)), layout = 2, link = :y)
-                end
-            end,
-        ],
-    ),
-    PlotExample(
-        "Error bars and array type recipes",
-        "",
-        [
-            quote
-                begin
-                    struct Measurement <: Number
-                        val::Float64
-                        err::Float64
-                    end
-                    value(m::Measurement) = m.val
-                    uncertainty(m::Measurement) = m.err
-
-                    @recipe function f(::Type{T}, m::T) where T <: AbstractArray{<:Measurement}
-                        if !(get(plotattributes, :seriestype, :path) in [:contour, :contourf, :contour3d, :heatmap, :surface, :wireframe, :image])
-                            error_sym = Symbol(plotattributes[:letter], :error)
-                            plotattributes[error_sym] = uncertainty.(m)
-                        end
-                        value.(m)
-                    end
-
-                    x = Measurement.(10sort(rand(10)), rand(10))
-                    y = Measurement.(10sort(rand(10)), rand(10))
-                    z = Measurement.(10sort(rand(10)), rand(10))
-                    surf = Measurement.((1:10) .* (1:10)', rand(10,10))
-
-                    plot(
-                        scatter(x, [x y], msw = 0),
-                        scatter(x, y, z, msw = 0),
-                        heatmap(x, y, surf),
-                        wireframe(x, y, surf),
-                        legend = :topleft
-                    )
-                end
-            end,
-        ],
-    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages
-_animation_examples = [2, 31]
+_animation_examples = [2, 30]
 _backend_skips = Dict(
     :gr => [25, 30],
-    :pyplot => [2, 25, 30, 31],
+    :pyplot => [25, 30],
     :plotlyjs => [2, 21, 24, 25, 30, 31],
     :plotly => [2, 21, 24, 25, 30, 31],
     :pgfplots => [2, 5, 6, 10, 16, 20, 22, 23, 25, 28, 30, 31, 34, 37, 38, 39],
-    :pgfplotsx => [
-        2, # animation
-        6, # images
-        10, # histogram2d
-        16, # pgfplots thinks the upper panel is too small
-        22, # contourf
-        23, # pie
-        31, # animation
-        32, # spy
-        38, # histogram2d
-        45, # wireframe
-    ],
-)
+    :pgfplotsx => [ 6, # images
+                    10, # histogram2d
+                    22, # contourf
+                    23, # pie
+                    32, # spy
+                    38, # histogram2d
+                  ] )
 
 
 

src/init.jl

@@ -3,7 +3,7 @@ using REPL
 
 function _plots_defaults()
     if isdefined(Main, :PLOTS_DEFAULTS)
-        copy(Dict{Symbol,Any}(Main.PLOTS_DEFAULTS))
+        Dict{Symbol,Any}(Main.PLOTS_DEFAULTS)
     else
         Dict{Symbol,Any}()
     end
@@ -13,9 +13,11 @@ end
 function __init__()
     user_defaults = _plots_defaults()
     if haskey(user_defaults, :theme)
-        theme(pop!(user_defaults, :theme))
+        theme(user_defaults[:theme])
+    end
+    for (k,v) in user_defaults
+        k == :theme || default(k, v)
     end
-    default(; user_defaults...)
 
     insert!(Base.Multimedia.displays, findlast(x -> x isa Base.TextDisplay || x isa REPL.REPLDisplay, Base.Multimedia.displays) + 1, PlotsDisplay())
 

src/output.jl

@@ -1,51 +1,54 @@
 
+
 defaultOutputFormat(plt::Plot) = "png"
 
 function png(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "png")
-    io = open(fn, "w")
-    show(io, MIME("image/png"), plt)
-    close(io)
+  fn = addExtension(fn, "png")
+  io = open(fn, "w")
+  show(io, MIME("image/png"), plt)
+  close(io)
 end
 png(fn::AbstractString) = png(current(), fn)
 
 function svg(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "svg")
-    io = open(fn, "w")
-    show(io, MIME("image/svg+xml"), plt)
-    close(io)
+  fn = addExtension(fn, "svg")
+  io = open(fn, "w")
+  show(io, MIME("image/svg+xml"), plt)
+  close(io)
 end
 svg(fn::AbstractString) = svg(current(), fn)
 
+
 function pdf(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "pdf")
-    io = open(fn, "w")
-    show(io, MIME("application/pdf"), plt)
-    close(io)
+  fn = addExtension(fn, "pdf")
+  io = open(fn, "w")
+  show(io, MIME("application/pdf"), plt)
+  close(io)
 end
 pdf(fn::AbstractString) = pdf(current(), fn)
 
+
 function ps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "ps")
-    io = open(fn, "w")
-    show(io, MIME("application/postscript"), plt)
-    close(io)
+  fn = addExtension(fn, "ps")
+  io = open(fn, "w")
+  show(io, MIME("application/postscript"), plt)
+  close(io)
 end
 ps(fn::AbstractString) = ps(current(), fn)
 
 function eps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "eps")
-    io = open(fn, "w")
-    show(io, MIME("image/eps"), plt)
-    close(io)
+  fn = addExtension(fn, "eps")
+  io = open(fn, "w")
+  show(io, MIME("image/eps"), plt)
+  close(io)
 end
 eps(fn::AbstractString) = eps(current(), fn)
 
 function tex(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "tex")
-    io = open(fn, "w")
-    show(io, MIME("application/x-tex"), plt)
-    close(io)
+  fn = addExtension(fn, "tex")
+  io = open(fn, "w")
+  show(io, MIME("application/x-tex"), plt)
+  close(io)
 end
 tex(fn::AbstractString) = tex(current(), fn)
 
@@ -66,39 +69,48 @@ end
 html(fn::AbstractString) = html(current(), fn)
 
 function txt(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "txt")
-    io = open(fn, "w")
-    show(io, MIME("text/plain"), plt)
-    close(io)
+  fn = addExtension(fn, "txt")
+  io = open(fn, "w")
+  show(io, MIME("text/plain"), plt)
+  close(io)
 end
 txt(fn::AbstractString) = txt(current(), fn)
 
-
 # ----------------------------------------------------------------
 
+
 const _savemap = Dict(
     "png" => png,
     "svg" => svg,
     "pdf" => pdf,
-    "ps" => ps,
+    "ps"  => ps,
     "eps" => eps,
     "tex" => tex,
     "json" => json,
     "html" => html,
     "tikz" => tex,
     "txt" => txt,
-)
+  )
 
-const _extension_map = Dict("tikz" => "tex")
+function getExtension(fn::AbstractString)
+  pieces = split(fn, ".")
+  length(pieces) > 1 || error("Can't extract file extension: ", fn)
+  ext = pieces[end]
+  haskey(_savemap, ext) || error("Invalid file extension: ", fn)
+  ext
+end
 
 function addExtension(fn::AbstractString, ext::AbstractString)
-    oldfn, oldext = splitext(fn)
-    oldext = chop(oldext, head = 1, tail = 0)
-    if get(_extension_map, oldext, oldext) == ext
-        return fn
+  try
+    oldext = getExtension(fn)
+    if oldext == ext
+      return fn
     else
-        return string(fn, ".", ext)
+      return "$fn.$ext"
     end
+  catch
+    return "$fn.$ext"
+  end
 end
 
 """
@@ -109,28 +121,27 @@ type is inferred from the file extension. All backends support png and pdf
 file types, some also support svg, ps, eps, html and tex.
 """
 function savefig(plt::Plot, fn::AbstractString)
-    fn = abspath(expanduser(fn))
+  fn = abspath(expanduser(fn))
+  # get the extension
+  local ext
+  try
+    ext = getExtension(fn)
+  catch
+    # if we couldn't extract the extension, add the default
+    ext = defaultOutputFormat(plt)
+    fn = addExtension(fn, ext)
+  end
 
-    # get the extension
-    fn, ext = splitext(fn)
-    ext = chop(ext, head = 1, tail = 0)
-    if isempty(ext)
-        ext = defaultOutputFormat(plt)
-    end
-
-    # save it
-    if haskey(_savemap, ext)
-        func = _savemap[ext]
-        return func(plt, fn)
-    else
-        error("Invalid file extension: ", fn)
-    end
+  # save it
+  func = get(_savemap, ext) do
+    error("Unsupported extension $ext with filename ", fn)
+  end
+  func(plt, fn)
 end
 savefig(fn::AbstractString) = savefig(current(), fn)
 
 
 # ---------------------------------------------------------
-
 """
     gui([plot])
 
@@ -153,13 +164,17 @@ end
 _do_plot_show(plt, showval::Bool) = showval && gui(plt)
 function _do_plot_show(plt, showval::Symbol)
     showval == :gui && gui(plt)
-    showval in (:inline, :ijulia) && inline(plt)
+    showval in (:inline,:ijulia) && inline(plt)
 end
 
 # ---------------------------------------------------------
 
-const _best_html_output_type =
-    KW(:pyplot => :png, :unicodeplots => :txt, :plotlyjs => :html, :plotly => :html)
+const _best_html_output_type = KW(
+    :pyplot => :png,
+    :unicodeplots => :txt,
+    :plotlyjs => :html,
+    :plotly => :html
+)
 
 # a backup for html... passes to svg or png depending on the html_output_format arg
 function _show(io::IO, ::MIME"text/html", plt::Plot)
@@ -169,12 +184,7 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
     end
     if output_type == :png
         # @info("writing png to html output")
-        print(
-            io,
-            "<img src=\"data:image/png;base64,",
-            base64encode(show, MIME("image/png"), plt),
-            "\" />",
-        )
+        print(io, "<img src=\"data:image/png;base64,", base64encode(show, MIME("image/png"), plt), "\" />")
     elseif output_type == :svg
         # @info("writing svg to html output")
         show(io, MIME("image/svg+xml"), plt)
@@ -186,7 +196,7 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
 end
 
 # delegate showable to _show instead
-function Base.showable(m::M, plt::P) where {M <: MIME, P <: Plot}
+function Base.showable(m::M, plt::P) where {M<:MIME, P<:Plot}
     return hasmethod(_show, Tuple{IO, M, P})
 end
 
@@ -195,31 +205,21 @@ function _display(plt::Plot)
 end
 
 # for writing to io streams... first prepare, then callback
-for mime in (
-    "text/plain",
-    "text/html",
-    "image/png",
-    "image/eps",
-    "image/svg+xml",
-    "application/eps",
-    "application/pdf",
-    "application/postscript",
-    "application/x-tex",
-    "application/vnd.plotly.v1+json",
-)
+for mime in ("text/plain", "text/html", "image/png", "image/eps", "image/svg+xml",
+             "application/eps", "application/pdf", "application/postscript",
+             "application/x-tex", "application/vnd.plotly.v1+json")
     @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
         if haskey(io, :juno_plotsize)
-            showjuno(io, m, plt)
+          showjuno(io, m, plt)
         else
-            prepare_output(plt)
-            _show(io, m, plt)
+          prepare_output(plt)
+          _show(io, m, plt)
         end
         return nothing
     end
 end
 
-Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) =
-    showjuno(io, MIME("text/html"), plt)
+Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) = showjuno(io, MIME("text/html"), plt)
 
 # default text/plain for all backends
 _show(io::IO, ::MIME{Symbol("text/plain")}, plt::Plot) = show(io, plt)
@@ -258,25 +258,25 @@ function showjuno(io::IO, m, plt)
 
     scale = minimum(jsize[i] / sz[i] for i in 1:2)
     plt[:size] = [s * scale for s in sz]
-    plt[:dpi] = jratio * Plots.DPI
+    plt[:dpi] = jratio*Plots.DPI
     plt[:thickness_scaling] *= scale
 
     prepare_output(plt)
     try
-        _showjuno(io, m, plt)
+      _showjuno(io, m, plt)
     finally
-        plt[:size] = sz
-        plt[:dpi] = dpi
-        plt[:thickness_scaling] = thickness_scaling
+      plt[:size] = sz
+      plt[:dpi] = dpi
+      plt[:thickness_scaling] = thickness_scaling
     end
 end
 
 function _showjuno(io::IO, m::MIME"image/svg+xml", plt)
-    if Symbol(plt.attr[:html_output_format]) ≠ :svg
-        throw(MethodError(show, (typeof(m), typeof(plt))))
-    else
-        _show(io, m, plt)
-    end
+  if Symbol(plt.attr[:html_output_format]) ≠ :svg
+    throw(MethodError(show, (typeof(m), typeof(plt))))
+  else
+    _show(io, m, plt)
+  end
 end
 
 Base.showable(::MIME"application/prs.juno.plotpane+html", plt::Plot) = false

src/pipeline.jl

@@ -1,8 +1,8 @@
-# RecipesPipeline API
+# RecipePipeline API
 
 ## Warnings
 
-function RecipesPipeline.warn_on_recipe_aliases!(
+function RecipePipeline.warn_on_recipe_aliases!(
     plt::Plot,
     plotattributes,
     recipe_type,
@@ -14,25 +14,25 @@ function RecipesPipeline.warn_on_recipe_aliases!(
             if k !== dk
                 @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $(_signature_string(Val{recipe_type}, args...)). To ensure expected behavior it is recommended to use the default attribute `$dk`."
             end
-            plotattributes[dk] = RecipesPipeline.pop_kw!(plotattributes, k)
+            plotattributes[dk] = pop_kw!(plotattributes, k)
         end
     end
 end
-function RecipesPipeline.warn_on_recipe_aliases!(
+function RecipePipeline.warn_on_recipe_aliases!(
     plt::Plot,
     v::AbstractVector,
     recipe_type,
     args...,
 )
-    foreach(x -> RecipesPipeline.warn_on_recipe_aliases!(plt, x, recipe_type, args...), v)
+    foreach(x -> RecipePipeline.warn_on_recipe_aliases!(plt, x, recipe_type, args...), v)
 end
-function RecipesPipeline.warn_on_recipe_aliases!(
+function RecipePipeline.warn_on_recipe_aliases!(
     plt::Plot,
     rd::RecipeData,
     recipe_type,
     args...,
 )
-    RecipesPipeline.warn_on_recipe_aliases!(plt, rd.plotattributes, recipe_type, args...)
+    RecipePipeline.warn_on_recipe_aliases!(plt, rd.plotattributes, recipe_type, args...)
 end
 
 function _signature_string(::Type{Val{:user}}, args...)
@@ -45,28 +45,28 @@ _signature_string(::Type{Val{:series}}, st) = "(::Type{Val{:$st}}, x, y, z)"
 
 ## Grouping
 
-RecipesPipeline.splittable_attribute(plt::Plot, key, val::SeriesAnnotations, len) =
-    RecipesPipeline.splittable_attribute(plt, key, val.strs, len)
+RecipePipeline.splittable_attribute(plt::Plot, key, val::SeriesAnnotations, len) =
+    RecipePipeline.splittable_attribute(plt, key, val.strs, len)
 
-function RecipesPipeline.split_attribute(plt::Plot, key, val::SeriesAnnotations, indices)
-    split_strs = _RecipesPipeline.split_attribute(key, val.strs, indices)
+function RecipePipeline.split_attribute(plt::Plot, key, val::SeriesAnnotations, indices)
+    split_strs = _RecipePipeline.split_attribute(key, val.strs, indices)
     return SeriesAnnotations(split_strs, val.font, val.baseshape, val.scalefactor)
 end
 
 
 ## Preprocessing attributes
 
-RecipesPipeline.preprocess_attributes!(plt::Plot, plotattributes) =
-    RecipesPipeline.preprocess_attributes!(plotattributes) # in src/args.jl
+RecipePipeline.preprocess_attributes!(plt::Plot, plotattributes) =
+    preprocess_attributes!(plotattributes) # in src/args.jl
 
-RecipesPipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl
+RecipePipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl
 
-RecipesPipeline.is_subplot_attribute(plt::Plot, attr) = is_subplot_attr(attr) # in src/args.jl
+RecipePipeline.is_subplot_attribute(plt::Plot, attr) = is_subplot_attr(attr) # in src/args.jl
 
 
 ## User recipes
 
-function RecipesPipeline.process_userrecipe!(plt::Plot, kw_list, kw)
+function RecipePipeline.process_userrecipe!(plt::Plot, kw_list, kw)
     _preprocess_userrecipe(kw)
     warn_on_unsupported_scales(plt.backend, kw)
     # add the plot index
@@ -105,7 +105,7 @@ end
 function _add_errorbar_kw(kw_list::Vector{KW}, kw::AKW)
     # handle error bars by creating new recipedata data... these will have
     # the same recipedata index as the recipedata they are copied from
-    for esym in (:xerror, :yerror, :zerror)
+    for esym in (:xerror, :yerror)
         if get(kw, esym, nothing) !== nothing
             # we make a copy of the KW and apply an errorbar recipe
             errkw = copy(kw)
@@ -142,22 +142,22 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW)
 end
 
 
-RecipesPipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter)
+RecipePipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], :x)
 
 
 ## Plot recipes
 
-RecipesPipeline.type_alias(plt::Plot) = get(_typeAliases, st, st)
+RecipePipeline.type_alias(plt::Plot) = get(_typeAliases, st, st)
 
 
 ## Plot setup
 
-function RecipesPipeline.plot_setup!(plt::Plot, plotattributes, kw_list)
+function RecipePipeline.plot_setup!(plt::Plot, plotattributes, kw_list)
     _plot_setup(plt, plotattributes, kw_list)
     _subplot_setup(plt, plotattributes, kw_list)
 end
 
-# TODO: Should some of this logic be moved to RecipesPipeline?
+# TODO: Should some of this logic be moved to RecipePipeline?
 function _plot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
     # merge in anything meant for the Plot
     for kw in kw_list, (k, v) in kw
@@ -269,18 +269,18 @@ end
 
 ## Series recipes
 
-function RecipesPipeline.slice_series_attributes!(plt::Plot, kw_list, kw)
+function RecipePipeline.slice_series_attributes!(plt::Plot, kw_list, kw)
     sp::Subplot = kw[:subplot]
     # in series attributes given as vector with one element per series,
     # select the value for current series
     _slice_series_args!(kw, plt, sp, series_idx(kw_list, kw))
 end
 
-RecipesPipeline.series_defaults(plt::Plot) = _series_defaults # in args.jl
+RecipePipeline.series_defaults(plt::Plot) = _series_defaults # in args.jl
 
-RecipesPipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported(st)
+RecipePipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported(st)
 
-function RecipesPipeline.add_series!(plt::Plot, plotattributes)
+function RecipePipeline.add_series!(plt::Plot, plotattributes)
     sp = _prepare_subplot(plt, plotattributes)
     _expand_subplot_extrema(sp, plotattributes, plotattributes[:seriestype])
     _update_series_attributes!(plotattributes, plt, sp)
@@ -298,7 +298,7 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T}
     st = _override_seriestype_check(plotattributes, st)
 
     # change to a 3d projection for this subplot?
-    if RecipesPipeline.needs_3d_axes(st)
+    if needs_3d_axes(st)
         sp.attr[:projection] = "3d"
     end
 
@@ -312,7 +312,7 @@ end
 
 function _override_seriestype_check(plotattributes::AKW, st::Symbol)
     # do we want to override the series type?
-    if !RecipesPipeline.is3d(st) && !(st in (:contour, :contour3d))
+    if !is3d(st) && !(st in (:contour, :contour3d))
         z = plotattributes[:z]
         if !isa(z, Nothing) &&
            (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z))

src/plot.jl

@@ -49,7 +49,7 @@ as a String to look up its docstring; e.g. `plotattr("seriestype")`.
 function plot(args...; kw...)
     # this creates a new plot with args/kw and sets it to be the current plot
     plotattributes = KW(kw)
-    RecipesPipeline.preprocess_attributes!(plotattributes)
+    preprocess_attributes!(plotattributes)
 
     # create an empty Plot then process
     plt = Plot()
@@ -61,7 +61,7 @@ end
 # note: we split into plt1 and plts_tail so we can dispatch correctly
 function plot(plt1::Plot, plts_tail::Plot...; kw...)
     plotattributes = KW(kw)
-    RecipesPipeline.preprocess_attributes!(plotattributes)
+    preprocess_attributes!(plotattributes)
 
     # build our plot vector from the args
     n = length(plts_tail) + 1
@@ -153,7 +153,7 @@ end
 # this adds to a specific plot... most plot commands will flow through here
 function plot!(plt::Plot, args...; kw...)
     plotattributes = KW(kw)
-    RecipesPipeline.preprocess_attributes!(plotattributes)
+    preprocess_attributes!(plotattributes)
     # merge!(plt.user_attr, plotattributes)
     _plot!(plt, plotattributes, args)
 end
@@ -164,7 +164,7 @@ end
 # a list of series KW dicts.
 # note: at entry, we only have those preprocessed args which were passed in... no default values yet
 function _plot!(plt::Plot, plotattributes, args)
-    RecipesPipeline.recipe_pipeline!(plt, plotattributes, args)
+    RecipePipeline.recipe_pipeline!(plt, plotattributes, args)
     current(plt)
     _do_plot_show(plt, plt[:show])
     return plt
@@ -212,3 +212,5 @@ function plot!(sp::Subplot, args...; kw...)
     plt = sp.plt
     plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
 end
+
+# --------------------------------------------------------------------

src/precompile.jl

@@ -6,7 +6,7 @@ function _precompile_()
     isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
     isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
     isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{typeof(RecipesPipeline.datetimeformatter)}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{typeof(Plots.datetimeformatter)}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis})
@@ -47,12 +47,493 @@ function _precompile_()
     isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}})
     isdefined(Plots, Symbol("#standalone_html##kw")) && precompile(Tuple{getfield(Plots, Symbol("#standalone_html##kw")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}})
     isdefined(Plots, Symbol("#test_examples##kw")) && precompile(Tuple{getfield(Plots, Symbol("#test_examples##kw")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Dates.DateTime, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, Base.UnitRange{Int64}, Plots.RecipePipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{Float64, 1}, typeof(identity), Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{String, 1}, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Array{String, 1}, Array{String, 1}, Plots.RecipePipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipePipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Base.StepRange{Int64, Int64}, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Nothing, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._compute_xyz), Nothing, Plots.RecipePipeline.Surface{Array{Float64, 2}}, Nothing})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy, typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.RecipePipeline.GroupBy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._extract_group_attributes), Array{String, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._filter_input_data!), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._finish_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData})
+    precompile(Tuple{typeof(Plots.RecipePipeline._finish_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData})
+    precompile(Tuple{typeof(Plots.RecipePipeline._nobigs), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Real, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Union{Base.Missing, Int64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._prepare_series_data), Array{Union{Base.Missing, Number}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._preprocess_axis_args!), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_fillrange), Int64, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_fillrange), Nothing, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipe), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_plotrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Int64, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Nothing, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_ribbon), typeof(identity), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipe), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_seriesrecipes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._process_userrecipes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._recipedata_vector), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Function, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Real, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline._series_data_vector), typeof(identity), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.add_series!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.RecipePipeline.add_series!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.RecipePipeline.filter_data!), Base.Dict{Symbol, Any}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Array{Float64, 1}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Base.OneTo{Int64}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.filter_data), Nothing, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Array{Symbol, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:contour}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:heatmap}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Base.Val{:path3d}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is3d), Type{Int}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_axis_attribute), Plots.Plot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_axis_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_seriestype_supported), Plots.Plot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_seriestype_supported), Plots.Plot{Plots.PlotlyBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Base.Val{:contour}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Base.Val{:heatmap}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.is_surface), Type{Int}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Type{Base.Val{:path3d}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.needs_3d_axes), Type{Int}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.preprocess_attributes!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.RecipePipeline.process_userrecipe!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.process_userrecipe!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.recipe_pipeline!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.slice_series_attributes!), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.slice_series_attributes!), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{String, 1}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Array{Symbol, 2}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.GridLayout, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Plots.Plot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, String, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.GRBackend}, Symbol, Symbol, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Int64, 1}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{String, 1}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Array{Symbol, 2}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.GridLayout, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Plots.Plot{Plots.PlotlyBackend}, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, String, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.splittable_attribute), Plots.Plot{Plots.PlotlyBackend}, Symbol, Symbol, Int64})
+    precompile(Tuple{typeof(Plots.RecipePipeline.unzip), Array{Tuple{Array{Float64, 1}, Array{Float64, 1}}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.unzip), Array{Tuple{Float64, Float64, Float64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Int64, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.GroupBy, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.GroupBy, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Int64, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.GroupBy, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.GRBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Array{T, 1} where T, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Base.Complex{Float64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Dates.DateTime, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Function, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{String, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Tuple{Int64, Real}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Array{Union{Base.Missing, Int64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.StepRange{Int64, Int64}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Nothing, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.PortfolioComposition})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.RecipePipeline.GroupBy, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Plots.Spy})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, Type{Int}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Array{RecipesBase.RecipeData, 1}, Symbol, typeof(identity), Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Array{T, 1} where T, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Base.Complex{Float64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Dates.DateTime, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Function, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{String, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Tuple{Int64, Real}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Array{Union{Base.Missing, Int64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.StepRange{Int64, Int64}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Nothing, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.PortfolioComposition})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.RecipePipeline.GroupBy, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Plots.Spy})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Type{Int}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, typeof(identity), Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Array{T, 1} where T, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Base.Complex{Float64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Dates.DateTime, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Function, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Plots.OHLC{T} where T<:Real, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{String, 1}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Tuple{Int64, Real}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Array{Union{Base.Missing, Int64}, 1}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.StepRange{Int64, Int64}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Nothing, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.PortfolioComposition})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.Formatted{Array{Int64, 1}}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.RecipePipeline.GroupBy, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Plots.Spy})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, Type{Int}, Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.warn_on_recipe_aliases!), Plots.Plot{Plots.PlotlyBackend}, RecipesBase.RecipeData, Symbol, typeof(identity), Int})
+    precompile(Tuple{typeof(Plots.RecipePipeline.wrap_surfaces!), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.__init__)})
     precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots._backend_instance), Symbol})
     precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._binbarlike_baseline), Float64, Symbol})
@@ -89,15 +570,15 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Bool})
     precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Symbol})
     precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.PlotlyBackend}, Bool})
-    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Symbol})
-    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol})
     precompile(Tuple{typeof(Plots._heatmap_edges), Array{Float64, 1}, Bool})
     precompile(Tuple{typeof(Plots._hist_edge), Tuple{Array{Float64, 1}}, Int64, Symbol})
     precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
     precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
     precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}}, Symbol})
     precompile(Tuple{typeof(Plots._initialize_backend), Plots.PlotlyBackend})
-    precompile(Tuple{typeof(Plots._override_seriestype_check), RecipesPipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots._override_seriestype_check), Plots.RecipePipeline.DefaultsDict, Symbol})
     precompile(Tuple{typeof(Plots._pick_default_backend)})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
@@ -155,24 +636,24 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
     precompile(Tuple{typeof(Plots._plotly_framestyle), Symbol})
     precompile(Tuple{typeof(Plots._plots_defaults)})
-    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}})
-    precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}})
-    precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}})
-    precompile(Tuple{typeof(Plots._preprocess_binlike), RecipesPipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.RecipePipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_binlike), Plots.RecipePipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._preprocess_userrecipe), Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._replace_linewidth), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._replace_linewidth), Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape})
     precompile(Tuple{typeof(Plots._scale_adjusted_values), Type{Float64}, Array{Float64, 1}, Symbol})
-    precompile(Tuple{typeof(Plots._series_index), RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._series_index), RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots._series_index), Plots.RecipePipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._series_index), Plots.RecipePipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
     precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64})
-    precompile(Tuple{typeof(Plots._slice_series_args!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
-    precompile(Tuple{typeof(Plots._slice_series_args!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64})
+    precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots._slice_series_args!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64})
     precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
     precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
     precompile(Tuple{typeof(Plots._transform_ticks), Base.StepRange{Int64, Int64}})
@@ -180,11 +661,11 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._transform_ticks), Nothing})
     precompile(Tuple{typeof(Plots._transform_ticks), Symbol})
     precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Base.Dict{Symbol, Any}, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, RecipesPipeline.DefaultsDict, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.RecipePipeline.DefaultsDict, Symbol, Int64})
     precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64})
     precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64})
     precompile(Tuple{typeof(Plots._update_axis_colors), Plots.Axis})
     precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.GRBackend}, Plots.Axis, Symbol})
     precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Symbol})
@@ -194,22 +675,22 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots._update_series_attributes!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._update_series_attributes!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.RecipePipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Int64, Bool})
-    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict, Int64, Bool})
     precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Int64, Bool})
-    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict, Int64, Bool})
     precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.GRBackend}, Array{Any, 1}})
     precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.PlotlyBackend}, Array{Any, 1}})
     precompile(Tuple{typeof(Plots.addExtension), String, String})
     precompile(Tuple{typeof(Plots.add_layout_pct!), Base.Dict{Symbol, Any}, Expr, Int64, Int64})
-    precompile(Tuple{typeof(Plots.aliasesAndAutopick), RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64})
+    precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.RecipePipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64})
     precompile(Tuple{typeof(Plots.allAlphas), Int64})
     precompile(Tuple{typeof(Plots.allStyles), Int64})
     precompile(Tuple{typeof(Plots.allStyles), Symbol})
@@ -243,10 +724,10 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64, Array{Plots.Plot{T} where T<:RecipesBase.AbstractBackend, 1}})
     precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64})
-    precompile(Tuple{typeof(Plots.build_layout), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.build_layout), Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.EmptyLayout})
     precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.GridLayout})
-    precompile(Tuple{typeof(Plots.color_or_nothing!), RecipesPipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.RecipePipeline.DefaultsDict, Symbol})
     precompile(Tuple{typeof(Plots.colorbar_style), Plots.Series})
     precompile(Tuple{typeof(Plots.compute_gridsize), Int64, Int64, Int64})
     precompile(Tuple{typeof(Plots.concatenate_fillrange), Base.UnitRange{Int64}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
@@ -272,11 +753,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Base.Missing})
     precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Char})
     precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, String})
-    precompile(Tuple{typeof(Plots.ensure_gradient!), RecipesPipeline.DefaultsDict, Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.error_coords), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}})
-    precompile(Tuple{typeof(Plots.error_coords), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}})
-    precompile(Tuple{typeof(Plots.error_style!), RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots.error_zipit), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.RecipePipeline.DefaultsDict, Symbol, Symbol})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Int64, 1}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.OneTo{Int64}})
@@ -285,14 +762,14 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Float64})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Int64})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.RecipePipeline.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Tuple{Float64, Float64}})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots.extend_by_data!), Array{Float64, 1}, Float64})
     precompile(Tuple{typeof(Plots.extend_series_data!), Plots.Series, Float64, Symbol})
     precompile(Tuple{typeof(Plots.fakedata), Int64, Int64})
-    precompile(Tuple{typeof(Plots.fg_color), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.fg_color), Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots.font), Int64, Int})
     precompile(Tuple{typeof(Plots.font), String, Int})
     precompile(Tuple{typeof(Plots.font), Symbol, Int})
@@ -394,7 +871,6 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.gr_set_markercolor), ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.gr_set_textcolor), ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Float64})
-    precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Int64})
     precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Nothing})
     precompile(Tuple{typeof(Plots.gr_set_transparency), Float64})
     precompile(Tuple{typeof(Plots.gr_set_viewport_cmap), Plots.Subplot{Plots.GRBackend}})
@@ -408,7 +884,6 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.gr_update_colorbar!), Plots.GRColorbar, Plots.Series})
     precompile(Tuple{typeof(Plots.gr_viewport_from_bbox), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.gr_w3tondc), Float64, Float64, Float64})
-    precompile(Tuple{typeof(Plots.gr_w3tondc), Int64, Float64, Float64})
     precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.guide_padding), Plots.Axis})
@@ -473,7 +948,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.isvertical), Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.isvertical), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.isvertical), Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}, Int})
     precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.iter_segments), Array{Int64, 1}, Array{Float64, 1}})
@@ -491,7 +966,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.layout_args), Int64, Tuple{Int64, Int64}})
     precompile(Tuple{typeof(Plots.layout_args), Int64})
     precompile(Tuple{typeof(Plots.layout_args), Plots.GridLayout})
-    precompile(Tuple{typeof(Plots.layout_args), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.layout_args), Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
     precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}})
     precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.GRBackend}})
@@ -502,7 +977,6 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.like_histogram), Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Array{RecipesBase.AbstractLayout, 1}, Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis, Plots.Axis})
-    precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis})
     precompile(Tuple{typeof(Plots.link_axes!), Plots.GridLayout, Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.GRBackend}, Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
@@ -548,7 +1022,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Nothing})
-    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Plots.RecipePipeline.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.plotly_domain), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
     precompile(Tuple{typeof(Plots.plotly_font), Plots.Font, ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.plotly_font), Plots.Font})
@@ -567,12 +1041,11 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
     precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.UnitRange{Int64}})
-    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Plots.RecipePipeline.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.plotly_polar!), Base.Dict{Symbol, Any}, Plots.Series})
     precompile(Tuple{typeof(Plots.plotly_polaraxis), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis})
     precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Series})
     precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}})
-    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Float64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Int64, 1}, Nothing, Tuple{Float64, Float64}})
@@ -583,10 +1056,12 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.UnitRange{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Nothing, Nothing, Nothing, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.plotly_series_shapes), Plots.Plot{Plots.PlotlyBackend}, Plots.Series, Tuple{Float64, Float64}})
-    precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, Plots.RecipePipeline.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.png), Plots.Plot{Plots.GRBackend}, String})
     precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.preprocess_attributes!), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.preprocess_attributes!), Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
@@ -597,7 +1072,7 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Int64, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.processGridArg!), RecipesPipeline.DefaultsDict, Bool, Symbol})
+    precompile(Tuple{typeof(Plots.processGridArg!), Plots.RecipePipeline.DefaultsDict, Bool, Symbol})
     precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Float64})
     precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Int64})
@@ -621,9 +1096,9 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Tuple{Int64, Int64}, Symbol})
     precompile(Tuple{typeof(Plots.recompute_lengths), Array{Measures.Measure, 1}})
     precompile(Tuple{typeof(Plots.replaceAlias!), Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Symbol}})
-    precompile(Tuple{typeof(Plots.replaceAlias!), RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}})
+    precompile(Tuple{typeof(Plots.replaceAlias!), Plots.RecipePipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}})
     precompile(Tuple{typeof(Plots.replaceAliases!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Symbol}})
-    precompile(Tuple{typeof(Plots.replaceAliases!), RecipesPipeline.DefaultsDict, Base.Dict{Symbol, Symbol}})
+    precompile(Tuple{typeof(Plots.replaceAliases!), Plots.RecipePipeline.DefaultsDict, Base.Dict{Symbol, Symbol}})
     precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)})
     precompile(Tuple{typeof(Plots.right), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
     precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.GRBackend}})
@@ -639,10 +1114,9 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.showaxis), Symbol, Symbol})
     precompile(Tuple{typeof(Plots.shrink_by), Float64, Float64, Float64})
     precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Bool})
-    precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, RecipesPipeline.DefaultsDict, Symbol, Int64, Bool})
-    precompile(Tuple{typeof(Plots.slice_arg!), RecipesPipeline.DefaultsDict, RecipesPipeline.DefaultsDict, Symbol, Int64, Bool})
+    precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.RecipePipeline.DefaultsDict, Symbol, Int64, Bool})
+    precompile(Tuple{typeof(Plots.slice_arg!), Plots.RecipePipeline.DefaultsDict, Plots.RecipePipeline.DefaultsDict, Symbol, Int64, Bool})
     precompile(Tuple{typeof(Plots.slice_arg), Array{ColorTypes.RGBA{Float64}, 2}, Int64})
-    precompile(Tuple{typeof(Plots.slice_arg), Array{Float64, 2}, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), Array{Measures.Length{:mm, Float64}, 2}, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), Array{String, 2}, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), Array{Symbol, 2}, Int64})
@@ -693,10 +1167,10 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.vline!), Array{Int64, 1}})
     precompile(Tuple{typeof(Plots.wand_edges), Array{Float64, 1}})
-    precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, RecipesPipeline.DefaultsDict})
-    precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, Plots.RecipePipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, Plots.RecipePipeline.DefaultsDict})
     precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol})

src/recipes.jl

@@ -458,7 +458,7 @@ end
 end
 @deps plots_heatmap shape
 is_3d(::Type{Val{:plots_heatmap}}) = true
-RecipesPipeline.is_surface(::Type{Val{:plots_heatmap}}) = true
+is_surface(::Type{Val{:plots_heatmap}}) = true
 
 # ---------------------------------------------------------------------------
 # Histograms
@@ -1014,62 +1014,49 @@ function error_zipit(ebar)
     end
 end
 
-error_tuple(x) = x, x
-error_tuple(x::Tuple) = x
-
-function error_coords(errorbar, errordata, otherdata...)
-    ed = Vector{float_extended_type(errordata)}(undef, 0)
-    od = [Float64[] for _ in otherdata]
-    for (i, edi) in enumerate(errordata)
-        for (j, odj) in enumerate(otherdata)
-            odi = _cycle(odj, i)
-            nanappend!(od[j], [odi, odi])
+function error_coords(xorig, yorig, ebar)
+    # init empty x/y, and zip errors if passed Tuple{Vector,Vector}
+    x, y = Array{float_extended_type(xorig)}(undef, 0), Array{Float64}(undef, 0)
+    # for each point, create a line segment from the bottom to the top of the errorbar
+    for i = 1:max(length(xorig), length(yorig))
+        xi = _cycle(xorig, i)
+        yi = _cycle(yorig, i)
+        ebi = _cycle(ebar, i)
+        nanappend!(x, [xi, xi])
+        e1, e2 = if istuple(ebi)
+            first(ebi), last(ebi)
+        elseif isscalar(ebi)
+            ebi, ebi
+        else
+            error("unexpected ebi type $(typeof(ebi)) for errorbar: $ebi")
         end
-        e1, e2 = error_tuple(_cycle(errorbar, i))
-        nanappend!(ed, [edi - e1, edi + e2])
+        nanappend!(y, [yi - e1, yi + e2])
     end
-    return (ed, od...)
+    x, y
 end
 
 # we will create a series of path segments, where each point represents one
 # side of an errorbar
-
-@recipe function f(::Type{Val{:xerror}}, x, y, z)
-    error_style!(plotattributes)
-    markershape := :vline
-    xerr = error_zipit(plotattributes[:xerror])
-    if z === nothing
-        plotattributes[:x], plotattributes[:y] = error_coords(xerr, x, y)
-    else
-        plotattributes[:x], plotattributes[:y], plotattributes[:z] =
-            error_coords(xerr, x, y, z)
-    end
-    ()
-end
-@deps xerror path
-
 @recipe function f(::Type{Val{:yerror}}, x, y, z)
     error_style!(plotattributes)
     markershape := :hline
-    yerr = error_zipit(plotattributes[:yerror])
-    if z === nothing
-        plotattributes[:y], plotattributes[:x] = error_coords(yerr, y, x)
-    else
-        plotattributes[:y], plotattributes[:x], plotattributes[:z] =
-            error_coords(yerr, y, x, z)
-    end
+    plotattributes[:x], plotattributes[:y] = error_coords(
+        plotattributes[:x],
+        plotattributes[:y],
+        error_zipit(plotattributes[:yerror]),
+    )
     ()
 end
 @deps yerror path
 
-@recipe function f(::Type{Val{:zerror}}, x, y, z)
+@recipe function f(::Type{Val{:xerror}}, x, y, z)
     error_style!(plotattributes)
-    markershape := :hline
-    if z !== nothing
-        zerr = error_zipit(plotattributes[:zerror])
-        plotattributes[:z], plotattributes[:x], plotattributes[:y] =
-            error_coords(zerr, z, x, y)
-    end
+    markershape := :vline
+    plotattributes[:y], plotattributes[:x] = error_coords(
+        plotattributes[:y],
+        plotattributes[:x],
+        error_zipit(plotattributes[:xerror]),
+    )
     ()
 end
 @deps xerror path
@@ -1164,7 +1151,7 @@ function quiver_using_hack(plotattributes::AKW)
         )
     end
 
-    plotattributes[:x], plotattributes[:y] = RecipesPipeline.unzip(pts[2:end])
+    plotattributes[:x], plotattributes[:y] = Plots.unzip(pts[2:end])
     # KW[plotattributes]
 end
 
@@ -1283,13 +1270,13 @@ end
 # --------------------------------------------------------------------
 # Lists of tuples and GeometryTypes.Points
 # --------------------------------------------------------------------
-@recipe f(v::AVec{<:GeometryTypes.Point}) = RecipesPipeline.unzip(v)
+@recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v)
 @recipe f(p::GeometryTypes.Point) = [p]
 
 # Special case for 4-tuples in :ohlc series
 @recipe f(xyuv::AVec{<:Tuple{R1, R2, R3, R4}}) where {R1, R2, R3, R4} =
     get(plotattributes, :seriestype, :path) == :ohlc ? OHLC[OHLC(t...) for t in xyuv] :
-    RecipesPipeline.unzip(xyuv)
+    unzip(xyuv)
 
 
 # -------------------------------------------------
@@ -1415,6 +1402,26 @@ abline!(plt::Plot, a, b; kw...) =
 
 abline!(args...; kw...) = abline!(current(), args...; kw...)
 
+
+# -------------------------------------------------
+# Dates & Times
+
+dateformatter(dt) = string(Date(Dates.UTD(dt)))
+datetimeformatter(dt) = string(DateTime(Dates.UTM(dt)))
+timeformatter(t) = string(Dates.Time(Dates.Nanosecond(t)))
+
+@recipe f(::Type{Date}, dt::Date) = (dt -> Dates.value(dt), dateformatter)
+@recipe f(::Type{DateTime}, dt::DateTime) =
+    (dt -> Dates.value(dt), datetimeformatter)
+@recipe f(::Type{Dates.Time}, t::Dates.Time) = (t -> Dates.value(t), timeformatter)
+@recipe f(::Type{P}, t::P) where {P<:Dates.Period} =
+    (t -> Dates.value(t), t -> string(P(t)))
+
+# -------------------------------------------------
+# Characters
+
+@recipe f(::Type{<:AbstractChar}, ::AbstractChar) = (string, string)
+
 # -------------------------------------------------
 # Complex Numbers
 

src/shorthands.jl

@@ -438,9 +438,8 @@ julia> plot(1:10)
 julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
 ```
 """
-annotate!(anns...; kw...)             = plot!(; annotation = anns, kw...)
-annotate!(anns::Tuple...; kw...)      = plot!(; annotation = collect(anns), kw...)
-annotate!(anns::AVec{<:Tuple}; kw...) = plot!(; annotation = anns, kw...)
+annotate!(anns...; kw...)                                        = plot!(; annotation = anns, kw...)
+annotate!(anns::AVec{T}; kw...) where {T<:Tuple}                 = plot!(; annotation = anns, kw...)
 
 "Flip the current plots' x axis"
 xflip!(flip::Bool = true; kw...)                          = plot!(; xflip = flip, kw...)

src/utils.jl

@@ -79,7 +79,7 @@ function iter_segments(series::Series)
         end
     else
         segs = UnitRange{Int}[]
-        args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
+        args = is3d(series) ? (x, y, z) : (x, y)
         for seg in iter_segments(args...)
             push!(segs, seg)
         end
@@ -145,14 +145,14 @@ maketuple(x::Tuple{T,S}) where {T,S} = x
 
 for i in 2:4
     @eval begin
-        RecipesPipeline.unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}},
+        unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}},
                    AVec{<:GeometryTypes.Point{$i}}}) = $(Expr(:tuple, (:([t[$j] for t in v]) for j=1:i)...))
     end
 end
 
-RecipesPipeline.unzip(v::Union{AVec{<:GeometryTypes.Point{N}},
+unzip(v::Union{AVec{<:GeometryTypes.Point{N}},
                AVec{<:Tuple{Vararg{T,N} where T}}}) where N = error("$N-dimensional unzip not implemented.")
-RecipesPipeline.unzip(v::Union{AVec{<:GeometryTypes.Point},
+unzip(v::Union{AVec{<:GeometryTypes.Point},
                AVec{<:Tuple}}) = error("Can't unzip points of different dimensions.")
 
 # given 2-element lims and a vector of data x, widen lims to account for the extrema of x
@@ -187,7 +187,7 @@ end
 
 function replaceAlias!(plotattributes::AKW, k::Symbol, aliases::Dict{Symbol,Symbol})
     if haskey(aliases, k)
-        plotattributes[aliases[k]] = RecipesPipeline.pop_kw!(plotattributes, k)
+        plotattributes[aliases[k]] = pop_kw!(plotattributes, k)
     end
 end
 
@@ -226,7 +226,7 @@ end
 
 "create an (n+1) list of the outsides of heatmap rectangles"
 function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false)
-    f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
+    f, invf = scale_func(scale), inverse_scale_func(scale)
     map(invf, _heatmap_edges(map(f,v), isedges))
 end
 
@@ -823,7 +823,7 @@ end
 
 extend_to_length!(v::AbstractRange, n) = range(first(v), step = step(v), length = n)
 function extend_to_length!(v::AbstractVector, n)
-    vmax = isempty(v) ? 0 : ignorenan_maximum(v)
+    vmax = isempy(v) ? 0 : ignorenan_maximum(v)
     extend_by_data!(v, vmax .+ (1:(n - length(v))))
 end
 extend_by_data!(v::AbstractVector, x) = isimmutable(v) ? vcat(v, x) : push!(v, x)
@@ -835,7 +835,7 @@ end
 
 function attr!(series::Series; kw...)
     plotattributes = KW(kw)
-    RecipesPipeline.preprocess_attributes!(plotattributes)
+    preprocess_attributes!(plotattributes)
     for (k,v) in plotattributes
         if haskey(_series_defaults, k)
             series[k] = v
@@ -849,7 +849,7 @@ end
 
 function attr!(sp::Subplot; kw...)
     plotattributes = KW(kw)
-    RecipesPipeline.preprocess_attributes!(plotattributes)
+    preprocess_attributes!(plotattributes)
     for (k,v) in plotattributes
         if haskey(_subplot_defaults, k)
             sp[k] = v
@@ -1071,7 +1071,7 @@ end
 function shape_data(series, expansion_factor = 1)
     sp = series[:subplot]
     xl, yl = isvertical(series) ? (xlims(sp), ylims(sp)) : (ylims(sp), xlims(sp))
-    x, y = copy(series[:x]), copy(series[:y])
+    x, y = series[:x], series[:y]
     factor = 100
     for i in eachindex(x)
         if x[i] == -Inf

test/runtests.jl

@@ -62,9 +62,9 @@ pyplot()
     image_comparison_facts(:pyplot, tol=img_tol, skip = Plots._backend_skips[:pyplot])
 end
 
-pgfplotsx()
-@testset "PGFPlotsX" begin
-    image_comparison_facts(:pgfplotsx, tol=img_tol, skip = Plots._backend_skips[:pgfplotsx])
+pgfplots()
+@testset "PGFPlots" begin
+    image_comparison_facts(:pgfplots, tol=img_tol, skip = Plots._backend_skips[:pgfplots])
 end
 =#
 ##

test/test_pgfplotsx.jl

@@ -84,7 +84,7 @@ end
       @test marker.options["mark"] == "*"
       @test marker.options["mark options"]["color"] ==
             RGBA{Float64}(colorant"green", 0.8)
-      @test marker.options["mark options"]["line width"] == 0.75 # 1px is 0.75pt
+      @test marker.options["mark options"]["line width"] == 1
    end # testset
    @testset "Plot in pieces" begin
       pic = plot(rand(100) / 3, reg = true, fill = (0, :green))
@@ -245,39 +245,15 @@ end
    end # testset
    @testset "Annotations" begin
       y = rand(10)
-      pgfx_plot = plot(
+      plot(
          y,
          annotations = (3, y[3], Plots.text("this is \\#3", :left)),
          leg = false,
       )
-      Plots._update_plot_object(pgfx_plot)
-      axis_content = Plots.pgfx_axes(pgfx_plot.o)[1].contents
-      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
-      @test length(nodes) == 1
-      mktempdir() do path
-         file_path =joinpath(path,"annotations.tex")
-         @test_nowarn savefig(pgfx_plot, file_path)
-         open(file_path) do io
-            lines = readlines(io)
-            @test count(s -> occursin("node", s), lines) == 1
-         end
-      end
       annotate!([
          (5, y[5], Plots.text("this is \\#5", 16, :red, :center)),
          (10, y[10], Plots.text("this is \\#10", :right, 20, "courier")),
       ])
-      Plots._update_plot_object(pgfx_plot)
-      axis_content = Plots.pgfx_axes(pgfx_plot.o)[1].contents
-      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
-      @test length(nodes) == 3
-      mktempdir() do path
-         file_path =joinpath(path,"annotations.tex")
-         @test_nowarn savefig(pgfx_plot, file_path)
-         open(file_path) do io
-            lines = readlines(io)
-            @test count(s -> occursin("node", s), lines) == 3
-         end
-      end
       annotation_plot = scatter!(
          range(2, stop = 8, length = 6),
          rand(6),
@@ -291,18 +267,9 @@ end
             Plots.text("data", :green),
          ],
       )
-      Plots._update_plot_object(annotation_plot)
-      axis_content = Plots.pgfx_axes(annotation_plot.o)[1].contents
-      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
-      @test length(nodes) == 9
-      mktempdir() do path
-         file_path =joinpath(path,"annotations.tex")
-         @test_nowarn savefig(annotation_plot, file_path)
-         open(file_path) do io
-            lines = readlines(io)
-            @test count(s -> occursin("node", s), lines) == 9
-         end
-      end
+      # mktempdir() do path
+      #    @test_nowarn savefig(annotation_plot, path*"annotation.pdf")
+      # end
    end # testset
    @testset "Ribbon" begin
       aa = rand(10)