Merge pull request #36 from hdgarrood/maximum-minimum

Add maximum and minimum

Author: paf31

bower.json

@@ -28,6 +28,9 @@
   },
   "devDependencies": {
     "purescript-console": "^0.1.0",
-    "purescript-assert": "^0.1.0"
+    "purescript-assert": "^0.1.0",
+    "purescript-functions": "~0.1.0",
+    "purescript-integers": "~0.2.1",
+    "purescript-math": "~0.2.0"
   }
 }

src/Data/Foldable.purs

@@ -16,6 +16,10 @@ module Data.Foldable
   , elem
   , notElem
   , find
+  , maximum
+  , maximumBy
+  , minimum
+  , minimumBy
   ) where
 
 import Prelude
@@ -228,3 +232,33 @@ notElem x = not <<< elem x
 -- | Try to find an element in a data structure which satisfies a predicate.
 find :: forall a f. (Foldable f) => (a -> Boolean) -> f a -> Maybe a
 find p = foldl (\r x -> if p x then Just x else r) Nothing
+
+-- | Find the largest element of a structure, according to its `Ord` instance.
+maximum :: forall a f. (Ord a, Foldable f) => f a -> Maybe a
+maximum = maximumBy compare
+
+-- | Find the largest element of a structure, according to a given comparison
+-- | function. The comparison function should represent a total ordering (see
+-- | the `Ord` type class laws); if it does not, the behaviour is undefined.
+maximumBy :: forall a f. (Foldable f) => (a -> a -> Ordering) -> f a -> Maybe a
+maximumBy cmp = foldl max' Nothing
+  where
+  max' Nothing x  = Just x
+  max' (Just x) y = Just (case cmp x y of
+                            GT -> x
+                            _  -> y)
+
+-- | Find the smallest element of a structure, according to its `Ord` instance.
+minimum :: forall a f. (Ord a, Foldable f) => f a -> Maybe a
+minimum = minimumBy compare
+
+-- | Find the smallest element of a structure, according to a given comparison
+-- | function. The comparison function should represent a total ordering (see
+-- | the `Ord` type class laws); if it does not, the behaviour is undefined.
+minimumBy :: forall a f. (Foldable f) => (a -> a -> Ordering) -> f a -> Maybe a
+minimumBy cmp = foldl min' Nothing
+  where
+  min' Nothing x  = Just x
+  min' (Just x) y = Just (case cmp x y of
+                            LT -> x
+                            _  -> y)

test/Main.purs

@@ -4,6 +4,9 @@ import Prelude
 
 import Control.Monad.Eff (Eff())
 import Control.Monad.Eff.Console
+import Data.Int (toNumber)
+import Data.Function (on)
+import Math (abs)
 import Data.Maybe
 import Data.Monoid.Additive
 import Data.Foldable
@@ -70,6 +73,24 @@ main = do
   log "Test bisequenceDefault"
   testBitraversableIOrWith BSD
 
+  log "Test maximum"
+  assert $ maximum (arrayFrom1UpTo 10) == Just 10
+
+  log "Test maximumBy"
+  assert $
+    maximumBy (compare `on` abs)
+              (map (negate <<< toNumber) (arrayFrom1UpTo 10))
+      == Just (-10.0)
+
+  log "Test minimum"
+  assert $ minimum (arrayFrom1UpTo 10) == Just 1
+
+  log "Test minimumBy"
+  assert $
+    minimumBy (compare `on` abs)
+              (map (negate <<< toNumber) (arrayFrom1UpTo 10))
+      == Just (-1.0)
+
   log "All done!"