diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.1.3
+
+- Add `Nil` and `Cons` `Set` and `IntSet` instanes
+- Add 'fromList' function for homogeneous things.
+- Enable `PolyKinds` for `Lists` instances.
+
 # 0.1.2
 
 - Add `Overloaded:RecordFields` type-checker plugin to emulate `HasField` from [`GHC.Record.Compat`](https://hackage.haskell.org/package/record-hasfield-1.0/docs/GHC-Records-Compat.html)
diff --git a/overloaded.cabal b/overloaded.cabal
--- a/overloaded.cabal
+++ b/overloaded.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.2
 name:               overloaded
-version:            0.1.2
+version:            0.1.3
 synopsis:           Overloaded pragmas as a plugin
 description:
   Implement @Overloaded@ pragmas as a source plugin
@@ -62,7 +62,7 @@
     , split            ^>=0.2.3.3
     , syb              ^>=0.7.1
     , symbols          ^>=0.3.0.0
-    , vec              ^>=0.1.1.1
+    , vec              ^>=0.1.1.1 || ^>=0.2
 
 test-suite example
   default-language: Haskell2010
diff --git a/src/Overloaded/Lists.hs b/src/Overloaded/Lists.hs
--- a/src/Overloaded/Lists.hs
+++ b/src/Overloaded/Lists.hs
@@ -3,7 +3,7 @@
 {-# LANGUAGE FlexibleInstances      #-}
 {-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE GADTs                  #-}
-{-# LANGUAGE KindSignatures         #-}
+{-# LANGUAGE PolyKinds              #-}
 {-# LANGUAGE ScopedTypeVariables    #-}
 {-# LANGUAGE TypeFamilies           #-}
 {-# LANGUAGE TypeOperators          #-}
@@ -26,14 +26,17 @@
 module Overloaded.Lists (
     Nil (..),
     Cons (..),
+    fromList,
   ) where
 
-import Data.SOP.NP (NP (..), POP (..))
+import Data.Coerce        (coerce)
 import Data.List.NonEmpty (NonEmpty (..))
-import Data.Coerce (coerce)
+import Data.SOP.NP        (NP (..), POP (..))
 
-import qualified Data.Vec.Lazy as Vec
+import qualified Data.IntSet   as IS
+import qualified Data.Set      as S
 import qualified Data.Type.Nat as N
+import qualified Data.Vec.Lazy as Vec
 
 -------------------------------------------------------------------------------
 -- Classes
@@ -43,7 +46,7 @@
 --
 -- See test-suite for ways to define instances for 'Data.Map.Map'.
 -- There are at-least two-ways.
--- 
+--
 class Nil a where
     nil :: a
 
@@ -51,6 +54,10 @@
 class Cons x ys zs | zs -> x ys where
     cons :: x -> ys -> zs
 
+-- | @since 0.1.2
+fromList :: (Nil xs, Cons x xs xs) => [x] -> xs
+fromList = foldr cons nil
+
 -------------------------------------------------------------------------------
 -- base
 -------------------------------------------------------------------------------
@@ -65,6 +72,26 @@
     cons = (:|)
 
 -------------------------------------------------------------------------------
+-- containers
+-------------------------------------------------------------------------------
+
+-- | @since 0.1.2
+instance Nil (S.Set a) where
+    nil = S.empty
+
+-- | @since 0.1.2
+instance Ord a => Cons a (S.Set a) (S.Set a) where
+    cons = S.insert
+
+-- | @since 0.1.2
+instance Nil IS.IntSet where
+    nil = IS.empty
+
+-- | @since 0.1.2
+instance Cons Int IS.IntSet IS.IntSet where
+    cons = IS.insert
+
+-------------------------------------------------------------------------------
 -- vec
 -------------------------------------------------------------------------------
 
@@ -88,4 +115,4 @@
     nil =  POP Nil
 
 instance Cons (NP f xs) (POP f xss) (POP f (xs ': xss)) where
-    cons = coerce ((:*) :: NP f xs -> NP (NP f) xss -> NP (NP f) (xs ': xss))
+    cons = coerce (cons :: NP f xs -> NP (NP f) xss -> NP (NP f) (xs ': xss))
diff --git a/test/Overloaded/Test/Lists.hs b/test/Overloaded/Test/Lists.hs
--- a/test/Overloaded/Test/Lists.hs
+++ b/test/Overloaded/Test/Lists.hs
@@ -12,6 +12,7 @@
 import Test.Tasty.HUnit       (testCase, (@?=))
 
 import qualified Data.Map      as Map
+import qualified Data.Set      as Set
 import qualified Data.Type.Nat as N
 
 import Overloaded.Lists
@@ -50,23 +51,31 @@
         pop @?= POP ((I 0 :* I False :* Nil) :* (I "NO" :* Nil) :* Nil)
 
     , testCase "Map inline" $ do
-        let m :: M Int Char
-            m = [1, 'x', 3, 'y', 2, 'z']
+        let m :: Map.Map Int Char
+            m = unM [1, 'x', 3, 'y', 2, 'z']
 
-        m @?= M (Map.fromList [(1,'x'),(2,'z'),(3,'y')])
+        m @?= Map.fromList [(1,'x'),(2,'z'),(3,'y')]
 
     , testCase "Map pairs" $ do
-        let m :: N Int Char
-            m = [(1, 'x'), (3, 'y'), (2, 'z')]
+        let m :: Map.Map Int Char
+            m = unN [(1, 'x'), (3, 'y'), (2, 'z')]
 
-        m @?= N (Map.fromList [(1,'x'),(2,'z'),(3,'y')])
+        m @?= Map.fromList [(1,'x'),(2,'z'),(3,'y')]
+
+    , testCase "Set" $ do
+        let s :: Set.Set Char
+            s = ['f', 'o', 'o']
+
+        s @?= Set.fromList ['o', 'f']
+
+        s @?= fromList ['o', 'f']
     ]
 
 -------------------------------------------------------------------------------
 -- Map inline
 -------------------------------------------------------------------------------
 
-newtype M k v = M (Map.Map k v)
+newtype M k v = M { unM :: Map.Map k v }
   deriving (Eq, Show)
 
 newtype M' k v = M' (k -> Map.Map k v)
@@ -84,7 +93,7 @@
 -- Map pairs
 -------------------------------------------------------------------------------
 
-newtype N k v = N (Map.Map k v)
+newtype N k v = N { unN :: Map.Map k v }
   deriving (Eq, Show)
 
 instance Nil (N k v) where