Language.Ninja.Misc

Utility types and functions for the rest of language-ninja.

This module re-exports all of the modules under the Language.Ninja.Misc namespace for convenience.

It is recommended that you import it with the following style:

import qualified Language.Ninja.Misc as Misc

Since: 0.1.0

Language.Ninja.Misc.Command

data Command

This type represents a POSIX sh command line.

Since: 0.1.0

Instances

Eq Command

Methods

(==) :: Command -> Command -> Bool

(/=) :: Command -> Command -> Bool

Ord Command

Methods

compare :: Command -> Command -> Ordering

(<) :: Command -> Command -> Bool

(<=) :: Command -> Command -> Bool

(>) :: Command -> Command -> Bool

(>=) :: Command -> Command -> Bool

max :: Command -> Command -> Command

min :: Command -> Command -> Command

Read Command

Methods

readsPrec :: Int -> ReadS Command

readList :: ReadS [Command]

readPrec :: ReadPrec Command

readListPrec :: ReadPrec [Command]

Show Command

Methods

showsPrec :: Int -> Command -> ShowS

show :: Command -> String

showList :: [Command] -> ShowS

Generic Command

Associated Types

type Rep Command :: * -> *

Methods

from :: Command -> Rep Command x

to :: Rep Command x -> Command

Hashable Command

Methods

hashWithSalt :: Int -> Command -> Int

hash :: Command -> Int

ToJSON Command

Methods

toJSON :: Command -> Value

toEncoding :: Command -> Encoding

toJSONList :: [Command] -> Value

toEncodingList :: [Command] -> Encoding

FromJSON Command

Methods

parseJSON :: Value -> Parser Command

parseJSONList :: Value -> Parser [Command]

NFData Command

Methods

rnf :: Command -> ()

(Monad m, Serial m Text) => Serial m Command

Uses the underlying Text instance.

Since: 0.1.0

Methods

series :: Series m Command

(Monad m, CoSerial m Text) => CoSerial m Command

Uses the underlying Text instance.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (Command -> b)

type Rep Command

type Rep Command = D1 (MetaData "Command" "Language.Ninja.Misc.Command" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" True) (C1 (MetaCons "MkCommand" PrefixI True) (S1 (MetaSel (Just Symbol "_commandText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Text)))

makeCommand :: Text -> Command

Constructor for a Command.

Since: 0.1.0

commandText :: Iso' Command Text

An isomorphism between a Command and its underlying Text.

Since: 0.1.0

Language.Ninja.Misc.Path

data Path

This type represents a Unix path string.

Since: 0.1.0

Instances

Eq Path

Methods

(==) :: Path -> Path -> Bool

(/=) :: Path -> Path -> Bool

Ord Path

Methods

compare :: Path -> Path -> Ordering

(<) :: Path -> Path -> Bool

(<=) :: Path -> Path -> Bool

(>) :: Path -> Path -> Bool

(>=) :: Path -> Path -> Bool

max :: Path -> Path -> Path

min :: Path -> Path -> Path

Read Path

Methods

readsPrec :: Int -> ReadS Path

readList :: ReadS [Path]

readPrec :: ReadPrec Path

readListPrec :: ReadPrec [Path]

Show Path

Methods

showsPrec :: Int -> Path -> ShowS

show :: Path -> String

showList :: [Path] -> ShowS

IsString Path

Methods

fromString :: String -> Path

Generic Path

Associated Types

type Rep Path :: * -> *

Methods

from :: Path -> Rep Path x

to :: Rep Path x -> Path

Hashable Path

Methods

hashWithSalt :: Int -> Path -> Int

hash :: Path -> Int

ToJSON Path

Methods

toJSON :: Path -> Value

toEncoding :: Path -> Encoding

toJSONList :: [Path] -> Value

toEncodingList :: [Path] -> Encoding

ToJSONKey Path

Methods

toJSONKey :: ToJSONKeyFunction Path

toJSONKeyList :: ToJSONKeyFunction [Path]

