diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -38,4 +38,8 @@
 
 # 1.2.2.0 -- 2022-07-24
 
-* Adding enumerateMaps function
+* Adding enumerateMaps function
+
+# 1.2.3.0 -- 2022-07-25
+
+* Adding all functions from Foldable
diff --git a/WeakSets.cabal b/WeakSets.cabal
--- a/WeakSets.cabal
+++ b/WeakSets.cabal
@@ -14,7 +14,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:            1.2.2.0
+version:            1.2.3.0
 
 -- A short (one-line) description of the package.
 synopsis:
diff --git a/src/Data/WeakSet.hs b/src/Data/WeakSet.hs
--- a/src/Data/WeakSet.hs
+++ b/src/Data/WeakSet.hs
@@ -102,7 +102,8 @@
     , filter
     , partition
 
-    -- * Indexed
+    -- * Indexed /!\
+    -- ** Beware if you use these functions as a 'Set' is not ordered, no guaranty is given on which element will be returned.
     , lookupIndex
     , findIndex
     , elemAt
@@ -118,13 +119,30 @@
     -- * Folds
     , foldr
     , foldl
-    , and
-    , or
     
     -- ** Strict folds
     , foldr'
     , foldl'
     
+    -- * Fold related functions
+    , length
+    , elem
+    , maximum
+    , minimum
+    , sum
+    , product
+    , concat
+    , concat2
+    , concatMap
+    , and
+    , or
+    , any
+    , all
+    , maximumBy
+    , minimumBy
+    , notElem
+    , find
+    
     -- * Conversion
 
     -- ** List
@@ -146,9 +164,10 @@
     , traverseSet
     , sequenceSet
     , anElement
+    , cartesianProductOfSet
     
 ) where
-import              Prelude         hiding (filter, splitAt, drop, take, map, foldr, foldl, null, and, or)
+import              Prelude         hiding (filter, splitAt, drop, take, map, foldr, foldl, length, elem, maximum, minimum, sum, product, concat, concat2, concatMap, and, or, any, all, maximumBy, minimumBy, notElem, find, null)
 import  qualified   Data.List       as      L
 import  qualified   Data.Maybe      as      M
 import              Control.Applicative    (liftA2)
@@ -268,7 +287,7 @@
 
 -- | /O(n)/. Return wether an element is in a set.
 isIn :: (Eq a) => a -> Set a -> Bool
-isIn x = (elem x).unsafeSetToList
+isIn x = (Foldable.elem x).unsafeSetToList
 
 -- | /O(n)/. Alias of `isIn`. Defined for backward compatibility with Data.Set.
 member :: Eq a => a -> Set a -> Bool
@@ -280,7 +299,7 @@
 
 -- | /O(n^2)/. Size of a set.
 cardinal :: (Eq a) => Set a -> Int
-cardinal = length.setToList
+cardinal = (Foldable.length).setToList
 
 -- | /O(n)/. Size of a set.
 size :: (Eq a) => Set a -> Int
@@ -290,7 +309,7 @@
 isIncludedIn :: (Eq a) => Set a -> Set a -> Bool
 (Set []) `isIncludedIn` _ = True
 (Set (x:xs)) `isIncludedIn` (Set ys)
-    | x `elem` ys = (Set xs) `isIncludedIn` (Set ys)
+    | x `Foldable.elem` ys = (Set xs) `isIncludedIn` (Set ys)
     | otherwise = False
 
 -- | /O(n^2)/. Return a boolean indicating if a `Set` is included in another one.
@@ -369,7 +388,7 @@
 -- | O(n^2). Retrieve an element by its index, i.e. by its zero-based index in the sorted sequence of elements. If the index is out of range (less than zero, greater or equal to size of the set), `error` is called.
 elemAt :: (Eq a) => Int -> Set a -> a 
 elemAt i s
-    | i < 0 || i >= (length xs) = error "WeakSet.elemAt: index out of range"
+    | i < 0 || i >= (Foldable.length xs) = error "WeakSet.elemAt: index out of range"
     | otherwise = (L.!!) xs i
     where
         xs = setToList s
@@ -525,6 +544,17 @@
 sequenceSet :: (Applicative f, Eq (f a)) => Set (f a) -> f (Set a)
 sequenceSet (Set xs) = Set <$> sequenceA (L.nub xs)
 
+
+-- | /O(1)/. Return an element of the set if it is not empty, throw an error otherwise.
+anElement :: Set a -> a
+anElement (Set []) = error "Data.WeakSet.anElement: empty set"
+anElement (Set (x:xs)) = x
+
+-- | Return the cartesian product of a set of set.
+cartesianProductOfSet :: Set (Set a) -> Set (Set a)
+cartesianProductOfSet (Set []) = Set ([Set []])
+cartesianProductOfSet (Set (x:xs)) = (\(y,ys) -> insert y ys) <$>  x |*| (cartesianProductOfSet (Set xs))
+
 -- | /O(n^2)/. Fold the elements in the set using the given right-associative binary operator.
 --
 -- Note that an Eq constraint must be added.
