Update comment

Author: alamb

datafusion/optimizer/src/optimizer.rs

@@ -185,39 +185,11 @@ pub struct Optimizer {
     pub rules: Vec<Arc<dyn OptimizerRule + Send + Sync>>,
 }
 
-/// If a rule is with `ApplyOrder`, it means the optimizer will handle
-/// recursion. If it is `None` the rule must handle any required recursion
+/// Specifies how recursion for an `OptimizerRule` should be handled.
 ///
-/// Notice: **sometime** result after optimize still can be optimized, we need
-/// apply again.
-///
-/// Usage Example: Merge Limit (subtree pattern is: Limit-Limit)
-/// ```rust
-/// use datafusion_expr::{Limit, LogicalPlan, LogicalPlanBuilder};
-/// use datafusion_common::Result;
-/// fn merge_limit(parent: &Limit, child: &Limit) -> LogicalPlan {
-///     // just for run
-///     return parent.input.as_ref().clone();
-/// }
-/// fn try_optimize(plan: &LogicalPlan) -> Result<Option<LogicalPlan>> {
-///     match plan {
-///         LogicalPlan::Limit(limit) => match limit.input.as_ref() {
-///             LogicalPlan::Limit(child_limit) => {
-///                 // merge limit ...
-///                 let optimized_plan = merge_limit(limit, child_limit);
-///                 // due to optimized_plan may be optimized again,
-///                 // for example: plan is Limit-Limit-Limit
-///                 Ok(Some(
-///                     try_optimize(&optimized_plan)?
-///                         .unwrap_or_else(|| optimized_plan.clone()),
-///                 ))
-///             }
-///             _ => Ok(None),
-///         },
-///         _ => Ok(None),
-///     }
-/// }
-/// ```
+/// If an `OptimizerRule` returns `Some` from `apply_order`, it means the
+/// optimizer will handle recursively applying the rule to the plan. If the
+/// apply order is `None`, the rule must handle any required recursion itself.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ApplyOrder {
     TopDown,