FIX: Don not clone Locales and Languages, pass them by reference

base/src/actions.rs

@@ -10,7 +10,7 @@ use crate::model::Model;
 // In IronCalc, if one of the edges of the range is deleted will replace the edge with #REF!
 // I feel this is unimportant for now.
 
-impl Model {
+impl<'a> Model<'a> {
     fn shift_cell_formula(
         &mut self,
         sheet: u32,
@@ -31,7 +31,7 @@ impl Model {
                 column,
             };
             // FIXME: This is not a very performant way if the formula has changed :S.
-            let formula = to_localized_string(node, &cell_reference, &self.locale, &self.language);
+            let formula = to_localized_string(node, &cell_reference, self.locale, self.language);
             let formula_displaced = to_string_displaced(node, &cell_reference, displace_data);
             if formula != formula_displaced {
                 self.update_cell_with_formula(sheet, row, column, format!("={formula_displaced}"))?;
@@ -111,7 +111,7 @@ impl Model {
         let formula_or_value = self
             .get_cell_formula(sheet, source_row, source_column)?
             .unwrap_or_else(|| {
-                source_cell.get_localized_text(&self.workbook.shared_strings, &self.language)
+                source_cell.get_localized_text(&self.workbook.shared_strings, self.language)
             });
         self.set_user_input(sheet, target_row, target_column, formula_or_value)?;
         self.workbook
@@ -497,7 +497,7 @@ impl Model {
             let formula_or_value =
                 self.get_cell_formula(sheet, r.row, column)?
                     .unwrap_or_else(|| {
-                        cell.get_localized_text(&self.workbook.shared_strings, &self.language)
+                        cell.get_localized_text(&self.workbook.shared_strings, self.language)
                     });
             original_cells.push((r.row, formula_or_value, style_idx));
             self.cell_clear_all(sheet, r.row, column)?;
@@ -584,7 +584,7 @@ impl Model {
                 .ok_or("Expected Cell to exist")?;
             let style_idx = cell.get_style();
             let formula_or_value = self.get_cell_formula(sheet, row, *c)?.unwrap_or_else(|| {
-                cell.get_localized_text(&self.workbook.shared_strings, &self.language)
+                cell.get_localized_text(&self.workbook.shared_strings, self.language)
             });
             original_cells.push((*c, formula_or_value, style_idx));
             self.cell_clear_all(sheet, row, *c)?;

base/src/arithmetic.rs

@@ -22,7 +22,7 @@ fn to_f64(value: &ArrayNode) -> Result<f64, Error> {
     }
 }
 
-impl Model {
+impl<'a> Model<'a> {
     /// Applies `op` element‐wise for arrays/numbers.
     pub(crate) fn handle_arithmetic(
         &mut self,

base/src/cast.rs

@@ -14,7 +14,7 @@ pub(crate) enum NumberOrArray {
     Array(Vec<Vec<ArrayNode>>),
 }
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn cast_number(&self, s: &str) -> Option<f64> {
         match s.trim().parse::<f64>() {
             Ok(f) => Some(f),

base/src/expressions/lexer/mod.rs

@@ -79,19 +79,24 @@ pub enum LexerMode {
 
 /// Tokenize an input
 #[derive(Clone)]
-pub struct Lexer {
+pub struct Lexer<'a> {
     position: usize,
     next_token_position: Option<usize>,
     len: usize,
     chars: Vec<char>,
     mode: LexerMode,
-    locale: Locale,
+    locale: &'a Locale,
-    language: Language,
+    language: &'a Language,
 }
 
-impl Lexer {
+impl<'a> Lexer<'a> {
     /// Creates a new `Lexer` that returns the tokens of a formula.
-    pub fn new(formula: &str, mode: LexerMode, locale: &Locale, language: &Language) -> Lexer {
+    pub fn new(
+        formula: &str,
+        mode: LexerMode,
+        locale: &'a Locale,
+        language: &'a Language,
+    ) -> Lexer<'a> {
         let chars: Vec<char> = formula.chars().collect();
         let len = chars.len();
         Lexer {
@@ -100,8 +105,8 @@ impl Lexer {
             next_token_position: None,
             len,
             mode,
-            locale: locale.clone(),
+            locale,
-            language: language.clone(),
+            language,
         }
     }
 
@@ -111,13 +116,13 @@ impl Lexer {
     }
 
     /// Sets the locale
-    pub fn set_locale(&mut self, locale: &Locale) {
+    pub fn set_locale(&mut self, locale: &'a Locale) {
-        self.locale = locale.clone();
+        self.locale = locale;
     }
 
     /// Sets the language
-    pub fn set_language(&mut self, language: &Language) {
+    pub fn set_language(&mut self, language: &'a Language) {
-        self.language = language.clone();
+        self.language = language;
     }
 
     // FIXME: I don't think we should have `is_a1_mode` and   `get_formula`.

base/src/expressions/lexer/ranges.rs

@@ -4,7 +4,7 @@ use crate::expressions::{token::TokenType, utils::column_to_number};
 use super::Lexer;
 use super::{ParsedRange, ParsedReference, Result};
 
-impl Lexer {
+impl<'a> Lexer<'a> {
     /// Consumes a reference in A1 style like:
     /// AS23, $AS23, AS$23, $AS$23, R12
     /// Or returns an error

base/src/expressions/lexer/structured_references.rs

@@ -16,7 +16,7 @@ use crate::expressions::token::{TableReference, TableSpecifier};
 use super::Result;
 use super::{Lexer, LexerError};
 
-impl Lexer {
+impl<'a> Lexer<'a> {
     fn consume_table_specifier(&mut self) -> Result<Option<TableSpecifier>> {
         if self.peek_char() == Some('#') {
             // It's a specifier

base/src/expressions/lexer/test/test_common.rs

@@ -11,7 +11,7 @@ use crate::expressions::{
     types::ParsedReference,
 };
 
-fn new_lexer(formula: &str, a1_mode: bool) -> Lexer {
+fn new_lexer(formula: &str, a1_mode: bool) -> Lexer<'_> {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     let mode = if a1_mode {
@@ -655,7 +655,9 @@ fn test_comma() {
 
     // Used for testing locales where the comma is the decimal separator
     let mut lx = new_lexer("12,34", false);
-    lx.locale.numbers.symbols.decimal = ",".to_string();
+    let locale = get_locale("de").unwrap();
+    lx.locale = locale;
+
     assert_eq!(lx.next_token(), Number(12.34));
     assert_eq!(lx.next_token(), EOF);
 }

base/src/expressions/lexer/test/test_implicit_intersection.rs

@@ -7,7 +7,7 @@ use crate::expressions::{
 use crate::language::get_language;
 use crate::locale::get_locale;
 
-fn new_lexer(formula: &str) -> Lexer {
+fn new_lexer(formula: &str) -> Lexer<'_> {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

base/src/expressions/lexer/test/test_language.rs

@@ -6,11 +6,11 @@ use crate::{
         token::{Error, TokenType},
     },
     language::get_language,
-    locale::get_locale,
+    locale::get_default_locale,
 };
 
-fn new_language_lexer(formula: &str, language: &str) -> Lexer {
+fn new_language_lexer<'a>(formula: &str, language: &str) -> Lexer<'a> {
-    let locale = get_locale("en").unwrap();
+    let locale = get_default_locale();
     let language = get_language(language).unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)
 }

base/src/expressions/lexer/test/test_locale.rs

@@ -9,7 +9,7 @@ use crate::{
     locale::get_locale,
 };
 
-fn new_language_lexer(formula: &str, locale: &str, language: &str) -> Lexer {
+fn new_language_lexer<'a>(formula: &str, locale: &str, language: &str) -> Lexer<'a> {
     let locale = get_locale(locale).unwrap();
     let language = get_language(language).unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

base/src/expressions/lexer/test/test_ranges.rs

@@ -10,7 +10,7 @@ use crate::expressions::{
 use crate::language::get_language;
 use crate::locale::get_locale;
 
-fn new_lexer(formula: &str) -> Lexer {
+fn new_lexer(formula: &str) -> Lexer<'_> {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

base/src/expressions/lexer/test/test_tables.rs

@@ -7,7 +7,7 @@ use crate::expressions::{
 use crate::language::get_language;
 use crate::locale::get_locale;
 
-fn new_lexer(formula: &str) -> Lexer {
+fn new_lexer(formula: &str) -> Lexer<'_> {
     let locale = get_locale("en").unwrap();
     let language = get_language("en").unwrap();
     Lexer::new(formula, LexerMode::A1, locale, language)

base/src/expressions/parser/mod.rs

@@ -31,8 +31,10 @@ f_args  => e (',' e)*
 use std::collections::HashMap;
 
 use crate::functions::Function;
+use crate::language::get_default_language;
 use crate::language::get_language;
 use crate::language::Language;
+use crate::locale::get_default_locale;
 use crate::locale::get_locale;
 use crate::locale::Locale;
 use crate::types::Table;
@@ -204,34 +206,34 @@ pub enum Node {
 }
 
 #[derive(Clone)]
-pub struct Parser {
+pub struct Parser<'a> {
-    lexer: lexer::Lexer,
+    lexer: lexer::Lexer<'a>,
     worksheets: Vec<String>,
     defined_names: Vec<DefinedNameS>,
     context: CellReferenceRC,
     tables: HashMap<String, Table>,
-    locale: Locale,
+    locale: &'a Locale,
-    language: Language,
+    language: &'a Language,
 }
 
-pub fn new_parser_english(
+pub fn new_parser_english<'a>(
     worksheets: Vec<String>,
     defined_names: Vec<DefinedNameS>,
     tables: HashMap<String, Table>,
-) -> Parser {
+) -> Parser<'a> {
-    let locale = Locale::default();
+    let locale = get_default_locale();
-    let language = Language::default();
+    let language = get_default_language();
-    Parser::new(worksheets, defined_names, tables, &locale, &language)
+    Parser::new(worksheets, defined_names, tables, locale, language)
 }
 
-impl Parser {
+impl<'a> Parser<'a> {
     pub fn new(
         worksheets: Vec<String>,
         defined_names: Vec<DefinedNameS>,
         tables: HashMap<String, Table>,
-        locale: &Locale,
+        locale: &'a Locale,
-        language: &Language,
+        language: &'a Language,
-    ) -> Parser {
+    ) -> Parser<'a> {
         let lexer = lexer::Lexer::new("", lexer::LexerMode::A1, locale, language);
         let context = CellReferenceRC {
             sheet: worksheets.first().map_or("", |v| v).to_string(),
@@ -244,21 +246,21 @@ impl Parser {
             defined_names,
             context,
             tables,
-            locale: locale.clone(),
+            locale,
-            language: language.clone(),
+            language,
         }
     }
     pub fn set_lexer_mode(&mut self, mode: lexer::LexerMode) {
         self.lexer.set_lexer_mode(mode)
     }
 
-    pub fn set_locale(&mut self, locale: &Locale) {
+    pub fn set_locale(&mut self, locale: &'a Locale) {
-        self.locale = locale.clone();
+        self.locale = locale;
         self.lexer.set_locale(locale);
     }
 
-    pub fn set_language(&mut self, language: &Language) {
+    pub fn set_language(&mut self, language: &'a Language) {
-        self.language = language.clone();
+        self.language = language;
         self.lexer.set_language(language);
     }
 

base/src/expressions/parser/tests/test_languages.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::unwrap_used)]
+
 use std::collections::HashMap;
 
 use crate::expressions::parser::{DefinedNameS, Node, Parser};
@@ -15,11 +17,11 @@ pub fn to_string(t: &Node, cell_reference: &CellReferenceRC) -> String {
     to_localized_string(t, cell_reference, locale, language)
 }
 
-pub fn new_parser(
+pub fn new_parser<'a>(
     worksheets: Vec<String>,
     defined_names: Vec<DefinedNameS>,
     tables: HashMap<String, Table>,
-) -> Parser {
+) -> Parser<'a> {
     let locale = get_locale("en").unwrap();
     let language = get_language("es").unwrap();
     Parser::new(worksheets, defined_names, tables, locale, language)

base/src/expressions/parser/tests/test_move_formula.rs

@@ -4,13 +4,13 @@ use crate::expressions::parser::move_formula::{move_formula as mf, MoveContext};
 use crate::expressions::parser::tests::utils::new_parser;
 use crate::expressions::parser::Node;
 use crate::expressions::types::{Area, CellReferenceRC};
-use crate::language::Language;
+use crate::language::get_default_language;
-use crate::locale::Locale;
+use crate::locale::get_default_locale;
 
 fn move_formula(node: &Node, context: &MoveContext) -> String {
-    let locale = Locale::default();
+    let locale = get_default_locale();
-    let language = Language::default();
+    let language = get_default_language();
-    mf(node, context, &locale, &language)
+    mf(node, context, locale, language)
 }
 
 #[test]

base/src/expressions/parser/tests/utils.rs

@@ -5,25 +5,25 @@ use crate::{
         parser::{DefinedNameS, Node, Parser},
         types::CellReferenceRC,
     },
-    language::Language,
+    language::get_default_language,
-    locale::Locale,
+    locale::get_default_locale,
     types::Table,
 };
 
 use crate::expressions::parser::stringify::to_localized_string;
 
 pub fn to_english_localized_string(t: &Node, cell_reference: &CellReferenceRC) -> String {
-    let locale = Locale::default();
+    let locale = get_default_locale();
-    let language = Language::default();
+    let language = get_default_language();
-    to_localized_string(t, cell_reference, &locale, &language)
+    to_localized_string(t, cell_reference, locale, language)
 }
 
-pub fn new_parser(
+pub fn new_parser<'a>(
     worksheets: Vec<String>,
     defined_names: Vec<DefinedNameS>,
     tables: HashMap<String, Table>,
-) -> Parser {
+) -> Parser<'a> {
-    let locale = Locale::default();
+    let locale = get_default_locale();
-    let language = Language::default();
+    let language = get_default_language();
-    Parser::new(worksheets, defined_names, tables, &locale, &language)
+    Parser::new(worksheets, defined_names, tables, locale, language)
 }

base/src/functions/binary_search.rs

@@ -137,7 +137,7 @@ pub(crate) fn binary_search_descending_or_greater<T: Ord>(target: &T, array: &[T
     Some((n - r - 1) as i32)
 }
 
-impl Model {
+impl<'a> Model<'a> {
     /// Returns an array with the list of cell values in the range
     pub(crate) fn prepare_array(
         &mut self,

base/src/functions/database.rs

@@ -9,7 +9,7 @@ use crate::{
 
 use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex};
 
-impl Model {
+impl<'a> Model<'a> {
     // =DAVERAGE(database, field, criteria)
     pub(crate) fn fn_daverage(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 3 {

base/src/functions/date_and_time.rs

@@ -470,7 +470,7 @@ fn parse_datevalue_text(value: &str) -> Result<i32, String> {
     }
 }
 
-impl Model {
+impl<'a> Model<'a> {
     fn get_date_serial(
         &mut self,
         node: &Node,

base/src/functions/engineering/bessel.rs

@@ -12,7 +12,7 @@ use super::transcendental::{bessel_i, bessel_j, bessel_k, bessel_y};
 // Notice that the parameters for Bessel functions in Excel and here have inverted order
 // EXCEL_BESSEL(x, n) => bessel(n, x)
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_besseli(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {
             return CalcResult::new_args_number_error(cell);

base/src/functions/engineering/bit_operations.rs

@@ -7,7 +7,7 @@ use crate::{
 // 2^48-1
 const MAX: f64 = 281474976710655.0;
 
-impl Model {
+impl<'a> Model<'a> {
     // BITAND( number1, number2)
     pub(crate) fn fn_bitand(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 2 {

base/src/functions/engineering/complex.rs

@@ -182,7 +182,7 @@ fn parse_complex_number(s: &str) -> Result<(f64, f64, Suffix), String> {
     }
 }
 
-impl Model {
+impl<'a> Model<'a> {
     fn get_complex_number(
         &mut self,
         node: &Node,

base/src/functions/engineering/convert.rs

@@ -41,7 +41,7 @@ fn convert_temperature(
     }
 }
 
-impl Model {
+impl<'a> Model<'a> {
     // CONVERT(number, from_unit, to_unit)
     pub(crate) fn fn_convert(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 3 {

base/src/functions/engineering/misc.rs

@@ -5,7 +5,7 @@ use crate::{
     number_format::to_precision,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // DELTA(number1, [number2])
     pub(crate) fn fn_delta(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let arg_count = args.len();

base/src/functions/engineering/number_basis.rs

@@ -31,7 +31,7 @@ fn from_binary_to_decimal(value: f64) -> Result<i64, String> {
     Ok(result)
 }
 
-impl Model {
+impl<'a> Model<'a> {
     // BIN2DEC(number)
     pub(crate) fn fn_bin2dec(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 1 {

base/src/functions/financial.rs

@@ -191,7 +191,7 @@ fn compute_ppmt(
 // All, except for rate are easily solvable in terms of the others.
 // In these formulas the payment (pmt) is normally negative
 
-impl Model {
+impl<'a> Model<'a> {
     fn get_array_of_numbers_generic(
         &mut self,
         arg: &Node,

base/src/functions/information.rs

@@ -4,7 +4,7 @@ use crate::{
     model::{Model, ParsedDefinedName},
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_isnumber(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 1 {
             match self.evaluate_node_in_context(&args[0], cell) {

base/src/functions/logical.rs

@@ -6,7 +6,7 @@ use crate::{
 
 use super::util::compare_values;
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_true(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.is_empty() {
             CalcResult::Boolean(true)

base/src/functions/lookup_and_reference.rs

@@ -7,7 +7,7 @@ use crate::{
 
 use super::util::{compare_values, from_wildcard_to_regex, result_matches_regex, values_are_equal};
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_index(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let row_num;
         let col_num;
@@ -698,7 +698,7 @@ impl Model {
                 let parsed_reference = ParsedReference::parse_reference_formula(
                     Some(cell.sheet),
                     &s,
-                    &self.locale,
+                    self.locale,
                     |name| self.get_sheet_index_by_name(name),
                 );
 

base/src/functions/mathematical.rs

@@ -47,7 +47,7 @@ pub fn random() -> f64 {
     Math::random()
 }
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_min(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let mut result = f64::NAN;
         for arg in args {

base/src/functions/mathematical_sum.rs

@@ -13,7 +13,7 @@ fn is_same_shape_or_1d(rows1: i32, cols1: i32, rows2: i32, cols2: i32) -> bool {
         || (rows2 == 1 && cols1 == 1 && cols2 == rows1)
 }
 
-impl Model {
+impl<'a> Model<'a> {
     // SUMX2MY2(array_x, array_y) - Returns the sum of the difference of squares
     pub(crate) fn fn_sumx2my2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let result = match self.fn_get_two_matrices(args, cell) {

base/src/functions/mod.rs

@@ -3,8 +3,7 @@ use std::array::IntoIter;
 use crate::{
     calc_result::CalcResult,
     expressions::{parser::Node, token::Error, types::CellReferenceIndex},
-    language::Functions,
+    language::{get_default_language, Functions, Language},
-    language::Language,
     model::Model,
 };
 
@@ -1642,8 +1641,8 @@ impl Function {
             Function::RankEq => "_xlfn.RANK.EQ".to_string(),
 
             _ => {
-                let language = Language::default();
+                let language = get_default_language();
-                self.to_localized_name(&language)
+                self.to_localized_name(language)
             }
         }
     }
@@ -1653,7 +1652,7 @@ impl Function {
     }
 }
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn evaluate_function(
         &mut self,
         kind: &Function,

base/src/functions/statistical/beta.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // BETA.DIST(x, alpha, beta, cumulative, [A], [B])
     pub(crate) fn fn_beta_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let arg_count = args.len();

base/src/functions/statistical/binom.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_binom_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 4 {
             return CalcResult::new_args_number_error(cell);

base/src/functions/statistical/chisq.rs

@@ -6,7 +6,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // CHISQ.DIST(x, deg_freedom, cumulative)
     pub(crate) fn fn_chisq_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 3 {

base/src/functions/statistical/correl.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // CORREL(array1, array2) - Returns the correlation coefficient of two data sets
     pub(crate) fn fn_correl(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let (_, _, values_left, values_right) = match self.fn_get_two_matrices(args, cell) {

base/src/functions/statistical/count_and_average.rs

@@ -7,7 +7,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     fn for_each_value<F>(
         &mut self,
         args: &[Node],

base/src/functions/statistical/covariance.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_covariance_p(
         &mut self,
         args: &[Node],

base/src/functions/statistical/devsq.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // DEVSQ(number1, [number2], ...)
     pub(crate) fn fn_devsq(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.is_empty() {

base/src/functions/statistical/exponential.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_expon_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         // EXPON.DIST(x, lambda, cumulative)
         if args.len() != 3 {

base/src/functions/statistical/fisher.rs

@@ -6,7 +6,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // FISHER(x) = 0.5 * ln((1 + x) / (1 - x))
     pub(crate) fn fn_fisher(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 1 {

base/src/functions/statistical/gamma.rs

@@ -6,7 +6,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_gamma(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 1 {
             return CalcResult::new_args_number_error(cell);

base/src/functions/statistical/gauss.rs

@@ -4,7 +4,7 @@ use crate::expressions::token::Error;
 use crate::expressions::types::CellReferenceIndex;
 use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_gauss(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 1 {
             return CalcResult::new_args_number_error(cell);

base/src/functions/statistical/geomean.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_geomean(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.is_empty() {
             return CalcResult::new_args_number_error(cell);

base/src/functions/statistical/hypegeom.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // =HYPGEOM.DIST(sample_s, number_sample, population_s, number_pop, cumulative)
     pub(crate) fn fn_hyp_geom_dist(
         &mut self,

base/src/functions/statistical/if_ifs.rs

@@ -8,7 +8,7 @@ use crate::{
     model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_countif(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() == 2 {
             let arguments = vec![args[0].clone(), args[1].clone()];

base/src/functions/statistical/log_normal.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_log_norm_dist(
         &mut self,
         args: &[Node],

base/src/functions/statistical/normal.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // NORM.DIST(x, mean, standard_dev, cumulative)
     pub(crate) fn fn_norm_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 4 {

base/src/functions/statistical/pearson.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // PEARSON(array1, array2)
     pub(crate) fn fn_pearson(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let (_, _, values_left, values_right) = match self.fn_get_two_matrices(args, cell) {

base/src/functions/statistical/phi.rs

@@ -1,7 +1,7 @@
 use crate::expressions::types::CellReferenceIndex;
 use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
 
-impl Model {
+impl<'a> Model<'a> {
     // PHI(x) = standard normal PDF at x
     pub(crate) fn fn_phi(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 1 {

base/src/functions/statistical/poisson.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // =POISSON.DIST(x, mean, cumulative)
     pub(crate) fn fn_poisson_dist(
         &mut self,

base/src/functions/statistical/rank_eq_avg.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // Helper to collect numeric values from the 2nd argument of RANK.*
     fn collect_rank_values(
         &mut self,

base/src/functions/statistical/standard_dev.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_stdev_p(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.is_empty() {
             return CalcResult::new_args_number_error(cell);

base/src/functions/statistical/standardize.rs

@@ -3,7 +3,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_standardize(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         // STANDARDIZE(x, mean, standard_dev)
         if args.len() != 3 {

base/src/functions/statistical/t_dist.rs

@@ -42,7 +42,7 @@ enum TTestTails {
     TwoTailed,
 }
 
-impl Model {
+impl<'a> Model<'a> {
     // T.DIST(x, deg_freedom, cumulative)
     pub(crate) fn fn_t_dist(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.len() != 3 {

base/src/functions/statistical/variance.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_var_p(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         if args.is_empty() {
             return CalcResult::new_args_number_error(cell);

base/src/functions/statistical/weibull.rs

@@ -5,7 +5,7 @@ use crate::{
     calc_result::CalcResult, expressions::parser::Node, expressions::token::Error, model::Model,
 };
 
-impl Model {
+impl<'a> Model<'a> {
     // WEIBULL.DIST(x, alpha, beta, cumulative)
     pub(crate) fn fn_weibull_dist(
         &mut self,

base/src/functions/statistical/z_test.rs

@@ -4,7 +4,7 @@ use crate::expressions::token::Error;
 use crate::expressions::types::CellReferenceIndex;
 use crate::{calc_result::CalcResult, expressions::parser::Node, model::Model};
 
-impl Model {
+impl<'a> Model<'a> {
     // Z.TEST(array, x, [sigma])
     pub(crate) fn fn_z_test(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         // 2 or 3 arguments

base/src/functions/subtotal.rs

@@ -32,7 +32,7 @@ pub enum CellTableStatus {
     Filtered,
 }
 
-impl Model {
+impl<'a> Model<'a> {
     fn get_table_for_cell(&self, sheet_index: u32, row: i32, column: i32) -> bool {
         let worksheet = match self.workbook.worksheet(sheet_index) {
             Ok(ws) => ws,

base/src/functions/text.rs

@@ -50,7 +50,7 @@ fn search(search_for: &str, text: &str, start: usize) -> Option<i32> {
     None
 }
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn fn_concat(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
         let mut result = "".to_string();
         for arg in args {
@@ -149,7 +149,7 @@ impl Model {
                 Ok(s) => s,
                 Err(s) => return s,
             };
-            let d = format_number(value, &format_code, &self.locale);
+            let d = format_number(value, &format_code, self.locale);
             if let Some(_e) = d.error {
                 return CalcResult::Error {
                     error: Error::VALUE,

base/src/functions/xlookup.rs

@@ -118,7 +118,7 @@ fn linear_search(
     None
 }
 
-impl Model {
+impl<'a> Model<'a> {
     /// The XLOOKUP function searches a range or an array, and then returns the item corresponding
     /// to the first match it finds. If no match exists, then XLOOKUP can return the closest (approximate) match.
     /// =XLOOKUP(lookup_value, lookup_array, return_array, [if_not_found], [match_mode], [search_mode])

base/src/language/mod.rs

@@ -2,13 +2,13 @@ use std::{collections::HashMap, sync::OnceLock};
 
 use bitcode::{Decode, Encode};
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct Booleans {
     pub r#true: String,
     pub r#false: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct Errors {
     pub r#ref: String,
     pub name: String,
@@ -24,7 +24,7 @@ pub struct Errors {
     pub null: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct Functions {
     pub and: String,
     pub r#false: String,
@@ -373,7 +373,7 @@ pub struct Functions {
     pub small: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct Language {
     pub name: String,
     pub code: String,
@@ -382,11 +382,9 @@ pub struct Language {
     pub functions: Functions,
 }
 
-impl Default for Language {
+pub fn get_default_language() -> &'static Language {
-    fn default() -> Self {
+    #[allow(clippy::unwrap_used)]
-        #[allow(clippy::unwrap_used)]
+    get_language("en").unwrap()
-        get_language("en").unwrap().clone()
-    }
 }
 
 static LANGUAGES: OnceLock<HashMap<String, Language>> = OnceLock::new();
@@ -398,7 +396,7 @@ fn get_languages() -> &'static HashMap<String, Language> {
     })
 }
 
-pub fn get_language(id: &str) -> Result<&Language, String> {
+pub fn get_language(id: &str) -> Result<&'static Language, String> {
     get_languages()
         .get(id)
         .ok_or_else(|| format!("Language is not supported: '{id}'"))

base/src/locale/mod.rs

@@ -2,27 +2,27 @@ use std::{collections::HashMap, sync::OnceLock};
 
 use bitcode::{Decode, Encode};
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct Locale {
     pub dates: Dates,
     pub numbers: NumbersProperties,
     pub currency: Currency,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct Currency {
     pub iso: String,
     pub symbol: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct NumbersProperties {
     pub symbols: NumbersSymbols,
     pub decimal_formats: DecimalFormats,
     pub currency_formats: CurrencyFormats,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct Dates {
     pub day_names: Vec<String>,
     pub day_names_short: Vec<String>,
@@ -34,7 +34,7 @@ pub struct Dates {
     pub date_time_formats: DateFormats,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct NumbersSymbols {
     pub decimal: String,
     pub group: String,
@@ -52,7 +52,7 @@ pub struct NumbersSymbols {
 }
 
 // See: https://cldr.unicode.org/translation/number-currency-formats/number-and-currency-patterns
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct CurrencyFormats {
     pub standard: String,
     pub standard_alpha_next_to_number: Option<String>,
@@ -62,12 +62,12 @@ pub struct CurrencyFormats {
     pub accounting_no_currency: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct DecimalFormats {
     pub standard: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct DateFormats {
     pub full: String,
     pub long: String,
@@ -75,7 +75,7 @@ pub struct DateFormats {
     pub short: String,
 }
 
-#[derive(Encode, Decode, Clone)]
+#[derive(Encode, Decode)]
 pub struct TimeFormats {
     pub full: String,
     pub long: String,
@@ -83,11 +83,9 @@ pub struct TimeFormats {
     pub short: String,
 }
 
-impl Default for Locale {
+pub fn get_default_locale() -> &'static Locale {
-    fn default() -> Self {
+    #[allow(clippy::unwrap_used)]
-        #[allow(clippy::unwrap_used)]
+    get_locale("en").unwrap()
-        get_locale("en").unwrap().clone()
-    }
 }
 
 static LOCALES: OnceLock<HashMap<String, Locale>> = OnceLock::new();
@@ -104,7 +102,7 @@ pub fn get_supported_locales() -> Vec<String> {
     get_locales().keys().cloned().collect()
 }
 
-pub fn get_locale(id: &str) -> Result<&Locale, String> {
+pub fn get_locale(id: &str) -> Result<&'static Locale, String> {
     get_locales()
         .get(id)
         .ok_or_else(|| format!("Invalid locale: '{id}'"))

base/src/model.rs

@@ -24,7 +24,7 @@ use crate::{
     },
     functions::util::compare_values,
     implicit_intersection::implicit_intersection,
-    language::{get_language, Language},
+    language::{get_default_language, get_language, Language},
     locale::{get_locale, Locale},
     types::*,
     utils as common,
@@ -95,7 +95,7 @@ pub(crate) enum ParsedDefinedName {
 /// * A list of cells with its status (evaluating, evaluated, not evaluated)
 /// * A dictionary with the shared strings and their indices.
 ///   This is an optimization for large files (~1 million rows)
-pub struct Model {
+pub struct Model<'a> {
     /// A Rust internal representation of an Excel workbook
     pub workbook: Workbook,
     /// A list of parsed formulas
@@ -105,13 +105,13 @@ pub struct Model {
     /// An optimization to lookup strings faster
     pub(crate) shared_strings: HashMap<String, usize>,
     /// An instance of the parser
-    pub(crate) parser: Parser,
+    pub(crate) parser: Parser<'a>,
     /// The list of cells with formulas that are evaluated or being evaluated
     pub(crate) cells: HashMap<(u32, i32, i32), CellState>,
     /// The locale of the model
-    pub(crate) locale: Locale,
+    pub(crate) locale: &'a Locale,
     /// The language used
-    pub(crate) language: Language,
+    pub(crate) language: &'a Language,
     /// The timezone used to evaluate the model
     pub(crate) tz: Tz,
     /// The view id. A view consists of a selected sheet and ranges.
@@ -129,7 +129,7 @@ pub struct CellIndex {
     pub column: i32,
 }
 
-impl Model {
+impl<'a> Model<'a> {
     pub(crate) fn evaluate_node_with_reference(
         &mut self,
         node: &Node,
@@ -721,7 +721,7 @@ impl Model {
             BooleanCell { v, .. } => CalcResult::Boolean(*v),
             NumberCell { v, .. } => CalcResult::Number(*v),
             ErrorCell { ei, .. } => {
-                let message = ei.to_localized_error_string(&self.language);
+                let message = ei.to_localized_error_string(self.language);
                 CalcResult::new_error(ei.clone(), cell_reference, message)
             }
             SharedString { si, .. } => {
@@ -747,7 +747,7 @@ impl Model {
                     CalcResult::Error {
                         error: ei.clone(),
                         origin: cell_reference,
-                        message: ei.to_localized_error_string(&self.language),
+                        message: ei.to_localized_error_string(self.language),
                     }
                 }
             }
@@ -852,7 +852,7 @@ impl Model {
     ///
     /// See also:
     /// * [Model::to_bytes]
-    pub fn from_bytes(s: &[u8], language_id: &str) -> Result<Model, String> {
+    pub fn from_bytes(s: &[u8], language_id: &'a str) -> Result<Model<'a>, String> {
         let workbook: Workbook =
             bitcode::decode(s).map_err(|e| format!("Error parsing workbook: {e}"))?;
         Model::from_workbook(workbook, language_id)
@@ -876,7 +876,7 @@ impl Model {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn from_workbook(workbook: Workbook, language_id: &str) -> Result<Model, String> {
+    pub fn from_workbook(workbook: Workbook, language_id: &str) -> Result<Model<'_>, String> {
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
 
@@ -894,9 +894,8 @@ impl Model {
         // }
 
         let cells = HashMap::new();
-        let locale = get_locale(&workbook.settings.locale)
+        let locale =
-            .map_err(|_| "Invalid locale".to_string())?
+            get_locale(&workbook.settings.locale).map_err(|_| "Invalid locale".to_string())?;
-            .clone();
         let tz: Tz = workbook
             .settings
             .tz
@@ -904,15 +903,15 @@ impl Model {
             .map_err(|_| format!("Invalid timezone: {}", workbook.settings.tz))?;
 
         let language = match get_language(language_id) {
-            Ok(lang) => lang.clone(),
+            Ok(lang) => lang,
             Err(_) => return Err("Invalid language".to_string()),
         };
         let parser = Parser::new(
             worksheet_names,
             defined_names,
             workbook.tables.clone(),
-            &locale,
+            locale,
-            &language,
+            language,
         );
         let mut shared_strings = HashMap::new();
         for (index, s) in workbook.shared_strings.iter().enumerate() {
@@ -1068,8 +1067,8 @@ impl Model {
                     row_delta: target.row - source.row,
                     column_delta: target.column - source.column,
                 },
-                &self.locale,
+                self.locale,
-                &self.language,
+                self.language,
             );
             Ok(format!("={formula_str}"))
         } else {
@@ -1108,7 +1107,7 @@ impl Model {
         let cell = self.workbook.worksheet(sheet)?.cell(row, column);
         let result = match cell {
             Some(cell) => match cell.get_formula() {
-                None => cell.get_localized_text(&self.workbook.shared_strings, &self.language),
+                None => cell.get_localized_text(&self.workbook.shared_strings, self.language),
                 Some(i) => {
                     let formula = &self.parsed_formulas[sheet as usize][i as usize];
                     let cell_ref = CellReferenceRC {
@@ -1118,7 +1117,7 @@ impl Model {
                     };
                     format!(
                         "={}",
-                        to_localized_string(formula, &cell_ref, &self.locale, &self.language)
+                        to_localized_string(formula, &cell_ref, self.locale, self.language)
                     )
                 }
             },
@@ -1179,7 +1178,7 @@ impl Model {
             };
             return Ok(format!(
                 "={}",
-                to_localized_string(formula, &cell_reference, &self.locale, &self.language)
+                to_localized_string(formula, &cell_reference, self.locale, self.language)
             ));
         };
         Ok(value.to_string())
@@ -1227,7 +1226,7 @@ impl Model {
                     };
                     Ok(Some(format!(
                         "={}",
-                        to_localized_string(formula, &cell_ref, &self.locale, &self.language)
+                        to_localized_string(formula, &cell_ref, self.locale, self.language)
                     )))
                 }
                 None => Ok(None),
@@ -1261,10 +1260,10 @@ impl Model {
                         row,
                         column,
                     };
-                    let language_en = Language::default();
+                    let language_en = get_default_language();
                     Ok(Some(format!(
                         "={}",
-                        to_localized_string(formula, &cell_ref, &self.locale, &language_en)
+                        to_localized_string(formula, &cell_ref, self.locale, language_en)
                     )))
                 }
                 None => Ok(None),
@@ -1306,7 +1305,7 @@ impl Model {
     ) -> Result<(), String> {
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         let new_style_index;
-        if common::value_needs_quoting(value, &self.language) {
+        if common::value_needs_quoting(value, self.language) {
             new_style_index = self
                 .workbook
                 .styles
@@ -1497,7 +1496,7 @@ impl Model {
         let style_index = self.get_cell_style_index(sheet, row, column)?;
         if let Some(new_value) = value.strip_prefix('\'') {
             // First check if it needs quoting
-            let new_style = if common::value_needs_quoting(new_value, &self.language) {
+            let new_style = if common::value_needs_quoting(new_value, self.language) {
                 self.workbook
                     .styles
                     .get_style_with_quote_prefix(style_index)?
@@ -1570,7 +1569,7 @@ impl Model {
                 // Check is it is error value
                 let upper = value.to_uppercase();
                 let worksheet = self.workbook.worksheet_mut(sheet)?;
-                match get_error_by_name(&upper, &self.language) {
+                match get_error_by_name(&upper, self.language) {
                     Some(error) => {
                         worksheet.set_cell_with_error(row, column, error, new_style_index)?;
                     }
@@ -1749,7 +1748,7 @@ impl Model {
             .cell(row, column)
             .cloned()
             .unwrap_or_default();
-        let cell_value = cell.value(&self.workbook.shared_strings, &self.language);
+        let cell_value = cell.value(&self.workbook.shared_strings, self.language);
         Ok(cell_value)
     }
 
@@ -1783,8 +1782,8 @@ impl Model {
             Some(cell) => {
                 let format = self.get_style_for_cell(sheet_index, row, column)?.num_fmt;
                 let formatted_value =
-                    cell.formatted_value(&self.workbook.shared_strings, &self.language, |value| {
+                    cell.formatted_value(&self.workbook.shared_strings, self.language, |value| {
-                        format_number(value, &format, &self.locale).text
+                        format_number(value, &format, self.locale).text
                     });
                 Ok(formatted_value)
             }
@@ -1825,10 +1824,10 @@ impl Model {
                 };
                 Ok(format!(
                     "={}",
-                    to_localized_string(formula, &cell_ref, &self.locale, &self.language)
+                    to_localized_string(formula, &cell_ref, self.locale, self.language)
                 ))
             }
-            None => Ok(cell.get_localized_text(&self.workbook.shared_strings, &self.language)),
+            None => Ok(cell.get_localized_text(&self.workbook.shared_strings, self.language)),
         }
     }
 
@@ -2156,12 +2155,9 @@ impl Model {
         }
 
         // Make sure the formula is valid
-        match common::ParsedReference::parse_reference_formula(
+        match common::ParsedReference::parse_reference_formula(None, formula, self.locale, |name| {
-            None,
+            self.get_sheet_index_by_name(name)
-            formula,
+        }) {
-            &self.locale,
-            |name| self.get_sheet_index_by_name(name),
-        ) {
             Ok(_) => {}
             Err(_) => {
                 return Err("Formula: Invalid defined name formula".to_string());
@@ -2350,10 +2346,10 @@ impl Model {
     /// Sets the locale of the model
     pub fn set_locale(&mut self, locale_id: &str) -> Result<(), String> {
         let locale = match get_locale(locale_id) {
-            Ok(l) => l.clone(),
+            Ok(l) => l,
             Err(_) => return Err(format!("Invalid locale: {locale_id}")),
         };
-        self.parser.set_locale(&locale);
+        self.parser.set_locale(locale);
         self.locale = locale;
         self.workbook.settings.locale = locale_id.to_string();
         self.evaluate();
@@ -2375,10 +2371,10 @@ impl Model {
     /// Sets the language
     pub fn set_language(&mut self, language_id: &str) -> Result<(), String> {
         let language = match get_language(language_id) {
-            Ok(l) => l.clone(),
+            Ok(l) => l,
             Err(_) => return Err(format!("Invalid language: {language_id}")),
         };
-        self.parser.set_language(&language);
+        self.parser.set_language(language);
         self.language = language;
         Ok(())
     }

base/src/new_empty.rs

@@ -8,13 +8,14 @@ use crate::{
     expressions::{
         lexer::LexerMode,
         parser::{
-            Parser, stringify::{rename_sheet_in_node, to_localized_string, to_rc_format}
+            stringify::{rename_sheet_in_node, to_localized_string, to_rc_format},
+            Parser,
         },
         types::CellReferenceRC,
     },
-    language::{Language, get_language},
+    language::{get_default_language, get_language},
-    locale::{Locale, get_locale},
+    locale::{get_default_locale, get_locale},
-    model::{Model, ParsedDefinedName, get_milliseconds_since_epoch},
+    model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
     types::{
         DefinedName, Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet,
         WorksheetView,
@@ -36,7 +37,7 @@ fn is_valid_sheet_name(name: &str) -> bool {
     !name.is_empty() && name.chars().count() <= 31 && !name.contains(&invalid[..])
 }
 
-impl Model {
+impl<'a> Model<'a> {
     /// Creates a new worksheet. Note that it does not check if the name or the sheet_id exists
     fn new_empty_worksheet(name: &str, sheet_id: u32, view_ids: &[&u32]) -> Worksheet {
         let mut views = HashMap::new();
@@ -83,11 +84,11 @@ impl Model {
     // This function parses all the internal formulas in all the worksheets
     // (in the default language ("en") and locale ("en") and the RC format)
     pub(crate) fn parse_formulas(&mut self) {
-        let locale = self.locale.clone();
+        let locale = self.locale;
-        let language = self.language.clone();
+        let language = self.language;
 
-        self.parser.set_locale(&Locale::default());
+        self.parser.set_locale(get_default_locale());
-        self.parser.set_language(&Language::default());
+        self.parser.set_language(get_default_language());
         self.parser.set_lexer_mode(LexerMode::R1C1);
         let worksheets = &self.workbook.worksheets;
         for worksheet in worksheets {
@@ -105,8 +106,8 @@ impl Model {
             self.parsed_formulas.push(parse_formula);
         }
         self.parser.set_lexer_mode(LexerMode::A1);
-        self.parser.set_locale(&locale);
+        self.parser.set_locale(locale);
-        self.parser.set_language(&language);
+        self.parser.set_language(language);
     }
 
     pub(crate) fn parse_defined_names(&mut self) {
@@ -116,7 +117,7 @@ impl Model {
                 ParsedReference::parse_reference_formula(
                     None,
                     &defined_name.formula,
-                    &self.locale,
+                    self.locale,
                     |name| self.get_sheet_index_by_name(name),
                 ) {
                 match reference {
@@ -298,7 +299,7 @@ impl Model {
         for defined_name in &mut self.workbook.defined_names {
             let mut t = self.parser.parse(&defined_name.formula, cell_reference);
             rename_sheet_in_node(&mut t, sheet_index, new_name);
-            let formula = to_localized_string(&t, cell_reference, &self.locale, &self.language);
+            let formula = to_localized_string(&t, cell_reference, self.locale, self.language);
             defined_names.push(DefinedName {
                 name: defined_name.name.clone(),
                 formula,
@@ -364,21 +365,21 @@ impl Model {
 
     /// Creates a new workbook with one empty sheet
     pub fn new_empty(
-        name: &str,
+        name: &'a str,
-        locale_id: &str,
+        locale_id: &'a str,
-        timezone: &str,
+        timezone: &'a str,
-        language_id: &str,
+        language_id: &'a str,
-    ) -> Result<Model, String> {
+    ) -> Result<Model<'a>, String> {
         let tz: Tz = match &timezone.parse() {
             Ok(tz) => *tz,
             Err(_) => return Err(format!("Invalid timezone: {}", &timezone)),
         };
         let locale = match get_locale(locale_id) {
-            Ok(l) => l.clone(),
+            Ok(l) => l,
             Err(_) => return Err(format!("Invalid locale: {locale_id}")),
         };
         let language = match get_language(language_id) {
-            Ok(l) => l.clone(),
+            Ok(l) => l,
             Err(_) => return Err(format!("Invalid language: {language_id}")),
         };
 
@@ -426,7 +427,7 @@ impl Model {
         let parsed_formulas = Vec::new();
         let worksheets = &workbook.worksheets;
         let worksheet_names = worksheets.iter().map(|s| s.get_name()).collect();
-        let parser = Parser::new(worksheet_names, vec![], HashMap::new(), &locale, &language);
+        let parser = Parser::new(worksheet_names, vec![], HashMap::new(), locale, language);
         let cells = HashMap::new();
 
         let mut model = Model {

base/src/styles.rs

@@ -213,7 +213,7 @@ impl Styles {
 }
 
 // TODO: Try to find a better spot for styles setters
-impl Model {
+impl<'a> Model<'a> {
     pub fn set_cell_style(
         &mut self,
         sheet: u32,

base/src/test/test_fn_time.rs

@@ -23,7 +23,7 @@ const TIME_2_AM: &str = "0.083333333"; // 2:00 AM = 2/24 ≈ 0.083333333
 const TIME_00_00_01: &str = "0.000011574"; // 1 second = 1/86400 ≈ 0.000011574
 
 /// Helper function to set up and evaluate a model with time expressions
-fn test_time_expressions(expressions: &[(&str, &str)]) -> crate::model::Model {
+fn test_time_expressions<'a>(expressions: &[(&str, &str)]) -> crate::model::Model<'a> {
     let mut model = new_empty_model();
     for (cell, formula) in expressions {
         model._set(cell, formula);

base/src/test/test_language.rs

@@ -2,7 +2,7 @@
 
 use crate::{test::util::new_empty_model, Model};
 
-pub fn new_german_empty_model() -> Model {
+pub fn new_german_empty_model<'a>() -> Model<'a> {
     Model::new_empty("model", "en", "UTC", "de").unwrap()
 }
 

base/src/test/test_locale.rs

@@ -2,7 +2,7 @@
 
 use crate::Model;
 
-pub fn new_empty_model() -> Model {
+pub fn new_empty_model<'a>() -> Model<'a> {
     Model::new_empty("model", "de", "UTC", "de").unwrap()
 }
 

base/src/test/user_model/test_to_from_bytes.rs

@@ -33,7 +33,9 @@ fn errors() {
 fn language() {
     let mut model = UserModel::from_model(new_empty_model());
     model.set_user_input(0, 1, 1, "=NOW()").unwrap();
-    model.set_user_input(0, 1, 2, "=SUM(1.234, 3.4, T1:T3, {1,2.4,3})").unwrap();
+    model
+        .set_user_input(0, 1, 2, "=SUM(1.234, 3.4, T1:T3, {1,2.4,3})")
+        .unwrap();
     model.set_language("fr").unwrap();
     model.set_locale("fr").unwrap();
     let model_bytes = model.to_bytes();
@@ -41,7 +43,10 @@ fn language() {
     let model2 = UserModel::from_bytes(&model_bytes, "es").unwrap();
     // Check that the formula has been localized to Spanish
     assert_eq!(model2.get_cell_content(0, 1, 1), Ok("=AHORA()".to_string()));
-    assert_eq!(model2.get_cell_content(0, 1, 2), Ok("=SUMA(1,234;3,4;T1:T3;{1;2,4;3})".to_string()));
+    assert_eq!(
+        model2.get_cell_content(0, 1, 2),
+        Ok("=SUMA(1,234;3,4;T1:T3;{1;2,4;3})".to_string())
+    );
 }
 
 #[test]
@@ -52,5 +57,8 @@ fn formulatext_english() {
 
     model.set_language("de").unwrap();
 
-    assert_eq!(model.get_formatted_cell_value(0, 1, 2), Ok("=SUM(1,2,3)".to_string()));
+    assert_eq!(
-}
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("=SUM(1,2,3)".to_string())
+    );
+}

base/src/test/user_model/util.rs

@@ -2,11 +2,11 @@
 
 use crate::{expressions::types::Area, types::Border, BorderArea, UserModel};
 
-pub fn new_empty_user_model() -> UserModel {
+pub fn new_empty_user_model<'a>() -> UserModel<'a> {
     UserModel::new_empty("model", "en", "UTC", "en").unwrap()
 }
 
-impl UserModel {
+impl<'a> UserModel<'a> {
     pub fn _set_cell_border(&mut self, cell: &str, color: &str) {
         let cell_reference = self.model._parse_reference(cell);
         let column = cell_reference.column;

base/src/test/util.rs

@@ -4,11 +4,11 @@ use crate::expressions::types::CellReferenceIndex;
 use crate::model::Model;
 use crate::types::Cell;
 
-pub fn new_empty_model() -> Model {
+pub fn new_empty_model<'a>() -> Model<'a> {
     Model::new_empty("model", "en", "UTC", "en").unwrap()
 }
 
-impl Model {
+impl<'a> Model<'a> {
     pub fn _parse_reference(&self, cell: &str) -> CellReferenceIndex {
         if cell.contains('!') {
             self.parse_reference(cell).unwrap()

base/src/units.rs

@@ -88,7 +88,7 @@ fn get_units_from_format_string(num_fmt: &str) -> Option<Units> {
     }
 }
 
-impl Model {
+impl<'a> Model<'a> {
     fn compute_cell_units(&self, cell_reference: &CellReferenceIndex) -> Option<Units> {
         let cell_style_res = &self.get_style_for_cell(
             cell_reference.sheet,

base/src/user_model/border.rs

@@ -7,7 +7,7 @@ use super::{
     border_utils::is_max_border, common::BorderType, history::Diff, BorderArea, UserModel,
 };
 
-impl UserModel {
+impl<'a> UserModel<'a> {
     fn update_single_cell_border(
         &mut self,
         border_area: &BorderArea,

base/src/user_model/common.rs

@@ -218,20 +218,20 @@ fn update_style(old_value: &Style, style_path: &str, value: &str) -> Result<Styl
 /// # Ok(())
 /// # }
 /// ```
-pub struct UserModel {
+pub struct UserModel<'a> {
-    pub(crate) model: Model,
+    pub(crate) model: Model<'a>,
     history: History,
     send_queue: Vec<QueueDiffs>,
     pause_evaluation: bool,
 }
 
-impl Debug for UserModel {
+impl<'a> Debug for UserModel<'a> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("UserModel").finish()
     }
 }
 
-impl UserModel {
+impl<'a> UserModel<'a> {
     /// Creates a user model from an existing model
     pub fn from_model(model: Model) -> UserModel {
         UserModel {
@@ -247,11 +247,11 @@ impl UserModel {
     /// See also:
     /// * [Model::new_empty]
     pub fn new_empty(
-        name: &str,
+        name: &'a str,
-        locale_id: &str,
+        locale_id: &'a str,
-        timezone: &str,
+        timezone: &'a str,
-        language_id: &str,
+        language_id: &'a str,
-    ) -> Result<UserModel, String> {
+    ) -> Result<UserModel<'a>, String> {
         let model = Model::new_empty(name, locale_id, timezone, language_id)?;
         Ok(UserModel {
             model,
@@ -265,7 +265,7 @@ impl UserModel {
     ///
     /// See also:
     /// * [Model::from_bytes]
-    pub fn from_bytes(s: &[u8], language_id: &str) -> Result<UserModel, String> {
+    pub fn from_bytes(s: &[u8], language_id: &'a str) -> Result<UserModel<'a>, String> {
         let model = Model::from_bytes(s, language_id)?;
         Ok(UserModel {
             model,
@@ -284,7 +284,7 @@ impl UserModel {
     }
 
     /// Returns the internal model
-    pub fn get_model(&self) -> &Model {
+    pub fn get_model(&self) -> &Model<'_> {
         &self.model
     }
 

base/src/user_model/ui.rs

@@ -21,7 +21,7 @@ pub struct SelectedView {
     pub left_column: i32,
 }
 
-impl UserModel {
+impl<'a> UserModel<'a> {
     /// Returns the selected sheet index
     pub fn get_selected_sheet(&self) -> u32 {
         if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {

bindings/nodejs/src/model.rs

@@ -28,17 +28,24 @@ fn to_node_error(error: XlsxError) -> Error {
   Error::new(Status::Unknown, error.to_string())
 }
 
+fn leak_str(s: &str) -> &'static str {
+  Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[napi]
 pub struct Model {
-  model: BaseModel,
+  model: BaseModel<'static>,
 }
 
 #[napi]
 impl Model {
   #[napi(constructor)]
   pub fn new(name: String, locale: String, timezone: String, language_id: String) -> Result<Self> {
-    let model =
+    let name = leak_str(&name);
-      BaseModel::new_empty(&name, &locale, &timezone, &language_id).map_err(to_js_error)?;
+    let locale = leak_str(&locale);
+    let timezone = leak_str(&timezone);
+    let language_id = leak_str(&language_id);
+    let model = BaseModel::new_empty(name, locale, timezone, language_id).map_err(to_js_error)?;
     Ok(Self { model })
   }
 
@@ -49,14 +56,16 @@ impl Model {
     tz: String,
     language_id: String,
   ) -> Result<Model> {
-    let model = load_from_xlsx(&file_path, &locale, &tz, &language_id)
+    let language_id = leak_str(&language_id);
+    let model = load_from_xlsx(&file_path, &locale, &tz, language_id)
       .map_err(|error| Error::new(Status::Unknown, error.to_string()))?;
     Ok(Self { model })
   }
 
   #[napi(factory)]
   pub fn from_icalc(file_name: String, language_id: String) -> Result<Model> {
-    let model = load_from_icalc(&file_name, &language_id)
+    let language_id = leak_str(&language_id);
+    let model = load_from_icalc(&file_name, language_id)
       .map_err(|error| Error::new(Status::Unknown, error.to_string()))?;
     Ok(Self { model })
   }

bindings/nodejs/src/user_model.rs

@@ -21,23 +21,31 @@ fn to_js_error(error: String) -> Error {
   Error::new(Status::Unknown, error)
 }
 
+fn leak_str(s: &str) -> &'static str {
+  Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[napi]
 pub struct UserModel {
-  model: BaseModel,
+  model: BaseModel<'static>,
 }
 
 #[napi]
 impl UserModel {
   #[napi(constructor)]
   pub fn new(name: String, locale: String, timezone: String, language_id: String) -> Result<Self> {
-    let model =
+    let name = leak_str(&name);
-      BaseModel::new_empty(&name, &locale, &timezone, &language_id).map_err(to_js_error)?;
+    let locale = leak_str(&locale);
+    let timezone = leak_str(&timezone);
+    let language_id = leak_str(&language_id);
+    let model = BaseModel::new_empty(name, locale, timezone, language_id).map_err(to_js_error)?;
     Ok(Self { model })
   }
 
   #[napi(factory)]
   pub fn from_bytes(bytes: &[u8], language_id: String) -> Result<UserModel> {
-    let model = BaseModel::from_bytes(bytes, &language_id).map_err(to_js_error)?;
+    let language_id = leak_str(&language_id);
+    let model = BaseModel::from_bytes(bytes, language_id).map_err(to_js_error)?;
     Ok(UserModel { model })
   }
 

bindings/python/src/lib.rs

@@ -12,10 +12,14 @@ mod types;
 
 create_exception!(_ironcalc, WorkbookError, PyException);
 
+fn leak_str(s: &str) -> &'static str {
+    Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[pyclass]
 pub struct PyUserModel {
     /// The user model, which is a wrapper around the Model
-    pub model: UserModel,
+    pub model: UserModel<'static>,
 }
 
 #[pymethods]
@@ -87,7 +91,7 @@ impl PyUserModel {
 /// This is a model implementing the 'raw' API
 #[pyclass]
 pub struct PyModel {
-    model: Model,
+    model: Model<'static>,
 }
 
 #[pymethods]
@@ -335,6 +339,10 @@ pub fn load_from_xlsx(
     tz: &str,
     language_id: &str,
 ) -> PyResult<PyModel> {
+    // let locale = leak_str(locale);
+    // let tz = leak_str(tz);
+    let language_id = leak_str(language_id);
+
     let model = import::load_from_xlsx(file_path, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -343,6 +351,7 @@ pub fn load_from_xlsx(
 /// Loads a function from icalc binary representation
 #[pyfunction]
 pub fn load_from_icalc(file_name: &str, language_id: &str) -> PyResult<PyModel> {
+    let language_id = leak_str(language_id);
     let model = import::load_from_icalc(file_name, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -355,6 +364,7 @@ pub fn load_from_icalc(file_name: &str, language_id: &str) -> PyResult<PyModel>
 pub fn load_from_bytes(bytes: &[u8], language_id: &str) -> PyResult<PyModel> {
     let workbook: Workbook =
         bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
+    let language_id = leak_str(language_id);
     let model = Model::from_workbook(workbook, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -363,6 +373,10 @@ pub fn load_from_bytes(bytes: &[u8], language_id: &str) -> PyResult<PyModel> {
 /// Creates an empty model in the raw API
 #[pyfunction]
 pub fn create(name: &str, locale: &str, tz: &str, language_id: &str) -> PyResult<PyModel> {
+    let name = leak_str(name);
+    let locale = leak_str(locale);
+    let tz = leak_str(tz);
+    let language_id = leak_str(language_id);
     let model = Model::new_empty(name, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyModel { model })
@@ -376,6 +390,10 @@ pub fn create_user_model(
     tz: &str,
     language_id: &str,
 ) -> PyResult<PyUserModel> {
+    let name = leak_str(name);
+    let locale = leak_str(locale);
+    let tz = leak_str(tz);
+    let language_id = leak_str(language_id);
     let model = UserModel::new_empty(name, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     Ok(PyUserModel { model })
@@ -389,6 +407,7 @@ pub fn create_user_model_from_xlsx(
     tz: &str,
     language_id: &str,
 ) -> PyResult<PyUserModel> {
+    let language_id = leak_str(language_id);
     let model = import::load_from_xlsx(file_path, locale, tz, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     let model = UserModel::from_model(model);
@@ -398,6 +417,7 @@ pub fn create_user_model_from_xlsx(
 /// Creates a user model from an icalc file
 #[pyfunction]
 pub fn create_user_model_from_icalc(file_name: &str, language_id: &str) -> PyResult<PyUserModel> {
+    let language_id = leak_str(language_id);
     let model = import::load_from_icalc(file_name, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     let model = UserModel::from_model(model);
@@ -411,6 +431,7 @@ pub fn create_user_model_from_icalc(file_name: &str, language_id: &str) -> PyRes
 pub fn create_user_model_from_bytes(bytes: &[u8], language_id: &str) -> PyResult<PyUserModel> {
     let workbook: Workbook =
         bitcode::decode(bytes).map_err(|e| WorkbookError::new_err(e.to_string()))?;
+    let language_id = leak_str(language_id);
     let model = Model::from_workbook(workbook, language_id)
         .map_err(|e| WorkbookError::new_err(e.to_string()))?;
     let user_model = UserModel::from_model(model);

bindings/wasm/src/lib.rs

@@ -59,9 +59,13 @@ struct DefinedName {
     formula: String,
 }
 
+fn leak_str(s: &str) -> &'static str {
+    Box::leak(s.to_owned().into_boxed_str())
+}
+
 #[wasm_bindgen]
 pub struct Model {
-    model: BaseModel,
+    model: BaseModel<'static>,
 }
 
 #[wasm_bindgen]
@@ -73,12 +77,17 @@ impl Model {
         timezone: &str,
         language_id: &str,
     ) -> Result<Model, JsError> {
+        let name = leak_str(name);
+        let locale = leak_str(locale);
+        let timezone = leak_str(timezone);
+        let language_id = leak_str(language_id);
         let model =
             BaseModel::new_empty(name, locale, timezone, language_id).map_err(to_js_error)?;
         Ok(Model { model })
     }
 
     pub fn from_bytes(bytes: &[u8], language_id: &str) -> Result<Model, JsError> {
+        let language_id = leak_str(language_id);
         let model = BaseModel::from_bytes(bytes, language_id).map_err(to_js_error)?;
         Ok(Model { model })
     }

webapp/IronCalc/src/components/SheetTabBar/SheetTabBar.tsx

@@ -1,3 +1,4 @@
+import type { Model } from "@ironcalc/wasm";
 import { styled, Tooltip } from "@mui/material";
 import { EllipsisVertical, Menu, Plus } from "lucide-react";
 import { useState } from "react";
@@ -11,7 +12,6 @@ import type { WorkbookState } from "../workbookState";
 import SheetListMenu from "./SheetListMenu";
 import SheetTab from "./SheetTab";
 import type { SheetOptions } from "./types";
-import { Model } from "@ironcalc/wasm";
 
 export interface SheetTabBarProps {
   sheets: SheetOptions[];
@@ -131,7 +131,7 @@ function SheetTabBar(props: SheetTabBarProps) {
         open={workbookSettingsOpen}
         onClose={() => setWorkbookSettingsOpen(false)}
         initialLocale={props.model.getLocale()}
-        initialTimezone={ props.model.getTimezone()}
+        initialTimezone={props.model.getTimezone()}
         initialLanguage={props.model.getLanguage()}
         onSave={(locale: string, timezone: string, language: string) => {
           props.onSettingsChange(locale, timezone, language);

webapp/app.ironcalc.com/frontend/src/components/storage.ts

@@ -139,8 +139,7 @@ export function saveSelectedModelInStorage(model: Model) {
       modelsJson = "{}";
     }
     const models: ModelsMetadata = JSON.parse(modelsJson);
-    models[uuid].language = model.getLanguage(),
+    models[uuid].language = model.getLanguage();
-      
     localStorage.setItem("models", JSON.stringify(models));
   }
 }

xlsx/src/export/test/test_export.rs

@@ -7,7 +7,7 @@ use crate::export::save_to_icalc;
 use crate::import::load_from_icalc;
 use crate::{export::save_to_xlsx, import::load_from_xlsx};
 
-pub fn new_empty_model() -> Model {
+pub fn new_empty_model<'a>() -> Model<'a> {
     Model::new_empty("model", "en", "UTC", "en").unwrap()
 }
 

xlsx/src/import/mod.rs

@@ -140,18 +140,18 @@ pub fn load_from_xlsx_bytes(
 }
 
 /// Loads a [Model] from an xlsx file
-pub fn load_from_xlsx(
+pub fn load_from_xlsx<'a>(
     file_name: &str,
     locale: &str,
     tz: &str,
-    language: &str,
+    language: &'a str,
-) -> Result<Model, XlsxError> {
+) -> Result<Model<'a>, XlsxError> {
     let workbook = load_from_excel(file_name, locale, tz)?;
     Model::from_workbook(workbook, language).map_err(XlsxError::Workbook)
 }
 
 /// Loads a [Model] from an `ic` file (a file in the IronCalc internal representation)
-pub fn load_from_icalc(file_name: &str, language_id: &str) -> Result<Model, XlsxError> {
+pub fn load_from_icalc<'a>(file_name: &str, language_id: &'a str) -> Result<Model<'a>, XlsxError> {
     let contents = fs::read(file_name)
         .map_err(|e| XlsxError::IO(format!("Could not extract workbook name: {e}")))?;
     let workbook: Workbook = bitcode::decode(&contents)