pub fn data_function_symbol(&self) -> DataFunctionSymbolRef<'_> {

            if is_data_application(&self.term) {

                self.term.arg(0).into()

            } else if is_data_function_symbol(&self.term) {

                self.term.copy().into()

        }

        pub fn data_arguments(&self) -> impl ExactSizeIterator<Item = DataExpressionRef<'_>> + use<'_> {

            let mut result = self.term.arguments();

            if is_data_application(&self.term) {

                result.next();

            } else if is_data_function_symbol(&self.term) || is_data_variable(&self.term) {

                result.next();

                result.next();

            } else {

            result.map(|t| t.into())

        }

        pub fn from_string(text: &str) -> Result<DataExpression, MercError> {

            Ok(to_untyped_data_expression(ATerm::from_string(text)?, None))

        }

        pub fn from_string_untyped(text: &str, variables: &AHashSet<String>) -> Result<DataExpression, MercError> {

            Ok(to_untyped_data_expression(ATerm::from_string(text)?, Some(variables)))

        }

        pub fn data_arg(&self, index: usize) -> DataExpressionRef<'_> {

            debug_assert!(is_data_application(self), "Term {self:?} is not a data application");

            debug_assert!(

                index + 1 < self.get_head_symbol().arity(),

            self.term.arg(index + 1).into()

        }

        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

            if is_data_function_symbol(&self.term) {

                write!(f, "{}", DataFunctionSymbolRef::from(self.term.copy()))

            } else if is_data_application(&self.term) {

                write!(f, "{}", DataApplicationRef::from(self.term.copy()))

            } else if is_data_variable(&self.term) {

            } else if is_data_machine_number(&self.term) {

                write!(f, "{}", MachineNumberRef::from(self.term.copy()))

        }

        pub fn new<N>(name: N) -> DataFunctionSymbol

        where

            N: Into<ATermString> + AsRef<str>,

            DATA_SYMBOLS.with_borrow(|ds| DataFunctionSymbol {

                term: ATerm::with_args(

                    ds.data_function_symbol.deref(),

                    &[Into::<ATerm>::into(name.into()), SortExpression::unknown_sort().into()],

                )

                .protect(),

            })

        }

        pub fn name(&self) -> ATermStringRef<'_> {

            ATermStringRef::from(self.term.arg(0))

        }

        pub fn operation_id(&self) -> usize {

            self.term.index()

        }

        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

            write!(f, "{}", self.name())

        }

        pub fn new<N: Into<ATermString>>(name: N) -> DataVariable {

            DATA_SYMBOLS.with_borrow(|ds| {

                let t = name.into();

                let args: &[ATerm] = &[t.into(), SortExpression::unknown_sort().into()];

                DataVariable {

                    term: ATerm::with_args(ds.data_variable.deref(), args).protect(),

                }

            })

        }

        pub fn name(&self) -> &str {

            self.term.arg(0).get_head_symbol().name()

        }

        pub fn with_args<'a, 'b, H: Term<'a, 'b>, T: Term<'a, 'b>>(head: &'b H, arguments: &'b [T]) -> DataApplication {

            DATA_SYMBOLS.with_borrow_mut(|ds| {

                let symbol = ds.get_data_application_symbol(arguments.len() + 1).copy();

                let args = iter::once(head.copy()).chain(arguments.iter().map(|t| t.copy()));

                let term = ATerm::with_iter(&symbol, args);

                DataApplication { term }

            })

        }

        pub fn with_iter<'a, 'b, 'c, 'd, T, H, I>(head: &'b H, arity: usize, arguments: I) -> DataApplication

        where

            I: Iterator<Item = T>,

            T: Term<'c, 'd>,

            H: Term<'a, 'b>,

            DATA_SYMBOLS.with_borrow_mut(|ds| {

                let symbol = ds.get_data_application_symbol(arity + 1).copy();

                let term = ATerm::with_iter_head(&symbol, head, arguments);

                DataApplication { term }

            })

        }

        pub fn data_function_symbol(&self) -> DataFunctionSymbolRef<'_> {

            self.term.arg(0).into()

        }

        pub fn data_arguments(&self) -> ATermArgs<'_> {

            let mut result = self.term.arguments();

            result.next();

            result

        }

        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

            write!(f, "{}", self.data_function_symbol())?;

            let mut first = true;

            for arg in self.data_arguments() {

                if !first {

                    write!(f, ", ")?;

                    write!(f, "(")?;

                write!(f, "{}", DataExpressionRef::from(arg.copy()))?;

                first = false;

            if !first {

                write!(f, ")")?;

            Ok(())

        }

        pub fn value(&self) -> u64 {

            Into::<ATermIntRef<'_>>::into(self.term.copy()).value() as u64

        }

        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

            write!(f, "{}", self.value())

        }

        fn from(value: DataFunctionSymbol) -> Self {

            value.term.into()

        }

        fn from(value: DataApplication) -> Self {

            value.term.into()

        }

        fn from(value: DataVariable) -> Self {

            value.term.into()

        }

        fn from(value: DataExpression) -> Self {

            value.term.into()

        }

        fn from(value: DataExpression) -> Self {

            value.term.into()

        }

        fn from(value: DataExpressionRef<'a>) -> Self {

            value.term.into()

        }

    pub fn data_arguments(&self) -> impl ExactSizeIterator<Item = DataExpressionRef<'a>> + use<'a> {

        let mut result = self.term.arguments();

        if is_data_application(&self.term) {

            result.next();

        } else if is_data_function_symbol(&self.term) || is_data_variable(&self.term) {

            result.next();

            result.next();

        } else {

        result.map(|t| t.into())

    }

    pub fn data_arg(&self, index: usize) -> DataExpressionRef<'a> {

        debug_assert!(is_data_application(self), "Term {self:?} is not a data application");

        debug_assert!(

            index + 1 < self.get_head_symbol().arity(),

        self.term.arg(index + 1).into()

    }

pub fn to_untyped_data_expression(t: ATerm, variables: Option<&AHashSet<String>>) -> DataExpression {

    let mut builder = TermBuilder::<ATerm, ATerm>::new();

    THREAD_TERM_POOL.with_borrow(|tp| {

        builder

            .evaluate(

                tp,

                t,

                |_tp, args, t| {

                    if variables.is_some_and(|v| v.contains(t.get_head_symbol().name())) {

                        Ok(Yield::Term(DataVariable::new(t.get_head_symbol().name()).into()))

                    } else if t.get_head_symbol().arity() == 0 {

                        Ok(Yield::Term(DataFunctionSymbol::new(t.get_head_symbol().name()).into()))

                        let head = DataFunctionSymbol::new(t.get_head_symbol().name());

                        for arg in t.arguments() {

                            args.push(arg.protect());

                        }

                        Ok(Yield::Construct(head.into()))

                },

                |_tp, input, args| {

                    let arity = args.clone().count();

                    Ok(DataApplication::with_iter(&input, arity, args).into())

                },

            .unwrap()

            .into()

    })

}

    fn test_print() {

        let _ = merc_utilities::test_logger();

        let a = DataFunctionSymbol::new("a");

        assert_eq!("a", format!("{}", a));

        let f = DataFunctionSymbol::new("f");

        let appl = DataApplication::with_args(&f, &[a]);

        assert_eq!("f(a)", format!("{}", appl));

    }

    fn test_recognizers() {

        let a = DataFunctionSymbol::new("a");

        let f = DataFunctionSymbol::new("f");

        let appl = DataApplication::with_args(&f, &[a]);

        let term: ATerm = appl.into();

        assert!(is_data_application(&term));

    }

    fn test_data_arguments() {

        let a = DataFunctionSymbol::new("a");

        let f = DataFunctionSymbol::new("f");

        let appl = DataApplication::with_args(&f, &[a]);

        assert_eq!(appl.data_arguments().count(), 1);

        let data_expr: DataExpression = appl.clone().into();

        assert_eq!(data_expr.data_arguments().count(), 1);

    }

    fn test_to_data_expression() {

        let expression = DataExpression::from_string("s(s(a, b), c)").unwrap();

        assert_eq!(expression.data_arg(0).data_function_symbol().name(), "s");

        assert_eq!(expression.data_arg(0).data_arg(0).data_function_symbol().name(), "a");

    }