diff --git a/NEWS.md b/NEWS.md
index ef2148e099..63d80ca509 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -30,6 +30,8 @@
 
 2. `set()` now automatically pre-allocates new column slots if needed, similar to what `:=` already does, [#1831](https://github.com/Rdatatable/data.table/issues/1831) [#4100](https://github.com/Rdatatable/data.table/issues/4100). Thanks to @zachokeeffe and @tyner for the report and @ben-schwen for the fix.
 
+3. `fcoalesce()` and `setcoalesce()` now allow mixing of `Date` and `IDate` classes, and mixing of `integer` and `double` types (coercing to `double` if needed), [#7463](https://github.com/Rdatatable/data.table/issues/7463). Thanks @akshkaushik for the report and the fix.
+
 ## data.table [v1.18.0](https://github.com/Rdatatable/data.table/milestone/37?closed=1)  23 December 2025
 
 ### BREAKING CHANGE
diff --git a/inst/tests/tests.Rraw b/inst/tests/tests.Rraw
index 8cad916e3b..cc026816d7 100644
--- a/inst/tests/tests.Rraw
+++ b/inst/tests/tests.Rraw
@@ -15628,8 +15628,8 @@ test(2060.202, fcoalesce(fkt), fkt)
 test(2060.203, fcoalesce(bool, 1L), error='Item 2 is type integer but the first item is type logical. Please coerce before coalescing')
 test(2060.204, fcoalesce(bool, NA_integer_), error='Item 2 is type integer but the first item is type logical.')
 test(2060.205, fcoalesce(fkt, 1L), error='Item 1 is a factor but item 2 is not a factor. When factors are involved, all items must be factor')
-test(2060.206, fcoalesce(num, 3L), error='Item 2 is type integer but the first item is type double')
-test(2060.207, fcoalesce(int, 3), error='Item 2 is type double but the first item is type integer')
+test(2060.206, fcoalesce(num, 3L), num_val)
+test(2060.207, fcoalesce(int, 3), num_val)
 test(2060.208, fcoalesce(fkt, 'b'), error='Item 1 is a factor but item 2 is not a factor. When factors are involved, all items must be factor.')
 test(2060.209, fcoalesce(str, factor('b')), error='Item 2 is a factor but item 1 is not a factor. When factors are involved, all items must be factor')
 test(2060.212, fcoalesce(list(1), list(2)), error="The first argument is a list, data.table or data.frame. In this case there should be no other arguments provided.")
@@ -15653,7 +15653,7 @@ if (test_bit64) {
   test(2060.302, as.character(fcoalesce(int64, as.integer64(NA), as.integer64(3))), as.character(int64_val))
   test(2060.303, as.character(fcoalesce(int64, as.integer64(rep(3, 4L)))), as.character(int64_val))
   test(2060.304, fcoalesce(int64, 1), error='Item 2 has a different class than item 1')
-  test(2060.305, fcoalesce(int64, 1L), error = 'Item 2 is type integer but the first item is type double')
+  test(2060.305, fcoalesce(int64, 1L), error = 'Item 2 has a different class than item 1.')
 }
 # 2060.401-405 tested nanotime moved to other.Rraw 23, #5516
 # setcoalesce
@@ -20607,6 +20607,7 @@ test(2294.59,
               VDate = fifelse(VDate == as.Date("3000-01-01"), as.Date(NA), VDate),
               VIDate = fifelse(VIDate == as.IDate("3000-01-01"), as.IDate(NA), VIDate),
               VNumA, VNumB, Count, Y_Sum)])