FromJSON Path

Methods

parseJSON :: Value -> Parser Path

parseJSONList :: Value -> Parser [Path]

FromJSONKey Path

Methods

fromJSONKey :: FromJSONKeyFunction Path

fromJSONKeyList :: FromJSONKeyFunction [Path]

NFData Path

Methods

rnf :: Path -> ()

(Monad m, Serial m Text) => Serial m Path

Uses the underlying IText instance.

Since: 0.1.0

Methods

series :: Series m Path

(Monad m, CoSerial m Text) => CoSerial m Path

Uses the underlying IText instance.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (Path -> b)

type Rep Path

type Rep Path = D1 (MetaData "Path" "Language.Ninja.Misc.Path" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" True) (C1 (MetaCons "MkPath" PrefixI True) (S1 (MetaSel (Just Symbol "_pathIText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 IText)))

makePath :: Text -> Path

Construct a Path from some Text.

Since: 0.1.0

pathIText :: Iso' Path IText

An isomorphism between a Path and its underlying IText.

Since: 0.1.0

pathText :: Iso' Path Text

An isomorphism that gives access to a Text-typed view of a Path, even though the underlying data has type IText.

This is equivalent to pathIText . from Ninja.itext.

Since: 0.1.0

pathString :: Iso' Path String

An isomorphism that gives access to a String-typed view of a Path.

Since: 0.1.0

pathFP :: Iso' Path FilePath

An isomorphism between a Path and a FilePath from system-filepath. This uses decodeString and encodeString, so all the caveats on those functions apply here.

Since: 0.1.0

Language.Ninja.Misc.IText

data IText

An interned (hash-consed) text type. This is a newtype over InternedText from the intern package.

Since: 0.1.0

Instances

Eq IText

Methods

(==) :: IText -> IText -> Bool

(/=) :: IText -> IText -> Bool

Ord IText

The Ord instance in intern compares hashes rather than values.

Since: 0.1.0

Methods

compare :: IText -> IText -> Ordering

(<) :: IText -> IText -> Bool

(<=) :: IText -> IText -> Bool

(>) :: IText -> IText -> Bool

(>=) :: IText -> IText -> Bool

max :: IText -> IText -> IText

min :: IText -> IText -> IText

Read IText

Inverse of the Show instance.

Since: 0.1.0

Methods

readsPrec :: Int -> ReadS IText

readList :: ReadS [IText]

readPrec :: ReadPrec IText

readListPrec :: ReadPrec [IText]

Show IText

Displays an IText such that fromString is inverse to show.

Since: 0.1.0

Methods

showsPrec :: Int -> IText -> ShowS

show :: IText -> String

showList :: [IText] -> ShowS

IsString IText

Methods

fromString :: String -> IText

Generic IText

Associated Types

type Rep IText :: * -> *

Methods

from :: IText -> Rep IText x

to :: Rep IText x -> IText

Hashable IText

Uses the Hashable instance for Text. Not very efficient.

TODO: perhaps switch to hashing the identifier, since this is likely pretty hot code given all the HashMap Target … types all over the place.

Since: 0.1.0

Methods

hashWithSalt :: Int -> IText -> Int

hash :: IText -> Int

ToJSON IText

Converts to JSON string via uninternText.

Since: 0.1.0

Methods

toJSON :: IText -> Value

toEncoding :: IText -> Encoding

toJSONList :: [IText] -> Value

toEncodingList :: [IText] -> Encoding

ToJSONKey IText

Converts to JSON string via uninternText.

Since: 0.1.0

Methods

toJSONKey :: ToJSONKeyFunction IText

toJSONKeyList :: ToJSONKeyFunction [IText]

FromJSON IText

Inverse of the ToJSON instance.

Since: 0.1.0

Methods

parseJSON :: Value -> Parser IText

parseJSONList :: Value -> Parser [IText]

FromJSONKey IText

Inverse of the ToJSONKey instance.

Since: 0.1.0

Methods

