diff --git a/Data/RangeSet/List.hs b/Data/RangeSet/List.hs
--- a/Data/RangeSet/List.hs
+++ b/Data/RangeSet/List.hs
@@ -70,7 +70,7 @@
 
 import Data.Monoid (Monoid(..))
 
--- | Internally set is represented as list of distinct inclusive ranges.
+-- | Internally set is represented as sorted list of distinct inclusive ranges.
 newtype RSet a = RSet [(a, a)]
   deriving (Eq, Ord)
 
diff --git a/range-set-list.cabal b/range-set-list.cabal
--- a/range-set-list.cabal
+++ b/range-set-list.cabal
@@ -1,6 +1,6 @@
 name:                range-set-list
-version:             0.0.1
-synopsis:            Memory efficient sets with continuous ranges of elements. List based implementation.
+version:             0.0.2
+synopsis:            Memory efficient sets with continuous ranges of elements.
 description:         Memory efficient sets with continuous ranges of elements. List based implementation. Interface mimics "Data.Set" interface where possible.
 homepage:            https://github.com/phadej/range-set-list
 bug-reports:         https://github.com/phadej/range-set-list/issues
@@ -14,11 +14,16 @@
 build-type:          Simple
 cabal-version:       >=1.10
 
+flag optimized
+  default: True
+
 library
   exposed-modules:     Data.RangeSet.List
   build-depends:       base >=4.6 && <5
   default-language:    Haskell98
   ghc-options:         -Wall
+  if flag(optimized)
+    ghc-options:       -funbox-strict-fields -O2
 
 test-suite test
   default-language:    Haskell2010
diff --git a/tests/Tests.hs b/tests/Tests.hs
--- a/tests/Tests.hs
+++ b/tests/Tests.hs
@@ -65,6 +65,15 @@
 elementsProp :: SetAction Int -> Bool
 elementsProp seta = Set.elems (toSet seta) == RSet.elems (toRSet seta)
 
+nullProp :: SetAction Int -> Bool
+nullProp seta = Set.null (toSet seta) == RSet.null (toRSet seta)
+
+memberProp :: Int -> SetAction Int -> Bool
+memberProp x seta = Set.member x (toSet seta) == RSet.member x (toRSet seta)
+
+notMemberProp :: Int -> SetAction Int -> Bool
+notMemberProp x seta = Set.notMember x (toSet seta) == RSet.notMember x (toRSet seta)
+
 data RSetAction a = RAEmpty
                   | RASingleton (a, a)
                   | RAFromList [(a, a)]
@@ -114,9 +123,26 @@
 rangeProp :: RSetAction Int8 -> Bool
 rangeProp seta = Set.elems (rangeToSet seta) == RSet.elems (rangeToRSet seta)
 
+ordered :: Ord a => [(a,a)] -> Bool
+ordered rs = all lt $ zip rs (tail rs)
+  where
+    lt :: Ord a => ((a,a),(a,a)) -> Bool
+    lt ((_,y),(u,_)) = y < u
 
+pairOrdered :: Ord a => [(a, a)] -> Bool
+pairOrdered = all (uncurry (<=))
+
+orderedProp :: RSetAction Int8 -> Bool
+orderedProp setAction = ordered rs && pairOrdered rs
+  where rs = RSet.toRangeList . rangeToRSet $ setAction
+
+
 qcProps :: TestTree
 qcProps = testGroup "QuickCheck properties"
   [ QC.testProperty "element operations similar" elementsProp
+  , QC.testProperty "null operation similar" nullProp
+  , QC.testProperty "member operation similar" memberProp
+  , QC.testProperty "notMember operation similar" notMemberProp
   , QC.testProperty "range operations similar" rangeProp
+  , QC.testProperty "ranges remain ordered" orderedProp
   ]