intersect

intersect :: Eq a => [a] -> [a] -> [a]
base Data.List
The intersect function takes the list intersection of two lists. For example, > [1,2,3,4] `intersect` [2,4,6,8] == [2,4] If the first list contains duplicates, so will the result. > [1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4] It is a special case of intersectBy, which allows the programmer to supply their own equality test.
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
base Data.List
The intersectBy function is the non-overloaded version of intersect.
intersectFileModes :: FileMode -> FileMode -> FileMode
unix System.Posix.Files.ByteString, unix System.Posix.Files
Combines two file modes into one that only contains modes that appear in both.
intersection :: IntMap a -> IntMap b -> IntMap a
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n+m). The (left-biased) intersection of two maps (based on keys). > intersection (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "a"
intersection :: IntSet -> IntSet -> IntSet
containers Data.IntSet
O(n+m). The intersection of two sets.
intersection :: Ord a => Set a -> Set a -> Set a
containers Data.Set
O(n+m). The intersection of two sets. Elements of the result come from the first set, so for example > import qualified Data.Set as S > data AB = A | B deriving Show > instance Ord AB > instance Eq AB > main = print (S.singleton A `S.intersection` S.singleton B, > S.singleton B `S.intersection` S.singleton A) prints (fromList [A],fromList [B]).
intersection :: Ord k => Map k a -> Map k b -> Map k a
containers Data.Map.Lazy, containers Data.Map.Strict
O(n+m). Intersection of two maps. Return data in the first map for the keys existing in both maps. (intersection m1 m2 == intersectionWith const m1 m2). > intersection (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "a"
intersectionWith :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n+m). The intersection with a combining function. > intersectionWith (++) (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "aA"
intersectionWith :: Ord k => (a -> b -> c) -> Map k a -> Map k b -> Map k c
containers Data.Map.Lazy, containers Data.Map.Strict
O(n+m). Intersection with a combining function. > intersectionWith (++) (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "aA"
intersectionWithKey :: (Key -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
containers Data.IntMap.Strict, containers Data.IntMap.Lazy
O(n+m). The intersection with a combining function. > let f k al ar = (show k) ++ ":" ++ al ++ "|" ++ ar > intersectionWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "5:a|A"
intersectionWithKey :: Ord k => (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
containers Data.Map.Lazy, containers Data.Map.Strict
O(n+m). Intersection with a combining function. Intersection is more efficient on (bigset `intersection` smallset). > let f k al ar = (show k) ++ ":" ++ al ++ "|" ++ ar > intersectionWithKey f (fromList [(5, "a"), (3, "b")]) (fromList [(5, "A"), (7, "C")]) == singleton 5 "5:a|A"