在haskell中制作takeUntil函数

Question

I want make a function which when given a string eg "ab" and "cdabd" when it will be used on these two strings it will output "cd"

I have this up to now

takeUntil :: String -> String -> String
takeUntil [] [] = []
takeUntil xs [] = []
takeUntil [] ys = []
takeUntil xs ys = if contains xs ys then -- ???? I get stuck here. 

the contains function is one in which I had defined previously(this whole function should be case insensitive) contains function:

contains :: String -> String -> Bool
contains _ [] = True
contains [] _ = False
contains xs ys = isPrefixOf (map toLower ys) (map toLower xs) || contains (tail(map toLower xs)      (map toLower ys)

Answer 1

There is a lot of ways to do this, but continuing with your path, try the following:

import Data.List

takeUntil :: String -> String -> String
takeUntil [] [] = []                           --don't need this
takeUntil xs [] = [] 
takeUntil [] ys = [] 
takeUntil xs (y:ys) = if   isPrefixOf xs (y:ys)
                      then []
                      else y:(takeUntil xs (tail (y:ys)))

Some outputs:

takeUntil "ab" "cdabd"
"cd"

takeUntil "b" "cdabd"
"cda"

takeUntil "d" "cdabd"
"c"

takeUntil "c" "cdabd"
""

takeUntil "xxx" "cdabd"
"cdabd"

EDIT:

The OP wants the function to be case-insensitive.

Well, again you can do that in lot of ways. For example you can write a lowerCase function like (i think you already have it in Data.Text ):

import qualified Data.Char as Char

lowerCase :: String -> String
lowerCase [] = []
lowerCase (x:xs) = (Char.toLower x):(lowerCase xs)

And then use it like (maybe ugly and not very practical):

takeUntil (lowerCase "cd") (lowerCase "abcDe")
"ab"

That is the result you expect.

Also, you can use that lowerCase function inside takeUntil :

-- ...
takeUntil xs (y:ys) = if  isPrefixOf (lowerCase xs) (lowerCase (y:ys))
-- ...

So, you can just do:

takeUntil "cd" "abcDe"
"ab"

Anyway, i think the best option is that one @bheklilr suggested. Make your own isPrefixOfCaseless function.

I hope this helps.

Answer 2

Within the numerous approaches to define takeUntil , consider using Data.Text functions as follows,

takeUntil :: String -> String -> String
takeUntil sep txt =  unpack $ fst $ breakOn (pack sep) (toCaseFold $ pack txt)

Note that pack converts a String to a Text , whereas uncpak does the inverse; toCaseFold for case insensitive operations; breakOn delivers a pair where the first element includes text until the first (possible) match.

Update

This approach covers tests already suggested, yet it does not preseve original String for instance here,

takeUntil "e" "abcDe"
"abcd"

A work around this involves for instance the splitting by index at the break point.