Hakyll.Core.Identifier.Pattern

As Identifier is used to specify a single item, a Pattern is used to specify a list of items.

In most cases, globs are used for patterns.

A very simple pattern of such a pattern is "foo/bar". This pattern will only match the exact foo/bar identifier.

To match more than one identifier, there are different captures that one can use:

• "*": matches at most one element of an identifier;
• "**": matches one or more elements of an identifier.

Some examples:

• "foo/*" will match "foo/bar" and "foo/foo", but not "foo/bar/qux";
• "**" will match any identifier;
• "foo/**" will match "foo/bar" and "foo/bar/qux", but not "bar/foo";
• "foo/*.html" will match all HTML files in the "foo/" directory.

The capture function allows the user to get access to the elements captured by the capture elements in the pattern.

The pattern type

data Pattern

Type that allows matching on identifiers

Instances

Show Pattern

IsString Pattern

Monoid Pattern

Binary Pattern

Creating patterns

fromGlob :: String -> Pattern

Parse a pattern from a string

fromList :: [Identifier] -> Pattern

Create a Pattern from a list of Identifiers it should match.

Warning: use this carefully with hasNoVersion and hasVersion. The Identifiers in the list already have versions assigned, and the pattern will then only match the intersection of both versions.

A more concrete example,

 fromList ["foo.markdown"] .&&. hasVersion "pdf"

will not match anything! The foo.markdown Identifier has no version assigned, so the LHS of .&&. will only match this Identifier with no version. The RHS only matches Identifiers with version set to pdf -- hence, this pattern matches nothing.

The correct way to use this is:

 fromList $ map (setVersion $ Just "pdf") ["foo.markdown"]

fromRegex :: String -> Pattern

Create a Pattern from a regex

Example:

 regex "^foo/[^x]*$

fromVersion :: Maybe String -> Pattern

Create a pattern which matches all items with the given version.

hasVersion :: String -> Pattern

Specify a version, e.g.

 "foo/*.markdown" .&&. hasVersion "pdf"

hasNoVersion :: Pattern

Match only if the identifier has no version set, e.g.

 "foo/*.markdown" .&&. hasNoVersion

Composing patterns

(.&&.) :: Pattern -> Pattern -> Pattern

&& for patterns: the given identifier must match both subterms

(.||.) :: Pattern -> Pattern -> Pattern

|| for patterns: the given identifier must match any subterm

complement :: Pattern -> Pattern

Inverts a pattern, e.g.

 complement "foo/bar.html"

will match anything except "foo/bar.html"

Applying patterns

matches :: Pattern -> Identifier -> Bool

Check if an identifier matches a pattern

filterMatches :: Pattern -> [Identifier] -> [Identifier]

Given a list of identifiers, retain only those who match the given pattern

Capturing strings

capture :: Pattern -> Identifier -> Maybe [String]

Match a glob against a pattern, generating a list of captures

fromCapture :: Pattern -> String -> Identifier

Create an identifier from a pattern by filling in the captures with a given string

Example:

 fromCapture (fromGlob "tags/*") "foo"

Result:

 "tags/foo"

fromCaptures :: Pattern -> [String] -> Identifier

Create an identifier from a pattern by filling in the captures with the given list of strings