@@ -537,16 +567,75 @@
 foldl :: (Eq b) => (a -> b -> a) -> a -> Set b -> a
 foldl f d s = Foldable.foldl f d (setToList s)
 
--- | Conjunction of a set of booleans.
-and :: Set Bool -> Bool
-and (Set xs) = Foldable.and xs
+-- | /O(n^2)/. Alias of `cardinal`.
+length :: (Eq a) => Set a -> Int
+length = cardinal
 
+-- | /O(n)/. Return wether an element is in the 'Set'.
+elem :: (Eq a) => a -> Set a -> Bool
+elem a (Set xs) = Foldable.elem a xs
 
--- | Disjunction of a set of booleans.
+-- | /O(n)/. Return the maximum value of a 'Set'. 
+maximum :: (Ord a) => Set a -> a
+maximum = (Foldable.maximum).unsafeSetToList
+
+-- | /O(n)/. Return the minimum value of a 'Set'. 
+minimum :: (Ord a) => Set a -> a
+minimum = (Foldable.minimum).unsafeSetToList
+
+-- | /O(n^2)/. Return the sum of values in a 'Set'.
+sum :: (Eq a, Num a) => Set a -> a
+sum = (Foldable.sum).setToList
+
+-- | /O(n^2)/. Return the product of values in a 'Set'.
+product :: (Eq a, Num a) => Set a -> a
+product = (Foldable.product).setToList
+
+-- | /O(n^2)/. Flatten a set of lists into a list.
+--
+-- Example : @concat set [[1,2,3],[1,2,3],[1,2]] == [1,2,3,1,2]@
+concat :: (Eq a) => Set [a] -> [a]
+concat = (Foldable.concat).setToList
+
+-- | /O(n)/. Flatten a set of sets into a set.
+--
+-- Example : @concat set [set [1,2,3], set [1,2,3], set [1,2]] == set [1,2,3]@
+concat2 :: Set (Set a) -> Set a
+concat2 (Set xs) = Set $ [x | s <- xs, x <- (unsafeSetToList s)]
+
+-- | /O(n^2)/. Map a function over all the elements of a 'Set' and concatenate the resulting lists.
+concatMap :: (Eq b) => (a -> [b]) -> Set a -> [b]
+concatMap f s = concat $ f <$> s 
+
+-- | /O(n)/. Return the conjonction of a 'Set' of booleans. 
+and :: Set Bool -> Bool
+and = (Foldable.and).unsafeSetToList
+
+-- | /O(n)/. Return the disjunction of a 'Set' of booleans. 
 or :: Set Bool -> Bool
-or (Set xs) = Foldable.or xs
+or = (Foldable.or).unsafeSetToList
 
--- | /O(1)/. Returns an element of the set if it is not empty, throw an error otherwise.
-anElement :: Set a -> a
-anElement (Set []) = error "Data.WeakSet.anElement: empty set"
-anElement (Set (x:xs)) = x
+-- | /O(n)/. Determines whether any element of the 'Set' satisfies the predicate.
+any :: (a -> Bool) -> Set a -> Bool
+any f (Set xs) = Foldable.any f (xs)
+
+-- | /O(n)/. Determines whether all elements of the 'Set' satisfy the predicate.
+all :: (a -> Bool) -> Set a -> Bool
+all f (Set xs) = Foldable.all f (xs)
+
+-- | /O(n)/. The largest element of a non-empty 'Set' with respect to the given comparison function.
+maximumBy ::  (a -> a -> Ordering) -> Set a -> a
+maximumBy f (Set xs) = Foldable.maximumBy f xs
+
+
+-- | /O(n)/. The smallest element of a non-empty 'Set' with respect to the given comparison function.
+minimumBy ::  (a -> a -> Ordering) -> Set a -> a
+minimumBy f (Set xs) = Foldable.minimumBy f xs
+
+-- | /O(n)/. Negation of 'elem'.
+notElem :: (Eq a) => a -> Set a -> Bool
+notElem x s = not $ elem x s
+
+-- | /O(n)/. The 'find' function takes a predicate and a 'Set' and returns an element of the 'Set' matching the predicate, or Nothing if there is no such element.
+find :: (a -> Bool) -> Set a -> Maybe a 
+find f (Set xs) = Foldable.find f xs
diff --git a/src/Data/WeakSet/Safe.hs b/src/Data/WeakSet/Safe.hs
--- a/src/Data/WeakSet/Safe.hs
+++ b/src/Data/WeakSet/Safe.hs
@@ -25,6 +25,7 @@
     (|^|),
     nubSetBy,
     anElement,
+    cartesianProductOfSet,
 )
 where
     import              Data.WeakSet