Support implicit promoting with f16

- Create a ImplicitPromote<f16> trait and implement it for other types
- Implement ImplicitPromote<T> traits for f16

Author: Benjamin-Philip

src/core/util.rs

@@ -472,6 +472,7 @@ macro_rules! implicit {
 implicit!(c64, c32 => c64);
 implicit!(c64, f64       => c64);
 implicit!(c64, f32       => c64);
+implicit!(c64, f16       => c64);
 implicit!(c64, i64       => c64);
 implicit!(c64, u64       => c64);
 implicit!(c64, i32       => c64);
@@ -485,6 +486,7 @@ implicit!(c64, u8        => c64);
 implicit!(c32, c64 => c64);
 implicit!(c32, f64       => c64);
 implicit!(c32, f32       => c32);
+implicit!(c32, f16       => c32);
 implicit!(c32, i64       => c32);
 implicit!(c32, u64       => c32);
 implicit!(c32, i32       => c32);
@@ -498,6 +500,7 @@ implicit!(c32, u8        => c32);
 implicit!(f64, c64 => c64);
 implicit!(f64, c32 => c64);
 implicit!(f64, f32       =>       f64);
+implicit!(f64, f16       =>       f64);
 implicit!(f64, i64       =>       f64);
 implicit!(f64, u64       =>       f64);
 implicit!(f64, i32       =>       f64);
@@ -511,6 +514,7 @@ implicit!(f64, u8        =>       f64);
 implicit!(f32, c64 => c64);
 implicit!(f32, c32 => c32);
 implicit!(f32, f64       =>       f64);
+implicit!(f32, f16       =>       f32);
 implicit!(f32, i64       =>       f32);
 implicit!(f32, u64       =>       f32);
 implicit!(f32, i32       =>       f32);
@@ -520,11 +524,26 @@ implicit!(f32, u16       =>       f32);
 implicit!(f32, bool      =>       f32);
 implicit!(f32, u8        =>       f32);
 
+//LHS is 16-bit floating point
+implicit!(f16, c64 => c64);
+implicit!(f16, c32 => c32);
+implicit!(f16, f64       =>       f64);
+implicit!(f16, f32       =>       f32);
+implicit!(f16, i64       =>       f16);
+implicit!(f16, u64       =>       f16);
+implicit!(f16, i32       =>       f16);
+implicit!(f16, u32       =>       f16);
+implicit!(f16, i16       =>       f16);
+implicit!(f16, u16       =>       f16);
+implicit!(f16, bool      =>       f16);
+implicit!(f16, u8        =>       f16);
+
 //LHS is 64-bit signed integer
 implicit!(i64, c64 => c64);
 implicit!(i64, c32 => c32);
 implicit!(i64, f64       =>       f64);
 implicit!(i64, f32       =>       f32);
+implicit!(i64, f16       =>       f16);
 implicit!(i64, u64       =>       u64);
 implicit!(i64, i32       =>       i64);
 implicit!(i64, u32       =>       i64);
@@ -538,6 +557,7 @@ implicit!(u64, c64 => c64);
 implicit!(u64, c32 => c32);
 implicit!(u64, f64       =>       f64);
 implicit!(u64, f32       =>       f32);
+implicit!(u64, f16       =>       f16);
 implicit!(u64, i64       =>       u64);
 implicit!(u64, i32       =>       u64);
 implicit!(u64, u32       =>       u64);
@@ -551,6 +571,7 @@ implicit!(i32, c64 => c64);
 implicit!(i32, c32 => c32);
 implicit!(i32, f64       =>       f64);
 implicit!(i32, f32       =>       f32);
+implicit!(i32, f16       =>       f16);
 implicit!(i32, i64       =>       i64);
 implicit!(i32, u64       =>       u64);
 implicit!(i32, u32       =>       u32);
@@ -564,6 +585,7 @@ implicit!(u32, c64 => c64);
 implicit!(u32, c32 => c32);
 implicit!(u32, f64       =>       f64);
 implicit!(u32, f32       =>       f32);
+implicit!(u32, f16       =>       f16);
 implicit!(u32, i64       =>       i64);
 implicit!(u32, u64       =>       u64);
 implicit!(u32, i32       =>       u32);
@@ -577,6 +599,7 @@ implicit!(i16, c64 => c64);
 implicit!(i16, c32 => c32);
 implicit!(i16, f64       =>       f64);
 implicit!(i16, f32       =>       f32);
+implicit!(i16, f16       =>       f16);
 implicit!(i16, i64       =>       i64);
 implicit!(i16, u64       =>       u64);
 implicit!(i16, i32       =>       i32);
@@ -590,6 +613,7 @@ implicit!(u16, c64 => c64);
 implicit!(u16, c32 => c32);
 implicit!(u16, f64       =>       f64);
 implicit!(u16, f32       =>       f32);
+implicit!(u16, f16       =>       f16);
 implicit!(u16, i64       =>       i64);
 implicit!(u16, u64       =>       u64);
 implicit!(u16, i32       =>       i32);
@@ -603,6 +627,7 @@ implicit!(u8, c64 => c64);
 implicit!(u8, c32 => c32);
 implicit!(u8, f64       =>       f64);
 implicit!(u8, f32       =>       f32);
+implicit!(u8, f16       =>       f16);
 implicit!(u8, i64       =>       i64);
 implicit!(u8, u64       =>       u64);
 implicit!(u8, i32       =>       i32);
@@ -616,6 +641,7 @@ implicit!(bool, c64 => c64);
 implicit!(bool, c32 => c32);
 implicit!(bool, f64       =>       f64);
 implicit!(bool, f32       =>       f32);
+implicit!(bool, f16       =>       f16);
 implicit!(bool, i64       =>       i64);
 implicit!(bool, u64       =>       u64);
 implicit!(bool, i32       =>       i32);