diff --git a/lib/std/math.zig b/lib/std/math.zig
index 5885964c3..3aa43832c 100644
--- a/lib/std/math.zig
    b/lib/std/math.zig
@@ -322,11  322,6 @@ test "math.clamp" {
     testing.expect(std.math.clamp(@as(i32, 8), @as(i32, 7), @as(i32, -4)) == 7);
 }
 
-pub fn mul(comptime T: type, a: T, b: T) (error{Overflow}!T) {
-    var answer: T = undefined;
-    return if (@mulWithOverflow(T, a, b, &answer)) error.Overflow else answer;
-}
-
 pub fn add(comptime T: type, a: T, b: T) (error{Overflow}!T) {
     var answer: T = undefined;
     return if (@addWithOverflow(T, a, b, &answer)) error.Overflow else answer;
@@ -949,15  944,43 @@ test "max value type" {
     testing.expect(x == 2147483647);
 }
 
-pub fn mulWide(comptime T: type, a: T, b: T) @IntType(T.is_signed, T.bit_count * 2) {
-    const ResultInt = @IntType(T.is_signed, T.bit_count * 2);
-    return @as(ResultInt, a) * @as(ResultInt, b);
 /// Multiply two integers together, without possibility of overflow.
 /// The return type will be just wide enough to be guaranteed to store the result.
 /// This function is safe and does not assert anything.
 pub fn mul(a: var, b: var) Mul(@TypeOf(a), @TypeOf(b)) {
     const ResultInt = Mul(@TypeOf(a), @TypeOf(b));
     // TODO implementation
 }
 
-test "math.mulWide" {
-    testing.expect(mulWide(u8, 5, 5) == 25);
-    testing.expect(mulWide(i8, 5, -5) == -25);
-    testing.expect(mulWide(u8, 100, 100) == 10000);
 test "mul" {
     {
         var a: u8 = 5;
         var b: u8 = 5;
         const result = mul(a, b);
         testing.expect(result == 25);
         testing.expect(@TypeOf(result) == u16);
     }
     {
         var a: u8 = 5;
         var b: i8 = -5;
         const result = mul(a, b);
         testing.expect(result == -25);
         testing.expect(@TypeOf(result) == i16);
     }
     {
         var a: u8 = 100;
         var b: u8 = 100;
         const result = mul(a, b);
         testing.expect(result == 10000);
         testing.expect(@TypeOf(result) == u16);
     }
     {
         var a: u8 = 100;
         var b: u8 = 100;
         const result = mul(@as(u8, 9), @as(i8, 100));
         testing.expect(result == 900);
         testing.expect(@TypeOf(result) == comptime_int);
     }
 }
 
 /// See also `CompareOperator`.