Added a few functions

* replicate
* replicateA
* none
* singleton

With some basic tests.

Author: LiamGoodacre

bower.json

@@ -24,6 +24,7 @@
     "purescript-tuples": "^0.4.0"
   },
   "devDependencies": {
-    "purescript-console": "^0.1.0"
+    "purescript-console": "^0.1.0",
+    "purescript-assert": "^0.1.0"
   }
 }

docs/Data/Unfoldable.md

@@ -27,4 +27,51 @@ The generating function `f` in `unfoldr f` in understood as follows:
 instance unfoldableArray :: Unfoldable Array
 ```
 
+#### `replicate`
+
+``` purescript
+replicate :: forall f a. (Unfoldable f) => Int -> a -> f a
+```
+
+Replicate a value some natural number of times.
+For example:
+
+~~~ purescript
+replicate 2 "foo" == ["foo", "foo"] :: Array String
+~~~
+
+#### `replicateA`
+
+``` purescript
+replicateA :: forall m f a. (Applicative m, Unfoldable f, Traversable f) => Int -> m a -> m (f a)
+```
+
+Perform an Applicative action `n` times, and accumulate all the results.
+
+#### `none`
+
+``` purescript
+none :: forall f a. (Unfoldable f) => f a
+```
+
+The container with no elements - unfolded with zero iterations.
+For example:
+
+~~~ purescript
+none == [] :: forall a. Array a
+~~~
+
+#### `singleton`
+
+``` purescript
+singleton :: forall f a. (Unfoldable f) => a -> f a
+```
+
+Contain a single value.
+For example:
+
+~~~ purescript
+singleton "foo" == ["foo"] :: Array String
+~~~
+
 

package.json

@@ -2,7 +2,7 @@
   "private": true,
   "scripts": {
     "postinstall": "pulp dep install",
-    "build": "pulp build && rimraf docs && pulp docs"
+    "build": "pulp build && pulp test && rimraf docs && pulp docs"
   },
   "devDependencies": {
     "pulp": "^4.0.2",

src/Data/Unfoldable.purs

@@ -11,6 +11,7 @@ import Prelude
 import Data.Maybe
 import Data.Tuple
 import Data.Array.ST
+import Data.Traversable
 import Control.Monad.Eff
 import Control.Monad.ST
 
@@ -24,7 +25,7 @@ import Control.Monad.ST
 -- |   appended to the result of `unfoldr f b1`.
 class Unfoldable t where
   unfoldr :: forall a b. (b -> Maybe (Tuple a b)) -> b -> t a
- 
+
 instance unfoldableArray :: Unfoldable Array where
   unfoldr f b = runPure (runSTArray (do
     arr  <- emptySTArray
@@ -38,3 +39,41 @@ instance unfoldableArray :: Unfoldable Array where
           writeSTRef seed b2
           return false
     return arr))
+
+-- | Replicate a value some natural number of times.
+-- | For example:
+-- |
+-- | ~~~ purescript
+-- | replicate 2 "foo" == ["foo", "foo"] :: Array String
+-- | ~~~
+replicate :: forall f a. (Unfoldable f) => Int -> a -> f a
+replicate n v = unfoldr step n
+  where
+    step :: Int -> Maybe (Tuple a Int)
+    step i =
+      if i <= 0 then Nothing
+      else Just (Tuple v (i - 1))
+
+-- | Perform an Applicative action `n` times, and accumulate all the results.
+replicateA :: forall m f a. (Applicative m, Unfoldable f, Traversable f) =>
+              Int -> m a -> m (f a)
+replicateA n m = sequence (replicate n m)
+
+-- | The container with no elements - unfolded with zero iterations.
+-- | For example:
+-- |
+-- | ~~~ purescript
+-- | none == [] :: forall a. Array a
+-- | ~~~
+none :: forall f a. (Unfoldable f) => f a
+none = unfoldr (const Nothing) unit
+
+-- | Contain a single value.
+-- | For example:
+-- |
+-- | ~~~ purescript
+-- | singleton "foo" == ["foo"] :: Array String
+-- | ~~~
+singleton :: forall f a. (Unfoldable f) => a -> f a
+singleton = replicate 1
+

test/Main.purs

@@ -0,0 +1,27 @@
+module Test.Main where
+
+import Prelude
+
+import Control.Monad.Eff (Eff())
+import Control.Monad.Eff.Console
+import Data.Maybe
+import Data.Unfoldable
+import Test.Assert
+
+main = do
+  log "Test none"
+  assert $ none == [] :: Array Unit
+
+  log "Test singleton"
+  assert $ singleton unit == [unit]
+
+  log "Test replicate"
+  assert $ replicate 3 "foo" == ["foo", "foo", "foo"]
+
+  log "Test replicateA"
+  assert $ replicateA 3 [1,2] == [
+    [1,1,1],[1,1,2], [1,2,1],[1,2,2],
+    [2,1,1],[2,1,2], [2,2,1],[2,2,2]
+  ]
+
+  log "All done!"