diff --git a/java-character.cabal b/java-character.cabal
--- a/java-character.cabal
+++ b/java-character.cabal
@@ -1,5 +1,5 @@
 Name:               java-character
-Version:            0.0.3
+Version:            0.0.4
 License:            BSD3
 License-File:       LICENSE
 Author:             Tony Morris <ʇǝu˙sıɹɹoɯʇ@ןןǝʞsɐɥ>
@@ -22,7 +22,7 @@
 Library
   Build-Depends:
                       base < 5 && >= 3
-                    , containers >= 0.4.0.0
+                    , diet >= 0.0.1
 
   GHC-Options:
                     -Wall
diff --git a/src/Language/Java/Character/IsDefined.hs b/src/Language/Java/Character/IsDefined.hs
--- a/src/Language/Java/Character/IsDefined.hs
+++ b/src/Language/Java/Character/IsDefined.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isDefined@.
 class Enum c => IsDefined c where
@@ -49,13 +48,9 @@
   isDefined c =
     c `S.member` isDefinedSet
 
-instance HasResolution a => IsDefined (Fixed a) where
-  isDefined c =
-    c `S.member` isDefinedSet
-
 isDefinedSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isDefinedSet =
   let r = [
             [0..566]
diff --git a/src/Language/Java/Character/IsDigit.hs b/src/Language/Java/Character/IsDigit.hs
--- a/src/Language/Java/Character/IsDigit.hs
+++ b/src/Language/Java/Character/IsDigit.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char hiding (isDigit)
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isDigit@.
 class Enum c => IsDigit c where
@@ -49,13 +48,9 @@
   isDigit c =
     c `S.member` isDigitSet
 
-instance HasResolution a => IsDigit (Fixed a) where
-  isDigit c =
-    c `S.member` isDigitSet
-
 isDigitSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isDigitSet =
   let r = [
             [48..57]
diff --git a/src/Language/Java/Character/IsIdentifierIgnorable.hs b/src/Language/Java/Character/IsIdentifierIgnorable.hs
--- a/src/Language/Java/Character/IsIdentifierIgnorable.hs
+++ b/src/Language/Java/Character/IsIdentifierIgnorable.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isIdentifierIgnorable@.
 class Enum c => IsIdentifierIgnorable c where
@@ -49,13 +48,9 @@
   isIdentifierIgnorable c =
     c `S.member` isIdentifierIgnorableSet
 
-instance HasResolution a => IsIdentifierIgnorable (Fixed a) where
-  isIdentifierIgnorable c =
-    c `S.member` isIdentifierIgnorableSet
-
 isIdentifierIgnorableSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isIdentifierIgnorableSet =
   let r = [
             [0..8]
diff --git a/src/Language/Java/Character/IsIsoControl.hs b/src/Language/Java/Character/IsIsoControl.hs
--- a/src/Language/Java/Character/IsIsoControl.hs
+++ b/src/Language/Java/Character/IsIsoControl.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isISOControl@.
 class Enum c => IsIsoControl c where
@@ -49,13 +48,9 @@
   isIsoControl c =
     c `S.member` isIsoControlSet
 
-instance HasResolution a => IsIsoControl (Fixed a) where
-  isIsoControl c =
-    c `S.member` isIsoControlSet
-
 isIsoControlSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isIsoControlSet =
   let r = [
             [0..31]
diff --git a/src/Language/Java/Character/IsJavaIdentifierPart.hs b/src/Language/Java/Character/IsJavaIdentifierPart.hs
--- a/src/Language/Java/Character/IsJavaIdentifierPart.hs
+++ b/src/Language/Java/Character/IsJavaIdentifierPart.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isJavaIdentifierPart@.
 class Enum c => IsJavaIdentifierPart c where
@@ -49,13 +48,9 @@
   isJavaIdentifierPart c =
     c `S.member` isJavaIdentifierPartSet
 
-instance HasResolution a => IsJavaIdentifierPart (Fixed a) where
-  isJavaIdentifierPart c =
-    c `S.member` isJavaIdentifierPartSet
-
 isJavaIdentifierPartSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isJavaIdentifierPartSet =
   let r = [
             [0..8]
diff --git a/src/Language/Java/Character/IsJavaIdentifierStart.hs b/src/Language/Java/Character/IsJavaIdentifierStart.hs
--- a/src/Language/Java/Character/IsJavaIdentifierStart.hs
+++ b/src/Language/Java/Character/IsJavaIdentifierStart.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isJavaIdentifierStart@.
 class Enum c => IsJavaIdentifierStart c where
@@ -49,13 +48,9 @@
   isJavaIdentifierStart c =
     c `S.member` isJavaIdentifierStartSet
 
-instance HasResolution a => IsJavaIdentifierStart (Fixed a) where
-  isJavaIdentifierStart c =
-    c `S.member` isJavaIdentifierStartSet
-
 isJavaIdentifierStartSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isJavaIdentifierStartSet =
   let r = [
             [36]
diff --git a/src/Language/Java/Character/IsLetter.hs b/src/Language/Java/Character/IsLetter.hs
--- a/src/Language/Java/Character/IsLetter.hs
+++ b/src/Language/Java/Character/IsLetter.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char hiding (isLetter)
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isLetter@.
 class Enum c => IsLetter c where
@@ -49,13 +48,9 @@
   isLetter c =
     c `S.member` isLetterSet
 
-instance HasResolution a => IsLetter (Fixed a) where
-  isLetter c =
-    c `S.member` isLetterSet
-
 isLetterSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isLetterSet =
   let r = [
             [65..90]
diff --git a/src/Language/Java/Character/IsLetterOrDigit.hs b/src/Language/Java/Character/IsLetterOrDigit.hs
--- a/src/Language/Java/Character/IsLetterOrDigit.hs
+++ b/src/Language/Java/Character/IsLetterOrDigit.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isLetterOrDigit@.
 class Enum c => IsLetterOrDigit c where
@@ -49,13 +48,9 @@
   isLetterOrDigit c =
     c `S.member` isLetterOrDigitSet
 
-instance HasResolution a => IsLetterOrDigit (Fixed a) where
-  isLetterOrDigit c =
-    c `S.member` isLetterOrDigitSet
-
 isLetterOrDigitSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isLetterOrDigitSet =
   let r = [
             [48..57]
diff --git a/src/Language/Java/Character/IsLowerCase.hs b/src/Language/Java/Character/IsLowerCase.hs
--- a/src/Language/Java/Character/IsLowerCase.hs
+++ b/src/Language/Java/Character/IsLowerCase.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @IsLowerCase@.
 class Enum c => IsLowerCase c where
@@ -49,13 +48,9 @@
   isLowerCase c =
     c `S.member` isLowerCaseSet
 
-instance HasResolution a => IsLowerCase (Fixed a) where
-  isLowerCase c =
-    c `S.member` isLowerCaseSet
-
 isLowerCaseSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isLowerCaseSet =
   let r = [
             [97..122]
diff --git a/src/Language/Java/Character/IsMirrored.hs b/src/Language/Java/Character/IsMirrored.hs
--- a/src/Language/Java/Character/IsMirrored.hs
+++ b/src/Language/Java/Character/IsMirrored.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isMirrored@.
 class Enum c => IsMirrored c where
@@ -49,13 +48,9 @@
   isMirrored c =
     c `S.member` isMirroredSet
 
-instance HasResolution a => IsMirrored (Fixed a) where
-  isMirrored c =
-    c `S.member` isMirroredSet
-
 isMirroredSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isMirroredSet =
   let r = [
             [40..41]
diff --git a/src/Language/Java/Character/IsSpaceChar.hs b/src/Language/Java/Character/IsSpaceChar.hs
--- a/src/Language/Java/Character/IsSpaceChar.hs
+++ b/src/Language/Java/Character/IsSpaceChar.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isSpaceChar@.
 class Enum c => IsSpaceChar c where
@@ -49,13 +48,9 @@
   isSpaceChar c =
     c `S.member` isSpaceCharSet
 
-instance HasResolution a => IsSpaceChar (Fixed a) where
-  isSpaceChar c =
-    c `S.member` isSpaceCharSet
-
 isSpaceCharSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isSpaceCharSet =
   let r = [
             [32]
diff --git a/src/Language/Java/Character/IsSupplementaryCodePoint.hs b/src/Language/Java/Character/IsSupplementaryCodePoint.hs
--- a/src/Language/Java/Character/IsSupplementaryCodePoint.hs
+++ b/src/Language/Java/Character/IsSupplementaryCodePoint.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isSupplementaryCodePoint@.
 class Enum c => IsSupplementaryCodePoint c where
@@ -49,13 +48,9 @@
   isSupplementaryCodePoint c =
     c `S.member` isSupplementaryCodePointSet
 
-instance HasResolution a => IsSupplementaryCodePoint (Fixed a) where
-  isSupplementaryCodePoint c =
-    c `S.member` isSupplementaryCodePointSet
-
 isSupplementaryCodePointSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isSupplementaryCodePointSet =
   let r = [
             [36]
diff --git a/src/Language/Java/Character/IsTitleCase.hs b/src/Language/Java/Character/IsTitleCase.hs
--- a/src/Language/Java/Character/IsTitleCase.hs
+++ b/src/Language/Java/Character/IsTitleCase.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isTitleCase@.
 class Enum c => IsTitleCase c where
@@ -49,13 +48,9 @@
   isTitleCase c =
     c `S.member` isTitleCaseSet
 
-instance HasResolution a => IsTitleCase (Fixed a) where
-  isTitleCase c =
-    c `S.member` isTitleCaseSet
-
 isTitleCaseSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isTitleCaseSet =
   let r = [
             [453]
diff --git a/src/Language/Java/Character/IsUnicodeIdentifierPart.hs b/src/Language/Java/Character/IsUnicodeIdentifierPart.hs
--- a/src/Language/Java/Character/IsUnicodeIdentifierPart.hs
+++ b/src/Language/Java/Character/IsUnicodeIdentifierPart.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isUnicodeIdentifierPart@.
 class Enum c => IsUnicodeIdentifierPart c where
@@ -49,13 +48,9 @@
   isUnicodeIdentifierPart c =
     c `S.member` isUnicodeIdentifierPartSet
 
-instance HasResolution a => IsUnicodeIdentifierPart (Fixed a) where
-  isUnicodeIdentifierPart c =
-    c `S.member` isUnicodeIdentifierPartSet
-
 isUnicodeIdentifierPartSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isUnicodeIdentifierPartSet =
   let r = [
             [0..8]
diff --git a/src/Language/Java/Character/IsUnicodeIdentifierStart.hs b/src/Language/Java/Character/IsUnicodeIdentifierStart.hs
--- a/src/Language/Java/Character/IsUnicodeIdentifierStart.hs
+++ b/src/Language/Java/Character/IsUnicodeIdentifierStart.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isUnicodeIdentifierStart@.
 class Enum c => IsUnicodeIdentifierStart c where
@@ -49,13 +48,9 @@
   isUnicodeIdentifierStart c =
     c `S.member` isUnicodeIdentifierStartSet
 
-instance HasResolution a => IsUnicodeIdentifierStart (Fixed a) where
-  isUnicodeIdentifierStart c =
-    c `S.member` isUnicodeIdentifierStartSet
-
 isUnicodeIdentifierStartSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isUnicodeIdentifierStartSet =
   let r = [
             [65..90]
diff --git a/src/Language/Java/Character/IsUpperCase.hs b/src/Language/Java/Character/IsUpperCase.hs
--- a/src/Language/Java/Character/IsUpperCase.hs
+++ b/src/Language/Java/Character/IsUpperCase.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isUpperCase@.
 class Enum c => IsUpperCase c where
@@ -49,13 +48,9 @@
   isUpperCase c =
     c `S.member` isUpperCaseSet
 
-instance HasResolution a => IsUpperCase (Fixed a) where
-  isUpperCase c =
-    c `S.member` isUpperCaseSet
-
 isUpperCaseSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isUpperCaseSet =
   let r = [
             [65..90]
diff --git a/src/Language/Java/Character/IsValidCodePoint.hs b/src/Language/Java/Character/IsValidCodePoint.hs
--- a/src/Language/Java/Character/IsValidCodePoint.hs
+++ b/src/Language/Java/Character/IsValidCodePoint.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isValidCodePoint@.
 class Enum c => IsValidCodePoint c where
@@ -49,13 +48,9 @@
   isValidCodePoint c =
     c `S.member` isValidCodePointSet
 
-instance HasResolution a => IsValidCodePoint (Fixed a) where
-  isValidCodePoint c =
-    c `S.member` isValidCodePointSet
-
 isValidCodePointSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isValidCodePointSet =
   let r = [
             [0..1114111]
diff --git a/src/Language/Java/Character/IsWhitespace.hs b/src/Language/Java/Character/IsWhitespace.hs
--- a/src/Language/Java/Character/IsWhitespace.hs
+++ b/src/Language/Java/Character/IsWhitespace.hs
@@ -5,10 +5,9 @@
 ) where
 
 import Data.Char
-import Data.Fixed
 import Data.Word
-import Data.Set(Set)
-import qualified Data.Set as S
+import Data.Set.Diet(Diet)
+import qualified Data.Set.Diet as S
 
 -- | Instances simulate Java characters and provide a decision on simulating @isWhitespace@.
 class Enum c => IsWhitespace c where
@@ -49,13 +48,9 @@
   isWhitespace c =
     c `S.member` isWhitespaceSet
 
-instance HasResolution a => IsWhitespace (Fixed a) where
-  isWhitespace c =
-    c `S.member` isWhitespaceSet
-
 isWhitespaceSet ::
   (Num a, Enum a, Ord a) =>
-  Set a
+  Diet a
 isWhitespaceSet =
   let r = [
             [9..13]