Turtle

See Turtle.Tutorial to learn how to use this library or Turtle.Prelude for a quick-start guide.

Here is the recommended way to import this library:

{-# LANGUAGE OverloadedStrings #-}

import Turtle
import Prelude hiding (FilePath)

This module re-exports the rest of the library and also re-exports useful modules from base:

Turtle.Format provides type-safe string formatting

Turtle.Pattern provides Patterns, which are like more powerful regular expressions

Turtle.Shell provides a Shell abstraction for building streaming, exception-safe pipelines

Turtle.Prelude provides a library of Unix-like utilities to get you started with basic shell-like programming within Haskell

Control.Applicative provides two classes:

• Applicative, which works with Fold, Pattern, Managed, and Shell
• Alternative, which works with Pattern and Shell

Control.Monad provides two classes:

• Monad, which works with Pattern, Managed and Shell
• MonadPlus, which works with Pattern and Shell

Control.Monad.IO.Class provides one class:

• MonadIO, which works with Managed and Shell

Data.Monoid provides one class:

• Monoid, which works with Fold, Pattern, Managed, and Shell

Control.Monad.Managed.Safe provides Managed resources

Filesystem.Path.CurrentOS provides FilePath-manipulation utilities

Additionally, you might also want to import the following modules qualified:

• Options.Applicative from optparse-applicative for command-line option parsing
• Control.Foldl (for predefined folds)
• Control.Foldl.Text (for Text-specific folds)
• Data.Text (for Text-manipulation utilities)
• Data.Text.IO (for reading and writing Text)
• Filesystem.Path.CurrentOS (for the remaining FilePath utilities)

Modules

module Turtle.Format

module Turtle.Pattern

module Turtle.Options

module Turtle.Shell

module Turtle.Prelude

module Control.Applicative

module Control.Monad

module Control.Monad.IO.Class

module Data.Monoid

module Control.Monad.Managed

module Filesystem.Path.CurrentOS

data Fold a b :: * -> * -> * where

Efficient representation of a left fold that preserves the fold's step function, initial accumulator, and extraction function

This allows the Applicative instance to assemble derived folds that traverse the container only once

A 'Fold a b' processes elements of type a and results in a value of type b.

Constructors

Fold :: (x -> a -> x) -> x -> (x -> b) -> Fold a b

Fold step initial extract

Instances

Profunctor Fold

Functor (Fold a)

Applicative (Fold a)

Comonad (Fold a)

Floating b => Floating (Fold a b)

Fractional b => Fractional (Fold a b)

Num b => Num (Fold a b)

Monoid b => Monoid (Fold a b)

data FoldM m a b :: (* -> *) -> * -> * -> * where

Like Fold, but monadic.

A 'FoldM m a b' processes elements of type a and results in a monadic value of type m b.

Constructors

FoldM :: (x -> a -> m x) -> m x -> (x -> m b) -> FoldM m a b

FoldM step initial extract

Instances

Monad m => Profunctor (FoldM m)

Monad m => Functor (FoldM m a)

Monad m => Applicative (FoldM m a)

(Monad m, Floating b) => Floating (FoldM m a b)

(Monad m, Fractional b) => Fractional (FoldM m a b)

(Monad m, Num b) => Num (FoldM m a b)

(Monoid b, Monad m) => Monoid (FoldM m a b)

data Text :: *

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text

Semigroup Text

type Item Text = Char

data UTCTime :: *

This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.

Instances

Eq UTCTime

Data UTCTime

Ord UTCTime

NFData UTCTime

ParseTime UTCTime

data NominalDiffTime :: *

This is a length of time, as measured by UTC. Conversion functions will treat it as seconds. It has a precision of 10^-12 s. It ignores leap-seconds, so it's not necessarily a fixed amount of clock time. For instance, 23:00 UTC + 2 hours of NominalDiffTime = 01:00 UTC (+ 1 day), regardless of whether a leap-second intervened.

Instances

Enum NominalDiffTime

Eq NominalDiffTime

Fractional NominalDiffTime

Data NominalDiffTime

Num NominalDiffTime

Ord NominalDiffTime

Real NominalDiffTime

RealFrac NominalDiffTime

Show NominalDiffTime

NFData NominalDiffTime

data Handle :: *

Haskell defines operations to read and write characters from and to files, represented by values of type Handle. Each value of this type is a handle: a record used by the Haskell run-time system to manage I/O with file system objects. A handle has at least the following properties:

• whether it manages input or output or both;
• whether it is open, closed or semi-closed;
• whether the object is seekable;
• whether buffering is disabled, or enabled on a line or block basis;
• a buffer (whose length may be zero).

Most handles will also have a current I/O position indicating where the next input or output operation will occur. A handle is readable if it manages only input or both input and output; likewise, it is writable if it manages only output or both input and output. A handle is open when first allocated. Once it is closed it can no longer be used for either input or output, though an implementation cannot re-use its storage while references remain to it. Handles are in the Show and Eq classes. The string produced by showing a handle is system dependent; it should include enough information to identify the handle for debugging. A handle is equal according to == only to itself; no attempt is made to compare the internal state of different handles for equality.

Instances

Eq Handle

Show Handle

data ExitCode :: *

Defines the exit codes that a program can return.

Constructors

ExitSuccess

indicates successful termination;

ExitFailure Int

indicates program failure with an exit code. The exact interpretation of the code is operating-system dependent. In particular, some values may be prohibited (e.g. 0 on a POSIX-compliant system).

Instances

Eq ExitCode

Ord ExitCode

Read ExitCode

Show ExitCode

Exception ExitCode

class IsString a where

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Methods

fromString :: String -> a

Instances

IsString Doc

IsString CmdSpec

construct a ShellCommand from a string literal

Since: 1.2.1.0

IsString HelpMessage

IsString Description

IsString CommandName

IsString ArgName

IsString [Char]

IsString a => IsString (Optional a)

IsString a => IsString (Shell a)

(~) * a Text => IsString (Pattern a)

(~) * a b => IsString (Format a b)

(&) :: a -> (a -> b) -> b infixl 1

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

Since: 4.8.0.0