Wrap +Text.Regex.Posix

module Text.Regex.Posix.Wrap
regex-posix Text.Regex.Posix.Wrap
WrapPosix.hsc exports a wrapped version of the ffi imports. To increase type safety, the flags are newtype'd. The other important export is a Regex type that is specific to the Posix library backend. The flags are documented in Text.Regex.Posix. The defaultCompOpt is (compExtended .|. compNewline). The Regex, CompOption, and ExecOption types and their RegexOptions instance is declared. The =~ and =~~ convenience functions are defined. The exported symbols are the same whether 1 is defined, but when it is not defined then getVersion == Nothing and all other exported values will call error or fail. This module will fail or error only if allocation fails or a nullPtr is passed in. 2009-January (:) wrapMatchAll and wrapCount now adjust the execution option execNotBOL after the first result to take into account '\n' in the text immediately before the next matches. (version 0.93.3) 2009-January (:) wrapMatchAll and wrapCount have been changed to return all non-overlapping matches, including empty matches even if they coincide with the end of the previous non-empty match. The change is that the first non-empty match no longer terminates the search. One can filter the results to obtain the old behavior or to obtain the behavior of sed, which coincide with the end of non-empty matches. (version 0.94.0)
type WrapError = (ReturnCode, String)
regex-posix Text.Regex.Posix.Wrap, regex-posix Text.Regex.Posix.String, regex-posix Text.Regex.Posix.Sequence, regex-posix Text.Regex.Posix.ByteString, regex-posix Text.Regex.Posix.ByteString.Lazy
The return code will be retOk when it is the Haskell wrapper and not the underlying library generating the error message.
package wraparound
package
WrapAround helps you perform calculations involving points on a finite, unbounded plane, in which objects that move across one edge of the map appear on the other. Add points, calculate distance, and so forth without worrying about the edge cases and frustrating math mistakes. Version 0.0.2
wrapCompile :: CompOption -> ExecOption -> CString -> IO (Either WrapError Regex)
regex-posix Text.Regex.Posix.Wrap
wrapCount :: Regex -> CString -> IO (Either WrapError Int)
regex-posix Text.Regex.Posix.Wrap
wrapMatch :: Regex -> CString -> IO (Either WrapError (Maybe [(RegOffset, RegOffset)]))
regex-posix Text.Regex.Posix.Wrap
wrapMatch returns offsets for the begin and end of each capture. Unused captures have offsets of unusedRegOffset which is (-1)
wrapMatchAll :: Regex -> CString -> IO (Either WrapError [MatchArray])
regex-posix Text.Regex.Posix.Wrap
wrapMatchAll returns the offset and length of each capture. Unused captures have an offset of unusedRegOffset which is (-1) and length of 0.
wrapTest :: Regex -> CString -> IO (Either WrapError Bool)
regex-posix Text.Regex.Posix.Wrap
package buildwrapper
package
Buildwrapper is an alternative to scion. It provides services to configure, build and give information on source files to help IDEs manage Haskell projects. You can use buildwrapper to build project and retrieve errors, get outline for each module source, get the type of something inside a source file, get lexer tokens, etc. Buildwrapper is used in the EclipseFP project (Eclipse plugins for Haskell development) Version 0.7.7
package either-unwrap
package
Functions for probing and unwrapping values inside of Either. Version 1.1
package flexiwrap
package
MPTC/FD framework using multi-purpose wrappers to direct instance selection Version 0.1.0
package flexiwrap-smallcheck
package
SmallCheck (Serial) instances for flexiwrap Version 0.0.1
package graph-wrapper
package
package monad-wrap
package
This package allows you to invoke a function on one monadic type passing it an argument of a different monadic type.  The canonical example is using a function such as finally or bracket to ensure cleanup is run regardless of any exceptions thrown by a computation such as x ::  ReaderT MyConfig IO b.  If x uses the ReaderT function ask, it cannot be re-written to run in the IO monad, and hence cannot be executed with a construction like lift (x ``finally`` cleanup).  Instead, you must use the wrap method, provided by module Control.Monad.Wrap in this package. This package contains several other modules: Control.Monad.WrapIO wraps an IO action through multiple monad transformers.  Control.Monad.WrapBase generalizes the concept to other base monads besides IO. Control.Monad.MultiWrap implements mwrap, a method that behaves like wrap but allows wrapping through multiple nested layers of monad transformer. The module Control.Monad.MultiLift provides mlift, a version of lift that similarly lifts through multiple nested monad transformers. Since this library was first released, an alternate approach was introduced by the monad-control package. monad-control is now the standard.  However, this package, monad-wrap, stands as an example of accomplishing similar goals with fewer language extensions and less complexity.  In particular, monad-wrap does not use RankNTypes or TypeFamilies, both required by monad-control.  Moreover, monad-wrap is much smaller--no MonadWrap method requires more than one line of code.  Both monad-wrap and monad-control require UndecidableInstances, but Control.Monad.Wrap itself does not require that extension, only the other modules. Version 0.1
package monadio-unwrappable
package
Provides MonadIOUnwrappable instances for monad transformer stacks that can be run in the IO monad, with the result converted back to the monadic type. This package also includes some utilities built using MonadIOUnwrappable, such as a bracket implementation that works with MonadIO even on stacks containing one or more ErrorT transformers Version 0.3
package OpenCLWrappers
package
Light opencl wrappers, a fork of the OpenCLRaw package. Version 0.1.0.2
package vcswrapper
package
Provides simple haskell functions to call external source code management systems. Currently git and SVN are supported. Version 0.0.1
package Win32-services-wrapper
package
Builds on the Win32-services package, providing a simple wrapper for turning a long-running process into a Windows service. Version 0.1.1.0