diff --git a/src/bin/lpython.cpp b/src/bin/lpython.cpp
index 6e036657c8..5b26125494 100644
--- a/src/bin/lpython.cpp
+++ b/src/bin/lpython.cpp
@@ -1106,7 +1106,7 @@ int compile_python_using_llvm(
 
         e.add_module(std::move(m));
         if (call_stmts) {
-            e.voidfn("__module___main_____main__global_stmts");
+            e.execfn<void>("__module___main_____main__global_stmts");
         }
 
         if (compiler_options.enable_cpython) {
diff --git a/src/libasr/codegen/evaluator.cpp b/src/libasr/codegen/evaluator.cpp
index 12f022100a..d96e729da7 100644
--- a/src/libasr/codegen/evaluator.cpp
+++ b/src/libasr/codegen/evaluator.cpp
@@ -275,72 +275,6 @@ intptr_t LLVMEvaluator::get_symbol_address(const std::string &name) {
     return (intptr_t)cantFail(std::move(addr0));
 }
 
-char *LLVMEvaluator::strfn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    char *(*f)() = (char *(*)())addr;
-    return f();
-}
-
-int8_t LLVMEvaluator::int8fn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    int8_t (*f)() = (int8_t (*)())addr;
-    return f();
-}
-
-int16_t LLVMEvaluator::int16fn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    int16_t (*f)() = (int16_t (*)())addr;
-    return f();
-}
-
-int32_t LLVMEvaluator::int32fn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    int32_t (*f)() = (int32_t (*)())addr;
-    return f();
-}
-
-int64_t LLVMEvaluator::int64fn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    int64_t (*f)() = (int64_t (*)())addr;
-    return f();
-}
-
-bool LLVMEvaluator::boolfn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    bool (*f)() = (bool (*)())addr;
-    return f();
-}
-
-float LLVMEvaluator::floatfn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    float (*f)() = (float (*)())addr;
-    return f();
-}
-
-double LLVMEvaluator::doublefn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    double (*f)() = (double (*)())addr;
-    return f();
-}
-
-std::complex<float> LLVMEvaluator::complex4fn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    std::complex<float> (*f)() = (std::complex<float> (*)())addr;
-    return f();
-}
-
-std::complex<double> LLVMEvaluator::complex8fn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    std::complex<double> (*f)() = (std::complex<double> (*)())addr;
-    return f();
-}
-
-void LLVMEvaluator::voidfn(const std::string &name) {
-    intptr_t addr = get_symbol_address(name);
-    void (*f)() = (void (*)())addr;
-    f();
-}
-
 void write_file(const std::string &filename, const std::string &contents)
 {
     std::ofstream out;
diff --git a/src/libasr/codegen/evaluator.h b/src/libasr/codegen/evaluator.h
index 65fc053527..9fc9981d16 100644
--- a/src/libasr/codegen/evaluator.h
+++ b/src/libasr/codegen/evaluator.h
@@ -52,17 +52,6 @@ class LLVMEvaluator
     void add_module(std::unique_ptr<llvm::Module> mod);
     void add_module(std::unique_ptr<LLVMModule> m);
     intptr_t get_symbol_address(const std::string &name);
-    char *strfn(const std::string &name);
-    int8_t int8fn(const std::string &name);
-    int16_t int16fn(const std::string &name);
-    int32_t int32fn(const std::string &name);
-    int64_t int64fn(const std::string &name);
-    bool boolfn(const std::string &name);
-    float floatfn(const std::string &name);
-    double doublefn(const std::string &name);
-    std::complex<float> complex4fn(const std::string &name);
-    std::complex<double> complex8fn(const std::string &name);
-    void voidfn(const std::string &name);
     std::string get_asm(llvm::Module &m);
     void save_asm_file(llvm::Module &m, const std::string &filename);
     void save_object_file(llvm::Module &m, const std::string &filename);
@@ -73,6 +62,13 @@ class LLVMEvaluator
     llvm::LLVMContext &get_context();
     static void print_targets();
     static std::string get_default_target_triple();
+
+    template<class T>
+    T execfn(const std::string &name) {
+        intptr_t addr = get_symbol_address(name);
+        T (*f)() = (T (*)())addr;
+        return f();
+    }
 };
 
 
