하스켈에서 줄을 나누는 방법?

Haskell에서 문자열을 분리하는 표준 방법이 있습니까?

lines및 words업무 공백이나 줄 바꿈에 분할에서 큰하지만 반드시 쉼표에 분할하는 표준 방법은 무엇입니까?

Hoogle에서 찾을 수 없습니다.

구체적으로, split "," "my,comma,separated,list"returns 가있는 곳을 찾고 ["my","comma","separated","list"]있습니다.

이를 위해 split 이라는 패키지가 있습니다 .

cabal install split

다음과 같이 사용하십시오.

ghci> import Data.List.Split
ghci> splitOn "," "my,comma,separated,list"
["my","comma","separated","list"]

일치하는 구분 기호를 분할하거나 여러 구분 기호를 갖는 많은 다른 기능이 제공됩니다.

Prelude 기능의 정의를 찾을 수 있습니다!

http://www.haskell.org/onlinereport/standard-prelude.html

거기를 보면 wordsis 의 정의 는

words   :: String -> [String]
words s =  case dropWhile Char.isSpace s of
                      "" -> []
                      s' -> w : words s''
                            where (w, s'') = break Char.isSpace s'

술어를 취하는 함수로 변경하십시오.

wordsWhen     :: (Char -> Bool) -> String -> [String]
wordsWhen p s =  case dropWhile p s of
                      "" -> []
                      s' -> w : wordsWhen p s''
                            where (w, s'') = break p s'

그런 다음 원하는 술어를 사용하여 호출하십시오!

main = print $ wordsWhen (==',') "break,this,string,at,commas"

Data.Text를 사용하면 splitOn이 있습니다.

http://hackage.haskell.org/packages/archive/text/0.11.2.0/doc/html/Data-Text.html#v:splitOn

이것은 Haskell 플랫폼에 내장되어 있습니다.

예를 들어 :

import qualified Data.Text as T
main = print $ T.splitOn (T.pack " ") (T.pack "this is a test")

또는:

{-# LANGUAGE OverloadedStrings #-}

import qualified Data.Text as T
main = print $ T.splitOn " " "this is a test"

Text.Regex (Haskell 플랫폼의 일부) 모듈에는 다음과 같은 기능이 있습니다.

splitRegex :: Regex -> String -> [String]

정규식을 기반으로 문자열을 분할합니다. API는 Hackage 에서 찾을 수 있습니다 .

를 사용 Data.List.Split하는 다음을 사용하십시오 split.

[me@localhost]$ ghci
Prelude> import Data.List.Split
Prelude Data.List.Split> let l = splitOn "," "1,2,3,4"
Prelude Data.List.Split> :t l
l :: [[Char]]
Prelude Data.List.Split> l
["1","2","3","4"]
Prelude Data.List.Split> let { convert :: [String] -> [Integer]; convert = map read }
Prelude Data.List.Split> let l2 = convert l
Prelude Data.List.Split> :t l2
l2 :: [Integer]
Prelude Data.List.Split> l2
[1,2,3,4]

이거 한번 해봐:

import Data.List (unfoldr)

separateBy :: Eq a => a -> [a] -> [[a]]
separateBy chr = unfoldr sep where
  sep [] = Nothing
  sep l  = Just . fmap (drop 1) . break (== chr) $ l

단일 문자에서만 작동하지만 쉽게 확장 가능해야합니다.

공백을 하나의 문자로 직접 대체하지 않고 대상 구분 기호 words는 공백입니다. 다음과 같은 것 :

words [if c == ',' then ' ' else c|c <- "my,comma,separated,list"]

또는

words let f ',' = ' '; f c = c in map f "my,comma,separated,list"

이를 매개 변수가있는 함수로 만들 수 있습니다. 다음 과 같이 일치하는 많은 문자와 일치 하는 매개 변수를 제거 할 수 있습니다 .

 [if elem c ";,.:-+@!$#?" then ' ' else c|c <-"my,comma;separated!list"]

split :: Eq a => a -> [a] -> [[a]]
split d [] = []
split d s = x : split d (drop 1 y) where (x,y) = span (/= d) s

예 :

split ';' "a;bb;ccc;;d"
> ["a","bb","ccc","","d"]

단일 후행 구분 기호가 삭제됩니다.

split ';' "a;bb;ccc;;d;"
> ["a","bb","ccc","","d"]

나는 어제 Haskell을 배우기 시작했습니다.

split :: Eq a => a -> [a] -> [[a]]
split x y = func x y [[]]
    where
        func x [] z = reverse $ map (reverse) z
        func x (y:ys) (z:zs) = if y==x then 
            func x ys ([]:(z:zs)) 
        else 
            func x ys ((y:z):zs)

제공합니다 :

*Main> split ' ' "this is a test"
["this","is","a","test"]

아니면 당신이 원하는

*Main> splitWithStr  " and " "this and is and a and test"
["this","is","a","test"]

다음과 같습니다.

splitWithStr :: Eq a => [a] -> [a] -> [[a]]
splitWithStr x y = func x y [[]]
    where
        func x [] z = reverse $ map (reverse) z
        func x (y:ys) (z:zs) = if (take (length x) (y:ys)) == x then
            func x (drop (length x) (y:ys)) ([]:(z:zs))
        else
            func x ys ((y:z):zs)

나는 스티브의 대답에 댓글을 추가하는 방법을 몰라,하지만 난 추천하고 싶습니다
  GHC 라이브러리 문서를 ,
그리고 거기에 특별히
  Data.List에서 하위 목록 기능

단순한 Haskell 보고서를 읽는 것보다 참조로 훨씬 좋습니다.

일반적으로 피드 할 새 하위 목록을 만들 때 규칙이있는 접기도 해결해야합니다.

답변에 주어진 효율적이고 사전 작성된 함수 외에도, 나는 내 자신의 시간에 언어를 배우기 위해 작성했던 Haskell 함수의 레퍼토리의 일부인 내 자신을 추가 할 것입니다.

-- Correct but inefficient implementation
wordsBy :: String -> Char -> [String]
wordsBy s c = reverse (go s []) where
    go s' ws = case (dropWhile (\c' -> c' == c) s') of
        "" -> ws
        rem -> go ((dropWhile (\c' -> c' /= c) rem)) ((takeWhile (\c' -> c' /= c) rem) : ws)

-- Breaks up by predicate function to allow for more complex conditions (\c -> c == ',' || c == ';')
wordsByF :: String -> (Char -> Bool) -> [String]
wordsByF s f = reverse (go s []) where
    go s' ws = case ((dropWhile (\c' -> f c')) s') of
        "" -> ws
        rem -> go ((dropWhile (\c' -> (f c') == False)) rem) (((takeWhile (\c' -> (f c') == False)) rem) : ws)

솔루션은 적어도 꼬리 재귀이므로 스택 오버플로가 발생하지 않습니다.

ghci의 예 :

>  import qualified Text.Regex as R
>  R.splitRegex (R.mkRegex "x") "2x3x777"
>  ["2","3","777"]

이해하기가 더 간단합니다.

split :: Char -> String -> [String]
split c xs = case break (==c) xs of 
  (ls, "") -> [ls]
  (ls, x:rs) -> ls : split c rs