{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances,
             MultiParamTypeClasses, RankNTypes, TypeFamilies #-}
-- | Lenses for working with YAML structures.
module Data.Yaml.YamlLight.Lens (
   -- * Traversals
   nth, key, key',
   -- * Yaml parsing prism
   _Yaml, AsYaml(..),
   -- * Numeric parsers
   yamlInt, yamlReal) where
#if __GLASGOW_HASKELL__ < 710
import Control.Applicative
#endif
import Control.Lens
import Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString.Lex.Integral as I
import qualified Data.ByteString.Lex.Fractional as F
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Yaml.YamlLight

-- $setup
-- >>> :set -XOverloadedStrings

-- | The two indexable types of YAML data are sequences and mappings.
data YamlIx = ArrIx Int | ObjIx YamlLight

type instance Index YamlLight = YamlIx
type instance IxValue YamlLight = YamlLight

instance Ixed YamlLight where
  ix :: Index YamlLight -> Traversal' YamlLight (IxValue YamlLight)
ix k :: Index YamlLight
k@(ArrIx i) IxValue YamlLight -> f (IxValue YamlLight)
f (YSeq [YamlLight]
xs) | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = YamlLight -> f YamlLight
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([YamlLight] -> YamlLight
YSeq [YamlLight]
xs)
                             | Bool
otherwise = [YamlLight] -> YamlLight
YSeq ([YamlLight] -> YamlLight) -> f [YamlLight] -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [YamlLight] -> Int -> f [YamlLight]
go [YamlLight]
xs Int
i where
    go :: [YamlLight] -> Int -> f [YamlLight]
go [] Int
_ = [YamlLight] -> f [YamlLight]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
    go (YamlLight
y:[YamlLight]
ys) Int
0 = (YamlLight -> [YamlLight] -> [YamlLight]
forall a. a -> [a] -> [a]
:[YamlLight]
ys) (YamlLight -> [YamlLight]) -> f YamlLight -> f [YamlLight]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (YamlLight -> f YamlLight) -> YamlIx -> YamlLight -> f YamlLight
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed IxValue YamlLight -> f (IxValue YamlLight)
YamlLight -> f YamlLight
f Index YamlLight
YamlIx
k YamlLight
y
    go (YamlLight
y:[YamlLight]
ys) Int
i' = (YamlLight
yYamlLight -> [YamlLight] -> [YamlLight]
forall a. a -> [a] -> [a]
:) ([YamlLight] -> [YamlLight]) -> f [YamlLight] -> f [YamlLight]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([YamlLight] -> Int -> f [YamlLight]
go [YamlLight]
ys (Int -> f [YamlLight]) -> Int -> f [YamlLight]
forall a b. (a -> b) -> a -> b
$! Int
i' Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
  ix k :: Index YamlLight
k@(ObjIx k') IxValue YamlLight -> f (IxValue YamlLight)
f (YMap Map YamlLight YamlLight
m) = case YamlLight -> Map YamlLight YamlLight -> Maybe YamlLight
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup YamlLight
k' Map YamlLight YamlLight
m of
    Just YamlLight
v -> Map YamlLight YamlLight -> YamlLight
YMap (Map YamlLight YamlLight -> YamlLight)
-> (YamlLight -> Map YamlLight YamlLight) -> YamlLight -> YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (YamlLight -> Map YamlLight YamlLight -> Map YamlLight YamlLight)
-> Map YamlLight YamlLight -> YamlLight -> Map YamlLight YamlLight
forall a b c. (a -> b -> c) -> b -> a -> c
flip (YamlLight
-> YamlLight -> Map YamlLight YamlLight -> Map YamlLight YamlLight
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert YamlLight
k') Map YamlLight YamlLight
m (YamlLight -> YamlLight) -> f YamlLight -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (YamlLight -> f YamlLight) -> YamlIx -> YamlLight -> f YamlLight
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed IxValue YamlLight -> f (IxValue YamlLight)
YamlLight -> f YamlLight
f Index YamlLight
YamlIx
k YamlLight
v
    Maybe YamlLight
Nothing -> YamlLight -> f YamlLight
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Map YamlLight YamlLight -> YamlLight
YMap Map YamlLight YamlLight
m)
  ix Index YamlLight
_ IxValue YamlLight -> f (IxValue YamlLight)
_ YamlLight
y = YamlLight -> f YamlLight
forall (f :: * -> *) a. Applicative f => a -> f a
pure YamlLight
y

instance At YamlLight where
  at :: Index YamlLight -> Lens' YamlLight (Maybe (IxValue YamlLight))
at k :: Index YamlLight
k@(ObjIx k') Maybe (IxValue YamlLight) -> f (Maybe (IxValue YamlLight))
f (YMap Map YamlLight YamlLight
m) = Map YamlLight YamlLight -> YamlLight
YMap (Map YamlLight YamlLight -> YamlLight)
-> (Maybe YamlLight -> Map YamlLight YamlLight)
-> Maybe YamlLight
-> YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe YamlLight -> Map YamlLight YamlLight
aux (Maybe YamlLight -> YamlLight)
-> f (Maybe YamlLight) -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe YamlLight -> f (Maybe YamlLight))
-> YamlIx -> Maybe YamlLight -> f (Maybe YamlLight)
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed Maybe (IxValue YamlLight) -> f (Maybe (IxValue YamlLight))
Maybe YamlLight -> f (Maybe YamlLight)
f Index YamlLight
YamlIx
k Maybe YamlLight
mv
    where aux :: Maybe YamlLight -> Map YamlLight YamlLight
aux Maybe YamlLight
Nothing = Map YamlLight YamlLight
-> (YamlLight -> Map YamlLight YamlLight)
-> Maybe YamlLight
-> Map YamlLight YamlLight
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Map YamlLight YamlLight
m (Map YamlLight YamlLight -> YamlLight -> Map YamlLight YamlLight
forall a b. a -> b -> a
const (YamlLight -> Map YamlLight YamlLight -> Map YamlLight YamlLight
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete YamlLight
k' Map YamlLight YamlLight
m)) Maybe YamlLight
mv
          aux (Just YamlLight
v) = YamlLight
-> YamlLight -> Map YamlLight YamlLight -> Map YamlLight YamlLight
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert YamlLight
k' YamlLight
v Map YamlLight YamlLight
m
          mv :: Maybe YamlLight
mv = YamlLight -> Map YamlLight YamlLight -> Maybe YamlLight
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup YamlLight
k' Map YamlLight YamlLight
m
  at Index YamlLight
k Maybe (IxValue YamlLight) -> f (Maybe (IxValue YamlLight))
f YamlLight
y = YamlLight -> Maybe YamlLight -> YamlLight
forall a b. a -> b -> a
const YamlLight
y (Maybe YamlLight -> YamlLight)
-> f (Maybe YamlLight) -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe YamlLight -> f (Maybe YamlLight))
-> YamlIx -> Maybe YamlLight -> f (Maybe YamlLight)
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed Maybe (IxValue YamlLight) -> f (Maybe (IxValue YamlLight))
Maybe YamlLight -> f (Maybe YamlLight)
f Index YamlLight
YamlIx
k Maybe YamlLight
forall a. Maybe a
Nothing

instance Each YamlLight YamlLight YamlLight YamlLight where
  each :: (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight
each YamlLight -> f YamlLight
f (YSeq [YamlLight]
xs) = [YamlLight] -> YamlLight
YSeq ([YamlLight] -> YamlLight) -> f [YamlLight] -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((YamlIx, YamlLight) -> f YamlLight)
-> [(YamlIx, YamlLight)] -> f [YamlLight]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ((YamlIx -> YamlLight -> f YamlLight)
-> (YamlIx, YamlLight) -> f YamlLight
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((YamlIx -> YamlLight -> f YamlLight)
 -> (YamlIx, YamlLight) -> f YamlLight)
-> (YamlIx -> YamlLight -> f YamlLight)
-> (YamlIx, YamlLight)
-> f YamlLight
forall a b. (a -> b) -> a -> b
$ (YamlLight -> f YamlLight) -> YamlIx -> YamlLight -> f YamlLight
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed YamlLight -> f YamlLight
f)
                                       ([YamlIx] -> [YamlLight] -> [(YamlIx, YamlLight)]
forall a b. [a] -> [b] -> [(a, b)]
zip ((Int -> YamlIx) -> [Int] -> [YamlIx]
forall a b. (a -> b) -> [a] -> [b]
map Int -> YamlIx
ArrIx [Int
0..]) [YamlLight]
xs)
  each YamlLight -> f YamlLight
f (YMap Map YamlLight YamlLight
m) = Map YamlLight YamlLight -> YamlLight
YMap (Map YamlLight YamlLight -> YamlLight)
-> f (Map YamlLight YamlLight) -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map YamlLight (f YamlLight) -> f (Map YamlLight YamlLight)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA ((YamlLight -> YamlLight -> f YamlLight)
-> Map YamlLight YamlLight -> Map YamlLight (f YamlLight)
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Map.mapWithKey ((YamlLight -> f YamlLight) -> YamlIx -> YamlLight -> f YamlLight
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed YamlLight -> f YamlLight
f (YamlIx -> YamlLight -> f YamlLight)
-> (YamlLight -> YamlIx) -> YamlLight -> YamlLight -> f YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. YamlLight -> YamlIx
ObjIx) Map YamlLight YamlLight
m)
  each YamlLight -> f YamlLight
_ YamlLight
y = YamlLight -> f YamlLight
forall (f :: * -> *) a. Applicative f => a -> f a
pure YamlLight
y

instance Plated YamlLight where
  plate :: (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight
plate YamlLight -> f YamlLight
f (YSeq [YamlLight]
xs) = [YamlLight] -> YamlLight
YSeq ([YamlLight] -> YamlLight) -> f [YamlLight] -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (YamlLight -> f YamlLight) -> [YamlLight] -> f [YamlLight]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse YamlLight -> f YamlLight
f [YamlLight]
xs
  plate YamlLight -> f YamlLight
f (YMap Map YamlLight YamlLight
m) = Map YamlLight YamlLight -> YamlLight
YMap (Map YamlLight YamlLight -> YamlLight)
-> f (Map YamlLight YamlLight) -> f YamlLight
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (YamlLight -> f YamlLight)
-> Map YamlLight YamlLight -> f (Map YamlLight YamlLight)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse YamlLight -> f YamlLight
f Map YamlLight YamlLight
m
  plate YamlLight -> f YamlLight
_f YamlLight
y = YamlLight -> f YamlLight
forall (f :: * -> *) a. Applicative f => a -> f a
pure YamlLight
y

noRemainder :: (a, ByteString) -> Maybe a
noRemainder :: (a, ByteString) -> Maybe a
noRemainder (a
x, ByteString
bs) = if ByteString -> Bool
BC.null ByteString
bs then a -> Maybe a
forall a. a -> Maybe a
Just a
x else Maybe a
forall a. Maybe a
Nothing

-- | Try to parse an 'Integral' value from a 'YamlLight'.
yamlInt :: Integral b => YamlLight -> Maybe b
yamlInt :: YamlLight -> Maybe b
yamlInt (YStr ByteString
s) = (ByteString -> Maybe (b, ByteString))
-> ByteString -> Maybe (b, ByteString)
forall a.
Num a =>
(ByteString -> Maybe (a, ByteString))
-> ByteString -> Maybe (a, ByteString)
I.readSigned ByteString -> Maybe (b, ByteString)
forall a. Integral a => ByteString -> Maybe (a, ByteString)
I.readDecimal ByteString
s Maybe (b, ByteString) -> ((b, ByteString) -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (b, ByteString) -> Maybe b
forall a. (a, ByteString) -> Maybe a
noRemainder
yamlInt YamlLight
_ = Maybe b
forall a. Maybe a
Nothing

-- | Try to parse a 'Fractional' value from a 'YamlLight'.
yamlReal :: Fractional b => YamlLight -> Maybe b
yamlReal :: YamlLight -> Maybe b
yamlReal (YStr ByteString
s) = (ByteString -> Maybe (b, ByteString))
-> ByteString -> Maybe (b, ByteString)
forall a.
Num a =>
(ByteString -> Maybe (a, ByteString))
-> ByteString -> Maybe (a, ByteString)
F.readSigned ByteString -> Maybe (b, ByteString)
forall a. Fractional a => ByteString -> Maybe (a, ByteString)
F.readDecimal ByteString
s Maybe (b, ByteString) -> ((b, ByteString) -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (b, ByteString) -> Maybe b
forall a. (a, ByteString) -> Maybe a
noRemainder
yamlReal YamlLight
_ = Maybe b
forall a. Maybe a
Nothing

-- | Lens into a sequence.
--
-- >>> YSeq [YStr "a", YStr "b", YStr "c"] ^? nth 1
-- Just (YStr "b")
--
-- >>> YSeq [YStr "a", YStr "b", YStr "c"] & nth 1 .~ YStr "B"
-- YSeq [YStr "a",YStr "B",YStr "c"]
--
-- >>> YSeq [YStr "a", YStr "b", YStr "c"] ^? nth 2 . _Yaml :: Maybe String
-- Just "c"
nth :: Int -> Traversal' YamlLight YamlLight
nth :: Int -> Traversal YamlLight YamlLight YamlLight YamlLight
nth = YamlIx -> (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight
forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix (YamlIx -> (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight)
-> (Int -> YamlIx)
-> Int
-> (YamlLight -> f YamlLight)
-> YamlLight
-> f YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> YamlIx
ArrIx

-- | Lens into a mapping. 'ByteString's are used as keys directly. If
-- you wish to use a complex mapping key, see 'key''.
--
-- >>> let m = YMap $ Map.fromList [(YStr "name", YStr "Tony Stark"), (YStr "sequels", YStr "2")]
-- >>> m & key "sequels" . _Yaml +~ 1
-- YMap (fromList [(YStr "name",YStr "Tony Stark"),(YStr "sequels",YStr "3")])
key :: ByteString -> Traversal' YamlLight YamlLight
key :: ByteString -> Traversal YamlLight YamlLight YamlLight YamlLight
key = YamlLight -> (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight
YamlLight -> Traversal YamlLight YamlLight YamlLight YamlLight
key' (YamlLight
 -> (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight)
-> (ByteString -> YamlLight)
-> ByteString
-> (YamlLight -> f YamlLight)
-> YamlLight
-> f YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> YamlLight
YStr

-- | Lens into a mapping using a complex key.
key' :: YamlLight -> Traversal' YamlLight YamlLight
key' :: YamlLight -> Traversal YamlLight YamlLight YamlLight YamlLight
key' = YamlIx -> (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight
forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix (YamlIx -> (YamlLight -> f YamlLight) -> YamlLight -> f YamlLight)
-> (YamlLight -> YamlIx)
-> YamlLight
-> (YamlLight -> f YamlLight)
-> YamlLight
-> f YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. YamlLight -> YamlIx
ObjIx

-- | Convert between YAML values and common types of Haskell values.
class AsYaml a where
  fromYaml :: YamlLight -> Maybe a
  toYaml   :: a -> YamlLight

instance AsYaml (Map YamlLight YamlLight) where
  fromYaml :: YamlLight -> Maybe (Map YamlLight YamlLight)
fromYaml (YMap Map YamlLight YamlLight
m) = Map YamlLight YamlLight -> Maybe (Map YamlLight YamlLight)
forall a. a -> Maybe a
Just Map YamlLight YamlLight
m
  fromYaml YamlLight
_        = Maybe (Map YamlLight YamlLight)
forall a. Maybe a
Nothing
  toYaml :: Map YamlLight YamlLight -> YamlLight
toYaml = Map YamlLight YamlLight -> YamlLight
YMap

instance AsYaml [YamlLight] where
  fromYaml :: YamlLight -> Maybe [YamlLight]
fromYaml (YSeq [YamlLight]
a) = [YamlLight] -> Maybe [YamlLight]
forall a. a -> Maybe a
Just [YamlLight]
a
  fromYaml YamlLight
_        = Maybe [YamlLight]
forall a. Maybe a
Nothing
  toYaml :: [YamlLight] -> YamlLight
toYaml = [YamlLight] -> YamlLight
YSeq

instance AsYaml ByteString where
  fromYaml :: YamlLight -> Maybe ByteString
fromYaml (YStr ByteString
s) = ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
s
  fromYaml YamlLight
_        = Maybe ByteString
forall a. Maybe a
Nothing
  toYaml :: ByteString -> YamlLight
toYaml = ByteString -> YamlLight
YStr

instance AsYaml String where
  fromYaml :: YamlLight -> Maybe String
fromYaml (YStr ByteString
s) = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ ByteString -> String
BC.unpack ByteString
s
  fromYaml YamlLight
_        = Maybe String
forall a. Maybe a
Nothing
  toYaml :: String -> YamlLight
toYaml = ByteString -> YamlLight
YStr (ByteString -> YamlLight)
-> (String -> ByteString) -> String -> YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BC.pack

instance AsYaml Int where
  fromYaml :: YamlLight -> Maybe Int
fromYaml x :: YamlLight
x@(YStr ByteString
_) = YamlLight -> Maybe Int
forall b. Integral b => YamlLight -> Maybe b
yamlInt YamlLight
x
  fromYaml YamlLight
_ = Maybe Int
forall a. Maybe a
Nothing
  toYaml :: Int -> YamlLight
toYaml Int
x = ByteString -> YamlLight
YStr (ByteString -> YamlLight) -> ByteString -> YamlLight
forall a b. (a -> b) -> a -> b
$ if Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 then Char -> ByteString -> ByteString
BC.cons Char
'-' ByteString
bs else ByteString
bs
    where Just ByteString
bs = Int -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
I.packDecimal (Int -> Maybe ByteString) -> Int -> Maybe ByteString
forall a b. (a -> b) -> a -> b
$ Int -> Int
forall a. Num a => a -> a
abs Int
x
  -- toYaml = YStr . BC.pack . show

instance AsYaml Integer where
  fromYaml :: YamlLight -> Maybe Integer
fromYaml x :: YamlLight
x@(YStr ByteString
_) = YamlLight -> Maybe Integer
forall b. Integral b => YamlLight -> Maybe b
yamlInt YamlLight
x
  fromYaml YamlLight
_ = Maybe Integer
forall a. Maybe a
Nothing
  toYaml :: Integer -> YamlLight
toYaml Integer
x = ByteString -> YamlLight
YStr (ByteString -> YamlLight) -> ByteString -> YamlLight
forall a b. (a -> b) -> a -> b
$ if Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0 then Char -> ByteString -> ByteString
BC.cons Char
'-' ByteString
bs else ByteString
bs
    where Just ByteString
bs = Integer -> Maybe ByteString
forall a. Integral a => a -> Maybe ByteString
I.packDecimal (Integer -> Maybe ByteString) -> Integer -> Maybe ByteString
forall a b. (a -> b) -> a -> b
$ Integer -> Integer
forall a. Num a => a -> a
abs Integer
x
  -- toYaml = YStr . BC.pack . show

instance AsYaml Double where
  fromYaml :: YamlLight -> Maybe Double
fromYaml x :: YamlLight
x@(YStr ByteString
_) = YamlLight -> Maybe Double
forall b. Fractional b => YamlLight -> Maybe b
yamlReal YamlLight
x
  fromYaml YamlLight
_ = Maybe Double
forall a. Maybe a
Nothing
  toYaml :: Double -> YamlLight
toYaml = ByteString -> YamlLight
YStr (ByteString -> YamlLight)
-> (Double -> ByteString) -> Double -> YamlLight
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
BC.pack (String -> ByteString)
-> (Double -> String) -> Double -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> String
forall a. Show a => a -> String
show

instance AsYaml Bool where
  fromYaml :: YamlLight -> Maybe Bool
fromYaml (YStr ByteString
s) = case () of
                        ()
_ | ByteString
s ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== String -> ByteString
BC.pack String
"true"  -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
                          | ByteString
s ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== String -> ByteString
BC.pack String
"false" -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
                          | Bool
otherwise            -> Maybe Bool
forall a. Maybe a
Nothing
  fromYaml YamlLight
_ = Maybe Bool
forall a. Maybe a
Nothing
  toYaml :: Bool -> YamlLight
toYaml Bool
True  = ByteString -> YamlLight
YStr (ByteString -> YamlLight) -> ByteString -> YamlLight
forall a b. (a -> b) -> a -> b
$ String -> ByteString
BC.pack String
"true"
  toYaml Bool
False = ByteString -> YamlLight
YStr (ByteString -> YamlLight) -> ByteString -> YamlLight
forall a b. (a -> b) -> a -> b
$ String -> ByteString
BC.pack String
"false"

-- | Convert between YAML values and corresponding common Haskell
-- values.
--
-- >>> YStr "-2.3" ^? _Yaml :: Maybe Double
-- Just (-2.3)
--
-- >>> YStr "7b.3" ^? _Yaml :: Maybe Double
-- Nothing
--
-- >>> YStr "-23" ^? _Yaml :: Maybe Int
-- Just (-23)
--
-- >>> YStr "Help, I'm trapped in a haddock factory!" ^? _Yaml :: Maybe String
-- Just "Help, I'm trapped in a haddock factory!"
--
-- >>> YStr "An integer" ^? _Yaml :: Maybe Integer
-- Nothing
--
-- If we just want to pull out those values that were successfully
-- parsed,
--
-- >>> let nums = YSeq [YStr "3", YStr "2a", YStr "1"]
-- >>> nums ^.. each._Yaml :: [Int]
-- [3,1]
--
-- Alternately, we may want to fail the entire parse if any element
-- fails to parse.
--
-- >>> sequenceA $ map (preview _Yaml) (nums ^.. each) :: Maybe [Int]
-- Nothing
-- >>> let nums' = YSeq [YStr "3", YStr "2", YStr "1"]
-- >>> sequenceA $ map (preview _Yaml) (nums' ^.. each) :: Maybe [Int]
-- Just [3,2,1]
_Yaml :: AsYaml a => Prism' YamlLight a
_Yaml :: Prism' YamlLight a
_Yaml = (a -> YamlLight) -> (YamlLight -> Maybe a) -> Prism' YamlLight a
forall b s a. (b -> s) -> (s -> Maybe a) -> Prism s s a b
prism' a -> YamlLight
forall a. AsYaml a => a -> YamlLight
toYaml YamlLight -> Maybe a
forall a. AsYaml a => YamlLight -> Maybe a
fromYaml