diff --git a/src/lpython/python_evaluator.cpp b/src/lpython/python_evaluator.cpp
index 19661c47c9..b5aad743c1 100644
--- a/src/lpython/python_evaluator.cpp
+++ b/src/lpython/python_evaluator.cpp
@@ -132,7 +132,7 @@ Result<PythonCompiler::EvalResult> PythonCompiler::evaluate(
                                     ->m_symtab->get_symbol(run_fn);
             LCOMPILERS_ASSERT(fn)
             if (ASRUtils::get_FunctionType(fn)->m_return_var_type->type == ASR::ttypeType::Character) {
-                char *r = e->strfn(run_fn);
+                char *r = e->execfn<char*>(run_fn);
                 result.type = EvalResult::string;
                 result.str = r;
             } else {
@@ -143,11 +143,11 @@ Result<PythonCompiler::EvalResult> PythonCompiler::evaluate(
                                     ->m_symtab->get_symbol(run_fn);
             LCOMPILERS_ASSERT(fn)
             if (ASRUtils::get_FunctionType(fn)->m_return_var_type->type == ASR::ttypeType::UnsignedInteger) {
-                uint8_t r = e->int8fn(run_fn);
+                uint8_t r = e->execfn<uint8_t>(run_fn);
                 result.type = EvalResult::unsignedInteger1;
                 result.u32 = r;
             } else {
-                int8_t r = e->int8fn(run_fn);
+                int8_t r = e->execfn<int8_t>(run_fn);
                 result.type = EvalResult::integer1;
                 result.i32 = r;
             }
@@ -156,11 +156,11 @@ Result<PythonCompiler::EvalResult> PythonCompiler::evaluate(
                                     ->m_symtab->get_symbol(run_fn);
             LCOMPILERS_ASSERT(fn)
             if (ASRUtils::get_FunctionType(fn)->m_return_var_type->type == ASR::ttypeType::UnsignedInteger) {
-                uint16_t r = e->int16fn(run_fn);
+                uint16_t r = e->execfn<uint16_t>(run_fn);
                 result.type = EvalResult::unsignedInteger2;
                 result.u32 = r;
             } else {
-                int16_t r = e->int16fn(run_fn);
+                int16_t r = e->execfn<int16_t>(run_fn);
                 result.type = EvalResult::integer2;
                 result.i32 = r;
             }
@@ -169,11 +169,11 @@ Result<PythonCompiler::EvalResult> PythonCompiler::evaluate(
                                     ->m_symtab->get_symbol(run_fn);
             LCOMPILERS_ASSERT(fn)
             if (ASRUtils::get_FunctionType(fn)->m_return_var_type->type == ASR::ttypeType::UnsignedInteger) {
-                uint32_t r = e->int32fn(run_fn);
+                uint32_t r = e->execfn<uint32_t>(run_fn);
                 result.type = EvalResult::unsignedInteger4;
                 result.u32 = r;
             } else {
-                int32_t r = e->int32fn(run_fn);
+                int32_t r = e->execfn<int32_t>(run_fn);
                 result.type = EvalResult::integer4;
                 result.i32 = r;
             }
@@ -182,34 +182,34 @@ Result<PythonCompiler::EvalResult> PythonCompiler::evaluate(
                                     ->m_symtab->get_symbol(run_fn);
             LCOMPILERS_ASSERT(fn)
             if (ASRUtils::get_FunctionType(fn)->m_return_var_type->type == ASR::ttypeType::UnsignedInteger) {
-                uint64_t r = e->int64fn(run_fn);
+                uint64_t r = e->execfn<uint64_t>(run_fn);
                 result.type = EvalResult::unsignedInteger8;
                 result.u64 = r;
             } else {
-                int64_t r = e->int64fn(run_fn);
+                int64_t r = e->execfn<int64_t>(run_fn);
                 result.type = EvalResult::integer8;
                 result.i64 = r;
             }
         } else if (return_type == "real4") {
-            float r = e->floatfn(run_fn);
+            float r = e->execfn<float>(run_fn);
             result.type = EvalResult::real4;
             result.f32 = r;
         } else if (return_type == "real8") {
-            double r = e->doublefn(run_fn);
+            double r = e->execfn<double>(run_fn);
             result.type = EvalResult::real8;
             result.f64 = r;
         } else if (return_type == "complex4") {
-            std::complex<float> r = e->complex4fn(run_fn);
+            std::complex<float> r = e->execfn<std::complex<float>>(run_fn);
             result.type = EvalResult::complex4;
             result.c32.re = r.real();
             result.c32.im = r.imag();
         } else if (return_type == "complex8") {
-            std::complex<double> r = e->complex8fn(run_fn);
+            std::complex<double> r = e->execfn<std::complex<double>>(run_fn);
             result.type = EvalResult::complex8;
             result.c64.re = r.real();
             result.c64.im = r.imag();
         } else if (return_type == "void") {
-            e->voidfn(run_fn);
+            e->execfn<void>(run_fn);
             result.type = EvalResult::statement;
         } else if (return_type == "none") {
             result.type = EvalResult::none;
diff --git a/src/lpython/tests/test_llvm.cpp b/src/lpython/tests/test_llvm.cpp
index a4e9fa545e..8891a9a8ce 100644
--- a/src/lpython/tests/test_llvm.cpp
+++ b/src/lpython/tests/test_llvm.cpp
@@ -26,9 +26,9 @@ define i64 @f1()
     ret i64 4
 }
     )""");
-    CHECK(e.int64fn("f1") == 4);
+    CHECK(e.execfn<int64_t>("f1") == 4);
     e.add_module("");
-    //CHECK(e.int64fn("f1") == 4);
+    //CHECK(e.execfn<int64_t>("f1") == 4);
 
     e.add_module(R"""(
 define i64 @f2()
@@ -36,9 +36,9 @@ define i64 @f2()
     ret i64 5
 }
     )""");
-    CHECK(e.int64fn("f2") == 5);
+    CHECK(e.execfn<int64_t>("f2") == 5);
     //e.add_module("");
-    //CHECK(e.int64fn("f2") == 5);
+    //CHECK(e.execfn<int64_t>("f2") == 5);
 }
 
 TEST_CASE("llvm 1 fail") {
@@ -72,7 +72,7 @@ define i64 @f1()
     ret i64 %1
 }
     )""");
-    CHECK(e.int64fn("f1") == 4);
+    CHECK(e.execfn<int64_t>("f1") == 4);
 
     e.add_module(R"""(
 @count = external global i64
@@ -83,7 +83,7 @@ define i64 @f2()
     ret i64 %1
 }
     )""");
-    CHECK(e.int64fn("f2") == 4);
+    CHECK(e.execfn<int64_t>("f2") == 4);
 
     CHECK_THROWS_AS(e.add_module(R"""(
 define i64 @f3()
@@ -118,12 +118,12 @@ define void @inc()
     ret void
 }
     )""");
-    CHECK(e.int64fn("f1") == 5);
+    CHECK(e.execfn<int64_t>("f1") == 5);
     /*
-    e.voidfn("inc");
-    CHECK(e.int64fn("f1") == 6);
-    e.voidfn("inc");
-    CHECK(e.int64fn("f1") == 7);
+    e.execfn<void>("inc");
+    CHECK(e.execfn<int64_t>("f1") == 6);
+    e.execfn<void>("inc");
+    CHECK(e.execfn<int64_t>("f1") == 7);
     */
 
     /*
@@ -138,13 +138,13 @@ define void @inc2()
     ret void
 }
     )""");
-    CHECK(e.int64fn("f1") == 7);
-    e.voidfn("inc2");
-    CHECK(e.int64fn("f1") == 9);
-    e.voidfn("inc");
-    CHECK(e.int64fn("f1") == 10);
-    e.voidfn("inc2");
-    CHECK(e.int64fn("f1") == 12);
+    CHECK(e.execfn<int64_t>("f1") == 7);
+    e.execfn<void>("inc2");
+    CHECK(e.execfn<int64_t>("f1") == 9);
+    e.execfn<void>("inc");
+    CHECK(e.execfn<int64_t>("f1") == 10);
+    e.execfn<void>("inc2");
+    CHECK(e.execfn<int64_t>("f1") == 12);
     */
 
     // Test that we can have another independent LLVMEvaluator and use both at
@@ -169,19 +169,19 @@ define void @inc()
 }
     )""");
 
-    CHECK(e2.int64fn("f1") == 5);
-    e2.voidfn("inc");
-    CHECK(e2.int64fn("f1") == 6);
-    e2.voidfn("inc");
-    CHECK(e2.int64fn("f1") == 7);
-
-    CHECK(e.int64fn("f1") == 12);
-    e2.voidfn("inc");
-    CHECK(e2.int64fn("f1") == 8);
-    CHECK(e.int64fn("f1") == 12);
-    e.voidfn("inc");
-    CHECK(e2.int64fn("f1") == 8);
-    CHECK(e.int64fn("f1") == 13);
+    CHECK(e2.execfn<int64_t>("f1") == 5);
+    e2.execfn<void>("inc");
+    CHECK(e2.execfn<int64_t>("f1") == 6);
+    e2.execfn<void>("inc");
+    CHECK(e2.execfn<int64_t>("f1") == 7);
+
+    CHECK(e.execfn<int64_t>("f1") == 12);
+    e2.execfn<void>("inc");
+    CHECK(e2.execfn<int64_t>("f1") == 8);
+    CHECK(e.execfn<int64_t>("f1") == 12);
+    e.execfn<void>("inc");
+    CHECK(e2.execfn<int64_t>("f1") == 8);
+    CHECK(e.execfn<int64_t>("f1") == 13);
 */
 }
 
@@ -204,12 +204,12 @@ define void @inc()
     ret void
 }
 )""");
