conversions between NonEmptyArray/NonEmptyString

addresses #101

This uses unsafePartial for the sake of efficiency.

Author: matthewleon

bower.json

@@ -22,7 +22,7 @@
     "purescript-maybe": "^3.0.0",
     "purescript-partial": "^1.2.0",
     "purescript-unfoldable": "^3.0.0",
-    "purescript-arrays": "^4.0.1",
+    "purescript-arrays": "^4.3.0",
     "purescript-integers": "^3.2.0"
   },
   "devDependencies": {

src/Data/String/NonEmpty.purs

@@ -10,12 +10,14 @@ module Data.String.NonEmpty
   , fromString
   , unsafeFromString
   , fromCharArray
+  , fromNonEmptyCharArray
   , singleton
   , cons
   , snoc
   , fromFoldable1
   , toString
   , toCharArray
+  , toNonEmptyCharArray
   , charAt
   , charCodeAt
   , toChar
@@ -52,6 +54,8 @@ module Data.String.NonEmpty
 
 import Prelude
 
+import Data.Array.NonEmpty (NonEmptyArray)
+import Data.Array.NonEmpty as NEA
 import Data.Foldable (class Foldable)
 import Data.Foldable as F
 import Data.Maybe (Maybe(..), fromJust)
@@ -60,6 +64,7 @@ import Data.Semigroup.Foldable as F1
 import Data.String (Pattern(..))
 import Data.String as String
 import Data.String.Unsafe as U
+import Partial.Unsafe (unsafePartial)
 import Unsafe.Coerce (unsafeCoerce)
 
 -- | A string that is known not to be empty.
@@ -110,6 +115,9 @@ fromCharArray = case _ of
   [] -> Nothing
   cs -> Just (NonEmptyString (String.fromCharArray cs))
 
+fromNonEmptyCharArray :: NonEmptyArray Char -> NonEmptyString
+fromNonEmptyCharArray = unsafePartial fromJust <<< fromCharArray <<< NEA.toArray
+
 -- | Creates a `NonEmptyString` from a character.
 singleton :: Char -> NonEmptyString
 singleton = NonEmptyString <<< String.singleton
@@ -181,6 +189,10 @@ toChar (NonEmptyString s) = String.toChar s
 toCharArray :: NonEmptyString -> Array Char
 toCharArray (NonEmptyString s) = String.toCharArray s
 
+-- | Converts the `NonEmptyString` into a non-empty array of characters.
+toNonEmptyCharArray :: NonEmptyString -> NonEmptyArray Char
+toNonEmptyCharArray = unsafePartial fromJust <<< NEA.fromArray <<< toCharArray
+
 -- | Appends a string to this non-empty string. Since one of the strings is
 -- | non-empty we know the result will be too.
 -- |

test/Test/Data/String/NonEmpty.purs

@@ -4,6 +4,7 @@ import Data.String.NonEmpty
 
 import Control.Monad.Eff (Eff)
 import Control.Monad.Eff.Console (CONSOLE, log)
+import Data.Array.NonEmpty as NEA
 import Data.Array.Partial as AP
 import Data.Foldable (class Foldable, foldl)
 import Data.Maybe (Maybe(..), fromJust, isNothing, maybe)
@@ -22,6 +23,9 @@ testNonEmptyString = do
   assert $ fromCharArray [] == Nothing
   assert $ fromCharArray ['a', 'b'] == Just (nes "ab")
 
+  log "fromNonEmptyCharArray"
+  assert $ fromNonEmptyCharArray (NEA.singleton 'b') == singleton 'b'
+
   log "singleton"
   assert $ singleton 'a' == nes "a"
 
@@ -64,6 +68,10 @@ testNonEmptyString = do
   assert $ toCharArray (nes "ab") == ['a', 'b']
   assert $ toCharArray (nes "Hello☺\n") == ['H','e','l','l','o','☺','\n']
 
+  log "toNonEmptyCharArray"
+  assert $ toNonEmptyCharArray (nes "ab")
+           == unsafePartial fromJust (NEA.fromArray ['a', 'b'])
+
   log "appendString"
   assert $ appendString (nes "Hello") " world" == nes "Hello world"
   assert $ appendString (nes "Hello") "" == nes "Hello"