[FACTO+RENAME] RandomText module.

src/randomText.purs

+{-|
+Module      : RandomText
+Description : Referential random of texts
+Copyright   : (c) CNRS / Alexandre Delanoe, 2017
+License     : AGPL + CECILL v3
+Maintainer  : alexandre.delanoe@iscpif.fr
+Stability   : experimental
+Portability : POSIX
+
+How semantic emerge from contextualized randomness can be experimented
+with these simple functions;
+
+randomSentences: randomizes sentences in a paragraph.
+randomWords    : randomizes words     in a sentence.
+randomChars    : randomizes chars     in a word.
+
+TODO: add some tests as examples.
+-}
+
 module RandomText where
 
 import Prelude
 
 import Control.Monad.Eff (Eff(..))
 import Control.Monad.Eff.Random (RANDOM(..), randomInt)
-import Data.Array (length, (!!), head, tail, take, takeEnd, drop, dropEnd)
+
 import Data.Maybe (Maybe(Nothing, Just), fromJust)
-import Data.String (toCharArray, fromCharArray)
-import Data.Tuple (Tuple(..))
+import Data.Array ( length, (!!), filter, foldl
+                  , head, tail
+                  , take, takeEnd
+                  , drop, dropEnd
+                  )
+import Data.String ( toCharArray, fromCharArray
+                   , split, Pattern(..)
+                   )
 import Data.Tuple.Nested ((/\))
 import Partial (crash)
 import Partial.Unsafe (unsafePartial)
 import Unsafe.Coerce (unsafeCoerce)
 
+-------------------------------------------------------------------
+randomSentences :: forall a. String -> Eff ( random :: RANDOM | a ) String
+randomSentences ss = case (length (sentences ss)) >= 5 of
+                    true -> foldl (\a b -> a <> "." <> b) "" <$> randomPart (sentences ss)
+                    _    -> pure ss
 
-data RanR = RanR { l :: Array Char, r :: Array Char}
 
-instance showRanR :: Show RanR where
-    show (RanR {l:l', r:r'}) = show $ (show l') /\ (show r')
+randomWords :: forall a. String -> Eff ( random :: RANDOM | a ) String
+randomWords ws = case (length (words ws)) >= 5 of
+                    true -> foldl (\a b -> a <> " " <> b) "" <$> randomPart (words ws)
+                    _    -> pure ws
 
-rando (RanR {l:x,r:[]}) = pure $ RanR {l:x,r:[]}
-rando (RanR {l:x,r:xs}) = do
-    Ran {l:x',r:xs'} <- randomIt xs
-    rando (RanR {l:(x <> [x']), r: xs'})
+randomChars :: forall a. String -> Eff ( random :: RANDOM | a ) String
+randomChars word = case (length (toCharArray word)) >= 5 of
+                    true -> fromCharArray <$> randomPart (toCharArray word)
+                    _    -> pure word
 
+-------------------------------------------------------------------
+words :: String -> Array String
+words sentence = filter ((/=) "") $ split (Pattern " ") sentence
 
-remove :: forall t5. Int -> Array t5 -> Array t5
-remove n [] = []
-remove n xs = unsafePartial $ case n of
-                   0 -> fromJust $ tail xs
-                   _ -> (take n xs) <> (drop (n+1) xs)
+sentences :: String -> Array String
+sentences paragraph = filter ((/=) "") $ split (Pattern ".") paragraph
+-------------------------------------------------------------------
 
 
-data Ran = Ran { l :: Char, r :: Array Char}
+data RandomWheel a = RandomWheel { before :: Array a
+                                 , during :: a
+                                 , after  :: Array a
+                                 }
 
-instance showRan :: Show Ran where
-    show (Ran {l:l', r:r'}) = show $ (show l') /\ (show r')
+randomPart :: forall a b. Array b -> Eff ( random :: RANDOM | a ) (Array b)
+randomPart array = randomArrayPoly middle >>= \(middle') -> pure ( start <> middle' <> end)
+        where
+            start   = take 2             array
+            middle  = dropEnd 2 $ drop 2 array
+            end     = takeEnd 2          array
 
-randomIt :: forall t46. Array Char -> Eff ( random :: RANDOM | t46 ) Ran
-randomIt ar = unsafePartial $ do
-    -- let ar' = toCharArray ar
-    n    <- randomInt 0 (length ar - 1)
 
-    let maybeChar = (ar !! n )
-    let rest   = remove n ar
+randomArrayPoly :: forall a b. Array a -> Eff ( random :: RANDOM | b ) (Array a)
+randomArrayPoly wheel = case head wheel of
+                         Nothing -> pure []
+                         Just wheel' -> randomWheel (RandomWheel { before:wheel, during:wheel', after:[]}) 
+                                     >>= \(RandomWheel rand) -> (pure rand.after)
 
-    case maybeChar of
-         Nothing    -> 
-            crash "it should not happen"
-         Just char  -> 
-            pure $ Ran {l : char, r : rest}
+randomWheel :: forall a b. RandomWheel b -> Eff ( random :: RANDOM | a ) (RandomWheel b)
+randomWheel (RandomWheel {before:[], during:d, after:a}) = 
+    pure   (RandomWheel {before:[], during:d, after:a})
 
-randomize :: forall t98. String -> Eff ( random :: RANDOM | t98) String
-randomize string = do 
-    RanR rr <- rando (RanR {l:[], r:(toCharArray string)})
-    pure $ fromCharArray (rr.l)
+randomWheel (RandomWheel {before:b, during:d, after:a}) = do
+    RandomWheel {before:b', during:d', after:a'} <- randomArray b
+    randomWheel $ RandomWheel {before:b', during:d', after:(a <> [d'])}
 
 
-randomize' :: forall t98. (Array Char) -> Eff ( random :: RANDOM | t98) (Array Char)
-randomize' string = do 
-    RanR rr <- rando (RanR {l:[], r:string})
-    pure rr.l
+randomArray :: forall a b. Array b -> Eff ( random :: RANDOM | a ) (RandomWheel b) 
+randomArray array = unsafePartial $ do
+    n    <- randomInt 0 (length array - 1)
 
+    let maybeDuring = (array !! n)
 
-randomText :: forall t114. String -> Eff( random :: RANDOM| t114) String
-randomText txt = randomize' middle >>= \middle' -> pure $ fromCharArray ( start <> middle' <> end)
-        where
-            txt'    = toCharArray        txt
-            start   = take 2             txt'
-            middle  = dropEnd 2 $ drop 2 txt'
-            end     = takeEnd 2          txt'
-
-testText :: forall t114. String -> Eff( random :: RANDOM| t114) String
-testText txt = case (length (toCharArray txt)) >= 5 of
-                    true -> randomText txt
-                    _    -> pure txt
+    case maybeDuring of
+         Nothing    ->
+            crash "[ERROR] It should never happen."
+         Just during  ->
+            pure $ RandomWheel { before : remove n array
+                               , during : during
+                               , after  : []
+                               }
+
+
+remove :: forall a. Int -> Array a -> Array a
+remove n [] = []
+remove n xs = unsafePartial $ case n of
+                   0 -> fromJust $ tail xs
+                   _ -> (take n xs) <> (drop (n+1) xs)
+
+-------------------------------------------------------------------