fromJSONKey :: FromJSONKeyFunction IText

fromJSONKeyList :: FromJSONKeyFunction [IText]

NFData IText

Defined by rnf a = seq a (), since IText is a newtype of strict types.

Since: 0.1.0

Methods

rnf :: IText -> ()

(Monad m, Serial m Text) => Serial m IText

Uses the Text instance.

Since: 0.1.0

Methods

series :: Series m IText

(Monad m, CoSerial m Text) => CoSerial m IText

Uses the Text instance.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (IText -> b)

type Rep IText

type Rep IText = D1 (MetaData "IText" "Language.Ninja.Misc.IText" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" True) (C1 (MetaCons "MkIText" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 InternedText)))

uninternText :: IText -> Text

Get the Text corresponding to the given IText value.

>>> uninternText ("foobar" :: IText)
"foobar"

Since: 0.1.0

internText :: Text -> IText

Intern a Text value, resulting in an IText value.

uninternText (internText (Text.pack x)) == Text.pack x

>>> internText ("foobar" :: Text)
"foobar"

Since: 0.1.0

itext :: Iso' Text IText

An Iso' between Text and IText.

(Lens.view itext (fromString x)) == fromString x

(Lens.view (Lens.from itext) (fromString x)) == fromString x

>>> (Lens.view itext ("foobar" :: Text)) :: IText
"foobar"

>>> (Lens.view (Lens.from itext) ("foobar" :: IText)) :: Text
"foobar"

Since: 0.1.0

Language.Ninja.Misc.Positive

data Positive

This type represents a positive number; i.e.: an integer greater than zero.

Since: 0.1.0

Instances

Enum Positive

Methods

succ :: Positive -> Positive

pred :: Positive -> Positive

toEnum :: Int -> Positive

fromEnum :: Positive -> Int

enumFrom :: Positive -> [Positive]

enumFromThen :: Positive -> Positive -> [Positive]

enumFromTo :: Positive -> Positive -> [Positive]

enumFromThenTo :: Positive -> Positive -> Positive -> [Positive]

Eq Positive

Methods

(==) :: Positive -> Positive -> Bool

(/=) :: Positive -> Positive -> Bool

Integral Positive

Methods

quot :: Positive -> Positive -> Positive

rem :: Positive -> Positive -> Positive

div :: Positive -> Positive -> Positive

mod :: Positive -> Positive -> Positive

quotRem :: Positive -> Positive -> (Positive, Positive)

divMod :: Positive -> Positive -> (Positive, Positive)

toInteger :: Positive -> Integer

Num Positive

This instance uses error to preserve the Positive invariant.

Since: 0.1.0

Methods

(+) :: Positive -> Positive -> Positive

(-) :: Positive -> Positive -> Positive

(*) :: Positive -> Positive -> Positive

negate :: Positive -> Positive

abs :: Positive -> Positive

signum :: Positive -> Positive

fromInteger :: Integer -> Positive

Ord Positive

Methods

compare :: Positive -> Positive -> Ordering

(<) :: Positive -> Positive -> Bool

(<=) :: Positive -> Positive -> Bool

(>) :: Positive -> Positive -> Bool

(>=) :: Positive -> Positive -> Bool

max :: Positive -> Positive -> Positive

min :: Positive -> Positive -> Positive

Read Positive

Methods

readsPrec :: Int -> ReadS Positive

readList :: ReadS [Positive]

readPrec :: ReadPrec Positive

readListPrec :: ReadPrec [Positive]

Real Positive

Methods

toRational :: Positive -> Rational

Show Positive

Methods

showsPrec :: Int -> Positive -> ShowS

show :: Positive -> String

showList :: [Positive] -> ShowS

Generic Positive

Associated Types

type Rep Positive :: * -> *

Methods

from :: Positive -> Rep Positive x

to :: Rep Positive x -> Positive

Hashable Positive

Methods

hashWithSalt :: Int -> Positive -> Int

hash :: Positive -> Int

ToJSON Positive

Methods

toJSON :: Positive -> Value

toEncoding :: Positive -> Encoding

toJSONList :: [Positive] -> Value

toEncodingList :: [Positive] -> Encoding

FromJSON Positive

Methods

parseJSON :: Value -> Parser Positive

parseJSONList :: Value -> Parser [Positive]

NFData Positive

Methods

rnf :: Positive -> ()

Monad m => Serial m Positive

Uses the underlying Int instance.

Since: 0.1.0

Methods

series :: Series m Positive

Monad m => CoSerial m Positive

Uses the underlying Int instance.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (Positive -> b)

type Rep Positive

type Rep Positive = D1 (MetaData "Positive" "Language.Ninja.Misc.Positive" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" True) (C1 (MetaCons "MkPositive" PrefixI True) (S1 (MetaSel (Just Symbol "_fromPositive") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

makePositive :: Int -> Maybe Positive

Constructor for a Positive.

Since: 0.1.0

fromPositive :: Getter Positive Int

A Getter for the Int underlying a Positive.

Since: 0.1.0

Language.Ninja.Misc.Annotated

class Functor ty => Annotated ty where

If you have some type that represents an AST node, it is often useful to add a polymorphic "annotation field" to it, which is used for things like source positions.

Specifically, suppose we have the following AST node type:

data Foo = Foo { _fooBar :: !Bar, _fooBaz :: !Baz } deriving (…)

Then an annotation field is added by the following process:

1. Add an extra (final) type parameter ann to the type.
2. Add an extra field _fooAnn :: !ann.
3. Derive instances of Functor, Foldable, and Traversable.
4. If the type is recursive, add a Plated instance. See Language.Ninja.AST.Expr for a complete example of this.
5. Write an Annotated instance with the canonical lens given by the _fooAnn field. There are plenty of examples around this library.

The end result then looks like:

data Foo ann
  = Foo
    { _fooAnn :: !ann
    , _fooBar :: !Bar
    , _fooBaz :: !Baz
    }
  deriving (…, Functor, Foldable, Traversable)

instance Annotated Foo where
  annotation' = …

Since: 0.1.0

Minimal complete definition

annotation'

Methods

annotation' :: (ann -> ann') -> Lens (ty ann) (ty ann') ann ann'

Given a function that is used when fmaping any subterms, return a lens into the "annotation" field.

When writing an instance, keep in mind that annotation' id should just be the typical definition for a lens into the annotation field.

It should also be true that for any f :: B -> C and g :: A -> B,

annotation' (f . g) == annotation' f . annotation' g

Since: 0.1.0

Instances

Annotated Expr

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (Expr ann) (Expr ann') ann ann'

Annotated Rule

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (Rule ann) (Rule ann') ann ann'

Annotated Deps

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (Deps ann) (Deps ann') ann ann'

Annotated Build

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (Build ann) (Build ann') ann ann'

Annotated Ninja

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (Ninja ann) (Ninja ann') ann ann'

Annotated LBuild

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (LBuild ann) (LBuild ann') ann ann'

Annotated LName

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (LName ann) (LName ann') ann ann'

Annotated Lexeme

The usual definition for Annotated.

Since: 0.1.0

Methods

annotation' :: (ann -> ann') -> Lens (Lexeme ann) (Lexeme ann') ann ann'

annotation :: Annotated ty => Lens' (ty ann) ann

This is just shorthand for annotation' id.

Since: 0.1.0

Language.Ninja.Misc.Located

data Located t

This datatype represents a value annotated with a source location.

Since: 0.1.0

Instances

Functor Located

Methods

fmap :: (a -> b) -> Located a -> Located b

(<$) :: a -> Located b -> Located a

Foldable Located

Methods

fold :: Monoid m => Located m -> m

foldMap :: Monoid m => (a -> m) -> Located a -> m

foldr :: (a -> b -> b) -> b -> Located a -> b

foldr' :: (a -> b -> b) -> b -> Located a -> b

foldl :: (b -> a -> b) -> b -> Located a -> b

foldl' :: (b -> a -> b) -> b -> Located a -> b

foldr1 :: (a -> a -> a) -> Located a -> a

foldl1 :: (a -> a -> a) -> Located a -> a

toList :: Located a -> [a]

null :: Located a -> Bool

length :: Located a -> Int

elem :: Eq a => a -> Located a -> Bool

maximum :: Ord a => Located a -> a

minimum :: Ord a => Located a -> a

sum :: Num a => Located a -> a

product :: Num a => Located a -> a

Traversable Located

Methods

traverse :: Applicative f => (a -> f b) -> Located a -> f (Located b)

sequenceA :: Applicative f => Located (f a) -> f (Located a)

mapM :: Monad m => (a -> m b) -> Located a -> m (Located b)

sequence :: Monad m => Located (m a) -> m (Located a)

(Monad m, Serial m Text, Serial m t) => Serial m (Located t)

Default Serial instance via Generic.

Since: 0.1.0

Methods

series :: Series m (Located t)

(Monad m, CoSerial m Text, CoSerial m t) => CoSerial m (Located t)

Default CoSerial instance via Generic.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (Located t -> b)

Eq t => Eq (Located t)

Methods

(==) :: Located t -> Located t -> Bool

(/=) :: Located t -> Located t -> Bool

Show t => Show (Located t)

Methods

showsPrec :: Int -> Located t -> ShowS

show :: Located t -> String

showList :: [Located t] -> ShowS

Generic (Located t)

Associated Types

type Rep (Located t) :: * -> *

Methods

from :: Located t -> Rep (Located t) x

to :: Rep (Located t) x -> Located t

Hashable t => Hashable (Located t)

Default Hashable instance via Generic.

Since: 0.1.0

Methods

hashWithSalt :: Int -> Located t -> Int

hash :: Located t -> Int

ToJSON t => ToJSON (Located t)

Converts to {position: …, value: …}.

Since: 0.1.0

Methods

toJSON :: Located t -> Value

toEncoding :: Located t -> Encoding

toJSONList :: [Located t] -> Value

toEncodingList :: [Located t] -> Encoding

FromJSON t => FromJSON (Located t)

Inverse of the ToJSON instance.

Since: 0.1.0

Methods

parseJSON :: Value -> Parser (Located t)

parseJSONList :: Value -> Parser [Located t]

NFData t => NFData (Located t)

Default NFData instance via Generic.

Since: 0.1.0

Methods

rnf :: Located t -> ()

type Rep (Located t)

type Rep (Located t) = D1 (MetaData "Located" "Language.Ninja.Misc.Located" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" False) (C1 (MetaCons "MkLocated" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_locatedPos") SourceUnpack SourceStrict DecidedUnpack) (Rec0 Position)) (S1 (MetaSel (Just Symbol "_locatedVal") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 t))))

tokenize :: Maybe Path -> Text -> [Located Text]

Given path :: Maybe Path and a text :: Text, do the following:

• Remove all '\r' characters from the text.
• Split the text into chunks that are guaranteed not to contain newlines or whitespace, and which are annotated with their location.

Since: 0.1.0

tokenizeFile :: MonadReadFile m => Path -> m [Located Text]

Read the file at the given Path and then run tokenize on the resulting Text.

Since: 0.1.0

tokenizeText :: Text -> [Located Text]

This function is equivalent to tokenize Nothing.

Since: 0.1.0

locatedPos :: Lens' (Located t) Position

The position of this located value.

Since: 0.1.0

locatedVal :: Lens' (Located t) t

The value underlying this located value.

Since: 0.1.0

data Spans

A type representing a set of source spans.

Since: 0.1.0

Instances

Eq Spans

Methods

(==) :: Spans -> Spans -> Bool

(/=) :: Spans -> Spans -> Bool

Show Spans

Methods

showsPrec :: Int -> Spans -> ShowS

show :: Spans -> String

showList :: [Spans] -> ShowS

Generic Spans

Associated Types

type Rep Spans :: * -> *

Methods

from :: Spans -> Rep Spans x

to :: Rep Spans x -> Spans

Semigroup Spans

Methods

(<>) :: Spans -> Spans -> Spans

sconcat :: NonEmpty Spans -> Spans

stimes :: Integral b => b -> Spans -> Spans

Monoid Spans

Methods

mempty :: Spans

mappend :: Spans -> Spans -> Spans

mconcat :: [Spans] -> Spans

Hashable Spans

Methods

hashWithSalt :: Int -> Spans -> Int

hash :: Spans -> Int

ToJSON Spans

Methods

toJSON :: Spans -> Value

toEncoding :: Spans -> Encoding

toJSONList :: [Spans] -> Value

toEncodingList :: [Spans] -> Encoding

FromJSON Spans

Methods

parseJSON :: Value -> Parser Spans

parseJSONList :: Value -> Parser [Spans]

NFData Spans

Methods

rnf :: Spans -> ()

(Monad m, Serial m (HashSet Span)) => Serial m Spans

Default Serial instance via Generic.

Since: 0.1.0

Methods

series :: Series m Spans

(Monad m, CoSerial m (HashSet Span)) => CoSerial m Spans

Default CoSerial instance via Generic.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (Spans -> b)

type Rep Spans

type Rep Spans = D1 (MetaData "Spans" "Language.Ninja.Misc.Located" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" True) (C1 (MetaCons "MkSpans" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (HashSet Span))))

makeSpans :: [Span] -> Spans

Construct a Spans from a list of Spans.

Since: 0.1.0

spansSet :: Iso' Spans (HashSet Span)

A lens into the HashSet Span underlying a value of type Spans.

Since: 0.1.0

data Span

Represents a span of source code.

Since: 0.1.0

Instances

Eq Span

Methods

(==) :: Span -> Span -> Bool

(/=) :: Span -> Span -> Bool

Show Span

Methods

showsPrec :: Int -> Span -> ShowS

show :: Span -> String

showList :: [Span] -> ShowS

Generic Span

Associated Types

type Rep Span :: * -> *

Methods

from :: Span -> Rep Span x

to :: Rep Span x -> Span

Hashable Span

Default Hashable instance via Generic.

Since: 0.1.0

Methods

hashWithSalt :: Int -> Span -> Int

hash :: Span -> Int

ToJSON Span

Converts to {file: …, start: …, end: …}.

Since: 0.1.0

Methods

toJSON :: Span -> Value

toEncoding :: Span -> Encoding

toJSONList :: [Span] -> Value

toEncodingList :: [Span] -> Encoding

FromJSON Span

Inverse of the ToJSON instance.

Since: 0.1.0

Methods

parseJSON :: Value -> Parser Span

parseJSONList :: Value -> Parser [Span]

NFData Span

Default NFData instance via Generic.

Since: 0.1.0

Methods

rnf :: Span -> ()

(Monad m, Serial m Text) => Serial m Span

Default Serial instance via Generic.

Since: 0.1.0

Methods

series :: Series m Span

(Monad m, CoSerial m Text) => CoSerial m Span

Default CoSerial instance via Generic.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (Span -> b)

type Rep Span

type Rep Span = D1 (MetaData "Span" "Language.Ninja.Misc.Located" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" False) (C1 (MetaCons "MkSpan" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Path))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Offset)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Offset)))))

makeSpan

Arguments

:: Maybe Path

The file in which this span resides, if any.

-> Offset

The start offset.

-> Offset

The end offset.

-> Span

Construct a Span from a given start position to a given end position.

Since: 0.1.0

spanPath :: Lens' Span (Maybe Path)

A lens into the (nullable) path associated with a Span.

Since: 0.1.0

spanRange :: Lens' Span (Offset, Offset)

A lens giving the start and end Offsets associated with a Span.

Since: 0.1.0

spanStart :: Lens' Span Offset

A lens into the Offset associated with the start of a Span.

Since: 0.1.0

spanEnd :: Lens' Span Offset

A lens into the Offset associated with the end of a Span.

Since: 0.1.0

data Position

This datatype represents the position of a cursor in a text file.

Since: 0.1.0

Instances

Eq Position

Methods

(==) :: Position -> Position -> Bool

(/=) :: Position -> Position -> Bool

Show Position

Methods

showsPrec :: Int -> Position -> ShowS

show :: Position -> String

showList :: [Position] -> ShowS

Generic Position

Associated Types

type Rep Position :: * -> *

Methods

from :: Position -> Rep Position x

to :: Rep Position x -> Position

Hashable Position

Default Hashable instance via Generic.

Since: 0.1.0

Methods

hashWithSalt :: Int -> Position -> Int

hash :: Position -> Int

ToJSON Position

Converts to {file: …, line: …, col: …}.

Since: 0.1.0

Methods

toJSON :: Position -> Value

toEncoding :: Position -> Encoding

toJSONList :: [Position] -> Value

toEncodingList :: [Position] -> Encoding

FromJSON Position

Inverse of the ToJSON instance.

Since: 0.1.0

Methods

parseJSON :: Value -> Parser Position

parseJSONList :: Value -> Parser [Position]

NFData Position

Default NFData instance via Generic.

Since: 0.1.0

Methods

rnf :: Position -> ()

(Monad m, Serial m Text) => Serial m Position

Default Serial instance via Generic.

Since: 0.1.0

Methods

series :: Series m Position

(Monad m, CoSerial m Text) => CoSerial m Position

Default CoSerial instance via Generic.

Since: 0.1.0

Methods

coseries :: Series m b -> Series m (Position -> b)

type Rep Position

type Rep Position = D1 (MetaData "Position" "Language.Ninja.Misc.Located" "language-ninja-0.2.0-4aVVODOvkNMFxGcRpnztag" False) (C1 (MetaCons "MkPosition" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_positionFile") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe Path))) ((:*:) (S1 (MetaSel (Just Symbol "_positionLine") SourceUnpack SourceStrict DecidedUnpack) (Rec0 Line)) (S1 (MetaSel (Just Symbol "_positionCol") SourceUnpack SourceStrict DecidedUnpack) (Rec0 Column)))))

makePosition :: Maybe Path -> Offset -> Position

Construct a Position from a (nullable) path and a (line, column) pair.

Since: 0.1.0

positionFile :: Lens' Position (Maybe Path)

The path of the file pointed to by this position, if any.

Since: 0.1.0

positionOffset :: Lens' Position Offset

The offset in the file pointed to by this position.

Since: 0.1.0

positionLine :: Lens' Position Line

The line number in the file pointed to by this position.

Since: 0.1.0

positionCol :: Lens' Position Column

The column number in the line pointed to by this position.

Since: 0.1.0

comparePosition :: Position -> Position -> Maybe Ordering

If two Positions are comparable (i.e.: if they are in the same file), this function will return an Ordering giving their relative positions. Otherwise, it will of course return Nothing.

Since: 0.1.0

type Offset = (Line, Column)

A line/column offset into a file.

Since: 0.1.0

compareOffset :: Offset -> Offset -> Ordering

Compare two Offsets in lexicographic order (i.e.: the Column is ignored unless they are on the same Line).

Since: 0.1.0

offsetLine :: Lens' Offset Line

A lens into the Line associated with an Offset.

For now, this is simply defined as offsetLine = _1, but if Offset is later refactored to be an abstract data type, using this lens instead of _1 will decrease the amount of code that breaks.

Since: 0.1.0

offsetColumn :: Lens' Offset Column

A lens into the Line associated with an Offset.

Read the description of offsetLine for an understanding of why this exists and why you should use it instead of _2.

Since: 0.1.0

type Line = Int

A line number.

Since: 0.1.0

type Column = Int

A column number.

Since: 0.1.0