docs: render EvalOptions in docs

Author: MilesCranmer

docs/src/eval.md

@@ -11,13 +11,10 @@ eval_tree_array(
     cX::AbstractMatrix{T},
     operators::OperatorEnum;
     eval_options::Union{EvalOptions,Nothing}=nothing,
-    turbo::Union{Bool,Val,Nothing}=nothing,
-    bumper::Union{Bool,Val,Nothing}=nothing,
 ) where {T}
 ```
 
-Assuming you are only using a single `OperatorEnum`, you can also use
-the following shorthand by using the expression as a function:
+You can also use the following shorthand by using the expression as a function:
 
 ```
     (tree::AbstractExpressionNode)(X, operators::OperatorEnum; kws...)
@@ -59,6 +56,14 @@ It also re-defines `print`, `show`, and the various operators, to work with the
     Thus, if you define an expression with one `OperatorEnum`, and then try to
     evaluate it or print it with a different `OperatorEnum`, you will get undefined behavior!
 
+    For safer behavior, you should use [`Expression`](@ref) objects.
+
+Evaluation options are specified using `EvalOptions`:
+
+```@docs
+EvalOptions
+```
+
 You can also work with arbitrary types, by defining a `GenericOperatorEnum` instead.
 The notation is the same for `eval_tree_array`, though it will return `nothing`
 when it can't find a method, and not do any NaN checks:

src/Evaluate.jl

@@ -31,14 +31,14 @@ end
 """
     EvalOptions{T,B,E}
 
-EvalOptions contain flags for the different modes to evaluate an expression.
+This holds options for expression evaluation, such as evaluation backend.
 
 # Fields
 
-- `turbo::Val`: If `Val{true}`, use LoopVectorization.jl for faster
+- `turbo::Val{T}`: If `Val{true}`, use LoopVectorization.jl for faster
     evaluation.
-- `bumper::Val`: If `Val{true}, use Bumper.jl for faster evaluation.
-- `early_exit::Val`: If `Val{true}`, any element of any step becoming
+- `bumper::Val{B}`: If `Val{true}, use Bumper.jl for faster evaluation.
+- `early_exit::Val{E}`: If `Val{true}`, any element of any step becoming
     `NaN` or `Inf` will terminate the computation and the whole buffer will be
     returned with `NaN`s. This makes sure that expressions with singularities
     don't wast compute cycles. Setting `Val{false}` will continue the computation
@@ -101,7 +101,7 @@ and triplets of operations for lower memory usage.
 - `tree::AbstractExpressionNode`: The root node of the tree to evaluate.
 - `cX::AbstractMatrix{T}`: The input data to evaluate the tree on.
 - `operators::OperatorEnum`: The operators used in the tree.
-- `eval_options::Union{EvalOptions,Nothing}`: See EvalOptions for documenation
+- `eval_options::Union{EvalOptions,Nothing}`: See [`EvalOptions`](@ref) for documentation
     on the different evaluation modes.
 
 

src/Node.jl

@@ -142,7 +142,7 @@ be performed with this assumption, to preserve structure of the graph.
 ```julia
 julia> operators = OperatorEnum(;
            binary_operators=[+, -, *], unary_operators=[cos, sin]
-       );
+        );
 
 julia> x = GraphNode(feature=1)
 x1