Thank you very much for this suggestion. I just tried the character class
you mentioned and it works.
The stackoverflow post you mentioned was a nice read and I surely agree
that regular expressions are normally not the way to go for most HTML
munging needs. But luckily the generated HTML from pandoc is very specific
and the <table> tag I wanted to match (for line-numbered code listings)
does not contain any further tables so I thought it should be safe to
approach it like this.
The resulting code is now:
-- Wraps numbered code listings within the page body with a div
-- in order to be able to apply some more specific styling.
wrapNumberedCodelistings (Page meta body) =
Page meta newBody
where
newBody = regexReplace
"]+>[\\s\\S]*?</table>" wrap body
wrap x = "" ++ x ++ "</div>"
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
Don't know though if it could be cleaned up further or even if this is by
any means good style (being still fairly new to haskell).
Furthermore I would still be very interested in the right approach to
manipulating the HTML structure as a whole and I too hope that another
Haskeller could name a more suitable solution for manipulating HTML.
Or even how to pass the 's' modifier to Text.Regex.PCRE.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss
wrote:
I'd be more inclined to look at a solution involving manipulating the HTML
structure, rather than trying a regexp-based approach, which will probably
end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609
)
I hope another Haskeller can speak to a library that would be good for
this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it
should work on multiline strings. If you can work out how to pass the 's'
modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc
btw.) and I am trying to wrap certain elements (tags with a given class)
with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a
reasonable choice because I am already familiar with similar regex
implementations in other languages.
I came up with the following function which takes a regex and replaces
all matches within the given string using the provided function (which I
would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
The problem with this function is, that it will not work on multiline
strings. I would like to call it like this:
newBody = regexReplace "
" wrap body
wrap x = "" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the
regex in question?
Or is this approach completely off and would something else be more
appropriate/haskelly for the problem at hand?
Thank you very much in advance.
_______________________________________________
Beginners mailing list
Beginners@haskell.org (mailto:Beginners@haskell.org)
http://www.haskell.org/mailman/listinfo/beginners
Exploring the documentation for Text.Regex.PCRE, I've found "CompOption":
http://hackage.haskell.org/packages/archive/regex-pcre/0.94.4/doc/html/Text-...
The constants are listed below; the one you want is probably compDotAll, to make "." match newlines as well. I'm not 100% sure if this is the module you want, though, and I can't seem to get regex-pcre installed, so I can't test. Apologies!
On Wednesday, 6 June 2012 at 4:52 PM, Rico Moorman wrote:
Thank you very much for this suggestion. I just tried the character class you mentioned and it works.
The stackoverflow post you mentioned was a nice read and I surely agree that regular expressions are normally not the way to go for most HTML munging needs. But luckily the generated HTML from pandoc is very specific and the <table> tag I wanted to match (for line-numbered code listings) does not contain any further tables so I thought it should be safe to approach it like this.
The resulting code is now:
-- Wraps numbered code listings within the page body with a div
-- in order to be able to apply some more specific styling.
wrapNumberedCodelistings (Page meta body) =
Page meta newBody
where
newBody = regexReplace "]+>[\\s\\S]*?</table>" wrap body
wrap x = "" ++ x ++ "</div>"
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
Don't know though if it could be cleaned up further or even if this is by any means good style (being still fairly new to haskell).
Furthermore I would still be very interested in the right approach to manipulating the HTML structure as a whole and I too hope that another Haskeller could name a more suitable solution for manipulating HTML.
Or even how to pass the 's' modifier to Text.Regex.PCRE.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss wrote:
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609)
I hope another Haskeller can speak to a library that would be good for this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "
" wrap body
wrap x = "" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance.
_______________________________________________
Beginners mailing list
Beginners@haskell.org (mailto:Beginners@haskell.org) (mailto:Beginners@haskell.org)
http://www.haskell.org/mailman/listinfo/beginners
Thank you again!
Looking at the docs it seems that this could do the trick. A pity that
you cannot install the package.
Now I am wondering how I would integrate this in the replacement
function or how to rewrite it properly.
Looking at the type signature of =~~ (with my limited knowledge) it
seems that I would have to "use" RegexMaker adding up the CompOptions
needed?
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext
Regex source1 target, Monad m) => source1 -> source -> m target
On Wed, Jun 6, 2012 at 9:46 AM, Arlen Cuss wrote:
Exploring the documentation for Text.Regex.PCRE, I've found "CompOption":
http://hackage.haskell.org/packages/archive/regex-pcre/0.94.4/doc/html/Text-...
The constants are listed below; the one you want is probably compDotAll, to make "." match newlines as well. I'm not 100% sure if this is the module you want, though, and I can't seem to get regex-pcre installed, so I can't test. Apologies!
On Wednesday, 6 June 2012 at 4:52 PM, Rico Moorman wrote:
Thank you very much for this suggestion. I just tried the character class you mentioned and it works.
The stackoverflow post you mentioned was a nice read and I surely agree that regular expressions are normally not the way to go for most HTML munging needs. But luckily the generated HTML from pandoc is very specific and the <table> tag I wanted to match (for line-numbered code listings) does not contain any further tables so I thought it should be safe to approach it like this.
The resulting code is now:
-- Wraps numbered code listings within the page body with a div
-- in order to be able to apply some more specific styling.
wrapNumberedCodelistings (Page meta body) =
Page meta newBody
where
newBody = regexReplace "]+>[\\s\\S]*?</table>" wrap body
wrap x = "" ++ x ++ "</div>"
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
Don't know though if it could be cleaned up further or even if this is by any means good style (being still fairly new to haskell).
Furthermore I would still be very interested in the right approach to manipulating the HTML structure as a whole and I too hope that another Haskeller could name a more suitable solution for manipulating HTML.
Or even how to pass the 's' modifier to Text.Regex.PCRE.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss wrote:
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609)
I hope another Haskeller can speak to a library that would be good for this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "
" wrap body
wrap x = "" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance.
_______________________________________________
Beginners mailing list
Beginners@haskell.org (mailto:Beginners@haskell.org) (mailto:Beginners@haskell.org)
http://www.haskell.org/mailman/listinfo/beginners
Since I can't seem to get the PCRE package installed (not sure what's going on here: http://hpaste.org/69589), I gave it a go with plain Text.Regex, which should (?) use Text.Regex.Posix by default.
λ> let regex = mkRegexWithOpts "abc(.*)def" False False in matchRegex regex "abc content\nmore def"
Just [" content\nmore "]
λ>
See: http://hackage.haskell.org/packages/archive/regex-compat/0.92/doc/html/Text-...
That said, Text.Regex.Posix is a bit broken, and you might want to use regex-tdfa. See also:
* http://www.haskell.org/haskellwiki/Regex_Posix
* http://www.haskell.org/haskellwiki/Regular_expressions
Cheers,
A
On Wednesday, 6 June 2012 at 6:39 PM, Rico Moorman wrote:
Thank you again!
Looking at the docs it seems that this could do the trick. A pity that
you cannot install the package.
Now I am wondering how I would integrate this in the replacement
function or how to rewrite it properly.
Looking at the type signature of =~~ (with my limited knowledge) it
seems that I would have to "use" RegexMaker adding up the CompOptions
needed?
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext
Regex source1 target, Monad m) => source1 -> source -> m target
On Wed, Jun 6, 2012 at 9:46 AM, Arlen Cuss wrote:
Exploring the documentation for Text.Regex.PCRE, I've found "CompOption":
http://hackage.haskell.org/packages/archive/regex-pcre/0.94.4/doc/html/Text-...
The constants are listed below; the one you want is probably compDotAll, to make "." match newlines as well. I'm not 100% sure if this is the module you want, though, and I can't seem to get regex-pcre installed, so I can't test. Apologies!
On Wednesday, 6 June 2012 at 4:52 PM, Rico Moorman wrote:
Thank you very much for this suggestion. I just tried the character class you mentioned and it works.
The stackoverflow post you mentioned was a nice read and I surely agree that regular expressions are normally not the way to go for most HTML munging needs. But luckily the generated HTML from pandoc is very specific and the <table> tag I wanted to match (for line-numbered code listings) does not contain any further tables so I thought it should be safe to approach it like this.
The resulting code is now:
-- Wraps numbered code listings within the page body with a div
-- in order to be able to apply some more specific styling.
wrapNumberedCodelistings (Page meta body) =
Page meta newBody
where
newBody = regexReplace "]+>[\\s\\S]*?</table>" wrap body
wrap x = "" ++ x ++ "</div>"
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
Don't know though if it could be cleaned up further or even if this is by any means good style (being still fairly new to haskell).
Furthermore I would still be very interested in the right approach to manipulating the HTML structure as a whole and I too hope that another Haskeller could name a more suitable solution for manipulating HTML.
Or even how to pass the 's' modifier to Text.Regex.PCRE.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:11 AM, Arlen Cuss wrote:
I'd be more inclined to look at a solution involving manipulating the HTML structure, rather than trying a regexp-based approach, which will probably end up disappointing. (See this: http://stackoverflow.com/a/1732454/499609)
I hope another Haskeller can speak to a library that would be good for this kind of purpose.
To suit what you're doing now, though; if you change .*? to [\s\S]*?, it should work on multiline strings. If you can work out how to pass the 's' modifier to Text.Regexp.PCRE, that should also do it.
—Arlen
On Wednesday, 6 June 2012 at 3:05 PM, Rico Moorman wrote:
Hello,
I have a given piece of multiline HTML (which is generated using pandoc btw.) and I am trying to wrap certain elements (tags with a given class) with a <div>.
I already took a look at the Text.Regex.PCRE module which seemed a reasonable choice because I am already familiar with similar regex implementations in other languages.
I came up with the following function which takes a regex and replaces all matches within the given string using the provided function (which I would use to wrap the element)
import Text.Regex.PCRE ((=~~))
-- Replaces the whole match for the given regex using the given function
regexReplace :: String -> (String -> String) -> String -> String
regexReplace regex replace text = go text
where
go text = case text =~~ regex of
Just (before, match, after) ->
before ++ replace match ++ go after
_ -> text
The problem with this function is, that it will not work on multiline strings. I would like to call it like this:
newBody = regexReplace "
" wrap body
wrap x = "" ++ x ++ "</div>"
Is there any way to easily pass some kind of multiline modifier to the regex in question?
Or is this approach completely off and would something else be more appropriate/haskelly for the problem at hand?
Thank you very much in advance.
_______________________________________________
Beginners mailing list
Beginners@haskell.org (mailto:Beginners@haskell.org) (mailto:Beginners@haskell.org)
http://www.haskell.org/mailman/listinfo/beginners
On Wed, Jun 6, 2012 at 10:39 AM, Rico Moorman wrote:
Now I am wondering how I would integrate this in the replacement
function or how to rewrite it properly.
Looking at the type signature of =~~ (with my limited knowledge) it
seems that I would have to "use" RegexMaker adding up the CompOptions
needed?
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext
Regex source1 target, Monad m) => source1 -> source -> m target
What's non-obvious and trip a lot of people when they try to use
regexes in Haskell is that most regex libraries use the same
interface, which is specified in the regex-base and consists of
several typeclasses that offers a very high degree of flexibility.
=~and =~~ are only the simplified front-ends to this and are pretty
inadequate for advanced usages (for instance compile and use multiple
time the same regex, you should really avoid =~ in this case, or
additional regex compilation options). To see the basic interface,
look at Text.Regex.Base.RegexLike :
http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-...
.
In particular, what you want to do should be done with makeRegexOpts
and match (or matchM), note that the available compilation and
execution options can vary depending on the regex library you use and
for regex-pcre, they're documented there :
http://hackage.haskell.org/packages/archive/regex-pcre/latest/doc/html/Text-...
--
Jedaï
Thank you for this important detail.
Following the advice in this thread I tried to rewrite the function in
terms of the lower-level interface instead of using =~~
-- qualified import to avoid clashes in main program
import qualified Text.Regex.PCRE as RE
regexReplace' :: String -> (String -> String) -> String -> String
regexReplace' regex replace text = go text
where
regex' :: RE.Regex
regex' = RE.makeRegexOpts RE.defaultCompOpt RE.defaultExecOpt regex
replace' :: RE.MatchText String -> String
replace' = undefined
go text = case RE.matchOnceText regex' text of
Just (before, match, after) ->
before ++ replace' match ++ go after
_ -> text
Did you mean something like this? (besides that the replace' function
still has to be filled in)
If this is correct ... I am still a little lost though. I cannot come
up with a way of matching the actual String out of the MatchText
returned by matchOnceText ...
http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-...
If I should structure the entire function differently, I would be very
grateful to receive some pointers how.
Best regards,
rico
On Wed, Jun 6, 2012 at 7:50 PM, Chaddaï Fouché wrote:
On Wed, Jun 6, 2012 at 10:39 AM, Rico Moorman wrote:
Now I am wondering how I would integrate this in the replacement
function or how to rewrite it properly.
Looking at the type signature of =~~ (with my limited knowledge) it
seems that I would have to "use" RegexMaker adding up the CompOptions
needed?
(=~~) :: (RegexMaker Regex CompOption ExecOption source, RegexContext
Regex source1 target, Monad m) => source1 -> source -> m target
What's non-obvious and trip a lot of people when they try to use
regexes in Haskell is that most regex libraries use the same
interface, which is specified in the regex-base and consists of
several typeclasses that offers a very high degree of flexibility.
=~and =~~ are only the simplified front-ends to this and are pretty
inadequate for advanced usages (for instance compile and use multiple
time the same regex, you should really avoid =~ in this case, or
additional regex compilation options). To see the basic interface,
look at Text.Regex.Base.RegexLike :
http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-...
.
In particular, what you want to do should be done with makeRegexOpts
and match (or matchM), note that the available compilation and
execution options can vary depending on the regex library you use and
for regex-pcre, they're documented there :
http://hackage.haskell.org/packages/archive/regex-pcre/latest/doc/html/Text-...
--
Jedaï
On Wed, Jun 6, 2012 at 10:08 PM, Rico Moorman wrote:
If this is correct ... I am still a little lost though. I cannot come
up with a way of matching the actual String out of the MatchText
returned by matchOnceText ...
http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-...
MatchText is an array, which allows for captures in the regex, for
instance, if matching "hello Abel ! And goodbye." with "hello (\w+)
([.!?])", MatchText would be :
array (0,2) [(0,("hello Abel !",(0,12))), (1,("Abel",(6,4))), (2,("!",(11,1)))]
So if you want the whole matched text, you would use :
fst (match ! 0)
Or you could just use matchM :
go text = case RE.matchM regex' text of
Just (before, match, after) ->
before ++ replace' match ++ go after
_ -> text
and have match be a string, just like before (since you don't use all
the power of MatchText anyway).
--
Jedaï
What's non-obvious and trip a lot of people when they try to use
regexes in Haskell is that most regex libraries use the same
interface, which is specified in the regex-base and consists of
several typeclasses that offers a very high degree of flexibility.
=~and =~~ are only the simplified front-ends to this and are pretty
inadequate for advanced usages (for instance compile and use multiple
time the same regex, you should really avoid =~ in this case, or
additional regex compilation options). To see the basic interface,
look at Text.Regex.Base.RegexLike :
http://hackage.haskell.org/packages/archive/regex-base/latest/doc/html/Text-...
.
In particular, what you want to do should be done with makeRegexOpts
and match (or matchM), note that the available compilation and
execution options can vary depending on the regex library you use and
for regex-pcre, they're documented there :
http://hackage.haskell.org/packages/archive/regex-pcre/latest/doc/html/Text-...
--
Jedaï
By the way, do you know other good resources on Regular expressions in
Haskell and especially the multiple backends (tdfa, posix and pcre
e.g.) in combination with the basic interface and how to use this all
together? Some example code would be really useful.
Furthermore the following page states that the Text.Regex.Base stuff
is being exported again by the newer/other regex modules.
http://hackage.haskell.org/packages/archive/regex-base/0.93.2/doc/html/Text-...
Does this mean I should use the specific regex modules directly or
should I import the base and then specific functionality from the
engine modules?
Thank you very much in advance,
Best regards,
Rico
4731
Last active (days ago)
List overview
Download
9 comments
3 participants
tags
participants (3)
-
Arlen Cuss
-
Chaddaï Fouché
-
Rico Moorman
