5df3524 · elk · git.iko.soy

git.iko.soy/elk

Remove Dict.{filter,partition}WithKey

commit5df3524a1182d842d239f3f4bd442b906fbc4874 authorHarry Garrood <harry@garrood.me> dateWed 16 Apr 2014, 20:54 (13 years ago) parentd1d687d

3 files changed+13−38

compare with master

unifiedsplit

libraries/Dict.elm+9−20 libraries/Set.elm+2−2 tests/elm/Test/Dict.elm+2−16

libraries/Dict.elm+9−20

@@ -1,8 +1,8 @@

11module Dict (empty,singleton,insert,update

22 ,lookup,findWithDefault

33 ,remove,member

4− ,filter,filterWithKey

5− ,partition,partitionWithKey

4+ ,filter

5+ ,partition

66 ,foldl,foldr,map

77 ,union,intersect,diff

88 ,keys,values

@@ -329,7 +329,7 @@ union t1 t2 = foldl insert t2 t1

329329{-| Keep a key-value pair when its key appears in the second dictionary.

330330Preference is given to values in the first dictionary. -}

331331intersect : Dict comparable v -> Dict comparable v -> Dict comparable v

332−intersect t1 t2 = filterWithKey (\k _ -> k `member` t2) t1

332+intersect t1 t2 = filter (\k _ -> k `member` t2) t1

333333

334334{-| Keep a key-value pair when its key does not appear in the second dictionary.

335335Preference is given to the first dictionary. -}

@@ -352,31 +352,20 @@ toList t = foldr (\k v acc -> (k,v) :: acc) [] t

352352fromList : [(comparable,v)] -> Dict comparable v

353353fromList assocs = List.foldl (\(k,v) d -> insert k v d) empty assocs

354354

355−{-| Keep only key-value pairs where the value satisfies a predicate. -}

356−filter : (v -> Bool) -> Dict comparable v -> Dict comparable v

357−filter p = filterWithKey (\_ v -> p v)

358−

359−{-| Keep only key-value pairs which satisfy a predicate. -}

360−filterWithKey : (comparable -> v -> Bool)

355+{-| Keep a key-value pair when it satisfies a predicate. -}

356+filter : (comparable -> v -> Bool)

361357 -> Dict comparable v

362358 -> Dict comparable v

363−filterWithKey p =

359+filter p =

364360 let add k v t = if p k v then insert k v t else t

365361 in foldl add empty

366362

367363{-| Partition the Dict according to a predicate. The first Dict contains all

368−values which satisfy a predicate; the second contains the rest. -}

369−partition : (v -> Bool)

364+key-value pairs which satisfy it; the second contains the rest. -}

365+partition : (comparable -> v -> Bool)

370366 -> Dict comparable v

371367 -> (Dict comparable v, Dict comparable v)

372−partition p = partitionWithKey (\_ v -> p v)

373−

374−{-| Partition the Dict according to a predicate. The first Dict contains all

375−key-value pairs which satisfy a predicate; the second contains the rest. -}

376−partitionWithKey : (comparable -> v -> Bool)

377− -> Dict comparable v

378− -> (Dict comparable v, Dict comparable v)

379−partitionWithKey p =

368+partition p =

380369 let add k v (t1, t2) = if p k v

381370 then (insert k v t1, t2)

382371 else (t1, insert k v t2)

libraries/Set.elm+2−2

@@ -92,11 +92,11 @@ map f s = fromList (List.map f (toList s))

9292

9393{-| Create a new set consisting only of elements which satisfy a predicate. -}

9494filter : (comparable -> Bool) -> Set comparable -> Set comparable

95−filter p = Dict.filterWithKey (\k _ -> p k)

95+filter p = Dict.filter (\k _ -> p k)

9696

9797{-| Create two new sets; the first consisting of elements which satisfy a

9898predicate, the second consisting of elements which do not. -}

9999partition : (comparable -> Bool)

100100 -> Set comparable

101101 -> (Set comparable, Set comparable)

102−partition p = Dict.partitionWithKey (\k _ -> p k)

102+partition p = Dict.partition (\k _ -> p k)

tests/elm/Test/Dict.elm+2−16

@@ -21,23 +21,9 @@ dict1Part1 = Dict.fromList (take 2 dict1List)

2121dict1Part2 : Dict Int Char

2222dict1Part2 = Dict.fromList (drop 2 dict1List)

2323

24−dict2List : Dict Int Char

25−dict2List = [(1,'2'),(3,'3'),(7,'4'),(8,'3')]

26−

27−dict2 : Dict Int Char

28−dict2 = Dict.fromList dict2List

29−

30−dict2Part1 : Dict Int Char

31−dict2Part1 = Dict.fromList (take 2 dict2List)

32−

33−dict2Part2 : Dict Int Char

34−dict2Part2 = Dict.fromList (drop 2 dict2List)

35−

3624tests : [Test]

3725tests =

3826 let

39− partitionTests = [assertEqual (dict1Part1, dict1Part2) <| partition (\v -> v != "3" && v != "5") dict1]

40− partitionWithKeyTests = [assertEqual (dict2Part1, dict2Part2) <| partition (\k v -> k <= parseDigit v)]

4127 filterTests = [assertEqual dict1Part2 <| filter (\v -> parseDigit v > 2) dict1]

42− filterWithKeyTests = [assertEqual dict2Part2 <| filterWithKey (\k _ -> k > 6) dict2]

43− in List.concat [partitionTests, partitionWithKeyTests, filterTests, filterWithKeyTests]

28+ partitionTests = [assertEqual (dict1Part1, dict1Part2) <| partition (\v -> v != '3' && v != '5') dict1]

29+ in List.concat [filterTests, partitionTests]