diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a42ad77c..f8dd3252 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,7 +15,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '0.7' 
+          - '0.7'
           - '1' # Leave this line unchanged. '1' will automatically expand to the latest stable 1.x release of Julia.
           - 'nightly'
         os:
diff --git a/Project.toml b/Project.toml
index 25c9f08f..d7a9d6cf 100644
--- a/Project.toml
+++ b/Project.toml
@@ -11,13 +11,11 @@ LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
-Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 
 [compat]
 Formatting = "0.4"
 LaTeXStrings = "0.3, 1"
 MacroTools = "0.4, 0.5"
-Requires = "0.5, 1"
 julia = "1"
 
 [extras]
diff --git a/src/Latexify.jl b/src/Latexify.jl
index 69de2457..dc6008b2 100644
--- a/src/Latexify.jl
+++ b/src/Latexify.jl
@@ -1,5 +1,6 @@
 module Latexify
-using Requires
+# Base.Experimental.@compiler_options optimize=0 compile=min infer=no
+# using Requires
 using LaTeXStrings
 using InteractiveUtils
 using Markdown
@@ -8,20 +9,18 @@ import MacroTools
 using Printf
 using Formatting
 
-export latexify, md, copy_to_clipboard, auto_display, set_default, get_default,
+export latexify, copy_to_clipboard, auto_display, set_default, get_default,
     reset_default, @latexrecipe, render, @latexify, @latexrun
 
-## Allow some backwards compatibility until its time to deprecate.
-export latexequation, latexarray, latexalign, latexraw, latexinline, latextabular, mdtable
 
 export StyledNumberFormatter, FancyNumberFormatter
 
-COPY_TO_CLIPBOARD = false
+const COPY_TO_CLIPBOARD = false
 function copy_to_clipboard(x::Bool)
     global COPY_TO_CLIPBOARD = x
 end
 
-AUTO_DISPLAY = false
+const AUTO_DISPLAY = false
 function auto_display(x::Bool)
     global AUTO_DISPLAY = x
 end
@@ -29,42 +28,25 @@ end
 include("unicode2latex.jl")
 include("function2latex.jl")
 include("latexraw.jl")
-include("latexoperation.jl")
-include("latexarray.jl")
-include("latexalign.jl")
-include("latexbracket.jl")
-include("latexinline.jl")
-include("latexequation.jl")
-include("latextabular.jl")
 include("default_kwargs.jl")
 include("recipes.jl")
 include("macros.jl")
+include("instructions.jl")
 
-include("mdtable.jl")
-include("mdtext.jl")
-include("md.jl")
+# include("mdtable.jl")
+# include("mdtext.jl")
+# include("md.jl")
 
 include("utils.jl")
+include("TracedIO.jl")
+include("config.jl")
 
 include("numberformatters.jl")
 
 include("latexify_function.jl")
+# include("refactor_prototype_2.jl")
+export descend, unpack, head, operation, arguments, nested 
 
-### Add support for additional packages without adding them as dependencies.
-function __init__()
-    @require DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e" begin
-        include("plugins/ParameterizedFunctions.jl")
-    end
-    @require DiffEqBiological = "eb300fae-53e8-50a0-950c-e21f52c2b7e0" begin
-        include("plugins/DiffEqBiological.jl")
-    end
-    @require SymEngine = "123dc426-2d89-5057-bbad-38513e3affd8" begin
-        include("plugins/SymEngine.jl")
-    end
-    @require DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" begin
-        include("plugins/DataFrames.jl")
-    end
-end
 
 macro generate_test(expr)
     return :(clipboard("@test $($(string(expr))) == replace(\nraw\"$($(esc(expr)))\", \"\\r\\n\"=>\"\\n\")\n"))
@@ -125,4 +107,44 @@ macro append_test!(fname, str)
     )
 end
 
