Nix.Match

A set of functions for matching on Nix expression trees and extracting the values of sub-trees.

Documentation

match :: Matchable t => WithHoles t v -> Fix t -> Maybe [(v, Fix t)]

Match a tree with holes against a tree without holes, returning the values of the holes if it matches.

NExprF and NExprLocF are both instances of Matchable. NExprLocF does not require the annotations to match. Please see the Matchable instance documentation for NExprF for more details.

>>> import Nix.TH
>>> match (addHoles [nix|{foo = x: ^foo; bar = ^bar;}|]) [nix|{foo = x: "hello"; bar = "world"; baz = "!";}|]
Just [("bar",Fix (NStr (DoubleQuoted [Plain "world"]))),("foo",Fix (NStr (DoubleQuoted [Plain "hello"])))]

findMatches

Arguments

:: Matchable t

=> WithHoles t v

Needle

-> Fix t

Haystack

-> [(Fix t, [(v, Fix t)])]

Find all the needles in a haystack, returning the matched expression as well as their filled holes. Results are returned productively in preorder.

>>> import Nix.TH
>>> import Control.Arrow
>>> pretty = prettyNix *** (fmap @[] (fmap @((,) Text) prettyNix))
>>> pretty <$> findMatches (addHoles [nix|{x=^x;}|]) [nix|{x=1;a={x=2;};}|]
[({ x = 1; a = { x = 2; }; },[("x",1)]),({ x = 2; },[("x",2)])]

class Traversable t => Matchable t where

Instances for this class can be derived for any type with a Generic1 instance.

Minimal complete definition

Nothing

Methods

zipMatchLeft :: t a -> t b -> Maybe (t (a, b))

Match one level of structure, returning the matched structure with sub structures to match. Needle is the first argument, matchee is the second.

Unlike the Unifiable class in the "unification-fd" package, this doesn't have to be a commutative operation, the needle will always be the first parameter and instances are free to treat if differently if appropriate.

default zipMatchLeft :: (Generic1 t, GMatchable (Rep1 t)) => t a -> t b -> Maybe (t (a, b))

Instances

Matchable []

Defined in Nix.Match

Methods

zipMatchLeft :: [a] -> [b] -> Maybe [(a, b)]

Matchable Maybe

Defined in Nix.Match

Methods

zipMatchLeft :: Maybe a -> Maybe b -> Maybe (Maybe (a, b))

Matchable NonEmpty

Defined in Nix.Match

Methods

zipMatchLeft :: NonEmpty a -> NonEmpty b -> Maybe (NonEmpty (a, b))

Matchable NExprF

There are a few special cases when matching expressions to make writing matchers nicer:

• For attrsets and let bindings, the matching is done on the needle's keys only. i.e. the matchee may have extra keys which are ignored.
• For attrsets and let bindings, bindings which have a LHS beginning with _ are treated as optional. If they are not present then any holes on their RHS will not be filled.
• Attrsets match ignoring recursiveness
• If a function in the needle has _ as its parameter, it matches everything, so _ acts as a wildcard pattern.

Defined in Nix.Match

Methods

zipMatchLeft :: NExprF a -> NExprF b -> Maybe (NExprF (a, b))

Matchable Binding

The matched pair uses the source location of the first argument

Defined in Nix.Match

Methods

zipMatchLeft :: Binding a -> Binding b -> Maybe (Binding (a, b))

Matchable Params

Defined in Nix.Match

Methods

zipMatchLeft :: Params a -> Params b -> Maybe (Params (a, b))

Matchable NString

Defined in Nix.Match

Methods

zipMatchLeft :: NString a -> NString b -> Maybe (NString (a, b))

Matchable NKeyName

No Generic1 instance

Defined in Nix.Match

Methods

zipMatchLeft :: NKeyName a -> NKeyName b -> Maybe (NKeyName (a, b))

Eq a => Matchable ((,) a)

Defined in Nix.Match

