diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,11 @@
 
+# 0.5.0
+
+20200323
+
+ - start using version 0.8.0 of first-class-families
+ - a documentation fix
+
 # 0.4.0
 
 20200216
diff --git a/default.nix b/default.nix
--- a/default.nix
+++ b/default.nix
@@ -16,17 +16,17 @@
           # });
           first-class-families = self.callCabal2nix "first-class-families" 
           #   ~/gito/first-class-families {}; 
-            (pkgs.fetchFromGitHub { # 0.7
+            (pkgs.fetchFromGitHub { # 0.8
               owner  = "Lysxia";
               repo   = "first-class-families";
-              rev    = "120e41ea3831b9ffad62239e109c1b2a0aaf269f";
-              sha256 = "0pyxpnkgr2rgn83whl37jh7k3rdr5hiprdmfkswwj7c1nhl1ky5i";
+              rev    = "4a0bf3ea9c125bb4009b61ce70b1a5339b7b2072";
+              sha256 = "14387mpfvds226iynkpay3aaqamvxznxjsmg2qcwdxafdvxmyq9z";
             }) {};
-            # (pkgs.fetchFromGitHub { # 0.6 TODO remove this
+            # (pkgs.fetchFromGitHub { # 0.7
             #   owner  = "Lysxia";
             #   repo   = "first-class-families";
-            #   rev    = "2fb77468d3b0ce64dc5371bed1b636d60219975c";
-            #   sha256 = "1jvn11nbb7271hhy7q21cyn4r238pfzj00aabd39gwhi0g2gzqbf";
+            #   rev    = "120e41ea3831b9ffad62239e109c1b2a0aaf269f";
+            #   sha256 = "0pyxpnkgr2rgn83whl37jh7k3rdr5hiprdmfkswwj7c1nhl1ky5i";
             # }) {};
         };
       };
diff --git a/fcf-containers.cabal b/fcf-containers.cabal
--- a/fcf-containers.cabal
+++ b/fcf-containers.cabal
@@ -6,7 +6,7 @@
     contents of containers-package and show how these can be used. Everything is
     based on the ideas given in the first-class-families -package.
 Homepage:            https://github.com/gspia/fcf-containers
-Version:             0.4.0
+Version:             0.5.0
 Build-type:          Simple
 Author:              gspia
 Maintainer:          iahogsp@gmail.com
@@ -24,14 +24,14 @@
                    , Fcf.Data.NatMap
                    , Fcf.Data.Tree
                    , Fcf.Data.Set
-                   , Fcf.Data.Symbol
                    , Fcf.Data.Text
                    , Fcf.Alg.List
                    , Fcf.Alg.Sort
+                   , Fcf.Alg.Symbol
                    , Fcf.Alg.Tree
                    , Fcf.Alg.Morphism
   build-depends:     base >= 4.9 && < 4.14
-                   , first-class-families >= 0.7 && < 0.8
+                   , first-class-families >= 0.8 && < 0.9
   ghc-options:      -Wall
   default-language:  Haskell2010
   -- ghc-options:
@@ -58,10 +58,10 @@
   default-language: Haskell2010
   other-modules:    Fcf.Alg.Morphism
                   , Fcf.Alg.List
+                  , Fcf.Alg.Symbol
                   , Fcf.Data.Tree
                   , Fcf.Data.MapC
                   , Fcf.Data.Set
-                  , Fcf.Data.Symbol
                   , Fcf.Data.Text
   build-depends:    base
                   , first-class-families
diff --git a/src/Fcf/Alg/List.hs b/src/Fcf/Alg/List.hs
--- a/src/Fcf/Alg/List.hs
+++ b/src/Fcf/Alg/List.hs
@@ -29,13 +29,12 @@
 
 import qualified GHC.TypeLits as TL
 
-import           Fcf.Core (Eval, Exp, type (@@))
-import           Fcf.Classes (Map)
-import           Fcf.Combinators (type (=<<), type (<=<), Pure)
-import           Fcf.Data.List (Foldr, Concat, TakeWhile, DropWhile, Reverse
-                               , type (++), ZipWith, Elem, Take, Unfoldr)
+import           Fcf.Core (Eval, Exp)
+import           Fcf.Class.Foldable (And)
+import           Fcf.Class.Functor (FMap)
+import           Fcf.Combinators (type (=<<), Pure)
+import           Fcf.Data.List (Foldr, Reverse, ZipWith, Elem, Take, Unfoldr)
 import           Fcf.Utils (If, TyEq)
-import           Fcf.Data.Bool (type (&&), type  (||), Not)
 import           Fcf.Data.Nat
 
 import           Fcf.Alg.Morphism
@@ -53,8 +52,8 @@
 data ListF a b = ConsF a b | NilF
 
 -- We need a functor instance for Cata and Ana to work.