+# const _ex = :(a+w*c/d-b+1+1. + [1,x/y^2] * [1 2. 2im] .* x ± x = l_Huge(y))
+# latexify(:(a+w*c/d-b+1+1. + [1,x/y^2] * [1 2. 2im] .* x ± x = l_Huge(y)))
+# Latexify._latextree(:(a+w*c/d-b+1+1. + [1,x/y^2] * [1 2. 2im] .* x ± x = l_Huge(y)))
+# latexify(:(a+w*c/d-b+1+1. + [1,x/y^2] * [1 2. 2im] .* x ± x = l_Huge(y)))
+# latexify(:(a+w*c/d-b+1+1. + [1,x/y^2] * [1 2. 2im] .* x ± x = l_Huge(y)))
+# latexify(_ex)
+# latexify(_ex)
+# @assert precompile(latexify, (Expr,))
+
+latexify(:(z/y*s+1.2+1//2))
+for f in DEFAULT_INSTRUCTIONS
+    for op in [Expr, Symbol, Float64, Int, Rational, ComplexF64]
+        for config in [Dict, NamedTuple]
+            for prevop in [Symbol, Nothing]
+                precompile(f, (IOBuffer, config, op, prevop ))
+            end
+        end
+    end
 end
+
+
+# ### Add support for additional packages without adding them as dependencies.
+# function __init__()
+#     @require DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e" begin
+#         include("plugins/ParameterizedFunctions.jl")
+#     end
+#     @require DiffEqBiological = "eb300fae-53e8-50a0-950c-e21f52c2b7e0" begin
+#         include("plugins/DiffEqBiological.jl")
+#     end
+#     @require SymEngine = "123dc426-2d89-5057-bbad-38513e3affd8" begin
+#         include("plugins/SymEngine.jl")
+#     end
+#     @require DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" begin
+#         include("plugins/DataFrames.jl")
+#     end
+#     # Latexify._latextree(:(a+w*c/d-b+1+1. + [1,x/y^2] * [1 2. 2im] .* x ± x = l_Huge(y)))
+#     # Latexify.latexify(:(a+w*c/d-b+1+1. + [1,x/y^2] * [1 2. 2im] .* x ± x = l_Huge(y)))
+# end
+
+end
+
diff --git a/src/TracedIO.jl b/src/TracedIO.jl
new file mode 100644
index 00000000..1ce32965
--- /dev/null
+++ b/src/TracedIO.jl
@@ -0,0 +1,19 @@
+
+struct TracedIO{T} <: IO
+  trace::Vector{Function}
+  io::T
+end
+Base.write(x::TracedIO, s::String; kwargs...) = Base.write(x.io, s; kwargs...)
+
+struct TracedResult{T}
+  trace::Vector{Function}
+  str::T
+end
+
+function Base.show(io::IO, tio::TracedResult)
+  write(io, "Latexify TracedResult\n")
+  write(io, "\nwith call trace:\n")
+  write(io, join(string.(typeof.(tio.trace)), "\n"))
+  write(io, "\n\nand result\n")
+  show(io, tio.str)
+end
\ No newline at end of file
diff --git a/src/config.jl b/src/config.jl
new file mode 100644
index 00000000..3fc13459
--- /dev/null
+++ b/src/config.jl
@@ -0,0 +1,35 @@
+const DEFAULT_CONFIG = (;
+  :mulsym => " \\cdot ",
+  :convert_unicode => true,
+  :strip_broadcast => true,
+  :fmt => identity,
+  :index => :bracket,
+  :ifstr => "\\text{if }",
+  :elseifstr => "\\text{elseif }",
+  :elsestr => "\\text{otherwise}",
+  :adjustment => "c",
+  :transpose => false,
+  :double_linebreak => false,
+  :starred => false,
+)
+
+## MODULE_CONFIG can store defaults specified in other modules. E.g. from recipes.
+const MODULE_CONFIG = Dict{Symbol, Any}()
+
+## USE_CONFIG can store user-specified defaults
+const USER_CONFIG = Dict{Symbol, Any}()
+
+const comparison_operators = (;
+        :< => "<",
+        :.< => "<",
+        :> => ">",
+        :.> => ">",
+        Symbol("==") => "=",
+        Symbol(".==") => "=",
+        :<= => "\\leq",
+        :.<= => "\\leq",
+        :>= => "\\geq",
+        :.>= => "\\geq",
+        :!= => "\\neq",
+        :.!= => "\\neq",
+        )
\ No newline at end of file
diff --git a/src/instructions.jl b/src/instructions.jl
new file mode 100644
index 00000000..6f1a032a
--- /dev/null
+++ b/src/instructions.jl
@@ -0,0 +1,617 @@
+
+DEFAULT_INSTRUCTIONS = Function[
+  function report_bad_call(io::IO,  expr, config, rules, prevop)
+     println("""
+     Unsupported input with
+     expr=$expr
+     prevop=$prevop
+     and config=$config
+     """)
+     return false
+  return false
+  end,
+  function _unpack_args(io::IO,  args, config, rules, prevop)
+  ### If no function has claimed the tuple, unpack it and try again. 
+  ### This is mainly to unpack the args to `latexify(args...)`. 
+  if args isa Tuple && length(args) == 1
+    descend(io, args[1], config, rules, prevop)
+    return true
+  end
+  return false
+  end,
+  function macrocall(io, expr, config, rules, prevop)
+    expr isa Expr && head(expr) == :macrocall || return false
+    h, op, args = unpack(expr)
+    if op isa Symbol
+      funcname = replace(string(op), "_"=>"\\_")
+      # funcname = string(get(Latexify.function2latex, op, replace(string(op), "_"=>"\\_")))
+      write(io, funcname)
+    else
+      descend(io,  op, config, rules, nothing)
+    end
+    write(io, "\\left( ")
+    !isempty(args) && join_descend(io,  args, config, rules, ", ")
+    write(io, " \\right)")
+      # _arg = "\\left( " * join(descend.(args), ", ") * " \\right)"
+    return  true
+  end,
+  function call(io::IO,  expr, config, rules, prevop)
+    if expr isa Expr && head(expr) == :call 
+      h, op, args = unpack(expr)
+
+      if op isa Symbol
+        funcname = string(get(Latexify.function2latex, op, replace(string(op), "_"=>"\\_")))
+        write(io, funcname)
+      else
+        descend(io,  op, config, rules)
+      end
+      if length(args) >= 1 && head(args[1]) == :parameters
+        write(io, "\\left( ")
+        join_descend(io,  args[2:end], config, rules, ", ")
+        write(io, "; ")
+        descend(io,  args[1], config, rules)
+        write(io, " \\right)")
+        # _arg = "\\left( $(join(descend.(args[2:end]), ", ")); $(descend(args[1])) \\right)"
+      else
+        write(io, "\\left( ")
+        !isempty(args) && join_descend(io,  args, config, rules, ", ")
+        write(io, " \\right)")
+        # _arg = "\\left( " * join(descend.(args), ", ") * " \\right)"
+      end
+        return  true
+    end
+  return false
+  end,
+  function _infix_operator(io, ex, config, rules, prevop)
+    ex isa Expr && head(ex) == :call && operation(ex) isa Symbol && Base.isbinaryoperator(operation(ex)) || return false
+    descend(io, arguments(ex)[1], config, rules, operation(ex))
+    write(io, " ")
+    descend(io, operation(ex), config, rules, operation(ex))
+    write(io, " ")
+    descend(io, arguments(ex)[2], config, rules, operation(ex))
+    return true
+  end,
+  function _aligned_tuple(io::IO,  expr, config, rules, prevop)
+    expr isa Tuple{Vararg{Pair}} || return false
+    descend(io,  NamedTuple(expr), config, rules, prevop)
+    return true
+  end,
+  function _aligned(io::IO,  expr, config, rules, prevop)
+    # expr isa Tuple{T, T} where T <: AbstractArray || return false
+    # expr isa Tuple{Pair} || return false
+    expr isa NamedTuple || return false
+    write(io, "\\begin{aligned}\n")
+    p_expr = pairs(expr)
+    for p in p_expr[1:end-1]
+      descend(io,  p, config, rules, nothing)
+      write(io, " \\\\\n")
+    end
+    descend(io,  p_expr[end], config, rules, nothing)
+    write(io, "\n")
+    write(io, "\\end{aligned}\n")
+    return true
+  end,
+  function _pair(io::IO,  expr, config, rules, prevop)
+    expr isa Pair || return false
+    descend(io,  expr.first, config, rules, :(=))
+    write(io, get(config, :separator, " =& "))
+    descend(io,  expr.second, config, rules, :(=))
+    return true
+  end,
+  function _sqrt(io::IO,  ex, config, rules, prevop)
+    operation(ex) == :sqrt || return false
+    write(io, "\\$(operation(ex)){")
+    descend(io, arguments(ex)[1], config, rules, :sqrt)
+    write(io, "}")
+    return true
+  return false
+  end,
+  function _abs(io::IO,  ex, config, rules, prevop)
+    operation(ex) == :abs || return false
+    write(io, "\\left\\| ")
+    descend(io, arguments(ex)[1], config, rules, :abs)
+    write(io, " \\right\\|")
+  return true
+  end,
+  function _single_comparison(io::IO, ex, config, rules, prevop)
+    operation(ex) ∈ keys(comparison_operators) && length(arguments(ex)) == 2 || return false
+    # write(io, "\\left( ")
+    join_descend(io, [arguments(ex)[1], operation(ex), arguments(ex)[2]], config, rules, " "; prevop)
+    # write(io, " \\right)")
+    return true
+  end,
+  function _if(io::IO, ex, config, rules, prevop)
+    ex isa Expr && head(ex) == :if || return false
+    write(io, "\n\\begin{cases}")
+    build_if_else_body(io, ex.args, config, rules, nothing)
+    write(io, "\n\\end{cases}\n")
+    return true
+  end,
+  function _elseif(io::IO,  ex, config, rules, prevop)
+    ex isa Expr && head(ex) == :elseif || return false
+    build_if_else_body(io, ex.args, config, rules, prevop; ifstr=get(config, :elseifstr, "elseif"))
+    return true
+  end,
+  function _oneline_function(io::IO,  ex, config, rules, prevop)
+    head(ex) == :function && length(arguments(ex)) == 1 || return false
+    join_descend(io, [operation(ex), :(=), arguments(ex)[1]], config, rules, " ")
+  return true
+  end,
+  function _return(io::IO,  ex, config, rules, prevop)
+    head(ex) == :return && length(arguments(ex)) == 0 || return false
+    descend(io, operation(ex), config, rules, nothing) 
+  return true
+  end,
+  function _chained_comparisons(io::IO, ex, config, rules, prevop)
+    head(ex) == :comparison && Symbol.(arguments(ex)[1:2:end]) ⊆ keys(comparison_operators) || return false
+    prevop ∈ [:*, :^, :+, :-] && write(io, "\\left( ")
+    join_descend(io, ex.args, config, rules, " "; prevop=nothing)
+    prevop ∈ [:*, :^, :+, :-] && write(io, " \\right)")
+    return true
+  end,
+  function _type_annotation(io::IO,  ex, config, rules, prevop)
+    head(ex) == :(::) || return false
+    if length(arguments(ex)) == 0 
+      write(io, "::")
+      descend(io, :(l_mathrm($(operation(ex)))), config, rules, nothing)
+    elseif length(arguments(ex)) == 1 
+      descend(io, operation(ex), config, rules, nothing)
+      write(io, "::")
+      descend(io, :(l_mathrm($(arguments(ex)[1]))), config, rules, nothing)
+    end
+  return true
+  end,
+  function _wedge(io::IO,  ex, config, rules, prevop)
+    head(ex) == :(&&) && length(arguments(ex)) == 1 || return false
+    descend(io, operation(ex), config, rules, nothing)
+    write(io, " \\wedge ")
+    descend(io, arguments(ex)[1], config, rules, nothing)
+  return true
+  end,
+  function _vee(io::IO,  ex, config, rules, prevop)
+    head(ex) == :(||) && length(arguments(ex)) == 1 || return false
+    descend(io, operation(ex), config, rules, nothing)
+    write(io, " \\vee ")
+    descend(io, arguments(ex)[1], config, rules, nothing)
+  return true
+  end,
+  function _negation(io::IO,  ex, config, rules, prevop)
+    operation(ex) == :(!) || return false
+    write(io, "\\neg ")
+    descend(io, arguments(ex)[1], config, rules, nothing)
+  return true
+  end,
+  function _kw(io::IO, ex, config, rules, prevop)
+    head(ex) == :kw || return false
+    descend(io, operation(ex), config, rules, nothing)
+    write(io, " = ")
+    descend(io, arguments(ex)[1], config, rules, nothing)
+  return true
+  end,
+  function _parameters(io::IO, x, config, rules, prevop)
+    head(x) == :parameters || return false
+    join_descend(io, vcat(operation(x), arguments(x)), config, rules, ", ")
+    # join(descend.(vcat(operation(x), arguments(x))), ", ") : nothing
+  return true
+  end,
+  function _indexing(io::IO,  x, config, rules, prevop)
+    head(x) == :ref || return false
+    if config[:index] == :subscript
+        descend(io, operation(x), config, rules, nothing)
+        write(io, "_{")
+        join_descend(io, arguments(x), config, rules, ",")
+        write(io, "}")
+    elseif config[:index] == :bracket
+        descend(io, operation(x), config, rules, nothing)
+        write(io, "\\left[")
+        join_descend(io, arguments(x), config, rules, ", ")
+        write(io, "\\right]")
+    else
+        throw(ArgumentError("Incorrect `index` keyword argument to latexify. Valid values are :subscript and :bracket"))
+    end
+    return true
+  end,
+  function _broadcast_macro(io::IO,  ex, config, rules, prevop)
+    head(ex) == :macrocall && operation(ex) == Symbol("@__dot__") || return false
+    descend(io, arguments(ex)[end], config, rules, prevop)
+    return true
+  end,
+  function _block(io::IO, x, config, rules, prevop)
+    head(x) == :block || return false
+    descend(io, vcat(operation(x), arguments(x))[end], config, rules, prevop)
+    # _args = filter(x -> !(x isa LineNumberNode), x.args)
+    # # write(io, "\\left\\{")
+    # write(io, "\\begin{array}{c}")
+    # join_descend(io, _args, config, rules, "\\\\\n"; prevop)
+    # write(io, "\\end{array}")
+  return true
+  end,
+  function number(io::IO,  x, config, rules, prevop) 
+    if x isa Number
+      if hasmethod(isinf, Tuple{typeof(x)}) && isinf(x)
+        sign(x) == -1 && write(io, "-")
+        write(io, "\\infty")
+        return true
+      end
+      fmt = config[:fmt]
+      fmt isa String && (fmt = PrintfNumberFormatter(fmt))
+      str = string(fmt(x))
+      write(io, str)
+      return true
+    end
+  return false
+  end,
+  function rational_expr(io::IO,  x, config, rules, prevop) 
+    if operation(x) == ://
+      if arguments(x)[2] == 1 
+        descend(io,  arguments(x)[1], config, rules, prevop)
+        return true
+      else
+        descend(io,  :($(arguments(x)[1])/$(arguments(x)[2])), config, rules, prevop)
+        return true
+      end
+    end
+  return false
+  end,
+  function rational(io::IO,  x, config, rules, prevop) 
+    if x isa Rational
+      prevop ∈ [:*, :^] && write(io, "\\left( ")
+      x.den == 1 ? descend(io, x.num, config, rules, nothing) : descend(io, :($(x.num)/$(x.den)), config, rules, nothing)
+      prevop ∈ [:*, :^] && write(io, " \\right)")
+      return true
+    end
+  return false
+  end,
+  function complex(io::IO,  z, config, rules, prevop) 
+    if z isa Complex
+      prevop ∈ [:*, :^] && write(io, "\\left( ")
+      descend(io, z.re, config, rules, nothing)
+      write(io, z.im < 0 ? "-" : "+")
+      descend(io, abs(z.im), config, rules, nothing)
+      write(io, "\\textit{i}")
+      prevop ∈ [:*, :^] && write(io, " \\right)")
+      return true
+    end
+  return false
+  end,
+  function _missing(io::IO,  x, config, rules, prevop) 
+    ismissing(x) || return false
+    write(io, get(config, :missingstring, "\\textrm{NA}"))
+    return true
+  end,
+  function _nothing(io::IO,  x, config, rules, prevop)
+    x === nothing || return false 
+    return true
+  end,
+  function symbol(io::IO,  sym, config, rules, _)
+    if sym isa Symbol
+      sym = sym ∈ keys(comparison_operators) ? comparison_operators[sym] : sym
+      str = string(sym == :Inf ? :∞ : sym)
+      str = convert_subscript(str)
+      config[:convert_unicode] && (str = unicode2latex(str))
+      write(io, str)
+      return true
+    end
+  return false
+  end,
+  function _char(io::IO,  c, config, rules, prevop)
+    c isa Char || return false 
+    descend(io, Symbol(c), config, rules, prevop)
+    return true
+  end,
+  function array(io::IO,  arr, config, rules, prevop) 
+    if arr isa AbstractArray
+      adjustment = get(config, :adjustment, "c")
+      transpose = get(config, :transpose, false)
+      double_linebreak = get(config, :double_linebreak, false)
+      starred = get(config, :starred, false)
+
+      transpose && (arr = permutedims(arr))
+      rows = first(size(arr))
+      columns = length(size(arr)) > 1 ? size(arr)[2] : 1
+
+      eol = double_linebreak ? " \\\\\\\\\n" : " \\\\\n"
+      write(io, get(config, :array_left, "\\left[\n"))
+      write(io, "\\begin{array}{" * "$(adjustment)"^columns * "}\n")
+      
+      for i=1:rows, j=1:columns
+          descend(io,  arr[i,j], config, rules, nothing)
+          write(io, j==columns ? eol : " & ")
+      end
+
+      write(io, "\\end{array}")
+      write(io, get(config, :array_right, "\n\\right]"))
+      return true
+    end
+    return false
+  end,
+  function _pair_container(io::IO,  expr, config, rules, prevop)
+    expr isa AbstractVector && eltype(expr) <: Pair || expr isa Tuple{Vararg{Pair}} || return false
+    write(io, "\\begin{aligned}\n")
+    for p in expr[1:end-1]
+      descend(io,  p, config, rules, nothing)
+      write(io, " \\\\\n")
+    end
+    descend(io,  expr[end], config, rules, nothing)
+    write(io, "\n")
+    write(io, "\\end{aligned}")
+    return true
+  end,
+  function tuple(io::IO,  arg, config, rules, prevop)
+    if arg isa Tuple
+      if first(arg) isa Tuple || first(arg) isa AbstractArray
+        descend(io,  reduce(hcat, [collect(i) for i in arg]), config, rules, nothing)
+        return true
+      end
+        descend(io,  collect(arg), config, rules, nothing)
+        return true
+      end
+    return false
+  end,
+  function vect_exp(io::IO,  x, config, rules, prevop)
+    if head(x) ∈ [:vect, :vcat, :hcat] 
+      descend(io,  expr_to_array(x), config, rules, prevop)
+      return true
+    end
+  return false
+  end,
+  #  (expr, prevop, config) -> begin
+  #  h, op, args = unpack(expr)
+  # #  if (expr isa LatexifyOperation || h == :LatexifyOperation) && op == :merge
+  #  if h == :call && op == :latexifymerge
+  #    join(descend.(args), "")
+  #  end
+  # return false
+  # end,
+  function parse_string(io::IO,  str, config, rules, prevop)
+    str isa AbstractString || return false
+    try
+        ex = Meta.parse(str)
+        descend(io, ex, config, rules, prevop)
+    catch ParseError
+        error("""
+          in Latexify.jl:
+          You are trying to create latex-maths from a `String` that cannot be parsed as
+          an expression.
+
+          `latexify` will, by default, try to parse any string inputs into expressions
+          and this parsing has just failed.
+
+          If you are passing strings that you want returned verbatim as part of your input,
+          try making them `LaTeXString`s first.
+
+          If you are trying to make a table with plain text, try passing the keyword
+          argument `latex=false`. You should also ensure that you have chosen an output
+          environment that is capable of displaying not-maths objects. Try for example
+          `env=:table` for a latex table or `env=:mdtable` for a markdown table.
+          """)
+    end
+  return true
+  end,
+  function _pass_through_LaTeXString_substrings(io::IO, str, config, rules, prevop)
+    str isa SubString{LaTeXString} || return false
+    write(io, String(str))
+    return true
+  end,
+  function _pass_through_LaTeXString(io::IO, str, config, rules, prevop)
+    str isa LaTeXString || return false
+    write(io, str.s)
+    return true
+  end,
+  function _tuple_expr(io::IO,  expr, config, rules, prevop)
+    head(expr) == :tuple || return false 
+    join_descend(io, vcat(operation(expr), arguments(expr)), config, rules, ", ")
+    return true
+  end,
+  function strip_broadcast_dot(io::IO,  expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    if expr isa Expr && config[:strip_broadcast] && h == :call && startswith(string(op), '.')
+      descend(io,  Expr(h, Symbol(string(op)[2:end]), args...), config, rules, prevop)
+      return true
+    end
+  return false
+  end,
+  function strip_broadcast_dot_call(io::IO,  expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    if expr isa Expr && config[:strip_broadcast] && h == :. 
+      descend(io,  Expr(:call, op, args[1].args...), config, rules, prevop)
+      return true
+    end
+  return false
+  end,
+  function plusminus(io::IO,  expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    h == :call && op == :± || return false
+    join_descend(io,  args, config, rules, " \\pm "; prevop=op)
+  return true
+  end,
+  function division(io::IO,  expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    if h == :call && op == :/
+      prevop ∈ [:^] && write(io, "\\left( ")
+      write(io, "\\frac{")
+      descend(io,  args[1], config, rules, op)
+      write(io, "}{")
+      descend(io,  args[2], config, rules, op)
+      write(io, "}")
+      prevop ∈ [:^] && write(io, "\\right) ")
+      return true
+    end
+  return false
+  end,
+  function multiplication(io::IO,  expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    if h == :call && op == :*
+      # join(descend.(args, op), "$(config[:mulsym])")
+      join_descend(io,  args, config, rules, config[:mulsym]; prevop=op)
+      return true
+    end
+  return false
+  end,
+  function addition(io::IO,  expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    if h == :call && op ∈ (:+, :.+)
+      prevop ∈ [:*] && write(io, "\\left( ")
+      for (i, arg) in enumerate(args)
+        if i == 1 
+          descend(io, arg, config, rules, :+)
+        elseif is_first_minus(arg)
+          write(io, " - ")
+          descend(io, abs_first_minus(arg), config, rules, :+) 
+        else
+          write(io, " + ")
+          descend(io, arg, config, rules, :+)
+        end
+      end
+      prevop ∈ [:*] && write(io, " \\right)")
+      return true
+    end
+  return false
+  end,
+  function subtraction(io::IO,  expr, config, rules, prevop)
+    # this one is so gnarly because it tries to fix stuff like - - or -(-(x-y))
+    # -(x) is also a bit different to -(x, y) which does not make things simpler
+    h, op, args = unpack(expr)
+    h == :call && op == :- || return false
+    if length(args) == 1
+      if operation(args[1]) == :- && length(arguments(args[1])) == 1 ## -(-x) -> x
+        descend(io,  arguments(args[1])[1], config, rules, prevop)
+      elseif args[1] isa Number && sign(args[1]) == -1 ## (-(-1)) -> 1
+        descend(io,  -args[1], config, rules, op)
+      else # -(expr)
+        # _arg = operation(args[1]) ∈ [:-, :+, :±] ? surround(args[1]) : args[1]
+        # prevop == :^ ? surround("$op$_arg") : "$op$_arg"
+        if operation(only(args)) ∈ [:+, :.+, :-, :.-, :±, :.±]
+          write(io, "$op")
+          write(io, "\\left( ")
+          descend(io,  only(args), config, rules, op)
+          write(io, " \\right)")
+        else
+        write(io, "$op")
+        descend(io, only(args), config, rules, op)
+        end
+      end
+      return true
+    elseif length(args) == 2
+      if args[2] isa Number && sign(args[2]) == -1
+        descend(io,  args[1], config, rules, :+) 
+        write(io, " + ")
+        descend(io,  -args[2], config, rules, :+)
+        return true
+      elseif operation(args[2]) == :- && length(arguments(args[2])) == 1
+        descend(io,  args[1], config, rules, :+)
+        write(io, " + ")
+        descend(io,  arguments(args[2])[1], config, rules, :+)
+        return true
+      elseif operation(args[2]) ∈ [:-, :.-, :+, :.+]
+        descend(io,  args[1], config, rules, op) 
+        write(io, " - ")
+        write(io, "\\left( ")
+        descend(io,  args[2], config, rules, op)
+        write(io, " \\right)")
+        return true
+      end
+
+      prevop ∈ [:*, :^] && write(io, "\\left( ")
+      join_descend(io,  args, config, rules, " - "; prevop = op)
+      prevop ∈ [:*, :^] && write(io, " \\right)")
+    end
+  return true
+  end,
+  function pow(io::IO,  expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    h == :call && op == :^ || return false
+    if operation(args[1]) in Latexify.trigonometric_functions
+      fsym = operation(args[1])
+      fstring = get(Latexify.function2latex, fsym, "\\$(fsym)")
+      write(io, "$fstring^{")
+      descend(io,  args[2], config, rules, op)
+      write(io, "}")
+      write(io, "\\left( ")
+      join_descend(io,  arguments(args[1]), config, rules, ", "; prevop= operation(args[1]))
+      write(io, " \\right)")
+    else
+      apply_surround = operation(args[1]) ∈ [:+, :.+] || (args[1] isa Number && sign(args[1])==-1)
+      apply_surround && write(io, "\\left( ")
+      descend(io,  args[1], config, rules, op)
+      apply_surround && write(io, " \\right)")
+      write(io, "^{")
+      descend(io,  args[2], config, rules, op)
+      write(io, "}")
+    end
+  return true
+  end,
+  function l_funcs(io::IO,  ex, config, rules, prevop)
+    head(ex) == :call && startswith(string(operation(ex)), "l_") || return false
+    l_func = string(operation(ex))[3:end]
+    write(io, "\\$(l_func){")
+    join_descend(io,  arguments(ex), config, rules, "}{"; prevop)
+    write(io, "}")
+    return true
+  end,
+  function equals(io,  expr, config, rules, prevop)
+    if head(expr) == :(=)
+      descend(io,  expr.args[1], config, rules, head(expr))
+      write(io, " = ")
+      descend(io,  expr.args[2], config, rules, head(expr))
+      return true
+    end
+    return false
+  end,
+  function strip_linenumbernode(io, expr, config, rules, prevop)
+    h, op, args = unpack(expr)
+    expr isa Expr && any(map(x->x isa LineNumberNode, args)) || return false
+    descend(io, Expr(head(expr), op, filter(x->!(x isa LineNumberNode), args)...), config, rules, prevop)
+    return true
+  end,
+]
+
+function build_if_else_body(io::IO, args, config, rules, prevop=nothing; ifstr =get(config, :ifstr, "if"), elsestr= get(config, :elsestr, "otherwise"))
+      _args = filter(x -> !(x isa LineNumberNode), args)
+      if length(_args) == 2
+        write(io, "\n")
+        descend(io, _args[2], config, rules, prevop)
+        write(io, " & $ifstr \\quad ")
+        descend(io, _args[1], config, rules, prevop)
+      elseif length(_args) == 3 && head(_args[end]) == :elseif
+        write(io, "\n")
+        descend(io, _args[2], config, rules, prevop)
+        write(io, " & $ifstr \\quad ")
+        descend(io, _args[1], config, rules, prevop)
+        write(io, " \\\\")
+        descend(io, _args[3], config, rules, prevop)
+      elseif length(_args) == 3 
+        write(io, "\n")
+        descend(io, _args[2], config, rules, prevop)
+        write(io, " & $ifstr \\quad ")
+        descend(io, _args[1], config, rules, prevop)
+        write(io, " \\\\\n")
+        descend(io, _args[3], config, rules, prevop)
+        write(io, " & $elsestr")
+      else 
+        throw(ArgumentError("Unexpected if/elseif/else statement to latexify. This could well be a Latexify.jl bug."))
+      end
+      # return str
+end
+
+
+is_neg_term(x::Number) = sign(x) == -1
+is_neg_term(x::Symbol) = false
+is_neg_term(arg::Expr) = operation(arg) ∈ [:-, :.-] && !isempty(arguments(arg)) && length(arguments(arg)) == 1
+
+is_first_minus(a::Number) = sign(a) == -1
+is_first_minus(x) = false
+
+function is_first_minus(ex::Expr)  
+  length(ex.args) == 1 && return is_first_minus(ex.args[1])
+  length(ex.args) == 2 && ex.args[1] == :- && return true
+  return is_first_minus(ex.args[2])
+end
+
+function abs_first_minus(ex::Expr)  
+  length(ex.args) == 1 && return Expr(ex.head, abs_first_minus(ex.args[1])) 
+  length(ex.args) == 2 && ex.args[1] == :- && return ex.args[2]
+  return Expr(ex.head, ex.args[1], abs_first_minus(ex.args[2]), ex.args[3:end]...)
+end
+abs_first_minus(x::Number) = abs(x)
+abs_first_minus(x) = x
\ No newline at end of file
diff --git a/src/latexalign.jl b/src/latexalign.jl
deleted file mode 100644
index d98125f0..00000000
--- a/src/latexalign.jl
+++ /dev/null
@@ -1,110 +0,0 @@
-
-@doc doc"""
-    latexalign()
-Generate a ``LaTeX`` align environment from an input.
-
-# Examples
-## use with arrays
-
-```julia
-lhs = [:(dx/dt), :(dy/dt), :(dz/dt)]
-rhs = [:(y-x), :(x*z-y), :(-z)]
-latexalign(lhs, rhs)
-```
-
-```LaTeX
-\begin{align}
-\frac{dx}{dt} =& y - x \\\\
-\frac{dy}{dt} =& x \cdot z - y \\\\
-\frac{dz}{dt} =& - z \\\\
-\end{align}
-```
-
-## use with ParameterizedFunction
-
-```julia-repl
-julia> using DifferentialEquations
-julia> ode = @ode_def foldChangeDetection begin
-    dm = r_m * (i - m)
-    dy = r_y * (p_y * i/m - y)
-end i r_m r_y p_y
-
-julia> latexalign(ode)
-```
-```LaTeX
-\begin{align}
-\frac{dm}{dt} =& r_{m} \cdot \left( i - m \right) \\\\
-\frac{dy}{dt} =& r_{y} \cdot \left( \frac{p_{y} \cdot i}{m} - y \right) \\\\
-\end{align}
-```
-
-"""
-latexalign(args...; kwargs...) = latexify(args...; kwargs..., env=:align)
-
-function _latexalign(arr::AbstractMatrix; separator=" =& ", double_linebreak=false, starred=false, rows=:all, aligned=false, kwargs...)
-    eol = double_linebreak ? " \\\\\\\\\n" : " \\\\\n"
-    arr = latexraw.(arr; kwargs...)
-    separator isa String && (separator = fill(separator, size(arr)[1]))
-    str = ""
-    if aligned
-        str *= "\\begin{aligned}\n"
-    else
-        str *= "\\begin{align$(starred ? "*" : "")}\n"
-    end
-    if rows == :all
-        iterate_rows = 1:(size(arr)[1])
-    else
-        iterate_rows = rows
-    end
-
-    for i in iterate_rows
-        if i != last(iterate_rows)
-            str *= join(arr[i,:], separator[i]) * eol
-        else
-            str *= join(arr[i,:], separator[i]) * "\n"
-        end
-    end
-    if aligned
-        str *= "\\end{aligned}\n"
-    else
-        str *= "\\end{align$(starred ? "*" : "")}\n"
-    end
-    latexstr = LaTeXString(str)
-    COPY_TO_CLIPBOARD && clipboard(latexstr)
-    return latexstr
-end
-
-function _latexalign(lhs::AbstractArray, rhs::AbstractArray; kwargs...)
-    return latexalign(hcat(lhs, rhs); kwargs...)
-end
-
-function _latexalign(lhs::Tuple, rhs::Tuple; kwargs...)
-    return latexalign(hcat(collect(lhs), collect(rhs)); kwargs...)
-end
-
-_latexalign(args::Tuple...; kwargs...) = latexalign(reduce(hcat, [collect(i) for i in args]); kwargs...)
-
-_latexalign(arg::Tuple; kwargs...) = latexalign(reduce(hcat, [collect(i) for i in arg]); kwargs...)
-
-function _latexalign(nested::AbstractVector{AbstractVector}; kwargs...)
-    return latexalign(reduce(hcat, nested); kwargs...)
-end
-
-function _latexalign(d::AbstractDict; kwargs...)
-    latexalign(collect(keys(d)), collect(values(d)); kwargs...)
-end
-
-"""
-    _latexalign(vec::AbstractVector)
-
-Go through the elements, split at any = sign, pass on as a matrix.
-"""
-function _latexalign(vec::AbstractVector; kwargs...)
-    lvec = _latexraw.(vec; kwargs...)
-    ## turn the array into a matrix
-    lmat = reduce(hcat, split.(lvec, " = "))
-    ## turn the matrix ito arrays of left-hand-side, right-hand-side.
-    larr = [lmat[i,:] for i in 1:size(lmat, 1)]
-    length(larr) < 2 && error("Invalid intput to _latexalign().")
-    return latexalign( reduce(hcat, larr) ; kwargs...)
-end
diff --git a/src/latexarray.jl b/src/latexarray.jl
deleted file mode 100644
index 7bc3e63c..00000000
--- a/src/latexarray.jl
+++ /dev/null
@@ -1,51 +0,0 @@
-
-"""
-    latexarray{T}(arr::AbstractArray{T, 2})
-Create a LaTeX array environment using [`latexraw`](@ref).
-
-# Examples
-```julia
-arr = [1 2; 3 4]
-latexarray(arr)
-```
-```math
-"\\begin{equation}\n\\left[\n\\begin{array}{cc}\n1 & 2\\\\ \n3 & 4\\\\ \n\\end{array}\n\\right]\n\\end{equation}\n"
-```
-"""
-latexarray(args...; kwargs...) = latexify(args...;kwargs...,env=:array)
-
-function _latexarray(arr::AbstractArray; adjustment::Symbol=:c, transpose=false, double_linebreak=false,
-    starred=false, kwargs...)
-    transpose && (arr = permutedims(arr))
-    rows = first(size(arr))
-    columns = length(size(arr)) > 1 ? size(arr)[2] : 1
-
-    eol = double_linebreak ? " \\\\\\\\\n" : " \\\\\n"
-
-    str = "\\left[\n"
-    str *= "\\begin{array}{" * "$(adjustment)"^columns * "}\n"
-
-    arr = latexraw.(arr; kwargs...)
-    for i=1:rows, j=1:columns
-        str *= arr[i,j]
-        j==columns ? (str *= eol) : (str *= " & ")
-    end
-
-    str *= "\\end{array}\n"
-    str *= "\\right]"
-    latexstr = LaTeXString(str)
-    # COPY_TO_CLIPBOARD && clipboard(latexstr)
-    return latexstr
-end
-
-
-_latexarray(args::AbstractArray...; kwargs...) = _latexarray(reduce(hcat, args); kwargs...)
-_latexarray(arg::AbstractDict; kwargs...) = _latexarray(collect(keys(arg)), collect(values(arg)); kwargs...)
-_latexarray(arg::Tuple...; kwargs...) = _latexarray([collect(i) for i in arg]...; kwargs...)
-
-function _latexarray(arg::Tuple; kwargs...)
-    if first(arg) isa Tuple || first(arg) isa AbstractArray
-        return _latexarray([collect(i) for i in arg]...; kwargs...)
-    end
-    return _latexarray(collect(arg); kwargs...)
-end
diff --git a/src/latexbracket.jl b/src/latexbracket.jl
deleted file mode 100644
index 18084a0d..00000000
--- a/src/latexbracket.jl
+++ /dev/null
@@ -1,9 +0,0 @@
-latexbracket(args...; kwargs...) = latexify(args...; kwargs..., env=:bracket)
-
-function _latexbracket(x; kwargs...)
-    latexstr = LaTeXString( "\\[\n" * latexraw(x; kwargs...) * "\\]\n")
-    COPY_TO_CLIPBOARD && clipboard(latexstr)
-    return latexstr
-end
-
-_latexbracket(args...; kwargs...) = latexbracket(args; kwargs...)
diff --git a/src/latexequation.jl b/src/latexequation.jl
deleted file mode 100644
index c772c885..00000000
--- a/src/latexequation.jl
+++ /dev/null
@@ -1,15 +0,0 @@
-
-latexequation(args...; kwargs...) = latexify(args...; kwargs..., env=:equation)
-
-function _latexequation(eq; starred=false, kwargs...)
-    latexstr = latexraw(eq; kwargs...)
-
-    str = "\\begin{equation$(starred ? "*" : "")}\n"
-    str *= latexstr
-    str *= "\n"
-    str *= "\\end{equation$(starred ? "*" : "")}\n"
-    latexstr = LaTeXString(str)
-    COPY_TO_CLIPBOARD && clipboard(latexstr)
-    return latexstr
-end
-
diff --git a/src/latexify_function.jl b/src/latexify_function.jl
index 985c3f4e..0d68178b 100644
--- a/src/latexify_function.jl
+++ b/src/latexify_function.jl
@@ -1,65 +1,207 @@
 function latexify(args...; kwargs...)
+  io = IOBuffer(; append=true)
+  config = (; DEFAULT_CONFIG..., MODULE_CONFIG..., USER_CONFIG..., default_kwargs..., kwargs...)
+  latexify(io, args...; kwargs...)
+  call_result = LaTeXString(String(take!(io)))
+  COPY_TO_CLIPBOARD && clipboard(call_result)
+  AUTO_DISPLAY && display(call_result)
+  get(config, :render, false) && render(call_result)
+  return call_result
+end
 
-    ## Let potential recipes transform the arguments.
-    args, kwargs = apply_recipe(args...; default_kwargs..., kwargs...)
-
-    ## If the environment is unspecified, use auto inference.
-    env = get(kwargs, :env, :auto)
-
-    latex_function = infer_output(env, args...)
+function latextrace(args...; kwargs...)
+  tio = TracedIO(Function[], IOBuffer(; append=true, read=true))
+  config = (; DEFAULT_CONFIG..., MODULE_CONFIG..., USER_CONFIG..., default_kwargs..., kwargs...)
+  latexify(tio, args...; kwargs...)
+  call_result = LaTeXString(read(tio.io, String))
+  COPY_TO_CLIPBOARD && clipboard(call_result)
+  AUTO_DISPLAY && display(call_result)
+  get(config, :render, false) && render(call_result)
+  return TracedResult(tio.trace, call_result)
+end
 
-    result = latex_function(args...; kwargs...)
+function latexify(io::IO, args...; rules = vcat(DEFAULT_INSTRUCTIONS, reduce(vcat, values(MODULE_INSTRUCTIONS); init=Function[]), USER_INSTRUCTIONS, ENV_INSTRUCTIONS, USER_INSTRUCTIONS), kwargs...)
+    config = (; descend_counter = [0], DEFAULT_CONFIG..., MODULE_CONFIG..., USER_CONFIG..., default_kwargs..., kwargs...)
+    descend(io,  args, config, rules)
+end
 
-    COPY_TO_CLIPBOARD && clipboard(result)
-    AUTO_DISPLAY && display(result)
-    return result
+function iterate_top_matcher(io, config, args, prevop=:_nothing)
+    env_instructions = vcat(ENV_INSTRUCTIONS, USER_ENV_INSTRUCTIONS)
+    for f in env_instructions[end:-1:1]
+        call_result = f(io, config, args, prevop)
+        if call_result
+            return call_result
+        end
+    end
+    throw(ArgumentError("No top-level matching expression for \a$args \n$kwargs"))
 end
 
 apply_recipe(args...; kwargs...) = (args, kwargs)
 
-# These functions should only be called from inside `latexify()`, so that
-# `apply_recipe` gets a chance to change args
-const OUTPUTFUNCTIONS = Dict(
-                             :inline    => _latexinline,
-                             :tabular   => _latextabular,
-                             :table     => _latextabular,
-                             :raw       => _latexraw,
-                             :array     => _latexarray,
-                             :align     => _latexalign,
-                             :aligned   => (args...; kwargs...) -> _latexbracket(_latexalign(args...; kwargs..., aligned=true, starred=false); kwargs...),
-                             :eq        => _latexequation,
-                             :equation  => _latexequation,
-                             :bracket   => _latexbracket,
-                             :mdtable   => mdtable,
-                             :mdtext    => mdtext,
-                            )
-function infer_output(env, args...)
-    env === :auto && return get_latex_function(args...)
-    # Must be like this, because items in OUTPUTFUNCTIONS must be defined
-    env in [:arrows, :chem, :chemical, :arrow] && return _chemical_arrows
-    return OUTPUTFUNCTIONS[env]
+
+abstract type AbstractLatexifyEnvironment end
+abstract type AbstractLatexEnvironment <: AbstractLatexifyEnvironment end
+for T in [:Inline, :Equation, :Bracket, :Table, :NoEnv, :Aligned, :Array]
+  @eval(struct $T <: AbstractLatexEnvironment
+    args
+  end)
+end
+for C in [:Inline, :Equation, :Bracket]
+  @eval $C(x1, x2) = $C(x1 .=> x2)
+end
+Table(d::Dict) = Table(hcat(collect(keys(d)), collect(values(d))))
+struct Align{T} <: AbstractLatexEnvironment
+  args::Matrix{T}
+end
+Align(t1::Tuple, t2::Tuple) = Align(reduce(hcat, (collect(t1), collect(t2))))
+Align(t::Tuple{Union{Tuple, Vector}, Union{Tuple, Vector}}) = Align(reduce(hcat, collect.(t)))
+# Align(t::Tuple{Tuple}) = Align(first(t))
+Align(v1::Vector, v2::Vector) = Align([v1 v2])
+# Align(t::Tuple{Vector{<:AbstractString}}) = Align(first(t))
+Align(v::Vector{<:AbstractString}) = Align(permutedims(reduce(hcat, split.(v, '='))))
+Align(v::Vector{<:Pair}) = Align(hcat(first.(v), last.(v)))
+Align(t::Tuple{T}) where T = Align(first(t))
+struct AutoEnv <: AbstractLatexEnvironment
+  args
+  env::Symbol
+end
+AutoEnv(args; default=:auto) = AutoEnv(args, default)
+
+abstract type AbstractMarkdownEnvironment <: AbstractLatexifyEnvironment end
+for T in [:MDTable, :MDText]
+  @eval(struct $T <: AbstractMarkdownEnvironment
+    args
+  end)
 end
 
-"""
-    get_latex_function(args...)
 
-Use overloading to determine which latex environment to output.
+wrap_env(x) = AutoEnv(x)
+wrap_end(x::AbstractLatexifyEnvironment) = x
+
 
-This determines the default behaviour of `latexify()` for different inputs.
-"""
-get_latex_function(args...) = _latexinline
-get_latex_function(args::AbstractArray...) = _latexequation
-get_latex_function(args::AbstractDict) = (args...; kwargs...) -> _latexequation(_latexarray(args...; kwargs...); kwargs...)
-get_latex_function(args::Tuple...) = (args...; kwargs...) -> _latexequation(_latexarray(args...; kwargs...); kwargs...)
-get_latex_function(arg::LaTeXString) = (arg; kwargs...) -> arg
+const OUTPUTFUNCTIONS = (;
+                             :inline    => Inline,
+                             :tabular   => Table,
+                             :table     => Table,
+                             :raw       => NoEnv,
+                             :none      => NoEnv,
+                             :noenv     => NoEnv,
+                             :align     => Align,
+                             :eq        => Equation,
+                             :equation  => Equation,
+                             :bracket   => Bracket,
+                             :mdtable   => MDTable,
+                             :mdtext    => MDText,
+                            )
+                            
+const ENV_INSTRUCTIONS = [
+  function _auto_environment(io::IO,  x, config, rules, prevop)
+    if x isa Tuple{AutoEnv} || (x isa Tuple && config[:descend_counter] == [1])
+      args = x isa Tuple{AutoEnv} ? x[1].args : x
+      _default_env = x isa Tuple{AutoEnv} ? x[1].env : :_nothing
+      if haskey(config, :env) && !haskey(OUTPUTFUNCTIONS, config.env)
+        throw(ArgumentError("Unsupported env specification :$(config.env)\nSupported envs are $(keys(OUTPUTFUNCTIONS))"))
+      end
 
-function get_latex_function(x::AbstractArray{T}) where T <: AbstractArray
-    try
-        x = reduce(hcat, x)
-        return (args...; kwargs...) -> _latexequation(_latexarray(args...; kwargs...); kwargs...)
-    catch
-        return _latexinline
+      env = get(config, :env, _default_env)
+      if haskey(OUTPUTFUNCTIONS, env) 
+        descend(io,  (OUTPUTFUNCTIONS[env](args...),), config, rules, prevop) 
+      elseif args isa Tuple{Vector, Vector}
+        descend(io,  (Align(hcat(args[1], args[2])),), config, rules)
+      elseif length(args) == 1
+        descend(io,  (Inline(args[1]),), config, rules)
+      else
+        throw(MethodError("Unspported argument to `latexify`: $args"))
+      end
+      return true
     end
-end
+    return false
+  end,
+  function _no_env(io::IO,  x, config, rules, prevop)
+    if x isa Tuple{NoEnv}
+      # for arg in x[1].args
+      descend(io,  x[1].args, config, rules, prevop)
+        # descend(io,  arg, config, rules, prevop)
+      # end
+      return true
+    end
+    return false
+  end,
+  function _inline(io::IO,  x, config, rules, prevop)
+    if x isa Tuple{Inline}
+      write(io, "\$")
+      descend(io,  x[1].args, config, rules, prevop)
+      write(io, "\$")
+      return true
+    end
+    return false
+  end,
+  function _table(io::IO,  x, config, rules, prevop)
+    if x isa Tuple{Table}
+      adjustment = get(config, :adjustment, "l")
+      elements = get(config, :latex, true) ? map(y->(Inline(y),), x[1].args) : x[1].args
+      get(config, :transpose, false) && (elements = permutedims(elements))
+      if haskey(config, :head)
+        elements=vcat(permutedims(vec(config[:head])), elements)
+      end
+      if haskey(config, :side)
+        elements=hcat(vec(config[:side]), elements)
+      end
+      columns = size(elements, 2)
+      write(io, "\\begin{tabular}{$(string(adjustment)^columns)}\n")
+      get(config, :booktabs, false) && write(io, "\\toprule\n")
+      join_matrix(io,  elements, config, rules, " & ")
+      get(config, :booktabs, false) && write(io, "\\bottomrule\n")
+      write(io, "\\end{tabular}")
+      return true
+    end
+    return false
+  end,
+  function _align(io::IO,  x, config, rules, prevop)
+    if x isa Tuple{Align}
+      write(io, "\\begin{align$(get(config, :starred, false) ? '*' : "")}\n")
+      join_matrix(io,  x[1].args, config, rules, get(config, :separator, " =& "))
+      write(io, "\\end{align$(get(config, :starred, false) ? '*' : "")}\n")
+      return true
+    end
+    return false
+  end,
+  function _bracket(io::IO,  x, config, rules, prevop)
+    if x isa Tuple{Bracket}
+      write(io, "\\[\n")
+      descend(io,  x[1].args, config, rules, prevop)
+      write(io, "\n\\]")
+      return true
+    end
+    return false
+  end,
+  function _equation(io::IO,  x, config, rules, prevop)
+    if x isa Tuple{Equation}
+      write(io, "\\begin{equation$(get(config, :starred, false) ? '*' : "")}\n")
+      descend(io,  x[1].args, config, rules, prevop)
+      write(io, "\n\\end{equation$(get(config, :starred, false) ? '*' : "")}")
+      return true
+    end
+    return false
+  end,
+  # function _mdtable(io::IO, x ,config, rules, prevop)
+  #   if x isa Tuple{MDTable}
+
+  #   end
+  #   return false
+  # end
+]
 
-get_latex_function(lhs::AbstractVector, rhs::AbstractVector) = _latexalign
+join_matrix(io, m, config, rules, delim::Union{String, Char, Symbol}, eol) = join_matrix(io, m, config, rules, fill(delim, size(m,1))) 
+function join_matrix(io,  m, config, rules, delim = fill(" & ", size(m, 1)), eol=" \\\\\n")
+   nrows, ncols = size(m)
+   for (i, row) in enumerate(eachrow(m))
+       for x in row[1:end-1]
+            descend(io,  x, config, rules)
+            write(io, delim[i])
+       end
+       descend(io,  row[end], config, rules)
+       i != nrows ? write(io, eol) : write(io, "\n")
+    end
+    return nothing
+end
\ No newline at end of file
diff --git a/src/latexinline.jl b/src/latexinline.jl
deleted file mode 100644
index 9991b6be..00000000
--- a/src/latexinline.jl
+++ /dev/null
@@ -1,7 +0,0 @@
-latexinline(args...;kwargs...) = latexify(args...;kwargs...,env=:inline)
-
-function _latexinline(x; kwargs...)
-    latexstr = latexstring( latexify(x; kwargs...,env=:raw) )
-    COPY_TO_CLIPBOARD && clipboard(latexstr)
-    return latexstr
-end
\ No newline at end of file
diff --git a/src/latexoperation.jl b/src/latexoperation.jl
deleted file mode 100644
index cf4735f9..00000000
--- a/src/latexoperation.jl
+++ /dev/null
@@ -1,229 +0,0 @@
-"""
-    latexoperation(ex::Expr, prevOp::AbstractArray)
-
-Translate a simple operation given by `ex` to LaTeX maths syntax.
-This uses the information about the previous operations to decide if
-a parenthesis is needed.
-
-"""
-function latexoperation(ex::Expr, prevOp::AbstractArray; cdot=true, index=:bracket, kwargs...)::String
-    op = ex.args[1]
-    args = map(i -> typeof(i) ∉ (String, LineNumberNode) ? latexraw(i; kwargs...) : i, ex.args)
-
-    # Remove math italics for variables (i.e. words) longer than 2 characters.
-    # args = map(i -> (i isa String && all(map(isletter, collect(i))) && length(i) > 2) ? "{\\rm $i}" : i, args)
-
-    if ex.head == :latexifymerge
-        if all(prevOp .== :none)
-            return join(args)
-        else
-            return "$(args[1])\\left( $(join(args[2:end])) \\right)"
-        end
-    end
-
-    if op in [:/, :./]
-        return "\\frac{$(args[2])}{$(args[3])}"
-
-    elseif op in [:*, :.*]
-        str=""
-        for i in 2:length(args)
-            arg = args[i]
-            prevOp[i] in [:+, :-, :±]  && (arg = "\\left( $arg \\right)")
-            str = string(str, arg)
-            i != length(args) && (str *= cdot ? " \\cdot " : " ")
-        end
-        return str
-
-    elseif op in [:+, :.+]
-        str = join(args[2:end], " + ")
-        str = replace(str, "+  -"=>"-")
-        str = replace(str, "+ -"=>"-")
-        return str
-
-    elseif op in [:±, :.±]
-        return "$(args[2]) \\pm $(args[3])"
-
-    elseif op in [:-, :.-]
-        if length(args) == 2
-            if prevOp[2] == :none && string(args[2])[1] == '-'
-                return " + " * string(args[2])[2:end]
-            elseif prevOp[2] == :none && string(args[2])[1] == '+'
-                return " - " * string(args[2])[2:end]
-            elseif prevOp[2] in [:+, :-, :±]
-                return " - \\left( $(args[2]) \\right)"
-            end
-            return " - $(args[2])"
-        end
-        prevOp[3] in [:+, :-, :±] &&  (args[3] = "\\left( $(args[3]) \\right)")
-
-        if prevOp[3] == :none && string(args[3])[1] == '-'
-            return "$(args[2]) + " * string(args[3])[2:end]
-        end
-        return "$(args[2]) - $(args[3])"
-
-    elseif op in [:^, :.^]
-        #isa(args[2], String) && (args[2]="($(args[2]))")
-        if prevOp[2] in trigonometric_functions
-            str = get(function2latex, prevOp[2], "\\$(prevOp[2])")
-            return replace(args[2], str => "$(str)^{$(args[3])}")
-        end
-        if (prevOp[2] != :none) || (ex.args[2] isa Real && sign(ex.args[2]) == -1) || (ex.args[2] isa Complex) || (ex.args[2] isa Rational)
-            args[2]="\\left( $(args[2]) \\right)"
-        end
-        return "$(args[2])^{$(args[3])}"
-    elseif (ex.head in (:(=), :function)) && length(args) == 2
-        return "$(args[1]) = $(args[2])"
-    elseif op == :(!)
-        return "\\neg $(args[2])"
-    end
-
-    if ex.head == :.
-        ex.head = :call
-        # op = string(op, ".") ## Signifies broadcasting.
-    end
-
-    string(op)[1] == '.' && (op = Symbol(string(op)[2:end]))
-
-    # infix_operators = [:<, :>, Symbol("=="), :<=, :>=, :!=]
-    comparison_operators = Dict(
-        :< => "<",
-        :.< => "<",
-        :> => ">",
-        :.> => ">",
-        Symbol("==") => "=",
-        Symbol(".==") => "=",
-        :<= => "\\leq",
-        :.<= => "\\leq",
-        :>= => "\\geq",
-        :.>= => "\\geq",
-        :!= => "\\neq",
-        :.!= => "\\neq",
-        )
-
-    if op in keys(comparison_operators) && length(args) == 3
-        str = "$(args[2]) $(comparison_operators[op]) $(args[3])"
-        str = "\\left( $str \\right)"
-        return str
-    end
-
-    ### Check for chained comparison operators
-    if ex.head == :comparison && Symbol.(args[2:2:end]) ⊆ keys(comparison_operators)
-        str = join([isodd(i) ? "$var" : comparison_operators[var] for (i, var) in enumerate(Symbol.(args))], " ")
-        str = "\\left( $str \\right)"
-        return str
-    end
-
-    if op in keys(function2latex)
-        return "$(function2latex[op])\\left( $(join(args[2:end], ", ")) \\right)"
-    end
-
-    op == :sqrt && return "\\$op{$(args[2])}"
-    op == :abs && return "\\left\\|$(args[2])\\right\\|"
-    op == :exp && return "e^{$(args[2])}"
-
-    ## Leave math italics for single-character operator names (e.g., f(x)).
-    opname = replace(string(op), '_'=>raw"\_")
-    if length(opname) > 1
-        opname = "\\mathrm{$opname}"
-    end
-
-    if ex.head == :ref
-        if index == :subscript
-            return "$(args[1])_{$(join(args[2:end], ","))}"
-        elseif index == :bracket
-            argstring = join(args[2:end], ", ")
-            return "$opname\\left[$argstring\\right]"
-        else
-            throw(ArgumentError("Incorrect `index` keyword argument to latexify. Valid values are :subscript and :bracket"))
-        end
-    end
-
-    if ex.head == :macrocall && ex.args[1] == Symbol("@__dot__")
-        return string(ex.args[end])
-    end
-
-    if ex.head == :call
-        if length(args) == 1
-            return "$opname()"
-        elseif args[2] isa String && occursin("=", args[2])
-            return "$opname\\left( $(join(args[3:end], ", ")); $(args[2]) \\right)"
-        else
-            return "$opname\\left( $(join(args[2:end], ", ")) \\right)"
-        end
-    end
-
-    if ex.head == :tuple
-        # return "\\left(" * join(ex.args, ", ") * "\\right)"
-        return join(ex.args, ", ")
-    end
-
-    ex.head == Symbol("'") && return "$(args[1])'"
-
-    ## Enable the parsing of kwargs in a function definition
-    ex.head == :kw && return "$(args[1]) = $(args[2])"
-    ex.head == :parameters && return join(args, ", ")
-
-    ## Use the last expression in a block.
-    ## This is somewhat shady but it helps with latexifying functions.
-    ex.head == :block && return args[end]
-
-    ## Sort out type annotations. Mainly for function arguments.
-    ex.head == :(::) && length(args) == 1 && return "::$(args[1])"
-    ex.head == :(::) && length(args) == 2 && return "$(args[1])::$(args[2])"
-
-    ## Pass back values that were explicitly returned.
-    ex.head == :return && length(args) == 1 && return args[1]
-
-    ## Case enviroment for if statements and ternary ifs.
-    if ex.head in (:if, :elseif)
-        textif::String = "\\text{if }"
-        begincases::String = ex.head == :if ? "\\begin{cases}\n" : ""
-        endcases::String = ex.head == :if ? "\n\\end{cases}" : ""
-        if length(args) == 3
-            # Check if already parsed elseif as args[3]
-            haselseif::Bool = occursin(Regex("\\$textif"), args[3])
-            otherwise::String = haselseif ? "" : " & \\text{otherwise}"
-            return """$begincases$(args[2]) & $textif $(args[1])\\\\
-                      $(args[3])$otherwise$endcases"""
-        elseif length(args) == 2
-            return "$begincases$(args[2]) & $textif $(args[1])$endcases"
-        end
-    end
-
-    ## Conditional operators converted to logical operators.
-    ex.head == :(&&) && length(args) == 2 && return "$(args[1]) \\wedge $(args[2])"
-    ex.head == :(||) && length(args) == 2 && return "$(args[1]) \\vee $(args[2])"
-
-
-
-    ## if we have reached this far without a return, then error.
-    error("Latexify.jl's latexoperation does not know what to do with one of the
-          expressions provided ($ex).")
-    return ""
-end
-
-latexoperation(sym::Symbol, prevOp::AbstractArray; kwargs...) = "$sym"
-
-
-function convertSubscript!(ex::Expr)
-    for i in 1:length(ex.args)
-        arg = ex.args[i]
-        if arg isa Symbol
-            ex.args[i] = convertSubscript(arg)
-        end
-    end
-    return nothing
-end
-
-function convertSubscript(str::String)
-    if occursin("_", str)
-        subscriptList = split(str, "_")
-        subscript = join(subscriptList[2:end], "\\_")
-        result = "$(subscriptList[1])_{$subscript}"
-    else
-        result = str
-    end
-    return result
-end
-
-convertSubscript(sym::Symbol) = convertSubscript(string(sym))
diff --git a/src/latexraw.jl b/src/latexraw.jl
index 58e38961..f4d1bb8c 100644
--- a/src/latexraw.jl
+++ b/src/latexraw.jl
@@ -1,142 +1,104 @@
-@doc doc"""
-    latexraw(arg)
-
-Generate LaTeX equations from `arg`.
-
-Parses expressions, ParameterizedFunctions, SymEngine.Base and arrays thereof.
-Returns a string formatted for LaTeX.
-
-# Examples
-
-## using expressions
-```jldoctest
-expr = :(x/(y+x))
-latexraw(expr)
-
-# output
-
-"\\frac{x}{y + x}"
-```
-
-```jldoctest
-expr = Meta.parse("x/(y+x)")
-latexraw(expr)
-
-# output
-
-"\\frac{x}{y + x}"
-```
-
-## using ParameterizedFunctions
-```julia
-using DifferentialEquations;
-f = @ode_def feedback begin
-         dx = y/c_1 - x
-         dy = x^c_2 - y
-       end c_1=>1.0 c_2=>1.0
-latexraw(f)
-
-# output
-
-2-element Array{String,1}:
- "dx/dt = \\frac{y}{c_{1}} - x"
- "dy/dt = x^{c_{2}} - y"
-```
-
-## using SymEngine
-```jldoctest
-using SymEngine
-@vars x y
-symExpr = x + x + x*y*y
-latexraw(symExpr)
-
-# output
-
-"2 \\cdot x + x \\cdot y^{2}"
-```
-"""
-latexraw(args...; kwargs...) = latexify(args...; kwargs..., env=:raw)
-
-function _latexraw(inputex::Expr; convert_unicode=true, kwargs...)
-    ## Pass all arrays or matrices in the expr to latexarray
-    inputex = postwalk(x -> x isa Expr && x.head in [:hcat, :vcat, :vect, :typed_vcat, :typed_hcat] ?
-                       latexarray(expr_to_array(x); kwargs...)
-                       : x,
-                       inputex)
-
-    recurseexp!(lstr::LaTeXString) = lstr.s
-    function recurseexp!(ex)
-        prevOp = Vector{Symbol}(undef, length(ex.args))
-        fill!(prevOp, :none)
-        for i in 1:length(ex.args)
-            if isa(ex.args[i], Expr)
-                length(ex.args[i].args) > 1 && ex.args[i].args[1] isa Symbol && (prevOp[i] = ex.args[i].args[1])
-                ex.args[i] = recurseexp!(ex.args[i])
-            elseif ex.args[i] isa AbstractArray
-                ex.args[i] = latexraw(ex.args[i]; kwargs...)
-            end
-        end
-        return latexoperation(ex, prevOp; convert_unicode=convert_unicode, kwargs...)
-    end
-    ex = deepcopy(inputex)
-    str = recurseexp!(ex)
-    convert_unicode && (str = unicode2latex(str))
-    return LaTeXString(str)
-end
-
-
-function _latexraw(args...; kwargs...)
-    @assert length(args) > 1 "latexify does not support objects of type $(typeof(args[1]))."
-    _latexraw(args; kwargs...)
-end
-_latexraw(arr::Union{AbstractArray, Tuple}; kwargs...) = _latexarray(arr; kwargs...)
-_latexraw(i::Nothing; kwargs...) = ""
-_latexraw(i::SubString; kwargs...) = latexraw(Meta.parse(i); kwargs...)
-_latexraw(i::SubString{LaTeXStrings.LaTeXString}; kwargs...) = i
-_latexraw(i::Rational; kwargs...) = i.den == 1 ? latexraw(i.num; kwargs...) : latexraw(:($(i.num)/$(i.den)); kwargs...)
-_latexraw(z::Complex; kwargs...) = LaTeXString("$(latexraw(z.re;kwargs...))$(z.im < 0 ? "-" : "+" )$(latexraw(abs(z.im);kwargs...))\\textit{i}")
-#latexraw(i::DataFrames.DataArrays.NAtype) = "\\textrm{NA}"
-_latexraw(str::LaTeXStrings.LaTeXString; kwargs...) = str
-
-function _latexraw(i::Number; fmt=PlainNumberFormatter(), kwargs...)
-    try isinf(i) && return LaTeXString("\\infty") catch; end
-    fmt isa String && (fmt = PrintfNumberFormatter(fmt))
-    return fmt(i)
+const INSTRUCTIONS = Function[]
+const USER_INSTRUCTIONS = Function[]
+const MODULE_INSTRUCTIONS = Dict{Symbol, Vector{Function}}()
+const USER_ENV_INSTRUCTIONS = Function[]
+
+# function latexraw(io::IO, config::NamedTuple, expr)
+#   # empty!(CONFIG)
+#   # merge!(CONFIG, DEFAULT_CONFIG, kwargs)
+#   empty!(INSTRUCTIONS)
+#   append!(INSTRUCTIONS, DEFAULT_INSTRUCTIONS, USER_INSTRUCTIONS, ENV_INSTRUCTIONS)
+#   descend(io, config, expr)
+# #   CONFIG[:convert_unicode] && (str = unicode2latex(str))
+#   return nothing
+# end
+
+
+function capture_function_signature(ex)
+  ex.head ∉ [:function, :(=)] && throw(ArgumentError("Malformed function signature to latexify recipe macro."))
+  annotated_args = ex.args[1].args[2:end]
+  types = Tuple(getindex.(getfield.(annotated_args, :args), 2))
+  vars = Tuple(getindex.(getfield.(annotated_args, :args), 1))
+  return vars, types
 end
 
-function _latexraw(i::Char; convert_unicode=true, kwargs...)
-    LaTeXString(convert_unicode ? unicode2latex(string(i)) : string(i))
+function capture_function_body(ex)
+    if ex.head == :function
+    elseif ex.head == :(=)
+       return ex.args[2]
+    else
+      throw(ArgumentError("Malformed function signature to latexify recipe macro."))
+    end
 end
 
-function _latexraw(i::Symbol; convert_unicode=true, kwargs...)
-    str = string(i == :Inf ? :∞ : i)
-    str = convertSubscript(str)
-    convert_unicode && (str = unicode2latex(str))
-    return LaTeXString(str)
+macro latextype(expr)
+  vars, types = capture_function_signature(expr)
+  body = esc(capture_function_body(expr))
+  io, x, prevop, config = gensym(:io), gensym(:x), gensym(:prevop), gensym(:config)
+  body = MacroTools.postwalk(x -> x isa Expr && x.head == :call && x.args[1] == :descend ? Expr(x.head, x.args[1], io, x.args[2], prevop, config) : x, body)
+
+  fname = gensym(:recipe_fn)
+  return esc(quote
+    push!(USER_INSTRUCTIONS, 
+       function $(fname)($io, $x, $prevop, $config)
+         $x isa Tuple && length($x) == $(length(vars)) || return false
+         types = $types
+        for i in $(eachindex(vars))
+          typeof($x[i]) <: types[i] || return false 
+        end
+         $(vars) = $x
+         $x[1] isa $(types[1]) || return false
+         $body
+         return true
+       end
+    )
+  end)
 end
-
-function _latexraw(i::String; kwargs...)
-    try
-        ex = Meta.parse(i)
-        return latexraw(ex; kwargs...)
-    catch ParseError
-        error("""
-in Latexify.jl:
-You are trying to create latex-maths from a `String` that cannot be parsed as
-an expression.
-
-`latexify` will, by default, try to parse any string inputs into expressions
-and this parsing has just failed.
-
-If you are passing strings that you want returned verbatim as part of your input,
-try making them `LaTeXString`s first.
-
-If you are trying to make a table with plain text, try passing the keyword
-argument `latex=false`. You should also ensure that you have chosen an output
-environment that is capable of displaying not-maths objects. Try for example
-`env=:table` for a latex table or `env=:mdtable` for a markdown table.
-""")
+# add_matcher(f) = push!(MATCHING_FUNCTIONS, f)
+
+# _check_call_match(e, op::Symbol) = e isa Expr && e.head === :call && e.args[1] === op
+# _check_call_match(e, op::AbstractArray) = e isa Expr && e.head === :call && e.args[1] ∈ op
+
+# # User would write:
+# #   text_color_latexify(e) = "\\textcolor{$(args[1])}{$(latexify(args[2]))}"
+# #   add_call_matcher(text_color_latexify, :textcolor)
+# function add_call_matcher(op, f::Function)
+#     push!(MATCHING_FUNCTIONS, (expr, prevop, config) -> _check_call_match(expr, op) ? f(expr, prevop, config) : nothing)
+# end
+
+
+nested(::Any) = false
+arguments(::Any) = nothing
+operation(::Any) = nothing
+head(::Any) = nothing
+
+nested(::Expr) = true
+arguments(ex::Expr) = ex.args[2:end]
+operation(ex::Expr) = ex.args[1]
+head(ex::Expr) = ex.head
+
+unpack(x) = (head(x), operation(x), arguments(x))
+
+function descend(io::IO, e, config::NamedTuple, rules::Vector{Function}, prevop=:(_nothing))::Nothing
+    config[:descend_counter][1] += 1
+    io isa TracedIO && push!(io.trace, x->nothing)
+    for rule in rules[end:-1:1]
+        io isa TracedIO && (io.trace[end] = rule) ## Inefficient to overwrite so much but should I care?
+        call_matched = rule(io, e, config, rules, prevop)::Bool
+        if call_matched
+            return nothing
+            break
+        end
     end
+    throw(ArgumentError("No matching expression conversion function for $e"))
 end
 
-_latexraw(i::Missing; kwargs...) = "\\textrm{NA}"
+surround(x) = "\\left( $x \\right)"
+
+function join_descend(io::IO, args, config, rules, delim; prevop=nothing) 
+  for arg in args[1:end-1]
+    descend(io, arg, config, rules, prevop)
+    write(io, delim)
+  end
+  descend(io, args[end], config, rules, prevop)
+end
\ No newline at end of file
diff --git a/src/latextabular.jl b/src/latextabular.jl
deleted file mode 100644
index 816d6ff7..00000000
--- a/src/latextabular.jl
+++ /dev/null
@@ -1,56 +0,0 @@
-latextabular(args...; kwargs...) = latexify(args...; kwargs..., env=:tabular)
-
-function _latextabular(arr::AbstractMatrix; latex::Bool=true, booktabs::Bool=false, head=[], side=[], adjustment::Symbol=:c, transpose=false, kwargs...)
-    transpose && (arr = permutedims(arr, [2,1]))
-
-    if !isempty(head)
-        arr = vcat(reduce(hcat, head), arr)
-        @assert length(head) == size(arr, 2) "The length of the head does not match the shape of the input matrix."
-    end
-    if !isempty(side)
-        length(side) == size(arr, 1) - 1 && (side = [""; side])
-        @assert length(side) == size(arr, 1) "The length of the side does not match the shape of the input matrix."
-        arr = hcat(side, arr)
-    end
-
-    (rows, columns) = size(arr)
-    str = "\\begin{tabular}{" * "$(adjustment)"^columns * "}\n"
-
-    if booktabs
-        str *= "\\toprule\n"
-    end
-
-    if latex
-        arr = latexinline.(arr; kwargs...)
-    elseif haskey(kwargs, :fmt)
-        formatter = kwargs[:fmt] isa String ? PrintfNumberFormatter(kwargs[:fmt]) : kwargs[:fmt]
-        arr = map(x -> x isa Number ? formatter(x) : x, arr)
-    end
-
-    # print first row
-    str *= join(arr[1,:], " & ")
-    str *= "\\\\\n"
-
-    if booktabs && !isempty(head)
-        str *= "\\midrule\n"
-    end
-
-    for i in 2:size(arr, 1)
-        str *= join(arr[i,:], " & ")
-        str *= "\\\\\n"
-    end
-
-    if booktabs
-        str *= "\\bottomrule\n"
-    end
-
-    str *= "\\end{tabular}\n"
-    latexstr = LaTeXString(str)
-    COPY_TO_CLIPBOARD && clipboard(latexstr)
-    return latexstr
-end
-
-
-_latextabular(vec::AbstractVector; kwargs...) = latextabular(reduce(hcat, vec); kwargs...)
-_latextabular(vectors::AbstractVector...; kwargs...) = latextabular(reduce(hcat, vectors); kwargs...)
-_latextabular(dict::AbstractDict; kwargs...) = latextabular(hcat(collect(keys(dict)), collect(values(dict))); kwargs...)
diff --git a/src/recipes.jl b/src/recipes.jl
index 022d67b3..5df183c8 100644
--- a/src/recipes.jl
+++ b/src/recipes.jl
@@ -167,3 +167,40 @@ macro latexrecipe(funcexpr)
     return funcdef
 end
 
+
+macro latexruletest(typename, expr)
+  x = expr.args[1].args[3]
+  io = expr.args[1].args[2]
+  return quote 
+      if !haskey(Latexify.MODULE_INSTRUCTIONS, Symbol($__module__)) 
+        Latexify.MODULE_INSTRUCTIONS[Symbol($__module__)]=Function[]
+      end
+      push!(
+        Latexify.MODULE_INSTRUCTIONS[Symbol($__module__)], 
+        function $((Symbol("type_recipe_", typename)))($io, config, $x, rules, prevop)
+          if $x isa $(esc(typename))
+            $(expand_descend(expr.args[end]))
+            return true
+          end
+          return false
+        end
+      )
+    end
+end
+
+using MacroTools
+
+function expand_descend(ex)
+  MacroTools.postwalk(x->head(x)==:call && operation(x)==:descend ? :(descend(io, config, $(x.args[end]), rules, prevop)) : x, ex)
+end
+
+
+# Example usage
+# f = @latexruletest TestModule1.TestType1 function f(io, x)
+#     write(io, "hello")
+#     descend(x.args)
+#     write(io, "bye")
+#     descend(x.args)
+#     write(io, "Just kidding!")
+#     descend(x.args)
+# end
\ No newline at end of file
diff --git a/src/utils.jl b/src/utils.jl
index 6e414d6e..e5473298 100644
--- a/src/utils.jl
+++ b/src/utils.jl
@@ -16,7 +16,8 @@ function _writetex(s::LaTeXString; name=tempname(), command="\\Large")
     \\documentclass[varwidth=100cm]{standalone}
     \\usepackage{amssymb}
     \\usepackage{amsmath}
-    $(occursin("\\ce{", s) ? "\\usepackage{mhchem}" : "")
+    $(occursin("\\ce{", s) ? "\\usepackage[version=3]{mhchem}" : "")
+    $(occursin("\\textcolor{", s) ? "\\usepackage{xcolor}" : "")
     \\begin{document}
     {
         $command
@@ -192,6 +193,30 @@ function render(s::LaTeXString, ::MIME"image/svg"; debug=false, name=tempname(),
 end
 
 
+function convert_subscript!(ex::Expr)
+    for i in 1:length(ex.args)
+        arg = ex.args[i]
+        if arg isa Symbol
+            ex.args[i] = convert_subscript(arg)
+        end
+    end
+    return nothing
+end
+
+function convert_subscript(str::String)
+    if occursin("_", str)
+        subscript_list = split(str, "_")
+        subscript = join(subscript_list[2:end], "\\_")
+        result = "$(subscript_list[1])_{$subscript}"
+    else
+        result = str
+    end
+    return result
+end
+
+convert_subscript(sym::Symbol) = convert_subscript(string(sym))
+
+
 function expr_to_array(ex)
     ex.head == :typed_vcat && (ex = Expr(:vcat, ex.args[2:end]...))
     ex.head == :typed_hcat && (ex = Expr(:hcat, ex.args[2:end]...))
diff --git a/test/cdot_test.jl b/test/cdot_test.jl
index f3a48263..e4ca4020 100644
--- a/test/cdot_test.jl
+++ b/test/cdot_test.jl
@@ -4,47 +4,45 @@ using Test
 
 
 #inline
-@test latexify(:(x * y); env=:inline, cdot=false) == raw"$x y$"
+@test latexify(:(x * y); env=:inline, mulsym=" ") == raw"$x y$"
 
-@test latexify(:(x * y); env=:inline, cdot=true) == raw"$x \cdot y$"
+@test latexify(:(x * y); env=:inline, mulsym=" \\cdot ") == raw"$x \cdot y$"
 
-@test latexify(:(x*(y+z)*y*(z+a)*(z+b)); env=:inline, cdot=false) ==
+@test latexify(:(x*(y+z)*y*(z+a)*(z+b)); env=:inline, mulsym=" ") ==
 raw"$x \left( y + z \right) y \left( z + a \right) \left( z + b \right)$"
 
-@test latexify(:(x*(y+z)*y*(z+a)*(z+b)); env=:inline, cdot=true) ==
+@test latexify(:(x*(y+z)*y*(z+a)*(z+b)); env=:inline, mulsym=" \\cdot ") ==
 raw"$x \cdot \left( y + z \right) \cdot y \cdot \left( z + a \right) \cdot \left( z + b \right)$"
 
 # raw
-@test latexify(:(x * y); env=:raw, cdot=false) == raw"x y"
+@test latexify(:(x * y); env=:raw, mulsym=" ") == raw"x y"
 
-@test latexify(:(x * y); env=:raw, cdot=true) == raw"x \cdot y"
+@test latexify(:(x * y); env=:raw, mulsym=" \\cdot ") == raw"x \cdot y"
 
-@test latexify(:(x * (y + z) * y * (z + a) * (z + b)); env=:raw, cdot=false) ==
+@test latexify(:(x * (y + z) * y * (z + a) * (z + b)); env=:raw, mulsym=" ") ==
 raw"x \left( y + z \right) y \left( z + a \right) \left( z + b \right)"
 
-@test latexify(:(x * (y + z) * y * (z + a) * (z + b)); env=:raw, cdot=true) ==
+@test latexify(:(x * (y + z) * y * (z + a) * (z + b)); env=:raw, mulsym=" \\cdot ") ==
 raw"x \cdot \left( y + z \right) \cdot y \cdot \left( z + a \right) \cdot \left( z + b \right)"
 
 # array
-@test latexify( [:(x*y), :(x*(y+z)*y*(z+a)*(z+b))]; env=:equation, transpose=true, cdot=false) == replace(
+@test latexify( [:(x*y), :(x*(y+z)*y*(z+a)*(z+b))]; env=:equation, transpose=true, mulsym=" ") == replace(
 raw"\begin{equation}
 \left[
 \begin{array}{cc}
 x y & x \left( y + z \right) y \left( z + a \right) \left( z + b \right) \\
 \end{array}
 \right]
-\end{equation}
-", "\r\n"=>"\n")
+\end{equation}", "\r\n"=>"\n")
 
-@test latexify( [:(x*y), :(x*(y+z)*y*(z+a)*(z+b))]; env=:equation, transpose=true, cdot=true) == replace(
+@test latexify( [:(x*y), :(x*(y+z)*y*(z+a)*(z+b))]; env=:equation, transpose=true, mulsym=" \\cdot ") == replace(
 raw"\begin{equation}
 \left[
 \begin{array}{cc}
 x \cdot y & x \cdot \left( y + z \right) \cdot y \cdot \left( z + a \right) \cdot \left( z + b \right) \\
 \end{array}
 \right]
-\end{equation}
-", "\r\n"=>"\n")
+\end{equation}", "\r\n"=>"\n")
 
 
 
@@ -52,7 +50,7 @@ x \cdot y & x \cdot \left( y + z \right) \cdot y \cdot \left( z + a \right) \cdo
 # mdtable
 arr = ["x*(y-1)", 1.0, 3*2, :(x-2y), :symb]
 
-@test latexify(arr; env=:mdtable, cdot=false) ==
+@test_broken latexify(arr; env=:mdtable, mulsym=" ") ==
 Markdown.md"| $x \left( y - 1 \right)$ |
 | ------------------------:|
 |                    $1.0$ |
@@ -61,7 +59,7 @@ Markdown.md"| $x \left( y - 1 \right)$ |
 |                   $symb$ |
 "
 
-@test latexify(arr; env=:mdtable, cdot=true) ==
+@test_broken latexify(arr; env=:mdtable, mulsym=" \\cdot ") ==
 Markdown.md"| $x \cdot \left( y - 1 \right)$ |
 | ------------------------------:|
 |                          $1.0$ |
diff --git a/test/latexalign_test.jl b/test/latexalign_test.jl
index 823c0abe..6a4efd04 100644
--- a/test/latexalign_test.jl
+++ b/test/latexalign_test.jl
@@ -1,7 +1,7 @@
 using Latexify
+# Latexify.set_default(; render=true)
 using Test
 
-
 @test latexify(((1.0, 2), (3, 4)); env=:align) == replace(
 raw"\begin{align}
 1.0 =& 3 \\
@@ -16,24 +16,26 @@ raw"\begin{align}
 \end{align}
 ", "\r\n"=>"\n")
 
-
 lhs = [:a, :b]
 rhs = [1, 2]
 
-@test latexify(lhs, rhs; env = :aligned) == replace(
+@test latexify(lhs, rhs; env = :bracket) == replace(
 raw"\[
 \begin{aligned}
 a =& 1 \\
 b =& 2
 \end{aligned}
-\]
-", "\r\n"=>"\n")
-
-# @test_throws MethodError latexify(rn; bad_kwarg="should error")
+\]", "\r\n"=>"\n")
 
-# Latexify.@generate_test latexify(["a=1"], env=:align)
 @test latexify(["a=1"], env = :align) == replace(
 raw"\begin{align}
 a =& 1
 \end{align}
-", "\r\n"=>"\n")
\ No newline at end of file
+", "\r\n"=>"\n")
+
+@test latexify(["a=1" ,"b=2", "c=x/y"], env = :align) == raw"\begin{align}
+a =& 1 \\
+b =& 2 \\
+c =& \frac{x}{y}
+\end{align}
+"
\ No newline at end of file
diff --git a/test/latexarray_test.jl b/test/latexarray_test.jl
index 4bb2825b..daa61eb1 100644
--- a/test/latexarray_test.jl
+++ b/test/latexarray_test.jl
@@ -1,18 +1,17 @@
 using Latexify
 using Test
 
+# Latexify.set_default(;render=true)
 arr = [1 2; 3 4]
 
+latexify(arr; env=:equation)
 @test latexify(arr) == replace(
-raw"\begin{equation}
-\left[
+raw"$\left[
 \begin{array}{cc}
 1 & 2 \\
 3 & 4 \\
 \end{array}
-\right]
-\end{equation}
-", "\r\n"=>"\n")
+\right]$", "\r\n"=>"\n")
 
 # Latexify.@generate_test latexify(arr; env=:inline)
 @test latexify(arr; env = :inline) == replace(
@@ -32,8 +31,7 @@ raw"\begin{equation}
 3 & 4 \\
 \end{array}
 \right]
-\end{equation}
-", "\r\n"=>"\n")
+\end{equation}", "\r\n"=>"\n")
 
 # Latexify.@generate_test latexify(arr; env=:bracket)
 @test latexify(arr; env = :bracket) == replace(
@@ -43,8 +41,8 @@ raw"\[
 1 & 2 \\
 3 & 4 \\
 \end{array}
-\right]\]
-", "\r\n"=>"\n")
+\right]
+\]", "\r\n"=>"\n")
 
 # Latexify.@generate_test latexify(arr; env=:raw)
 @test latexify(arr; env = :raw) == replace(
@@ -58,49 +56,21 @@ raw"\left[
 arr = [1,2,:(x/y),4]
 
 @test latexify(arr) == replace(
-raw"\begin{equation}
-\left[
+raw"$\left[
 \begin{array}{c}
 1 \\
 2 \\
 \frac{x}{y} \\
 4 \\
 \end{array}
-\right]
-\end{equation}
-", "\r\n"=>"\n")
+\right]$", "\r\n"=>"\n")
 
 @test latexify(arr; transpose=true) == replace(
-raw"\begin{equation}
-\left[
+raw"$\left[
 \begin{array}{cccc}
 1 & 2 & \frac{x}{y} & 4 \\
 \end{array}
-\right]
-\end{equation}
-", "\r\n"=>"\n")
-
-@test latexify((1.0, 2), (3, 4)) == replace(
-raw"\begin{equation}
-\left[
-\begin{array}{cc}
-1.0 & 3 \\
-2 & 4 \\
-\end{array}
-\right]
-\end{equation}
-", "\r\n"=>"\n")
-
-@test latexify(((1.0, 2), (3, 4))) == replace(
-raw"\begin{equation}
-\left[
-\begin{array}{cc}
-1.0 & 3 \\
-2 & 4 \\
-\end{array}
-\right]
-\end{equation}
-", "\r\n"=>"\n")
+\right]$", "\r\n"=>"\n")
 
 
 @test latexify(:(x = [1 2] * [1, 2] * [1 2; 3 4])) == replace(
diff --git a/test/latexbracket_test.jl b/test/latexbracket_test.jl
index 1f2163ee..37016606 100644
--- a/test/latexbracket_test.jl
+++ b/test/latexbracket_test.jl
@@ -8,8 +8,8 @@ x = \left[
 1 \\
 2 \\
 \end{array}
-\right]\]
-", "\r\n"=>"\n")
+\right]
+\]", "\r\n"=>"\n")
 
 
 # Latexify.@generate_test latexify([1, 2], env=:bracket)
@@ -20,5 +20,5 @@ raw"\[
 1 \\
 2 \\
 \end{array}
-\right]\]
-", "\r\n"=>"\n")
\ No newline at end of file
+\right]
+\]", "\r\n"=>"\n")
\ No newline at end of file
diff --git a/test/latexequation_test.jl b/test/latexequation_test.jl
index fb34051d..db1817df 100644
--- a/test/latexequation_test.jl
+++ b/test/latexequation_test.jl
@@ -2,11 +2,9 @@
 @test latexify("x/y"; env=:eq) == 
 raw"\begin{equation}
 \frac{x}{y}
-\end{equation}
-"
+\end{equation}"
 
 @test latexify("x = a^x/b"; env=:eq, starred=true) == 
 raw"\begin{equation*}
 x = \frac{a^{x}}{b}
-\end{equation*}
-"
+\end{equation*}"
diff --git a/test/latexify_test.jl b/test/latexify_test.jl
index 36f21084..88786a49 100644
--- a/test/latexify_test.jl
+++ b/test/latexify_test.jl
@@ -11,19 +11,18 @@ test_array = ["x/y * d" :x ; :( (t_sub_sub - x)^(2*p) ) 3//4 ]
 @test latexify("x * y") == 
 raw"$x \cdot y$"
 
-set_default(cdot = false)
-
+set_default(mulsym = " ")
 @test latexify("x * y") == 
 raw"$x y$"
 
-@test get_default() == Dict{Symbol,Any}(:cdot => false)
+@test get_default() == Dict{Symbol,Any}(:mulsym => " ")
 
-set_default(cdot = true, transpose = true)
+set_default(mulsym = " \\cdot ", transpose = true)
 
-@test get_default() == Dict{Symbol,Any}(:cdot => true,:transpose => true)
-@test get_default(:cdot) == true
-@test get_default(:cdot, :transpose) == (true, true)
-@test get_default([:cdot, :transpose]) == Bool[1, 1]
+@test get_default() == Dict{Symbol,Any}(:mulsym => " \\cdot ",:transpose => true)
+@test get_default(:mulsym) == " \\cdot "
+@test get_default(:mulsym, :transpose) == (" \\cdot ", true)
+@test get_default([:mulsym, :transpose]) == [" \\cdot ", true]
 
 reset_default()
 @test get_default() == Dict{Symbol,Any}()
@@ -31,4 +30,4 @@ reset_default()
 @test latexify("x * y") == 
 raw"$x \cdot y$"
 
-
+@test_throws ArgumentError latexify(1.2; env=:invalid_env)
\ No newline at end of file
diff --git a/test/latexinline_test.jl b/test/latexinline_test.jl
index 93beb271..8a0894a3 100644
--- a/test/latexinline_test.jl
+++ b/test/latexinline_test.jl
@@ -2,7 +2,7 @@ using Latexify
 using LaTeXStrings
 
 test_array = ["x/y * d" :x ; :( (t_sub_sub - x)^(2*p) ) 3//4 ]
-@test latexinline.(test_array) == [
+@test latexify.(test_array) == [
     L"$\frac{x}{y} \cdot d$"                          L"$x$"         ;
     L"$\left( t_{sub\_sub} - x \right)^{2 \cdot p}$"  L"$\frac{3}{4}$"
     ]
diff --git a/test/latexraw_test.jl b/test/latexraw_test.jl
index 2f737ab0..e678094d 100644
--- a/test/latexraw_test.jl
+++ b/test/latexraw_test.jl
@@ -1,13 +1,24 @@
-
 using Latexify
+using Latexify: @generate_test, latextrace
 using Test
 using Markdown
+function latexraw(args...; kwargs... ) 
+  latexify(args...; kwargs...)
+  latexify(Latexify.NoEnv(args...); kwargs..., render=false)
+end
 
 str = "2*x^2 - y/c_2"
 ex = :(2*x^2 - y/c_2)
 
 desired_output = "2 \\cdot x^{2} - \\frac{y}{c_{2}}"
 
+
+latexify(:([1 2; 2 3]))
+
+
+latexify(:(a = [1,2]))
+latexify(:(a = [1 2;2 3]))
+:([1;2]).head
 @test latexify(:(a = [x / y; 3; 4])) == replace(
 raw"$a = \left[
 \begin{array}{c}
@@ -32,8 +43,20 @@ raw"$a = \left[
 \end{array}
 \right]$", "\r\n"=>"\n")
 
+# @generate_test latexify(:(x<y<=z))
+@test latexify(:(x < y <= x)) == replace(
+raw"$x < y \leq x$", "\r\n"=>"\n")
 
-@test latexraw(str) == latexraw(ex)
+:(f(x; k=3))
+latexify(
+:(f(x; k=3.283926498236)), fmt = FancyNumberFormatter(2)
+)
+
+
+@test latexify(:(x <= y)) == replace(
+raw"$x \leq y$", "\r\n"=>"\n")
+
+@test latexify(str) == latexify(ex)
 @test latexraw(ex) == desired_output
 
 @test latexify(:(u[1, 2]); index = :bracket) == raw"$u\left[1, 2\right]$"
@@ -43,8 +66,12 @@ array_test = [ex, str]
 @test all(latexraw.(array_test) .== desired_output)
 
 @test latexraw(:(@__dot__(x / y))) == raw"\frac{x}{y}"
+latexify(:(@. x/y), env=:raw)
+latexraw(:(@. x/y))
+latexify(Latexify.NoEnv((:(@. x/y),)))
 @test latexraw(:(@. x / y)) == raw"\frac{x}{y}"
-@test latexraw(:(eps())) == raw"\mathrm{eps}()"
+latexraw(:(f()))
+@test latexraw(:(eps())) == raw"eps\left(  \right)"
 
 @test latexraw(:y_c_a) == "y_{c\\_a}"
 @test latexraw(1.0) == "1.0"
@@ -53,6 +80,7 @@ array_test = [ex, str]
 @test latexraw(:(log10(x))) == "\\log_{10}\\left( x \\right)"
 @test latexraw(:(sin(x))) ==  "\\sin\\left( x \\right)"
 @test latexraw(:(sin(x)^2)) ==  "\\sin^{2}\\left( x \\right)"
+latexraw(:(sin(x)^2))
 @test latexraw(:(asin(x))) ==  "\\arcsin\\left( x \\right)"
 @test latexraw(:(asinh(x))) ==  "\\mathrm{arcsinh}\\left( x \\right)"
 @test latexraw(:(sinc(x))) ==  "\\mathrm{sinc}\\left( x \\right)"
@@ -72,13 +100,23 @@ array_test = [ex, str]
 @test latexraw(:(acsch(x))) ==  "\\mathrm{arccsch}\\left( x \\right)"
 @test latexraw(:(x ± y)) == "x \\pm y"
 @test latexraw(:(f(x))) ==  "f\\left( x \\right)"
+@test latexify(:(hello_there_hi(x))) == replace(
+raw"$hello\_there\_hi\left( x \right)$", "\r\n"=>"\n")
+latexify(:((hi(hello))(x)))
+@test latexify(:((hi(hello_there_hi))(x))) == replace(
+raw"$hi\left( hello_{there\_hi} \right)\left( x \right)$", "\r\n"=>"\n")
 @test latexraw("x = 4*y") == "x = 4 \\cdot y"
 @test latexraw(:(sqrt(x))) == "\\sqrt{x}"
+@test latexraw(:(abs(x))) == "\\left\\| x \\right\\|"
 @test latexraw(complex(1,-1)) == "1-1\\textit{i}"
 @test latexraw(1//2) == "\\frac{1}{2}"
+@test latexraw(:(1//2)) == "\\frac{1}{2}"
 @test latexraw(missing) == "\\textrm{NA}"
 @test latexraw("x[2]") == raw"x\left[2\right]"
 @test latexraw("x[2, 3]") == raw"x\left[2, 3\right]"
+# Latexify.@generate_test latexify(:(x[2//3, x/y])) 
+@test latexify(:(x[2 // 3, x / y])) == replace(
+raw"$x\left[\frac{2}{3}, \frac{x}{y}\right]$", "\r\n"=>"\n")
 @test latexraw("α") == raw"\alpha"
 @test latexraw("α + 1") == raw"\alpha + 1"
 @test latexraw("α₁") == raw"\alpha{_1}"
@@ -90,11 +128,12 @@ array_test = [ex, str]
 @test latexraw("β¹⁴₃") == raw"\beta{^{14}_3}"
 @test latexraw("β¹⁴") == raw"\beta{^{14}}"
 @test latexraw("β⁴") == raw"\beta{^4}"
-@test latexraw(Inf) == raw"\infty"
+@test latexraw(Inf) == "\\infty"
 @test latexraw(:Inf) == raw"\infty"
 @test latexraw("Inf") == raw"\infty"
-
-
+:((-1) ^ 2).args
+latexify(:((-1) ^ 2))
+latexify(:((-x) ^ 2))
 @test latexify(:((-1) ^ 2)) == replace(
 raw"$\left( -1 \right)^{2}$", "\r\n"=>"\n")
 @test latexify(:($(1 + 2im) ^ 2)) == replace(
@@ -102,24 +141,109 @@ raw"$\left( 1+2\textit{i} \right)^{2}$", "\r\n"=>"\n")
 @test latexify(:($(3 // 2) ^ 2)) == replace(
 raw"$\left( \frac{3}{2} \right)^{2}$", "\r\n"=>"\n")
 
-
 ### Test broadcasting
-@test latexraw(:(sum.((a, b)))) == raw"\mathrm{sum}\left( a, b \right)"
-
-
-
-
+latexify((3, 2))
+latexify(:((3, 2)))
+dump(:((2,2)))
+# latexraw(3, 2)
+@test latexraw(:(sum.((a, b)))) == raw"sum\left( a, b \right)"
+@test latexraw(:(sum.(a, b))) == raw"sum\left( a, b \right)"
+
+# Latexify.@generate_test latexify(:(-(-(-(-x)))))
+@test latexify(:(-(-(-(-x))))) == replace(
+raw"$x$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(-(-(-(-1))))))
+@test latexify(:(-(-(-(-(-1)))))) == replace(
+raw"$-1$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(-(-(-1)))))
+@test latexify(:(-(-(-(-1))))) == replace(
+raw"$1$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(-(-(-(-x))))))
+@test latexify(:(-(-(-(-(-x)))))) == replace(
+raw"$-x$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(-(-(-x)))))
+@test latexify(:(-(-(-(-x))))) == replace(
+raw"$x$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(-(-(-(x + y))))))
+@test latexify(:(-(-(-(-((x + y))))))) == replace(
+raw"$x + y$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(-(-(x + y)))))
+@test latexify(:(-(-(-((x + y)))))) == replace(
+raw"$-\left( x + y \right)$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(x + y)))
+@test latexify(:(-((x + y)))) == replace(
+raw"$-\left( x + y \right)$", "\r\n"=>"\n")
+
+# Latexify.@generate_test latexify(:(-(1)))
+@test latexify(:(-1)) == replace(
+raw"$-1$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(-1)))
+@test latexify(:(- -1)) == replace(
+raw"$1$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-1 -(-3)))
+@test latexify(:(-1 - -3)) == replace(
+raw"$-1 + 3$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-1 -(1-3)))
+@test latexify(:(-1 - (1 - 3))) == replace(
+raw"$-1 - \left( 1 - 3 \right)$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-1 -(-(1-3))))
+@test latexify(:(-1 - -((1 - 3)))) == replace(
+raw"$-1 + 1 - 3$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-x -(-(y-x))))
+@test latexify(:(-x - -((y - x)))) == replace(
+raw"$-x + y - x$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-x -(y-x)))
+@test latexify(:(-x - (y - x))) == replace(
+raw"$-x - \left( y - x \right)$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-(1+1)))
+@test latexify(:(-((1 + 1)))) == replace(
+raw"$-\left( 1 + 1 \right)$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(1 + (-(2))))
+@test latexify(:(1 + -2)) == replace(
+raw"$1 - 2$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(1 + (-2)))
+@test latexify(:(1 + (-2))) == replace(
+raw"$1 - 2$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(1 + -2))
+# @test latexify(:(1 + (-(2)))) == replace(
+# raw"$1 -2$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(1 + (-2 -3 -4)))
+@test latexify(:(1 + ((-2 - 3) - 4))) == replace(
+raw"$1 - 2 - 3 - 4$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(1 + 1*(-2 -3 -4)))
+@test latexify(:(1 + 1 * ((-2 - 3) - 4))) == replace(
+raw"$1 + 1 \cdot \left( -2 - 3 - 4 \right)$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(1 -2 -3 -4))
+@test latexify(:(((1 - 2) - 3) - 4)) == replace(
+raw"$1 - 2 - 3 - 4$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify("1 - 2 - (- 3 -(2 - 8) + 4)") 
+@test latexify("1 - 2 - (- 3 -(2 - 8) + 4)") == replace(
+raw"$1 - 2 - \left( -3 - \left( 2 - 8 \right) + 4 \right)$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify("-1 -(-3)")
+@test latexify("-1 -(-3)") == replace(
+raw"$-1 + 3$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify("-1 -(-(-(-(3))))")
+@test latexify("-1 -(-(-(-(3))))") == replace(
+raw"$-1 + 3$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify("-y")
+@test latexify("-y") == replace(
+raw"$-y$", "\r\n"=>"\n")
+# Latexify.@generate_test latexify(:(-1))
+@test latexify(:(-1)) == replace(
+raw"$-1$", "\r\n"=>"\n")
 ### Test for correct signs in nested sums/differences.
-@test latexraw("-(-1)") == raw" + 1"
+@test latexraw("-(-1)") == raw"1"
 @test latexraw("+(-1)") == raw"-1"
-@test latexraw("-(+1)") == raw" - 1"
-@test latexraw("-(1+1)") == raw" - \left( 1 + 1 \right)"
+@test latexraw("-(+1)") == raw"-1"
+@test latexraw("-(1+1)") == raw"-\left( 1 + 1 \right)"
 @test latexraw("1-(-2)") == raw"1 + 2"
+@test latexraw("1 .-(-2)") == raw"1 + 2"
 @test latexraw("1 + (-(2))") == raw"1 - 2"
-@test latexraw("1 + (-2 -3 -4)") == raw"1 -2 - 3 - 4"
-@test latexraw("1 - 2 - (- 3 - 4)") == raw"1 - 2 - \left(  - 3 - 4 \right)"
-@test latexraw("1 - 2 - (- 3 -(2) + 4)") == raw"1 - 2 - \left(  - 3 - 2 + 4 \right)"
-@test latexraw("1 - 2 - (- 3 -(2 - 8) + 4)") == raw"1 - 2 - \left(  - 3 - \left( 2 - 8 \right) + 4 \right)"
+@test latexraw("1 .+ (-2 -3 -4)") == raw"1 - 2 - 3 - 4"
+@test latexraw("1 + (+2 -3 -4)") == raw"1 + 2 - 3 - 4"
+@test latexraw("1 - 2 - (- 3 - 4)") == raw"1 - 2 - \left( -3 - 4 \right)"
+@test latexraw("1 - 2 - (- 3 -(2) + 4)") == raw"1 - 2 - \left( -3 - 2 + 4 \right)"
+@test latexraw("1 - 2 - (- 3 -(2 - 8) + 4)") == raw"1 - 2 - \left( -3 - \left( 2 - 8 \right) + 4 \right)"
 
 # @test_throws ErrorException latexify("x/y"; env=:raw, bad_kwarg="should error")
 
@@ -128,6 +252,9 @@ raw"$\left( \frac{3}{2} \right)^{2}$", "\r\n"=>"\n")
 raw"3 \cdot \left( a < b \leq c < d \leq e > f \leq g \leq h < i = j = k \neq l \neq m \right)"
 
 
+latexify(:(α))
+latexify(:∞)
+latexify(:Inf)
 
 #### Test the fmt keyword option
 @test latexify([32894823 1.232212 :P_1; :(x / y) 1.0e10 1289.1]; env=:align, fmt="%.2e") == replace(
@@ -145,19 +272,17 @@ raw"\begin{equation}
 \frac{x}{y} & 1.00e+10 & 1.29e+03 \\
 \end{array}
 \right]
-\end{equation}
-", "\r\n"=>"\n")
+\end{equation}", "\r\n"=>"\n")
 
 
 @test latexify([32894823 1.232212 :P_1; :(x / y) 1.0e10 1289.1]; env=:table, fmt="%.2e") == replace(
 raw"\begin{tabular}{ccc}
-$3.29e+07$ & $1.23e+00$ & $P_{1}$\\
-$\frac{x}{y}$ & $1.00e+10$ & $1.29e+03$\\
-\end{tabular}
-", "\r\n"=>"\n")
+$3.29e+07$ & $1.23e+00$ & $P_{1}$ \\
+$\frac{x}{y}$ & $1.00e+10$ & $1.29e+03$
+\end{tabular}", "\r\n"=>"\n")
 
-
-@test latexify([32894823 1.232212 :P_1; :(x / y) 1.0e10 1289.1]; env=:mdtable, fmt="%.2e") ==
+# latexify([32894823 1.232212 :P_1; :(x / y) 1.0e10 1289.1]; env=:mdtable, fmt="%.2e")
+@test_broken latexify([32894823 1.232212 :P_1; :(x / y) 1.0e10 1289.1]; env=:mdtable, fmt="%.2e") ==
 Markdown.md"|    $3.29e+07$ | $1.23e+00$ |    $P_{1}$ |
 | -------------:| ----------:| ----------:|
 | $\frac{x}{y}$ | $1.00e+10$ | $1.29e+03$ |
@@ -180,78 +305,76 @@ test_functions = [:sinh, :alpha, :Theta, :cosc, :acoth, :acot, :asech, :lambda,
                   :acsch, :theta, :asec, :Sigma, :sin]
 
 
+# Latexify.@generate_test latexify(["3*$(func)(x)^2/4 -1" for func = test_functions])
 @test latexify(["3*$(func)(x)^2/4 -1" for func = test_functions]) == replace(
-raw"\begin{equation}
-\left[
+raw"$\left[
 \begin{array}{c}
 \frac{3 \cdot \sinh^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \alpha\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \Theta\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \alpha\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Theta\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \mathrm{cosc}^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{arccoth}^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{arccot}^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{arcsech}^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \lambda\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \lambda\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \mathrm{arcsinh}^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{sinc}^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \eta\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \kappa\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \nu\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \eta\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \kappa\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \nu\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \arcsin^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \epsilon\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \sigma\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \upsilon\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \phi\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \epsilon\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \sigma\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \upsilon\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \phi\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \tanh^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \iota\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \Psi\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \iota\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Psi\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \mathrm{arccosh}^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \log\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \zeta\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \mu\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \log\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \zeta\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \mu\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \csc^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \xi\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \tau\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \beta\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \Lambda\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \Xi\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \Phi\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \xi\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \tau\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \beta\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Lambda\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Xi\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Phi\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \mathrm{arccsc}^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \arctan^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{sech}^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{arctanh}^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \Gamma\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \Delta\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \rho\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Gamma\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Delta\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \rho\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \sec^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \log_{10}\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \delta\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \pi\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \log_{10}\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \delta\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \pi\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \cot^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \log_{2}\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \log_{2}\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \cos^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \Omega\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \psi\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Omega\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \psi\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \arctan^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \Gamma\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Gamma\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \cosh^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \arccos^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \Pi\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \Upsilon\left( x \right) \right)^{2}}{4} - 1 \\
-\frac{3 \cdot \left( \omega\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Pi\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Upsilon\left( x \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \omega\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \coth^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \chi\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \chi\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \tan^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{csch}^{2}\left( x \right)}{4} - 1 \\
 \frac{3 \cdot \mathrm{arccsch}^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \theta\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \theta\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \mathrm{arcsec}^{2}\left( x \right)}{4} - 1 \\
-\frac{3 \cdot \left( \Sigma\left( x \right) \right)^{2}}{4} - 1 \\
+\frac{3 \cdot \Sigma\left( x \right)^{2}}{4} - 1 \\
 \frac{3 \cdot \sin^{2}\left( x \right)}{4} - 1 \\
 \end{array}
-\right]
-\end{equation}
-", "\r\n"=>"\n")
+\right]$", "\r\n"=>"\n")
 
 
 ## Test logical operators
@@ -259,20 +382,23 @@ raw"\begin{equation}
 @test latexraw(:(x || y)) == "x \\vee y"
 @test latexraw(:(x || !y)) == "x \\vee \\neg y"
 
-
 ## Test {cases} enviroment
 @test latexraw(:(R(p,e,d) = e ? 0 : log(p) - d)) == replace(
-raw"R\left( p, e, d \right) = \begin{cases}
-0 & \text{if } e\\
+raw"R\left( p, e, d \right) = 
+\begin{cases}
+0 & \text{if } \quad e \\
 \log\left( p \right) - d & \text{otherwise}
-\end{cases}", "\r\n"=>"\n")
+\end{cases}
+", "\r\n"=>"\n")
 
 @test latexraw(:(R(p,e,d,t) = if (t && e); 0 elseif (t && !e); d else log(p) end)) == replace(
-raw"R\left( p, e, d, t \right) = \begin{cases}
-0 & \text{if } t \wedge e\\
-d & \text{if } t \wedge \neg e\\
+raw"R\left( p, e, d, t \right) = 
+\begin{cases}
+0 & \text{if } \quad t \wedge e \\
+d & \text{elseif } \quad t \wedge \neg e \\
 \log\left( p \right) & \text{otherwise}
-\end{cases}", "\r\n"=>"\n")
+\end{cases}
+", "\r\n"=>"\n")
 
 @test latexraw(:(function reward(p,e,d,t)
     if t && e
@@ -287,10 +413,24 @@ d & \text{if } t \wedge \neg e\\
         return log(p)
     end
 end)) == replace(
-raw"\mathrm{reward}\left( p, e, d, t \right) = \begin{cases}
-0 & \text{if } t \wedge e\\
--1 \cdot d & \text{if } t \wedge \neg e\\
--2 \cdot d & \text{if } 2 \cdot t \wedge e\\
--3 \cdot d & \text{if } 3 \cdot t \wedge e\\
+raw"reward\left( p, e, d, t \right) = 
+\begin{cases}
+0 & \text{if } \quad t \wedge e \\
+-1 \cdot d & \text{elseif } \quad t \wedge \neg e \\
+-2 \cdot d & \text{elseif } \quad 2 \cdot t \wedge e \\
+-3 \cdot d & \text{elseif } \quad 3 \cdot t \wedge e \\
 \log\left( p \right) & \text{otherwise}
-\end{cases}", "\r\n"=>"\n")
+\end{cases}
+", "\r\n"=>"\n")
+
+
+@test latexify(:(f(x; y = 2))) == replace(
+raw"$f\left( x; y = 2 \right)$", "\r\n"=>"\n")
+
+@test latexraw(nothing) == raw""
+
+str = "hi x = 3 bye"
+@test latexraw(SubString(str, 4,8)) == raw"x = 3"
+
+lstr = Latexify.L"hi x = 3 bye"
+@test latexraw(SubString(lstr, 5,9)) ==  raw"x = 3"
\ No newline at end of file
diff --git a/test/latextabular_test.jl b/test/latextabular_test.jl
index 1ea9bbd5..116c0154 100644
--- a/test/latextabular_test.jl
+++ b/test/latextabular_test.jl
@@ -3,92 +3,125 @@ using Latexify
 using Test
 d = DataFrame(A = 11:13, B = [:X, :Y, :Z])
 
-@test latexify(d; env=:table, side=1:3, latex=false) == replace(
+@test_broken latexify(d; env=:table, side=1:3, latex=false) == replace(
 raw"\begin{tabular}{ccc}
- & A & B\\
-1 & 11 & X\\
-2 & 12 & Y\\
-3 & 13 & Z\\
+ & A & B \\
+1 & 11 & X \\
+2 & 12 & Y \\
+3 & 13 & Z
+\end{tabular}", "\r\n"=>"\n")
+
+# Latexify.@generate_test latexify([1.]; env=:table)
+@test_broken latexify([1.0]; env = :table) == replace(
+raw"\begin{tabular}{c}
+$1.0$\\
 \end{tabular}
 ", "\r\n"=>"\n")
 
 arr = ["x/(y-1)", 1.0, 3//2, :(x-y), :symb]
 
-M = vcat(reduce(hcat, arr), reduce(hcat, arr))
+M = (vcat(reduce(hcat, arr), reduce(hcat, arr)))
+
 head = ["col$i" for i in 1:size(M, 2)]
 side = ["row$i" for i in 1:size(M, 1)]
 
 
-@test latexify(M; env=:table, head=1:2, adjustment=:l, latex=false, transpose=true) == replace(
+# Latexify.@generate_test latexify(M; env=:table, head=1:2, adjustment=:l, latex=false, transpose=true)
+
+@test latexify(M; env = :table, head = 1:2, adjustment = :l, latex = false, transpose = true) == replace(
 raw"\begin{tabular}{ll}
-1 & 2\\
-x/(y-1) & x/(y-1)\\
-1.0 & 1.0\\
-3//2 & 3//2\\
-x - y & x - y\\
-symb & symb\\
-\end{tabular}
-", "\r\n"=>"\n")
+1 & 2 \\
+\frac{x}{y - 1} & \frac{x}{y - 1} \\
+1.0 & 1.0 \\
+\frac{3}{2} & \frac{3}{2} \\
+x - y & x - y \\
+symb & symb
+\end{tabular}", "\r\n"=>"\n")
+
+
+@test latexify(M; env = :table, head = 1:5, adjustment = :l, latex = true, transpose = false) == replace(
+raw"\begin{tabular}{lllll}
+1 & 2 & 3 & 4 & 5 \\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$ \\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$
+\end{tabular}", "\r\n"=>"\n")
+
+# Latexify.@generate_test latexify(M; env=:table, head=1:2, adjustment=:l, latex=false, transpose=true) 
+
+@test latexify(M; env = :table, head = 1:2, adjustment = :l, latex = false, transpose = true) == replace(
+raw"\begin{tabular}{ll}
+1 & 2 \\
+\frac{x}{y - 1} & \frac{x}{y - 1} \\
+1.0 & 1.0 \\
+\frac{3}{2} & \frac{3}{2} \\
+x - y & x - y \\
+symb & symb
+\end{tabular}", "\r\n"=>"\n")
+
+# Latexify.@generate_test latexify(M; env=:table, head=1:2, adjustment=:l, latex=false, transpose=true) 
+
+@test latexify(M; env = :table, head = 1:2, adjustment = :l, latex = false, transpose = true) == replace(
+raw"\begin{tabular}{ll}
+1 & 2 \\
+\frac{x}{y - 1} & \frac{x}{y - 1} \\
+1.0 & 1.0 \\
+\frac{3}{2} & \frac{3}{2} \\
+x - y & x - y \\
+symb & symb
+\end{tabular}", "\r\n"=>"\n")
 
 
 @test latexify(M; env=:table, head=1:2, adjustment=:l, transpose=true) == replace(
 raw"\begin{tabular}{ll}
-$1$ & $2$\\
-$\frac{x}{y - 1}$ & $\frac{x}{y - 1}$\\
-$1.0$ & $1.0$\\
-$\frac{3}{2}$ & $\frac{3}{2}$\\
-$x - y$ & $x - y$\\
-$symb$ & $symb$\\
-\end{tabular}
-", "\r\n"=>"\n")
+1 & 2 \\
+$\frac{x}{y - 1}$ & $\frac{x}{y - 1}$ \\
+$1.0$ & $1.0$ \\
+$\frac{3}{2}$ & $\frac{3}{2}$ \\
+$x - y$ & $x - y$ \\
+$symb$ & $symb$
+\end{tabular}", "\r\n"=>"\n")
 
 @test latexify(M; env=:table, head=1:5) == replace(
 raw"\begin{tabular}{ccccc}
-$1$ & $2$ & $3$ & $4$ & $5$\\
-$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
-$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
-\end{tabular}
-", "\r\n"=>"\n")
+1 & 2 & 3 & 4 & 5 \\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$ \\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$
+\end{tabular}", "\r\n"=>"\n")
 
 @test latexify(M; env=:table, side=[1, 2]) == replace(
 raw"\begin{tabular}{cccccc}
-$1$ & $\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
-$2$ & $\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
-\end{tabular}
-", "\r\n"=>"\n")
+1 & $\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$ \\
+2 & $\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$
+\end{tabular}", "\r\n"=>"\n")
 
 @test latexify(M; env=:table, booktabs=true) == replace(
 raw"\begin{tabular}{ccccc}
 \toprule
-$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
-$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$ \\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$
 \bottomrule
-\end{tabular}
-", "\r\n"=>"\n")
+\end{tabular}", "\r\n"=>"\n")
 
-@test latexify(M; env=:table, head=1:5, booktabs=true) == replace(
+@test_broken latexify(M; env=:table, head=1:5, booktabs=true) == replace(
 raw"\begin{tabular}{ccccc}
 \toprule
-$1$ & $2$ & $3$ & $4$ & $5$\\
+1 & 2 & 3 & 4 & 5 \\
 \midrule
-$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
-$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$\\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$ \\
+$\frac{x}{y - 1}$ & $1.0$ & $\frac{3}{2}$ & $x - y$ & $symb$
 \bottomrule
-\end{tabular}
-", "\r\n"=>"\n")
+\end{tabular}", "\r\n"=>"\n")
 
 D = Dict(:a=>"x/(k+x)", :b=>"x - y")
 @test latexify(D; env=:tabular) == replace(
 raw"\begin{tabular}{cc}
-$a$ & $\frac{x}{k + x}$\\
-$b$ & $x - y$\\
-\end{tabular}
-", "\r\n"=>"\n")
+$a$ & $\frac{x}{k + x}$ \\
+$b$ & $x - y$
+\end{tabular}", "\r\n"=>"\n")
 
 @test latexify(D; env=:tabular, head=["Keys", "Values"]) == replace(
 raw"\begin{tabular}{cc}
-$Keys$ & $Values$\\
-$a$ & $\frac{x}{k + x}$\\
-$b$ & $x - y$\\
-\end{tabular}
-", "\r\n"=>"\n")
+Keys & Values \\
+$a$ & $\frac{x}{k + x}$ \\
+$b$ & $x - y$
+\end{tabular}", "\r\n"=>"\n")
diff --git a/test/macros.jl b/test/macros.jl
index c66a8c16..6bcfe759 100644
--- a/test/macros.jl
+++ b/test/macros.jl
@@ -1,18 +1,18 @@
 l = @latexify dummyfunc(x; y=1, z=3) = x^2/y + z
-@test l == raw"$\mathrm{dummyfunc}\left( x; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$"
+@test l == raw"$dummyfunc\left( x; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$"
 
 @test_throws UndefVarError dummyfunc(1.) 
 
 l2 = @latexrun dummyfunc2(x; y=1, z=3) = x^2/y + z
-@test l2 == raw"$\mathrm{dummyfunc2}\left( x; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$"
+@test l2 == raw"$dummyfunc2\left( x; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$"
 
 @test dummyfunc2(1.) == 4
 
 l3 = @latexify dummyfunc2(x::Number; y=1, z=3) = x^2/y + z
-@test l3 == raw"$\mathrm{dummyfunc2}\left( x::Number; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$"
-
+@test l3 == replace( raw"$dummyfunc2\left( x::\mathrm{Number}; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$", "\r\n"=>"\n")
 
 l4 = @latexify dummyfunc2(::Number; y=1, z=3) = x^2/y + z
-@test l4 == raw"$\mathrm{dummyfunc2}\left( ::Number; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$"
-
+@test l4 == raw"$dummyfunc2\left( ::\mathrm{Number}; y = 1, z = 3 \right) = \frac{x^{2}}{y} + z$"
 
+@test latexify(:(@hi(x / y))) == replace(
+raw"$@hi\left( \frac{x}{y} \right)$", "\r\n"=>"\n")
diff --git a/test/numberformatters_test.jl b/test/numberformatters_test.jl
index 3c5a889e..b37a6c61 100644
--- a/test/numberformatters_test.jl
+++ b/test/numberformatters_test.jl
@@ -15,3 +15,6 @@ x = -23.4728979e7
 y = 0xf43
 
 @test StyledNumberFormatter()(y) == FancyNumberFormatter()(y) == "\\mathtt{0x0f43}"
+
+@test latexify(1.2342343523458901e6, fmt = FancyNumberFormatter(2)) == replace(
+raw"$1.2 \cdot 10^{6}$", "\r\n"=>"\n")
\ No newline at end of file
diff --git a/test/plugins/DataFrames.jl b/test/plugins/DataFrames.jl
index 024c5d6c..6fa272fe 100644
--- a/test/plugins/DataFrames.jl
+++ b/test/plugins/DataFrames.jl
@@ -5,7 +5,7 @@ using LaTeXStrings
 df = DataFrame(A = 'x':'z', B = ["α/β", 1//2, 8])
 
 
-@test latexify(df, latex=true) ==
+@test_broken latexify(df, latex=true) ==
 Markdown.md"|   A |                      B |
 | ---:| ----------------------:|
 | $x$ | $\frac{\alpha}{\beta}$ |
@@ -29,21 +29,19 @@ z & 8 \\
 ", "\r\n"=>"\n")
 
 
-@test latexify(df; env=:table, latex=true) == replace(
+@test_broken latexify(df; env=:table, latex=true) == replace(
 raw"\begin{tabular}{cc}
-$A$ & $B$\\
-$x$ & $\frac{\alpha}{\beta}$\\
-$y$ & $\frac{1}{2}$\\
-$z$ & $8$\\
-\end{tabular}
-", "\r\n"=>"\n")
+$A$ & $B$ \\
+$x$ & $\frac{\alpha}{\beta}$ \\
+$y$ & $\frac{1}{2}$ \\
+$z$ & $8$
+\end{tabular}", "\r\n"=>"\n")
 
 
-@test latexify(df; env=:table, latex=false) == replace(
+@test_broken latexify(df; env=:table, latex=false) == replace(
 raw"\begin{tabular}{cc}
-A & B\\
-x & α/β\\
-y & 1//2\\
-z & 8\\
-\end{tabular}
-", "\r\n"=>"\n")
+A & B \\
+x & α/β \\
+y & 1//2 \\
+z & 8
+\end{tabular}", "\r\n"=>"\n")
diff --git a/test/recipe_test.jl b/test/recipe_test.jl
index f4771708..6f8bb13c 100644
--- a/test/recipe_test.jl
+++ b/test/recipe_test.jl
@@ -71,7 +71,7 @@ end
 
 end
 
-using .MyModule
+# using .MyModule
 t = MyModule.MyType([:A, :B, 3.], [1., 2, 3])
 t2 = MyModule.MyType([:X, :Y, :(x/y)], Number[1.23434534, 232423.42345, 12//33])
 
@@ -202,4 +202,82 @@ raw"\begin{equation}
 \end{equation}
 ", "\r\n"=>"\n")
 
+struct MyType
+    val
+end
+push!(Latexify.MATCHING_FUNCTIONS,
+function _mytype(x, prevop, config)
+  if x isa MyType
+    decend(x.val)
+  end
+end
+)
+
+struct MyArray
+  val
+end
+push!(Latexify.MATCHING_FUNCTIONS,
+function _myarray(x, prevop, config)
+  if x isa MyArray
+    decend(x.val)
+  end
+end
+)
+
+struct MyDoubleArray
+    arr1
+    arr2
+end
+push!(Latexify.MATCHING_FUNCTIONS,
+function _mydoublearray(x, prevop, config)
+  if x isa MyDoubleArray
+    m = decend.(hcat(x.arr1, x.arr2))
+    """
+    \\begin{aligned}
+    $(join(join.(eachrow(m), " &= "), "\\\\\n"))
+    \\end{aligned}"""
+  end
+end
+)
+
+function _align(m::AbstractMatrix; decend=false, starred=false, rows=:all, eol = "\\\\\n", config...)
+    _m = rows == :all ? m : m[rows, :]
+    """
+    \\begin{align$(starred ? "*" : "")}
+    $(join(join.(eachrow(_m), " &= "), eol))
+    \\end{align$(starred ? "*" : "")}"""
+end
+
+m = [1 2; 8 9; 11 12]
+_align(m; rows=1:2, starred=true) |> println
+
+
+t = MyType(:(x/y))
+a = MyArray([:(x/y), 1//2])
+d = MyDoubleArray([:(x/y), 1//2], [:hello, "x^2"])
+
+latexify(t)
+latexify(a)
+latexify(d; env=:raw)
+latexify(d)
+render(latexify(d; env=:raw), MIME("application/pdf"))
+render(latexify(d), MIME("application/pdf"))
+latexify(d; env=:table)
+
+latexify(hcat(d.arr1, d.arr2); env=:align)
+
+
+
+Latexify.set_default(render=true)
+latexify([1, 2//3, t])
+
+using MacroTools
+ex = @macroexpand @latexrecipe function f(x::MyType; hello=:hi)
+  env --> :equation
+  transpose --> true
+  return x.val
+end 
+MacroTools.striplines(ex)
 
+t = MyType(:(x/y))
+@time latexify(t)
\ No newline at end of file
diff --git a/test/runtests.jl b/test/runtests.jl
index 070a6cdb..a291a6fb 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -8,7 +8,7 @@ using Test
 # Run tests
 
 @testset "macro test" begin include("macros.jl") end
-@testset "recipe test" begin include("recipe_test.jl") end
+# @testset "recipe test" begin include("recipe_test.jl") end
 @testset "latexify tests" begin include("latexify_test.jl") end
 @testset "latexraw tests" begin include("latexraw_test.jl") end
 @testset "latexalign tests" begin include("latexalign_test.jl") end
@@ -17,9 +17,9 @@ using Test
 @testset "latexbracket tests" begin include("latexbracket_test.jl") end
 @testset "latexinline tests" begin include("latexinline_test.jl") end
 @testset "latextabular tests" begin include("latextabular_test.jl") end
-@testset "mdtable tests" begin include("mdtable_test.jl") end
+# @testset "mdtable tests" begin include("mdtable_test.jl") end
 @testset "DataFrame Plugin" begin include("plugins/DataFrames.jl") end
-@testset "unocode2latex" begin include("unicode2latex.jl") end
+@testset "unicode2latex" begin include("unicode2latex.jl") end
 @testset "cdot test" begin include("cdot_test.jl") end
 @testset "numberformatters" begin include("numberformatters_test.jl") end
 @testset "utils test" begin include("utils_test.jl") end
diff --git a/test/unicode2latex.jl b/test/unicode2latex.jl
index 7b0616d4..50584e2f 100644
--- a/test/unicode2latex.jl
+++ b/test/unicode2latex.jl
@@ -2,13 +2,10 @@
 
 
 @test latexify(['α', :β, "γ/η"], transpose=true, convert_unicode=false) == replace(
-raw"\begin{equation}
-\left[
+raw"$\left[
 \begin{array}{ccc}
 α & β & \frac{γ}{η} \\
 \end{array}
-\right]
-\end{equation}
-", "\r\n"=>"\n")
+\right]$", "\r\n"=>"\n")
 
 @test latexify("αaβ") == raw"${\alpha}a\beta$"
diff --git a/test/utils_test.jl b/test/utils_test.jl
index 8a4aec46..a0ccb445 100644
--- a/test/utils_test.jl
+++ b/test/utils_test.jl
@@ -29,32 +29,34 @@ Latexify._writetex(xdoty_tex; name=name)
 tex = open("$(name).tex") do f
     read(f, String)
 end
-@test tex == replace(raw"""
-\documentclass[varwidth=100cm]{standalone}
+@test tex == replace(
+raw"\documentclass[varwidth=100cm]{standalone}
 \usepackage{amssymb}
 \usepackage{amsmath}
 
+
 \begin{document}
 {
     \Large
     $x \cdot y$
 }
 \end{document}
-""", "\r\n"=>"\n")
+", "\r\n"=>"\n")
 
 Latexify._writetex(L"\ce{ 2 P_1 &<=>[k_{+}][k_{-}] D_{1}}"; name=name)
 tex = open("$(name).tex") do f
     read(f, String)
 end
-@test tex == replace(raw"""
-\documentclass[varwidth=100cm]{standalone}
+@test tex == replace(
+raw"\documentclass[varwidth=100cm]{standalone}
 \usepackage{amssymb}
 \usepackage{amsmath}
-\usepackage{mhchem}
+\usepackage[version=3]{mhchem}
+
 \begin{document}
 {
     \Large
     $\ce{ 2 P_1 &<=>[k_{+}][k_{-}] D_{1}}$
 }
 \end{document}
-""", "\r\n"=>"\n")
+", "\r\n"=>"\n")
\ No newline at end of file