Methods

zipMatchLeft :: (a, a0) -> (a, b) -> Maybe (a, (a0, b))

Matchable (Ann ann)

Doesn't require the annotations to match, returns the second annotation.

Defined in Nix.Match

Methods

zipMatchLeft :: Ann ann a -> Ann ann b -> Maybe (Ann ann (a, b))

Matchable (Antiquoted Text)

Defined in Nix.Match

Methods

zipMatchLeft :: Antiquoted Text a -> Antiquoted Text b -> Maybe (Antiquoted Text (a, b))

(Matchable f, Matchable g) => Matchable (Compose f g)

Defined in Nix.Match

Methods

zipMatchLeft :: Compose f g a -> Compose f g b -> Maybe (Compose f g (a, b))

class (Traversable t, Generic1 t) => GMatchable t where

A class used in the default definition for zipMatchLeft

Methods

gZipMatchLeft :: t a -> t b -> Maybe (t (a, b))

Instances

GMatchable Par1

Defined in Nix.Match

Methods

gZipMatchLeft :: Par1 a -> Par1 b -> Maybe (Par1 (a, b))

GMatchable (U1 :: Type -> Type)

Defined in Nix.Match

Methods

gZipMatchLeft :: U1 a -> U1 b -> Maybe (U1 (a, b))

Matchable x => GMatchable (Rec1 x)

Defined in Nix.Match

Methods

gZipMatchLeft :: Rec1 x a -> Rec1 x b -> Maybe (Rec1 x (a, b))

Eq c => GMatchable (K1 m c :: Type -> Type)

Defined in Nix.Match

Methods

gZipMatchLeft :: K1 m c a -> K1 m c b -> Maybe (K1 m c (a, b))

(GMatchable l, GMatchable r) => GMatchable (l :+: r)

Defined in Nix.Match

Methods

gZipMatchLeft :: (l :+: r) a -> (l :+: r) b -> Maybe ((l :+: r) (a, b))

(GMatchable l, GMatchable r) => GMatchable (l :*: r)

Defined in Nix.Match

Methods

gZipMatchLeft :: (l :*: r) a -> (l :*: r) b -> Maybe ((l :*: r) (a, b))

GMatchable t => GMatchable (M1 m i t)

Defined in Nix.Match

Methods

gZipMatchLeft :: M1 m i t a -> M1 m i t b -> Maybe (M1 m i t (a, b))

(Matchable a, GMatchable b) => GMatchable (a :.: b)

Defined in Nix.Match

Methods

gZipMatchLeft :: (a :.: b) a0 -> (a :.: b) b0 -> Maybe ((a :.: b) (a0, b0))

data WithHoles t v

Like Fix but each layer could instead be a Hole

Constructors

Hole !v

Term !(t (WithHoles t v))

Instances

(Typeable t, Data (t (WithHoles t v)), Data v) => Data (WithHoles t v)

Defined in Nix.Match

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WithHoles t v -> c (WithHoles t v)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WithHoles t v)

toConstr :: WithHoles t v -> Constr

dataTypeOf :: WithHoles t v -> DataType

dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (WithHoles t v))

dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (WithHoles t v))

gmapT :: (forall b. Data b => b -> b) -> WithHoles t v -> WithHoles t v

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WithHoles t v -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WithHoles t v -> r

gmapQ :: (forall d. Data d => d -> u) -> WithHoles t v -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WithHoles t v -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WithHoles t v -> m (WithHoles t v)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WithHoles t v -> m (WithHoles t v)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WithHoles t v -> m (WithHoles t v)

addHoles :: NExpr -> WithHoles NExprF Text

Make syntactic holes into Holes

addHolesLoc :: NExprLoc -> WithHoles NExprLocF Text

Make syntactic holes into Holes

isOptionalPath :: NAttrPath r -> Maybe (NAttrPath r)

Basically: does the path begin with an underscore, if so return it removed without the underscore.