hs-tango 1.0.0 → 2.0.0

raw patch · 5 files changed

+434/−142 lines, 5 filesdep +http-mediadep +lucid2dep +servantdep ~basedep ~textPVP ok

version bump matches the API change (PVP)

Dependencies added: http-media, lucid2, servant, servant-server, warp

Dependency ranges changed: base, text

API changes (from Hackage documentation)

Files

• README.org +7/−0
• app/WebAstor.hs +259/−0
• hs-tango.cabal +18/−3
• lib/Tango/Client.hs +101/−90
• lib/Tango/Raw/Common.hsc +49/−49

@@ -91,6 +91,13 @@           putStrLn "received change" #+end_src +*** Example: Web Astor++Under =benchmark= in the =.cabal= file, you will find =web-astor=, which is a web-based implementation of the Astor starter overlay. It runs on =localhost:8081= and displays a HTML version of Astor, asking for a Tango host. The code is short and should be fairly easy to grasp. A screenshot of that should explain it well:++[[https://raw.githubusercontent.com/pmiddend/hs-tango/main/doc-assets/web-astor.png]]++The example uses Servant and Lucid to render the HTML. ** What's missing  - Server: Everything

@@ -0,0 +1,259 @@+{-# LANGUAGE BlockArguments #-}+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE EmptyDataDecls #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE ImportQualifiedPost #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE NamedFieldPuns #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE TypeOperators #-}++module Main where++import Control.Applicative (pure)+import Control.Exception (handle)+import Control.Monad (Monad, forM_, (>>=))+import Control.Monad.IO.Class (liftIO)+import Data.Bool (not)+import Data.Either (Either (Left, Right))+import Data.Function (flip, ($), (.))+import Data.Functor (void, (<$>))+import Data.Int (Int)+import Data.List (sortOn)+import Data.List.NonEmpty qualified as NE+import Data.Maybe (Maybe (Just, Nothing), fromMaybe)+import Data.Monoid (mempty)+import Data.Semigroup ((<>))+import Data.Text (Text, breakOn, breakOnAll, drop, isPrefixOf, lines, pack, strip, unlines, words)+import Data.Text.Read (decimal)+import Data.Traversable (for, traverse)+import Data.Typeable (Typeable)+import Lucid (ToHtml (toHtml, toHtmlRaw))+import Lucid qualified as L+import Lucid.Base (renderBS)+import Lucid.Html5 (h1_)+import Network.HTTP.Media qualified as M+import Network.Wai.Handler.Warp (run)+import Servant (Get, Handler, Proxy (Proxy), QueryParam, (:>))+import Servant.API (Accept (..), JSON, MimeRender (..), Post, ReqBody, (:<|>) ((:<|>)))+import Servant.API.Generic (Generic)+import Servant.Server (Application, Server, serve)+import System.Environment (getArgs)+import System.IO (IO, putStrLn)+import Tango.Client (AttributeName (AttributeName), CommandData (CommandString), CommandName (CommandName), TangoException (TangoException), commandInOutGeneric, parseTangoUrl, readStringSpectrumAttribute, tangoValueRead, withDeviceProxy)+import Text.Show (show)+import Prelude (undefined)++-- | HTML type which uses lucid2 to output the bytes. lucid1 would have been simpler, but lucid2 is cleaner.+data HTML deriving stock (Typeable)++instance Accept HTML where+  contentTypes _ =+    "text" M.// "html" M./: ("charset", "utf-8")+      NE.:| ["text" M.// "html"]++instance (ToHtml a) => MimeRender HTML a where+  mimeRender _ = renderBS . toHtml++-- | A Tango device server description that is parsed from the Astor server output+data AstorServer = AstorServer+  { serverDevice :: Text,+    serverStatus :: Text,+    serverControlled :: Int,+    serverLevel :: Int,+    serverNbInstances :: Int+  }+  deriving (Generic)++-- | Message to display after an action (start server, stop server)+data Message = MessageError Text | MessageSuccess Text++-- | Main type holding information about what to output+data RefreshOutput = RefreshOutput+  { refreshOutputServers :: Either Text [AstorServer],+    refreshOutputHost :: Text,+    refreshOutputMessage :: Maybe Message+  }+  deriving (Generic)++viewServerStatus :: (Monad m) => Text -> L.HtmlT m ()+viewServerStatus "ON" = L.span_ [L.class_ "badge text-bg-success"] "ON"+viewServerStatus "MOVING" = L.span_ [L.class_ "spinner-border spinner-border-sm text-secondary"] mempty+viewServerStatus "FAULT" = L.span_ [L.class_ "badge text-bg-danger"] "FAULT"+viewServerStatus t = L.span_ [L.class_ "badge text-bg-secondary"] (L.toHtml t)++instance ToHtml RefreshOutput where+  toHtml (RefreshOutput servers host message) = viewHtmlSkeleton do+    L.form_ [L.action_ "servers"] do+      L.div_ [L.class_ "form-floating mb-3"] do+        L.input_+          [ L.type_ "text",+            L.class_ "form-control",+            L.id_ "host",+            L.placeholder_ "localhost:10000",+            L.name_ "host",+            L.value_ host+          ]+        L.label_ [L.for_ "host"] "Tango Host:Port"+      L.button_ [L.class_ "btn btn-primary mb-3", L.type_ "submit"] "Refresh"+    case servers of+      Left e ->+        L.div_ [L.class_ "alert alert-danger"] (L.toHtml ("Something went wrong: " <> e))+      Right serverList -> do+        case message of+          Just (MessageError e) -> L.div_ [L.class_ "alert alert-danger"] (L.toHtml ("Something went wrong: " <> e))+          Just (MessageSuccess s) -> L.div_ [L.class_ "alert alert-success"] (L.toHtml s)+          Nothing -> mempty+        L.table_ [L.class_ "table"] do+          L.thead_ do+            L.tr_ do+              L.th_ "Lvl"+              L.th_ "Device"+              L.th_ "Status"+              L.th_ "Actions"+          L.tbody_+            ( forM_ (sortOn serverLevel serverList) \(AstorServer {serverDevice, serverStatus, serverLevel}) ->+                L.tr_ do+                  L.td_ (L.toHtml (pack (show serverLevel)))+                  L.td_ (L.code_ (L.toHtml serverDevice))+                  L.td_ do+                    viewServerStatus serverStatus+                  L.td_ do+                    L.div_ [L.class_ "hstack gap-1"] do+                      L.a_+                        [ L.href_ ("servers?host=" <> host <> "&action=stop&device=" <> serverDevice),+                          L.class_ "btn btn-sm btn-primary rounded-circle"+                        ]+                        do+                          L.i_ [L.class_ "bi-stop"] mempty+                      L.a_+                        [ L.href_ ("servers?host=" <> host <> "&action=start&device=" <> serverDevice),+                          L.class_ "btn btn-sm btn-primary rounded-circle"+                        ]+                        do+                          L.i_ [L.class_ "bi-play"] mempty+            )+  toHtmlRaw = toHtml++type AstorAPI =+  "servers"+    :> QueryParam "host" Text+    :> QueryParam "action" Text+    :> QueryParam "device" Text+    :> Get '[HTML] RefreshOutput++parseServersOutput :: Text -> Either Text [AstorServer]+parseServersOutput l = for (lines l) \line -> case words line of+  [device, status, controlledStr, levelStr, nbInstancesStr] ->+    case (decimal controlledStr, decimal levelStr, decimal nbInstancesStr) of+      (Right (controlled, _), Right (level, _), Right (nbInstances, _)) ->+        Right (AstorServer {serverDevice = device, serverStatus = status, serverControlled = controlled, serverLevel = level, serverNbInstances = nbInstances})+      _ -> Left ("one of controlled, level, nbInstances is not a number: " <> line)+  _ -> Left ("expected whitespace-separated list of 5 values, got: " <> line)++data HostWithPort = HostWithPort Text Int++parseHostWithPort :: Text -> Maybe HostWithPort+parseHostWithPort hostAndPort =+  case breakOn ":" hostAndPort of+    (host, maybePort) ->+      if not (":" `isPrefixOf` maybePort)+        then Nothing+        else case decimal (drop 1 maybePort) of+          Right (port, _) -> Just (HostWithPort host port)+          _ -> Nothing++astorServer :: Server AstorAPI+astorServer = astorEndpointServers++astorEndpointServers :: Maybe Text -> Maybe Text -> Maybe Text -> Handler RefreshOutput+astorEndpointServers inputHost action devicename =+  case inputHost >>= parseHostWithPort of+    Nothing ->+      pure+        ( RefreshOutput+            { refreshOutputHost = "",+              refreshOutputServers = Right [],+              refreshOutputMessage = Nothing+            }+        )+    Just (HostWithPort inputHost' inputPort) -> do+      let inputHostAndPortStr = inputHost' <> ":" <> pack (show inputPort)+       in case parseTangoUrl ("tango://" <> inputHostAndPortStr <> "/tango/admin/" <> inputHost') of+            Left e ->+              pure+                ( RefreshOutput+                    { refreshOutputHost = inputHostAndPortStr,+                      refreshOutputServers = Left ("error parsing host: " <> e),+                      refreshOutputMessage = Nothing+                    }+                )+            Right deviceAddress -> liftIO+              $ handle+                ( \e@(TangoException _) ->+                    pure+                      ( RefreshOutput+                          { refreshOutputHost = inputHostAndPortStr,+                            refreshOutputServers = Left ("error in tango: " <> pack (show e)),+                            refreshOutputMessage = Nothing+                          }+                      )+                )+              $ withDeviceProxy deviceAddress \proxy -> do+                outputMessage <- case (action, devicename) of+                  (Just "stop", Just deviceName) -> do+                    void (commandInOutGeneric proxy (CommandName "DevStop") (CommandString deviceName))+                    pure (Just (MessageSuccess "stopping!"))+                  (Just "start", Just deviceName) -> do+                    void (commandInOutGeneric proxy (CommandName "DevStart") (CommandString deviceName))+                    pure (Just (MessageSuccess "starting!"))+                  _ -> pure Nothing++                servers <- readStringSpectrumAttribute proxy (AttributeName "Servers")+                case parseServersOutput (unlines (tangoValueRead servers)) of+                  Left e ->+                    pure+                      ( RefreshOutput+                          { refreshOutputHost = inputHostAndPortStr,+                            refreshOutputServers = Left ("error parsing servers output: " <> e),+                            refreshOutputMessage = outputMessage+                          }+                      )+                  Right serversParsed ->+                    pure+                      ( RefreshOutput+                          { refreshOutputHost = inputHostAndPortStr,+                            refreshOutputServers = Right serversParsed,+                            refreshOutputMessage = outputMessage+                          }+                      )++astorAPI :: Proxy AstorAPI+astorAPI = Proxy++app :: Application+app = serve astorAPI astorServer++viewHtmlSkeleton content = do+  L.doctypehtml_ do+    L.head_ do+      L.meta_ [L.charset_ "utf-8"]+      L.meta_ [L.name_ "viewport", L.content_ "width=device-width, initial-scale=1"]+      L.title_ "Astor on the Web"+      L.link_ [L.href_ "https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css", L.rel_ "stylesheet"]+      L.link_ [L.href_ "https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.min.css", L.rel_ "stylesheet"]+    L.body_ do+      L.div_ [L.class_ "container"] do+        L.header_ do+          L.h1_ "Astor on the Web"+        L.main_ do+          content+      -- Not sure if we need the bootstrap JS, and it must save some bandwidth, so leave it out maybe+      L.script_ [L.src_ "https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js"] ("" :: Text)++main :: IO ()+main = do+  putStrLn "listening on port 8081..."+  run 8081 app

@@ -1,6 +1,6 @@ cabal-version:      3.6 name:               hs-tango-version:            1.0.0+version:            2.0.0 synopsis:           Bindings to the Tango Controls system description:   Haskell bindings for Tango, part of the Tango Distributed Control System toolkit. Some general notes about this project:@@ -65,13 +65,28 @@     -- otherwise: undefined reference to operator new     extra-libraries: stdc++ +benchmark web-astor+  type: exitcode-stdio-1.0+  main-is: WebAstor.hs+  hs-source-dirs: app+  default-language:  Haskell2010+  build-depends:+      base >=4.7 && <5+    , hs-tango+    , servant-server+    , servant+    , text+    , warp+    , lucid2+    , http-media+ benchmark tango-read-test-device   type: exitcode-stdio-1.0   main-is: ReadTestDevice.hs      ghc-options: -threaded -rtsopts -with-rtsopts=-N-  hs-source-dirs:-      app+  default-language:  Haskell2010+  hs-source-dirs: app   build-depends:       base >=4.7 && <5     , hs-tango

@@ -1,6 +1,7 @@ {-# LANGUAGE BlockArguments #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE ExistentialQuantification #-}+{-# LANGUAGE ImportQualifiedPost #-} {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-}@@ -43,14 +44,22 @@ -- -- = Examples --+-- The examples below are alightly more explicit than needed (explicit imports), to make it easier to follow.+-- -- == Reading and writing a scalar, boolean attribute ----- >{-# LANGUAGE BlockArguments #-}+-- > -- >{-# LANGUAGE OverloadedStrings #-} -- > -- >module Main where -- >--- >import Tango.Client+-- >import Data.Either (Either (Left, Right))+-- >import Data.Function (($))+-- >import Data.Semigroup ((<>))+-- >import System.IO (putStrLn)+-- >import Tango.Client (AttributeName (AttributeName), parseTangoUrl, readBoolAttribute, tangoValueRead, withDeviceProxy)+-- >import Text.Show (show)+-- >import Prelude (error) -- > -- >main = -- >  case parseTangoUrl "sys/tg_test/1" of@@ -58,25 +67,29 @@ -- >    Right deviceAddress -> withDeviceProxy deviceAddress \proxy -> do -- >      booleanResult <- readBoolAttribute proxy (AttributeName "boolean_scalar") -- >      putStrLn $ "boolean_scalar is " <> show (tangoValueRead booleanResult)--- >--- >      writeBoolAttribute proxy (AttributeName "boolean_scalar") True ----- == Reading a spectrum string attribute+-- == Reading a spectrum boolean attribute -- -- >{-# LANGUAGE BlockArguments #-} -- >{-# LANGUAGE OverloadedStrings #-} -- > -- >module Main where -- >--- >import Tango.Client+-- >import Control.Monad (mapM_)+-- >import Data.Either (Either (Left, Right))+-- >import Data.Function ((.))+-- >import Data.Text (pack) -- >import qualified Data.Text.IO as TIO+-- >import Tango.Client (AttributeName (AttributeName), TangoValue (tangoValueRead), parseTangoUrl, readBoolSpectrumAttribute, withDeviceProxy)+-- >import Text.Show (show)+-- >import Prelude (error) -- > -- >main = -- >  case parseTangoUrl "sys/tg_test/1" of -- >    Left e -> error "couldn't resolve tango URL" -- >    Right deviceAddress -> withDeviceProxy deviceAddress \proxy -> do--- >      result <- readBoolSpectrumAttribute proxy (AttributeName "string_spectrum_ro")--- >      mapM_ TIO.putStrLn result+-- >      result <- readBoolSpectrumAttribute proxy (AttributeName "boolean_spectrum_ro")+-- >      mapM_ (TIO.putStrLn . pack . show) (tangoValueRead result) module Tango.Client   ( -- * Basics and initialization @@ -100,7 +113,7 @@      -- * Attributes     AttributeName (AttributeName),-    AttributeInfo (AttributeInfo),+    AttributeInfo (..),     getConfigsForAttributes,     getConfigForAttribute,     TangoValue (TangoValue, tangoValueRead, tangoValueWrite),@@ -222,7 +235,7 @@     getDeviceProperties,     putDeviceProperties,     deleteDeviceProperties,-    HaskellTangoDevState (Alarm, Close, Disable, Extract, Fault, Init, Insert, Moving, Off, On, Open, Running, Standby, Unknown),+    DeviceState (..),      -- * Events     subscribeEvent,@@ -266,9 +279,10 @@ import Data.Function (const, id, ($), (.)) import Data.Functor (Functor, (<$>)) import Data.Int (Int, Int16, Int32, Int64)-import Data.List (drop, head, length, splitAt)+import Data.List (drop, head, length)+import Data.List.NonEmpty qualified as NE import Data.Maybe (Maybe (Just, Nothing))-import Data.Ord ((>))+import Data.Ord (Ord, (>)) import Data.Semigroup ((<>)) import Data.Text (Text, intercalate, isPrefixOf, null, pack, splitOn, unpack) import Data.Traversable (traverse)@@ -279,21 +293,22 @@ import Foreign.Ptr (Ptr, nullPtr) import System.IO (IO) import Tango.Raw.Common-  ( DatabaseProxyPtr,+  ( AttrWriteType,+    DataFormat (FormatImage, FormatScalar, FormatSpectrum),+    DatabaseProxyPtr,     DevFailed (DevFailed, devFailedDesc, devFailedOrigin, devFailedReason, devFailedSeverity),     DeviceProxyPtr,+    DeviceState (StateAlarm, StateClose, StateDisable, StateExtract, StateFault, StateInit, StateInsert, StateMoving, StateOff, StateOn, StateOpen, StateRunning, StateStandby, StateUnknown),+    DisplayLevel,     EventType,-    HaskellAttrWriteType,     HaskellAttributeData (HaskellAttributeData, dataFormat, dataQuality, dataType, dimX, dimY, name, nbRead, tangoAttributeData, timeStamp),     HaskellAttributeInfoList (HaskellAttributeInfoList, attributeInfoListLength, attributeInfoListSequence),     HaskellCommandData (HaskellCommandData, tangoCommandData),     HaskellCommandInfo (HaskellCommandInfo, cmdDisplayLevel, cmdInType, cmdInTypeDesc, cmdName, cmdOutType, cmdOutTypeDesc, cmdTag),     HaskellCommandInfoList (HaskellCommandInfoList, commandInfoLength, commandInfoSequence),-    HaskellDataFormat (HaskellImage, HaskellScalar, HaskellSpectrum),     HaskellDataQuality (HaskellValid),     HaskellDbData (HaskellDbData, dbDataLength, dbDataSequence),     HaskellDbDatum (HaskellDbDatum, dbDatumIsEmpty, dbDatumPropData, dbDatumPropertyName, dbDatumWrongDataType),-    HaskellDispLevel,     HaskellErrorStack (errorStackLength, errorStackSequence),     HaskellTangoAttributeData       ( HaskellAttributeDataBoolArray,@@ -309,11 +324,10 @@         HaskellAttributeDataUShortArray       ),     HaskellTangoCommandData (HaskellCommandBool, HaskellCommandCString, HaskellCommandDevEnum, HaskellCommandDevState, HaskellCommandDouble, HaskellCommandFloat, HaskellCommandInt32, HaskellCommandLong64, HaskellCommandShort, HaskellCommandULong64, HaskellCommandUShort, HaskellCommandVarBool, HaskellCommandVarCString, HaskellCommandVarDevState, HaskellCommandVarDouble, HaskellCommandVarFloat, HaskellCommandVarLong, HaskellCommandVarLong64, HaskellCommandVarShort, HaskellCommandVarULong, HaskellCommandVarULong64, HaskellCommandVarUShort, HaskellCommandVoid),-    HaskellTangoDataType (HaskellDevBoolean, HaskellDevDouble, HaskellDevEnum, HaskellDevFloat, HaskellDevInt, HaskellDevLong, HaskellDevLong64, HaskellDevShort, HaskellDevState, HaskellDevString, HaskellDevULong, HaskellDevULong64, HaskellDevUShort, HaskellDevVarBooleanArray, HaskellDevVarDoubleArray, HaskellDevVarFloatArray, HaskellDevVarLong64Array, HaskellDevVarLongArray, HaskellDevVarShortArray, HaskellDevVarStateArray, HaskellDevVarStringArray, HaskellDevVarULong64Array, HaskellDevVarULongArray, HaskellDevVarUShortArray, HaskellDevVoid),-    HaskellTangoDevState (Alarm, Close, Disable, Extract, Fault, Init, Insert, Moving, Off, On, Open, Running, Standby, Unknown),     HaskellTangoPropertyData (HaskellPropStringArray),     HaskellTangoVarArray (HaskellTangoVarArray, varArrayLength, varArrayValues),     TangoAttrMemorizedType (Memorized, MemorizedWriteInit, None, NotKnown),+    TangoDataType (HaskellDevBoolean, HaskellDevDouble, HaskellDevEnum, HaskellDevFloat, HaskellDevInt, HaskellDevLong, HaskellDevLong64, HaskellDevShort, HaskellDevState, HaskellDevString, HaskellDevULong, HaskellDevULong64, HaskellDevUShort, HaskellDevVarBooleanArray, HaskellDevVarDoubleArray, HaskellDevVarFloatArray, HaskellDevVarLong64Array, HaskellDevVarLongArray, HaskellDevVarShortArray, HaskellDevVarStateArray, HaskellDevVarStringArray, HaskellDevVarULong64Array, HaskellDevVarULongArray, HaskellDevVarUShortArray, HaskellDevVoid),     Timeval (Timeval),     createEventCallbackWrapper,     tango_command_inout,@@ -353,11 +367,11 @@     tango_unsubscribe_event,     tango_write_attribute,   )-import qualified Tango.Raw.Common as RawCommon+import Tango.Raw.Common qualified as RawCommon import Text.Show (Show, show) import UnliftIO (MonadUnliftIO, bracket, finally, withRunInIO) import UnliftIO.Foreign (CBool, CDouble, CFloat, CLong, CShort, CULong, CUShort, alloca, free, new, newArray, newCString, peek, peekArray, peekCString, with, withArray, withCString)-import Prelude (Bounded, Double, Enum (fromEnum, toEnum), Float, Fractional, Integral, Num ((*)), Real, error, fromIntegral, realToFrac)+import Prelude (Double, Enum (fromEnum, toEnum), Float, Fractional, Integral, Num ((*)), Real, error, fromIntegral, realToFrac)  -- | This wraps the Tango exception trace in Haskell newtype TangoException = TangoException [DevFailed Text] deriving (Show)@@ -388,7 +402,7 @@     throw (TangoException formattedStackItems)  -- | Newtype wrapper around a Tango URL like @tango:\/\/host:port\/foo\/bar\/baz@. Retrieve via 'parseTangoUrl'-newtype TangoUrl = TangoUrl Text+newtype TangoUrl = TangoUrl Text deriving (Show, Eq, Ord)  -- | Try to parse a Tango URL like @tango:\/\/host:port\/foo\/bar\/baz@ (the left side of the @Either@ will be an error message) parseTangoUrl :: Text -> Either Text TangoUrl@@ -449,7 +463,7 @@   DeviceProxy ->   AttributeName ->   tangoType ->-  HaskellTangoDataType ->+  TangoDataType ->   (HaskellTangoVarArray tangoType -> HaskellTangoAttributeData) ->   m () writeScalarAttribute (DeviceProxy proxyPtr) (AttributeName attributeName) newValue tangoType intract = do@@ -457,7 +471,7 @@     with newValue $ \newValuePtr ->       with         ( HaskellAttributeData-            { dataFormat = HaskellScalar,+            { dataFormat = FormatScalar,               dataQuality = HaskellValid,               nbRead = 0,               name = attributeNamePtr,@@ -475,7 +489,7 @@   DeviceProxy ->   AttributeName ->   [tangoType] ->-  HaskellTangoDataType ->+  TangoDataType ->   (HaskellTangoVarArray tangoType -> HaskellTangoAttributeData) ->   m () writeSpectrumAttribute (DeviceProxy proxyPtr) (AttributeName attributeName) newValues tangoType intract =@@ -483,7 +497,7 @@     withArray newValues \newValuesPtr ->       with         ( HaskellAttributeData-            { dataFormat = HaskellSpectrum,+            { dataFormat = FormatSpectrum,               dataQuality = HaskellValid,               nbRead = 0,               name = attributeNamePtr,@@ -501,7 +515,7 @@   DeviceProxy ->   AttributeName ->   Image tangoType ->-  HaskellTangoDataType ->+  TangoDataType ->   (HaskellTangoVarArray tangoType -> HaskellTangoAttributeData) ->   m () writeImageAttribute (DeviceProxy proxyPtr) (AttributeName attributeName) newImage tangoType intract =@@ -509,7 +523,7 @@     withArray (imageContent newImage) \newValuesPtr ->       with         ( HaskellAttributeData-            { dataFormat = HaskellImage,+            { dataFormat = FormatImage,               dataQuality = HaskellValid,               nbRead = 0,               name = attributeNamePtr,@@ -733,17 +747,17 @@   writeImageAttribute proxy attributeName (realToFrac <$> newImage) HaskellDevDouble HaskellAttributeDataDoubleArray  -- | Write a state scalar attribute-writeStateAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> HaskellTangoDevState -> m ()+writeStateAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> DeviceState -> m () writeStateAttribute proxy attributeName newValue =   writeScalarAttribute proxy attributeName newValue HaskellDevState HaskellAttributeDataStateArray  -- | Write a state spectrum attribute-writeStateSpectrumAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> [HaskellTangoDevState] -> m ()+writeStateSpectrumAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> [DeviceState] -> m () writeStateSpectrumAttribute proxy attributeName newValues =   writeSpectrumAttribute proxy attributeName newValues HaskellDevState HaskellAttributeDataStateArray  -- | Write a state image attribute-writeStateImageAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> Image HaskellTangoDevState -> m ()+writeStateImageAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> Image DeviceState -> m () writeStateImageAttribute proxy attributeName newImage =   writeImageAttribute proxy attributeName newImage HaskellDevState HaskellAttributeDataStateArray @@ -770,7 +784,7 @@       with newValuePtr \newValuePtrPtr ->         with           ( HaskellAttributeData-              { dataFormat = HaskellScalar,+              { dataFormat = FormatScalar,                 dataQuality = HaskellValid,                 nbRead = 0,                 name = attributeNameC,@@ -791,7 +805,7 @@       withArray stringPointerList \stringPointerPtr ->         with           ( HaskellAttributeData-              { dataFormat = HaskellSpectrum,+              { dataFormat = FormatSpectrum,                 dataQuality = HaskellValid,                 nbRead = 0,                 name = attributeNameC,@@ -812,7 +826,7 @@       withArray stringPointerList \stringPointerPtr ->         with           ( HaskellAttributeData-              { dataFormat = HaskellSpectrum,+              { dataFormat = FormatSpectrum,                 dataQuality = HaskellValid,                 nbRead = 0,                 name = attributeNameC,@@ -871,78 +885,77 @@         Just v ->           pure v -data AtLeastTwo a = AtLeastTwo a a [a]- -- | Call 'withExtractedAttributeValue' to read an attribute's value (safely), extract the array within, and call a function that makes the parsed contents into something more useful. readAttributeSimple ::   (Storable a, Show a, MonadUnliftIO m) =>   -- | Extract a specific type of data array (usually extracting a single data type like bool, long, ...)   (HaskellTangoAttributeData -> Maybe (HaskellTangoVarArray a)) ->   -- | After taking at least two elements from the array given by the previous function, call this function and turn the whole thing into something useful-  (HaskellAttributeData -> AtLeastTwo a -> m b) ->+  (HaskellAttributeData -> NE.NonEmpty a -> m b) ->   DeviceProxy ->   AttributeName ->   m b readAttributeSimple extractValue convertValue proxy attributeName = withExtractedAttributeValue (\d -> pure ((d,) <$> extractValue (tangoAttributeData d))) proxy attributeName \(attributeData, tangoArray) -> do   arrayElements <- peekArray (fromIntegral (varArrayLength tangoArray)) (varArrayValues tangoArray)   case arrayElements of-    (first : second : rest) -> convertValue attributeData (AtLeastTwo first second rest)-    _ -> error $ "couldn't read attribute " <> show attributeName <> ": expected a value array of length at least two, but got " <> show arrayElements+    (first : rest) -> convertValue attributeData (first NE.:| rest)+    _ -> error $ "couldn't read attribute " <> show attributeName <> ": expected a non-empty value array, but got " <> show arrayElements  readAttributeSimple' ::   (MonadIO m, Show a) =>   (HaskellTangoAttributeData -> IO (Maybe [a])) ->-  (HaskellAttributeData -> AtLeastTwo a -> m b) ->+  (HaskellAttributeData -> NE.NonEmpty a -> m b) ->   DeviceProxy ->   AttributeName ->   m b readAttributeSimple' extractValue convertValue proxy attributeName = do   (attributeData, tangoArray) <- readAttributeGeneral (\d -> ((d,) <$>) <$> extractValue (tangoAttributeData d)) proxy attributeName   case tangoArray of-    (first : second : rest) -> convertValue attributeData (AtLeastTwo first second rest)-    _ -> error $ "couldn't read attribute " <> show attributeName <> ": expected a value array of length at least two, but got " <> show tangoArray+    (first : rest) -> convertValue attributeData (first NE.:| rest)+    _ -> error $ "couldn't read attribute " <> show attributeName <> ": expected a non-empty value array, but got " <> show tangoArray -convertGenericScalar :: (Applicative f) => (a -> b) -> HaskellAttributeData -> AtLeastTwo a -> f (TangoValue b)-convertGenericScalar f _ (AtLeastTwo first second _) = pure (TangoValue (f first) (f second))+convertGenericScalar :: (Applicative f) => (a -> b) -> HaskellAttributeData -> NE.NonEmpty a -> f (TangoValue b)+convertGenericScalar f _ (first NE.:| []) = pure (TangoValue (f first) Nothing)+convertGenericScalar f _ (first NE.:| (second : _)) = pure (TangoValue (f first) (Just (f second))) -convertGenericSpectrum :: (Applicative f) => (a -> b) -> HaskellAttributeData -> AtLeastTwo a -> f (TangoValue [b])-convertGenericSpectrum f (HaskellAttributeData {dimX}) (AtLeastTwo first second remainder) =-  let wholeList = f <$> (first : second : remainder)-      (readValue, writeValue) = splitAt (fromIntegral dimX) wholeList-   in pure (TangoValue readValue writeValue)+convertGenericSpectrum :: (Applicative f) => (a -> b) -> HaskellAttributeData -> NE.NonEmpty a -> f (TangoValue [b])+convertGenericSpectrum f (HaskellAttributeData {dimX}) data' =+  let wholeList = f <$> data'+      (readValue, writeValue) = NE.splitAt (fromIntegral dimX) wholeList+   in pure (TangoValue readValue (Just writeValue)) -convertGenericSpectrum' :: (Applicative f) => HaskellAttributeData -> AtLeastTwo a -> f (TangoValue [a])-convertGenericSpectrum' (HaskellAttributeData {dimX}) (AtLeastTwo first second remainder) =-  let wholeList = first : second : remainder-      (readValue, writeValue) = splitAt (fromIntegral dimX) wholeList-   in pure (TangoValue readValue writeValue)+convertGenericSpectrum' :: (Applicative f) => HaskellAttributeData -> NE.NonEmpty a -> f (TangoValue [a])+convertGenericSpectrum' (HaskellAttributeData {dimX}) data' =+  let wholeList = data'+      (readValue, writeValue) = NE.splitAt (fromIntegral dimX) wholeList+   in pure (TangoValue readValue (Just writeValue)) -convertGenericImage :: (Applicative f) => (a1 -> a2) -> HaskellAttributeData -> AtLeastTwo a1 -> f (TangoValue (Image a2))-convertGenericImage f (HaskellAttributeData {dimX, dimY}) (AtLeastTwo first second remainder) =-  let wholeList = f <$> (first : second : remainder)-      (readValue, writeValue) = splitAt (fromIntegral (dimX * dimY)) wholeList+convertGenericImage :: (Applicative f) => (a1 -> a2) -> HaskellAttributeData -> NE.NonEmpty a1 -> f (TangoValue (Image a2))+convertGenericImage f (HaskellAttributeData {dimX, dimY}) data' =+  let wholeList = f <$> data'+      (readValue, writeValue) = NE.splitAt (fromIntegral (dimX * dimY)) wholeList    in pure         ( TangoValue             (Image readValue (fromIntegral dimX) (fromIntegral dimY))-            (Image writeValue (fromIntegral dimX) (fromIntegral dimY))+            (Just (Image writeValue (fromIntegral dimX) (fromIntegral dimY)))         ) -convertGenericImage' :: (Applicative f) => HaskellAttributeData -> AtLeastTwo a1 -> f (TangoValue (Image a1))-convertGenericImage' (HaskellAttributeData {dimX, dimY}) (AtLeastTwo first second remainder) =-  let wholeList = first : second : remainder-      (readValue, writeValue) = splitAt (fromIntegral (dimX * dimY)) wholeList+convertGenericImage' :: (Applicative f) => HaskellAttributeData -> NE.NonEmpty a1 -> f (TangoValue (Image a1))+convertGenericImage' (HaskellAttributeData {dimX, dimY}) data' =+  let wholeList = data'+      (readValue, writeValue) = NE.splitAt (fromIntegral (dimX * dimY)) wholeList    in pure         ( TangoValue             (Image readValue (fromIntegral dimX) (fromIntegral dimY))-            (Image writeValue (fromIntegral dimX) (fromIntegral dimY))+            (Just (Image writeValue (fromIntegral dimX) (fromIntegral dimY)))         )  -- | Represents an attribute's value, with read and write part, for different data types. Fields for quality etc. are currently missing data TangoValue a = TangoValue   { -- | Read part of the attribute's value     tangoValueRead :: a,-    -- | Write part of the attribute's value-    tangoValueWrite :: a+    -- | Write part of the attribute's value; this can be missing!+    tangoValueWrite :: Maybe a   }   deriving (Show) @@ -1018,8 +1031,9 @@   where     extract (HaskellAttributeDataStringArray a) = Just a     extract _ = Nothing-    convert _ (AtLeastTwo read write []) = TangoValue <$> peekCStringText read <*> peekCStringText write-    convert _ _ = error "expected a read and a write value for attribute, got more elements"+    convert _ (read NE.:| [write]) = TangoValue <$> peekCStringText read <*> (Just <$> peekCStringText write)+    convert _ (read NE.:| []) = TangoValue <$> peekCStringText read <*> pure Nothing+    convert _ _ = error "expected a read and an optional write value for attribute, got something else"  -- | Read a string spectrum (array/list) attribute and decode it into a text readStringSpectrumAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue [Text])@@ -1027,10 +1041,10 @@   where     extract (HaskellAttributeDataStringArray a) = Just a     extract _ = Nothing-    convert (HaskellAttributeData {dimX}) (AtLeastTwo first second remainder) = do-      wholeList <- traverse peekCStringText (first : second : remainder)-      let (readValue, writeValue) = splitAt (fromIntegral dimX) wholeList-      pure (TangoValue readValue writeValue)+    convert (HaskellAttributeData {dimX}) data' = do+      wholeList <- traverse peekCStringText data'+      let (readValue, writeValue) = NE.splitAt (fromIntegral dimX) wholeList+      pure (TangoValue readValue (Just writeValue))  -- | Read a string image attribute and decode it into a text readStringImageAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue (Image Text))@@ -1038,13 +1052,13 @@   where     extract (HaskellAttributeDataStringArray a) = Just a     extract _ = Nothing-    convert (HaskellAttributeData {dimX, dimY}) (AtLeastTwo first second remainder) = do-      wholeList <- traverse peekCStringText (first : second : remainder)-      let (readValue, writeValue) = splitAt (fromIntegral (dimX * dimY)) wholeList+    convert (HaskellAttributeData {dimX, dimY}) data' = do+      wholeList <- traverse peekCStringText data'+      let (readValue, writeValue) = NE.splitAt (fromIntegral (dimX * dimY)) wholeList       pure         ( TangoValue             (Image readValue (fromIntegral dimX) (fromIntegral dimY))-            (Image writeValue (fromIntegral dimX) (fromIntegral dimY))+            (Just (Image writeValue (fromIntegral dimX) (fromIntegral dimY)))         )  extractShort :: HaskellTangoAttributeData -> Maybe (HaskellTangoVarArray CShort)@@ -1175,20 +1189,20 @@ readDoubleImageAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue (Image Double)) readDoubleImageAttribute = readAttributeSimple extractDouble (convertGenericImage realToFrac) -extractState :: HaskellTangoAttributeData -> Maybe (HaskellTangoVarArray HaskellTangoDevState)+extractState :: HaskellTangoAttributeData -> Maybe (HaskellTangoVarArray DeviceState) extractState (HaskellAttributeDataStateArray a) = Just a extractState _ = Nothing  -- | Read a state-type scalar attribute, fail hard if it's not really a state-readStateAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue HaskellTangoDevState)+readStateAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue DeviceState) readStateAttribute = readAttributeSimple extractState (convertGenericScalar id)  -- | Read a state-type spectrum (list) attribute, fail hard if it's not really a state type-readStateSpectrumAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue [HaskellTangoDevState])+readStateSpectrumAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue [DeviceState]) readStateSpectrumAttribute = readAttributeSimple extractState (convertGenericSpectrum id)  -- | Read a state-type image attribute, fail hard if it's not really a state-readStateImageAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue (Image HaskellTangoDevState))+readStateImageAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m (TangoValue (Image DeviceState)) readStateImageAttribute = readAttributeSimple extractState (convertGenericImage id)  extractEnum :: HaskellTangoAttributeData -> Maybe (HaskellTangoVarArray CShort)@@ -1225,7 +1239,7 @@   | CommandFloat !Float   | CommandDouble !Double   | CommandString !Text-  | CommandState !HaskellTangoDevState+  | CommandState !DeviceState   | CommandEnum !Int16   | CommandListBool ![Bool]   | CommandListShort ![Int16]@@ -1237,7 +1251,7 @@   | CommandListFloat ![Float]   | CommandListDouble ![Double]   | CommandListString ![Text]-  | CommandListState ![HaskellTangoDevState]+  | CommandListState ![DeviceState]   deriving (Show)  -- | Execute command with no input and no output@@ -1410,9 +1424,9 @@  -- | Information for a single attribute (for spectrum and images as well, see the dimensions) data AttributeInfo = AttributeInfo-  { attributeInfoWritable :: !HaskellAttrWriteType,-    attributeInfoDataFormat :: !HaskellDataFormat,-    attributeInfoDataType :: !HaskellTangoDataType,+  { attributeInfoWritable :: !AttrWriteType,+    attributeInfoDataFormat :: !DataFormat,+    attributeInfoDataType :: !TangoDataType,     attributeInfoMaxDimX :: !Int,     attributeInfoMaxDimY :: !Int,     attributeInfoDescription :: !Text,@@ -1426,7 +1440,7 @@     attributeInfoMinAlarm :: !Text,     attributeInfoMaxAlarm :: !Text,     attributeInfoWritableAttrName :: !Text,-    attributeInfoDispLevel :: !HaskellDispLevel,+    attributeInfoDispLevel :: !DisplayLevel,     attributeInfoEnumLabels :: [Text],     -- | Root attribute name (in case of forwarded attribute)     attributeInfoRootAttrName :: Text,@@ -1643,15 +1657,12 @@ stopPollAttribute :: (MonadUnliftIO m) => DeviceProxy -> AttributeName -> m () stopPollAttribute (DeviceProxy proxy) (AttributeName attributeName) = liftIO $ withCStringText attributeName (checkResult . tango_stop_poll_attribute proxy) --- | Where to display this command (in Jive, for example)-data DisplayLevel = Operator | Expert deriving (Show, Enum, Bounded, Eq)- -- | All information Tango has on a command data CommandInfo = CommandInfo   { commandInfoName :: !Text,     commandInfoTag :: !Int,-    commandInfoInType :: !HaskellTangoDataType,-    commandInfoOutType :: !HaskellTangoDataType,+    commandInfoInType :: !TangoDataType,+    commandInfoOutType :: !TangoDataType,     commandInfoInTypeDesc :: !Text,     commandInfoOutTypeDesc :: !Text,     commandInfoDisplayLevel :: !DisplayLevel

@@ -11,12 +11,12 @@ -- | -- Description : Low-level interface to all Tango functions module Tango.Raw.Common-  ( HaskellTangoDevState (..),-    HaskellDispLevel (..),+  ( DeviceState (..),+    DisplayLevel (..),     HaskellTangoPropertyData (..),     HaskellTangoDevEncoded (..),     EventType (..),-    HaskellAttrWriteType (..),+    AttrWriteType (..),     ErrSeverity (..),     DatabaseProxyPtr,     HaskellDataQuality (..),@@ -25,7 +25,7 @@     HaskellAttributeInfoList (..),     HaskellAttributeDataList (..),     HaskellAttributeInfo (..),-    HaskellDataFormat (..),+    DataFormat (..),     HaskellTangoVarArray (..),     Timeval (..),     DeviceProxyPtr,@@ -35,7 +35,7 @@     TangoAttrMemorizedType (..),     HaskellAttributeData (..),     HaskellCommandData (..),-    HaskellTangoDataType (..),+    TangoDataType (..),     HaskellTangoCommandData (..),     HaskellCommandInfoList (..),     HaskellCommandInfo (..),@@ -140,24 +140,24 @@     Just v -> poke @CInt (castPtr ptr) v  -- | List of all states that Tango knows about for device servers-data HaskellTangoDevState-  = On-  | Off-  | Close-  | Open-  | Insert-  | Extract-  | Moving-  | Standby-  | Fault-  | Init-  | Running-  | Alarm-  | Disable-  | Unknown+data DeviceState+  = StateOn+  | StateOff+  | StateClose+  | StateOpen+  | StateInsert+  | StateExtract+  | StateMoving+  | StateStandby+  | StateFault+  | StateInit+  | StateRunning+  | StateAlarm+  | StateDisable+  | StateUnknown   deriving (Show, Eq, Bounded, Enum) -instance Storable HaskellTangoDevState where+instance Storable DeviceState where   sizeOf _ = (# size TangoDevState)   alignment _ = (# alignment TangoDevState)   peek = peekBounded "dev state"@@ -214,7 +214,7 @@   | HaskellCommandDouble !CDouble   | HaskellCommandCString !CString   | HaskellCommandLong64 !CLong-  | HaskellCommandDevState !HaskellTangoDevState+  | HaskellCommandDevState !DeviceState   | HaskellCommandULong64 !CULong   | HaskellCommandDevEncoded !HaskellTangoDevEncoded   | HaskellCommandDevEnum !CTangoEnum@@ -229,7 +229,7 @@   | HaskellCommandVarFloat !(HaskellTangoVarArray CFloat)   | HaskellCommandVarDouble !(HaskellTangoVarArray CDouble)   | HaskellCommandVarCString !(HaskellTangoVarArray CString)-  | HaskellCommandVarDevState !(HaskellTangoVarArray HaskellTangoDevState)+  | HaskellCommandVarDevState !(HaskellTangoVarArray DeviceState)   | HaskellCommandLongStringArray !HaskellVarLongStringArray   | HaskellCommandDoubleStringArray !HaskellVarDoubleStringArray   deriving (Show)@@ -247,7 +247,7 @@   | HaskellAttributeDataFloatArray !(HaskellTangoVarArray CFloat)   | HaskellAttributeDataDoubleArray !(HaskellTangoVarArray CDouble)   | HaskellAttributeDataStringArray !(HaskellTangoVarArray CString)-  | HaskellAttributeDataStateArray !(HaskellTangoVarArray HaskellTangoDevState)+  | HaskellAttributeDataStateArray !(HaskellTangoVarArray DeviceState)   | HaskellAttributeDataEncodedArray !(HaskellTangoVarArray HaskellTangoDevEncoded)   deriving (Show) @@ -277,7 +277,7 @@  -- | Haskell mapping for the C type TangoDataType -- Beware: this is encoded positionally!-data HaskellTangoDataType+data TangoDataType   = HaskellDevVoid   | HaskellDevBoolean   | HaskellDevShort@@ -314,7 +314,7 @@   | HaskellDevVarEncodedArray   deriving (Show, Eq, Ord, Bounded, Enum) -instance Storable HaskellTangoDataType where+instance Storable TangoDataType where   sizeOf _ = (# size TangoDataType)   alignment _ = (# alignment TangoDataType)   peek = peekBounded "data type"@@ -348,28 +348,28 @@   peek = peekBounded "event type"   poke = pokeBounded "event type" -data HaskellDataFormat-  = HaskellScalar-  | HaskellSpectrum-  | HaskellImage+data DataFormat+  = FormatScalar+  | FormatSpectrum+  | FormatImage   deriving (Show) -instance Storable HaskellDataFormat where+instance Storable DataFormat where   sizeOf _ = (# size AttrDataFormat)   alignment _ = (# alignment AttrDataFormat)   peek ptr = do     value :: CInt <- peek (castPtr ptr)     case value of-      0 -> pure HaskellScalar-      1 -> pure HaskellSpectrum-      _ -> pure HaskellImage+      0 -> pure FormatScalar+      1 -> pure FormatSpectrum+      _ -> pure FormatImage   poke ptr x =     poke @CInt       (castPtr ptr)       ( case x of-          HaskellScalar -> 0-          HaskellSpectrum -> 1-          HaskellImage -> 2+          FormatScalar -> 0+          FormatSpectrum -> 1+          FormatImage -> 2       )  data HaskellDataQuality@@ -398,9 +398,9 @@     (# poke struct timeval, tv_sec) ptr tvSec'     (# poke struct timeval, tv_usec) ptr tvUsec' -data HaskellAttrWriteType = Read | ReadWithWrite | Write | ReadWrite deriving (Show)+data AttrWriteType = Read | ReadWithWrite | Write | ReadWrite deriving (Show) -instance Storable HaskellAttrWriteType where+instance Storable AttrWriteType where   sizeOf _ = (# size AttrWriteType)   alignment _ = (# alignment AttrWriteType)   peek ptr = do@@ -420,9 +420,9 @@           ReadWrite -> 3       ) -data HaskellDispLevel = Operator | Expert deriving (Show, Eq)+data DisplayLevel = Operator | Expert deriving (Show, Eq, Enum) -instance Storable HaskellDispLevel where+instance Storable DisplayLevel where   sizeOf _ = (# size DispLevel)   alignment _ = (# alignment DispLevel)   peek ptr = do@@ -489,9 +489,9 @@  data HaskellAttributeInfo = HaskellAttributeInfo   { attributeInfoName :: !CString,-    attributeInfoWritable :: !HaskellAttrWriteType,-    attributeInfoDataFormat :: !HaskellDataFormat,-    attributeInfoDataType :: !HaskellTangoDataType,+    attributeInfoWritable :: !AttrWriteType,+    attributeInfoDataFormat :: !DataFormat,+    attributeInfoDataType :: !TangoDataType,     attributeInfoMaxDimX :: !Int32,     attributeInfoMaxDimY :: !Int32,     attributeInfoDescription :: !CString,@@ -505,7 +505,7 @@     attributeInfoMinAlarm :: !CString,     attributeInfoMaxAlarm :: !CString,     attributeInfoWritableAttrName :: !CString,-    attributeInfoDispLevel :: !HaskellDispLevel,+    attributeInfoDispLevel :: !DisplayLevel,     attributeInfoEnumLabels :: !(Ptr CString),     attributeInfoEnumLabelsCount :: !Word16,     attributeInfoRootAttrName :: !CString,@@ -519,26 +519,26 @@   { dbDatumPropertyName :: !CString,     dbDatumIsEmpty :: !Bool,     dbDatumWrongDataType :: !Bool,-    dbDatumDataType :: !HaskellTangoDataType,+    dbDatumDataType :: !TangoDataType,     dbDatumPropData :: !HaskellTangoPropertyData   }   deriving (Show)  data HaskellAttributeData = HaskellAttributeData-  { dataFormat :: !HaskellDataFormat,+  { dataFormat :: !DataFormat,     dataQuality :: !HaskellDataQuality,     nbRead :: !CLong,     name :: !CString,     dimX :: !Int32,     dimY :: !Int32,     timeStamp :: !Timeval,-    dataType :: !HaskellTangoDataType,+    dataType :: !TangoDataType,     tangoAttributeData :: !HaskellTangoAttributeData   }   deriving (Show)  data HaskellCommandData = HaskellCommandData-  { argType :: !HaskellTangoDataType,+  { argType :: !TangoDataType,     tangoCommandData :: !HaskellTangoCommandData   }   deriving (Show)