-    CHECK(e.int64fn("f1") == 5);
+    CHECK(e.execfn<int64_t>("f1") == 5);
     /*
-    e.voidfn("inc");
-    CHECK(e.int64fn("f1") == 6);
-    e.voidfn("inc");
-    CHECK(e.int64fn("f1") == 7);
+    e.execfn<void>("inc");
+    CHECK(e.execfn<int64_t>("f1") == 6);
+    e.execfn<void>("inc");
+    CHECK(e.execfn<int64_t>("f1") == 7);
 
     e.add_module(R"""(
 declare void @inc()
@@ -221,13 +221,13 @@ define void @inc2()
     ret void
 }
 )""");
-    CHECK(e.int64fn("f1") == 7);
-    e.voidfn("inc2");
-    CHECK(e.int64fn("f1") == 9);
-    e.voidfn("inc");
-    CHECK(e.int64fn("f1") == 10);
-    e.voidfn("inc2");
-    CHECK(e.int64fn("f1") == 12);
+    CHECK(e.execfn<int64_t>("f1") == 7);
+    e.execfn<void>("inc2");
+    CHECK(e.execfn<int64_t>("f1") == 9);
+    e.execfn<void>("inc");
+    CHECK(e.execfn<int64_t>("f1") == 10);
+    e.execfn<void>("inc2");
+    CHECK(e.execfn<int64_t>("f1") == 12);
 
     CHECK_THROWS_AS(e.add_module(R"""(
 define void @inc2()
@@ -280,7 +280,7 @@ define i64 @f()
     ret i64 %r
 }
     )""");
-    CHECK(e.int64fn("f") == 6);
+    CHECK(e.execfn<int64_t>("f") == 6);
 }
 
 TEST_CASE("llvm array 2") {
@@ -325,7 +325,7 @@ define i64 @f()
     ret i64 %r
 }
     )""");
-    //CHECK(e.int64fn("f") == 6);
+    //CHECK(e.execfn<int64_t>("f") == 6);
 }
 
 int f(int a, int b) {
@@ -349,7 +349,7 @@ define i64 @f1()
     ret i64 %r
 }
     )""");
-    CHECK(e.int64fn("f1") == 5);
+    CHECK(e.execfn<int64_t>("f1") == 5);
 }
 
 
@@ -387,7 +387,7 @@ define float @f()
     ret float %r
 }
     )""");
-    CHECK(std::abs(e.floatfn("f") - 8) < 1e-6);
+    CHECK(std::abs(e.execfn<float>("f") - 8) < 1e-6);
 }
 
 // Tests passing the complex struct by value
@@ -426,7 +426,7 @@ define float @f()
     ret float %r
 }
     )""");
-    //CHECK(std::abs(e.floatfn("f") - 8) < 1e-6);
+    //CHECK(std::abs(e.execfn<float>("f") - 8) < 1e-6);
 }
 
 // Tests passing boolean by reference
@@ -456,7 +456,7 @@ define i1 @b()
     ret i1 %r
 }
     )""");
-    CHECK(e.boolfn("b") == false);
+    CHECK(e.execfn<bool>("b") == false);
 }
 
 // Tests passing boolean by value
@@ -486,7 +486,7 @@ define i1 @b()
     ret i1 %r
 }
     )""");
-    CHECK(e.boolfn("b") == false);
+    CHECK(e.execfn<bool>("b") == false);
 }
 
 // Tests pointers
@@ -507,7 +507,7 @@ define i64 @f()
     ret i64 %raddr
 }
     )""");
-    int64_t r = e.int64fn("f");
+    int64_t r = e.execfn<int64_t>("f");
     CHECK(r != 8);
     int64_t *p = (int64_t*)r;
     CHECK(*p == 8);
@@ -527,7 +527,7 @@ define i64 @f()
     ret i64 %raddr
 }
     )""");
-    int64_t r = e.int64fn("f");
+    int64_t r = e.execfn<int64_t>("f");
     float *p = (float *)r;
     CHECK(std::abs(*p - 8) < 1e-6);
 }
@@ -568,7 +568,7 @@ define float @f()
     ret float %ret
 }
     )""");
-    float r = e.floatfn("f");
+    float r = e.execfn<float>("f");
     CHECK(std::abs(r - 8) < 1e-6);
 }
 
@@ -605,7 +605,7 @@ define float @f()
     ret float %ret
 }
     )""");
-    float r = e.floatfn("f");
+    float r = e.execfn<float>("f");
     CHECK(std::abs(r - 8) < 1e-6);
 }