packages feed

int-like (empty) → 0.1.0

raw patch · 10 files changed

+600/−0 lines, 10 filesdep +algebraic-graphsdep +basedep +containerssetup-changed

Dependencies added: algebraic-graphs, base, containers, deepseq, hashable, int-like, tasty, tasty-hunit

Files

+ LICENSE view
@@ -0,0 +1,30 @@+Copyright Author name here (c) 2022++All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:++    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.++    * Redistributions in binary form must reproduce the above+      copyright notice, this list of conditions and the following+      disclaimer in the documentation and/or other materials provided+      with the distribution.++    * Neither the name of Author name here nor the names of other+      contributors may be used to endorse or promote products derived+      from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ README.md view
@@ -0,0 +1,5 @@+# int-like++[![CircleCI](https://circleci.com/gh/ejconlon/int-like/tree/master.svg?style=svg)](https://circleci.com/gh/ejconlon/int-like/tree/master)++Newtype wrappers over `IntSet` and `IntMap`
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ int-like.cabal view
@@ -0,0 +1,116 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.34.4.+--+-- see: https://github.com/sol/hpack++name:           int-like+version:        0.1.0+synopsis:       Newtype wrappers over IntSet and IntMap+description:    Please see the README on GitHub at <https://github.com/ejconlon/int-like#readme>+category:       Data Structures+homepage:       https://github.com/ejconlon/int-like#readme+bug-reports:    https://github.com/ejconlon/int-like/issues+author:         Eric Conlon+maintainer:     ejconlon@gmail.com+copyright:      (c) 2022 Eric Conlon+license:        BSD3+license-file:   LICENSE+build-type:     Simple+extra-source-files:+    README.md++source-repository head+  type: git+  location: https://github.com/ejconlon/int-like++library+  exposed-modules:+      IntLike.Equiv+      IntLike.Graph+      IntLike.Map+      IntLike.MultiMap+      IntLike.Set+  other-modules:+      Paths_int_like+  hs-source-dirs:+      src+  default-extensions:+      BangPatterns+      ConstraintKinds+      DeriveAnyClass+      DeriveFunctor+      DeriveFoldable+      DeriveGeneric+      DeriveTraversable+      DerivingStrategies+      DerivingVia+      FlexibleContexts+      FlexibleInstances+      FunctionalDependencies+      GADTs+      GeneralizedNewtypeDeriving+      LambdaCase+      KindSignatures+      MultiParamTypeClasses+      Rank2Types+      ScopedTypeVariables+      StandaloneDeriving+      TemplateHaskell+      TupleSections+      TypeApplications+      TypeOperators+      TypeFamilies+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wpartial-fields -Wredundant-constraints -fno-warn-unused-top-binds -fwrite-ide-info -hiedir=.hie+  build-depends:+      algebraic-graphs >=0.5 && <0.7+    , base >=4.12 && <5+    , containers ==0.6.*+    , deepseq ==1.4.*+    , hashable >=1.3 && <1.5+  default-language: Haskell2010++test-suite int-like-test+  type: exitcode-stdio-1.0+  main-is: Main.hs+  other-modules:+      Paths_int_like+  hs-source-dirs:+      test+  default-extensions:+      BangPatterns+      ConstraintKinds+      DeriveAnyClass+      DeriveFunctor+      DeriveFoldable+      DeriveGeneric+      DeriveTraversable+      DerivingStrategies+      DerivingVia+      FlexibleContexts+      FlexibleInstances+      FunctionalDependencies+      GADTs+      GeneralizedNewtypeDeriving+      LambdaCase+      KindSignatures+      MultiParamTypeClasses+      Rank2Types+      ScopedTypeVariables+      StandaloneDeriving+      TemplateHaskell+      TupleSections+      TypeApplications+      TypeOperators+      TypeFamilies+  ghc-options: -Wall -Wcompat -Widentities -Wincomplete-record-updates -Wincomplete-uni-patterns -Wpartial-fields -Wredundant-constraints -fno-warn-unused-top-binds -fwrite-ide-info -hiedir=.hie -threaded -rtsopts -with-rtsopts=-N+  build-depends:+      algebraic-graphs >=0.5 && <0.7+    , base >=4.12 && <5+    , containers ==0.6.*+    , deepseq ==1.4.*+    , hashable >=1.3 && <1.5+    , int-like+    , tasty+    , tasty-hunit+  default-language: Haskell2010
+ src/IntLike/Equiv.hs view
@@ -0,0 +1,46 @@+{-# LANGUAGE DeriveAnyClass #-}++module IntLike.Equiv+  ( IntLikeEquiv+  , fwdView+  , bwdView+  , empty+  , insert+  , partialInsert+  , member+  , lookupClass+  ) where++import Control.DeepSeq (NFData)+import Data.Coerce (Coercible)+import Data.Either (fromRight)+import GHC.Generics (Generic)+import IntLike.Map (IntLikeMap)+import qualified IntLike.Map as ILM+import IntLike.MultiMap (IntLikeMultiMap)+import qualified IntLike.MultiMap as ILMM++data IntLikeEquiv k v = IntLikeEquiv+  { fwdView :: !(IntLikeMultiMap k v)+  , bwdView :: !(IntLikeMap v k)+  } deriving stock (Eq, Show, Generic)+    deriving anyclass (NFData)++empty :: IntLikeEquiv k v+empty = IntLikeEquiv ILMM.empty ILM.empty+{-# INLINE empty #-}++insert :: (Coercible k Int, Coercible v Int) => k -> v -> IntLikeEquiv k v -> Either k (IntLikeEquiv k v)+insert k v (IntLikeEquiv fwd bwd) =+  case ILM.lookup v bwd of+    Nothing -> Right (IntLikeEquiv (ILMM.insert k v fwd) (ILM.insert v k bwd))+    Just k' -> Left k'++partialInsert :: (Coercible k Int, Coercible v Int) => k -> v -> IntLikeEquiv k v -> IntLikeEquiv k v+partialInsert k v = fromRight (error "duplicate insert into equiv") . insert k v++member :: (Eq k, Coercible v Int) => k -> v -> IntLikeEquiv k v -> Bool+member k v m = Just k == lookupClass v m++lookupClass :: (Coercible v Int) => v -> IntLikeEquiv k v -> Maybe k+lookupClass v = ILM.lookup v . bwdView
+ src/IntLike/Graph.hs view
@@ -0,0 +1,74 @@+module IntLike.Graph+  ( IntLikeGraph (..)+  , adjacencyIntMultiMap+  , vertexList+  , fromDirectedEdges+  , fromUndirectedEdges+  , reachable+  , Component (..)+  , undirectedComponents+  ) where++import Algebra.Graph.AdjacencyIntMap (AdjacencyIntMap)+import qualified Algebra.Graph.AdjacencyIntMap as AdjacencyIntMap+import qualified Algebra.Graph.AdjacencyIntMap.Algorithm as AIMA+import Algebra.Graph.Class (Graph (..))+import Control.DeepSeq (NFData)+import Data.Coerce (Coercible, coerce)+import Data.Foldable (foldl')+import Data.Hashable (Hashable)+import Data.Tuple (swap)+import IntLike.Equiv (IntLikeEquiv)+import qualified IntLike.Equiv as ILE+import IntLike.Map (IntLikeMap (..))+import IntLike.MultiMap (IntLikeMultiMap)+import IntLike.Set (IntLikeSet (..))+import qualified IntLike.Set as ILS++newtype IntLikeGraph x = IntLikeGraph { unIntLikeGraph :: AdjacencyIntMap }+  deriving newtype (Eq, Show, NFData)++instance Coercible x Int => Graph (IntLikeGraph x) where+  type Vertex (IntLikeGraph x) = x+  empty = IntLikeGraph AdjacencyIntMap.empty+  vertex v = IntLikeGraph (AdjacencyIntMap.vertex (coerce v))+  overlay x y = IntLikeGraph (AdjacencyIntMap.overlay (unIntLikeGraph x) (unIntLikeGraph y))+  connect x y = IntLikeGraph (AdjacencyIntMap.connect (unIntLikeGraph x) (unIntLikeGraph y))++adjacencyIntMultiMap :: IntLikeGraph x -> IntLikeMultiMap x x+adjacencyIntMultiMap = coerce . AdjacencyIntMap.adjacencyIntMap . unIntLikeGraph+{-# INLINE adjacencyIntMultiMap #-}++vertexList :: Coercible x Int => IntLikeGraph x -> [x]+vertexList = coerce . AdjacencyIntMap.vertexList . unIntLikeGraph+{-# INLINE vertexList #-}++fromDirectedEdges :: Coercible x Int => [(x, x)] -> IntLikeGraph x+fromDirectedEdges = IntLikeGraph . AdjacencyIntMap.edges . coerce+{-# INLINE fromDirectedEdges #-}++fromUndirectedEdges :: Coercible x Int => [(x, x)] -> IntLikeGraph x+fromUndirectedEdges es = overlay (fromDirectedEdges es) (fromDirectedEdges (fmap swap es))+{-# INLINE fromUndirectedEdges #-}++reachable :: Coercible x Int => x -> IntLikeGraph x -> [x]+reachable x = coerce . AIMA.reachable (coerce x) . unIntLikeGraph+{-# INLINE reachable #-}++newtype Component = Component { unComponent :: Int }+  deriving stock (Show)+  deriving newtype (Eq, Ord, Enum, Hashable, NFData)++undirectedComponents :: Coercible x Int => [(x, x)] -> IntLikeEquiv Component x+undirectedComponents es = go 0 startVs ILE.empty where+  g = fromUndirectedEdges es+  startVs = ILS.fromList (vertexList g)+  go i vs eqv =+    case ILS.minView vs of+      Nothing -> eqv+      Just (v, vs') ->+        let rs = reachable v g+            -- partial: ok by construction of graph and defn of reachable+            eqv' = foldl' (flip (ILE.partialInsert (Component i))) eqv rs+            vs'' = foldl' (flip ILS.delete) vs' rs+        in go (i + 1) vs'' eqv'
+ src/IntLike/Map.hs view
@@ -0,0 +1,124 @@+module IntLike.Map+  ( IntLikeMap (..)+  , empty+  , singleton+  , fromList+  , size+  , null+  , member+  , toList+  , keys+  , elems+  , lookup+  , partialLookup+  , findWithDefault+  , insert+  , insertWith+  , adjust+  , alter+  , delete+  , minViewWithKey+  , filter+  , restrictKeys+  , map+  , insertState+  ) where++import Control.DeepSeq (NFData)+import Data.Coerce (Coercible, coerce)+import Data.IntMap.Strict (IntMap)+import qualified Data.IntMap.Strict as IntMap+import IntLike.Set (IntLikeSet (..))+import Prelude hiding (filter, lookup, map, null)++newtype IntLikeMap x a = IntLikeMap { unIntLikeMap :: IntMap a }+  deriving stock (Show, Traversable)+  deriving newtype (Eq, Functor, Foldable, NFData, Semigroup, Monoid)++empty :: IntLikeMap x a+empty = IntLikeMap IntMap.empty+{-# INLINE empty #-}++singleton :: Coercible x Int => x -> a -> IntLikeMap x a+singleton x = IntLikeMap . IntMap.singleton (coerce x)+{-# INLINE singleton #-}++fromList :: Coercible x Int => [(x, a)] -> IntLikeMap x a+fromList = IntLikeMap . IntMap.fromList . coerce+{-# INLINE fromList #-}++size :: IntLikeMap x a -> Int+size = IntMap.size . unIntLikeMap+{-# INLINE size #-}++null :: IntLikeMap x a -> Bool+null = IntMap.null . unIntLikeMap+{-# INLINE null #-}++member :: Coercible x Int => x -> IntLikeMap x a -> Bool+member x = IntMap.member (coerce x) . unIntLikeMap+{-# INLINE member #-}++toList :: Coercible x Int => IntLikeMap x a -> [(x, a)]+toList = coerce . IntMap.toList . unIntLikeMap+{-# INLINE toList #-}++keys :: Coercible x Int => IntLikeMap x a -> [x]+keys = coerce . IntMap.keys . unIntLikeMap+{-# INLINE keys #-}++elems :: IntLikeMap x a -> [a]+elems = IntMap.elems . unIntLikeMap+{-# INLINE elems #-}++lookup :: Coercible x Int => x -> IntLikeMap x a -> Maybe a+lookup x = IntMap.lookup (coerce x) . unIntLikeMap+{-# INLINE lookup #-}++partialLookup :: Coercible x Int => x -> IntLikeMap x a -> a+partialLookup x m = unIntLikeMap m IntMap.! coerce x+{-# INLINE partialLookup #-}++findWithDefault :: Coercible x Int => a -> x -> IntLikeMap x a -> a+findWithDefault a x = IntMap.findWithDefault a (coerce x) . unIntLikeMap+{-# INLINE findWithDefault #-}++insert :: Coercible x Int => x -> a -> IntLikeMap x a -> IntLikeMap x a+insert x a = IntLikeMap . IntMap.insert (coerce x) a . unIntLikeMap+{-# INLINE insert #-}++insertWith :: Coercible x Int => (a -> a -> a) -> x -> a -> IntLikeMap x a -> IntLikeMap x a+insertWith f x a = IntLikeMap . IntMap.insertWith f (coerce x) a . unIntLikeMap+{-# INLINE insertWith #-}++adjust :: Coercible x Int => (a -> a) -> x -> IntLikeMap x a -> IntLikeMap x a+adjust f x = IntLikeMap . IntMap.adjust f (coerce x) . unIntLikeMap+{-# INLINE adjust #-}++alter :: Coercible x Int => (Maybe a -> Maybe a) -> x -> IntLikeMap x a -> IntLikeMap x a+alter f x = IntLikeMap . IntMap.alter f (coerce x) . unIntLikeMap+{-# INLINE alter #-}++delete :: Coercible x Int => x -> IntLikeMap x a -> IntLikeMap x a+delete x = IntLikeMap . IntMap.delete (coerce x) . unIntLikeMap+{-# INLINE delete #-}++minViewWithKey :: Coercible x Int => IntLikeMap x a -> Maybe ((x, a), IntLikeMap x a)+minViewWithKey = coerce . IntMap.minViewWithKey . unIntLikeMap+{-# INLINE minViewWithKey #-}++filter :: (a -> Bool) -> IntLikeMap x a -> IntLikeMap x a+filter f = IntLikeMap . IntMap.filter f . unIntLikeMap+{-# INLINE filter #-}++restrictKeys :: IntLikeMap x a -> IntLikeSet x -> IntLikeMap x a+restrictKeys m s = IntLikeMap (IntMap.restrictKeys (unIntLikeMap m) (unIntLikeSet s))+{-# INLINE restrictKeys #-}++map :: (a -> b) -> IntLikeMap x a -> IntLikeMap x b+map f = IntLikeMap . IntMap.map f . unIntLikeMap+{-# INLINE map #-}++insertState :: Coercible x Int => (Maybe a -> b) -> x -> a -> IntLikeMap x a -> (b, IntLikeMap x a)+insertState f x a = coerce . IntMap.alterF (\m -> (f m, Just a)) (coerce x) . unIntLikeMap+{-# INLINE insertState #-}
+ src/IntLike/MultiMap.hs view
@@ -0,0 +1,58 @@+module IntLike.MultiMap+  ( IntLikeMultiMap+  , empty+  , size+  , toList+  , insert+  , member+  , invertDisjoint+  , unsafeInvertDisjoint+  , fromInvertedMap+  ) where++import Control.Monad (foldM)+import Data.Coerce (Coercible)+import Data.Foldable (foldl')+import IntLike.Map (IntLikeMap)+import qualified IntLike.Map as ILM+import IntLike.Set (IntLikeSet)+import qualified IntLike.Set as ILS++type IntLikeMultiMap k v = IntLikeMap k (IntLikeSet v)++empty :: IntLikeMultiMap k v+empty = ILM.empty+{-# INLINE empty #-}++size :: IntLikeMultiMap k v -> Int+size = ILM.size+{-# INLINE size #-}++toList :: Coercible k Int => IntLikeMultiMap k v -> [(k, IntLikeSet v)]+toList = ILM.toList+{-# INLINE toList #-}++insert :: (Coercible k Int, Coercible v Int) => k -> v -> IntLikeMultiMap k v -> IntLikeMultiMap k v+insert k v = ILM.insertWith ILS.union k (ILS.singleton v)+{-# INLINE insert #-}++member :: (Coercible k Int, Coercible v Int) => k -> v -> IntLikeMultiMap k v -> Bool+member k v = maybe False (ILS.member v) . ILM.lookup k+{-# INLINE member #-}++invertDisjoint :: (Coercible k Int, Coercible v Int) => IntLikeMultiMap k v -> Either (k, k, v) (IntLikeMap v k)+invertDisjoint = foldM go1 ILM.empty . ILM.toList where+  go1 m (k, vs) = foldM (go2 k) m (ILS.toList vs)+  go2 k m v =+    case ILM.lookup v m of+      Nothing -> Right (ILM.insert v k m)+      Just k' -> Left (k, k', v)++unsafeInvertDisjoint :: (Coercible k Int, Coercible v Int) => IntLikeMultiMap k v -> IntLikeMap v k+unsafeInvertDisjoint = foldl' go1 ILM.empty . ILM.toList where+  go1 m (k, vs) = foldl' (go2 k) m (ILS.toList vs)+  go2 k m v = ILM.insert v k m++fromInvertedMap :: (Coercible k Int, Coercible v Int) => IntLikeMap k v -> IntLikeMultiMap v k+fromInvertedMap = foldl' (\m (k, v) -> insert v k m) empty . ILM.toList+{-# INLINE fromInvertedMap #-}
+ src/IntLike/Set.hs view
@@ -0,0 +1,131 @@+module IntLike.Set+  ( IntLikeSet (..)+  , empty+  , singleton+  , fromList+  , size+  , null+  , member+  , toList+  , insert+  , delete+  , isSubsetOf+  , intersection+  , difference+  , union+  , unions+  , findMin+  , minView+  , disjoint+  , map+  , filter+  , insertState+  , orderedPairs+  , unorderedPairs+  ) where++import Control.DeepSeq (NFData)+import Data.Coerce (Coercible, coerce)+import Data.Foldable (foldl')+import Data.IntSet (IntSet)+import qualified Data.IntSet as IntSet+import Prelude hiding (filter, map, null)++newtype IntLikeSet x = IntLikeSet { unIntLikeSet :: IntSet }+  deriving stock (Show)+  deriving newtype (Eq, NFData, Semigroup, Monoid)++empty :: IntLikeSet x+empty = IntLikeSet IntSet.empty+{-# INLINE empty #-}++singleton :: Coercible x Int => x -> IntLikeSet x+singleton = IntLikeSet . IntSet.singleton . coerce+{-# INLINE singleton #-}++fromList :: Coercible x Int => [x] -> IntLikeSet x+fromList = IntLikeSet . IntSet.fromList . coerce+{-# INLINE fromList #-}++size :: IntLikeSet x -> Int+size = IntSet.size . unIntLikeSet+{-# INLINE size #-}++null :: IntLikeSet x -> Bool+null = IntSet.null . unIntLikeSet+{-# INLINE null #-}++member :: Coercible x Int => x -> IntLikeSet x -> Bool+member x = IntSet.member (coerce x) . unIntLikeSet+{-# INLINE member #-}++toList :: Coercible x Int => IntLikeSet x -> [x]+toList = coerce . IntSet.toList . unIntLikeSet+{-# INLINE toList #-}++insert :: Coercible x Int => x -> IntLikeSet x -> IntLikeSet x+insert x = IntLikeSet . IntSet.insert (coerce x) . unIntLikeSet+{-# INLINE insert #-}++delete :: Coercible x Int => x -> IntLikeSet x -> IntLikeSet x+delete x = IntLikeSet . IntSet.delete (coerce x) . unIntLikeSet+{-# INLINE delete #-}++isSubsetOf :: IntLikeSet x -> IntLikeSet x -> Bool+isSubsetOf xs ys = IntSet.isSubsetOf (unIntLikeSet xs) (unIntLikeSet ys)+{-# INLINE isSubsetOf #-}++intersection :: IntLikeSet x -> IntLikeSet x -> IntLikeSet x+intersection xs ys = IntLikeSet (IntSet.intersection (unIntLikeSet xs) (unIntLikeSet ys))+{-# INLINE intersection #-}++difference :: IntLikeSet x -> IntLikeSet x -> IntLikeSet x+difference xs ys = IntLikeSet (IntSet.difference (unIntLikeSet xs) (unIntLikeSet ys))+{-# INLINE difference #-}++union :: IntLikeSet x -> IntLikeSet x -> IntLikeSet x+union xs ys = IntLikeSet (IntSet.union (unIntLikeSet xs) (unIntLikeSet ys))+{-# INLINE union #-}++-- Copied here because coercion through f is difficult+unions :: Foldable f => f (IntLikeSet x) -> IntLikeSet x+unions = foldl' union empty+{-# INLINE unions #-}++findMin :: Coercible x Int => IntLikeSet x -> x+findMin = coerce . IntSet.findMin . unIntLikeSet+{-# INLINE findMin #-}++minView :: Coercible x Int => IntLikeSet x -> Maybe (x, IntLikeSet x)+minView = coerce . IntSet.minView . unIntLikeSet+{-# INLINE minView #-}++disjoint :: IntLikeSet x -> IntLikeSet x -> Bool+disjoint a b = IntSet.disjoint (unIntLikeSet a) (unIntLikeSet b)+{-# INLINE disjoint #-}++map :: (Coercible x Int, Coercible y Int) => (x -> y) -> IntLikeSet x -> IntLikeSet y+map f = IntLikeSet . IntSet.map (coerce f) . unIntLikeSet+{-# INLINE map #-}++filter :: (Coercible x Int) => (x -> Bool) -> IntLikeSet x -> IntLikeSet x+filter f = IntLikeSet . IntSet.filter (coerce f) . unIntLikeSet+{-# INLINE filter #-}++insertState :: Coercible x Int => (Bool -> b) -> x -> IntLikeSet x -> (b, IntLikeSet x)+insertState f x = coerce . IntSet.alterF (\b -> (f b, True)) (coerce x) . unIntLikeSet+{-# INLINE insertState #-}++orderedPairs :: Coercible x Int => IntLikeSet x -> [(x, x)]+orderedPairs s = let vs = toList s in [(x, y) | x <- vs, y <- vs]++unorderedPairs :: Coercible x Int => IntLikeSet x -> [(x, x)]+unorderedPairs = go1 . toList where+  go1 vs =+    case vs of+      [] -> []+      x:xs -> go2 x xs xs+  go2 x vl vs =+    case vl of+      [] -> go1 vs+      y:vl' -> (x, y):go2 x vl' vs
+ test/Main.hs view
@@ -0,0 +1,14 @@+module Main (main) where++import Test.Tasty (TestTree, defaultMain, testGroup)+import Test.Tasty.HUnit (testCase, (@?=))++testSimple :: TestTree+testSimple = testCase "simple" $ do+    let actual = (1 + 1) :: Int+        expected = 2 :: Int+    actual @?= expected++-- TODO uh, write some tests!?!+main :: IO ()+main = defaultMain (testGroup "IntLike" [testSimple])