Trait tptp::visitor::Visitor

source · [−]
pub trait Visitor<'a> {

Show 118 methods    fn visit_lower_word(&mut self, _lower_word: &LowerWord<'a>) { ... }

    fn visit_upper_word(&mut self, _upper_word: &UpperWord<'a>) { ... }

    fn visit_single_quoted(&mut self, _single_quoted: &SingleQuoted<'a>) { ... }

    fn visit_distinct_object(&mut self, _distinct_object: &DistinctObject<'a>) { ... }

    fn visit_atomic_word(&mut self, atomic_word: &AtomicWord<'a>) { ... }

    fn visit_integer(&mut self, _integer: &Integer<'a>) { ... }

    fn visit_rational(&mut self, _rational: &Rational<'a>) { ... }

    fn visit_real(&mut self, _real: &Real<'a>) { ... }

    fn visit_name(&mut self, name: &Name<'a>) { ... }

    fn visit_variable(&mut self, variable: &Variable<'a>) { ... }

    fn visit_functor(&mut self, functor: &Functor<'a>) { ... }

    fn visit_type_functor(&mut self, type_functor: &TypeFunctor<'a>) { ... }

    fn visit_constant(&mut self, constant: &Constant<'a>) { ... }

    fn visit_type_constant(&mut self, type_constant: &TypeConstant<'a>) { ... }

    fn visit_dollar_word(&mut self, dollar_word: &DollarWord<'a>) { ... }

    fn visit_dollar_dollar_word(
        &mut self, 
        dollar_dollar_word: &DollarDollarWord<'a>
    ) { ... }

    fn visit_number(&mut self, number: &Number<'a>) { ... }

    fn visit_atomic_defined_word(
        &mut self, 
        atomic_defined_word: &AtomicDefinedWord<'a>
    ) { ... }

    fn visit_atomic_system_word(
        &mut self, 
        atomic_system_word: &AtomicSystemWord<'a>
    ) { ... }

    fn visit_system_functor(&mut self, system_functor: &SystemFunctor<'a>) { ... }

    fn visit_system_constant(&mut self, system_constant: &SystemConstant<'a>) { ... }

    fn visit_defined_functor(&mut self, defined_functor: &DefinedFunctor<'a>) { ... }

    fn visit_defined_type(&mut self, defined_type: &DefinedType<'a>) { ... }

    fn visit_defined_constant(&mut self, defined_constant: &DefinedConstant<'a>) { ... }

    fn visit_defined_term(&mut self, defined_term: &DefinedTerm<'a>) { ... }

    fn visit_untyped_atom(&mut self, untyped_atom: &UntypedAtom<'a>) { ... }

    fn visit_infix_equality(&mut self, _infix_equality: InfixEquality) { ... }

    fn visit_defined_infix_pred(&mut self, defined_infix_pred: DefinedInfixPred) { ... }

    fn visit_infix_inequality(&mut self, _infix_inequality: InfixInequality) { ... }

    fn visit_unary_connective(&mut self, _unary_connective: UnaryConnective) { ... }

    fn visit_nonassoc_connective(
        &mut self, 
        _nonassoc_connective: NonassocConnective
    ) { ... }

    fn visit_tfx_type_arguments(
        &mut self, 
        tfx_type_arguments: &TypeArguments<'a>
    ) { ... }

    fn visit_tfx_atomic_type(&mut self, tfx_atomic_type: &AtomicType<'a>) { ... }

    fn visit_tfx_xprod_type(&mut self, tfx_xprod_type: &XprodType<'a>) { ... }

    fn visit_tfx_typed_variable(
        &mut self, 
        tfx_typed_variable: &TypedVariable<'a>
    ) { ... }

    fn visit_tfx_variable(&mut self, tfx_variable: &Variable<'a>) { ... }

    fn visit_tfx_variable_list(&mut self, tfx_variable_list: &VariableList<'a>) { ... }

    fn visit_tfx_unitary_type(&mut self, tfx_unitary_type: &UnitaryType<'a>) { ... }

    fn visit_tfx_mapping_type(&mut self, tfx_mapping_type: &MappingType<'a>) { ... }

    fn visit_tfx_monotype(&mut self, tfx_monotype: &Monotype<'a>) { ... }

    fn visit_tfx_quantified_type(
        &mut self, 
        tfx_quantified_type: &QuantifiedType<'a>
    ) { ... }

    fn visit_tfx_non_atomic_type(
        &mut self, 
        tfx_non_atomic_type: &NonAtomicType<'a>
    ) { ... }

    fn visit_tfx_toplevel_type(&mut self, tfx_toplevel_type: &TopLevelType<'a>) { ... }

    fn visit_tfx_atom_typing(&mut self, tfx_atom_typing: &AtomTyping<'a>) { ... }

    fn visit_tfx_term(&mut self, tfx_term: &Term<'a>) { ... }

    fn visit_tfx_unitary_term(&mut self, tfx_unitary_term: &UnitaryTerm<'a>) { ... }

    fn visit_tfx_arguments(&mut self, tfx_arguments: &Arguments<'a>) { ... }

    fn visit_tfx_plain_atomic(&mut self, tfx_plain_atomic: &PlainAtomic<'a>) { ... }

    fn visit_tfx_system_atomic(&mut self, tfx_system_atomic: &SystemAtomic<'a>) { ... }

    fn visit_tfx_defined_plain(&mut self, tfx_defined_plain: &DefinedPlain<'a>) { ... }

    fn visit_tfx_defined_atomic(
        &mut self, 
        tfx_defined_atomic: &DefinedAtomic<'a>
    ) { ... }

    fn visit_tfx_atomic_formula(
        &mut self, 
        tfx_atomic_formula: &AtomicFormula<'a>
    ) { ... }

    fn visit_tfx_preunit_formula(
        &mut self, 
        tfx_preunit_formula: &PreunitFormula<'a>
    ) { ... }

    fn visit_tfx_prefix_unary(&mut self, tfx_prefix_unary: &PrefixUnary<'a>) { ... }

    fn visit_tfx_infix_unary(&mut self, tfx_infix_unary: &InfixUnary<'a>) { ... }

    fn visit_tfx_defined_infix(&mut self, tfx_defined_infix: &DefinedInfix<'a>) { ... }

    fn visit_tfx_unary_formula(&mut self, tfx_unary_formula: &UnaryFormula<'a>) { ... }

    fn visit_tfx_quantified_formula(
        &mut self, 
        tfx_quantified_formula: &QuantifiedFormula<'a>
    ) { ... }

    fn visit_tfx_unit_formula(&mut self, tfx_unit_formula: &UnitFormula<'a>) { ... }

    fn visit_tfx_unitary_formula(
        &mut self, 
        tfx_unitary_formula: &UnitaryFormula<'a>
    ) { ... }

    fn visit_tfx_or_formula(&mut self, tfx_or_formula: &OrFormula<'a>) { ... }

    fn visit_tfx_and_formula(&mut self, tfx_and_formula: &AndFormula<'a>) { ... }

    fn visit_tfx_binary_assoc(&mut self, tfx_binary_assoc: &BinaryAssoc<'a>) { ... }

    fn visit_tfx_binary_nonassoc(
        &mut self, 
        tfx_binary_nonassoc: &BinaryNonassoc<'a>
    ) { ... }

    fn visit_tfx_binary_formula(
        &mut self, 
        tfx_binary_formula: &BinaryFormula<'a>
    ) { ... }

    fn visit_tfx_logic_formula(&mut self, tfx_logic_formula: &LogicFormula<'a>) { ... }

    fn visit_tfx_formula(&mut self, tfx_formula: &Formula<'a>) { ... }

    fn visit_fof_arguments(&mut self, fof_arguments: &Arguments<'a>) { ... }

    fn visit_fof_system_term(&mut self, fof_system_term: &SystemTerm<'a>) { ... }

    fn visit_fof_plain_term(&mut self, fof_plain_term: &PlainTerm<'a>) { ... }

    fn visit_fof_defined_plain_term(
        &mut self, 
        fof_defined_plain_term: &DefinedPlainTerm<'a>
    ) { ... }

    fn visit_fof_defined_atomic_term(
        &mut self, 
        fof_defined_atomic_term: &DefinedAtomicTerm<'a>
    ) { ... }

    fn visit_fof_defined_term(&mut self, fof_defined_term: &DefinedTerm<'a>) { ... }

    fn visit_fof_function_term(&mut self, fof_function_term: &FunctionTerm<'a>) { ... }

    fn visit_fof_term(&mut self, fof_term: &Term<'a>) { ... }

    fn visit_fof_quantifier(&mut self, _fof_quantifier: Quantifier) { ... }

    fn visit_fof_system_atomic_formula(
        &mut self, 
        fof_system_atomic_formula: &SystemAtomicFormula<'a>
    ) { ... }

    fn visit_fof_plain_atomic_formula(
        &mut self, 
        fof_plain_atomic_formula: &PlainAtomicFormula<'a>
    ) { ... }

    fn visit_fof_defined_plain_formula(
        &mut self, 
        fof_defined_plain_formula: &DefinedPlainFormula<'a>
    ) { ... }

    fn visit_fof_defined_infix_formula(
        &mut self, 
        fof_defined_infix_formula: &DefinedInfixFormula<'a>
    ) { ... }

    fn visit_fof_defined_atomic_formula(
        &mut self, 
        fof_defined_atomic_formula: &DefinedAtomicFormula<'a>
    ) { ... }

    fn visit_fof_atomic_formula(
        &mut self, 
        fof_atomic_formula: &AtomicFormula<'a>
    ) { ... }

    fn visit_fof_infix_unary(&mut self, fof_infix_unary: &InfixUnary<'a>) { ... }

    fn visit_fof_binary_nonassoc(
        &mut self, 
        fof_binary_nonassoc: &BinaryNonassoc<'a>
    ) { ... }

    fn visit_fof_or_formula(&mut self, fof_or_formula: &OrFormula<'a>) { ... }

    fn visit_fof_and_formula(&mut self, fof_and_formula: &AndFormula<'a>) { ... }

    fn visit_fof_binary_assoc(&mut self, fof_binary_assoc: &BinaryAssoc<'a>) { ... }

    fn visit_fof_binary_formula(
        &mut self, 
        fof_binary_formula: &BinaryFormula<'a>
    ) { ... }

    fn visit_fof_unary_formula(&mut self, fof_unary_formula: &UnaryFormula<'a>) { ... }

    fn visit_fof_variable_list(&mut self, fof_variable_list: &VariableList<'a>) { ... }

    fn visit_fof_unit_formula(&mut self, fof_unit_formula: &UnitFormula<'a>) { ... }

    fn visit_fof_quantified_formula(
        &mut self, 
        fof_quantified_formula: &QuantifiedFormula<'a>
    ) { ... }

    fn visit_fof_unitary_formula(
        &mut self, 
        fof_unitary_formula: &UnitaryFormula<'a>
    ) { ... }

    fn visit_fof_logic_formula(&mut self, fof_logic_formula: &LogicFormula<'a>) { ... }

    fn visit_fof_formula(&mut self, fof_formula: &Formula<'a>) { ... }

    fn visit_literal(&mut self, literal: &Literal<'a>) { ... }

    fn visit_disjunction(&mut self, disjunction: &Disjunction<'a>) { ... }

    fn visit_cnf_formula(&mut self, cnf_formula: &Formula<'a>) { ... }

    fn visit_formula_role(&mut self, formula_role: &FormulaRole<'a>) { ... }

    fn visit_general_terms(&mut self, general_terms: &GeneralTerms<'a>) { ... }

    fn visit_general_list(&mut self, general_list: &GeneralList<'a>) { ... }

    fn visit_general_function(&mut self, general_function: &GeneralFunction<'a>) { ... }

    fn visit_formula_data(&mut self, formula_data: &FormulaData<'a>) { ... }

    fn visit_general_data(&mut self, general_data: &GeneralData<'a>) { ... }

    fn visit_general_term(&mut self, general_term: &GeneralTerm<'a>) { ... }

    fn visit_source(&mut self, source: &Source<'a>) { ... }

    fn visit_useful_info(&mut self, useful_info: &UsefulInfo<'a>) { ... }

    fn visit_optional_info(&mut self, optional_info: &OptionalInfo<'a>) { ... }

    fn visit_annotations(&mut self, annotations: &Annotations<'a>) { ... }

    fn visit_tfx_annotated(&mut self, tfx_annotated: &TfxAnnotated<'a>) { ... }

    fn visit_fof_annotated(&mut self, fof_annotated: &FofAnnotated<'a>) { ... }

    fn visit_cnf_annotated(&mut self, cnf_annotated: &CnfAnnotated<'a>) { ... }

    fn visit_annotated_formula(&mut self, annotated: &AnnotatedFormula<'a>) { ... }

    fn visit_name_list(&mut self, name_list: &NameList<'a>) { ... }

    fn visit_formula_selection(&mut self, selection: &FormulaSelection<'a>) { ... }

    fn visit_file_name(&mut self, file_name: &FileName<'a>) { ... }

    fn visit_include(&mut self, include: &Include<'a>) { ... }

    fn visit_tptp_input(&mut self, input: &TPTPInput<'a>) { ... }

}
Expand description

visitor pattern trait

This can make traversing parsed syntax easier. Default method implementations visit child structures in parsing order.

Provided methods

Implementors