{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE OverloadedStrings #-}

{- |
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.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 Prettyprinter (
    Doc,
    Pretty (..),
    defaultLayoutOptions,
    layoutPretty,
    viaShow,
    (<+>),
 )
import qualified Prettyprinter as P
import Prettyprinter.Render.Terminal (
    AnsiStyle,
    renderStrict,
 )

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 b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse
                    ( 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 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 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 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 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}}}