Extract the value out of an annotated value.

Attempts to cast to the given type.

Matches on a (possibly nested) or, and focuses the value if its field annotation is a match.

Note that field annotations do not have to be unique. If two or branches have the same field annotation, variant will match on either branch.

>>> :{
or = Right (Left 3) :: Either Integer (Either Natural Integer)
notes =
  NTOr noAnn [fieldAnnQ|first|] noAnn
    starNotes
    (NTOr noAnn [fieldAnnQ|second|] [fieldAnnQ|third|] starNotes starNotes)
val = SomeAnnotatedValue notes (toVal or)
:}

>>> val ^? variant [fieldAnnQ|second|] . to pretty
Just "3 :: nat"

>>> val ^? variant [fieldAnnQ|first|] . to pretty
Nothing

Traverses all nodes in a tree of pairs that have a field annotation. The elements are indexed by their field annotations.

Note that sub-trees are not inspected. For example, for this type:

pair
  (int %storageField1)
  (pair %storageField2
    (int %nestedField1)
    (string %nestedField2)
  )

fields will:

• ignore the top-level node, because it does not have a field annotation.
• traverse the storageField1 and storageField2 fields.
• ignore nestedField1 and nestedField2, because they're in a sub-tree of a traversed node.

Note that field annotations do not have to be unique. If two fields have the same field annotation, both will be indexed/traversed.

>>> :{
pair = (1, 2, 3) :: (Integer, Natural, Integer)
notes =
  NTPair noAnn [fieldAnnQ|first|] noAnn noAnn noAnn
    starNotes
    (NTPair noAnn [fieldAnnQ|second|] [fieldAnnQ|third|] noAnn noAnn starNotes starNotes)
val = SomeAnnotatedValue notes (toVal pair)
:}

>>> mapM_ print $ val ^@.. fields . to pretty
(%first,"1 :: int")
(%second,"2 :: nat")
(%third,"3 :: int")

Looks up a member of a tree of pairs by its field annotation. Note that sub-trees of nodes with field annotations are not inspected.

Note that field annotations do not have to be unique. If two fields have the same field annotation, both will be indexed/traversed.

>>> :{
pair = (1, 2, 3) :: (Integer, Natural, Integer)
notes =
  NTPair noAnn [fieldAnnQ|first|] noAnn noAnn noAnn
    starNotes
    (NTPair noAnn [fieldAnnQ|second|] [fieldAnnQ|third|] noAnn noAnn starNotes starNotes)
val = SomeAnnotatedValue notes (toVal pair)
:}

>>> val ^? field [fieldAnnQ|second|] . castTo @Natural . value
Just 2

Lists all nodes in a tree of pairs. The elements are indexed by their field annotations.

Note that field annotations do not have to be unique. If two fields have the same field annotation, both will be indexed.

>>> :{
pair = (1, 2, 3) :: (Integer, Natural, Integer)
notes =
  NTPair noAnn [fieldAnnQ|first|] noAnn noAnn noAnn
    starNotes
    (NTPair noAnn [fieldAnnQ|second|] [fieldAnnQ|third|] noAnn noAnn starNotes starNotes)
val = SomeAnnotatedValue notes (toVal pair)
:}

>>> mapM_ print $ val ^@.. nodes . to pretty
(%first,"1 :: int")
(%,"Pair 2 3 :: pair (nat %second) (int %third)")
(%second,"2 :: nat")
(%third,"3 :: int")

Looks up nodes in a tree of pairs with the given field annotation.

Casts a SomeAnnotatedValue to a list.

>>> list = [ [mt|hello|], [mt|world|] ]
>>> val = SomeAnnotatedValue starNotes (toVal list)
>>> val ^? asList . ix 1 . castTo @MText . value . to pretty
Just "world"

Casts a SomeAnnotatedValue to a map.

>>> map = Map.fromList @Integer @Bool [(10, False), (20, True)]
>>> val = SomeAnnotatedValue starNotes (toVal map)
>>> val ^? asMap @Integer . ix 20 . castTo @Bool . value
Just True