{-# LANGUAGE CPP                   #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes            #-}
#if __GLASGOW_HASKELL__ < 710
{-# LANGUAGE OverlappingInstances  #-}
#endif
{- |
Module      :  Neovim.Classes
Description :  Type classes used for conversion of msgpack and Haskell types
Copyright   :  (c) Sebastian Witte
License     :  Apache-2.0

Maintainer  :  woozletoff@gmail.com
Stability   :  experimental

-}
module Neovim.Classes
    ( NvimObject(..)
    , Dictionary
    , (+:)
    , Generic
    , docToObject
    , docFromObject
    , docToText

    , Doc
    , AnsiStyle
    , Pretty(..)
    , (<+>)
    , module Data.Int
    , module Data.Word
    , module Control.DeepSeq
    ) where

import Neovim.Exceptions (NeovimException (..))

import           Control.Applicative
import           Control.Arrow                             ((***))
import           Control.DeepSeq
import           Control.Monad.Except
import           Data.ByteString                           (ByteString)
import           Data.Int
    ( Int16
    , Int32
    , Int64
    , Int8
    )
import qualified Data.Map.Strict                           as SMap
import           Data.MessagePack
import           Data.Monoid
import           Data.Text                                 as Text (Text)
import           Data.Text.Prettyprint.Doc
    ( Doc
    , Pretty (..)
    , defaultLayoutOptions
    , layoutPretty
    , viaShow
    , (<+>)
    )
import qualified Data.Text.Prettyprint.Doc                 as P
import           Data.Text.Prettyprint.Doc.Render.Terminal
    ( AnsiStyle
    , renderStrict
    )
import           Data.Traversable                          hiding (forM, mapM)
import           Data.Vector                               (Vector)
import qualified Data.Vector                               as V
import           Data.Word
    ( Word
    , Word16
    , Word32
    , Word64
    , Word8
    )
import           GHC.Generics                              (Generic)

import qualified Data.ByteString.UTF8 as UTF8 (fromString, toString)
import           Data.Text.Encoding   (decodeUtf8, encodeUtf8)
import           UnliftIO.Exception   (throwIO)

import Prelude


infixr 5 +:

-- | Convenient operator to create a list of 'Object' from normal values.
-- @
-- values +: of :+ different :+ types :+ can +: be +: combined +: this +: way +: []
-- @
(+:) :: (NvimObject o) => o -> [Object] -> [Object]
o
o +: :: forall o. NvimObject o => o -> [Object] -> [Object]
+: [Object]
os = forall o. NvimObject o => o -> Object
toObject o
o forall a. a -> [a] -> [a]
: [Object]
os


-- | Convert a 'Doc'-ument to a messagepack 'Object'. This is more a convenience
-- method to transport error message from and to neovim. It generally does not
-- hold that 'docToObject . docFromObject' = 'id'.
docToObject :: Doc AnsiStyle -> Object
docToObject :: Doc AnsiStyle -> Object
docToObject = ByteString -> Object
ObjectString forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
encodeUtf8 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc AnsiStyle -> Text
docToText


-- | See 'docToObject'.
docFromObject :: Object -> Either (Doc AnsiStyle) (Doc AnsiStyle)
docFromObject :: Object -> Either (Doc AnsiStyle) (Doc AnsiStyle)
docFromObject Object
o = (forall a ann. Show a => a -> Doc ann
P.viaShow :: Text -> Doc AnsiStyle) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o


docToText :: Doc AnsiStyle -> Text
docToText :: Doc AnsiStyle -> Text
docToText = SimpleDocStream AnsiStyle -> Text
renderStrict forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall ann. LayoutOptions -> Doc ann -> SimpleDocStream ann
layoutPretty LayoutOptions
defaultLayoutOptions


-- | A generic vim dictionary is a simply a map from strings to objects.  This
-- type alias is sometimes useful as a type annotation especially if the
-- OverloadedStrings extension is enabled.
type Dictionary = SMap.Map ByteString Object


-- | Conversion from 'Object' files to Haskell types and back with respect
-- to neovim's interpretation.
--
-- The 'NFData' constraint has been added to allow forcing results of function
-- evaluations in order to catch exceptions from pure code. This adds more
-- stability to the plugin provider and seems to be a cleaner approach.
class NFData o => NvimObject o where
    toObject :: o -> Object

    fromObjectUnsafe :: Object -> o
    fromObjectUnsafe Object
o = case forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o of
        Left Doc AnsiStyle
e -> forall a. HasCallStack => [Char] -> a
error forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$
            Doc AnsiStyle
"Not the expected object:" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
P.viaShow Object
o
            forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall ann. Doc ann
P.lparen forall a. Semigroup a => a -> a -> a
<> Doc AnsiStyle
e forall a. Semigroup a => a -> a -> a
<> forall ann. Doc ann
P.rparen
        Right o
obj -> o
obj

    fromObject :: Object -> Either (Doc AnsiStyle) o
    fromObject = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o. NvimObject o => Object -> o
fromObjectUnsafe

    fromObject' :: (MonadIO io) => Object -> io o
    fromObject' = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throwIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc AnsiStyle -> NeovimException
ErrorMessage) forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject

    {-# MINIMAL toObject, (fromObject | fromObjectUnsafe) #-}


-- Instances for NvimObject {{{1
instance NvimObject () where
    toObject :: () -> Object
toObject ()
_           = Object
ObjectNil

    fromObject :: Object -> Either (Doc AnsiStyle) ()
fromObject Object
ObjectNil = forall (m :: * -> *) a. Monad m => a -> m a
return ()
    fromObject Object
o         = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectNil, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
P.viaShow Object
o


-- We may receive truthy values from neovim, so we should be more forgiving
-- here.
instance NvimObject Bool where
    toObject :: Bool -> Object
toObject                      = Bool -> Object
ObjectBool

    fromObject :: Object -> Either (Doc AnsiStyle) Bool
fromObject (ObjectBool Bool
o)     = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
o
    fromObject (ObjectInt  Int64
0)     = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    fromObject (ObjectUInt Word64
0)     = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    fromObject Object
ObjectNil          = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    fromObject (ObjectBinary ByteString
"0") = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    fromObject (ObjectBinary ByteString
"")  = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    fromObject (ObjectString ByteString
"0") = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    fromObject (ObjectString ByteString
"")  = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    fromObject Object
_                  = forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True


instance NvimObject Double where
    toObject :: Double -> Object
toObject                    = Double -> Object
ObjectDouble

    fromObject :: Object -> Either (Doc AnsiStyle) Double
fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
o
    fromObject (ObjectInt Int64
o)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
o
    fromObject (ObjectUInt Word64
o)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectDouble, but got"
                                                forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Integer where
    toObject :: Integer -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Integer
fromObject (ObjectInt Int64
o)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger Int64
o
    fromObject (ObjectUInt Word64
o)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger Word64
o
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectInt, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Int64 where
    toObject :: Int64 -> Object
toObject                    = Int64 -> Object
ObjectInt

    fromObject :: Object -> Either (Doc AnsiStyle) Int64
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return Int64
i
    fromObject (ObjectUInt Word64
o)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
o
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Int32 where
    toObject :: Int32 -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Int32
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Int16 where
    toObject :: Int16 -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Int16
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Int8 where
    toObject :: Int8 -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Int8
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Word where
    toObject :: Word -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Word
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Word64 where
    toObject :: Word64 -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Word64
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Word32 where
    toObject :: Word32 -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Word32
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Word16 where
    toObject :: Word16 -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Word16
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Word8 where
    toObject :: Word8 -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Word8
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Int where
    toObject :: Int -> Object
toObject                    = Int64 -> Object
ObjectInt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

    fromObject :: Object -> Either (Doc AnsiStyle) Int
fromObject (ObjectInt Int64
i)    = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
i
    fromObject (ObjectUInt Word64
i)   = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
i
    fromObject (ObjectDouble Double
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Double
o
    fromObject (ObjectFloat Float
o)  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
round Float
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected any Integer value, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance {-# OVERLAPPING #-} NvimObject [Char] where
    toObject :: [Char] -> Object
toObject                    = ByteString -> Object
ObjectBinary forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ByteString
UTF8.fromString

    fromObject :: Object -> Either (Doc AnsiStyle) [Char]
fromObject (ObjectBinary ByteString
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ByteString -> [Char]
UTF8.toString ByteString
o
    fromObject (ObjectString ByteString
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ByteString -> [Char]
UTF8.toString ByteString
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectString, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance {-# OVERLAPPABLE #-} NvimObject o => NvimObject [o] where
    toObject :: [o] -> Object
toObject                    = [Object] -> Object
ObjectArray forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall o. NvimObject o => o -> Object
toObject

    fromObject :: Object -> Either (Doc AnsiStyle) [o]
fromObject (ObjectArray [Object]
os) = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject [Object]
os
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject o => NvimObject (Maybe o) where
    toObject :: Maybe o -> Object
toObject = forall b a. b -> (a -> b) -> Maybe a -> b
maybe Object
ObjectNil forall o. NvimObject o => o -> Object
toObject

    fromObject :: Object -> Either (Doc AnsiStyle) (Maybe o)
fromObject Object
ObjectNil = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
    fromObject Object
o         = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just) forall a b. (a -> b) -> a -> b
$ forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o


instance NvimObject o => NvimObject (Vector o) where
    toObject :: Vector o -> Object
toObject = [Object] -> Object
ObjectArray forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [a]
V.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> Vector a -> Vector b
V.map forall o. NvimObject o => o -> Object
toObject

    fromObject :: Object -> Either (Doc AnsiStyle) (Vector o)
fromObject (ObjectArray [Object]
os) = forall a. [a] -> Vector a
V.fromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject [Object]
os
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


-- | Right-biased instance for toObject.
instance (NvimObject l, NvimObject r) => NvimObject (Either l r) where
    toObject :: Either l r -> Object
toObject = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall o. NvimObject o => o -> Object
toObject forall o. NvimObject o => o -> Object
toObject

    fromObject :: Object -> Either (Doc AnsiStyle) (Either l r)
fromObject Object
o = case forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o of
                     Right r
r ->
                         forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right r
r

                     Left Doc AnsiStyle
e1 -> case forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o of
                                  Right l
l ->
                                      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left l
l

                                  Left Doc AnsiStyle
e2 ->
                                      forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
e1 forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc AnsiStyle
"--" forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc AnsiStyle
e2


instance (Ord key, NvimObject key, NvimObject val)
        => NvimObject (SMap.Map key val) where
    toObject :: Map key val -> Object
toObject = Map Object Object -> Object
ObjectMap
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Ord k => [(k, a)] -> Map k a
SMap.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (forall o. NvimObject o => o -> Object
toObject forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** forall o. NvimObject o => o -> Object
toObject) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
SMap.toList

    fromObject :: Object -> Either (Doc AnsiStyle) (Map key val)
fromObject (ObjectMap Map Object Object
om) = forall k a. Ord k => [(k, a)] -> Map k a
SMap.fromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        (forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA
            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,))
                    forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject))
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
SMap.toList) Map Object Object
om

    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectMap, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Text where
    toObject :: Text -> Object
toObject                    = ByteString -> Object
ObjectBinary forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ByteString
encodeUtf8

    fromObject :: Object -> Either (Doc AnsiStyle) Text
fromObject (ObjectBinary ByteString
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ByteString -> Text
decodeUtf8 ByteString
o
    fromObject (ObjectString ByteString
o) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ByteString -> Text
decodeUtf8 ByteString
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectBinary, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject ByteString where
    toObject :: ByteString -> Object
toObject                    = ByteString -> Object
ObjectBinary

    fromObject :: Object -> Either (Doc AnsiStyle) ByteString
fromObject (ObjectBinary ByteString
o) = forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
o
    fromObject (ObjectString ByteString
o) = forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
o
    fromObject Object
o                = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectBinary, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance NvimObject Object where
    toObject :: Object -> Object
toObject = forall a. a -> a
id

    fromObject :: Object -> Either (Doc AnsiStyle) Object
fromObject = forall (m :: * -> *) a. Monad m => a -> m a
return
    fromObjectUnsafe :: Object -> Object
fromObjectUnsafe = forall a. a -> a
id


-- By the magic of vim, i will create these.
instance (NvimObject o1, NvimObject o2) => NvimObject (o1, o2) where
    toObject :: (o1, o2) -> Object
toObject (o1
o1, o2
o2) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2]

    fromObject :: Object -> Either (Doc AnsiStyle) (o1, o2)
fromObject (ObjectArray [Object
o1, Object
o2]) = (,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o

instance (NvimObject o1, NvimObject o2, NvimObject o3) => NvimObject (o1, o2, o3) where
    toObject :: (o1, o2, o3) -> Object
toObject (o1
o1, o2
o2, o3
o3) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2, forall o. NvimObject o => o -> Object
toObject o3
o3]

    fromObject :: Object -> Either (Doc AnsiStyle) (o1, o2, o3)
fromObject (ObjectArray [Object
o1, Object
o2, Object
o3]) = (,,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o3
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance (NvimObject o1, NvimObject o2, NvimObject o3, NvimObject o4) => NvimObject (o1, o2, o3, o4) where
    toObject :: (o1, o2, o3, o4) -> Object
toObject (o1
o1, o2
o2, o3
o3, o4
o4) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2, forall o. NvimObject o => o -> Object
toObject o3
o3, forall o. NvimObject o => o -> Object
toObject o4
o4]

    fromObject :: Object -> Either (Doc AnsiStyle) (o1, o2, o3, o4)
fromObject (ObjectArray [Object
o1, Object
o2, Object
o3, Object
o4]) = (,,,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o3
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o4
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance (NvimObject o1, NvimObject o2, NvimObject o3, NvimObject o4, NvimObject o5) => NvimObject (o1, o2, o3, o4, o5) where
    toObject :: (o1, o2, o3, o4, o5) -> Object
toObject (o1
o1, o2
o2, o3
o3, o4
o4, o5
o5) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2, forall o. NvimObject o => o -> Object
toObject o3
o3, forall o. NvimObject o => o -> Object
toObject o4
o4, forall o. NvimObject o => o -> Object
toObject o5
o5]

    fromObject :: Object -> Either (Doc AnsiStyle) (o1, o2, o3, o4, o5)
fromObject (ObjectArray [Object
o1, Object
o2, Object
o3, Object
o4, Object
o5]) = (,,,,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o3
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o4
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o5
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance (NvimObject o1, NvimObject o2, NvimObject o3, NvimObject o4, NvimObject o5, NvimObject o6) => NvimObject (o1, o2, o3, o4, o5, o6) where
    toObject :: (o1, o2, o3, o4, o5, o6) -> Object
toObject (o1
o1, o2
o2, o3
o3, o4
o4, o5
o5, o6
o6) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2, forall o. NvimObject o => o -> Object
toObject o3
o3, forall o. NvimObject o => o -> Object
toObject o4
o4, forall o. NvimObject o => o -> Object
toObject o5
o5, forall o. NvimObject o => o -> Object
toObject o6
o6]

    fromObject :: Object -> Either (Doc AnsiStyle) (o1, o2, o3, o4, o5, o6)
fromObject (ObjectArray [Object
o1, Object
o2, Object
o3, Object
o4, Object
o5, Object
o6]) = (,,,,,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o3
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o4
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o5
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o6
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance (NvimObject o1, NvimObject o2, NvimObject o3, NvimObject o4, NvimObject o5, NvimObject o6, NvimObject o7) => NvimObject (o1, o2, o3, o4, o5, o6, o7) where
    toObject :: (o1, o2, o3, o4, o5, o6, o7) -> Object
toObject (o1
o1, o2
o2, o3
o3, o4
o4, o5
o5, o6
o6, o7
o7) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2, forall o. NvimObject o => o -> Object
toObject o3
o3, forall o. NvimObject o => o -> Object
toObject o4
o4, forall o. NvimObject o => o -> Object
toObject o5
o5, forall o. NvimObject o => o -> Object
toObject o6
o6, forall o. NvimObject o => o -> Object
toObject o7
o7]

    fromObject :: Object -> Either (Doc AnsiStyle) (o1, o2, o3, o4, o5, o6, o7)
fromObject (ObjectArray [Object
o1, Object
o2, Object
o3, Object
o4, Object
o5, Object
o6, Object
o7]) = (,,,,,,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o3
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o4
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o5
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o6
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o7
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance (NvimObject o1, NvimObject o2, NvimObject o3, NvimObject o4, NvimObject o5, NvimObject o6, NvimObject o7, NvimObject o8) => NvimObject (o1, o2, o3, o4, o5, o6, o7, o8) where
    toObject :: (o1, o2, o3, o4, o5, o6, o7, o8) -> Object
toObject (o1
o1, o2
o2, o3
o3, o4
o4, o5
o5, o6
o6, o7
o7, o8
o8) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2, forall o. NvimObject o => o -> Object
toObject o3
o3, forall o. NvimObject o => o -> Object
toObject o4
o4, forall o. NvimObject o => o -> Object
toObject o5
o5, forall o. NvimObject o => o -> Object
toObject o6
o6, forall o. NvimObject o => o -> Object
toObject o7
o7, forall o. NvimObject o => o -> Object
toObject o8
o8]

    fromObject :: Object -> Either (Doc AnsiStyle) (o1, o2, o3, o4, o5, o6, o7, o8)
fromObject (ObjectArray [Object
o1, Object
o2, Object
o3, Object
o4, Object
o5, Object
o6, Object
o7, Object
o8]) = (,,,,,,,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o3
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o4
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o5
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o6
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o7
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o8
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


instance (NvimObject o1, NvimObject o2, NvimObject o3, NvimObject o4, NvimObject o5, NvimObject o6, NvimObject o7, NvimObject o8, NvimObject o9) => NvimObject (o1, o2, o3, o4, o5, o6, o7, o8, o9) where
    toObject :: (o1, o2, o3, o4, o5, o6, o7, o8, o9) -> Object
toObject (o1
o1, o2
o2, o3
o3, o4
o4, o5
o5, o6
o6, o7
o7, o8
o8, o9
o9) = [Object] -> Object
ObjectArray forall a b. (a -> b) -> a -> b
$ [forall o. NvimObject o => o -> Object
toObject o1
o1, forall o. NvimObject o => o -> Object
toObject o2
o2, forall o. NvimObject o => o -> Object
toObject o3
o3, forall o. NvimObject o => o -> Object
toObject o4
o4, forall o. NvimObject o => o -> Object
toObject o5
o5, forall o. NvimObject o => o -> Object
toObject o6
o6, forall o. NvimObject o => o -> Object
toObject o7
o7, forall o. NvimObject o => o -> Object
toObject o8
o8, forall o. NvimObject o => o -> Object
toObject o9
o9]

    fromObject :: Object
-> Either (Doc AnsiStyle) (o1, o2, o3, o4, o5, o6, o7, o8, o9)
fromObject (ObjectArray [Object
o1, Object
o2, Object
o3, Object
o4, Object
o5, Object
o6, Object
o7, Object
o8, Object
o9]) = (,,,,,,,,)
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o1
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o2
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o3
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o4
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o5
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o6
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o7
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o8
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall o. NvimObject o => Object -> Either (Doc AnsiStyle) o
fromObject Object
o9
    fromObject Object
o = forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError forall a b. (a -> b) -> a -> b
$ Doc AnsiStyle
"Expected ObjectArray, but got" forall ann. Doc ann -> Doc ann -> Doc ann
<+> forall a ann. Show a => a -> Doc ann
viaShow Object
o


-- 1}}}