diff --git a/Zora.cabal b/Zora.cabal
--- a/Zora.cabal
+++ b/Zora.cabal
@@ -1,5 +1,5 @@
 Name:		   Zora
-Version:	   1.1.9
+Version:	   1.1.10
 Synopsis:      Graphing library wrapper + assorted useful functions 
 Description:   A library of assorted useful functions and data types and classes for working with lists, doing mathematical operations and graphing custom data types.
 Category:      Unclassified
@@ -32,4 +32,5 @@
     Zora.List
     Zora.Math
     Zora.Types
-    Zora.TreeGraphing
+    Zora.Graphing.TreeGraphing
+    Zora.Graphing.DAGGraphing
diff --git a/Zora/Graphing/DAGGraphing.hs b/Zora/Graphing/DAGGraphing.hs
new file mode 100644
--- /dev/null
+++ b/Zora/Graphing/DAGGraphing.hs
@@ -0,0 +1,233 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE ExtendedDefaultRules #-}
+{-# OPTIONS_GHC -fno-warn-type-defaults #-}
+
+-- |
+-- Module      : Zora.Graphing.DAGGraphing
+-- Copyright   : (c) Brett Wines 2014
+--
+-- License	   : BSD-style
+--
+-- Maintainer  : bgwines@cs.stanford.edu
+-- Stability   : experimental
+-- Portability : portable
+-- 
+-- A typeclass with default implementation for graphing trees with <https://hackage.haskell.org/package/graphviz Haskell GraphViz>. It is intended to be extremely straightforward to graph your data type; you only need to define three very simple functions (example implementations below).
+--
+
+module Zora.Graphing.DAGGraphing
+( DAGGraphable
+, graph
+, expand
+, zoldMap
+) where
+
+import Shelly
+import System.Directory (removeFile, getDirectoryContents)
+import Control.Exception
+import System.IO.Error hiding (catch)
+
+import System.IO.Unsafe
+
+import Data.Maybe
+import Data.Tuple
+
+import Data.Monoid
+
+import qualified Data.Map as M
+import qualified Data.List as L hiding (zip, map, length, take, drop, takeWhile, last, filter, concatMap)
+import qualified Data.Text as Tx
+import qualified Data.Text.Lazy as Ly
+import qualified Data.ByteString.Char8 as ByteString
+
+--  hiding (Graph, Edge, Node)
+import Data.Graph.Inductive
+import Data.GraphViz
+import Data.GraphViz.Attributes.Complete hiding (show_node, Label)
+import Data.Word
+
+type Label = Int
+
+-- | A typeclass for tree-like algebraic data types that are able to be graphed.
+--
+-- For these descriptions, assume the following example data type:
+-- 
+-- > data Tree a = Empty | Leaf a | Node a (Tree a) (Tree a)
+-- 
+class DAGGraphable g where
+	-- | Expands a node into its show_node and children. For example,
+	-- 
+	-- > expand (Empty) = Nothing
+	-- > expand (Leaf x) = Just (x, [])
+	-- > expand (Node x l r) = Just (x, [("L child", l), ("R child", r)])
+	expand :: g -> Maybe (Maybe String, [(Maybe String, g)])
+
+-- | Returns whether a node is empty. Sometimes, when declaringlgebraic data types, it is desirable to have an \"Empty\" show_node constructor. If your data type does not have an \"Empty\" show_node constructor, just always return @False@.
+-- 
+-- > is_empty Empty = True
+-- > is_empty _ = False
+is_empty :: (DAGGraphable g) => g -> Bool
+is_empty = isNothing . expand
+
+-- | Gets the show_node contained in a node. For example,
+-- 
+-- > show_node (Empty) = error "Empty nodes don't contain show_nodes."
+-- > show_node (Leaf x) = Just x
+-- > show_node (Node x _ _) =
+-- >     if x == 0
+-- >         then Nothing
+-- >         else Just x
+show_node :: (DAGGraphable g) => g -> Maybe String
+show_node node = if is_empty node
+	then error "DAGGraphable implementation error. We shouldn't be calling this function for an empty node."
+	else fst . fromJust . expand $ node
+
+-- | Gets the children of the current node together with edge label information. For example,
+-- 
+-- > get_children (Empty) = error "Empty nodes don't have children."
+-- > get_children (Leaf _) = []
+-- > get_children (Node _ childrenMap) = map (show . fst) . toList $ childrenMap
+get_children :: (DAGGraphable g) => g -> [(Maybe String, g)]
+get_children node =
+	if is_empty node
+		then error "DAGGraphable implementation error. We shouldn't be calling this function for an empty node."
+		else snd . fromJust . expand $ node
+
+-- | A default implementation of @zoldMap@ -- being instance of @DAGGraphable@ is enough to make your data type an instance of @Zoldable@ (in @Zora.Types@). You shouldn't need to override this implementation; just define
+--
+-- > instance Zoldable Tree where
+-- > 	zoldMap :: (Monoid m) => (Tree a -> m) -> Tree a -> m
+-- > 	zoldMap = G.zoldMap
+--
+zoldMap :: (Monoid m, DAGGraphable g) => (g -> m) -> g -> m
+zoldMap f node =
+	if is_empty node
+		then mempty
+		else (f node) `mappend` (mconcat . map (zoldMap f) . map snd . get_children $ node)
+
+-- | Returns a @String@ to be put into a .dot file for the given @DAGGraphable@ type. You shouldn't need to override this implementation.
+as_graph :: forall g. (Eq g, Show g, DAGGraphable g) => g -> ([LNode Ly.Text], [LEdge Ly.Text])
+as_graph g = (nodes, edges)
+	where
+		nodes :: [LNode Ly.Text]
+		nodes = zip [0..] $ map show' nodes_in_g
+
+		show' :: g -> Ly.Text
+		show' node =
+			if isNothing . show_node $ node
+				then Ly.empty
+				else Ly.pack . fromJust . show_node $ node
+
+		nodes_in_g :: [g]
+		nodes_in_g
+			= filter (not . is_empty)
+			. L.nub
+			. zoldMap (\a -> [a])
+			$ g
+
+		edges :: [LEdge Ly.Text]
+		edges = concatMap edgeify nodes_in_g
+
+		edgeify :: g -> [LEdge Ly.Text]
+		edgeify node
+			= map make_edge
+			. filter (not . is_empty . snd)
+			. get_children
+			$ node
+			where 
+				make_edge :: (Maybe String, g) -> LEdge Ly.Text
+				make_edge (str, child) =
+					( get_label node
+					, get_label child
+					, if isNothing str then Ly.empty else (Ly.pack . fromJust $ str) )
+
+				get_label :: g -> Label
+				get_label node
+					= snd
+					. head
+					. filter ((==) node . fst)
+					$ zip nodes_in_g [0..]
+
+-- TODO: Multiple trees (e.g. binomial heaps / random access lists)
+-- | Returns a @String@ to be put into a @.dot@ file for the given @DAGGraphable@ type. You won't need to override this implementation.
+as_dotfile :: forall g. (Eq g, Show g, DAGGraphable g) => g -> String
+as_dotfile
+	= Ly.unpack
+	. printDotGraph
+	. graphToDot params
+	. mkGraph'
+	. as_graph
+	where
+		mkGraph' :: ([LNode Ly.Text], [LEdge Ly.Text]) -> (Gr Ly.Text Ly.Text)
+		mkGraph' (v, e) = mkGraph v e
+
+		params :: GraphvizParams n Ly.Text Ly.Text () Ly.Text
+		params = nonClusteredParams { globalAttributes = ga
+									, fmtNode = fn
+									, fmtEdge = fe }
+			where
+				fn (_,l) = [textLabel l]
+				fe (_,_,l) = [textLabel l]
+
+				ga = [ GraphAttrs [ RankDir	 FromTop
+								  , BgColor	 [toWColor White] ]
+					 , NodeAttrs	[ shape	 BoxShape
+									-- , FillColor (some_color 4)
+									-- , style	 filled
+									, Width  0.1
+									, Height 0.1 ] ]
+
+-- | Graphs the given @DAGGraphable@ data type. Output is written to a file named \"graph-i.dot\", where /i/ is the successor of the highest /i/-show_node of all existing \"graph-i.dot\" files in the current directory.You won't need to override this implementation.
+graph :: (Eq g, Show g, DAGGraphable g) => g -> IO String
+graph g = do
+	outfile_name <- calc_outfile_name
+	write_dot_file
+	run_dot_cmd
+	remove_dot_file
+	return ("Graphed data structure to " ++ outfile_name)
+	where
+		calc_outfile_name :: IO String
+		calc_outfile_name = do
+			index <- calc_index_of_graph_file
+			return $ "graph-" ++ index ++ ".png"
+			where
+				calc_index_of_graph_file :: IO String
+				calc_index_of_graph_file = do
+					existing_graph_files_in_dir <- calc_existing_graph_files_in_dir
+					return
+						. show
+						. (+) 1
+						. (\s -> read s :: Integer)
+						. takeWhile ((/=) '.')
+						. drop 6 -- length "graph-"
+						. last
+						. L.sort
+						. ((:) "graph--1")
+						$ existing_graph_files_in_dir
+				
+				calc_existing_graph_files_in_dir :: IO [String]
+				calc_existing_graph_files_in_dir = do
+					directory_contents <- (getDirectoryContents "." :: IO [String])
+					return . filter is_graph_file $ directory_contents
+					where
+						is_graph_file :: String -> Bool
+						is_graph_file = starts_with "graph-"
+
+						starts_with :: String -> String -> Bool
+						starts_with prefix str = take (length prefix) str == prefix
+
+		run_dot_cmd :: IO ()
+		run_dot_cmd = do
+			outfile_name <- calc_outfile_name
+			shelly $ do cmd "dot" "-Tpng" "graph.dot" (Tx.pack $ "-o" ++ outfile_name)
+
+		write_dot_file :: IO ()
+		write_dot_file = do writeFile "graph.dot" $ as_dotfile g
+
+		remove_dot_file :: IO ()
+		remove_dot_file = removeFile "graph.dot" `catch` handleExists
+			where
+				handleExists e = if isDoesNotExistError e
+					then return ()
+					else throwIO e
diff --git a/Zora/Graphing/TreeGraphing.hs b/Zora/Graphing/TreeGraphing.hs
new file mode 100644
--- /dev/null
+++ b/Zora/Graphing/TreeGraphing.hs
@@ -0,0 +1,205 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE ExtendedDefaultRules #-}
+{-# OPTIONS_GHC -fno-warn-type-defaults #-}
+
+-- |
+-- Module      : Zora.Graphing.TreeGraphing
+-- Copyright   : (c) Brett Wines 2014
+--
+-- License	   : BSD-style
+--
+-- Maintainer  : bgwines@cs.stanford.edu
+-- Stability   : experimental
+-- Portability : portable
+-- 
+-- [DEPRECATED; use @DAGGraphable@ instead]
+-- A typeclass with default implementation for graphing trees with <https://hackage.haskell.org/package/graphviz Haskell GraphViz>. It is intended to be extremely straightforward to graph your data type; you only need to define three very simple functions (example implementations below).
+--
+
+module Zora.Graphing.TreeGraphing
+( TreeGraphable
+, value
+, get_children
+, is_empty
+, graph
+, zoldMap
+) where
+
+import Shelly
+import System.Directory (removeFile, getDirectoryContents)
+import Control.Exception
+import System.IO.Error hiding (catch)
+
+import System.IO.Unsafe
+
+import Data.Maybe
+import Data.Tuple
+
+import Data.Monoid
+
+import qualified Data.Map as M
+import qualified Data.List as L hiding (zip, map, length, take, drop, takeWhile, last, filter, concatMap)
+import qualified Data.Text.Lazy as Ly
+import qualified Data.ByteString.Char8 as ByteString
+
+--  hiding (Graph, Edge, Node)
+import Data.Graph.Inductive
+import Data.GraphViz
+import Data.GraphViz.Attributes.Complete hiding (value, Label)
+import Data.Word
+
+type Label = Int
+
+-- | A typeclass for algebraic data types that are able to be graphed.
+--
+-- For these descriptions, assume the following example data type:
+-- 
+-- > data Tree a = Empty | Leaf a | Node a (Tree a) (Tree a)
+-- 
+-- Being an instance of @TreeGraphable@ is enough to make your data type an instance of @Zoldable@; just define
+--
+-- > instance Zoldable Tree where
+-- > 	zoldMap :: (Monoid m) => (Tree a -> m) -> Tree a -> m
+-- > 	zoldMap = G.zoldMap
+--
+class TreeGraphable g where
+	-- | Gets the value contained in a node. For example,
+	-- 
+	-- > value (Empty) = error "Empty nodes don't contain values."
+	-- > value (Leaf x) = x
+	-- > value (Node x _ _) = x
+	value :: g a -> a
+	
+	-- | Gets the children of the current node. For example,
+	-- 
+	-- > get_children (Empty) = error "Empty nodes don't have children."
+	-- > get_children (Leaf _) = []
+	-- > get_children (Node _ l r) = [l, r]
+	get_children :: g a -> [g a]
+
+	-- | Returns whether a node is empty. Sometimes, when declaring algebraic data types, it is desirable to have an \"Empty\" value constructor. If your data type does not have an \"Empty\" value constructor, just always return @False@.
+	-- 
+	-- > is_empty Empty = True
+	-- > is_empty _ = False
+	is_empty :: g a -> Bool
+
+	-- | A default implementation of @zoldMap@. This enough to make you an instance of @Zoldable@ (in @Zora.Types@). You shouldn't need to override this implementation.
+	zoldMap :: (Monoid m) => (g a -> m) -> g a -> m
+	zoldMap f node =
+		if is_empty node
+			then mempty
+			else (f node) `mappend` (mconcat . map (zoldMap f) . get_children $ node)
+
+	-- | Returns a @String@ to be put into a @.dot@ file for the given @Graphable@ type. You shouldn't need to override this implementation.
+	as_graph :: forall a. (Ord a, Show a) => g a -> ([LNode Ly.Text], [LEdge Ly.Text])
+	as_graph g = (nodes, edges)
+		where
+			nodes :: [LNode Ly.Text]
+			nodes = zip [0..] $ map show' nodes_in_g
+
+			show' :: g a -> Ly.Text
+			show' = Ly.pack . show  . value
+
+			nodes_in_g :: [g a]
+			nodes_in_g = zoldMap (\a -> [a]) g
+
+			edges :: [LEdge Ly.Text]
+			edges = concatMap edgeify nodes_in_g
+
+			edgeify :: g a -> [LEdge Ly.Text]
+			edgeify node =
+				catMaybes . map maybe_edge . get_children $ node
+				where 
+					maybe_edge :: g a -> Maybe (LEdge Ly.Text)
+					maybe_edge child = if is_empty child
+						then Nothing
+						else Just
+							( m M.! (show' node)
+							, m M.! (show' child)
+							, Ly.empty )
+
+					m :: M.Map Ly.Text Label
+					m = M.fromList $ map swap nodes
+
+	-- TODO: Multiple trees (e.g. binomial heaps / random access lists)
+	-- | Returns a @String@ to be put into a @.dot@ file for the given @Graphable@ type. You won't need to override this implementation.
+	as_dotfile :: forall a. (Show a, Ord a) => g a -> String
+	as_dotfile
+		= Ly.unpack
+		. printDotGraph
+		. graphToDot params
+		. mkGraph'
+		. as_graph
+		where
+			mkGraph' :: ([LNode Ly.Text], [LEdge Ly.Text]) -> (Gr Ly.Text Ly.Text)
+			mkGraph' (v, e) = mkGraph v e
+
+			params :: GraphvizParams n Ly.Text Ly.Text () Ly.Text
+			params = nonClusteredParams { globalAttributes = ga
+										, fmtNode = fn
+										, fmtEdge = fe }
+				where
+					fn (_,l) = [textLabel l]
+					fe (_,_,l) = [textLabel l]
+
+					ga = [ GraphAttrs [ RankDir	 FromTop
+									  , BgColor	 [toWColor White] ]
+						 , NodeAttrs	[ shape	 BoxShape
+										-- , FillColor (some_color 4)
+										-- , style	 filled
+										, Width	 0.1
+										, Height	0.1 ] ]
+
+	-- TODO : output is written to a file named \"graph-i.dot\", where /i/ is the successor of the highest /i/-value of all existing \"graph-i.dot\" files in the current directory.
+	-- | Graphs the given @TreeGraphable@ data type. Creates and writes to a file named \"graph.png\", overwriting any existing files with that name. You won't need to override this implementation.
+	graph :: (Show a, Ord a) => g a -> IO String
+	graph g =
+		let
+			outfile :: String
+			outfile = "graph-" ++ index ++ ".png"
+				where
+					index :: String
+					index
+						= show
+						. (+) 1
+						. (\s -> read s :: Integer)
+						. takeWhile (/= '.')
+						. drop 6 -- (length "graph-")
+						. last
+						$ "graph--1" : graph_files_in_dir
+
+					files_in_dir :: IO [String]
+					files_in_dir = getDirectoryContents "." :: IO [String]
+					
+					graph_files_in_dir :: [String]
+					graph_files_in_dir
+						= L.sort
+						. filter (starts_with "graph-")
+						. filter ((==) "graph.png")
+						. unsafePerformIO -- TODO: not this
+						$ files_in_dir
+
+					starts_with :: String -> String -> Bool
+					starts_with prefix str = take (length prefix) str == prefix
+
+			run_dot_cmd :: IO ()
+			run_dot_cmd = shelly $ do
+				cmd "dot" "-Tpng" "graph.dot" "-ograph.png"--("-o" ++ outfile) -- Can't get this to compile. Not sure why yet. For now, we always write to the same file.
+
+			write_dot_file :: IO ()
+			write_dot_file = do
+				writeFile "graph.dot" $ as_dotfile g
+
+			remove_dot_file :: IO ()
+			remove_dot_file = removeFile "graph.dot" `catch` handleExists
+				where
+					handleExists e
+						| isDoesNotExistError e = return ()
+						| otherwise = throwIO e
+		in
+			do
+				write_dot_file
+				run_dot_cmd
+				remove_dot_file
+				return ("Graphed data structure to " ++ "graph.png") -- outfile
diff --git a/Zora/List.hs b/Zora/List.hs
--- a/Zora/List.hs
+++ b/Zora/List.hs
@@ -24,7 +24,7 @@
 -- * Permutations, combinations, and cycles
 , powerset
 , permutations
-, all_subsets_of_size
+, subsets_of_size
 , cycles
 , has_cycles
 
@@ -44,6 +44,8 @@
 , subseq
 , take_while_keep_last
 , take_while_and_rest
+, subsequences
+, contiguous_subsequences
 
 -- * Sorting
 , is_sorted
@@ -197,30 +199,30 @@
             ]
 
 -- | /O(2^k)/ Generates all subsets of the given list of size /k/.
-all_subsets_of_size :: [a] -> Integer -> [[a]]
-all_subsets_of_size l size = all_subsets_of_size_rec l [] size
+subsets_of_size :: [a] -> Integer -> [[a]]
+subsets_of_size l size = subsets_of_size_rec l [] size
     where
-        all_subsets_of_size_rec :: [a] -> [a] -> Integer -> [[a]]
-        all_subsets_of_size_rec src so_far size =
+        subsets_of_size_rec :: [a] -> [a] -> Integer -> [[a]]
+        subsets_of_size_rec src so_far size =
             if size == 0
                 then [so_far]
                 else if (length src) == 0
                     then []
                     else without ++ with
             where
-                without = all_subsets_of_size_rec (tail src) so_far size
-                with    = all_subsets_of_size_rec (tail src) ((head src) : so_far) (size-1)
+                without = subsets_of_size_rec (tail src) so_far size
+                with    = subsets_of_size_rec (tail src) ((head src) : so_far) (size-1)
 
-{-all_subsets_of_size_with_replacement_rec :: Integer -> [a] -> [a] -> [[a]]
-all_subsets_of_size_with_replacement_rec size src so_far =
+{-subsets_of_size_with_replacement_rec :: Integer -> [a] -> [a] -> [[a]]
+subsets_of_size_with_replacement_rec size src so_far =
     case size == 0 of
         True  -> [so_far]
         False -> concat [map (e:) rec | e <- src]
-        where rec = all_subsets_of_size_with_replacement_rec (size - 1)
+        where rec = subsets_of_size_with_replacement_rec (size - 1)
 
-all_subsets_of_size_with_replacement :: [a] -> Integer -> [[a]]
-all_subsets_of_size_with_replacement l size =
-    all_subsets_of_size_with_replacement_rec size l []-}
+subsets_of_size_with_replacement :: [a] -> Integer -> [[a]]
+subsets_of_size_with_replacement l size =
+    subsets_of_size_with_replacement_rec size l []-}
 
 -- | /O(n)/ Generates all cycles of a given list. For example,
 -- 
@@ -361,6 +363,15 @@
     else (x:(fst rec), snd rec)
     where
         rec = take_while_and_rest f xs
+
+-- | /(O(n^2))/ Returns all contiguous subsequences.
+contiguous_subsequences :: [a] -> [[a]]
+contiguous_subsequences = (:) [] . concatMap (tail . List.inits) . List.tails
+
+-- | /(O(2^n))/ Returns all subsequences (contiguous and noncontiguous)
+subsequences :: [a] -> [[a]]
+subsequences = map reverse . powerset
+
 
 -- ---------------------------------------------------------------------
 -- Sorting
diff --git a/Zora/TreeGraphing.hs b/Zora/TreeGraphing.hs
deleted file mode 100644
--- a/Zora/TreeGraphing.hs
+++ /dev/null
@@ -1,204 +0,0 @@
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE ExtendedDefaultRules #-}
-{-# OPTIONS_GHC -fno-warn-type-defaults #-}
-
--- |
--- Module      : Zora.TreeGraphing
--- Copyright   : (c) Brett Wines 2014
---
--- License	   : BSD-style
---
--- Maintainer  : bgwines@cs.stanford.edu
--- Stability   : experimental
--- Portability : portable
--- 
--- A typeclass with default implementation for graphing trees with <https://hackage.haskell.org/package/graphviz Haskell GraphViz>. It is intended to be extremely straightforward to graph your data type; you only need to define three very simple functions (example implementations below).
---
-
-module Zora.TreeGraphing
-( TreeGraphable
-, value
-, get_children
-, is_empty
-, graph
-, zoldMap
-) where
-
-import Shelly
-import System.Directory (removeFile, getDirectoryContents)
-import Control.Exception
-import System.IO.Error hiding (catch)
-
-import System.IO.Unsafe
-
-import Data.Maybe
-import Data.Tuple
-
-import Data.Monoid
-
-import qualified Data.Map as M
-import qualified Data.List as L hiding (zip, map, length, take, drop, takeWhile, last, filter, concatMap)
-import qualified Data.Text.Lazy as Ly
-import qualified Data.ByteString.Char8 as ByteString
-
---  hiding (Graph, Edge, Node)
-import Data.Graph.Inductive
-import Data.GraphViz
-import Data.GraphViz.Attributes.Complete hiding (value, Label)
-import Data.Word
-
-type Label = Int
-
--- | A typeclass for algebraic data types that are able to be graphed.
---
--- For these descriptions, assume the following example data type:
--- 
--- > data Tree a = Empty | Leaf a | Node a (Tree a) (Tree a)
--- 
--- Being an instance of @TreeGraphable@ is enough to make your data type an instance of @Zoldable@; just define
---
--- > instance Zoldable Tree where
--- > 	zoldMap :: (Monoid m) => (Tree a -> m) -> Tree a -> m
--- > 	zoldMap = G.zoldMap
---
-class TreeGraphable g where
-	-- | Gets the value contained in a node. For example,
-	-- 
-	-- > value (Empty) = error "Empty nodes don't contain values."
-	-- > value (Leaf x) = x
-	-- > value (Node x _ _) = x
-	value :: g a -> a
-	
-	-- | Gets the children of the current node. For example,
-	-- 
-	-- > get_children (Empty) = error "Empty nodes don't have children."
-	-- > get_children (Leaf _) = []
-	-- > get_children (Node _ l r) = [l, r]
-	get_children :: g a -> [g a]
-
-	-- | Returns whether a node is empty. Sometimes, when declaring algebraic data types, it is desirable to have an \"Empty\" value constructor. If your data type does not have an \"Empty\" value constructor, just always return @False@.
-	-- 
-	-- > is_empty Empty = True
-	-- > is_empty _ = False
-	is_empty :: g a -> Bool
-
-	-- | A default implementation of @zoldMap@. This enough to make you an instance of @Zoldable@ (in @Zora.Types@). You shouldn't need to override this implementation.
-	zoldMap :: (Monoid m) => (g a -> m) -> g a -> m
-	zoldMap f node =
-		if is_empty node
-			then mempty
-			else (f node) `mappend` (mconcat . map (zoldMap f) . get_children $ node)
-
-	-- | Returns a @String@ to be put into a @.dot@ file for the given @Graphable@ type. You shouldn't need to override this implementation.
-	as_graph :: forall a. (Ord a, Show a) => g a -> ([LNode Ly.Text], [LEdge Ly.Text])
-	as_graph g = (nodes, edges)
-		where
-			nodes :: [LNode Ly.Text]
-			nodes = zip [0..] $ map show' nodes_in_g
-
-			show' :: g a -> Ly.Text
-			show' = Ly.pack . show  . value
-
-			nodes_in_g :: [g a]
-			nodes_in_g = zoldMap (\a -> [a]) g
-
-			edges :: [LEdge Ly.Text]
-			edges = concatMap edgeify nodes_in_g
-
-			edgeify :: g a -> [LEdge Ly.Text]
-			edgeify node =
-				catMaybes . map maybe_edge . get_children $ node
-				where 
-					maybe_edge :: g a -> Maybe (LEdge Ly.Text)
-					maybe_edge child = if is_empty child
-						then Nothing
-						else Just
-							( m M.! (show' node)
-							, m M.! (show' child)
-							, Ly.empty )
-
-					m :: M.Map Ly.Text Label
-					m = M.fromList $ map swap nodes
-
-	-- TODO: Multiple trees (e.g. binomial heaps / random access lists)
-	-- | Returns a @String@ to be put into a @.dot@ file for the given @Graphable@ type. You won't need to override this implementation.
-	as_dotfile :: forall a. (Show a, Ord a) => g a -> String
-	as_dotfile
-		= Ly.unpack
-		. printDotGraph
-		. graphToDot params
-		. mkGraph'
-		. as_graph
-		where
-			mkGraph' :: ([LNode Ly.Text], [LEdge Ly.Text]) -> (Gr Ly.Text Ly.Text)
-			mkGraph' (v, e) = mkGraph v e
-
-			params :: GraphvizParams n Ly.Text Ly.Text () Ly.Text
-			params = nonClusteredParams { globalAttributes = ga
-										, fmtNode = fn
-										, fmtEdge = fe }
-				where
-					fn (_,l) = [textLabel l]
-					fe (_,_,l) = [textLabel l]
-
-					ga = [ GraphAttrs [ RankDir	 FromTop
-									  , BgColor	 [toWColor White] ]
-						 , NodeAttrs	[ shape	 BoxShape
-										-- , FillColor (some_color 4)
-										-- , style	 filled
-										, Width	 0.1
-										, Height	0.1 ] ]
-
-	-- TODO : output is written to a file named \"graph-i.dot\", where /i/ is the successor of the highest /i/-value of all existing \"graph-i.dot\" files in the current directory.
-	-- | Graphs the given @TreeGraphable@ data type. Creates and writes to a file named \"graph.png\", overwriting any existing files with that name. You won't need to override this implementation.
-	graph :: (Show a, Ord a) => g a -> IO String
-	graph g =
-		let
-			outfile :: String
-			outfile = "graph-" ++ index ++ ".png"
-				where
-					index :: String
-					index
-						= show
-						. (+) 1
-						. (\s -> read s :: Integer)
-						. takeWhile (/= '.')
-						. drop 6 -- (length "graph-")
-						. last
-						$ "graph--1" : graph_files_in_dir
-
-					files_in_dir :: IO [String]
-					files_in_dir = getDirectoryContents "." :: IO [String]
-					
-					graph_files_in_dir :: [String]
-					graph_files_in_dir
-						= L.sort
-						. filter (starts_with "graph-")
-						. filter ((==) "graph.png")
-						. unsafePerformIO -- TODO: not this
-						$ files_in_dir
-
-					starts_with :: String -> String -> Bool
-					starts_with prefix str = take (length prefix) str == prefix
-
-			run_dot_cmd :: IO ()
-			run_dot_cmd = shelly $ do
-				cmd "dot" "-Tpng" "graph.dot" "-ograph.png"--("-o" ++ outfile) -- Can't get this to compile. Not sure why yet. For now, we always write to the same file.
-
-			write_dot_file :: IO ()
-			write_dot_file = do
-				writeFile "graph.dot" $ as_dotfile g
-
-			remove_dot_file :: IO ()
-			remove_dot_file = removeFile "graph.dot" `catch` handleExists
-				where
-					handleExists e
-						| isDoesNotExistError e = return ()
-						| otherwise = throwIO e
-		in
-			do
-				write_dot_file
-				run_dot_cmd
-				remove_dot_file
-				return ("Graphed data structure to " ++ "graph.png") -- outfile