Clean up the Bit struct and rename the file from Types.cs to Bit.cs

BizHawk.Common/Bit.cs

@@ -0,0 +1,88 @@
+using System.Diagnostics;
+
+namespace BizHawk.Common
+{
+	// I think this is a little faster with uint than with byte
+	public struct Bit
+	{
+		private readonly uint _val;
+
+		public Bit(uint val)
+		{
+			_val = val;
+		}
+		
+		public static implicit operator Bit(int rhs)
+		{
+			Debug.Assert((rhs & ~1) == 0); 
+			return new Bit((uint)rhs);
+		}
+
+		public static implicit operator Bit(uint rhs)
+		{
+			Debug.Assert((rhs & ~1) == 0);
+			return new Bit(rhs);
+		}
+
+		public static implicit operator Bit(byte rhs)
+		{
+			Debug.Assert((rhs & ~1) == 0);
+			return new Bit(rhs);
+		}
+
+		public static implicit operator Bit(bool rhs)
+		{
+			return new Bit(rhs ? (byte)1 : (byte)0);
+		}
+
+		public static implicit operator long(Bit rhs)
+		{
+			return rhs._val;
+		}
+
+		public static implicit operator int(Bit rhs)
+		{
+			return (int)rhs._val;
+		}
+
+		public static implicit operator uint(Bit rhs)
+		{
+			return rhs._val;
+		}
+
+		public static implicit operator byte(Bit rhs)
+		{
+			return (byte)rhs._val;
+		}
+
+		public static implicit operator bool(Bit rhs)
+		{
+			return rhs._val != 0;
+		}
+
+		public override string ToString()
+		{
+			return _val.ToString();
+		}
+
+		public static bool operator ==(Bit lhs, Bit rhs)
+		{
+			return lhs._val == rhs._val;
+		}
+
+		public static bool operator !=(Bit lhs, Bit rhs)
+		{
+			return lhs._val != rhs._val;
+		}
+
+		public override int GetHashCode()
+		{
+			return _val.GetHashCode();
+		}
+
+		public override bool Equals(object obj)
+		{
+			return this == (Bit)obj;  // this is probably wrong
+		}
+	}
+}

BizHawk.Common/BizHawk.Common.csproj

@@ -47,6 +47,7 @@
     <Compile Include="..\VersionInfo.cs">
       <Link>VersionInfo.cs</Link>
     </Compile>
+    <Compile Include="Bit.cs" />
     <Compile Include="BitReverse.cs" />
     <Compile Include="Buffer.cs" />
     <Compile Include="Colors.cs" />
@@ -62,7 +63,6 @@
     <Compile Include="QuickCollections.cs" />
     <Compile Include="Serializer.cs" />
     <Compile Include="SwitcherStream.cs" />
-    <Compile Include="Types.cs" />
     <Compile Include="UndoHistory.cs" />
     <Compile Include="Util.cs" />
   </ItemGroup>

BizHawk.Common/Types.cs

@@ -1,31 +0,0 @@
-using System.Diagnostics;
-
-namespace BizHawk.Common
-{
-	//I think this is a little faster with uint than with byte
-	public struct Bit
-	{
-		readonly uint val;
-
-		Bit(uint val)
-		{
-			this.val = val;
-		}
-		
-		public static implicit operator Bit(int rhs) { Debug.Assert((rhs & ~1) == 0); return new Bit((uint)(rhs)); }
-		public static implicit operator Bit(uint rhs) { Debug.Assert((rhs & ~1) == 0); return new Bit((uint)(rhs)); }
-		public static implicit operator Bit(byte rhs) { Debug.Assert((rhs & ~1) == 0); return new Bit((uint)(rhs)); }
-		public static implicit operator Bit(bool rhs) { return new Bit(rhs ? (byte)1 : (byte)0); }
-		public static implicit operator long(Bit rhs) { return (long)rhs.val; }
-		public static implicit operator int(Bit rhs) { return (int)rhs.val; }
-		public static implicit operator uint(Bit rhs) { return (uint)rhs.val; }
-		public static implicit operator byte(Bit rhs) { return (byte)rhs.val; }
-		public static implicit operator bool(Bit rhs) { return rhs.val != 0; }
-		public override string ToString() {return val.ToString(); }
-		public static bool operator ==(Bit lhs, Bit rhs) { return lhs.val == rhs.val; }
-		public static bool operator !=(Bit lhs, Bit rhs) { return lhs.val != rhs.val; }
-		public override int GetHashCode() { return val.GetHashCode(); }
-		public override bool Equals(object obj) { return this == (Bit)obj; } //this is probably wrong
-	}
-
-}