yaml-light-0.1.4: A light-weight wrapper with utility functions around HsSyck

Portability | portable
Stability | provisional
Maintainer | michael <dot> ilseman <at> gmail <dot> com
Safe Haskell | None

Data.Yaml.YamlLight

Contents

- YamlLight data type
- YamlLight versions of Syck functions
- YamlLight utility functions
  - Extractors

Description

A light-weight wrapper with utility functions around HsSyck

Synopsis

- data YamlLight
  - = YMap (Map YamlLight YamlLight)
  - | YSeq [YamlLight]
  - | YStr ByteString
  - | YNil
- parseYaml :: String -> IO YamlLight
- parseYamlFile :: String -> IO YamlLight
- parseYamlBytes :: ByteString -> IO YamlLight
- fromYamlNode :: YamlNode -> YamlLight
- lookupYL :: YamlLight -> YamlLight -> Maybe YamlLight
- lookupYLWith :: (YamlLight -> Bool) -> YamlLight -> Maybe YamlLight
- combineSequencedMaps :: YamlLight -> Maybe [(YamlLight, YamlLight)]
- combineMappedSequences :: YamlLight -> Maybe [(YamlLight, YamlLight)]
- getTerminalsKeys :: YamlLight -> [(ByteString, [YamlLight])]
- unSeq :: YamlLight -> Maybe [YamlLight]
- unMap :: YamlLight -> Maybe (Map YamlLight YamlLight)
- unStr :: YamlLight -> Maybe ByteString

# YamlLight data type

data YamlLight Source

A light-weight, single ADT representation of a yaml document in contrast with what is provided by HsSyck. Note that the YMap is an actual Map from Data.Map, so behavior with respect to identical keys and ordering of entries will behave as Data.Map dictates. This behavior is also in compliance with the Yaml spec. If you currently rely on HsSyck's preservation of ordering, you can also consider representing such maps as sequences of single entry maps. See the examples of "Ordered Mappings" in the Yaml spec: http://www.yaml.org/spec/1.2/spec.html.

Constructors

YMap (Map YamlLight YamlLight) |
YSeq [YamlLight] |
YStr ByteString |
YNil |

Instances

Eq YamlLight |
Ord YamlLight |
Show YamlLight |

# YamlLight versions of Syck functions

parseYaml :: String -> IO YamlLight Source

Parse a regular Haskell string

parseYamlFile :: String -> IO YamlLight Source

Given a file name, parse contents of file

parseYamlBytes :: ByteString -> IO YamlLight Source

Parse a ByteString buffer (this is faster)

# YamlLight utility functions

fromYamlNode :: YamlNode -> YamlLight Source

Convert a Syck YamlNode to a YamlLight

lookupYL :: YamlLight -> YamlLight -> Maybe YamlLight Source

Lookup the key's corresponding value in a Map. Returns Nothing if the YamlLight is not a map, or if the key is not found

lookupYLWith :: (YamlLight -> Bool) -> YamlLight -> Maybe YamlLight Source

General form of lookup. Will return the first element that satisfies predicate p, otherwise Nothing

combineSequencedMaps :: YamlLight -> Maybe [(YamlLight, YamlLight)]Source

Combine a sequence of YMaps into a list of (key,value) pairs. The ordering of the result preserves the ordering of the sequence, but the ordering of the individual maps is as Data.Map handles it.

Example:

         - key1: val1
           key2: val2
         - key3: val3

Would become:

         [(key1,val1),(key2,val2),(key3,val3)]

where key1 and key2 might be arranged differently as Data.Map would arrange them. This does not enforce uniqueness of keys across different maps. Any items of the sequence that are not maps will not be present in the output list. Returns Nothing if not called on a Sequence

combineMappedSequences :: YamlLight -> Maybe [(YamlLight, YamlLight)]Source

Take a YamlLight that is a YMap of keys to YSeqs, and return a list of (key,elem) pairs, where elem is an element of the YSeq under key.

Example:

         key1: [val1, val2, val3]
         key2: [val4, val5]

Would become:

         [(key1,val1),(key1,val2),(key1,val3),(key2,val4),(key2,val5)]

where the precise ordering of the key1 and key2 pairs depends on the ordering of Data.Map. Any values of keys that are not sequences will not appear in the output list. Returns Nothing if not called on a YMap.

getTerminalsKeys :: YamlLight -> [(ByteString, [YamlLight])]Source

Create a list of all the terminal YStrs in a YamlLight tree, and couple them with a list of all the keys above them.

Example:

            - key1:
                key1_1:
                  - "str1"
                  - "str2"
                key1_2:
                  - "str2"
                  - "str3"
            - key2:
                "str4"
            - "str5"

Would become:

            [("str1",[key1_1, key1]), ("str2", [key1_1, key1]), ("str2", [key1_2, key1]), ("str3",[key1_2, key1]), ("str4",[key2]), ("str5",[])

## Extractors

unSeq :: YamlLight -> Maybe [YamlLight]Source

Get the contents of a sequence

unMap :: YamlLight -> Maybe (Map YamlLight YamlLight)Source

Get the contents of a map

unStr :: YamlLight -> Maybe ByteString Source

Get the contents of a string