code: func (iter *ExprIter) Next() (found bool) {
  	defer func() {
  		iter.matched = found
  	}()
  
  	// Iterate child firstly.
  	for i := len(iter.Children) - 1; i >= 0; i-- {
  		if !iter.Children[i].Next() {
  			continue
  		}
  
  		for j := i + 1; j < len(iter.Children); j++ {
  			iter.Children[j].Reset()
  		}
  		return true
  	}
  
  	// It's root node.
  	if iter.Group == nil {
  		return false
  	}
  
  	// Otherwise, iterate itself to find more matched equivalent expressions.
  	for elem := iter.Element.Next(); elem != nil; elem = elem.Next() {
  		expr := elem.Value.(*GroupExpr)
  		exprOperand := GetOperand(expr.ExprNode)
  
  		if !iter.Operand.Match(exprOperand) {
  			// All the Equivalents which have the same Operand are continuously
  			// stored in the list. Once the current equivalent can not Match
  			// the Operand, the rest can not, either.
  			return false
  		}
  
  		if len(iter.Children) != len(expr.Children) {
  			continue
  		}
  
  		allMatched := true
  		for i := range iter.Children {
  			iter.Children[i].Group = expr.Children[i]
  			if !iter.Children[i].Reset() {
  				allMatched = false
  				break
  			}
  		}
  
  		if allMatched {
  			iter.Element = elem
  			return true
  		}
  	}
  	return false
  }
docs: // Next returns the next Group expression matches the pattern.