Safe Haskell	Safe
Language	Haskell98

Language.Google.Search.Simple

Contents

Units
Search expression construction
Generalised Boolean operators
Primitive Terms
Boolean expressions

Description

An orphan lives in this module,

instance (Functor f, IsString a) => IsString (Free f a)

so that we can write "simple queries" :: Simple.

Synopsis

Documentation

Units

data Duration Source

Constructors

Days
Months
Years

Instances

Show Duration Source

data Size Source

Constructors

Bytes
KBytes
MBytes

Instances

Show Size Source

Search expression construction

data PrecBuilder Source

Builder with precedence, though ambiguous associativity. (But that's okay because Google doesn't mind which way you lean.)

Note that at Google OR binds tighter than conjunction, which is flipped in contrast to everywhere else. We take the analogous Haskell fixities when building search expressions:

11: atomic tokens or parenthesised expressions
10: complementation, search operators (cf. Haskell prefix application)
3: disjunction (OR or |)
2: conjunction (by juxtaposition)

Constructors

PrecBuilder Int Builder

Instances

Show PrecBuilder Source

parentheses :: Int -> ((PrecBuilder -> Builder) -> Builder) -> PrecBuilder Source

Give me the precedence of the piece of syntax you're building, and I'll give you a function that parenthesise any sub-expressions when necessary.

class SearchBuilder e where Source

Render a search expression using Google search syntax.

Methods

searchBuilder :: e -> PrecBuilder Source

Instances

SearchBuilder Text Source
SearchBuilder MailOp Source
SearchBuilder a => SearchBuilder (Term a) Source
(Functor f, SearchBuilder a, SyntaxBuilder f) => SearchBuilder (Free f a) Source	`SearchBuilder` for `Free`!

class SyntaxBuilder f where Source

Higher-order version of SearchBuilder.

Methods

syntaxBuilder :: f PrecBuilder -> PrecBuilder Source

Instances

SyntaxBuilder BooleanF Source
SyntaxBuilder Term Source

Generalised Boolean operators

class DisjunctF f where Source

Methods

disjunctF :: e -> e -> f e Source

Instances

DisjunctF BooleanF Source

class Disjunct e where Source

Methods

(\/) :: e -> e -> e infixr 2 Source

Instances

DisjunctF f => Disjunct (Free f a) Source

class ConjunctF f where Source

Methods

conjunctF :: e -> e -> f e Source

Instances

ConjunctF BooleanF Source

class Conjunct e where Source

Methods

(/\) :: e -> e -> e infixr 3 Source

Instances

ConjunctF f => Conjunct (Free f a) Source

class ComplementF f where Source

Methods

complementF :: e -> f e Source

Instances

ComplementF BooleanF Source

class Complement e where Source

Methods

notB :: e -> e Source

Instances

ComplementF f => Complement (Free f a) Source

andB :: Conjunct e => [e] -> e Source

andB is to /\ what and is to &&.

orB :: Disjunct e => [e] -> e Source

orB is to \/ what or is to ||.

Primitive Terms

data Term t Source

Fuzzy terms are grouped with parentheses (if necessary), while Exact terms are always “double-quoted”. The IsString instance defaults to Fuzzy, so just writing "literal string" ∷ Term Text is acceptable.

Constructors

Fuzzy t
Exact t

Instances

Functor Term Source
SyntaxBuilder Term Source
Show t => Show (Term t) Source
IsString t => IsString (Term t) Source
SearchBuilder a => SearchBuilder (Term a) Source

Boolean expressions

data BooleanF e Source

The shape of Boolean expressions.

Constructors

NotB e
e `AndB` e infixr 3
e `OrB` e infixr 2

Instances

Functor BooleanF Source
ComplementF BooleanF Source
ConjunctF BooleanF Source
DisjunctF BooleanF Source
SyntaxBuilder BooleanF Source
Show e => Show (BooleanF e) Source

type BooleanM = Free BooleanF Source

The free Boolean-shaped monad. No refunds.

type Simple = BooleanM (Term Text) Source

Simple Boolean combinations of Terms.