¿Cuál es la mejor manera de dividir una cadena por un delimitador de manera funcional?

Question

Traté de escribir el programa en Haskell, que tendrá una cadena de números enteros delimitados por comas, convertirlo a la lista de números enteros y el incremento por cada número 1.

Por ejemplo "1,2,-5,-23,15" -> [2,3,-4,-22,16]

A continuación se el programa resultante

import Data.List 

main :: IO() 
main = do 
    n <- return 1 
    putStrLn . show . map (+1) . map toInt . splitByDelimiter delimiter 
    $ getList n 

getList :: Int -> String 
getList n = foldr (++) [] . intersperse [delimiter] $ replicate n inputStr 

delimiter = ',' 

inputStr = "1,2,-5,-23,15" 

splitByDelimiter :: Char -> String -> [String] 
splitByDelimiter _ "" = [] 
splitByDelimiter delimiter list = 
    map (takeWhile (/= delimiter) . tail) 
    (filter (isPrefixOf [delimiter]) 
     (tails 
      (delimiter : list))) 

toInt :: String -> Int 
toInt = read 

la parte más difícil para mí fue la programación de la función splitByDelimiter que toman una cadena y la lista de regreso de Cuerdas

"1,2,-5,-23,15" -> ["1","2","-5","-23","15"]

Pensé que funcionaba, no estoy contento con la forma en que está escrito. Hay muchos paréntesis, así que luce como Lisp. Asimismo, el algoritmo es algo artificial:

1. Prepend delimitador de comienzo de la cadena de ",1,2,-5,-23,15"

2. lista de todas las colas [",1,2,-5,-23,15", "1,2,-5,-23,15", ",2,-5,-23,15", .... ]

3. Filtrar Generar y dejó sólo cadenas que comienza con delimitador [",1,2,-5,-23,15", ",2,-5,-23,15", .... ]

4. Suelta el primer delimitador y toma los símbolos hasta que se cumpla el siguiente delimitador ["1", "2", .... ]

Así que las preguntas son:

¿Cómo puedo mejorar la función splitByDelimiter?

¿Puedo eliminar anteponer y soltar el delimitador y hacer una división directa de la cadena?

¿Cómo puedo reescribir la función para que haya menos paréntesis?

¿Puedo perder algo y ya hay una función estándar con esta funcionalidad?

Answer 1

¿No Data.List.Split.splitOn hace esto?

Answer 2

Esto es un truco, pero diablos, funciona.

yourFunc str = map (+1) $ read ("[" ++ str ++ "]") 

Aquí es una versión no-hack usando unfoldr:

import Data.List 
import Control.Arrow(second) 

-- break' is like break but removes the 
-- delimiter from the rest string 
break' d = second (drop 1) . break d 

split :: String -> Maybe (String,String) 
split [] = Nothing 
split xs = Just . break' (==',') $ xs 

yourFunc :: String -> [Int] 
yourFunc = map ((+1) . read) . unfoldr split 

Answer 3

Ésta es la aplicación de la respuesta de HaskellElephant a la pregunta original con cambios menores

 
splitByDelimiter :: Char -> String -> [String] 
splitByDelimiter = unfoldr . splitSingle 

splitSingle :: Char -> String -> Maybe (String,String) 
splitSingle _ [] = Nothing 
splitSingle delimiter xs = 
    let (ys, zs) = break (== delimiter) xs in 
    Just (ys, drop 1 zs) 

Cuando el splitSingle función de división de la lista en dos subcadenas por primer delimitador.

Por ejemplo: "1,2,-5,-23,15" -> Just ("1", "2,-5,-23,15")

Answer 4

Sólo por diversión, aquí es cómo se puede crear un programa de análisis sencillo con Parsec:

module Main where 

import Control.Applicative hiding (many) 
import Text.Parsec 
import Text.Parsec.String 

line :: Parser [Int] 
line = number `sepBy` (char ',' *> spaces) 

number = read <$> many digit 

Una de las ventajas es que es fácilmente crear un analizador que es flexible en lo que aceptará:

*Main Text.Parsec Text.Parsec.Token> :load "/home/mikste/programming/Temp.hs" 
[1 of 1] Compiling Main    (/home/mikste/programming/Temp.hs, interpreted) 
Ok, modules loaded: Main. 
*Main Text.Parsec Text.Parsec.Token> parse line "" "1, 2, 3" 
Right [1,2,3] 
*Main Text.Parsec Text.Parsec.Token> parse line "" "10,2703, 5, 3" 
Right [10,2703,5,3] 
*Main Text.Parsec Text.Parsec.Token> 

Answer 5

splitBy delimiter = foldr f [[]] 
      where f c l@(x:xs) | c == delimiter = []:l 
          | otherwise = (c:x):xs 

Editar: no por el autor original, pero a continuación es una versión más (¿demasiado?) Detallada y menos flexible (específica de Char/String) para ayudar a aclarar cómo funciona esto. Utilice la versión anterior porque funciona en cualquier lista de un tipo con una instancia Eq.

splitBy :: Char -> String -> [String] 
splitBy _ "" = []; 
splitBy delimiterChar inputString = foldr f [""] inputString 
    where f :: Char -> [String] -> [String] 
     f currentChar allStrings@(partialString:handledStrings) 
      | currentChar == delimiterChar = "":allStrings -- start a new partial string at the head of the list of all strings 
      | otherwise = (currentChar:partialString):handledStrings -- add the current char to the partial string 

-- input:  "a,b,c" 
-- fold steps: 
-- first step: 'c' -> [""] -> ["c"] 
-- second step: ',' -> ["c"] -> ["","c"] 
-- third step: 'b' -> ["","c"] -> ["b","c"] 
-- fourth step: ',' -> ["b","c"] -> ["","b","c"] 
-- fifth step: 'a' -> ["","b","c"] -> ["a","b","c"] 

Answer 6

splitBy del str = helper del str [] 
    where 
     helper _ [] acc = let acc0 = reverse acc in [acc0] 
     helper del (x:xs) acc 
      | x==del = let acc0 = reverse acc in acc0 : helper del xs [] 
      | otherwise = let acc0 = x : acc  in helper del xs acc0 

Answer 7

Este código funciona bien uso: - split "Su cadena" [] y reemplazar '' con cualquier delimitador

split [] t = [t] 
split (a:l) t = if a==',' then (t:split l []) else split l (t++[a]) 

Answer 8

import qualified Text.Regex as RegExp 

myRegexSplit :: String -> String -> [String] 
myRegexSplit regExp theString = 
    let result = RegExp.splitRegex (RegExp.mkRegex regExp) theString 
    in filter (not . null) result 

-- using regex has the advantage of making it easy to use a regular 
-- expression instead of only normal strings as delimiters. 

-- the splitRegex function tends to return an array with an empty string 
-- as the last element. So the filter takes it out 

-- how to use in ghci to split a sentence 
let timeParts = myRegexSplit " " "I love ponies a lot"