data-object-yaml-0.3.3.5/0000755000000000000000000000000011537355500013167 5ustar0000000000000000data-object-yaml-0.3.3.5/Setup.lhs0000644000000000000000000000046711537355500015006 0ustar0000000000000000#!/usr/bin/env runhaskell > module Main where > import Distribution.Simple > import System.Cmd (system) > main :: IO () > main = defaultMainWithHooks (simpleUserHooks { runTests = runTests' }) > runTests' :: a -> b -> c -> d -> IO () > runTests' _ _ _ _ = system "runhaskell -DTEST runtests.hs" >> return () data-object-yaml-0.3.3.5/runtests.hs0000644000000000000000000001556211537355500015423 0ustar0000000000000000{-# LANGUAGE NamedFieldPuns #-} import Test.Framework (Test, defaultMain, testGroup) import Test.Framework.Providers.HUnit import Test.HUnit hiding (Test) import Data.Maybe import qualified Data.ByteString.Char8 as B8 import Data.Convertible.Text (cs) import qualified Text.Libyaml as LY import Data.Object import Data.Object.Yaml import Control.Monad mkFoldedScalar :: String -> YamlScalar mkFoldedScalar s = YamlScalar (cs s) LY.StrTag LY.Folded mkScalar :: String -> YamlScalar mkScalar s = YamlScalar (cs s) LY.NoTag LY.Plain mkStrScalar :: String -> YamlScalar mkStrScalar s = YamlScalar (cs s) LY.StrTag LY.Plain mappingKey :: YamlObject -> String -> YamlObject mappingKey (Mapping m) k = (fromJust . lookup (mkScalar k) $ m) mappingKey _ _ = error "expected Mapping" decodeYaml :: String -> Maybe YamlObject decodeYaml s = decode $ B8.pack s sample :: YamlObject sample = Sequence [ Scalar $ mkFoldedScalar "foo" , Mapping [ (mkFoldedScalar "bar1", Scalar $ mkFoldedScalar "bar2") ] ] sampleStr :: Object String String sampleStr = mapKeysValues fromYamlScalar fromYamlScalar sample main :: IO () main = defaultMain [ testSuite , testSuiteOfAliases , testSuiteOfMergeKeys ] testSuite :: Test testSuite = testGroup "Data.Object.Yaml" [ testCase "encode/decode" caseEncodeDecode , testCase "encode/decode file" caseEncodeDecodeFile , testCase "encode/decode strings" caseEncodeDecodeStrings , testCase "decode invalid file" caseDecodeInvalid , testCase "encode/decode in order" caseInOrder ] caseEncodeDecode :: Assertion caseEncodeDecode = do out <- decode $ encode sample out @?= sample caseEncodeDecodeFile :: Assertion caseEncodeDecodeFile = do let fp = "tmp.yaml" encodeFile fp sample out <- join $ decodeFile fp out @?= sample caseEncodeDecodeStrings :: Assertion caseEncodeDecodeStrings = do out <- decode $ encode $ toYamlObject sampleStr fromYamlObject out @?= sampleStr caseDecodeInvalid :: Assertion caseDecodeInvalid = do let invalid = B8.pack "\tthis is 'not' valid :-)" Nothing @=? (decode invalid :: Maybe YamlObject) testSuiteOfAliases :: Test testSuiteOfAliases = testGroup "Tests of aliases" [ testCase "simple scalar alias" caseSimpleScalarAlias , testCase "simple sequence alias" caseSimpleSequenceAlias , testCase "simple mapping alias" caseSimpleMappingAlias , testCase "mapping alias before anchor" caseMappingAliasBeforeAnchor , testCase "mapping alias inside anchor" caseMappingAliasInsideAnchor , testCase "scalar alias overriding" caseScalarAliasOverriding ] caseSimpleScalarAlias :: Assertion caseSimpleScalarAlias = do let maybeRes = decodeYaml "- &anch foo\n- baz\n- *anch" isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing" let res = fromJust maybeRes res @?= Sequence [Scalar (mkScalar "foo"), Scalar (mkScalar "baz"), Scalar (mkScalar "foo")] caseSimpleSequenceAlias :: Assertion caseSimpleSequenceAlias = do let maybeRes = decodeYaml "seq: &anch\n - foo\n - baz\nseq2: *anch" isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing" let res = fromJust maybeRes res @?= Mapping [(mkScalar "seq", Sequence [Scalar (mkScalar "foo"), Scalar (mkScalar "baz")]), (mkScalar "seq2", Sequence [Scalar (mkScalar "foo"), Scalar (mkScalar "baz")])] caseSimpleMappingAlias :: Assertion caseSimpleMappingAlias = do let maybeRes = decodeYaml "map: &anch\n key1: foo\n key2: baz\nmap2: *anch" isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing" let res = fromJust maybeRes res @?= Mapping [(mkScalar "map", Mapping [(mkScalar "key1", Scalar (mkScalar "foo")), (mkScalar "key2", Scalar (mkScalar "baz"))]), (mkScalar "map2", Mapping [(mkScalar "key1", Scalar (mkScalar "foo")), (mkScalar "key2", Scalar (mkScalar "baz"))])] caseMappingAliasBeforeAnchor :: Assertion caseMappingAliasBeforeAnchor = do let res = decodeYaml "map: *anch\nmap2: &anch\n key1: foo\n key2: baz" isNothing res @? "decode should return Nothing due to unknown alias" caseMappingAliasInsideAnchor :: Assertion caseMappingAliasInsideAnchor = do let res = decodeYaml "map: &anch\n key1: foo\n key2: *anch" isNothing res @? "decode should return Nothing due to unknown alias" caseScalarAliasOverriding :: Assertion caseScalarAliasOverriding = do let maybeRes = decodeYaml "- &anch foo\n- baz\n- *anch\n- &anch boo\n- buz\n- *anch" isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing" let res = fromJust maybeRes res @?= Sequence [Scalar (mkScalar "foo"), Scalar (mkScalar "baz"), Scalar (mkScalar "foo"), Scalar (mkScalar "boo"), Scalar (mkScalar "buz"), Scalar (mkScalar "boo")] testSuiteOfMergeKeys :: Test testSuiteOfMergeKeys = testGroup "Tests of 'merge keys' feature" [ testCase "test uniqueness of keys" caseAllKeysShouldBeUnique , testCase "test mapping merge" caseSimpleMappingMerge , testCase "test sequence of mappings merging" caseMergeSequence ] caseAllKeysShouldBeUnique :: Assertion caseAllKeysShouldBeUnique = do let maybeRes = decodeYaml "foo1: foo\nfoo2: baz\nfoo1: buz" isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing" let res = fromJust maybeRes mappingKey res "foo1" @?= Scalar (mkScalar "buz") caseSimpleMappingMerge :: Assertion caseSimpleMappingMerge = do let maybeRes = decodeYaml "foo1: foo\nfoo2: baz\n<<:\n foo1: buz\n foo3: fuz" isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing" let res = fromJust maybeRes mappingKey res "foo1" @?= Scalar (mkScalar "foo") mappingKey res "foo3" @?= Scalar (mkScalar "fuz") caseMergeSequence :: Assertion caseMergeSequence = do let maybeRes = decodeYaml "m1: &m1\n k1: !!str 1\n k2: !!str 2\nm2: &m2\n k1: !!str 3\n k3: !!str 4\nfoo1: foo\n<<: [ *m1, *m2 ]" isJust maybeRes @? "decoder should return Just YamlObject but returned Nothing" let res = fromJust maybeRes mappingKey res "foo1" @?= Scalar (mkScalar "foo") mappingKey res "k1" @?= Scalar (mkStrScalar "1") mappingKey res "k2" @?= Scalar (mkStrScalar "2") mappingKey res "k3" @?= Scalar (mkStrScalar "4") inOrderData :: String inOrderData = "'Fatal': 'Unknown variable \"bar\"'\n'Date': '2001-11-23 15:03:17 -5'\n'User': 'ed'\n'Stack':\n- 'line': '23'\n 'file': 'TopClass.py'\n 'code': 'x = MoreObject(\"345\\n\")\n\n'\n- 'line': '58'\n 'file': 'MoreClass.py'\n 'code': 'foo = bar'\n" inOrderData2 :: String inOrderData2 = "'a': '1'\n'b': '2'\n'd': '4'\n'c': '3'\n" ++ "'g': '1'\n'n': '2'\n'q': '4'\n'f': '3'\n" ++ "'z': '1'\n'y': '2'\n'x': '4'\n'w': '3'\n" caseInOrder :: Assertion caseInOrder = do Just (Mapping ((x, _):_)) <- return $ decodeYaml inOrderData x @?= mkScalar "Fatal" fmap (B8.unpack . encode) (decodeYaml inOrderData2) @?= Just inOrderData2 data-object-yaml-0.3.3.5/data-object-yaml.cabal0000644000000000000000000000311611537355500017271 0ustar0000000000000000name: data-object-yaml version: 0.3.3.5 license: BSD3 license-file: LICENSE author: Michael Snoyman , Anton Ageev maintainer: Michael Snoyman synopsis: Serialize data to and from Yaml files description: Provides high level conversions based on the data-object package. Parsing and emitting is handled by the yaml package, which in turn uses the libyaml C library. category: Web stability: unstable cabal-version: >= 1.2 build-type: Simple homepage: http://github.com/snoyberg/data-object-yaml flag buildtests description: Build the executable to run unit tests default: False library build-depends: base >= 4 && < 5, data-object >= 0.3.0 && < 0.4, bytestring >= 0.9.1.4 && < 0.10, text >= 0.7 && < 0.12, failure >= 0.1.0 && < 0.2, transformers >= 0.2 && < 0.3, yaml >= 0.4.1 && < 0.5, containers >= 0.2.0.0 && < 0.5, enumerator >= 0.4 && < 0.5, convertible-text >= 0.3.0 && < 0.4 exposed-modules: Data.Object.Yaml ghc-options: -Wall executable runtests if flag(buildtests) Buildable: True cpp-options: -DTEST build-depends: test-framework, test-framework-hunit, HUnit else Buildable: False ghc-options: -Wall main-is: runtests.hs data-object-yaml-0.3.3.5/LICENSE0000644000000000000000000000253011537355500014174 0ustar0000000000000000The following license covers this documentation, and the source code, except where otherwise indicated. Copyright 2008, Michael Snoyman. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. data-object-yaml-0.3.3.5/Data/0000755000000000000000000000000011537355500014040 5ustar0000000000000000data-object-yaml-0.3.3.5/Data/Object/0000755000000000000000000000000011537355500015246 5ustar0000000000000000data-object-yaml-0.3.3.5/Data/Object/Yaml.hs0000644000000000000000000003173611537355500016516 0ustar0000000000000000{-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE PackageImports #-} {-| As a bit of background, this package is built on a few other packages I wrote. yaml is a low-level wrapper around the C libyaml library, with an enumerator interface. data-object is a package defining a data type: @ data Object k v = Scalar v | Sequence [Object k v] | Mapping [(k, Object k v)] @ In other words, it can represent JSON data fully, and YAML data almost fully. In particular, it doesn't handle cyclical aliases, which I hope doesn't really occur too much in real life. Another package to deal with is failure: it basically replaces using an Either for error-handling into a typeclass. It has instances for Maybe, IO and lists by default. The last package is convertible-text, which is a fork of John Goerzen's convertible package. The difference is it supports both conversions that are guaranteed to succeed (Int -> String) and ones which may fail (String -> Int), and also supports various textual datatypes (String, lazy\/strict ByteString, lazy\/string Text). /YamlScalar and YamlObject/ We have a @type YamlObject = Object YamlScalar YamlScalar@, where a YamlScalar is just a ByteString value with a tag and a style. A \"style\" is how the data was represented in the underlying YAML file: single quoted, double quoted, etc. Then there is an IsYamlScalar typeclass, which provides fromYamlScalar and toYamlScalar conversion functions. There are instances for all the \"text-like\" datatypes: String, ByteString and Text. The built-in instances all assume a UTF-8 data encoding. And around this we have toYamlObject and fromYamlObject functions, which do exactly what they sound like. /Encoding and decoding/ There are two encoding files: encode and encodeFile. You can guess the different: the former produces a ByteString (strict) and the latter writes to a file. They both take an Object, whose keys and values must be an instance of IsYamlScalar. So, for example: @ encodeFile "myfile.yaml" $ Mapping [ ("Michael", Mapping [ ("age", Scalar "26") , ("color", Scalar "blue") ]) , ("Eliezer", Mapping [ ("age", Scalar "2") , ("color", Scalar "green") ]) ] @ decoding is only slightly more complicated, since the decoding can fail. In particular, the return type is an IO wrapped around a Failure. For example, you could use: @ maybeObject <- decodeFile "myfile.yaml" case maybeObject of Nothing -> putStrLn "Error parsing YAML file." Just object -> putStrLn "Successfully parsed." @ If you just want to throw any parse errors as IO exception, you can use join: @ import Control.Monad (join) object <- join $ decodeFile "myfile.yaml" @ This takes advantage of the IO instance of Failure. /Parsing an Object/ In order to pull the data out of an Object, you can use the helper functions from Data.Object. For example: @ import Data.Object import Data.Object.Yaml import Control.Monad main = do object <- join $ decodeFile "myfile.yaml" people <- fromMapping object michael <- lookupMapping "Michael" people age <- lookupScalar "age" michael putStrLn $ "Michael is " ++ age ++ " years old." @ lookupScalar and friends implement Maybe, so you can test for optional attributes by switching on Nothing/Just a: @ name <- lookupScalar "middleName" michael :: Maybe String @ /And that's it/ There's really not more to know about this library. Enjoy! -} module Data.Object.Yaml ( -- * Definition of 'YamlObject' YamlScalar (..) , YamlObject -- * Automatic scalar conversions , IsYamlScalar (..) , toYamlObject , fromYamlObject -- * Encoding/decoding , encode , encodeFile , decode , decodeFile -- * Exceptions , ParseException (..) ) where import qualified Text.Libyaml as Y import Text.Libyaml hiding (encode, decode, encodeFile, decodeFile) import Data.Object import Data.ByteString (ByteString) import qualified Data.Map as Map import System.IO.Unsafe (unsafePerformIO) import Control.Failure import qualified Data.Text import qualified Data.Text.Lazy import qualified Data.ByteString import qualified Data.ByteString.Lazy import Data.Convertible.Text (cs) import Data.Data import Control.Monad.Trans.Class import Control.Monad.IO.Class import Control.Monad.Trans.State import Control.Monad import qualified Data.Enumerator as E import Data.Enumerator (($$)) import Prelude hiding (catch) import Control.Exception (throwIO, Exception) import Data.String (IsString (fromString)) -- | Equality depends on 'value' and 'tag', not 'style'. data YamlScalar = YamlScalar { value :: ByteString , tag :: Tag , style :: Style } deriving (Show, Read, Data, Typeable) instance Eq YamlScalar where (YamlScalar v t _) == (YamlScalar v' t' _) = v == v' && t == t' instance IsString YamlScalar where fromString = toYamlScalar type YamlObject = Object YamlScalar YamlScalar class (Eq a) => IsYamlScalar a where fromYamlScalar :: YamlScalar -> a toYamlScalar :: a -> YamlScalar instance IsYamlScalar YamlScalar where fromYamlScalar = id toYamlScalar = id instance IsYamlScalar Data.Text.Text where fromYamlScalar = cs . value toYamlScalar t = YamlScalar (cs t) NoTag Any instance IsYamlScalar Data.Text.Lazy.Text where fromYamlScalar = cs . value toYamlScalar t = YamlScalar (cs t) NoTag Any instance IsYamlScalar [Char] where fromYamlScalar = cs . value toYamlScalar s = YamlScalar (cs s) NoTag Any instance IsYamlScalar Data.ByteString.ByteString where fromYamlScalar = value toYamlScalar b = YamlScalar b NoTag Any instance IsYamlScalar Data.ByteString.Lazy.ByteString where fromYamlScalar = cs . value toYamlScalar b = YamlScalar (cs b) NoTag Any -- | Merge assoc-lists by keys. -- First list overrides second: -- [(k1, x), (k2, y)] `mergeAssocLists` [(k3, z)] == [(k1, x), (k2, y), (k3, z)] -- [(k1, x), (k2, y)] `mergeAssocLists` [(k2, z)] == [(k1, x), (k2, y)] mergeAssocLists :: (Eq k) => [(k, v)] -> [(k, v)] -> [(k, v)] mergeAssocLists a [] = a mergeAssocLists [] b = b mergeAssocLists a ((bk, bv):bs) = case lookup bk a of Nothing -> (bk, bv) : mergeAssocLists a bs Just av -> (bk, av) : mergeAssocLists (filter (\(x, _) -> x /= bk) a) bs toYamlObject :: IsYamlScalar k => IsYamlScalar v => Object k v -> YamlObject toYamlObject = mapKeysValues toYamlScalar toYamlScalar fromYamlObject :: IsYamlScalar k => IsYamlScalar v => YamlObject -> Object k v fromYamlObject = mapKeysValues fromYamlScalar fromYamlScalar encode :: (IsYamlScalar k, IsYamlScalar v) => Object k v -> ByteString encode obj = unsafePerformIO $ do x <- E.run $ E.enumList 1 (objToEvents $ toYamlObject obj) $$ Y.encode case x of Left err -> throwIO err Right y -> return y encodeFile :: (IsYamlScalar k, IsYamlScalar v) => FilePath -> Object k v -> IO () encodeFile fp obj = do x <- E.run $ E.enumList 1 (objToEvents $ toYamlObject obj) $$ Y.encodeFile fp case x of Left err -> throwIO err Right () -> return () objToEvents :: YamlObject -> [Y.Event] objToEvents o = (:) EventStreamStart . (:) EventDocumentStart $ objToEvents' o [ EventDocumentEnd , EventStreamEnd ] scalarToEvent :: YamlScalar -> Event scalarToEvent (YamlScalar v t s) = EventScalar v t s Nothing objToEvents' :: YamlObject -> [Y.Event] -> [Y.Event] objToEvents' (Scalar s) rest = scalarToEvent s : rest objToEvents' (Sequence list) rest = EventSequenceStart Nothing : foldr ($) (EventSequenceEnd : rest) (map objToEvents' list) objToEvents' (Mapping pairs) rest = EventMappingStart Nothing : foldr ($) (EventMappingEnd : rest) (map pairToEvents pairs) pairToEvents :: (YamlScalar, YamlObject) -> [Y.Event] -> [Y.Event] pairToEvents (k, v) rest = scalarToEvent k : objToEvents' v rest -- Parsing data ParseException = NonScalarKey | UnknownAlias { _anchorName :: Y.AnchorName } | UnexpectedEvent { _received :: Maybe Event , _expected :: Maybe Event } | InvalidYaml (Maybe String) deriving (Show, Typeable) instance Exception ParseException newtype PErrorT m a = PErrorT { runPErrorT :: m (Either ParseException a) } instance Monad m => Monad (PErrorT m) where return = PErrorT . return . Right (PErrorT m) >>= f = PErrorT $ do e <- m case e of Left e' -> return $ Left e' Right a -> runPErrorT $ f a instance MonadTrans PErrorT where lift = PErrorT . liftM Right instance MonadIO m => MonadIO (PErrorT m) where liftIO = lift . liftIO pfailure :: Monad m => ParseException -> PErrorT m a pfailure = PErrorT . return . Left type Parser = PErrorT (StateT (Map.Map String YamlObject) IO) requireEvent :: Event -> E.Iteratee Event Parser () requireEvent e = do f <- E.head if f == Just e then return () else lift $ pfailure $ UnexpectedEvent f $ Just e parse :: E.Iteratee Event Parser YamlObject parse = do requireEvent EventStreamStart requireEvent EventDocumentStart res <- parseO requireEvent EventDocumentEnd requireEvent EventStreamEnd return res parseScalar :: ByteString -> Tag -> Style -> Anchor -> E.Iteratee Event Parser YamlScalar parseScalar v t s a = do let res = YamlScalar v t s case a of Nothing -> return res Just an -> do lift $ lift $ modify (Map.insert an $ Scalar res) return res parseO :: E.Iteratee Event Parser YamlObject parseO = do me <- E.head case me of Just (EventScalar v t s a) -> Scalar `liftM` parseScalar v t s a Just (EventSequenceStart a) -> parseS a id Just (EventMappingStart a) -> parseM a id Just (EventAlias an) -> do m <- lift $ lift get case Map.lookup an m of Nothing -> lift $ pfailure $ UnknownAlias an Just v -> return v _ -> lift $ pfailure $ UnexpectedEvent me Nothing parseS :: Y.Anchor -> ([YamlObject] -> [YamlObject]) -> E.Iteratee Event Parser YamlObject parseS a front = do me <- E.peek case me of Just EventSequenceEnd -> do E.drop 1 let res = Sequence $ front [] case a of Nothing -> return res Just an -> do lift $ lift $ modify $ Map.insert an res return res _ -> do o <- parseO parseS a $ front . (:) o parseM :: Y.Anchor -> ([(YamlScalar, YamlObject)] -> [(YamlScalar, YamlObject)]) -> E.Iteratee Event Parser YamlObject parseM a front = do me <- E.peek case me of Just EventMappingEnd -> do E.drop 1 let res = Mapping $ front [] case a of Nothing -> return res Just an -> do lift $ lift $ modify $ Map.insert an res return res _ -> do me' <- E.head s <- case me' of Just (EventScalar v t s a') -> parseScalar v t s a' _ -> lift $ pfailure $ UnexpectedEvent me' Nothing o <- parseO let al = mergeAssocLists [(s, o)] $ front [] al' = if fromYamlScalar s == "<<" then case o of Scalar _ -> al Mapping l -> mergeAssocLists al l Sequence l -> mergeAssocLists al $ foldl merge' [] l else al parseM a (`mergeAssocLists` al') where merge' :: (Eq k) => [(k, Object k v)] -> Object k v -> [(k, Object k v)] merge' al (Mapping om) = mergeAssocLists al om merge' al _ = al decode :: (Failure ParseException m, IsYamlScalar k, IsYamlScalar v) => ByteString -> m (Object k v) decode bs = unsafePerformIO $ do x <- flip evalStateT Map.empty $ runPErrorT $ E.run $ Y.decode bs $$ parse case x of Left err -> return $ failure err Right (Left err) -> return $ failure $ InvalidYaml $ Just $ show err Right (Right y) -> return $ return $ fromYamlObject y decodeFile :: (Failure ParseException m, IsYamlScalar k, IsYamlScalar v) => FilePath -> IO (m (Object k v)) decodeFile fp = do x <- flip evalStateT Map.empty $ runPErrorT $ E.run $ Y.decodeFile fp $$ parse case x of Left err -> return $ failure err Right (Left err) -> return $ failure $ InvalidYaml $ Just $ show err Right (Right y) -> return $ return $ fromYamlObject y