Factor out some new libraries

	word64-map:
		Data.Word64Map
	network-addr:
		Network.Address
	tox-crypto:
		Crypto.Tox
	lifted-concurrent:
		Control.Concurrent.Lifted.Instrument
		Control.Concurrent.Async.Lifted.Instrument
	psq-wrap:
		Data.Wrapper.PSQInt
		Data.Wrapper.PSQ
	minmax-psq:
		Data.MinMaxPSQ
        tasks:
                Control.Concurrent.Tasks
	kad:
		Network.Kademlia
		Network.Kademlia.Bootstrap
		Network.Kademlia.Routing
		Network.Kademlia.CommonAPI
		Network.Kademlia.Persistence
		Network.Kademlia.Search

1 files changed, 0 insertions, 53 deletions

diff --git a/src/Data/Wrapper/PSQInt.hs b/src/Data/Wrapper/PSQInt.hs
deleted file mode 100644
index 5badb8b2..00000000
--- a/src/Data/Wrapper/PSQInt.hs
+++ /dev/null
@@ -1,53 +0,0 @@
-{-# LANGUAGE PatternSynonyms #-}
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE ConstraintKinds #-}
-module Data.Wrapper.PSQInt
-#if 0
-     ( module Data.Wrapper.PSQInt , module Data.PSQueue ) where
-
-import Data.PSQueue hiding (foldr, foldl, PSQ)
-import qualified Data.PSQueue as PSQueue
-
-type PSQ p = PSQueue.PSQ Int p
-
--- | Wrapper over PSQueue-style foldr to implement a psqueues-style interface.
-fold' :: (Ord p) => (Int -> p -> () -> a -> a) -> a -> PSQ p -> a
-fold' f a q = PSQueue.foldr f' a q
- where
-    f' (k :-> prio) x = f k prio () x
-
-#else
-    ( module Data.Wrapper.PSQInt
-    , module IntPSQ
-    , module Data.Wrapper.PSQ
-    ) where
-
-import Data.Wrapper.PSQ (Binding, pattern (:->), key, prio, toMicroseconds)
-
-import Data.IntPSQ as IntPSQ hiding (insert, map, singleton, minView)
-import qualified Data.IntPSQ as Q
-
-type PSQ p = IntPSQ p ()
-
-type PSQKey = ()
-
-insert :: (Ord p) => Int -> p -> PSQ p -> PSQ p
-insert k p q = Q.insert k p () q
-{-# INLINE insert #-}
-
-insertWith :: (Ord p) => (p -> p -> p) -> Int -> p -> PSQ p -> PSQ p
-insertWith f k p0 q = snd $ Q.alter f' k q
- where
-    f' (Just (p,())) = ((),Just (f p0 p, ()))
-    f' Nothing      = ((),Nothing)
-{-# INLINE insertWith #-}
-
-singleton :: (Ord p) => Int -> p -> PSQ p
-singleton k p = Q.singleton k p ()
-{-# INLINE singleton #-}
-
-minView :: (Ord p) => PSQ p -> Maybe (Binding Int p, PSQ p)
-minView q = fmap (\(k,p,(),q') -> (k :-> p, q')) $ Q.minView q
-{-# INLINE minView #-}
-
-#endif