-type instance Eval (Map f 'NilF) = 'NilF
-type instance Eval (Map f ('ConsF a b)) = 'ConsF a (Eval (f b))
+type instance Eval (FMap f 'NilF) = 'NilF
+type instance Eval (FMap f ('ConsF a b)) = 'ConsF a (Eval (f b))
 
 --------------------------------------------------------------------------------
 
@@ -222,251 +221,6 @@
 
 --------------------------------------------------------------------------------
 
--- | Partition
--- 
--- === __Example__
--- 
--- >>> :kind! Eval (Fcf.Alg.List.Partition ((>=) 35) '[ 20, 30, 40, 50])
--- Eval (Fcf.Alg.List.Partition ((>=) 35) '[ 20, 30, 40, 50]) :: ([Nat],
---                                                                [Nat])
--- = '( '[20, 30], '[40, 50])
-data Partition :: (a -> Exp Bool) -> [a] -> Exp ([a],[a])
-type instance Eval (Partition p lst) = Eval (Foldr (PartHelp p) '( '[], '[]) lst)
-
--- helper
-data PartHelp :: (a -> Exp Bool) -> a -> ([a],[a]) -> Exp ([a],[a])
-type instance Eval (PartHelp p a '(xs,ys)) =
-    If (Eval (p a))
-        '(a ': xs, ys)
-        '(xs, a ': ys)
-
--- | Intersperse for type-level lists.
---
--- === __Example__
--- 
--- >>> :kind! Eval (Intersperse 0 '[1,2,3,4])
--- Eval (Intersperse 0 '[1,2,3,4]) :: [Nat]
--- = '[1, 0, 2, 0, 3, 0, 4]
-data Intersperse :: a -> [a] -> Exp [a]
-type instance Eval (Intersperse _   '[]      ) = '[]
-type instance Eval (Intersperse sep (x ': xs)) = x ': Eval (PrependToAll sep xs)
-
--- helper for Intersperse
-data PrependToAll :: a -> [a] -> Exp [a]
-type instance Eval (PrependToAll _   '[]      ) = '[]
-type instance Eval (PrependToAll sep (x ': xs)) = sep ': x ': Eval (PrependToAll sep xs)
-
--- | Intercalate for type-level lists.
--- 
--- === __Example__
--- 
--- >>> :kind! Eval (Intercalate '[", "] '[ '["Lorem"], '["ipsum"], '["dolor"] ])
--- Eval (Intercalate '[", "] '[ '["Lorem"], '["ipsum"], '["dolor"] ]) :: [TL.Symbol]
--- = '["Lorem", ", ", "ipsum", ", ", "dolor"]
-data Intercalate :: [a] -> [[a]] -> Exp [a]
-type instance Eval (Intercalate xs xss) = Eval (Concat =<< Intersperse xs xss)
-
-
--- | 'Span', applied to a predicate @p@ and a type-level list @xs@, returns a 
--- type-level tuple where
--- first element is longest prefix (possibly empty) of @xs@ of elements that
--- satisfy @p@ and second element is the remainder of the list:
---
--- === __Example__
--- 
--- >>> :kind! Eval (Span (Flip (<) 3) '[1,2,3,4,1,2,3,4])
--- Eval (Span (Flip (<) 3) '[1,2,3,4,1,2,3,4]) :: ([Nat], [Nat])
--- = '( '[1, 2], '[3, 4, 1, 2, 3, 4])
---
--- >>> :kind! Eval (Span (Flip (<) 9) '[1,2,3])
--- Eval (Span (Flip (<) 9) '[1,2,3]) :: ([Nat], [Nat])
--- = '( '[1, 2, 3], '[])
---
--- >>> :kind! Eval (Span (Flip (<) 0) '[1,2,3])
--- Eval (Span (Flip (<) 0) '[1,2,3]) :: ([Nat], [Nat])
--- = '( '[], '[1, 2, 3])
-data Span :: (a -> Exp Bool) -> [a] -> Exp ([a],[a])
-type instance Eval (Span p lst) = '( Eval (TakeWhile p lst), Eval (DropWhile p lst))
-
-
--- | 'Break', applied to a predicate @p@ and a type-level list @xs@, returns a 
--- type-level tuple where
--- first element is longest prefix (possibly empty) of @xs@ of elements that
--- /do not satisfy/ @p@ and second element is the remainder of the list:
---
--- === __Example__
--- 
--- >>> :kind! Eval (Break (Flip (>) 3) '[1,2,3,4,1,2,3,4])
--- Eval (Break (Flip (>) 3) '[1,2,3,4,1,2,3,4]) :: ([Nat], [Nat])
--- = '( '[1, 2, 3], '[4, 1, 2, 3, 4])
---
--- >>> :kind! Eval (Break (Flip (<) 9) '[1,2,3])
--- Eval (Break (Flip (<) 9) '[1,2,3]) :: ([Nat], [Nat])
--- = '( '[], '[1, 2, 3])
---
--- >>> :kind! Eval (Break (Flip (>) 9) '[1,2,3])
--- Eval (Break (Flip (>) 9) '[1,2,3]) :: ([Nat], [Nat])
--- = '( '[1, 2, 3], '[])
-data Break :: (a -> Exp Bool) -> [a] -> Exp ([a],[a])
-type instance Eval (Break p lst) = Eval (Span (Not <=< p) lst)
-
-
--- | IsPrefixOf takes two type-level lists and returns true
--- iff the first list is a prefix of the second.
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsPrefixOf '[0,1,2] '[0,1,2,3,4,5])
--- Eval (IsPrefixOf '[0,1,2] '[0,1,2,3,4,5]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (IsPrefixOf '[0,1,2] '[0,1,3,2,4,5])
--- Eval (IsPrefixOf '[0,1,2] '[0,1,3,2,4,5]) :: Bool
--- = 'False
---
--- >>> :kind! Eval (IsPrefixOf '[] '[0,1,3,2,4,5])
--- Eval (IsPrefixOf '[] '[0,1,3,2,4,5]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (IsPrefixOf '[0,1,3,2,4,5] '[])
--- Eval (IsPrefixOf '[0,1,3,2,4,5] '[]) :: Bool
--- = 'False
-data IsPrefixOf :: [a] -> [a] -> Exp Bool
-type instance Eval (IsPrefixOf xs ys) = IsPrefixOf_ xs ys
-
--- helper for IsPrefixOf
-type family IsPrefixOf_ (xs :: [a]) (ys :: [a]) :: Bool where
-    IsPrefixOf_ '[] _ = 'True
-    IsPrefixOf_ _ '[] = 'False
-    IsPrefixOf_ (x ': xs) (y ': ys) =
-         Eval ((Eval (TyEq x y)) && IsPrefixOf_ xs ys)
-
-
--- | IsSuffixOf take two type-level lists and returns true
--- iff the first list is a suffix of the second.
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsSuffixOf '[3,4,5] '[0,1,2,3,4,5])
--- Eval (IsSuffixOf '[3,4,5] '[0,1,2,3,4,5]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (IsSuffixOf '[3,4,5] '[0,1,3,2,4,5])
--- Eval (IsSuffixOf '[3,4,5] '[0,1,3,2,4,5]) :: Bool
--- = 'False
---
--- >>> :kind! Eval (IsSuffixOf '[] '[0,1,3,2,4,5])
--- Eval (IsSuffixOf '[] '[0,1,3,2,4,5]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (IsSuffixOf '[0,1,3,2,4,5] '[])
--- Eval (IsSuffixOf '[0,1,3,2,4,5] '[]) :: Bool
--- = 'False
-data IsSuffixOf :: [a] -> [a] -> Exp Bool
-type instance Eval (IsSuffixOf xs ys) =
-    Eval (IsPrefixOf (Reverse @@ xs) (Reverse @@ ys))
-
-
--- | IsInfixOf take two type-level lists and returns true
--- iff the first list is a infix of the second.
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsInfixOf '[2,3,4]  '[0,1,2,3,4,5,6])
--- Eval (IsInfixOf '[2,3,4]  '[0,1,2,3,4,5,6]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (IsInfixOf '[2,4,4]  '[0,1,2,3,4,5,6])
--- Eval (IsInfixOf '[2,4,4]  '[0,1,2,3,4,5,6]) :: Bool
--- = 'False
-data IsInfixOf :: [a] -> [a] -> Exp Bool
-type instance Eval (IsInfixOf xs ys) = Eval (Any (IsPrefixOf xs) =<< Tails ys)
-
-
--- | Tails
--- 
--- === __Example__
--- 
--- >>> :kind! Eval (Tails '[0,1,2,3])
--- Eval (Tails '[0,1,2,3]) :: [[Nat]]
--- = '[ '[0, 1, 2, 3], '[1, 2, 3], '[2, 3], '[3]]
-data Tails :: [a] -> Exp [[a]]
-type instance Eval (Tails '[]) = '[]
-type instance Eval (Tails (a ': as)) = (a ': as) ': Eval (Tails as)
-
---------------------------------------------------------------------------------
-
-
--- | Give true if all of the booleans in the list are true.
---
--- === __Example__
--- 
--- >>> :kind! Eval (And '[ 'True, 'True])
--- Eval (And '[ 'True, 'True]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (And '[ 'True, 'True, 'False])
--- Eval (And '[ 'True, 'True, 'False]) :: Bool
--- = 'False
-data And :: [Bool] -> Exp Bool
-type instance Eval (And lst) = Eval (Foldr (&&) 'True lst)
-
-
--- | Type-level All.
---
--- === __Example__
---
--- >>> :kind! Eval (All (Flip (<) 6) '[0,1,2,3,4,5])
--- Eval (All (Flip (<) 6) '[0,1,2,3,4,5]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (All (Flip (<) 5) '[0,1,2,3,4,5])
--- Eval (All (Flip (<) 5) '[0,1,2,3,4,5]) :: Bool
--- = 'False
-data All :: (a -> Exp Bool) -> [a] -> Exp Bool
-type instance Eval (All p lst) = Eval (And =<< Map p lst)
-
-
--- | Give true if any of the booleans in the list is true.
---
--- === __Example__
--- 
--- >>> :kind! Eval (Or '[ 'True, 'True])
--- Eval (Or '[ 'True, 'True]) :: Bool
--- = 'True
--- 
--- >>> :kind! Eval (Or '[ 'False, 'False])
--- Eval (Or '[ 'False, 'False]) :: Bool
--- = 'False
-data Or :: [Bool] -> Exp Bool
-type instance Eval (Or lst) = Eval (Foldr (||) 'False lst)
-
-
--- | Type-level Any.
---
--- === __Example__
--- 
--- >>> :kind! Eval (Any (Flip (<) 5) '[0,1,2,3,4,5])
--- Eval (Any (Flip (<) 5) '[0,1,2,3,4,5]) :: Bool
--- = 'True
---
--- >>> :kind! Eval (Any (Flip (<) 0) '[0,1,2,3,4,5])
--- Eval (Any (Flip (<) 0) '[0,1,2,3,4,5]) :: Bool
--- = 'False
-data Any :: (a -> Exp Bool) -> [a] -> Exp Bool
-type instance Eval (Any p lst) = Eval (Or =<< Map p lst)
-
---------------------------------------------------------------------------------
-
--- | Snoc for type-level lists.
---
--- === __Example__
--- 
--- >>> :kind! Eval (Snoc '[1,2,3] 4)
--- Eval (Snoc '[1,2,3] 4) :: [Nat]
--- = '[1, 2, 3, 4]
-data Snoc :: [a] -> a -> Exp [a]
-type instance Eval (Snoc lst a) = Eval (lst ++ '[a])
 
 -- | ToList for type-level lists.
 --
diff --git a/src/Fcf/Alg/Sort.hs b/src/Fcf/Alg/Sort.hs
--- a/src/Fcf/Alg/Sort.hs
+++ b/src/Fcf/Alg/Sort.hs
@@ -28,12 +28,13 @@
                      , Flip, Not, TyEq, Pure )
 import           Fcf.Data.List ( ZipWith, Filter, type (++) )
 import           Fcf.Data.Nat (Nat)
+import           Fcf.Data.Symbol (Symbol)
 
 --------------------------------------------------------------------------------
 
 import           Fcf.Alg.Tree (BTreeF(..))
 import           Fcf.Alg.Morphism
-import           Fcf.Data.Symbol (Symbol, SymbolOrd)
+import           Fcf.Alg.Symbol (SymbolOrd)
 
 --------------------------------------------------------------------------------
 
@@ -41,7 +42,7 @@
 
 -- $setup
 -- >>> import qualified Fcf.Data.Nat as N ( type (<) )
--- >>> import qualified Fcf.Data.Symbol as S ( type (<) )
+-- >>> import qualified Fcf.Alg.Symbol as S ( type (<) )
 
 --------------------------------------------------------------------------------
 
diff --git a/src/Fcf/Alg/Symbol.hs b/src/Fcf/Alg/Symbol.hs
new file mode 100644
--- /dev/null
+++ b/src/Fcf/Alg/Symbol.hs
@@ -0,0 +1,251 @@
+{-# LANGUAGE DataKinds              #-}
+{-# LANGUAGE PolyKinds              #-}
+{-# LANGUAGE TypeFamilies           #-}
+{-# LANGUAGE TypeInType             #-}
+{-# LANGUAGE TypeOperators          #-}
+{-# LANGUAGE UndecidableInstances   #-}
+{-# OPTIONS_GHC -Wall                       #-}
+{-# OPTIONS_GHC -Werror=incomplete-patterns #-}
+
+{-|
+Module      : Fcf.Alg.Symbol
+Description : Type level symbols
+Copyright   : (c) gspia 2020-
+License     : BSD
+Maintainer  : gspia
+
+= Fcf.Alg.Symbol
+
+Type-level symbols and functions for them.
+
+Note that the operators from this module conflict with "GHC.TypeLits".
+
+
+TODO: Would this whole module have a place first-class-families?
+
+-}
+
+--------------------------------------------------------------------------------
+
+module Fcf.Alg.Symbol
+    ( -- * Reexported type
+      -- | From "Fcf.Data.Symbol" (which is from GHC).
+
+      module X
+
+      -- * Functions
+
+    , Append
+    , Intercalate
+    , IsSpace
+    , IsNewLine
+    , IsTab
+    , IsSpaceDelim
+    , IsDigit
+
+     -- * Comparison functions
+
+    , SymbolOrd
+    , type (<=)
+    , type (>=)
+    , type (<)
+    , type (>)
+    , type (==)
+    )
+  where
+
+--------------------------------------------------------------------------------
+        
+import           GHC.TypeLits (Symbol)
+import qualified GHC.TypeLits as TL
+
+import           Fcf.Core (Eval, Exp)
+import           Fcf.Data.List (Foldr, Elem)
+import           Fcf.Data.Bool (type (||))
+import           Fcf.Data.Symbol as X
+import           Fcf.Utils (TyEq)
+
+import           Fcf.Combinators (type (=<<))
+
+--------------------------------------------------------------------------------
+
+-- | Append two type-level symbols.
+--
+-- === __Example__
+-- 
+-- >>> :kind! Eval (Append "hmm" " ok")
+-- Eval (Append "hmm" " ok") :: Symbol
+-- = "hmm ok"
+data Append :: Symbol -> Symbol -> Exp Symbol
+type instance Eval (Append s1 s2) = TL.AppendSymbol s1 s2
+
+
+-- | Intercalate type-level symbols.
+-- 
+-- === __Example__
+-- 
+-- >>> :kind! Eval (Intercalate "+" '["aa", "bb", "cc"])
+-- Eval (Intercalate "+" '["aa", "bb", "cc"]) :: Symbol
+-- = "aa+bb+cc"
+--
+-- >>> :kind! Eval (Intercalate "+" '["aa"])
+-- Eval (Intercalate "+" '["aa"]) :: Symbol
+-- = "aa"
+--
+-- >>> :kind! Eval (Intercalate "+" '[])
+-- Eval (Intercalate "+" '[]) :: Symbol
+-- = ""
+data Intercalate :: Symbol -> [Symbol] -> Exp Symbol
+type instance Eval (Intercalate s1 '[]) = ""
+type instance Eval (Intercalate s1 (s ': sLst)) =
+    Eval (Append s =<< Foldr (InterCalHelp s1) "" sLst)
+
+-- helper
+data InterCalHelp :: Symbol -> Symbol -> Symbol -> Exp Symbol
+type instance Eval (InterCalHelp s s1 s2) = Eval (Append (Eval (Append s s1)) s2)
+
+
+-- | IsSpace
+--
+-- === __Example__
+-- 
+-- >>> :kind! Eval (IsSpace "a")
+-- Eval (IsSpace "a") :: Bool
+-- = 'False
+--
+-- >>> :kind! Eval (IsSpace " ")
+-- Eval (IsSpace " ") :: Bool
+-- = 'True
+data IsSpace :: Symbol -> Exp Bool
+type instance Eval (IsSpace s) = Eval (s == " ")
+
+
+-- | IsNewline
+--
+-- === __Example__
+-- 
+-- >>> :kind! Eval (IsNewLine "a")
+-- Eval (IsNewLine "a") :: Bool
+-- = 'False
+--
+-- >>> :kind! Eval (IsNewLine "\n")
+-- Eval (IsNewLine "\n") :: Bool
+-- = 'True
+data IsNewLine :: Symbol -> Exp Bool
+type instance Eval (IsNewLine s) = Eval (s == "\n")
+
+
+-- | IsTab
+--
+-- === __Example__
+-- 
+-- >>> :kind! Eval (IsTab "a")
+-- Eval (IsTab "a") :: Bool
+-- = 'False
+--
+-- >>> :kind! Eval (IsTab "\t")
+-- Eval (IsTab "\t") :: Bool
+-- = 'True
+data IsTab :: Symbol -> Exp Bool
+type instance Eval (IsTab s) = Eval (s == "\t")
+
+
+-- | IsSpaceDelim
+--
+-- === __Example__
+-- 
+-- >>> :kind! Eval (IsSpaceDelim "a")
+-- Eval (IsSpaceDelim "a") :: Bool
+-- = 'False
+--
+-- >>> :kind! Eval (IsSpaceDelim "\n")
+-- Eval (IsSpaceDelim "\n") :: Bool
+-- = 'True
+data IsSpaceDelim :: Symbol -> Exp Bool
+type instance Eval (IsSpaceDelim s) =
+    Eval (Eval (IsSpace s) || (Eval (Eval (IsNewLine s) || Eval (IsTab s))))
+
+
+-- | IsDigit
+--
+-- === __Example__
+-- 
+-- >>> :kind! Eval (IsDigit "3")
+-- Eval (IsDigit "3") :: Bool
+-- = 'True
+--
+-- >>> :kind! Eval (IsDigit "a")
+-- Eval (IsDigit "a") :: Bool
+-- = 'False
+data IsDigit :: Symbol -> Exp Bool
+type instance Eval (IsDigit s)
+    = Eval (Elem s '["0","1","2","3","4","5","6","7","8","9"])
+
+
+
+--------------------------------------------------------------------------------
+
+
+-- | SymbolOrd - compare two symbols and give type-level Ordering 
+-- ( $ 'LT $, $ 'EQ $ or $ 'GT $ ).
+--
+-- === __Example__
+-- 
+-- >>> :kind! Eval (SymbolOrd "a" "b")
+-- Eval (SymbolOrd "a" "b") :: Ordering
+-- = 'LT
+data SymbolOrd :: Symbol -> Symbol -> Exp Ordering
+type instance Eval (SymbolOrd a b) = TL.CmpSymbol a b
+
+-- | Less-than-or-equal comparison for symbols.
+-- 
+-- === __Example__
+-- 
+-- >>> :kind! Eval ("b" <= "a")
+-- Eval ("b" <= "a") :: Bool
+-- = 'False
+--
+data (<=) :: Symbol -> Symbol -> Exp Bool
+type instance Eval ((<=) a b) =
+    Eval (Eval (TyEq (TL.CmpSymbol a b) 'LT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))
+
+-- | Larger-than-or-equal comparison for symbols.
+-- 
+-- === __Example__
+-- 
+-- >>> :kind! Eval ("b" >= "a")
+-- Eval ("b" >= "a") :: Bool
+-- = 'True
+data (>=) :: Symbol -> Symbol -> Exp Bool
+type instance Eval ((>=) a b) =
+    Eval (Eval (TyEq (TL.CmpSymbol a b) 'GT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))
+
+-- | Less-than comparison for symbols.
+-- 
+-- === __Example__
+-- 
+-- >>> :kind! Eval ("a" < "b")
+-- Eval ("a" < "b") :: Bool
+-- = 'True
+data (<) :: Symbol -> Symbol -> Exp Bool
+type instance Eval ((<) a b) = Eval (TyEq (TL.CmpSymbol a b) 'LT)
+
+-- | Larger-than comparison for symbols.
+-- 
+-- === __Example__
+-- 
+-- >>> :kind! Eval ("b" > "a")
+-- Eval ("b" > "a") :: Bool
+-- = 'True
+data (>) :: Symbol -> Symbol -> Exp Bool
+type instance Eval ((>) a b) = Eval (TyEq (TL.CmpSymbol a b) 'GT)
+
+-- | Equality of symbols
+-- 
+-- === __Example__
+-- 
+-- >>> :kind! Eval ("b" == "a")
+-- Eval ("b" == "a") :: Bool
+-- = 'False
+data (==) :: Symbol -> Symbol -> Exp Bool
+type instance Eval ((==) a b) = Eval (TyEq (TL.CmpSymbol a b) 'EQ)
diff --git a/src/Fcf/Data/MapC.hs b/src/Fcf/Data/MapC.hs
--- a/src/Fcf/Data/MapC.hs
+++ b/src/Fcf/Data/MapC.hs
@@ -82,10 +82,10 @@
                      , type (++), Not, If
                      , Pure, TyEq, Length, Uncurry)
 import qualified Fcf as Fcf (Map, Foldr, Filter)
-import           Fcf.Data.List (Elem)
+import qualified Fcf.Data.List as L (Elem, Partition)
 
 import           Fcf.Alg.Morphism
-import qualified Fcf.Alg.List as Fcf (Partition)
+-- import qualified Fcf.Alg.List as Fcf (Partition)
 
 --------------------------------------------------------------------------------
 
@@ -94,7 +94,7 @@
 -- $setup
 -- >>> import           Fcf (type (>=))
 -- >>> import           Fcf.Data.Nat
--- >>> import           Fcf.Data.Symbol (Symbol,Append)
+-- >>> import           Fcf.Alg.Symbol (Symbol,Append)
 
 --------------------------------------------------------------------------------
 
@@ -154,7 +154,7 @@
 -- = 'MapC '[ '(3, "hih"), '(1, "haa"), '(2, "hoo")]
 data Insert :: k -> v -> MapC k v -> Exp (MapC k v)
 type instance Eval (Insert k v ('MapC lst)) =
-    If (Eval (Elem k =<< Fcf.Map Fst lst))
+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))
         ('MapC lst)
         ('MapC ( '(k,v) ': lst))
 
@@ -179,7 +179,7 @@
 -- = 'MapC '[ '(7, "xxx")]
 data InsertWith :: (v -> v -> Exp v) -> k -> v -> MapC k v -> Exp (MapC k v)
 type instance Eval (InsertWith f k v ('MapC lst)) =
-    If (Eval (Elem k =<< Fcf.Map Fst lst))
+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))
         ('MapC (Eval (Fcf.Map (InsWithHelp f k v) lst)))
         ('MapC (Eval (lst ++ '[ '(k,v)])))
 
@@ -272,7 +272,7 @@
 -- = 'False
 data Member :: k -> MapC k v -> Exp Bool
 type instance Eval (Member k mp) =
-    Eval (Elem k =<< Keys mp)
+    Eval (L.Elem k =<< Keys mp)
 
 -- | NotMember
 --
@@ -286,7 +286,7 @@
 -- = 'True
 data NotMember :: k -> MapC k v -> Exp Bool
 type instance Eval (NotMember k mp) =
-    Eval (Not =<< Elem k =<< Keys mp)
+    Eval (Not =<< L.Elem k =<< Keys mp)
 
 -- | Null
 --
@@ -327,7 +327,7 @@
 
 data UComb :: (k,v) -> [(k,v)] -> Exp [(k,v)]
 type instance Eval (UComb '(k,v) lst) =
-    If (Eval (Elem k =<< Fcf.Map Fst lst))
+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))
         lst
         ('(k,v) ': lst)
 
@@ -348,7 +348,7 @@
 -- helper
 data DiffNotMem :: MapC k v -> k -> v -> Exp Bool
 type instance Eval (DiffNotMem mp k _) =
-    Eval (Not =<< Elem k =<< Keys mp)
+    Eval (Not =<< L.Elem k =<< Keys mp)
 
 
 -- | Intersection
@@ -366,7 +366,7 @@
 
 -- helper
 data InterMem :: MapC k v -> k -> v -> Exp Bool
-type instance Eval (InterMem mp k _) = Eval (Elem k =<< Keys mp)
+type instance Eval (InterMem mp k _) = Eval (L.Elem k =<< Keys mp)
 
 
 -- | Disjoint
@@ -519,7 +519,7 @@
 -- = '( 'MapC '[ '(3, 30)], 'MapC '[ '(5, 50)])
 data Partition :: (v -> Exp Bool) -> MapC k v -> Exp (MapC k v, MapC k v)
 type instance Eval (Partition f ('MapC lst)) =
-    Eval (PartitionHlp (Eval (Fcf.Partition (f <=< Snd) lst)))
+    Eval (PartitionHlp (Eval (L.Partition (f <=< Snd) lst)))
 
 data PartitionHlp :: ([(k,v)],[(k,v)]) -> Exp (MapC k v, MapC k v)
 type instance Eval (PartitionHlp '(xs,ys)) = '( 'MapC xs, 'MapC ys)
diff --git a/src/Fcf/Data/NatMap.hs b/src/Fcf/Data/NatMap.hs
--- a/src/Fcf/Data/NatMap.hs
+++ b/src/Fcf/Data/NatMap.hs
@@ -14,11 +14,11 @@
 License     : BSD
 Maintainer  : gspia
 
-= Fcf.Data.NatNatMap
+= Fcf.Data.NatMap
 
 NatMap provides an interface to mapping keys (Nat's) to values, which is
 similar to
-NatIntMap given by the containers-package. Note that the this module still misses
+IntMap given by the containers-package. Note that the this module still misses
 some of the methods that can be found in containers. If you need some, please
 do open up an issue or better, make a PR.
 
@@ -71,17 +71,14 @@
     )
   where
 
--- import qualified GHC.TypeLits as TL
-
 import           Fcf ( Eval, Exp, Fst, Snd, type (=<<), type (<=<), type (@@)
                      , type (++), Not, If
                      , Pure, TyEq, Length, Uncurry)
 import qualified Fcf as Fcf (Map, Foldr, Filter)
-import           Fcf.Data.List (Elem)
+import qualified Fcf.Data.List as L (Elem, Partition)
 
 import           Fcf.Data.Nat
 import           Fcf.Alg.Morphism
-import qualified Fcf.Alg.List as Fcf (Partition)
 
 --------------------------------------------------------------------------------
 
@@ -90,7 +87,7 @@
 -- $setup
 -- >>> import           Fcf (type (>=))
 -- >>> import           Fcf.Data.Nat
--- >>> import           Fcf.Data.Symbol (Symbol,Append)
+-- >>> import           Fcf.Alg.Symbol (Symbol,Append)
 
 --------------------------------------------------------------------------------
 
@@ -149,13 +146,15 @@
 -- = 'NatMap '[ '(3, "hih"), '(1, "haa"), '(2, "hoo")]
 data Insert :: Nat -> v -> NatMap v -> Exp (NatMap v)
 type instance Eval (Insert k v ('NatMap lst)) =
-    If (Eval (Elem k =<< Fcf.Map Fst lst))
+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))
         ('NatMap lst)
         ('NatMap ( '(k,v) ': lst))
 
 
 -- | InsertWith
+--
 -- if old there, map
+--
 -- if no old, add
 --
 -- === __Example__
@@ -175,7 +174,7 @@
 -- = 'NatMap '[ '(7, "xxx")]
 data InsertWith :: (v -> v -> Exp v) -> Nat -> v -> NatMap v -> Exp (NatMap v)
 type instance Eval (InsertWith f k v ('NatMap lst)) =
-    If (Eval (Elem k =<< Fcf.Map Fst lst))
+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))
         ('NatMap (Eval (Fcf.Map (InsWithHelp f k v) lst)))
         ('NatMap (Eval (lst ++ '[ '(k,v)])))
 
@@ -268,7 +267,7 @@
 -- = 'False
 data Member :: Nat -> NatMap v -> Exp Bool
 type instance Eval (Member k mp) =
-    Eval (Elem k =<< Keys mp)
+    Eval (L.Elem k =<< Keys mp)
 
 -- | NotMember
 --
@@ -282,7 +281,7 @@
 -- = 'True
 data NotMember :: Nat -> NatMap v -> Exp Bool
 type instance Eval (NotMember k mp) =
-    Eval (Not =<< Elem k =<< Keys mp)
+    Eval (Not =<< L.Elem k =<< Keys mp)
 
 -- | Null
 --
@@ -322,7 +321,7 @@
 
 data UComb :: (k,v) -> [(k,v)] -> Exp [(k,v)]
 type instance Eval (UComb '(k,v) lst) =
-    If (Eval (Elem k =<< Fcf.Map Fst lst))
+    If (Eval (L.Elem k =<< Fcf.Map Fst lst))
         lst
         ('(k,v) ': lst)
 
@@ -342,7 +341,7 @@
 -- helper
 data DiffNotMem :: NatMap v -> k -> v -> Exp Bool
 type instance Eval (DiffNotMem mp k _) =
-    Eval (Not =<< Elem k =<< Keys mp)
+    Eval (Not =<< L.Elem k =<< Keys mp)
 
 
 -- | Intersection
@@ -359,7 +358,7 @@
 
 -- helper
 data InterMem :: NatMap v -> Nat -> v -> Exp Bool
-type instance Eval (InterMem mp k _) = Eval (Elem k =<< Keys mp)
+type instance Eval (InterMem mp k _) = Eval (L.Elem k =<< Keys mp)
 
 
 -- | Disjoint
@@ -513,7 +512,7 @@
 -- = '( 'NatMap '[ '(3, 30)], 'NatMap '[ '(5, 50)])
 data Partition :: (v -> Exp Bool) -> NatMap v -> Exp (NatMap v, NatMap v)
 type instance Eval (Partition f ('NatMap lst)) =
-    Eval (PartitionHlp (Eval (Fcf.Partition (f <=< Snd) lst)))
+    Eval (PartitionHlp (Eval (L.Partition (f <=< Snd) lst)))
 
 data PartitionHlp :: ([(Nat,v)],[(Nat,v)]) -> Exp (NatMap v, NatMap v)
 type instance Eval (PartitionHlp '(xs,ys)) = '( 'NatMap xs, 'NatMap ys)
diff --git a/src/Fcf/Data/Set.hs b/src/Fcf/Data/Set.hs
--- a/src/Fcf/Data/Set.hs
+++ b/src/Fcf/Data/Set.hs
@@ -64,9 +64,9 @@
 import           Fcf ( Eval, Exp, type (=<<), type (<=<), type (&&)
                      , Not, If, Map, Flip, TyEq )
 import qualified Fcf as Fcf (Foldr, Filter)
+import           Fcf.Class.Foldable (All, Any)
 import           Fcf.Data.List ( Elem, Cons, Concat, Reverse, Length, type (++)
                                , ZipWith, Replicate)
-import           Fcf.Alg.List ( All, Any )
 
 --------------------------------------------------------------------------------
 
diff --git a/src/Fcf/Data/Symbol.hs b/src/Fcf/Data/Symbol.hs
deleted file mode 100644
--- a/src/Fcf/Data/Symbol.hs
+++ /dev/null
@@ -1,250 +0,0 @@
-{-# LANGUAGE DataKinds              #-}
-{-# LANGUAGE PolyKinds              #-}
-{-# LANGUAGE TypeFamilies           #-}
-{-# LANGUAGE TypeInType             #-}
-{-# LANGUAGE TypeOperators          #-}
-{-# LANGUAGE UndecidableInstances   #-}
-{-# OPTIONS_GHC -Wall                       #-}
-{-# OPTIONS_GHC -Werror=incomplete-patterns #-}
-
-{-|
-Module      : Fcf.Data.Symbol
-Description : Type level symbols
-Copyright   : (c) gspia 2020-
-License     : BSD
-Maintainer  : gspia
-
-= Fcf.Data.Symbol
-
-Type-level symbols and functions for them.
-
-Note that the operators from this module conflict with "GHC.TypeLits".
-
-
-TODO: Would this whole module have a place first-class-families?
-
--}
-
---------------------------------------------------------------------------------
-
-module Fcf.Data.Symbol
-    ( -- * Reexported type
-      -- | From "GHC.TypeList".
-
-      Symbol
-
-      -- * Functions
-
-    , Append
-    , Intercalate
-    , IsSpace
-    , IsNewLine
-    , IsTab
-    , IsSpaceDelim
-    , IsDigit
-
-     -- * Comparison functions
-
-    , SymbolOrd
-    , type (<=)
-    , type (>=)
-    , type (<)
-    , type (>)
-    , type (==)
-    )
-  where
-
---------------------------------------------------------------------------------
-        
-import           GHC.TypeLits (Symbol)
-import qualified GHC.TypeLits as TL
-
-import           Fcf.Core (Eval, Exp)
-import           Fcf.Data.List (Foldr, Elem)
-import           Fcf.Data.Bool (type (||))
-import           Fcf.Utils (TyEq)
-
-import           Fcf.Combinators (type (=<<))
-
---------------------------------------------------------------------------------
-
--- | Append two type-level symbols.
---
--- === __Example__
--- 
--- >>> :kind! Eval (Append "hmm" " ok")
--- Eval (Append "hmm" " ok") :: Symbol
--- = "hmm ok"
-data Append :: Symbol -> Symbol -> Exp Symbol
-type instance Eval (Append s1 s2) = TL.AppendSymbol s1 s2
-
-
--- | Intercalate type-level symbols.
--- 
--- === __Example__
--- 
--- >>> :kind! Eval (Intercalate "+" '["aa", "bb", "cc"])
--- Eval (Intercalate "+" '["aa", "bb", "cc"]) :: Symbol
--- = "aa+bb+cc"
---
--- >>> :kind! Eval (Intercalate "+" '["aa"])
--- Eval (Intercalate "+" '["aa"]) :: Symbol
--- = "aa"
---
--- >>> :kind! Eval (Intercalate "+" '[])
--- Eval (Intercalate "+" '[]) :: Symbol
--- = ""
-data Intercalate :: Symbol -> [Symbol] -> Exp Symbol
-type instance Eval (Intercalate s1 '[]) = ""
-type instance Eval (Intercalate s1 (s ': sLst)) =
-    Eval (Append s =<< Foldr (InterCalHelp s1) "" sLst)
-
--- helper
-data InterCalHelp :: Symbol -> Symbol -> Symbol -> Exp Symbol
-type instance Eval (InterCalHelp s s1 s2) = Eval (Append (Eval (Append s s1)) s2)
-
-
--- | IsSpace
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsSpace "a")
--- Eval (IsSpace "a") :: Bool
--- = 'False
---
--- >>> :kind! Eval (IsSpace " ")
--- Eval (IsSpace " ") :: Bool
--- = 'True
-data IsSpace :: Symbol -> Exp Bool
-type instance Eval (IsSpace s) = Eval (s == " ")
-
-
--- | IsNewline
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsNewLine "a")
--- Eval (IsNewLine "a") :: Bool
--- = 'False
---
--- >>> :kind! Eval (IsNewLine "\n")
--- Eval (IsNewLine "\n") :: Bool
--- = 'True
-data IsNewLine :: Symbol -> Exp Bool
-type instance Eval (IsNewLine s) = Eval (s == "\n")
-
-
--- | IsTab
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsTab "a")
--- Eval (IsTab "a") :: Bool
--- = 'False
---
--- >>> :kind! Eval (IsTab "\t")
--- Eval (IsTab "\t") :: Bool
--- = 'True
-data IsTab :: Symbol -> Exp Bool
-type instance Eval (IsTab s) = Eval (s == "\t")
-
-
--- | IsSpaceDelim
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsSpaceDelim "a")
--- Eval (IsSpaceDelim "a") :: Bool
--- = 'False
---
--- >>> :kind! Eval (IsSpaceDelim "\n")
--- Eval (IsSpaceDelim "\n") :: Bool
--- = 'True
-data IsSpaceDelim :: Symbol -> Exp Bool
-type instance Eval (IsSpaceDelim s) =
-    Eval (Eval (IsSpace s) || (Eval (Eval (IsNewLine s) || Eval (IsTab s))))
-
-
--- | IsDigit
---
--- === __Example__
--- 
--- >>> :kind! Eval (IsDigit "3")
--- Eval (IsDigit "3") :: Bool
--- = 'True
---
--- >>> :kind! Eval (IsDigit "a")
--- Eval (IsDigit "a") :: Bool
--- = 'False
-data IsDigit :: Symbol -> Exp Bool
-type instance Eval (IsDigit s)
-    = Eval (Elem s '["0","1","2","3","4","5","6","7","8","9"])
-
-
-
---------------------------------------------------------------------------------
-
-
--- | SymbolOrd - compare two symbols and give type-level Ordering 
--- ( $ 'LT $, $ 'EQ $ or $ 'GT $ ).
---
--- === __Example__
--- 
--- >>> :kind! Eval (SymbolOrd "a" "b")
--- Eval (SymbolOrd "a" "b") :: Ordering
--- = 'LT
-data SymbolOrd :: Symbol -> Symbol -> Exp Ordering
-type instance Eval (SymbolOrd a b) = TL.CmpSymbol a b
-
--- | Less-than-or-equal comparison for symbols.
--- 
--- === __Example__
--- 
--- >>> :kind! Eval ("b" <= "a")
--- Eval ("b" <= "a") :: Bool
--- = 'False
---
-data (<=) :: Symbol -> Symbol -> Exp Bool
-type instance Eval ((<=) a b) =
-    Eval (Eval (TyEq (TL.CmpSymbol a b) 'LT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))
-
--- | Larger-than-or-equal comparison for symbols.
--- 
--- === __Example__
--- 
--- >>> :kind! Eval ("b" >= "a")
--- Eval ("b" >= "a") :: Bool
--- = 'True
-data (>=) :: Symbol -> Symbol -> Exp Bool
-type instance Eval ((>=) a b) =
-    Eval (Eval (TyEq (TL.CmpSymbol a b) 'GT) || Eval (TyEq (TL.CmpSymbol a b) 'EQ))
-
--- | Less-than comparison for symbols.
--- 
--- === __Example__
--- 
--- >>> :kind! Eval ("a" < "b")
--- Eval ("a" < "b") :: Bool
--- = 'True
-data (<) :: Symbol -> Symbol -> Exp Bool
-type instance Eval ((<) a b) = Eval (TyEq (TL.CmpSymbol a b) 'LT)
-
--- | Larger-than comparison for symbols.
--- 
--- === __Example__
--- 
--- >>> :kind! Eval ("b" > "a")
--- Eval ("b" > "a") :: Bool
--- = 'True
-data (>) :: Symbol -> Symbol -> Exp Bool
-type instance Eval ((>) a b) = Eval (TyEq (TL.CmpSymbol a b) 'GT)
-
--- | Equality of symbols
--- 
--- === __Example__
--- 
--- >>> :kind! Eval ("b" == "a")
--- Eval ("b" == "a") :: Bool
--- = 'False
-data (==) :: Symbol -> Symbol -> Exp Bool
-type instance Eval ((==) a b) = Eval (TyEq (TL.CmpSymbol a b) 'EQ)
diff --git a/src/Fcf/Data/Text.hs b/src/Fcf/Data/Text.hs
--- a/src/Fcf/Data/Text.hs
+++ b/src/Fcf/Data/Text.hs
@@ -47,7 +47,7 @@
     , CompareLength
 
     -- * Transformation
-    , Map
+    , FMap
     , Intercalate
     , Intersperse
     , Reverse
@@ -55,7 +55,7 @@
 
     -- * Special Folds
     , Concat
-    , ConcatMap
+    , FConcatMap
     , Any
     , All
 
@@ -90,22 +90,20 @@
 
 import           Fcf ( If, Eval, Exp, type (=<<), type (@@)
                      , Flip, Pure )
+import qualified Fcf.Class.Foldable as F (All, Any)
 import           Fcf.Data.List ( type (++) )
 import qualified Fcf.Data.List as F
     ( Length, Head, Tail, Init, Reverse, Take, Drop, TakeWhile, DropWhile
-    , Foldr)
-
-import qualified Fcf.Classes as F ( Map )
+    , Foldr, Intercalate, Intersperse, IsPrefixOf, IsSuffixOf, IsInfixOf, Snoc)
+import           Fcf.Data.Symbol (Symbol)
+-- import qualified Fcf.Data.Symbol as FS
 
-import qualified Fcf.Alg.List as F
-    ( Any, All, IsPrefixOf, IsSuffixOf, IsInfixOf, Snoc, Intercalate
-    , Intersperse)
+import qualified Fcf.Class.Functor as F ( FMap )
 
 
 import           Fcf.Data.Nat (Nat)
 import           Fcf.Alg.Morphism (First,Second)
-import           Fcf.Data.Symbol (Symbol)
-import qualified Fcf.Data.Symbol as S
+import qualified Fcf.Alg.Symbol as S
 
 --------------------------------------------------------------------------------
 
@@ -268,7 +266,7 @@
 -- = 'Nothing
 data Unsnoc :: Text -> Exp (Maybe (Symbol, Text))
 type instance Eval (Unsnoc txt) =
-    Eval (F.Map (Second Reverse) =<< Uncons =<< Reverse txt)
+    Eval (F.FMap (Second Reverse) =<< Uncons =<< Reverse txt)
 
 
 -- | Get the first symbol of type-level text.
@@ -297,7 +295,7 @@
 -- Eval (Tail ('Text '[])) :: Maybe Text
 -- = 'Nothing
 data Tail :: Text -> Exp (Maybe Text)
-type instance Eval (Tail ('Text lst)) = Eval (F.Map FromList =<< F.Tail lst)
+type instance Eval (Tail ('Text lst)) = Eval (F.FMap FromList =<< F.Tail lst)
 
 -- | Take all except the last symbol from type-level text.
 --
@@ -311,7 +309,7 @@
 -- Eval (Init ('Text '[])) :: Maybe Text
 -- = 'Nothing
 data Init :: Text -> Exp (Maybe Text)
-type instance Eval (Init ('Text lst)) = Eval (F.Map FromList =<< F.Init lst)
+type instance Eval (Init ('Text lst)) = Eval (F.FMap FromList =<< F.Init lst)
 
 
 -- | Compare the length of type-level text to given Nat and give
@@ -327,7 +325,7 @@
 
 
 
--- | Map for type-level text.
+-- | FMap for type-level text.
 --
 -- === __Example__
 -- 
@@ -342,11 +340,11 @@
 --     )
 -- :}
 -- 
--- >>> :kind! Eval (Map Isymb2e ('Text '["i","m","u"]))
--- Eval (Map Isymb2e ('Text '["i","m","u"])) :: Text
+-- >>> :kind! Eval (FMap Isymb2e ('Text '["i","m","u"]))
+-- Eval (FMap Isymb2e ('Text '["i","m","u"])) :: Text
 -- = 'Text '["e", "m", "u"]
-data Map :: (Symbol -> Exp Symbol) -> Text -> Exp Text
-type instance Eval (Map f ('Text lst)) = 'Text (Eval (F.Map f lst))
+data FMap :: (Symbol -> Exp Symbol) -> Text -> Exp Text
+type instance Eval (FMap f ('Text lst)) = 'Text (Eval (F.FMap f lst))
 
 
 -- | Intercalate for type-level text.
@@ -358,7 +356,7 @@
 -- = 'Text '["a", "a", "m", "u", " ", "&", " ", "v", "a", "l", "o"]
 data Intercalate :: Text -> [Text] -> Exp Text
 type instance Eval (Intercalate ('Text txt) txts) =
-    Eval (FromList =<< F.Intercalate txt =<< F.Map ToList txts)
+    Eval (FromList =<< F.Intercalate txt =<< F.FMap ToList txts)
 
 
 -- | Intersperse for type-level text.
@@ -409,7 +407,7 @@
 
 
 
--- | ConcatMap for type-level text.
+-- | FConcatMap for type-level text.
 --
 -- === __Example__
 --
@@ -424,11 +422,11 @@
 --     )
 -- :}
 --
--- >>> :kind! Eval (ConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"]))
--- Eval (ConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"])) :: Text
+-- >>> :kind! Eval (FConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"]))
+-- Eval (FConcatMap Isymb2aa ('Text '["i","m","u"," ","i","h"])) :: Text
 -- = 'Text '["a", "a", "m", "u", " ", "a", "a", "h"]
-data ConcatMap :: (Symbol -> Exp Text) -> Text -> Exp Text
-type instance Eval (ConcatMap f ('Text lst)) = Eval (Concat =<< F.Map f lst)
+data FConcatMap :: (Symbol -> Exp Text) -> Text -> Exp Text
+type instance Eval (FConcatMap f ('Text lst)) = Eval (Concat =<< F.FMap f lst)
 
 -- | Any for type-level text.
 --
@@ -586,7 +584,7 @@
 -- = '[ 'Text '["c", "d"], 'Text '["f", "g"], 'Text '["h"]]
 data SplitOn :: Text -> Text -> Exp [Text]
 type instance Eval (SplitOn ('Text sep) ('Text txt)) =
-    Eval (F.Map FromList =<< SOLoop sep '( '[], txt))
+    Eval (F.FMap FromList =<< SOLoop sep '( '[], txt))
 
 
 -- | Helper for SplitOn
@@ -619,7 +617,7 @@
 -- = '[ 'Text '["c", "d"], 'Text '["b", "f"], 'Text '["a", "b", "h"]]
 data Split :: (Symbol -> Exp Bool) -> Text -> Exp [Text]
 type instance Eval (Split p ('Text txt)) =
-    Eval (F.Map FromList =<< SplitLoop p '( '[], txt))
+    Eval (F.FMap FromList =<< SplitLoop p '( '[], txt))
 
 -- | Helper for Split
 data SplitTake :: (Symbol -> Exp Bool) -> [Symbol] -> [Symbol] -> Exp ([Symbol], [Symbol])
@@ -668,7 +666,7 @@
 -- = 'Text '["o", "k", "\n", "h", "m", "m ", "\n", "a", "b", "\n"]
 data Unlines :: [Text] -> Exp Text
 type instance Eval (Unlines txts) =
-    Eval (Concat =<< F.Map (Flip Append (Singleton @@ "\n")) txts)
+    Eval (Concat =<< F.FMap (Flip Append (Singleton @@ "\n")) txts)
 
 -- | Unwords for type-level text. This uses 'Intercalate' to add space-symbol
 -- between the given texts.