วิธีการแยกสตริงใน Haskell หรือไม่?

มีวิธีมาตรฐานในการแบ่งสตริงใน Haskell หรือไม่?

linesและwordsที่ดีทำงานจากที่แยกในพื้นที่หรือขึ้นบรรทัดใหม่ แต่ก็มีวิธีมาตรฐานในการแยกจุลภาคหรือไม่?

ฉันหามันไม่พบใน Hoogle

จะเฉพาะเจาะจง, ฉันกำลังมองหาบางสิ่งบางอย่างที่ผลตอบแทนsplit "," "my,comma,separated,list"["my","comma","separated","list"]

มีแพ็คเกจสำหรับการแยกที่เรียกว่านี้

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

มองมีความหมายของwordsมี

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

นี้ถูกสร้างขึ้นใน Platform 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 ธรรมดา

โดยทั่วไปพับด้วยกฎเมื่อสร้างรายการย่อยใหม่เพื่อฟีดควรแก้ไขด้วย

นอกเหนือจากฟังก์ชั่นที่มีประสิทธิภาพและสร้างขึ้นล่วงหน้าที่ให้ไว้ในคำตอบฉันจะเพิ่มของฉันเองซึ่งเป็นเพียงส่วนหนึ่งของ repertory ของฟังก์ชั่น 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