diff --git a/forest.cabal b/forest.cabal
--- a/forest.cabal
+++ b/forest.cabal
@@ -1,5 +1,5 @@
 name:           forest
-version:        0.1.1.1
+version:        0.2
 synopsis:       Tree and Forest types
 license:        MPL-2.0
 license-file:   LICENSE
diff --git a/src/Data/Tree/Forest.hs b/src/Data/Tree/Forest.hs
--- a/src/Data/Tree/Forest.hs
+++ b/src/Data/Tree/Forest.hs
@@ -74,7 +74,7 @@
 import           Control.Monad.Fail (MonadFail)
 import qualified Control.Monad.Fail as F (fail)
 #endif
-import           Data.Bifoldable (Bifoldable, bifoldr)
+import           Data.Bifoldable (Bifoldable, bifoldl', bifoldr)
 import           Data.Bifunctor (Bifunctor, bimap)
 import           Data.Bitraversable (Bitraversable, bitraverse)
 #if __GLASGOW_HASKELL__ < 710
@@ -130,6 +130,7 @@
 #if __GLASGOW_HASKELL__ < 710
 import           Prelude hiding (foldr)
 #endif
+import           Prelude hiding (foldr1)
 
 
 -- deepseq -------------------------------------------------------------------
@@ -149,6 +150,10 @@
 import           Data.Functor.Apply (Apply, (<.>))
 import           Data.Functor.Bind (Bind, (>>-), join)
 import           Data.Functor.Plus (Plus, zero)
+import           Data.Semigroup.Bifoldable (Bifoldable1, bifoldMap1)
+import           Data.Semigroup.Bitraversable (Bitraversable1, bitraverse1)
+import           Data.Semigroup.Foldable (Foldable1, foldMap1)
+import           Data.Semigroup.Traversable (Traversable1, traverse1)
 
 
 ------------------------------------------------------------------------------
@@ -229,6 +234,14 @@
 
 
 ------------------------------------------------------------------------------
+instance Foldable f => Bifoldable1 (Tree f) where
+    bifoldMap1 _ g (Leaf a) = g a
+    bifoldMap1 f g (Node s ts) =
+        bifoldl' ((. f) . (<>)) ((. g) . (<>)) (f s) ts
+    {-# INLINE bifoldMap1 #-}
+
+
+------------------------------------------------------------------------------
 instance Traversable f => Bitraversable (Tree f) where
     bitraverse _ g (Leaf a) = Leaf <$> g a
     bitraverse f g (Node s ts) = Node <$> f s <*> bitraverse f g ts
@@ -236,6 +249,13 @@
 
 
 ------------------------------------------------------------------------------
+instance Traversable1 f => Bitraversable1 (Tree f) where
+    bitraverse1 _ g (Leaf a) = Leaf <$> g a
+    bitraverse1 f g (Node s ts) = Node <$> f s <.> bitraverse1 f g ts
+    {-# INLINE bitraverse1 #-}
+
+
+------------------------------------------------------------------------------
 instance Functor f => Functor (Tree f s) where
     fmap f (Leaf a) = Leaf (f a)
     fmap f (Node s ts) = Node s (fmap f ts)
@@ -250,6 +270,13 @@
 
 
 ------------------------------------------------------------------------------
+instance Foldable1 f => Foldable1 (Tree f s) where
+    foldMap1 f (Leaf a) = f a
+    foldMap1 f (Node _ ts) = foldMap1 f ts
+    {-# INLINE foldMap1 #-}
+
+
+------------------------------------------------------------------------------
 instance Traversable f => Traversable (Tree f s) where
     traverse f (Leaf a) = Leaf <$> f a
     traverse f (Node s ts) = Node s <$> traverse f ts
@@ -257,6 +284,13 @@
 
 
 ------------------------------------------------------------------------------
+instance Traversable1 f => Traversable1 (Tree f s) where
+    traverse1 f (Leaf a) = Leaf <$> f a
+    traverse1 f (Node s ts) = Node s <$> traverse1 f ts
+    {-# INLINE traverse1 #-}
+
+
+------------------------------------------------------------------------------
 instance Functor f => Apply (Tree f s) where
     Leaf f <.> Leaf a = Leaf (f a)
     Leaf f <.> Node s ts = Node s (fmap f ts)
@@ -470,12 +504,22 @@
 
 
 ------------------------------------------------------------------------------
+instance Foldable1 f => Bifoldable1 (Forest f) where
+    bifoldMap1 f g (Forest ts) = foldMap1 (bifoldMap1 f g) ts
+
+
+------------------------------------------------------------------------------
 instance Traversable f => Bitraversable (Forest f) where
     bitraverse f g (Forest ts) = Forest <$> traverse (bitraverse f g) ts
     {-# INLINE bitraverse #-}
 
 
 ------------------------------------------------------------------------------
+instance Traversable1 f => Bitraversable1 (Forest f) where
+    bitraverse1 f g (Forest ts) = Forest <$> traverse1 (bitraverse1 f g) ts
+
+
+------------------------------------------------------------------------------
 instance Functor f => Functor (Forest f s) where
     fmap f (Forest ts) = Forest (fmap (fmap f) ts)
     {-# INLINE fmap #-}
@@ -488,9 +532,21 @@
 
 
 ------------------------------------------------------------------------------
+instance Foldable1 f => Foldable1 (Forest f s) where
+    foldMap1 f (Forest ts) = foldMap1 (foldMap1 f) ts
+    {-# INLINE foldMap1 #-}
+
+
+------------------------------------------------------------------------------
 instance Traversable f => Traversable (Forest f s) where
     traverse f (Forest ts) = Forest <$> traverse (traverse f) ts
     {-# INLINE traverse #-}
+
+
+------------------------------------------------------------------------------
+instance Traversable1 f => Traversable1 (Forest f s) where
+    traverse1 f (Forest ts) = Forest <$> traverse1 (traverse1 f) ts
+    {-# INLINE traverse1 #-}
 
 
 ------------------------------------------------------------------------------