Cleanup

src/Dodge/Combine.hs

@@ -3,39 +3,18 @@ module Dodge.Combine (
     combineList,
 ) where
 
-import Dodge.Combine.Combinations
 import Data.Bifunctor
-import Data.List (sortOn)
+import Data.Foldable
+import Data.List (sort, sortOn)
 import qualified Data.Map.Strict as M
 import Dodge.Base.You
+import Dodge.Combine.Combinations
 import Dodge.Data.Combine
 import Dodge.Data.Universe
 import Dodge.Item.Display
 import Dodge.Item.InventoryColor
 import qualified IntMapHelp as IM
 import SimpleTrie
-import Data.Foldable
-import Data.List (sort)
-
-invertInventoryToMap :: IM.IntMap Item -> M.Map ItemType [Int]
-invertInventoryToMap =
-    IM.foldrWithKey
-        (\k it -> M.insertWith (++) (_itType it) [k])
-        mempty
-
-groupSplitItemAmounts :: M.Map ItemType [Int] -> [((ItAmount, ItemType), [Int])]
---groupSplitItemAmounts = M.foldrWithKey f []
-groupSplitItemAmounts = M.foldrWithKey f []
-  where
-    f ibt is = (++) [((fromIntegral i, ibt), take i is) | i <- [1 .. length is]]
-
-flatLookupItems :: IM.IntMap Item -> [([[Int]], Item)]
-flatLookupItems =
-    flip multiLookupTrieI combinationsTrie . sortOn fst . groupSplitItemAmounts
-        . invertInventoryToMap
-
-combineItemListYouX :: World -> [([Int], Item)]
-combineItemListYouX = map (first concat) . flatLookupItems . yourInv
 
 combineList :: World -> [SelectionItem CombinableItem]
 combineList = map f . combineItemListYouX
@@ -50,6 +29,14 @@ combineList = map f . combineItemListYouX
             , _siPayload = CombinableItem is itm []
             }
 
+combineItemListYouX :: World -> [([Int], Item)]
+combineItemListYouX = map (first concat) . flatLookupItems . yourInv
+
+flatLookupItems :: IM.IntMap Item -> [([[Int]], Item)]
+flatLookupItems =
+    flip multiLookupTrieI combinationsTrie . sortOn fst . groupSplitItemAmounts
+        . invertInventoryToMap
+
 combinationsTrie :: Trie (ItAmount, ItemType) Item
 {-# INLINE combinationsTrie #-}
 combinationsTrie =
@@ -57,3 +44,14 @@ combinationsTrie =
         (flip $ uncurry insertInTrie . first sort)
         emptyTrie
         itemCombinations
+
+groupSplitItemAmounts :: M.Map ItemType [Int] -> [((ItAmount, ItemType), [Int])]
+groupSplitItemAmounts = M.foldMapWithKey f
+  where
+    f ibt is = [((fromIntegral i, ibt), take i is) | i <- [1 .. length is]]
+
+invertInventoryToMap :: IM.IntMap Item -> M.Map ItemType [Int]
+invertInventoryToMap =
+    IM.foldrWithKey
+        (\k it -> M.insertWith (++) (_itType it) [k])
+        mempty

src/IntMapHelp.hs

@@ -18,11 +18,14 @@ module IntMapHelp
 
     cycleGT,
     cycleLT,
+
+    invertIntMap,
 ) where
 
 import Control.Applicative
 import Data.Aeson
 import Data.IntMap.Strict
+import qualified Data.Map.Strict as M
 import GHC.Generics
 import LensHelp
 
@@ -94,3 +97,9 @@ cycleGT i m = lookupGT i m <|> lookupMin m
 
 cycleLT :: Int -> IntMap a -> Maybe (Int, a)
 cycleLT i m = lookupLT i m <|> lookupMax m
+
+invertIntMap :: Ord a => IntMap a -> M.Map a [Int]
+invertIntMap = foldrWithKey
+        (\k xs -> M.insertWith (++) xs [k])
+        mempty
+