+
 # 60. label is a scalar with class not matching any variable in 'by'.
 test(2294.60,
      groupingsets(DT1, .(Count = .N, Y_Sum = sum(Y)),
@@ -21968,3 +21969,21 @@ test(2356.2, options=c(datatable.alloccol=1L), set(DT, j="c", value=3), data.tab
 # ensure := and set are consistent if they need to overallocate
 DT = data.table(); DT2 = data.table()
 test(2356.3, options=c(datatable.alloccol=1L), {for (i in seq(10L)) set(DT, j = sprintf("V%d",i), value = i); DT}, {for (i in seq(10)) DT2[, sprintf("V%d",i) := i]; DT2})
+
+# fcoalesce Date and IDate mixing, #7463
+test(2357.1, fcoalesce(as.Date("2026-01-01"), as.IDate("2026-01-02")), as.Date("2026-01-01"))
+test(2357.2, {
+  res = fcoalesce(as.IDate("2026-01-02"), as.Date("2026-01-01"))
+  list(res, class(res))
+}, list(as.double(as.IDate("2026-01-02")), c("IDate", "Date"))) # promoted to double
+test(2357.3, fcoalesce(1L, 2.0), 1.0)
+test(2357.4, fcoalesce(2.0, 1L), 2.0)
+test(2357.5, {
+  r = c(NA_real_, 2.0)
+  setcoalesce(r, 1L)
+  r
+}, c(1.0, 2.0))
+test(2357.6, {
+  i = c(NA_integer_, 2L)
+  setcoalesce(i, 1.0)
+}, error="In-place coalesce cannot promote integer to double")
diff --git a/src/coalesce.c b/src/coalesce.c
index 10b7b77576..af944dca2d 100644
--- a/src/coalesce.c
+++ b/src/coalesce.c
@@ -7,190 +7,304 @@
     - The conditional checks within parallelized loops
 */
 SEXP coalesce(SEXP x, SEXP inplaceArg, SEXP nan_is_na_arg) {
-  if (TYPEOF(x)!=VECSXP) internal_error(__func__, "input is list(...) at R level"); // # nocov
-  if (!IS_TRUE_OR_FALSE(inplaceArg)) internal_error(__func__, "argument 'inplaceArg' must be TRUE or FALSE"); // # nocov
-  if (!IS_TRUE_OR_FALSE(nan_is_na_arg)) internal_error(__func__, "argument 'nan_is_na_arg' must be TRUE or FALSE"); // # nocov
+  if (TYPEOF(x) != VECSXP)
+    internal_error(__func__, "input is list(...) at R level"); // # nocov
+  if (!IS_TRUE_OR_FALSE(inplaceArg))
+    internal_error(__func__,
+                   "argument 'inplaceArg' must be TRUE or FALSE"); // # nocov
+  if (!IS_TRUE_OR_FALSE(nan_is_na_arg))
+    internal_error(__func__,
+                   "argument 'nan_is_na_arg' must be TRUE or FALSE"); // # nocov
   const bool inplace = LOGICAL(inplaceArg)[0];
   const bool nan_is_na = LOGICAL(nan_is_na_arg)[0];
   const bool verbose = GetVerbose();
   int nprotect = 0;
-  if (length(x)==0 || isNull(VECTOR_ELT(x,0))) return R_NilValue;  // coalesce(NULL, "foo") return NULL even though character type mismatches type NULL
-  SEXP first;  // the first vector (it might be the first argument, or it might be the first column of a data.table|frame
-  int off = 1; // when x has been pointed to the list of replacement candidates, is the first candidate in position 0 or 1 in the list
-  if (TYPEOF(VECTOR_ELT(x,0)) == VECSXP) {
-    if (length(x)!=1)
-      error(_("The first argument is a list, data.table or data.frame. In this case there should be no other arguments provided."));
-    x = VECTOR_ELT(x,0);
-    if (length(x)==0) return R_NilValue;
-    first = VECTOR_ELT(x,0);
+  if (length(x) == 0 || isNull(VECTOR_ELT(x, 0)))
+    return R_NilValue; // coalesce(NULL, "foo") return NULL even though
+                       // character type mismatches type NULL
+  SEXP first;  // the first vector (it might be the first argument, or it might
+               // be the first column of a data.table|frame
+  int off = 1; // when x has been pointed to the list of replacement candidates,
+               // is the first candidate in position 0 or 1 in the list
+  if (TYPEOF(VECTOR_ELT(x, 0)) == VECSXP) {
+    if (length(x) != 1)
+      error(_("The first argument is a list, data.table or data.frame. In this "
+              "case there should be no other arguments provided."));
+    x = VECTOR_ELT(x, 0);
+    if (length(x) == 0)
+      return R_NilValue;
+    first = VECTOR_ELT(x, 0);
   } else {
-    first = VECTOR_ELT(x,0);
-    if (length(x)>1 && TYPEOF(VECTOR_ELT(x,1))==VECSXP) { x=VECTOR_ELT(x,1); off=0; }  // coalesce(x, list(y,z))
+    first = VECTOR_ELT(x, 0);
+    if (length(x) > 1 && TYPEOF(VECTOR_ELT(x, 1)) == VECSXP) {
+      x = VECTOR_ELT(x, 1);
+      off = 0;
+    } // coalesce(x, list(y,z))
   }
-  const int nval = length(x)-off;
-  if (nval==0) return first;
+  const int nval = length(x) - off;
+  if (nval == 0)
+    return first;
   const bool factor = isFactor(first);
   const int nrow = length(first);
-  for (int i=0; i<nval; ++i) {
-    SEXP item = VECTOR_ELT(x, i+off);
+  bool promote_to_real = false;
+  for (int i = 0; i < nval; ++i) {
+    SEXP item = VECTOR_ELT(x, i + off);
     if (factor) {
       if (!isFactor(item))
-        error(_("Item 1 is a factor but item %d is not a factor. When factors are involved, all items must be factor."), i+2);
-      if (!R_compute_identical(PROTECT(getAttrib(first, R_LevelsSymbol)), PROTECT(getAttrib(item, R_LevelsSymbol)), 0))
-        error(_("Item %d is a factor but its levels are not identical to the first item's levels."), i+2);
+        error(_("Item 1 is a factor but item %d is not a factor. When factors "
+                "are involved, all items must be factor."),
+              i + 2);
+      if (!R_compute_identical(PROTECT(getAttrib(first, R_LevelsSymbol)),
+                               PROTECT(getAttrib(item, R_LevelsSymbol)), 0))
+        error(_("Item %d is a factor but its levels are not identical to the "
+                "first item's levels."),
+              i + 2);
       UNPROTECT(2);
     } else {
       if (isFactor(item))
-        error(_("Item %d is a factor but item 1 is not a factor. When factors are involved, all items must be factor."), i+2);
+        error(_("Item %d is a factor but item 1 is not a factor. When factors "
+                "are involved, all items must be factor."),
+              i + 2);
+    }
+    if (TYPEOF(first) != TYPEOF(item)) {
+      if ((TYPEOF(first) == INTSXP || TYPEOF(first) == LGLSXP) &&
+          TYPEOF(item) == REALSXP) {
+        promote_to_real = true;
+      } else if (TYPEOF(first) == REALSXP &&
+                 (TYPEOF(item) == INTSXP || TYPEOF(item) == LGLSXP)) {
+        // ok, will cast to double in REALSXP block
+      } else {
+        error(_("Item %d is type %s but the first item is type %s. Please "
+                "coerce before coalescing."),
+              i + 2, type2char(TYPEOF(item)), type2char(TYPEOF(first)));
+      }
+    }
+    if (!R_compute_identical(PROTECT(getAttrib(first, R_ClassSymbol)),
+                             PROTECT(getAttrib(item, R_ClassSymbol)), 0)) {
+      if (INHERITS(first, char_Date) && INHERITS(item, char_Date)) {
+        // ok, both are Date-like (Date or IDate)
+      } else {
+        error(_("Item %d has a different class than item 1."), i + 2);
+      }
     }
-    if (TYPEOF(first) != TYPEOF(item))
-      error(_("Item %d is type %s but the first item is type %s. Please coerce before coalescing."), i+2, type2char(TYPEOF(item)), type2char(TYPEOF(first)));
-    if (!R_compute_identical(PROTECT(getAttrib(first, R_ClassSymbol)), PROTECT(getAttrib(item, R_ClassSymbol)), 0))
-      error(_("Item %d has a different class than item 1."), i+2);
     UNPROTECT(2);
-    if (length(item)!=1 && length(item)!=nrow)
-      error(_("Item %d is length %d but the first item is length %d. Only singletons are recycled."), i+2, length(item), nrow);
+    if (length(item) != 1 && length(item) != nrow)
+      error(_("Item %d is length %d but the first item is length %d. Only "
+              "singletons are recycled."),
+            i + 2, length(item), nrow);
   }
-  if (!inplace) {
-    first = PROTECT(copyAsPlain(first)); nprotect++;
-    if (verbose) Rprintf(_("coalesce copied first item (inplace=FALSE)\n"));
+  if (promote_to_real) {
+    if (inplace)
+      error(_("In-place coalesce cannot promote %s to %s. Please coerce before "
+              "coalescing."),
+            type2char(TYPEOF(first)), type2char(REALSXP));
+    first = PROTECT(coerceVector(first, REALSXP));
+    nprotect++;
+  } else if (!inplace) {
+    first = PROTECT(copyAsPlain(first));
+    nprotect++;
+    if (verbose)
+      Rprintf(_("coalesce copied first item (inplace=FALSE)\n"));
   }
   const void **valP = (const void **)R_alloc(nval, sizeof(*valP));
-  switch(TYPEOF(first)) {
+  memset(valP, 0, nval * sizeof(*valP));
+  switch (TYPEOF(first)) {
   case LGLSXP:
   case INTSXP: {
-    int *xP = INTEGER(first), k=0, finalVal=NA_INTEGER;
-    for (int j=0; j<nval; ++j) {
-      SEXP item = VECTOR_ELT(x, j+off);
-      if (length(item)==1) {
+    int *xP = INTEGER(first), k = 0, finalVal = NA_INTEGER;
+    for (int j = 0; j < nval; ++j) {
+      SEXP item = VECTOR_ELT(x, j + off);
+      if (length(item) == 1) {
         int tt = INTEGER(item)[0];
-        if (tt==NA_INTEGER) continue;  // singleton NA can be skipped
+        if (tt == NA_INTEGER)
+          continue; // singleton NA can be skipped
         finalVal = tt;
-        break;  // stop early on the first singleton that is not NA; minimizes deepest loop body below
+        break; // stop early on the first singleton that is not NA; minimizes
+               // deepest loop body below
       }
       valP[k++] = INTEGER_RO(item);
     }
-    const bool final=(finalVal!=NA_INTEGER);
-    #pragma omp parallel for num_threads(getDTthreads(nrow, true))
-    for (int i=0; i<nrow; ++i) {
+    const bool final = (finalVal != NA_INTEGER);
+#pragma omp parallel for num_threads(getDTthreads(nrow, true))
+    for (int i = 0; i < nrow; ++i) {
       int val = xP[i];
-      if (val!=NA_INTEGER) continue;
-      int j=0; while (val==NA_INTEGER && j<k) val=((int *)valP[j++])[i];  // k is the number of non-singletons
-      if (val!=NA_INTEGER) xP[i]=val; else if (final) xP[i]=finalVal;
+      if (val != NA_INTEGER)
+        continue;
+      int j = 0;
+      while (val == NA_INTEGER && j < k)
+        val = ((int *)valP[j++])[i]; // k is the number of non-singletons
+      if (val != NA_INTEGER)
+        xP[i] = val;
+      else if (final)
+        xP[i] = finalVal;
     }
   } break;
   case REALSXP: {
     if (INHERITS(first, char_integer64)) {
-      int64_t *xP=(int64_t *)REAL(first), finalVal=NA_INTEGER64;
-      int k=0;
-      for (int j=0; j<nval; ++j) {
-        SEXP item = VECTOR_ELT(x, j+off);
-        if (length(item)==1) {
+      int64_t *xP = (int64_t *)REAL(first), finalVal = NA_INTEGER64;
+      int k = 0;
+      for (int j = 0; j < nval; ++j) {
+        SEXP item = VECTOR_ELT(x, j + off);
+        if (length(item) == 1) {
           int64_t tt = ((int64_t *)REAL(item))[0];
-          if (tt==NA_INTEGER64) continue;
+          if (tt == NA_INTEGER64)
+            continue;
           finalVal = tt;
           break;
         }
         valP[k++] = REAL_RO(item);
       }
-      const bool final = (finalVal!=NA_INTEGER64);
-      #pragma omp parallel for num_threads(getDTthreads(nrow, true))
-      for (int i=0; i<nrow; ++i) {
-        int64_t val=xP[i];
-        if (val!=NA_INTEGER64) continue;
-        int j=0; while (val==NA_INTEGER64 && j<k) val=((int64_t *)valP[j++])[i];
-        if (val!=NA_INTEGER64) xP[i]=val; else if (final) xP[i]=finalVal;
+      const bool final = (finalVal != NA_INTEGER64);
+#pragma omp parallel for num_threads(getDTthreads(nrow, true))
+      for (int i = 0; i < nrow; ++i) {
+        int64_t val = xP[i];
+        if (val != NA_INTEGER64)
+          continue;
+        int j = 0;
+        while (val == NA_INTEGER64 && j < k)
+          val = ((int64_t *)valP[j++])[i];
+        if (val != NA_INTEGER64)
+          xP[i] = val;
+        else if (final)
+          xP[i] = finalVal;
       }
     } else {
-      double *xP = REAL(first), finalVal=NA_REAL;
-      int k=0;
+      double *xP = REAL(first), finalVal = NA_REAL;
+      bool *is_real = (bool *)R_alloc(nval, sizeof(bool));
       if (nan_is_na) {
-        for (int j=0; j<nval; ++j) {
-          SEXP item = VECTOR_ELT(x, j+off);
-          if (length(item)==1) {
-            double tt = REAL(item)[0];
-            if (ISNAN(tt)) continue;
+        for (int j = 0; j < nval; ++j) {
+          SEXP item = VECTOR_ELT(x, j + off);
+          is_real[j] = (TYPEOF(item) == REALSXP);
+          if (length(item) == 1) {
+            double tt = is_real[j] ? REAL(item)[0] : (double)INTEGER(item)[0];
+            if (ISNAN(tt))
+              continue;
             finalVal = tt;
             break;
           }
-          valP[k++] = REAL_RO(item);
+          valP[j] = is_real[j] ? (const void *)REAL_RO(item)
+                               : (const void *)INTEGER_RO(item);
         }
         const bool final = !ISNAN(finalVal);
-        #pragma omp parallel for num_threads(getDTthreads(nrow, true))
-        for (int i=0; i<nrow; ++i) {
-          double val=xP[i];
-          if (!ISNAN(val)) continue;
-          int j=0; while (ISNAN(val) && j<k) val=((double *)valP[j++])[i];
-          if (!ISNAN(val)) xP[i]=val; else if (final) xP[i]=finalVal;
+#pragma omp parallel for num_threads(getDTthreads(nrow, true))
+        for (int i = 0; i < nrow; ++i) {
+          double val = xP[i];
+          if (!ISNAN(val))
+            continue;
+          for (int j = 0; j < nval; ++j) {
+            if (!valP[j])
+              continue;
+            if (is_real[j])
+              val = ((const double *)valP[j])[i];
+            else
+              val = (double)((const int *)valP[j])[i];
+            if (!ISNAN(val))
+              break;
+          }
+          if (!ISNAN(val))
+            xP[i] = val;
+          else if (final)
+            xP[i] = finalVal;
         }
       } else {
-        for (int j=0; j<nval; ++j) {
-          SEXP item = VECTOR_ELT(x, j+off);
-          if (length(item)==1) {
-            double tt = REAL(item)[0];
-            if (ISNA(tt)) continue;
+        for (int j = 0; j < nval; ++j) {
+          SEXP item = VECTOR_ELT(x, j + off);
+          is_real[j] = (TYPEOF(item) == REALSXP);
+          if (length(item) == 1) {
+            double tt = is_real[j] ? REAL(item)[0] : (double)INTEGER(item)[0];
+            if (ISNA(tt))
+              continue;
             finalVal = tt;
             break;
           }
-          valP[k++] = REAL_RO(item);
+          valP[j] = is_real[j] ? (const void *)REAL_RO(item)
+                               : (const void *)INTEGER_RO(item);
         }
         const bool final = !ISNA(finalVal);
-        #pragma omp parallel for num_threads(getDTthreads(nrow, true))
-        for (int i=0; i<nrow; ++i) {
-          double val=xP[i];
-          if (!ISNA(val)) continue;
-          int j=0; while (ISNA(val) && j<k) val=((double *)valP[j++])[i];
-          if (!ISNA(val)) xP[i]=val; else if (final) xP[i]=finalVal;
+#pragma omp parallel for num_threads(getDTthreads(nrow, true))
+        for (int i = 0; i < nrow; ++i) {
+          double val = xP[i];
+          if (!ISNA(val))
+            continue;
+          for (int j = 0; j < nval; ++j) {
+            if (!valP[j])
+              continue;
+            if (is_real[j])
+              val = ((const double *)valP[j])[i];
+            else
+              val = (double)((const int *)valP[j])[i];
+            if (!ISNA(val))
+              break;
+          }
+          if (!ISNA(val))
+            xP[i] = val;
+          else if (final)
+            xP[i] = finalVal;
         }
       }
     }
   } break;
   case CPLXSXP: {
-    Rcomplex *xP = COMPLEX(first), finalVal=NA_CPLX;
-    int k=0;
-    for (int j=0; j<nval; ++j) {
-      SEXP item = VECTOR_ELT(x, j+off);
-      if (length(item)==1) {
+    Rcomplex *xP = COMPLEX(first), finalVal = NA_CPLX;
+    int k = 0;
+    for (int j = 0; j < nval; ++j) {
+      SEXP item = VECTOR_ELT(x, j + off);
+      if (length(item) == 1) {
         Rcomplex tt = COMPLEX(item)[0];
-        if (ISNAN(tt.r) && ISNAN(tt.i)) continue;
+        if (ISNAN(tt.r) && ISNAN(tt.i))
+          continue;
         finalVal = tt;
         break;
       }
       valP[k++] = COMPLEX_RO(item);
     }
     const bool final = !ISNAN(finalVal.r) && !ISNAN(finalVal.i);
-    #pragma omp parallel for num_threads(getDTthreads(nrow, true))
-    for (int i=0; i<nrow; ++i) {
-      Rcomplex val=xP[i];
-      if (!ISNAN(val.r) && !ISNAN(val.i)) continue;
-      int j=0; while (ISNAN(val.r) && ISNAN(val.i) && j<k) val=((Rcomplex *)valP[j++])[i];
-      if (!ISNAN(val.r) || !ISNAN(val.i)) xP[i]=val; else if (final) xP[i]=finalVal;
+#pragma omp parallel for num_threads(getDTthreads(nrow, true))
+    for (int i = 0; i < nrow; ++i) {
+      Rcomplex val = xP[i];
+      if (!ISNAN(val.r) && !ISNAN(val.i))
+        continue;
+      int j = 0;
+      while (ISNAN(val.r) && ISNAN(val.i) && j < k)
+        val = ((Rcomplex *)valP[j++])[i];
+      if (!ISNAN(val.r) || !ISNAN(val.i))
+        xP[i] = val;
+      else if (final)
+        xP[i] = finalVal;
     }
   } break;
   case STRSXP: {
     const SEXP *xP = STRING_PTR_RO(first);
-    SEXP finalVal=NA_STRING;
-    int k=0;
-    for (int j=0; j<nval; ++j) {
-      SEXP item = VECTOR_ELT(x, j+off);
-      if (length(item)==1) {
-        SEXP tt = STRING_ELT(item,0);
-        if (tt==NA_STRING) continue;
+    SEXP finalVal = NA_STRING;
+    int k = 0;
+    for (int j = 0; j < nval; ++j) {
+      SEXP item = VECTOR_ELT(x, j + off);
+      if (length(item) == 1) {
+        SEXP tt = STRING_ELT(item, 0);
+        if (tt == NA_STRING)
+          continue;
         finalVal = tt;
         break;
       }
       valP[k++] = STRING_PTR_RO(item);
     }
-    const bool final = (finalVal!=NA_STRING);
-    for (int i=0; i<nrow; ++i) {
+    const bool final = (finalVal != NA_STRING);
+    for (int i = 0; i < nrow; ++i) {
       SEXP val = xP[i];
-      if (val!=NA_STRING) continue;
-      int j=0; while (val==NA_STRING && j<k) val=((SEXP *)valP[j++])[i];
-      if (val!=NA_STRING) SET_STRING_ELT(first, i, val); else if (final) SET_STRING_ELT(first, i, finalVal);
+      if (val != NA_STRING)
+        continue;
+      int j = 0;
+      while (val == NA_STRING && j < k)
+        val = ((SEXP *)valP[j++])[i];
+      if (val != NA_STRING)
+        SET_STRING_ELT(first, i, val);
+      else if (final)
+        SET_STRING_ELT(first, i, finalVal);
     }
   } break;
   default:
-    error(_("Type '%s' is not supported"), type2char(TYPEOF(first))); // e.g. raw is tested
+    error(_("Type '%s' is not supported"),
+          type2char(TYPEOF(first))); // e.g. raw is tested
   }
   UNPROTECT(nprotect);
   return first;