code
stringlengths 5
1.03M
| repo_name
stringlengths 5
90
| path
stringlengths 4
158
| license
stringclasses 15
values | size
int64 5
1.03M
| n_ast_errors
int64 0
53.9k
| ast_max_depth
int64 2
4.17k
| n_whitespaces
int64 0
365k
| n_ast_nodes
int64 3
317k
| n_ast_terminals
int64 1
171k
| n_ast_nonterminals
int64 1
146k
| loc
int64 -1
37.3k
| cycloplexity
int64 -1
1.31k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|
module Import.File where
import Prelude
import Yesod
import Data.Text (Text, unpack, pack)
import qualified Data.Text as T
import System.FilePath ((</>))
import Data.Char (isPrint, toLower)
import ModelTypes
-- | List of files types which have thumbnails
thumbFileTypes :: [FileType]
thumbFileTypes = [FileVideo, FileImage] --, FileSource, FileDoc] TODO: thumbnails for docs and source files
sanitizeFileName :: String -> String
sanitizeFileName = filter (\x -> x `notElem` ("\\/"::String) && isPrint x)
fileExt :: FileInfo -> String
fileExt = map toLower . reverse . takeWhile (/='.') . reverse . sanitizeFileName . unpack . fileName
extractFileExt :: String -> String
extractFileExt = map toLower . reverse . takeWhile (/='.') . reverse
-------------------------------------------------------------------------------------------------------------------
-- Paths
-------------------------------------------------------------------------------------------------------------------
geoIconPath :: String -> Text -> Text
geoIconPath staticDir code = pack $ "/" </> staticDir </> "geoicons" </> (unpack $ (T.toLower code) <> ".png")
captchaFilePath :: String -> String -> String
captchaFilePath staticDir file = staticDir </> "captcha" </> file
-- Thumbnails
choseFileIcon :: FileType -> String
choseFileIcon ft = case ft of
FileAudio -> "audio"
FileFlash -> "flash"
FileArchive -> "archive"
FileUndetected -> "default"
_ -> "default"
thumbIconExt :: String
thumbIconExt = "png"
thumbDirectory :: FilePath
thumbDirectory = "thumb"
thumbUrlPath :: String -> String -> Int -> FileType -> String -> String -> Bool -> FilePath
thumbUrlPath uploadDir staticDir size filetype fileext hashsum onion = "/" </>
(thumbFilePath (if onion then uploadDir </> "onion" else uploadDir) staticDir size filetype fileext hashsum)
thumbFilePath :: String -> String -> Int -> FileType -> String -> String -> FilePath
thumbFilePath uploadDir staticDir size filetype fileext hashsum
| filetype == FileVideo = uploadDir </> thumbDirectory </> (show size ++ "thumb-" ++ hashsum ++ ".png")
| filetype `elem` thumbFileTypes = uploadDir </> thumbDirectory </> (show size ++ "thumb-" ++ hashsum ++ "." ++ fileext)
| otherwise = staticDir </> "fileicons" </> ((choseFileIcon filetype) ++ "." ++ thumbIconExt)
| ahushh/Monaba | monaba/src/Import/File.hs | mit | 2,415 | 0 | 12 | 444 | 627 | 340 | 287 | 39 | 5 |
module CFDI.Types.ConceptTaxes where
import CFDI.Chainable
import CFDI.Types.ConceptRetainedTaxes
import CFDI.Types.ConceptTransferedTaxes
import CFDI.XmlNode
import Data.Maybe (catMaybes)
data ConceptTaxes = ConceptTaxes
{ conceptRetainedTaxes :: Maybe ConceptRetainedTaxes
, conceptTransferedTaxes :: Maybe ConceptTransferedTaxes
} deriving (Eq, Show)
instance Chainable ConceptTaxes where
chain c = conceptTransferedTaxes
<@> conceptRetainedTaxes
<~> (c, "")
instance XmlNode ConceptTaxes where
children n = catMaybes
[ renderNode <$> conceptTransferedTaxes n
, renderNode <$> conceptRetainedTaxes n
]
nodeName = const "Impuestos"
parseNode n = ConceptTaxes
<$> parseChild "Retenciones" n
<*> parseChild "Traslados" n
| yusent/cfdis | src/CFDI/Types/ConceptTaxes.hs | mit | 802 | 0 | 9 | 161 | 180 | 97 | 83 | 22 | 0 |
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE Strict #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
-- | Geometry Scenario
--
-- The main structure in qua-view!
--
module Model.Scenario
( Scenario, Scenario' (..), getTransferables
, name, geoLoc, srid, properties, objects, objIdSeq, viewState, withoutObjects
, selectedDynamicColor, selectedStaticColor, selectedGroupColor
, defaultStaticColor
, defaultBlockColor, defaultLineColor, defaultPointColor
, defaultObjectHeight
, viewDistance, evaluationCellSize
, servicePluginsProp
, maxCameraDistance, minCameraDistance
, mapZoomLevel, mapOpacity, useMapLayer, mapUrl
, hiddenProperties
, resolvedObjectHeight, resolvedObjectColor
, resolvedObjectColorIgnoreVisible
, ScenarioState (..)
, cameraPos, cameraLoc, cameraLookAt, objectGroups, clippingDist, zoomLimits
, templates, forcedAreaObjId, groupIdSeq, creationPoint, servicePlugins
) where
import qualified Data.Map.Strict as Map
import qualified Data.Set as Set
import Control.Lens (set,(^.),non, _1, _2)
import Control.Applicative ((<|>))
import Numeric.DataFrame hiding (toList)
import Data.Foldable (toList)
import Data.Semigroup (stimesIdempotentMonoid)
import GHC.Generics
import Commons.NoReflex
import Model.Scenario.Properties
import Model.Scenario.ServicePlugin
import Model.Scenario.Object ( GroupId, ObjectId)
import qualified Model.Scenario.Object as Object
import qualified Model.Scenario.Object.Geometry as Geometry
type Scenario = Scenario' 'Object.Renderable
data Scenario' s
= Scenario
{ _name :: !(Maybe JSString)
-- ^ Friendly name for a scenario
, _geoLoc :: !(Maybe (Double, Double, Double))
-- ^ Longitude, Latitude, and Altitude of scenario reference point
, _srid :: !(Maybe Int)
-- ^ We can explicitly specify srid
, _properties :: !Properties
-- ^ key-value of arbitrary JSON properties
, _objects :: !(Object.Collection' s)
-- ^ Map with scenario content
, _objIdSeq :: !ObjectId
-- ^ Keep track of highest ObjectId to be able to generate more
, _viewState :: !ScenarioState
-- ^ Some necessary information for viewing and interacting with scenario
} deriving Generic
instance FromJSVal (Scenario' Object.Prepared)
instance ToJSVal (Scenario' Object.Prepared)
-- | Get transferable content of each scenario object
getTransferables :: Scenario' s -> IO [Transferable]
getTransferables = mapM Object.getTransferable . toList . _objects
-- | Get scenario with no Objects inside.
-- Used to send scenario information to a geometry loader,
-- so that geometry loader has scenario context.
withoutObjects :: Scenario' s -> Scenario' Object.Prepared
withoutObjects = set objects mempty
. set (viewState.objectGroups) mempty
-- * Lenses
name :: Functor f
=> (Maybe JSString -> f (Maybe JSString))
-> Scenario' s -> f (Scenario' s)
name f s = (\x -> s{_name = x}) <$> f (_name s)
geoLoc :: Functor f
=> (Maybe (Double, Double, Double) -> f (Maybe (Double, Double, Double)))
-> Scenario' s -> f (Scenario' s)
geoLoc f s = (\x -> s{_geoLoc = x}) <$> f (_geoLoc s)
srid :: Functor f
=> (Maybe Int -> f (Maybe Int))
-> Scenario' s -> f (Scenario' s)
srid f s = (\x -> s{_srid = x}) <$> f (_srid s)
properties :: Functor f
=> (Properties -> f Properties)
-> Scenario' s -> f (Scenario' s)
properties f s = (\x -> s{_properties = x}) <$> f (_properties s)
objects :: Functor f
=> (Object.Collection' s -> f (Object.Collection' t))
-> Scenario' s -> f (Scenario' t)
objects f s = (\x -> s{_objects = x}) <$> f (_objects s)
objIdSeq :: Functor f
=> (ObjectId -> f ObjectId)
-> Scenario' s -> f (Scenario' s)
objIdSeq f s = (\x -> s{_objIdSeq = x}) <$> f (_objIdSeq s)
viewState :: Functor f
=> (ScenarioState -> f ScenarioState)
-> Scenario' s -> f (Scenario' s)
viewState f s = (\x -> s{_viewState = x}) <$> f (_viewState s)
instance Semigroup (Scenario' s) where
scOld <> scNew = Scenario
{ -- trying to update scenario name if it has changed
_name = _name scNew <|> _name scOld
-- keeping GeoLocation from older version
, _geoLoc = _geoLoc scOld <|> _geoLoc scNew
-- keeping SRID from older version
, _srid = _srid scOld <|> _srid scNew
-- prefer duplicate properties from a new version
, _properties = _properties scNew <> _properties scOld
-- replace older objects with newer ones
, _objects = _objects scNew <> _objects scOld
-- get maximum of objId counters to make sure
-- no objects could have the same object Id
, _objIdSeq = max (_objIdSeq scOld) (_objIdSeq scNew)
-- just get a new view state
, _viewState = _viewState scNew
}
stimes = stimesIdempotentMonoid
instance Monoid (Scenario' s) where
mempty = Scenario
{ _name = Nothing
, _geoLoc = Nothing
, _srid = Nothing
, _properties = mempty
, _objects = mempty
, _objIdSeq = Object.ObjectId 0
, _viewState = def
}
mappend = (<>)
instance Default (Scenario' s) where
def = mempty
-- * Special properties
defaultObjectHeight :: Functor f
=> (Double -> f Double) -> Scenario' s -> f (Scenario' s)
defaultObjectHeight f = properties $ property "defaultObjectHeight" g
where
g Nothing = Just <$> f 3.5
g (Just c) = Just <$> f c
selectedDynamicColor :: Functor f
=> (HexColor -> f HexColor) -> Scenario' s -> f (Scenario' s)
selectedDynamicColor f = properties $ property "selectedDynamicColor" g
where
g Nothing = Just <$> f "#FF6060FF"
g (Just c) = Just <$> f c
selectedGroupColor :: Functor f
=> (HexColor -> f HexColor) -> Scenario' s -> f (Scenario' s)
selectedGroupColor f = properties $ property "selectedGroupColor" g
where
g Nothing = Just <$> f "#CC8888E0"
g (Just c) = Just <$> f c
selectedStaticColor :: Functor f
=> (HexColor -> f HexColor) -> Scenario' s -> f (Scenario' s)
selectedStaticColor f = properties $ property "selectedStaticColor" g
where
g Nothing = Just <$> f "#BB8888FF"
g (Just c) = Just <$> f c
defaultStaticColor :: Functor f
=> (HexColor -> f HexColor) -> Scenario' s -> f (Scenario' s)
defaultStaticColor f = properties $ property "defaultStaticColor" g
where
g Nothing = Just <$> f "#808088E0"
g (Just c) = Just <$> f c
defaultBlockColor :: Functor f
=> (HexColor -> f HexColor) -> Scenario' s -> f (Scenario' s)
defaultBlockColor f = properties $ property "defaultBlockColor" g
where
g Nothing = Just <$> f "#C0C082FF"
g (Just c) = Just <$> f c
defaultLineColor :: Functor f
=> (HexColor -> f HexColor) -> Scenario' s -> f (Scenario' s)
defaultLineColor f = properties $ property "defaultLineColor" g
where
g Nothing = Just <$> f "#CC6666FF"
g (Just c) = Just <$> f c
defaultPointColor :: Functor f
=> (HexColor -> f HexColor) -> Scenario' s -> f (Scenario' s)
defaultPointColor f = properties $ property "defaultPointColor" g
where
g Nothing = Just <$> f "#006666FF"
g (Just c) = Just <$> f c
viewDistance :: Functor f
=> (Maybe Float -> f (Maybe Float)) -> Scenario' s -> f (Scenario' s)
viewDistance = properties . property "viewDistance"
maxCameraDistance :: Functor f
=> (Maybe Float -> f (Maybe Float)) -> Scenario' s -> f (Scenario' s)
maxCameraDistance = properties . property "maxCameraDistance"
minCameraDistance :: Functor f
=> (Maybe Float -> f (Maybe Float)) -> Scenario' s -> f (Scenario' s)
minCameraDistance = properties . property "minCameraDistance"
mapZoomLevel :: Functor f
=> (Int -> f Int) -> Scenario' s -> f (Scenario' s)
mapZoomLevel f = properties $ property "mapZoomLevel" g
where
g Nothing = Just <$> f 15
g (Just c) = Just <$> f c
mapOpacity :: Functor f
=> (Double -> f Double) -> Scenario' s -> f (Scenario' s)
mapOpacity f = properties $ property "mapOpacity" g
where
g Nothing = Just <$> f 0.8
g (Just c) = Just <$> f c
useMapLayer :: Functor f
=> (Bool -> f Bool) -> Scenario' s -> f (Scenario' s)
useMapLayer f = properties $ property "useMapLayer" g
where
g Nothing = Just <$> f False
g (Just c) = Just <$> f c
mapUrl :: Functor f
=> (JSString -> f JSString) -> Scenario' s -> f (Scenario' s)
mapUrl f = properties $ property "mapUrl" g
where
g Nothing = Just <$> f "https://a.tile.openstreetmap.org/${z}/${x}/${y}.png"
g (Just c) = Just <$> f c
hiddenProperties :: Functor f
=> ([JSString] -> f [JSString]) -> Scenario' s -> f (Scenario' s)
hiddenProperties f = properties $ property "hiddenProperties" g
where
g Nothing = Just <$> f [ "geomID", "groupID"
, "hiddenProperties", "viewColor"
, "height", "static", "selectable"
, "visible", "special"]
g (Just c) = Just <$> f c
evaluationCellSize :: Functor f
=> (Double -> f Double) -> Scenario' s -> f (Scenario' s)
evaluationCellSize f = properties $ property "evaluationCellSize" g
where
g Nothing = Just <$> f 5.0
g (Just c) = Just <$> f c
servicePluginsProp :: Functor f
=> ([ServicePlugin] -> f [ServicePlugin])
-> Scenario' s -> f (Scenario' s)
servicePluginsProp f = properties $ property "servicePlugins" g
where
g Nothing = nonEmpty <$> f []
g (Just c) = nonEmpty <$> f c
nonEmpty [] = Nothing
nonEmpty xs = Just xs
-- * Resolved properties
resolvedObjectColorIgnoreVisible :: Scenario' s -> Object.Object' t -> HexColor
resolvedObjectColorIgnoreVisible s o = o^.Object.viewColor.non sdef
where
sdef = case o^.Object.geometry of
Geometry.Points _ -> s^.defaultPointColor
Geometry.Lines _ -> s^.defaultLineColor
Geometry.Polygons _ -> case o^.Object.objectBehavior of
Object.Static -> s^.defaultStaticColor
Object.Dynamic -> s^.defaultBlockColor
-- | Resolve view color of object based on object and scenario properties.
resolvedObjectColor :: Scenario' s -> Object.Object' t -> HexColor
resolvedObjectColor s o
= if o^.Object.visible
then resolvedObjectColorIgnoreVisible s o
else "#00000000"
-- | Resolve object height to extrude it if necessary
resolvedObjectHeight :: Scenario' s -> Object.Object' t -> Double
resolvedObjectHeight s o = o^.Object.height.non (s^.defaultObjectHeight)
-- * Computed and updateable attributes
-- | Parsed settings for qua-view
data ScenarioState
= ScenarioState
{ _cameraPos :: !(Vec3f, Vec3f)
, _objectGroups :: !(Map.Map GroupId [ObjectId])
, _clippingDist :: !Float
, _zoomLimits :: !(Float, Float)
, _templates :: !(Set.Set (Either ObjectId GroupId))
, _forcedAreaObjId :: !(Maybe ObjectId)
, _groupIdSeq :: !GroupId
, _creationPoint :: !(Maybe Vec3f)
, _servicePlugins :: ![ServicePlugin]
} deriving Generic
instance FromJSVal ScenarioState
instance ToJSVal ScenarioState
instance FromJSVal (Either ObjectId GroupId)
instance ToJSVal (Either ObjectId GroupId)
instance FromJSVal (Set.Set (Either ObjectId GroupId)) where
fromJSVal = fmap (fmap Set.fromDistinctAscList) . fromJSVal
instance ToJSVal (Set.Set (Either ObjectId GroupId)) where
toJSVal = toJSVal . Set.toAscList
instance Default ScenarioState where
def = ScenarioState
{ _cameraPos = (vec3 100 150 500, 0)
, _objectGroups = mempty
, _clippingDist = 2000
, _zoomLimits = (1, 1334)
, _templates = mempty
, _forcedAreaObjId = Nothing
, _groupIdSeq = 0
, _creationPoint = Nothing
, _servicePlugins = []
}
cameraPos :: Functor f
=> ((Vec3f, Vec3f) -> f (Vec3f, Vec3f))
-> ScenarioState -> f ScenarioState
cameraPos f s = (\x -> s{_cameraPos = x}) <$> f (_cameraPos s)
cameraLoc :: Functor f
=> (Vec3f -> f Vec3f)
-> ScenarioState -> f ScenarioState
cameraLoc = cameraPos . _1
cameraLookAt :: Functor f
=> (Vec3f -> f Vec3f)
-> ScenarioState -> f ScenarioState
cameraLookAt = cameraPos . _2
objectGroups :: Functor f
=> (Map.Map GroupId [ObjectId] -> f (Map.Map GroupId [ObjectId]))
-> ScenarioState -> f ScenarioState
objectGroups f s = (\x -> s{_objectGroups = x}) <$> f (_objectGroups s)
clippingDist :: Functor f
=> (Float -> f Float)
-> ScenarioState -> f ScenarioState
clippingDist f s = (\x -> s{_clippingDist = x}) <$> f (_clippingDist s)
zoomLimits :: Functor f
=> ((Float, Float) -> f (Float, Float))
-> ScenarioState -> f ScenarioState
zoomLimits f s = (\x -> s{_zoomLimits = x}) <$> f (_zoomLimits s)
templates :: Functor f
=> (Set.Set (Either ObjectId GroupId) -> f (Set.Set (Either ObjectId GroupId) ))
-> ScenarioState -> f ScenarioState
templates f s = (\x -> s{_templates = x}) <$> f (_templates s)
forcedAreaObjId :: Functor f
=> (Maybe ObjectId -> f (Maybe ObjectId))
-> ScenarioState -> f ScenarioState
forcedAreaObjId f s = (\x -> s{_forcedAreaObjId = x}) <$> f (_forcedAreaObjId s)
groupIdSeq :: Functor f
=> (GroupId -> f GroupId)
-> ScenarioState -> f ScenarioState
groupIdSeq f s = (\x -> s{_groupIdSeq = x}) <$> f (_groupIdSeq s)
creationPoint :: Functor f
=> (Maybe Vec3f -> f (Maybe Vec3f))
-> ScenarioState -> f ScenarioState
creationPoint f s = (\x -> s{_creationPoint = x}) <$> f (_creationPoint s)
servicePlugins :: Functor f
=> ([ServicePlugin] -> f [ServicePlugin])
-> ScenarioState -> f ScenarioState
servicePlugins f s = (\x -> s{_servicePlugins = x}) <$> f (_servicePlugins s)
| achirkin/qua-view | src/Model/Scenario.hs | mit | 14,362 | 0 | 13 | 3,750 | 4,518 | 2,339 | 2,179 | -1 | -1 |
module GraphDB.Util.TH.Q where
import GraphDB.Util.Prelude
import Language.Haskell.TH
import qualified GraphDB.Util.TH.Type as Type
import qualified Data.Attoparsec.Text as AP
import qualified Data.Text.IO as Text
import qualified Data.Text as Text
import qualified Data.Char as Char
import qualified Language.Haskell.TH.ExpandSyns as ExpandSyns
reifyLocalFunctions :: Q [(Name, Type)]
reifyLocalFunctions =
listTopLevelFunctionLikeNames >>=
mapM (\name -> reifyFunction name >>= mapM (return . (name, ))) >>=
return . catMaybes
where
listTopLevelFunctionLikeNames = do
loc <- location
text <- runIO $ Text.readFile $ loc_filename loc
return $ map (mkName . Text.unpack) $ nub $ parse text
where
parse text =
either (error . ("Local function name parsing failure: " ++)) id $
AP.parseOnly parser text
where
parser =
AP.sepBy (optional topLevelFunctionP <* AP.skipWhile (not . AP.isEndOfLine))
AP.endOfLine >>=
return . catMaybes
where
topLevelFunctionP = do
head <- AP.satisfy Char.isLower
tail <- many (AP.satisfy (\c -> Char.isAlphaNum c || c `elem` ['_', '\'']))
return $ Text.pack $ head : tail
reifyFunction :: Name -> Q (Maybe Type)
reifyFunction name = do
tryToReify name >>= \case
Just (VarI _ t _ _) -> return $ Just $ t
_ -> return Nothing
reifyType :: Name -> Q (Maybe Type)
reifyType name = do
tryToReify name >>= \case
Just (TyConI _) -> Just <$> conT name
_ -> return Nothing
expandRootSynType :: Type -> Q (Maybe Type)
expandRootSynType t =
case reverse $ Type.unapply t of
ConT name : applications -> expandTypeSynonym name applications
_ -> return Nothing
-- |
-- Expand a type synonym identified by name, while providing the types to
-- substitute its variables with.
--
-- Returns nothing, if it's not a type synonym.
--
-- TODO:
-- Should fail if incorrect amount of args is provided, hence this function is only supposed
-- to be used as a helper for other functions, which unapply the type internally
-- and know exactly how many arguments to apply to it.
expandTypeSynonym :: Name -> [Type] -> Q (Maybe Type)
expandTypeSynonym name args = tryToReify name >>= return . join . fmap fromInfo
where
fromInfo = \case
TyConI (TySynD _ vars t) ->
Just $ foldr ($) t $ do
(var, arg) <- zip vars args
return $ ExpandSyns.substInType ((tvName var), arg)
_ -> Nothing
tvName = \case
PlainTV n -> n
KindedTV n _ -> n
tryToReify :: Name -> Q (Maybe Info)
tryToReify n = recover (return Nothing) (fmap Just $ reify n)
purify :: Q a -> a
purify = unsafePerformIO . runQ
run :: MonadIO m => Q a -> m a
run = liftIO . runQ
caseLambda :: [Q Match] -> Q Exp
caseLambda matches = lamE [varP argName] (caseE (varE argName) matches)
where
argName = mkName "_0"
-- |
-- Only checks the instances in scope of the calling site,
-- it will not detect the declared instances, if they are not imported.
whenNoInstance :: Monoid a => Name -> [Type] -> Q a -> Q a
whenNoInstance name types f = do
z <- recover (return False) (isInstance name types)
if z
then return mempty
else f
liftSTM :: STM a -> Q a
liftSTM = runIO . atomically
| nikita-volkov/graph-db | library/GraphDB/Util/TH/Q.hs | mit | 3,383 | 0 | 24 | 873 | 1,041 | 538 | 503 | -1 | -1 |
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE RecursiveDo #-}
module Widgets.Modal.ServicePlugin
( popupServicePlugin
) where
import Reflex.Dom
import Text.Julius (julius, rawJS)
import Language.Haskell.TH
import Control.Lens
import GHC.Generics (Generic)
import QuaTypes
import Commons
import Model.Scenario.ServicePlugin
import Model.Scenario (Scenario)
import qualified Model.Scenario as Scenario
import Model.GeoJSON.Scenario () -- toJSON instance for Scenario
import JavaScript.JSON.Types.Instances
import Widgets.Commons
import Widgets.Generation
import Widgets.Modal
popupServicePlugin :: Reflex t
=> ServicePlugin
-> Behavior t Scenario
-> Event t (ElementClick servicePluginButton)
-> QuaWidget t x ()
popupServicePlugin servicePlugin scB scContentPopupE = do
settingsD <- quaSettings
let scAndSettingsE = (,) <$> scB <*> current settingsD <@ scContentPopupE
requestE = pushAlways getRequest scAndSettingsE
targetAndReqE <- renderFormTarget servicePlugin requestE
performEvent_
$ (uncurry $ submitForm servicePlugin)
<$> targetAndReqE
where
getRequest (sc, ss)
= liftIO $ case ( getSubmissionGeometryUrl ss
, isViewerOnly $ permissions ss ) of
(Just url, True ) -> pure $ Url url
_ -> Geom <$> jsonStringify (toJSON sc)
type FormTarget = JSString
data View = NewTab | Modal
data RequestType = Geom JSString | Url JSString
deriving Generic
instance ToJSON RequestType
instance PToJSVal RequestType where
pToJSVal = pToJSVal . toJSON
-- | Submit a POST or GET form to a specified target
submitForm :: MonadIO m
=> ServicePlugin
-> FormTarget
-> RequestType
-> m ()
submitForm servicePlugin fTarget req = do
$(qjs
[julius|
document['q$submitServicePluginForm'] = function(servicePlugin, fTarget, req) {
var isPOST = (req.tag == "Geom");
var f = document.createElement("form");
f.hidden = true;
f.target = fTarget;
f.method = isPOST ? "POST" : "GET";
f.action = servicePlugin.url;
var ic = document.createElement("input");
ic.type = "hidden";
ic.name = isPOST ? "geometry" : "url";
ic.value = req.contents;
f.appendChild(ic);
var it = document.createElement("input");
it.type = "hidden";
it.name = "view";
it.value = (fTarget == "_blank") ? "newtab" : "modal";
f.appendChild(it);
document.body.appendChild(f);
f.submit();
document.body.removeChild(f);
};
|]
)
liftIO $ js_submitServicePluginForm (pToJSVal servicePlugin) fTarget (pToJSVal req)
-- this function is updated every time `submitFOrm is called.
foreign import javascript "document['q$submitServicePluginForm']($1, $2, $3);"
js_submitServicePluginForm :: JSVal -> JSString -> JSVal -> IO ()
renderFormTarget :: Reflex t
=> ServicePlugin
-> Event t RequestType
-> QuaWidget t x (Event t (FormTarget, RequestType))
renderFormTarget servicePlugin reqE = mdo
(_, closeButtonE ) <- createModal
(leftmost [showModalE, Inactive <$ closeButtonE ] )
Inactive
(do
elAttr "iframe"
( "name" =: iFrameTargetName
<> "style" =: "width: 100%; border: none;"
) blank
elClass "div" "modal-footer" $
elClass "p" "text-right" $
buttonFlat "close" def
)
"standard"
return $ inferTarget <$> reqE
where
showModalE = fmapMaybe activeModal $ inferView <$> reqE
activeModal Modal = Just Active
activeModal NewTab = Nothing
inferTarget req
= case inferView req of
Modal -> (textToJSString iFrameTargetName, req)
NewTab -> ("_blank", req)
inferView req
= case servicePlugin ^. spView of
SPVModal -> Modal
SPVNewTab -> NewTab
SPVAuto -> case req of
Geom _ -> Modal
Url _ -> NewTab
iFrameTargetName = $(newVar >>= returnVars . (:[]))
| achirkin/qua-view | src/Widgets/Modal/ServicePlugin.hs | mit | 4,587 | 9 | 16 | 1,474 | 822 | 432 | 390 | 92 | 6 |
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE EmptyDataDecls #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Model where
import Data.Text (Text)
import Database.Persist.TH
import Database.Persist.Quasi
import Yesod.Form.Fields (Textarea)
import Data.Time.Clock (UTCTime)
share [mkPersist sqlSettings, mkMigrate "migrateAll"]
$(persistFileWith lowerCaseSettings "config/models")
| cuklev/huseless-pastebin | src/Model.hs | mit | 650 | 0 | 8 | 165 | 85 | 52 | 33 | 16 | 0 |
/*Owner & Copyrights: Vance King Saxbe. A.*//* Copyright (c) <2014> Author Vance King Saxbe. A, and contributors Power Dominion Enterprise, Precieux Consulting and other contributors. Modelled, Architected and designed by Vance King Saxbe. A. with the geeks from GoldSax Consulting and GoldSax Technologies email @[email protected]. Development teams from Power Dominion Enterprise, Precieux Consulting. Project sponsored by GoldSax Foundation, GoldSax Group and executed by GoldSax Manager.*/{-# Modelled, Architected and designed by Vance King Saxbe. A. with the geeks from GoldSax Consulting, GoldSax Money, GoldSax Treasury, GoldSax Finance, GoldSax Banking and GoldSax Technologies email @[email protected]. Development teams from Power Dominion Enterprise, Precieux Consulting. This Engagement sponsored by GoldSax Foundation, GoldSax Group and executed by GoldSax Manager. LANGUAGE TypeSynonymInstances, LiberalTypeSynonyms #-}
module GoldSaxMachineModule6.CombinatorsState where
import GoldSaxMachineModule6.Vector
import Data.Default
import Data.List
import qualified Data.Map as M
type State s a = s -> (a, s)
thenDo :: State s a -> (a -> State s b) -> State s b
-- thenDo :: (s -> (a,s)) -> (a -> s -> (b,s)) -> s -> (b,s)
--thenDo f g s = let (resultOfF, stateAfterF) = f s
-- in g resultOfF stateAfterF
thenDo f g = uncurry g . f
data KMeansState v = KMeansState { centroids :: [v]
, threshold :: Double
, steps :: Int }
newCentroids :: (Vector v, Vectorizable e v) => M.Map v [e] -> [v]
newCentroids = M.elems . fmap (centroid . map toVector)
clusterAssignments :: (Vector v, Vectorizable e v) => [v] -> [e] -> M.Map v [e]
clusterAssignments centrs points =
let initialMap = M.fromList $ zip centrs (repeat [])
in foldr (\p m -> let chosenCentroid = minimumBy (\x y -> compare (distance x $ toVector p)
(distance y $ toVector p))
centrs
in M.adjust (p:) chosenCentroid m)
initialMap points
kMeans' :: (Vector v, Vectorizable e v) => [e] -> State (KMeansState v) [v]
kMeans' points =
(\s -> (centroids s,s)) `thenDo` (\prevCentrs ->
(\s -> (clusterAssignments prevCentrs points, s)) `thenDo` (\assignments ->
(\s -> (newCentroids assignments, s)) `thenDo` (\newCentrs ->
(\s -> ((), s { centroids = newCentrs })) `thenDo` (\_ ->
(\s -> ((), s { steps = steps s + 1 })) `thenDo` (\_ ->
(\s -> (threshold s, s)) `thenDo` (\t ->
(\s -> (sum $ zipWith distance prevCentrs newCentrs, s)) `thenDo` (\err ->
if err < t then (\s -> (newCentrs, s)) else (kMeans' points) )))))))
initialState :: (Vector v, Vectorizable e v) => (Int -> [e] -> [v]) -> Int -> [e] -> Double -> KMeansState v
initialState i k pts t = KMeansState (i k pts) t 0
kMeans :: (Vector v, Vectorizable e v) => (Int -> [e] -> [v]) -> Int -> [e] -> Double -> [v]
kMeans i k pts t = fst $ kMeans' pts (initialState i k pts t)
remain :: a -> (s -> (a,s))
remain x = \s -> (x,s)
access :: (s -> a) -> (s -> (a,s))
access f = \s -> (f s, s)
modify :: (s -> s) -> (s -> ((), s))
modify f = \s -> ((), f s)
kMeans2 :: (Vector v, Vectorizable e v) => [e] -> State (KMeansState v) [v]
kMeans2 points =
access centroids `thenDo` (\prevCentrs ->
remain (clusterAssignments prevCentrs points) `thenDo` (\assignments ->
remain (newCentroids assignments) `thenDo` (\newCentrs ->
modify (\s -> s { centroids = newCentrs }) `thenDo` (\_ ->
modify (\s -> s { steps = steps s + 1 }) `thenDo` (\_ ->
access threshold `thenDo` (\t ->
remain (sum $ zipWith distance prevCentrs newCentrs) `thenDo` (\err ->
if err < t then remain newCentrs else kMeans2 points )))))))
/*email to provide support at [email protected], [email protected], For donations please write to [email protected]*/ | VanceKingSaxbeA/GoldSaxMachineStore | GoldSaxMachineModule6/src/Chapter6/CombinatorsState.hs | mit | 4,327 | 23 | 29 | 1,233 | 1,532 | 843 | 689 | 51 | 2 |
{-# LANGUAGE OverloadedStrings #-}
module Component where
import Book
import Reflex.Dom
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Text (Text)
type AttrMap = Map Text Text
searchInput :: MonadWidget t m => m (TextInput t)
searchInput = do
textInput $
def & attributes .~ constDyn
(mconcat [ "class" =: "books-search"
, "placeholder" =: "Search books"
]
)
formatSimplePairs :: [Text] -> [(Text, Text)]
formatSimplePairs ts = zip ts ts
selectableList :: (MonadWidget t m, Ord k)
=> Dynamic t (Maybe k) -- Key of element that may be selected
-> Dynamic t (Map k v) -- Map of elements to be shown in the list
-> (Dynamic t Bool -> Dynamic t v -> m (Event t a))
-- ^ Action that renders a widget for an element. The element may fire events
-> m (Event t k) -- List fires events whenever an element is selected
selectableList selection elems mkEntry = do
selectEntry <- listWithKey elems $ \k v -> do
let isSelected = ffor selection $ \s -> s == Just k
fmap (const k) <$> mkEntry isSelected v
switchPromptlyDyn <$> mapDyn (leftmost . Map.elems) selectEntry
selectedStyle :: AttrMap
selectedStyle = "style" =: "font-weight: bold"
dropdownWith :: ( MonadWidget t m ) => [Text] -> m ( Dynamic t Text )
dropdownWith pairs = do
let ops = Map.fromList $ formatSimplePairs pairs
formatDropdown <- dropdown "mobi" (constDyn ops) def
let selectedFormat = _dropdown_value formatDropdown
pure selectedFormat
metadata_for :: MonadWidget t m => Book -> m ()
metadata_for book = do
elClass "span" "book-meta" $ do
el "p" $ text "format"
elClass "p" "book-format" $ text (format book)
bookshelfContainer :: MonadWidget t m => m () -> m ()
bookshelfContainer m = do
elClass "h1" "center" $ text "your bookshelf"
elClass "div" "six columns bookshelf" $ m
metadataContainer :: MonadWidget t m => m () -> m ()
metadataContainer = elClass "div" "four columns metadata"
bookshelfLoading :: MonadWidget t m => m ()
bookshelfLoading = bookshelfContainer $ do
text "loading books..."
pure ()
metadataLoading :: MonadWidget t m => m ()
metadataLoading = metadataContainer $ do
text "..."
pure ()
header :: MonadWidget t m => Text -> m ()
header = el "h1" . text
| tippenein/bookshelf | src/Component.hs | mit | 2,356 | 0 | 18 | 570 | 769 | 375 | 394 | 55 | 1 |
module SrcTemplateLexer
(
stringLit,
intLit,
identifier,
symbol,
reserved,
whiteSpace,
reservedOp,
parens,
squares
)
where
import Text.ParserCombinators.Parsec
import qualified Text.ParserCombinators.Parsec.Token as P
import Text.ParserCombinators.Parsec.Language(javaStyle)
srcTemplateLexer = P.makeTokenParser srcTemplateDef
srcTemplateDef = javaStyle
{
P.reservedNames = ["params", "$$", "true", "false", "if", "then", "else", "def", "options",
"description", "history"],
P.reservedOpNames = ["+", "-", "*", "/", "%", "and", "or", "not"],
P.caseSensitive = True,
P.opLetter = oneOf $ concat $ P.reservedOpNames srcTemplateDef,
P.commentStart = "",
P.commentEnd = "",
P.commentLine = ""
}
intLit = P.integer srcTemplateLexer
stringLit = P.stringLiteral srcTemplateLexer
identifier = P.identifier srcTemplateLexer
symbol = P.symbol srcTemplateLexer
reserved = P.reserved srcTemplateLexer
whiteSpace = P.whiteSpace srcTemplateLexer
reservedOp = P.reservedOp srcTemplateLexer
parens = P.parens srcTemplateLexer
squares = P.squares srcTemplateLexer
| thomkoehler/SrcGen | src/SrcTemplateLexer.hs | gpl-2.0 | 1,162 | 0 | 9 | 226 | 294 | 175 | 119 | 33 | 1 |
import System.Environment (getArgs)
import System.Exit (exitFailure)
import AbsMini
import LexMini
import ParMini
import ErrM
import AnnotatingTypeChecker
import Compiler
-- driver
comp :: String -> String -> IO ()
comp name s = case pProgram (myLexer s) of
Bad err -> do putStrLn "SYNTAX ERROR"
putStrLn err
exitFailure
Ok tree -> case typecheck tree of
Bad err -> do putStrLn "TYPE ERROR"
putStrLn err
exitFailure
Ok tree' -> do
writeFile (name ++ ".j") $ compile name tree'
putStrLn $ "wrote " ++ name ++ ".j"
main :: IO ()
main = do args <- getArgs
case args of
[file] -> readFile file >>= comp (takeWhile (/='.') file)
_ -> do putStrLn "Usage: lab3 <SourceFile>"
exitFailure
| izimbra/PLT2014 | mini/haskell/compmini.hs | gpl-2.0 | 1,023 | 0 | 16 | 457 | 266 | 127 | 139 | 26 | 3 |
{-
(
save,
UrlSchemes
)
-}
{-# LANGUAGE UnicodeSyntax #-}
{-# LANGUAGE GADTs, TypeFamilies, TemplateHaskell, QuasiQuotes, FlexibleInstances, StandaloneDeriving #-}
module Database.Categories
where
import URL
-- import Database.Groundhog.TH
-- import Database.Groundhog.MySQL
data Categories = Categories {
id :: Int,
label :: String
} deriving Show
{-
mkPersist defaultCodegenConfig [groundhog|
- entity: Categories
dbName: url_schemes
autoKey: null
# constrName: URLAutoKey
constructors:
- name: Categories
# keyDbName: id
fields:
- name: id
type: int(11)
dbName: id
- name: label
type: varchar(255)
dbName: label
|]
-} | xruzzz/axt-links-saver-haskell | src/Categories.hs | gpl-2.0 | 747 | 0 | 8 | 208 | 39 | 27 | 12 | 8 | 0 |
{-# LANGUAGE ForeignFunctionInterface #-}
import Data.ByteString.Char8 (pack, unpack)
import Network hiding (accept, sClose)
import Network.Socket hiding (recv)
import Network.Socket.ByteString (sendAll, recv)
import Control.Concurrent
import Foreign.C
import Foreign.Marshal.Alloc()
foreign import ccall start_finding:: CString -> CString
main :: IO a
main = withSocketsDo (listenOn (PortNumber 5002) >>= loop)
loop :: Socket -> IO b
loop sock = do
(conn, _) <- accept sock
_ <- forkIO $ body conn
loop sock
where
body conn = do
line <- start_finding <$> (( unpack <$> recv conn 1024) >>= newCString)
lint <- pack <$> peekCString line
sendAll conn lint
sClose conn
| PeterPiggyDevelopment/Labyrinth | src/server/server.hs | gpl-2.0 | 748 | 0 | 15 | 179 | 242 | 127 | 115 | 21 | 1 |
{-# LANGUAGE CPP #-}
{- |
Module : ./Common/Utils.hs
Description : utility functions that can't be found in the libraries
Copyright : (c) Klaus Luettich, Uni Bremen 2002-2006
License : GPLv2 or higher, see LICENSE.txt
Maintainer : [email protected]
Stability : provisional
Portability : portable
Utility functions that can't be found in the libraries
but should be shared across Hets.
-}
module Common.Utils
( isSingleton
, replace
, hasMany
, number
, combine
, trim
, trimLeft
, trimRight
, toSnakeCase
, nubOrd
, nubOrdOn
, atMaybe
, readMaybe
, mapAccumLM
, mapAccumLCM
, concatMapM
, composeMap
, keepMins
, splitOn
, splitPaths
, splitBy
, splitByList
, numberSuffix
, basename
, dirname
, fileparse
, stripDir
, stripSuffix
, makeRelativeDesc
, getEnvSave
, getEnvDef
, filterMapWithList
, timeoutSecs
, executeProcess
, executeProcessWithEnvironment
, timeoutCommand
, withinDirectory
, writeTempFile
, getTempFile
, getTempFifo
, readFifo
, verbMsg
, verbMsgLn
, verbMsgIO
, verbMsgIOLn
) where
import Data.Char
import Data.List
import Data.Maybe
import qualified Data.Map as Map
import qualified Data.Set as Set
import System.Directory
import System.Environment
import System.Exit
import System.FilePath (joinPath, makeRelative, equalFilePath, takeDirectory)
import System.IO
import System.IO.Error (isEOFError)
import System.Process
import System.Timeout
#ifdef UNIX
import System.Posix.Files (createNamedPipe, unionFileModes,
ownerReadMode, ownerWriteMode)
import System.Posix.IO (OpenMode (ReadWrite), defaultFileFlags,
openFd, closeFd, fdRead)
import Control.Concurrent (threadDelay, forkIO, killThread)
import Control.Concurrent.MVar (MVar, newEmptyMVar, takeMVar, putMVar)
import Control.Exception as Exception
import System.IO.Unsafe (unsafeInterleaveIO)
#endif
import Control.Monad
{- | Writes the message to the given handle unless the verbosity is less than
the message level. -}
verbMsg :: Handle -- ^ Output handle
-> Int -- ^ global verbosity
-> Int -- ^ message level
-> String -- ^ message level
-> IO ()
verbMsg hdl v lvl = when (lvl <= v) . hPutStr hdl
-- | Same as 'verbMsg' but with a newline at the end
verbMsgLn :: Handle -> Int -> Int -> String -> IO ()
verbMsgLn hdl v lvl = when (lvl <= v) . hPutStrLn hdl
-- | 'verbMsg' with stdout as handle
verbMsgIO :: Int -> Int -> String -> IO ()
verbMsgIO = verbMsg stdout
-- | 'verbMsgLn' with stdout as handle
verbMsgIOLn :: Int -> Int -> String -> IO ()
verbMsgIOLn = verbMsgLn stdout
{- | replace all occurrences of the first (non-empty sublist) argument
with the second argument in the third (list) argument. -}
replace :: Eq a => [a] -> [a] -> [a] -> [a]
replace sl r = case sl of
[] -> error "Common.Utils.replace: empty list"
_ -> concat . unfoldr (\ l -> case l of
[] -> Nothing
hd : tl -> Just $ case stripPrefix sl l of
Nothing -> ([hd], tl)
Just rt -> (r, rt))
-- | add indices to a list starting from one
number :: [a] -> [(a, Int)]
number = flip zip [1 ..]
-- | /O(1)/ test if the set's size is one
isSingleton :: Set.Set a -> Bool
isSingleton s = Set.size s == 1
-- | /O(1)/ test if the set's size is greater one
hasMany :: Set.Set a -> Bool
hasMany s = Set.size s > 1
{- | Transform a list @[l1, l2, ... ln]@ to (in sloppy notation)
@[[x1, x2, ... xn] | x1 <- l1, x2 <- l2, ... xn <- ln]@
(this is just the 'sequence' function!) -}
combine :: [[a]] -> [[a]]
combine = sequence
-- see http://www.haskell.org/pipermail/haskell-cafe/2009-November/069490.html
-- | trims a string both on left and right hand side
trim :: String -> String
trim = trimRight . trimLeft
-- | trims a string only on the left side
trimLeft :: String -> String
trimLeft = dropWhile isSpace
-- | trims a string only on the right side
trimRight :: String -> String
trimRight = foldr (\ c cs -> if isSpace c && null cs then [] else c : cs) ""
{-
Convert CamelCased or mixedCases 'String' to a 'String' with underscores,
the \"snake\" 'String'.
It also considers SCREAMINGCamelCase:
`toSnakeCase "SomeSCREAMINGCamelCase" == "some_screaming_camel_case"`
-}
toSnakeCase :: String -> String
toSnakeCase c = if hasBump c then unScream c else mkSnake c where
hasBump s = case s of
a : b : _ -> isUpper a && isLower b
_ -> False
unScream s = case s of
a : r -> toLower a : mkSnake r
_ -> s
mkSnake s = let newSnake t = '_' : unScream t in case s of
a : r@(b : _) | hasBump [b, a] -> a : newSnake r
_ | hasBump s -> newSnake s
_ -> unScream s
{- | The 'nubWith' function accepts as an argument a \"stop list\" update
function and an initial stop list. The stop list is a set of list elements
that 'nubWith' uses as a filter to remove duplicate elements. The stop list
is normally initially empty. The stop list update function is given a list
element a and the current stop list b, and returns 'Nothing' if the element is
already in the stop list, else 'Just' b', where b' is a new stop list updated
to contain a. -}
nubWith :: (a -> b -> Maybe b) -> b -> [a] -> [a]
nubWith f s es = case es of
[] -> []
e : rs -> case f e s of
Just s' -> e : nubWith f s' rs
Nothing -> nubWith f s rs
nubOrd :: Ord a => [a] -> [a]
nubOrd = nubOrdOn id
nubOrdOn :: Ord b => (a -> b) -> [a] -> [a]
nubOrdOn g = let f a s = let e = g a in
if Set.member e s then Nothing else Just (Set.insert e s)
in nubWith f Set.empty
-- | safe variant of !!
atMaybe :: [a] -> Int -> Maybe a
atMaybe l i = if i < 0 then Nothing else case l of
[] -> Nothing
x : r -> if i == 0 then Just x else atMaybe r (i - 1)
readMaybe :: Read a => String -> Maybe a
readMaybe s = case filter (all isSpace . snd) $ reads s of
[(a, _)] -> Just a
_ -> Nothing
-- | generalization of mapAccumL to monads
mapAccumLM :: Monad m
=> (acc -> x -> m (acc, y))
{- ^ Function taking accumulator and list element,
returning new accumulator and modified list element -}
-> acc -- ^ Initial accumulator
-> [x] -- ^ Input list
-> m (acc, [y]) -- ^ Final accumulator and result list
mapAccumLM f s l = case l of
[] -> return (s, [])
x : xs -> do
(s', y) <- f s x
(s'', ys) <- mapAccumLM f s' xs
return (s'', y : ys)
-- | generalization of mapAccumL to monads with combine function
mapAccumLCM :: (Monad m) => (a -> b -> c) -> (acc -> a -> m (acc, b))
-> acc -> [a] -> m (acc, [c])
mapAccumLCM g f s l = case l of
[] -> return (s, [])
x : xs -> do
(s', y) <- f s x
(s'', ys) <- mapAccumLCM g f s' xs
return (s'', g x y : ys)
{- | Monadic version of concatMap
taken from http://darcs.haskell.org/ghc/compiler/utils/MonadUtils.hs -}
concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
concatMapM f = liftM concat . mapM f
-- | composition of arbitrary maps
composeMap :: Ord a => Map.Map a b -> Map.Map a a -> Map.Map a a -> Map.Map a a
composeMap s m1 m2 = if Map.null m2 then m1 else Map.intersection
(Map.foldWithKey ( \ i j ->
let k = Map.findWithDefault j j m2 in
if i == k then Map.delete i else Map.insert i k) m2 m1) s
-- | keep only minimal elements
keepMins :: (a -> a -> Bool) -> [a] -> [a]
keepMins lt l = case l of
[] -> []
x : r -> let s = filter (not . lt x) r
m = keepMins lt s
in if any (`lt` x) s then m
else x : m
{- |
A function inspired by the perl function split. A list is splitted
on a separator element in smaller non-empty lists.
The separator element is dropped from the resulting list.
-}
splitOn :: Eq a => a -- ^ separator
-> [a] -- ^ list to split
-> [[a]]
splitOn x = filter (not . null) . splitBy x
-- | split a colon (or on windows semicolon) separated list of paths
splitPaths :: String -> [FilePath]
splitPaths = splitOn
#ifdef UNIX
':'
#else
';'
#endif
{- |
Same as splitOn but empty lists are kept. Even the empty list is split into
a singleton list containing the empty list.
-}
splitBy :: Eq a => a -- ^ separator
-> [a] -- ^ list to split
-> [[a]]
splitBy c l = let (p, q) = break (c ==) l in p : case q of
[] -> []
_ : r -> splitBy c r
{- | Same as splitBy but the separator is a sublist not only one element.
Note that the separator must be non-empty. -}
splitByList :: Eq a => [a] -> [a] -> [[a]]
splitByList sep l = case l of
[] -> [[]]
h : t -> case stripPrefix sep l of
Just suf -> [] : splitByList sep suf
Nothing -> let f : r = splitByList sep t in (h : f) : r
{- | If the given string is terminated by a decimal number
this number and the nonnumber prefix is returned. -}
numberSuffix :: String -> Maybe (String, Int)
numberSuffix s =
let f a r@(x, y, b) =
let b' = isDigit a
y' = y + x * digitToInt a
out | not b = r
| b && b' = (x * 10, y', b')
| otherwise = (x, y, False)
in out
in case foldr f (1, 0, True) s of
(1, _, _) ->
Nothing
(p, n, _) ->
Just (take (1 + length s - length (show p)) s, n)
{- |
A function inspired by a perl function from the standard perl-module
File::Basename. It removes the directory part of a filepath.
-}
basename :: FilePath -> FilePath
basename = snd . stripDir
{- |
A function inspired by a perl function from the standard perl-module
File::Basename. It gives the directory part of a filepath.
-}
dirname :: FilePath -> FilePath
dirname = fst . stripDir
{- |
A function inspired by a perl function from the standard perl-module
File::Basename. It splits a filepath into the basename, the
directory and gives the suffix that matched from the list of
suffixes. If a suffix matched it is removed from the basename.
-}
fileparse :: [String] -- ^ list of suffixes
-> FilePath
-> (FilePath, FilePath, Maybe String)
-- ^ (basename,directory,matched suffix)
fileparse sufs fp = let (path, base) = stripDir fp
(base', suf) = stripSuffix sufs base
in (base', path, suf)
stripDir :: FilePath -> (FilePath, FilePath)
stripDir =
(\ (x, y) -> (if null y then "./" else reverse y, reverse x))
. break (== '/') . reverse
stripSuffix :: [String] -> FilePath -> (FilePath, Maybe String)
stripSuffix suf fp = case filter isJust $ map (stripSuf fp) suf of
Just (x, s) : _ -> (x, Just s)
_ -> (fp, Nothing)
where stripSuf f s | s `isSuffixOf` f =
Just (take (length f - length s) f, s)
| otherwise = Nothing
{- |
This function generalizes makeRelative in that it computes also a relative
path with descents such as ../../test.txt
-}
makeRelativeDesc :: FilePath -- ^ path to a directory
-> FilePath -- ^ to be computed relatively to given directory
-> FilePath -- ^ resulting relative path
makeRelativeDesc dp fp = f dp fp []
where f "" y l = joinPath $ l ++ [y]
f x y l = let y' = makeRelative x y
in if equalFilePath y y'
then f (takeDirectory x) y $ ".." : l
else joinPath $ l ++ [y']
{- | filter a map according to a given list of keys (it dosen't hurt
if a key is not present in the map) -}
filterMapWithList :: Ord k => [k] -> Map.Map k e -> Map.Map k e
filterMapWithList = filterMapWithSet . Set.fromList
{- | filter a map according to a given set of keys (it dosen't hurt if
a key is not present in the map) -}
filterMapWithSet :: Ord k => Set.Set k -> Map.Map k e -> Map.Map k e
filterMapWithSet s = Map.filterWithKey (\ k _ -> Set.member k s)
{- | get, parse and check an environment variable; provide the default
value, only if the envionment variable is not set or the
parse-check-function returns Nothing -}
getEnvSave :: a -- ^ default value
-> String -- ^ name of environment variable
-> (String -> Maybe a) -- ^ parse and check value of variable
-> IO a
getEnvSave defValue envVar readFun =
liftM (maybe defValue (fromMaybe defValue . readFun)
. lookup envVar) getEnvironment
-- | get environment variable
getEnvDef :: String -- ^ environment variable
-> String -- ^ default value
-> IO String
getEnvDef envVar defValue = getEnvSave defValue envVar Just
-- | the timeout function taking seconds instead of microseconds
timeoutSecs :: Int -> IO a -> IO (Maybe a)
timeoutSecs time = timeout $ let
m = 1000000
u = div maxBound m
in if time > u then maxBound else
if time < 1 then 100000 -- 1/10 of a second
else m * time
-- | like readProcessWithExitCode, but checks the command argument first
executeProcess
:: FilePath -- ^ command to run
-> [String] -- ^ any arguments
-> String -- ^ standard input
-> IO (ExitCode, String, String) -- ^ exitcode, stdout, stderr
executeProcess cmd args input = do
mp <- findExecutable cmd
case mp of
Nothing -> return (ExitFailure 127, "", "command not found: " ++ cmd)
Just exe -> readProcessWithExitCode exe args input
executeProcessWithEnvironment :: FilePath
-> [String]
-> String
-> [(String, String)]
-> IO (ExitCode, String, String)
executeProcessWithEnvironment cmd args input environment = do
mp <- findExecutable cmd
case mp of
Nothing -> return (ExitFailure 127, "", "command not found: " ++ cmd)
Just exe -> do
(Just hin, mHout, mHerr, processHandle) <-
createProcess $ (proc exe args) { env = Just environment
, std_in = CreatePipe
, std_out = CreatePipe
}
hPutStr hin input
out <- case mHout of
Just hout -> hGetContents hout
_ -> return ""
err <- case mHerr of
Just herr -> hGetContents herr
_ -> return ""
exitCode <- waitForProcess processHandle
return (exitCode, out, err)
-- | runs a command with timeout
timeoutCommand :: Int -> FilePath -> [String]
-> IO (Maybe (ExitCode, String, String))
timeoutCommand time cmd args =
timeoutSecs time $
executeProcess cmd args "" -- no input from stdin
{- | runs an action in a different directory without changing the current
directory globally. -}
withinDirectory :: FilePath -> IO a -> IO a
withinDirectory p a = do
d <- getCurrentDirectory
setCurrentDirectory p
r <- a
setCurrentDirectory d
return r
-- | opens a temp file but directly writes content and closes the file
writeTempFile :: String -- ^ Content
-> FilePath -- ^ Directory in which to create the file
-> String -- ^ File name template
-> IO FilePath -- ^ create file
writeTempFile str tmpDir file = do
(tmpFile, hdl) <- openTempFileWithDefaultPermissions tmpDir file
hPutStr hdl str
hFlush hdl
hClose hdl
return tmpFile
-- | create file in temporary directory (the first argument is the content)
getTempFile :: String -- ^ Content
-> String -- ^ File name template
-> IO FilePath -- ^ create file
getTempFile str file = do
tmpDir <- getTemporaryDirectory
writeTempFile str tmpDir file
#ifdef UNIX
getTempFifo :: String -> IO FilePath
getTempFifo f = do
tmpDir <- getTemporaryDirectory
(tmpFile, hdl) <- openTempFile tmpDir f
hClose hdl
removeFile tmpFile
createNamedPipe tmpFile $ unionFileModes ownerReadMode ownerWriteMode
return tmpFile
#else
getTempFifo :: String -> IO FilePath
getTempFifo _ = return ""
#endif
#ifdef UNIX
type Pipe = (IO (), MVar String)
#endif
#ifdef UNIX
openFifo :: FilePath -> IO Pipe
openFifo fp = do
mvar <- newEmptyMVar
let readF fd = forever (fmap fst (fdRead fd 100) >>= putMVar mvar)
`Exception.catch`
\ e -> const (threadDelay 100) (e :: Exception.IOException)
let reader = forever $ do
fd <- openFd fp ReadWrite Nothing defaultFileFlags
readF fd `Exception.catch`
\ e -> closeFd fd >>
if isEOFError e then reader
else throwIO (e :: Exception.IOException)
return (reader, mvar)
readFifo' :: MVar String -> IO [String]
readFifo' mvar = do
x <- unsafeInterleaveIO $ takeMVar mvar
xs <- unsafeInterleaveIO $ readFifo' mvar
return $ x : xs
readFifo :: FilePath -> IO ([String], IO ())
readFifo fp = do
(reader, pipe) <- openFifo fp
tid <- forkIO reader
l <- readFifo' pipe
m <- newEmptyMVar
forkIO $ takeMVar m >> killThread tid
return (l, putMVar m ())
#else
readFifo :: FilePath -> IO ([String], IO ())
readFifo _ = return ([], return ())
#endif
| gnn/Hets | Common/Utils.hs | gpl-2.0 | 17,063 | 0 | 20 | 4,715 | 4,663 | 2,442 | 2,221 | 310 | 6 |
module Parse (parseScript) where
import Text.Parsec hiding (Line, sourceLine)
import Text.Parsec.String
import Text.Printf
------------------------------------------------------------
-- public api
------------------------------------------------------------
parseScript :: String -> String -> Maybe ScriptData
parseScript fname script =
let parsed = parse (text fname) "(script parse)" script
in case parsed of (Left _) -> Nothing
(Right x) -> Just x
------------------------------------------------------------
-- types
------------------------------------------------------------
data ScriptData = ScriptData { _scriptData_name :: String
, _scriptData_comment :: String
, _scriptData_args :: [String] -- TODO: currently unimplemented
}
instance Show ScriptData where
show sd = printf "%-25s %s" (_scriptData_name sd) (_scriptData_comment sd)
data ParseLine = Useless | Args [String] | Comment String
isUseful :: ParseLine -> Bool
isUseful Useless = False
isUseful _ = True
isComment :: ParseLine -> Bool
isComment (Comment _) = True
isComment _ = False
------------------------------------------------------------
-- internal parsers
------------------------------------------------------------
text :: String -> Parser ScriptData
text filename = do
xs <- many line
-- make a singleton list with the first comment, which is all we'll use for now
let usefuls = filter isUseful xs
let comments = take 1 . filter isComment $ usefuls
let args = take 1 . filter (not . isComment) $ usefuls
let comment = case comments of (Comment x:_) -> x
_ -> ""
let args' = case args of Args x:_ -> x
_ -> []
return (ScriptData filename comment args')
line :: Parser ParseLine
line =
try argLine <|>
try commentLine <|>
try sheBangLine <|>
try whitespaceLine <|>
try emptyLine <|>
sourceLine <?> "didn't find commenty or whitespace"
-- parsers that gather data we care about
argLine :: Parser ParseLine
argLine = do
_ <- string "# args: "
open <- char '['
inner <- many (noneOf "[]")
close <- char ']'
_ <- trailingSpaceEol
return $ Args $ read $ [open] ++ inner ++ [close]
commentLine :: Parser ParseLine
commentLine = do
_ <- char '#'
_ <- optional $ char ' '
x <- noneOf "!"
xs <- nonEolChars
_ <- trailingSpaceEol
return $ Comment (x:xs)
-- line parsers that return discardable results
emptyLine :: Parser ParseLine
emptyLine = endOfLine >> return Useless
whitespaceLine :: Parser ParseLine
whitespaceLine = trailingSpaceEol >> return Useless
sheBangLine :: Parser ParseLine
sheBangLine = string "#!" >> nonEolChars >> endOfLine >> return Useless
sourceLine :: Parser ParseLine
sourceLine = noneOf "#" >> nonEolChars >> endOfLine >> return Useless
-- mid-line parsers
trailingSpaceEol :: Parser Char
trailingSpaceEol = nonEolSpaces >> endOfLine
nonEolSpaces :: Parser String
nonEolSpaces = many (oneOf " \t\f\v\xa0")
nonEolChars :: Parser String
nonEolChars = many (noneOf "\n\r")
| steventlamb/kj | src/Parse.hs | gpl-3.0 | 3,118 | 0 | 15 | 667 | 840 | 420 | 420 | 70 | 3 |
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE Rank2Types #-}
{-# OPTIONS_GHC -F -pgmF htfpp #-}
-- # Standard Library
import qualified Data.Map as M
-- # Site Packages
import Crypto.Random (SystemRandom, newGenIO)
import Control.Monad.CryptoRandom (CRandom(..))
-- # Local
import Data.RAE.Encoder
import Data.RAE.Encoder.Internal.DRAC
import Data.RAE.Evaluation
import Data.RAE.Decoder
import Data.RAE.Types
import Data.ExpressionTypes
import Data.FieldTypes
import qualified Math.Polynomials as P
import qualified Functionality.AllInOne as AIO
-- # HTF
import Test.Framework
-- # DEBUG
import Debug.Trace
import Math.FiniteFields.F2Pow256
type Element = F2Pow256
--import Math.FiniteFields.F97
--type Element = F97
_SOME_POS_NUMS_ :: [Element]
_SOME_POS_NUMS_ = map fromIntegral $ [1..100] ++
[ 2^256-1, 2^42-1, 234345, 391238571]
_VAR_X_ :: Field el => Expr el
_VAR_X_ = Var "x"
_VAR_Y_ :: Field el => Expr el
_VAR_Y_ = Var "y"
_VAR_Z_ :: Field el => Expr el
_VAR_Z_ = Var "z"
_VAL_X_ :: Field el => el
_VAL_X_ = 23
_VAL_Y_ :: Field el => el
_VAL_Y_ = 42
_TEST_VAR_MAP_CLEAN_ :: Field el => VarMapping el
_TEST_VAR_MAP_CLEAN_ = M.fromList [ ("x", _VAL_X_)
, ("y", _VAL_Y_)
, ("z", _VAL_Y_)
]
_TEST_VAR_MAP_ :: Field el => VarMapping el
_TEST_VAR_MAP_ = M.fromList [ ("x", _VAL_X_)
, (leftVar "x", _VAL_X_)
, (rightVar "x", _VAL_X_)
, ("y", _VAL_Y_)
, (leftVar "y", _VAL_Y_)
, (rightVar "y", _VAL_Y_)
]
deriveSkp :: Field el => el -> el -> (el, el)
deriveSkp l r = (if l == 0 then 23 else l, if r == 0 then 42 else r)
draeDecodeFull :: VarMapping Element -> DRAE Element -> Maybe Element
draeDecodeFull varMap drae =
let out = decodeDRAE varMap drae
(DRAE ((skL, skR), (dkL, dkR)) _ _) = drae
in case out of
Nothing -> trace "DECODE FAILED" Nothing
Just (l, r) ->
let finalL = (l-dkL) * invert skL
finalR = (r-dkR) * invert skR
in if finalL == finalR
then Just finalL
else trace ("<"++show finalL++" vs. "++show finalR++">") $
Nothing
execExpr :: (Show el, CRandom el, Field el) => Expr el -> IO (Maybe el)
execExpr expr =
do g <- (newGenIO :: IO SystemRandom)
let varMap = _TEST_VAR_MAP_CLEAN_
(_, drac) = exprToDRAC g expr
(rac, oac) = singularizeDRAC drac
(outDirect, _) = runDRAC varMap drac
outRAC = case runRAC rac oac varMap of
Left err -> trace err Nothing
Right val -> Just val
out = if outDirect == outRAC
then outDirect
else trace "DIRECT != RAC EVAL" Nothing
funcOutM <- AIO.evaluateExpr varMap expr (\_ -> return ())
let finalOut = if out == funcOutM
then out
else trace "DIRECT != FUNC" Nothing
return finalOut
test_simpleDRAE =
do act <- execExpr $ sum (replicate 96 1)
assertEqual (Just (sum (replicate 96 1)) :: Maybe Element) act
test_complexAddDRAE =
do actual <- execExpr $ 1 + 17 + _VAR_X_ + (_VAR_X_ + 23)
let expected :: Maybe Element
expected = Just $ 1 + 17 + _VAL_X_ + (_VAL_X_ + 23)
assertEqual expected actual
test_complexDRAE1 =
do actual <- execExpr $ 4 * _VAR_X_ + _VAR_Y_ + _VAR_X_ * _VAR_X_ * _VAR_X_
let expected :: Maybe Element
expected = Just $ 4 * _VAL_X_ + _VAL_Y_ + _VAL_X_ * _VAL_X_ * _VAL_X_
assertEqual expected actual
test_complexDRAE2 =
do actual <- execExpr $ ( ( (4 * _VAR_X_ * _VAR_X_ + 2)
* (_VAR_X_ + _VAR_Y_ * (_VAR_X_ + _VAR_Y_))
* _VAR_X_ * _VAR_Y_ + 7)
* _VAR_X_
)
let expected :: Maybe Element
expected = Just $ ( ( (4 * _VAL_X_ * _VAL_X_ + 2)
* (_VAL_X_ + _VAL_Y_ * (_VAL_X_ + _VAL_Y_))
* _VAL_X_ * _VAL_Y_ + 7)
* _VAL_X_
)
assertEqual expected actual
poly1toN :: Integer -> (forall a. Num a => a -> [a] -> a) -> IO ()
poly1toN n buildPoly =
do let polyCoeffs :: [Element]
polyCoeffs = map fromInteger [1..n]
poly :: Expr Element
poly = buildPoly _VAR_X_ (map Literal polyCoeffs)
expected = Just $ buildPoly _VAL_X_ polyCoeffs
actual <- execExpr poly
assertEqual expected actual
test_oneConstantMul =
do actual <- execExpr $ (4 * 17 :: Expr Element)
let expected :: Maybe Element
expected = Just $ (4 * 17 :: Element)
assertEqual expected actual
test_twoConstantMuls =
do actual <- execExpr $ (4 * 17 * 23 :: Expr Element)
let expected :: Maybe Element
expected = Just $ (4 * 17 * 23 :: Element)
assertEqual expected actual
test_lotsConstantMuls =
do act <- execExpr $ product (replicate 96 2 :: [Expr Element])
assertEqual (Just (product (replicate 96 2)) :: Maybe Element) act
test_oneMulConstAndVar =
do actual <- execExpr $ (4 * _VAR_X_ :: Expr Element)
let expected :: Maybe Element
expected = Just $ (4 * _VAL_X_ :: Element)
assertEqual expected actual
test_oneMulVarAndConst =
do actual <- execExpr $ (_VAR_X_ * 4:: Expr Element)
let expected :: Maybe Element
expected = Just $ (4 * _VAL_X_ :: Element)
assertEqual expected actual
test_oneMulVarAndVar =
do actual <- execExpr $ (_VAR_X_ * _VAR_Y_:: Expr Element)
let expected :: Maybe Element
expected = Just $ (_VAL_X_ * _VAL_Y_ :: Element)
assertEqual expected actual
test_oneVarOnly =
do actual <- execExpr $ (_VAR_X_ :: Expr Element)
let expected :: Maybe Element
expected = Just $ (_VAL_X_ :: Element)
assertEqual expected actual
test_oneConstOnly =
do actual <- execExpr $ ( 17 :: Expr Element)
let expected :: Maybe Element
expected = Just $ ( 17 :: Element)
assertEqual expected actual
test_hornerPoly1to100 = poly1toN 100 P.horner
test_monomialPoly1to100 = poly1toN 10 P.monomial
prop_draeAddDRAEConstants :: Element
-> Element
-> Element
-> Element
-> Element
-> Element
-> Element
-> Element
-> Bool
prop_draeAddDRAEConstants el1 el2 r1 r2 r3 r4 skpL skpR =
let skp = deriveSkp skpL skpR
el1DRAE = draeEncodePrimaryExpr skp (DualConst el1) r1 r2
el2DRAE = draeEncodePrimaryExpr skp (DualConst el2) r3 r4
el1el2DRAE = draeEncodeDRAEAdd skp el1DRAE el2DRAE
act = draeDecodeFull M.empty el1el2DRAE
in Just (el1 + el2) == act
prop_draeAddConstants :: Element
-> Element
-> Element
-> Element
-> Element
-> Element
-> Element
-> Element
-> Bool
prop_draeAddConstants el1 el2 r1 r2 r3 r4 skpL skpR =
let skp = deriveSkp skpL skpR
el1pe = DualConst el1
el2pe = DualConst el2
outDRAE = draeEncodeAdd skp el1pe el2pe r1 r2 r3 r4
act = draeDecodeFull M.empty outDRAE
in Just (el1 + el2) == act
prop_draeAddAndMulVars :: Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Bool
prop_draeAddAndMulVars r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r16
rk1 rg1 rk2 rg2 rk3 rg3 rk4 rg4
rk5 rg5 rk6 rg6 rk7 rg7 rk8 rg8 =
let v1pe = DualVar (0,0) "x"
v2pe = DualVar (0,0) "y"
skp = (1,1)
-- Use kappas and gammas normally (1 to 8)
drae1 = draeEncodeMul skp v1pe v1pe r1 r2 r3 r4 r5 r6 r7 r8
rk1 rg1 rk2 rg2 rk3 rg3 rk4 rg4
rk5 rg5 rk6 rg6 rk7 rg7 rk8 rg8
-- Use kappas and gammas permutated (5 to 8 and 1 to 4)
drae2 = draeEncodeMul skp v2pe v2pe r9 r10 r11 r12 r13 r14 r15 r16
rk5 rg5 rk6 rg6 rk7 rg7 rk8 rg8
rk1 rg1 rk2 rg2 rk3 rg3 rk4 rg4
outDRAE = draeEncodeDRAEAdd skp drae1 drae2
act = draeDecodeFull _TEST_VAR_MAP_ outDRAE
in Just ((_VAL_X_ * _VAL_X_)+(_VAL_Y_ * _VAL_Y_)) == act
prop_draeAddConstants2 :: Element
-> Element
-> Property
prop_draeAddConstants2 el1 el2 =
let el1pe = DualConst el1
el2pe = DualConst el2
outDRAE r = draeEncodeAdd (deriveSkp r r) el1pe el2pe r r r r
act r = draeDecodeFull M.empty (outDRAE r)
in forAll arbitrarySizedIntegral $ \r -> Just (el1 + el2) == act r
prop_draeMulConstants :: Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Element
-> Element -> Element -> Element -> Element -> Bool
prop_draeMulConstants skil skir el1 el2 el3 r1 r2 r3 r4 r5 r6 r7 r8
rk1 rg1 rk2 rg2 rk3 rg3 rk4 rg4
rk5 rg5 rk6 rg6 rk7 rg7 rk8 rg8 =
let el1pe = DualConst el1
el2pe = DualConst el2
skp = deriveSkp skil skir
outDRAE = draeEncodeMul skp el1pe el2pe r1 r2 r3 r4 r5 r6 r7 r8
rk1 rg1 rk2 rg2 rk3 rg3 rk4 rg4
rk5 rg5 rk6 rg6 rk7 rg7 rk8 rg8
act = draeDecodeFull M.empty outDRAE
in Just (el1 * el2) == act
main = htfMain htf_thisModulesTests
| weissi/diplomarbeit | test/TestRAE.hs | gpl-3.0 | 10,765 | 0 | 36 | 3,968 | 3,193 | 1,638 | 1,555 | 231 | 4 |
{-|
Module : Primeri
Description : Primeri tipov
Copyright : (c) Domen Močnik, 2015
Matej Aleksandorv 2015
License : GPL-3
Maintainer : [email protected], [email protected]
Stability : experimental
Portability : POSIX
Nekaj primerov tipov, ki se jih lahko uporabi v programu za generiranje zastonjskih izrekov.
Leva komponenta para je predstavitev tipa v nizu, desna komponenta pa je ime tipa.
-}
module Primeri where
-- ^ Primere se testira z: odgovor tPrimer.
-- | Aplikacija.
tApplication :: (String, String)
tApplication = ("(a -> b) -> a -> b", "app")
-- | Kompozitum.
tComposition :: (String, String)
tComposition = ("(a -> b) -> (b -> c) -> (a -> c)", "comp")
-- | Fold.
tFold :: (String, String)
tFold = ("(a -> b -> b) -> b -> [a] -> b", "fold")
-- | Filter.
tFilter :: (String, String)
tFilter = ("(a -> Bool) -> [a] -> [a] ", "filter")
-- | Map.
tMap :: (String, String)
tMap = ("(a -> b) -> [a] -> [b]", "map")
-- | Konkatenacija.
tConcat :: (String, String)
tConcat = ("[[a]] -> [a]", "concat")
-- | Izmišljena 1.
tIzm :: (String, String)
tIzm = ("x -> (y -> [x -> [y]]) -> y", "f")
-- | Reverse.
tReverse :: (String, String)
tReverse = ("[x] -> [x]", "reverse")
| Trdonja/Zastonjski-izreki | Primeri.hs | gpl-3.0 | 1,236 | 0 | 5 | 254 | 190 | 125 | 65 | 17 | 1 |
module Interp(apply,arity) where
import Data.List((!!))
import Data.Map(Map,(!))
import SyntaxTree(Bits,Pattern(Literal,Binding,Wildcard),Expr(LiteralBits,Concat,Bound,Call),Definition(Def))
apply :: Map String [Definition] -> String -> [Bits] -> Bits
arity :: Map String [Definition] -> String -> Int
arity defs fn = case defs ! fn of (Def patterns _):_ -> length patterns
apply defs fn args =
let evalMatching Nothing (Def patterns expr) =
case bind patterns args [] of
Just bindings -> Just (eval defs bindings expr)
_ -> Nothing
evalMatching result _ = result
in case foldl evalMatching Nothing (defs ! fn) of
Just bits -> bits
_ -> error ("No matching pattern for "++fn)
bind :: [Pattern] -> [Bits] -> [Bits] -> Maybe [Bits]
bind (pattern:patterns) (arg:args) acc =
case pattern of
Literal bits ->
case matchArg bits arg of
Just [] -> bind patterns args acc
_ -> Nothing
Binding bits _ ->
case matchArg bits arg of
Just binding -> bind patterns args (binding:acc)
_ -> Nothing
Wildcard bits ->
case matchArg bits arg of
Just _ -> bind patterns args acc
_ -> Nothing
bind [] [] acc = Just (reverse acc)
matchArg (bit:bits) (argBit:argBits)
| bit == argBit = matchArg bits argBits
| otherwise = Nothing
matchArg [] arg = Just arg
matchArg _ [] = Nothing
eval :: Map String [Definition] -> [Bits] -> Expr -> Bits
eval _ _ (LiteralBits bits) = bits
eval defs bindings (Concat head tail) =
eval defs bindings head ++ eval defs bindings tail
eval _ bindings (Bound i) = bindings !! i
eval defs bindings (Call fn args) =
apply defs fn (map (eval defs bindings) args)
| qpliu/esolang | 01_/hs/interp/Interp.hs | gpl-3.0 | 1,870 | 0 | 14 | 569 | 738 | 379 | 359 | 44 | 6 |
module Command
( Command(..)
, readCommand
)
where
import Data.Char (isDigit)
import Data.Maybe
import Text.ParserCombinators.ReadP as P
import Types (Color(..))
data Command
= CmdColor Color
| CmdBlock Int Int Int
| CmdBrick Int Int
| CmdPlate Int Int
| CmdClone
| CmdDelete
| CmdMove
| CmdGroup
| CmdUngroup
| CmdRotate
deriving Show
readCommand :: [Char] -> Maybe Command
readCommand = fmap fst . listToMaybe . readP_to_S (command <* eof)
command = P.choice
[ cmdColor
, cmdBlock
, cmdBrick
, cmdPlate
, cmdClone
, cmdDelete
, cmdMove
, cmdGroup
, cmdUngroup
, cmdRotate
]
cmdColor = do
P.char 'c'
c <- P.get
CmdColor <$>
case c of
'b' -> return Blue
'B' -> return DarkBlue
'e' -> return Gray
'E' -> return DarkGray
'g' -> return Green
'G' -> return DarkGreen
'k' -> return Black
'l' -> return LightBlue
'o' -> return Brown
'r' -> return Red
't' -> return Tan
'w' -> return White
'y' -> return Yellow
_ -> pfail
cmdPlate = do
P.char 'p'
CmdPlate <$> (int <* char 'x') <*> int
cmdBrick = do
P.char 'b'
CmdBrick <$> (int <* char 'x') <*> int
cmdBlock = do
P.char 'B'
CmdBlock <$> (int <* char 'x') <*> (int <* char 'x') <*> int
cmdClone = const CmdClone <$> P.char ' '
cmdDelete = const CmdDelete <$> P.char 'x'
cmdMove = const CmdMove <$> P.char 'm'
cmdGroup = const CmdGroup <$> P.char 'g'
cmdUngroup = const CmdUngroup <$> P.char 'G'
cmdRotate = const CmdRotate <$> P.char 'r'
int :: ReadP Int
int = read <$> many1 (satisfy isDigit)
| holmisen/glbrix | src/Command.hs | gpl-3.0 | 1,676 | 0 | 12 | 498 | 585 | 298 | 287 | 68 | 14 |
-- | This module contains functions for generating & manipulating Widgets.
module Util.Widgets where
import Data.Maybe (fromJust)
import Import
-- | The GET value for a Sorting Option.
type SortValue = Text
-- | The display name for a Sorting Option.
type SortName = Text
-- | A list of possible Sorting Options for a data type.
type SortOptions a = [(SortValue, SortName, a -> a -> Ordering)]
-- | Create a dropdown widget for selecting Sorting Options.
sortWidget :: SortOptions a -> Widget
sortWidget sortOptions =
let dropdownOptions = map (\(a, b, _) -> (a, b)) sortOptions
in $(widgetFile "widgets/sortDropdownWidget")
-- | Sort the list using the comparison function of the given 'SortValue'.
sortListByOption :: SortOptions a -> SortValue -> [a] -> [a]
sortListByOption sortOptions sortValue = sortBy $ getThird sortResult
where getFirst (a, _, _) = a
getThird (_, _, c) = c
sortResult = fromJust $ find ((==) sortValue . getFirst)
sortOptions
-- | Attempt to pull a 'SortValue' from the GET Parameters, falling back to
-- a specified default.
getSortValue :: SortValue -> Handler SortValue
getSortValue val = fromMaybe val <$> runInputGet (iopt textField "sort")
| prikhi/MyBookList | Util/Widgets.hs | gpl-3.0 | 1,285 | 0 | 12 | 302 | 275 | 155 | 120 | -1 | -1 |
module Problems61thru69Spec where
import Problems61thru69
import ADT.Tree
import Test.Hspec
tree :: Tree Int
tree = Node (Node Nil 2 (leaf 4)) 1 (leaf 2)
spec :: Spec
spec = do
describe "countLeaves" $ do
it "can count leaves of a binary tree" $ do
countLeaves tree `shouldBe` 2
describe "leaves" $ do
it "can collect the leaves of a binary tree in a list" $ do
leaves tree `shouldBe` [4,2]
describe "internals" $ do
it "can collect the internal nodes of a binary tree in a list" $ do
internals tree `shouldBe` [1,2]
describe "atLevel" $ do
it "can collect the nodes at a given level in a list" $ do
atLevel tree 2 `shouldBe` [2,2]
| zcesur/h99 | tests/Problems61thru69Spec.hs | gpl-3.0 | 686 | 0 | 14 | 170 | 217 | 107 | 110 | 20 | 1 |
{-# LANGUAGE TypeOperators #-}
module Pearl.SWB.Section07 where
import Pearl.SWB.Section03 (
K(..)
, Gf(..)
, Lf(..)
, KList(..)
, SList(..)
, fold
, unfold
)
import Pearl.SWB.Section04 (
(:/\:)(..)
, (:\/:)(..)
, ( /\ )
, ( \/ )
, para
, apo
)
import Pearl.SWB.Section06 (
KTree(..)
, STree(..)
, (//\\)
, downcast
)
type Heap = KTree
-- We start with the natural transformation from the KTree, sprout:
--
-- @
-- sprout :: KList (l :/\: STree l) -> STree (l :\/: KList l)
-- sprout KNil = KE
-- sprout (KCons a (As t KE )) = (//\\) (Paws t ) a (Paws t )
-- sprout (KCons a (As t (KY l b r ) ))
-- | a <= b = (//\\) (Play (KCons a l)) b (Paws r )
-- | otherwise = (//\\) (Paws l) b (Play (KCons a r))
-- @
--
pile :: KList (l :/\: STree l) -> STree (l :\/: KList l)
pile KNil = KE
pile (KCons a (As t KE )) = (//\\) (Paws t ) a (Paws t )
pile (KCons a (As t (KY l b r ) ))
-- = (//\\) (Play (KCons (a `max` b) l)) (a `min` b) (Paws r)
-- = (//\\) (Play (KCons (a `max` b) r)) (a `min` b) (Paws l)
-- = (//\\) (Paws l) (a `max` b) (Play (KCons (a `min` b) r))
= (//\\) (Paws r) (a `max` b) (Play (KCons (a `min` b) l))
-- ^
-- >>> :t pile
-- we want a:
--
-- KList algebra
-- Heap co-algebra
--
--
-- So we start with treeIn:
--
treeIn :: KList (Gf STree) -> STree (Gf STree :\/: KList (Gf STree))
treeIn KNil = KE
treeIn (KCons a (OutO KE )) = (//\\) (Paws (OutO KE) ) a (Paws (OutO KE ))
treeIn (KCons a (OutO (KY l b r ) ))
| a <= b = (//\\) (Play (KCons a l)) b (Paws r )
| otherwise = (//\\) (Paws l) b (Play (KCons a r))
--
-- ^
-- All we need to do is change the guards:
--
-- @
-- | a <= b = (//\\) (Play (KCons a l)) b (Paws r )
-- | otherwise = (//\\) (Paws l) b (Play (KCons a r))
-- becomes:
-- | a <= b = (//\\) (Play (KCons a l)) a (Paws l )
-- | otherwise = (//\\) (Play (KCons a r)) b (Paws l )
-- @
heapIn :: KList (Gf Heap ) -> Heap (Gf Heap :\/: KList (Gf Heap ))
heapIn KNil = KE
heapIn (KCons a (OutO KE )) = (//\\) (Paws (OutO KE) ) a (Paws (OutO KE ))
heapIn (KCons a (OutO (KY l b r ) ))
| a <= b = (//\\) (Play (KCons b l)) a (Paws l )
| otherwise = (//\\) (Play (KCons a r)) b (Paws l )
blah0 = apo heapIn
-- Finally, we start with 'pivot' and end up with 'diivy':
--
--
pivot :: KList (STree (Lf KList)) -> STree (Lf KList)
pivot KNil = KE
pivot (KCons a KE ) = (//\\) (In (KNil )) a (In (KNil ))
pivot (KCons a (KY l b r))
| a <= b = (//\\) (In (KCons a l)) b ( r )
| otherwise = (//\\) ( l ) b (In (KCons a r))
-- Again, the top two cases are identical.
--
divvy :: KList (Heap (Lf KList)) -> Heap (Lf KList)
divvy KNil = KE
divvy (KCons a KE ) = (//\\) (In (KNil )) a (In (KNil ))
divvy (KCons a (KY l b r))
| a <= b = (//\\) (In (KCons b r)) a ( l )
| otherwise = (//\\) (In (KCons a r)) b ( l )
-- ^
-- as usual, we had to correct the guarded cases.
foldWithDivvy = fold divvy
unfoldWithDivvy = unfold (para ( fmap (id \/ In) . blend ))
sift :: Heap (t :/\: SList t) -> SList (t :\/: Heap t)
sift KE = SNil
sift (KY (As l SNil ) a (As r ____________ ) ) = SCons a (Paws r)
sift (KY (As l __________ ) a (As r SNil ) ) = SCons a (Paws l)
sift (KY (As l (SCons b l') ) a (As r (SCons d r') ) )
| b <= d = SCons a (Play (KY l' b r ))
| otherwise = SCons a (Play (KY l d r'))
meld :: Heap (Lf Heap :/\: SList (Lf Heap )) -> SList (Lf Heap )
meld KE = SNil
meld (KY (As l SNil ) a (As r ____________ ) ) = SCons a r
meld (KY (As l __________ ) a (As r SNil ) ) = SCons a l
meld (KY (As l (SCons b l') ) a (As r (SCons d r') ) )
| b <= d = SCons a (In (KY l' b r ))
| otherwise = SCons a (In (KY l d r'))
-- ^ meld is sometimes known as 'deleteMin' in a priorityqueue library
blend :: Heap (t :/\: SList t) -> SList (t :\/: Heap t)
blend KE = SNil
blend (KY (As l SNil ) a (As r ____________ ) ) = SCons a (Paws r)
blend (KY (As l __________ ) a (As r SNil ) ) = SCons a (Paws l)
blend (KY (As l (SCons b l') ) a (As r (SCons d r') ) )
| b <= d = SCons a (Play (KY l' b r ))
| otherwise = SCons a (Play (KY l d r'))
blah = para meld
tMerge = apo (blend . fmap (id /\ insideO))
heapSort = unfold deleteMin . downcast . fold heapInsert
where deleteMin = para meld
heapInsert = apo heapIn
mingleSort = fold tMerge . downcast . unfold (fold divvy)
data Bush b = Leaf K | Y b b
data List1 l1 = Single K | Push K l1
data Rose r = Rose K [r]
| technogeeky/pearl-sorting-with-bialgebras | src/Pearl/SWB/Section07.hs | gpl-3.0 | 6,233 | 0 | 12 | 2,989 | 2,049 | 1,071 | 978 | -1 | -1 |
module TaskTree.Cli.Run
( runCmd
, load
)
where
import TaskTree.Cli.Cmd
import TaskTree.Cli.Draw (draw)
import TaskTree.Lib (Forest, Task, loadForest)
runCmd :: Forest Task -> Cmd -> IO (Forest Task)
runCmd ts (Load f) = load ts f
runCmd ts (Save f) = save ts f
runCmd ts (Edit s) = edit ts s
runCmd ts Print = prnt ts
-- TODO move to Lib/File.hs?
load :: Forest Task -> FilePath -> IO (Forest Task)
load ts f = do
putStr $ "loading " ++ f ++ "..."
s <- readFile f
putStrLn "ok"
case loadForest s of
Right ts' -> prnt ts'
Left _ -> do
putStrLn $ "error: " ++ f
return ts
save :: Forest Task -> FilePath -> IO (Forest Task)
save = undefined
edit :: Forest Task -> String -> IO (Forest Task)
edit ts _ = return ts
prnt :: Forest Task -> IO (Forest Task)
prnt ts = mapM_ (\t -> draw t 3 "") ts >> return ts
| jefdaj/todotree | old/TaskTree/Cli/Run.hs | gpl-3.0 | 856 | 0 | 13 | 216 | 388 | 190 | 198 | 27 | 2 |
-- ProjectEuler assignment 9
-- find the special Pythagorean triples for which a + b + c = 1000
-- Since the sum of the triplets is 1000, the maximum value of c can also be 1000.
-- Since it's a natural number, a^2 + b^2 should be in the list of squared values from 0 .. 1000
-- Takes some time, but resolves to 31875000
main = print $ findTriplet 1 2
findTriplet :: Int -> Int -> Int
findTriplet 1000 _ = -1
findTriplet a b | (a + b) > 1000 = findTriplet (a+1) (a+2)
| triplet a b = a * b * (calcSide a b)
| otherwise = findTriplet a (b+1)
triplet :: Int -> Int -> Bool
triplet a b = (isSquare (calcSquared a b)) && (sumValid a b (calcSide a b))
calcSide :: Int -> Int -> Int
calcSide a b = floor $ sqrt $ fromIntegral $ calcSquared a b
calcSquared :: Int -> Int -> Int
calcSquared a b = (a^2 + b^2)
isSquare :: Int -> Bool
isSquare a = contains possibleSquares a
contains :: [Int] -> Int -> Bool
contains [] a = False
contains (x:xs) a | a == x = True
| otherwise = contains xs a
possibleSquares :: [Int]
possibleSquares = squares 1000
squares :: Int -> [Int]
squares a = take a $ map (^2) [1..]
sumValid :: Int -> Int -> Int -> Bool
sumValid a b c = a + b + c == 1000
| vdweegen/UvA-Software_Testing | Lab1/Bauke/ProjectEuler9.hs | gpl-3.0 | 1,235 | 0 | 10 | 316 | 466 | 238 | 228 | 24 | 1 |
module Main where
import Control.Arrow
import System.IO (hPutStrLn, stderr)
import Text.XML.HXT.Core
import Text.ParserCombinators.Parsec
import Data.List (intercalate)
import Text.Parse.SvgPath.PathParser
( Path
, PathInstruction
, parsePath
, convertToAbsolute
, pathBounds
, scaleToFit
, dumbGcode
)
getDoc = readDocument [] ""
printBed = ((-90.0,-90.0),(90.0,90.0))
main :: IO ()
main = do
result <- runX (getDoc >>> selectAllPaths)
let nonZeroLength [] = False
nonZeroLength _ = True
pathFromEither p = case parsePath p of Left err -> []
Right p -> p
paths = filter nonZeroLength $ map pathFromEither result
path = concat $ map convertToAbsolute paths
bounds = pathBounds path
let path' = scaleToFit printBed path
putStrLn $ "; New bounds " ++ (show $ pathBounds path')
putStrLn $ intercalate "\n" (map dumbGcode path')
selectAllPaths :: ArrowXml a => a XmlTree String
selectAllPaths = deep
( isElem >>> hasName "path"
>>>
getAttrValue "d"
)
| r24y/svg2gcode | Svg2Gcode.hs | gpl-3.0 | 1,127 | 0 | 13 | 321 | 339 | 178 | 161 | 34 | 3 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- |
-- Module : Network.Google.Resource.Compute.MachineTypes.AggregatedList
-- Copyright : (c) 2015-2016 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves an aggregated list of machine types.
--
-- /See:/ <https://developers.google.com/compute/docs/reference/latest/ Compute Engine API Reference> for @compute.machineTypes.aggregatedList@.
module Network.Google.Resource.Compute.MachineTypes.AggregatedList
(
-- * REST Resource
MachineTypesAggregatedListResource
-- * Creating a Request
, machineTypesAggregatedList
, MachineTypesAggregatedList
-- * Request Lenses
, mtalIncludeAllScopes
, mtalReturnPartialSuccess
, mtalOrderBy
, mtalProject
, mtalFilter
, mtalPageToken
, mtalMaxResults
) where
import Network.Google.Compute.Types
import Network.Google.Prelude
-- | A resource alias for @compute.machineTypes.aggregatedList@ method which the
-- 'MachineTypesAggregatedList' request conforms to.
type MachineTypesAggregatedListResource =
"compute" :>
"v1" :>
"projects" :>
Capture "project" Text :>
"aggregated" :>
"machineTypes" :>
QueryParam "includeAllScopes" Bool :>
QueryParam "returnPartialSuccess" Bool :>
QueryParam "orderBy" Text :>
QueryParam "filter" Text :>
QueryParam "pageToken" Text :>
QueryParam "maxResults" (Textual Word32) :>
QueryParam "alt" AltJSON :>
Get '[JSON] MachineTypeAggregatedList
-- | Retrieves an aggregated list of machine types.
--
-- /See:/ 'machineTypesAggregatedList' smart constructor.
data MachineTypesAggregatedList =
MachineTypesAggregatedList'
{ _mtalIncludeAllScopes :: !(Maybe Bool)
, _mtalReturnPartialSuccess :: !(Maybe Bool)
, _mtalOrderBy :: !(Maybe Text)
, _mtalProject :: !Text
, _mtalFilter :: !(Maybe Text)
, _mtalPageToken :: !(Maybe Text)
, _mtalMaxResults :: !(Textual Word32)
}
deriving (Eq, Show, Data, Typeable, Generic)
-- | Creates a value of 'MachineTypesAggregatedList' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'mtalIncludeAllScopes'
--
-- * 'mtalReturnPartialSuccess'
--
-- * 'mtalOrderBy'
--
-- * 'mtalProject'
--
-- * 'mtalFilter'
--
-- * 'mtalPageToken'
--
-- * 'mtalMaxResults'
machineTypesAggregatedList
:: Text -- ^ 'mtalProject'
-> MachineTypesAggregatedList
machineTypesAggregatedList pMtalProject_ =
MachineTypesAggregatedList'
{ _mtalIncludeAllScopes = Nothing
, _mtalReturnPartialSuccess = Nothing
, _mtalOrderBy = Nothing
, _mtalProject = pMtalProject_
, _mtalFilter = Nothing
, _mtalPageToken = Nothing
, _mtalMaxResults = 500
}
-- | Indicates whether every visible scope for each scope type (zone, region,
-- global) should be included in the response. For new resource types added
-- after this field, the flag has no effect as new resource types will
-- always include every visible scope for each scope type in response. For
-- resource types which predate this field, if this flag is omitted or
-- false, only scopes of the scope types where the resource type is
-- expected to be found will be included.
mtalIncludeAllScopes :: Lens' MachineTypesAggregatedList (Maybe Bool)
mtalIncludeAllScopes
= lens _mtalIncludeAllScopes
(\ s a -> s{_mtalIncludeAllScopes = a})
-- | Opt-in for partial success behavior which provides partial results in
-- case of failure. The default value is false.
mtalReturnPartialSuccess :: Lens' MachineTypesAggregatedList (Maybe Bool)
mtalReturnPartialSuccess
= lens _mtalReturnPartialSuccess
(\ s a -> s{_mtalReturnPartialSuccess = a})
-- | Sorts list results by a certain order. By default, results are returned
-- in alphanumerical order based on the resource name. You can also sort
-- results in descending order based on the creation timestamp using
-- \`orderBy=\"creationTimestamp desc\"\`. This sorts results based on the
-- \`creationTimestamp\` field in reverse chronological order (newest
-- result first). Use this to sort resources like operations so that the
-- newest operation is returned first. Currently, only sorting by \`name\`
-- or \`creationTimestamp desc\` is supported.
mtalOrderBy :: Lens' MachineTypesAggregatedList (Maybe Text)
mtalOrderBy
= lens _mtalOrderBy (\ s a -> s{_mtalOrderBy = a})
-- | Project ID for this request.
mtalProject :: Lens' MachineTypesAggregatedList Text
mtalProject
= lens _mtalProject (\ s a -> s{_mtalProject = a})
-- | A filter expression that filters resources listed in the response. The
-- expression must specify the field name, a comparison operator, and the
-- value that you want to use for filtering. The value must be a string, a
-- number, or a boolean. The comparison operator must be either \`=\`,
-- \`!=\`, \`>\`, or \`\<\`. For example, if you are filtering Compute
-- Engine instances, you can exclude instances named \`example-instance\`
-- by specifying \`name != example-instance\`. You can also filter nested
-- fields. For example, you could specify \`scheduling.automaticRestart =
-- false\` to include instances only if they are not scheduled for
-- automatic restarts. You can use filtering on nested fields to filter
-- based on resource labels. To filter on multiple expressions, provide
-- each separate expression within parentheses. For example: \`\`\`
-- (scheduling.automaticRestart = true) (cpuPlatform = \"Intel Skylake\")
-- \`\`\` By default, each expression is an \`AND\` expression. However,
-- you can include \`AND\` and \`OR\` expressions explicitly. For example:
-- \`\`\` (cpuPlatform = \"Intel Skylake\") OR (cpuPlatform = \"Intel
-- Broadwell\") AND (scheduling.automaticRestart = true) \`\`\`
mtalFilter :: Lens' MachineTypesAggregatedList (Maybe Text)
mtalFilter
= lens _mtalFilter (\ s a -> s{_mtalFilter = a})
-- | Specifies a page token to use. Set \`pageToken\` to the
-- \`nextPageToken\` returned by a previous list request to get the next
-- page of results.
mtalPageToken :: Lens' MachineTypesAggregatedList (Maybe Text)
mtalPageToken
= lens _mtalPageToken
(\ s a -> s{_mtalPageToken = a})
-- | The maximum number of results per page that should be returned. If the
-- number of available results is larger than \`maxResults\`, Compute
-- Engine returns a \`nextPageToken\` that can be used to get the next page
-- of results in subsequent list requests. Acceptable values are \`0\` to
-- \`500\`, inclusive. (Default: \`500\`)
mtalMaxResults :: Lens' MachineTypesAggregatedList Word32
mtalMaxResults
= lens _mtalMaxResults
(\ s a -> s{_mtalMaxResults = a})
. _Coerce
instance GoogleRequest MachineTypesAggregatedList
where
type Rs MachineTypesAggregatedList =
MachineTypeAggregatedList
type Scopes MachineTypesAggregatedList =
'["https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/compute",
"https://www.googleapis.com/auth/compute.readonly"]
requestClient MachineTypesAggregatedList'{..}
= go _mtalProject _mtalIncludeAllScopes
_mtalReturnPartialSuccess
_mtalOrderBy
_mtalFilter
_mtalPageToken
(Just _mtalMaxResults)
(Just AltJSON)
computeService
where go
= buildClient
(Proxy :: Proxy MachineTypesAggregatedListResource)
mempty
| brendanhay/gogol | gogol-compute/gen/Network/Google/Resource/Compute/MachineTypes/AggregatedList.hs | mpl-2.0 | 8,333 | 0 | 20 | 1,772 | 842 | 503 | 339 | 123 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- |
-- Module : Network.Google.Resource.Logging.Folders.Sinks.Delete
-- Copyright : (c) 2015-2016 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes a sink. If the sink has a unique writer_identity, then that
-- service account is also deleted.
--
-- /See:/ <https://cloud.google.com/logging/docs/ Stackdriver Logging API Reference> for @logging.folders.sinks.delete@.
module Network.Google.Resource.Logging.Folders.Sinks.Delete
(
-- * REST Resource
FoldersSinksDeleteResource
-- * Creating a Request
, foldersSinksDelete
, FoldersSinksDelete
-- * Request Lenses
, fsdXgafv
, fsdUploadProtocol
, fsdPp
, fsdAccessToken
, fsdUploadType
, fsdBearerToken
, fsdSinkName
, fsdCallback
) where
import Network.Google.Logging.Types
import Network.Google.Prelude
-- | A resource alias for @logging.folders.sinks.delete@ method which the
-- 'FoldersSinksDelete' request conforms to.
type FoldersSinksDeleteResource =
"v2" :>
Capture "sinkName" Text :>
QueryParam "$.xgafv" Xgafv :>
QueryParam "upload_protocol" Text :>
QueryParam "pp" Bool :>
QueryParam "access_token" Text :>
QueryParam "uploadType" Text :>
QueryParam "bearer_token" Text :>
QueryParam "callback" Text :>
QueryParam "alt" AltJSON :> Delete '[JSON] Empty
-- | Deletes a sink. If the sink has a unique writer_identity, then that
-- service account is also deleted.
--
-- /See:/ 'foldersSinksDelete' smart constructor.
data FoldersSinksDelete = FoldersSinksDelete'
{ _fsdXgafv :: !(Maybe Xgafv)
, _fsdUploadProtocol :: !(Maybe Text)
, _fsdPp :: !Bool
, _fsdAccessToken :: !(Maybe Text)
, _fsdUploadType :: !(Maybe Text)
, _fsdBearerToken :: !(Maybe Text)
, _fsdSinkName :: !Text
, _fsdCallback :: !(Maybe Text)
} deriving (Eq,Show,Data,Typeable,Generic)
-- | Creates a value of 'FoldersSinksDelete' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'fsdXgafv'
--
-- * 'fsdUploadProtocol'
--
-- * 'fsdPp'
--
-- * 'fsdAccessToken'
--
-- * 'fsdUploadType'
--
-- * 'fsdBearerToken'
--
-- * 'fsdSinkName'
--
-- * 'fsdCallback'
foldersSinksDelete
:: Text -- ^ 'fsdSinkName'
-> FoldersSinksDelete
foldersSinksDelete pFsdSinkName_ =
FoldersSinksDelete'
{ _fsdXgafv = Nothing
, _fsdUploadProtocol = Nothing
, _fsdPp = True
, _fsdAccessToken = Nothing
, _fsdUploadType = Nothing
, _fsdBearerToken = Nothing
, _fsdSinkName = pFsdSinkName_
, _fsdCallback = Nothing
}
-- | V1 error format.
fsdXgafv :: Lens' FoldersSinksDelete (Maybe Xgafv)
fsdXgafv = lens _fsdXgafv (\ s a -> s{_fsdXgafv = a})
-- | Upload protocol for media (e.g. \"raw\", \"multipart\").
fsdUploadProtocol :: Lens' FoldersSinksDelete (Maybe Text)
fsdUploadProtocol
= lens _fsdUploadProtocol
(\ s a -> s{_fsdUploadProtocol = a})
-- | Pretty-print response.
fsdPp :: Lens' FoldersSinksDelete Bool
fsdPp = lens _fsdPp (\ s a -> s{_fsdPp = a})
-- | OAuth access token.
fsdAccessToken :: Lens' FoldersSinksDelete (Maybe Text)
fsdAccessToken
= lens _fsdAccessToken
(\ s a -> s{_fsdAccessToken = a})
-- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").
fsdUploadType :: Lens' FoldersSinksDelete (Maybe Text)
fsdUploadType
= lens _fsdUploadType
(\ s a -> s{_fsdUploadType = a})
-- | OAuth bearer token.
fsdBearerToken :: Lens' FoldersSinksDelete (Maybe Text)
fsdBearerToken
= lens _fsdBearerToken
(\ s a -> s{_fsdBearerToken = a})
-- | Required. The full resource name of the sink to delete, including the
-- parent resource and the sink identifier:
-- \"projects\/[PROJECT_ID]\/sinks\/[SINK_ID]\"
-- \"organizations\/[ORGANIZATION_ID]\/sinks\/[SINK_ID]\" It is an error if
-- the sink does not exist. Example:
-- \"projects\/my-project-id\/sinks\/my-sink-id\". It is an error if the
-- sink does not exist.
fsdSinkName :: Lens' FoldersSinksDelete Text
fsdSinkName
= lens _fsdSinkName (\ s a -> s{_fsdSinkName = a})
-- | JSONP
fsdCallback :: Lens' FoldersSinksDelete (Maybe Text)
fsdCallback
= lens _fsdCallback (\ s a -> s{_fsdCallback = a})
instance GoogleRequest FoldersSinksDelete where
type Rs FoldersSinksDelete = Empty
type Scopes FoldersSinksDelete =
'["https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/logging.admin"]
requestClient FoldersSinksDelete'{..}
= go _fsdSinkName _fsdXgafv _fsdUploadProtocol
(Just _fsdPp)
_fsdAccessToken
_fsdUploadType
_fsdBearerToken
_fsdCallback
(Just AltJSON)
loggingService
where go
= buildClient
(Proxy :: Proxy FoldersSinksDeleteResource)
mempty
| rueshyna/gogol | gogol-logging/gen/Network/Google/Resource/Logging/Folders/Sinks/Delete.hs | mpl-2.0 | 5,699 | 0 | 17 | 1,351 | 860 | 503 | 357 | 121 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- |
-- Module : Network.Google.Resource.Compute.Routers.Get
-- Copyright : (c) 2015-2016 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns the specified Router resource. Gets a list of available routers
-- by making a list() request.
--
-- /See:/ <https://developers.google.com/compute/docs/reference/latest/ Compute Engine API Reference> for @compute.routers.get@.
module Network.Google.Resource.Compute.Routers.Get
(
-- * REST Resource
RoutersGetResource
-- * Creating a Request
, routersGet
, RoutersGet
-- * Request Lenses
, rggProject
, rggRouter
, rggRegion
) where
import Network.Google.Compute.Types
import Network.Google.Prelude
-- | A resource alias for @compute.routers.get@ method which the
-- 'RoutersGet' request conforms to.
type RoutersGetResource =
"compute" :>
"v1" :>
"projects" :>
Capture "project" Text :>
"regions" :>
Capture "region" Text :>
"routers" :>
Capture "router" Text :>
QueryParam "alt" AltJSON :> Get '[JSON] Router
-- | Returns the specified Router resource. Gets a list of available routers
-- by making a list() request.
--
-- /See:/ 'routersGet' smart constructor.
data RoutersGet =
RoutersGet'
{ _rggProject :: !Text
, _rggRouter :: !Text
, _rggRegion :: !Text
}
deriving (Eq, Show, Data, Typeable, Generic)
-- | Creates a value of 'RoutersGet' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'rggProject'
--
-- * 'rggRouter'
--
-- * 'rggRegion'
routersGet
:: Text -- ^ 'rggProject'
-> Text -- ^ 'rggRouter'
-> Text -- ^ 'rggRegion'
-> RoutersGet
routersGet pRggProject_ pRggRouter_ pRggRegion_ =
RoutersGet'
{ _rggProject = pRggProject_
, _rggRouter = pRggRouter_
, _rggRegion = pRggRegion_
}
-- | Project ID for this request.
rggProject :: Lens' RoutersGet Text
rggProject
= lens _rggProject (\ s a -> s{_rggProject = a})
-- | Name of the Router resource to return.
rggRouter :: Lens' RoutersGet Text
rggRouter
= lens _rggRouter (\ s a -> s{_rggRouter = a})
-- | Name of the region for this request.
rggRegion :: Lens' RoutersGet Text
rggRegion
= lens _rggRegion (\ s a -> s{_rggRegion = a})
instance GoogleRequest RoutersGet where
type Rs RoutersGet = Router
type Scopes RoutersGet =
'["https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/compute",
"https://www.googleapis.com/auth/compute.readonly"]
requestClient RoutersGet'{..}
= go _rggProject _rggRegion _rggRouter (Just AltJSON)
computeService
where go
= buildClient (Proxy :: Proxy RoutersGetResource)
mempty
| brendanhay/gogol | gogol-compute/gen/Network/Google/Resource/Compute/Routers/Get.hs | mpl-2.0 | 3,536 | 0 | 16 | 860 | 468 | 280 | 188 | 75 | 1 |
-- | This module contains the definitions for a generic parser, without
-- running state. These are the parts that are shared between the Plain
-- and Lazy variations. Do not import this module directly, but only
-- via T.P.Poly.Plain or T.P.Poly.Lazy.
module Text.ParserCombinators.Poly.Parser
( -- * The Parser datatype
Parser(P) -- datatype, instance of: Functor, Monad, PolyParse
, Result(..) -- internal to the Parser Monad.
-- ** Basic parsers
, next -- :: Parser t t
, eof -- :: Parser t ()
, satisfy -- :: (t->Bool) -> Parser t t
, satisfyMsg -- :: Show t => (t->Bool) -> String -> Parser t t
, onFail -- :: Parser t a -> Parser t a -> Parser t a
-- ** Re-parsing
, reparse -- :: [t] -> Parser t ()
) where
import Text.ParserCombinators.Poly.Base
import Text.ParserCombinators.Poly.Result
import Control.Applicative
import Control.Monad (liftM, ap)
-- | This @Parser@ datatype is a fairly generic parsing monad with error
-- reporting. It can be used for arbitrary token types, not just
-- String input. (If you require a running state, use module Poly.State
-- instead)
newtype Parser t a = P ([t] -> Result [t] a)
instance Functor (Parser t) where
fmap f (P p) = P (fmap f . p)
instance Applicative (Parser t) where
pure f = return f
pf <*> px = do { f <- pf; x <- px; return (f x) }
#if defined(GLASGOW_HASKELL) && GLASGOW_HASKELL > 610
p <* q = p `discard` q
#endif
instance Alternative (Parser t) where
empty = fail "no parse"
p <|> q = p `onFail` q
instance Monad (Parser t) where
return x = P (\ts-> Success ts x)
fail e = P (\ts-> Failure ts e)
(P f) >>= g = P (continue . f)
where
continue (Success ts x) = let (P g') = g x in g' ts
continue (Committed r) = Committed (continue r)
continue (Failure ts e) = Failure ts e
instance Commitment (Parser t) where
commit (P p) = P (Committed . squash . p)
where
squash (Committed r) = squash r
squash r = r
(P p) `adjustErr` f = P (adjust . p)
where
adjust (Failure z e) = Failure z (f e)
adjust (Committed r) = Committed (adjust r)
adjust good = good
oneOf' = accum []
where accum errs [] =
fail ("failed to parse any of the possible choices:\n"
++indent 2 (concatMap showErr (reverse errs)))
accum errs ((e,P p):ps) =
P (\ts-> case p ts of
Failure _ err ->
let (P p) = accum ((e,err):errs) ps
in p ts
r@(Success z a) -> r
r@(Committed _) -> r )
showErr (name,err) = name++":\n"++indent 2 err
infixl 6 `onFail` -- not sure about precedence 6?
-- | @p `onFail` q@ means parse p, unless p fails, in which case
-- parse q instead.
-- Can be chained together to give multiple attempts to parse something.
-- (Note that q could itself be a failing parser, e.g. to change the error
-- message from that defined in p to something different.)
-- However, a severe failure in p cannot be ignored.
onFail :: Parser t a -> Parser t a -> Parser t a
(P p) `onFail` (P q) = P (\ts-> continue ts $ p ts)
where
continue ts (Failure z e) = q ts
-- continue _ (Committed r) = r -- no, remain Committed
continue _ r = r
------------------------------------------------------------------------
-- | Simply return the next token in the input tokenstream.
next :: Parser t t
next = P (\ts-> case ts of
[] -> Failure [] "Ran out of input (EOF)"
(t:ts') -> Success ts' t )
-- | Succeed if the end of file/input has been reached, fail otherwise.
eof :: Parser t ()
eof = P (\ts-> case ts of
[] -> Success [] ()
(t:ts') -> Failure ts "Expected end of input (EOF)" )
-- | Return the next token if it satisfies the given predicate.
satisfy :: (t->Bool) -> Parser t t
satisfy pred = do { x <- next
; if pred x then return x else fail "Parse.satisfy: failed"
}
-- | Return the next token if it satisfies the given predicate. The
-- String argument describes the function, for better error messages.
satisfyMsg :: Show t => (t->Bool) -> String -> Parser t t
satisfyMsg pred s
= do { x <- next
; if pred x then return x
else fail $ "Parse.satisfy ("++s++") ("
++show x++"): failed"
}
------------------------------------------------------------------------
-- | Push some tokens back onto the front of the input stream and reparse.
-- This is useful e.g. for recursively expanding macros. When the
-- user-parser recognises a macro use, it can lookup the macro
-- expansion from the parse state, lex it, and then stuff the
-- lexed expansion back down into the parser.
reparse :: [t] -> Parser t ()
reparse ts = P (\inp-> Success (ts++inp) ())
------------------------------------------------------------------------
| Kludgy/polyparse-fork | src/Text/ParserCombinators/Poly/Parser.hs | lgpl-2.1 | 5,311 | 0 | 21 | 1,692 | 1,295 | 683 | 612 | 76 | 2 |
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ApplicativeDo #-}
module Main where
import Control.Applicative
import Control.Concurrent.STM
import KVOperation
import Action
import Backend
--import MonadAction
import DSL
import qualified MemBackend
import qualified Aggregator
import qualified Future
import qualified TransactionBuilder
import qualified BatchedTransactionBuilder
import qualified Transaction
-- | Generic runner
run :: (Monad m, Functor m, Applicative m) => (forall c. b c -> m c) -> DSL b a -> m a
run runDSL m =
case m of
Pure x ->
return x
Single (Action instruction f) ->
fmap f $ runDSL instruction
MonadBind a b ->
run runDSL a >>= \result -> run runDSL $ b result
ApBind a b ->
run runDSL a <*> run runDSL b
-- | Execute optimzed: queue all backend operations on the Aggregator, wrap the result in a Future and only force the
-- | evaluation of the Future when we need the result. Piggy-back all outstanding operations on the back-end operation
-- | needed to force the evaluation of that specific Future.
recRunBatched :: (forall b. (c b -> IO (Future.FutureT IO b))) -> DSL c a -> IO (Future.FutureT IO a)
recRunBatched aggregate m =
case m of
Pure x -> return $ pure x
Single (Action action f) -> do
future <- aggregate action
return $ fmap f future
MonadBind a b -> do
future <- recRunBatched aggregate a
result <- Future.force future
recRunBatched aggregate $ b result
ApBind a b -> do
future1 <- recRunBatched aggregate a
future2 <- recRunBatched aggregate b
return $ future1 <*> future2
runBatched :: Backend -> DSL KVOperation a -> IO a
runBatched backend m = do
aggregator <- Aggregator.create backend
result <- recRunBatched (Aggregator.add aggregator) m
Future.force result
buildTransactionBatched :: Backend -> DSL KVOperation a -> IO (a, Transaction.Transaction)
buildTransactionBatched backend m = do
aggregator <- Aggregator.create backend
transactionBuilder <- BatchedTransactionBuilder.create aggregator
futureResult <- recRunBatched (BatchedTransactionBuilder.add transactionBuilder) m
result <- Future.force futureResult
transaction <- BatchedTransactionBuilder.toTransaction transactionBuilder
return (result, transaction)
-- | Build a transaction based on the GET/PUT operations
-- | Gather all the input data (i.e. GET's on keys that were not yet modified in this transaction)
-- | Return a list of ASSERTS and PUTS which defines the transaction
buildTransaction :: Backend -> DSL KVOperation a -> IO (a, Transaction.Transaction)
buildTransaction backend m = do
transactionBuilder <- atomically $ TransactionBuilder.create backend
result <- run (TransactionBuilder.add transactionBuilder) m
transaction <- atomically $ TransactionBuilder.toTransaction transactionBuilder
return (result, transaction)
-- | EXAMPLES
-- | Building blocks, shorthand for the 2 basic operations
get :: String -> DSL KVOperation String
get key = Single $ Action (Get key) id
put :: String -> String -> DSL KVOperation ()
put key value = Single $ Action (Put key value) (const ())
getBatchSampleBackend :: IO Backend
getBatchSampleBackend = do
backend <- MemBackend.create
runBatched backend $
put "user_7_pass" "7DFJ45FDXM" *>
put "user_7_site" "www.haskell.org" *>
put "user_12_pass" "DFGRED43S" *>
put "user_12_site" "www.ocaml.org" *>
put "user_18_pass" "DSZWQ52VB23V" *>
put "user_18_site" "www.scala.org" *>
put "default_site" "www.zombo.com"
return backend
getBatch :: DSL KVOperation (String,String,String)
getBatch = (,,) <$>
get "user_7_pass" <*>
get "user_12_pass" <*>
get "user_18_pass" >>=
\(pass7, pass12, pass18) -> (,,) <$>
(if (check 7 pass7) then get "user_7_site" else get "default_site") <*>
(if (check 12 pass12) then get "user_12_site" else get "default_site") <*>
(if (check 18 pass18) then get "user_18_site" else get "default_site")
where
check 7 _ = True
check 12 _ = False
check 18 _ = False
getBatchDo :: DSL KVOperation (String,String,String)
getBatchDo = do
pass7 <- get "user_7_pass"
pass12 <- get "user_12_pass"
pass18 <- get "user_18_pass"
site7 <- if (check 7 pass7) then get "user_7_site" else get "default_site"
site12 <- if (check 12 pass12) then get "user_12_site" else get "default_site"
site18 <- if (check 18 pass18) then get "user_18_site" else get "default_site"
pure (site7, site12, site18)
where
check 7 _ = True
check 12 _ = False
check 18 _ = False
getBatchDoReorder :: DSL KVOperation (String,String,String)
getBatchDoReorder = do
pass7 <- get "user_7_pass"
site7 <- if (check 7 pass7) then get "user_7_site" else get "default_site"
pass12 <- get "user_12_pass"
site12 <- if (check 12 pass12) then get "user_12_site" else get "default_site"
pass18 <- get "user_18_pass"
site18 <- if (check 18 pass18) then get "user_18_site" else get "default_site"
pure (site7, site12, site18)
where
check 7 _ = True
check 12 _ = False
check 18 _ = False
batchStepDo :: String -> (String -> String -> Bool) -> DSL KVOperation String
batchStepDo userId check = do
pass <- get $ "user_" ++ userId ++ "_pass"
site <- if (check userId pass) then get $ "user_" ++ userId ++ "_site" else get "default_site"
return site
getBatchDoStep :: DSL KVOperation (String,String,String)
getBatchDoStep = do
site7 <- batchStepDo "7" check
site12 <- batchStepDo "12" check
site18 <- batchStepDo "18" check
pure (site7, site12, site18)
where
check "7" _ = True
check "12" _ = False
check "18" _ = False
addUserSampleBackend :: IO Backend
addUserSampleBackend = do
backend <- MemBackend.create
runBatched backend $
put "user_7_pass" "7DFJ45FDXM" *>
put "user_7_site" "www.haskell.org" *>
put "user_12_pass" "DFGRED43S" *>
put "user_12_site" "www.ocaml.org" *>
put "user_count" "17"
return backend
addUser :: String -> String -> DSL KVOperation ()
addUser password site = do
numberOfUsers <- read <$> get "user_count"
let nextUser = show $ numberOfUsers + 1
put ("user_" ++ nextUser ++ "_pass") password
put ("user_" ++ nextUser ++ "_site") site
put "user_count" nextUser
batchExample :: IO ()
batchExample = do
putStrLn "Batching example"
putStrLn "\nFill backend"
sampleBackend <- getBatchSampleBackend
putStrLn "\nStart batched run"
_result <- runBatched sampleBackend getBatchDoStep
putStrLn "\nBatched run done"
return ()
transactionExample :: IO ()
transactionExample = do
putStrLn "Transaction example"
putStrLn "\nFill backend"
sampleBackend <- addUserSampleBackend
putStrLn "\nStart transaction build"
(_result, transaction) <- buildTransactionBatched sampleBackend $ addUser "rickAE870D" "www.clojure.org"
putStrLn $ show transaction
putStrLn "\nTransaction example done"
main :: IO ()
main = do
batchExample
--transactionExample
| kdkeyser/kvstore-batch | app/Main.hs | lgpl-3.0 | 7,281 | 0 | 14 | 1,560 | 2,074 | 1,004 | 1,070 | 168 | 6 |
import Test.HUnit
import P9x.P70.P70
import P9x.Util
p70 = testList "P70" [
expectEqual_ 2 (nodeCount (MNode 'a' [(MNode 'b' [])])),
expectEqual_ (MNode 'a' []) (stringToMTree "a^"),
expectEqual_ (MNode 'a' [(MNode 'b' [(MNode 'c' [])])]) (stringToMTree "abc^^^"),
expectEqual_ (MNode 'a' [(MNode 'b' []), (MNode 'c' [])]) (stringToMTree "ab^c^^"),
expectEqual_
(MNode 'a' [
(MNode 'f' [MNode 'g' []]),
(MNode 'c' []),
(MNode 'b' [
(MNode 'd' []),
(MNode 'e' [])
])
])
(stringToMTree "afg^^c^bd^e^^^"),
expectEqual_ (MNode 'a' []) (parseAsMTree "a^"),
expectEqual_ (MNode 'a' [(MNode 'b' [(MNode 'c' [])])]) (parseAsMTree "abc^^^"),
expectEqual_ (MNode 'a' [(MNode 'b' []), (MNode 'c' [])]) (parseAsMTree "ab^c^^"),
expectEqual_
(MNode 'a' [
(MNode 'f' [MNode 'g' []]),
(MNode 'c' []),
(MNode 'b' [
(MNode 'd' []),
(MNode 'e' [])
])
])
(parseAsMTree "afg^^c^bd^e^^^"),
expectEqual_
"afg^^c^bd^e^^^"
(toString
(MNode 'a' [
(MNode 'f' [MNode 'g' []]),
(MNode 'c' []),
(MNode 'b' [
(MNode 'd' []),
(MNode 'e' [])
])
])
)
]
p71 = testList "P71" [
expectEqual_ 9 (internalPathLength (stringToMTree "afg^^c^bd^e^^^"))
]
p72 = testList "P72" [
expectEqual_ "gfcdeba" (postorder (stringToMTree "afg^^c^bd^e^^^"))
]
p73 = testList "P73" [
expectEqual_ "a" (toLispyTree (stringToMTree "a^")),
expectEqual_ "(a b c)" (toLispyTree (stringToMTree "ab^c^^")),
expectEqual_ "(a (b c))" (toLispyTree (stringToMTree "abc^^^")),
expectEqual_ "(a (f g) c (b d e))" (toLispyTree (stringToMTree "afg^^c^bd^e^^^")),
expectEqual_ (stringToMTree "a^") (fromLispyTree "a"),
expectEqual_ (stringToMTree "ab^c^^") (fromLispyTree "(a b c)"),
expectEqual_ (stringToMTree "abc^^^") (fromLispyTree "(a (b c))"),
expectEqual_ (stringToMTree "afg^^c^bd^e^^^") (fromLispyTree "(a (f g) c (b d e))"),
expectEqual_ (stringToMTree "a^") (parseAsLispyTree "a"),
expectEqual_ (stringToMTree "ab^c^^") (parseAsLispyTree "(a b c)"),
expectEqual_ (stringToMTree "abc^^^") (parseAsLispyTree "(a (b c))"),
expectEqual_ (stringToMTree "afg^^c^bd^e^^^") (parseAsLispyTree "(a (f g) c (b d e))")
]
main :: IO Counts
main = runTestTT $ TestList [p70, p71, p72, p73]
| dkandalov/katas | haskell/p99/src/p9x/p70/P70_Test.hs | unlicense | 2,588 | 0 | 18 | 751 | 919 | 475 | 444 | 55 | 1 |
import Data.List
import Data.Char
import Unsafe.Coerce
import Test.HUnit
data Nat = Zero
| Succ Nat
deriving Show
-- natToInteger Zero = 0
-- natToInteger (Succ n) = natToInteger n + 1
-- natToInteger = head . m
-- where m Zero = [0]
-- m (Succ n) = [sum [x | x <- (1 : m n)]]
natToInteger :: Nat -> Integer
natToInteger = \n -> genericLength [c | c <- show n, c == 'S']
tests = TestList
[ "natToInteger 1" ~: natToInteger Zero ~?= 0
, "natToInteger 2" ~: natToInteger (Succ Zero) ~?= 1
, "natToInteger 3" ~: natToInteger (Succ (Succ Zero)) ~?= 2
] | prt2121/fp101x | natToInt.hs | apache-2.0 | 650 | 0 | 13 | 208 | 153 | 83 | 70 | 13 | 1 |
{-
Copyright 2015 Tristan Aubrey-Jones
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-}
{-|
Copyright : (c) Tristan Aubrey-Jones, 2015
License : Apache-2
Maintainer : [email protected]
Stability : experimental
For more information please see <http://www.flocc.net/>
-}
module Compiler.Types.TermBuilder (buildTermsForExpr, performConstraintAnalysis, scm, tup, fun, vara, varb, varc, vard, vare, varf, varg, varh, vari, varj, vark, varl, initTermEnvInState,
Substs, composeSubsts, nullSubsts, applySubstsToTerm, applySubstsToEnv, applySubstsToConstrs,
InferenceMonad, InferenceFunction, inferTerms, inferNewTerms, runTermInferencer, runNewTermInferencer,
inferTermsFoldF, inferEqTermsFoldF, addAConstraint,
buildForIdxTree) where
-- Helper functions for building term environments and constraint lists in various term languages
-- for expr trees
-- ------------------------
import Compiler.Front.Indices (Idx, IdxSet)
import Compiler.Types.TermLanguage
import Compiler.Front.ExprTree hiding (Var)
import qualified Compiler.Front.ExprTree as ExprTree (Expr(Var))
import Compiler.Front.Common
import Control.Monad.State.Strict ( lift, StateT, runStateT, get, modify )
import Data.Foldable (foldlM)
import Data.List (nub, isPrefixOf)
import Debug.Trace (trace)
-- |Trace function for debugging build function when vars are encountered
trcVarTermBuilding :: (Show a, Show b) => (a,b) -> c -> c
--trcVarTermBuilding = tracerEx3 "Building var term: " (\(n,t) -> (show n) ++ ": " ++ (show t))
trcVarTermBuilding _ = id
-- |Trace function displaying new envs when entering scopes
trcScopeBuilding :: (Show a) => [a] -> b -> b
--trcScopeBuilding = tracerEx3 "Building new scope vars: \n " (\l -> delimList "\n " $ map show l)
trcScopeBuilding _ = id
-- |Trace function displaying schemes in varEnv at each var use, and the resulting
-- |instantiations
trcSchemeInstantiation :: Show t => Idx -> FuncScheme t -> FuncTerm t -> a -> a
--trcSchemeInstantiation varId scheme term = trace ("SchemeInst: V" ++ (show varId) ++
-- ": " ++ (showFunctionScheme scheme) ++ " => " ++ (showFunctionTerm term) ++ "\n")
trcSchemeInstantiation _ _ _ = id
-- |Trace function displaying result of build function
{-trcBuildResult :: (Show t, Show c) => (Expr,TermEnv t,c) -> d -> d
trcBuildResult = tracerEx3 "Build result: " (\(exp,env,cl) ->
"\n\n Expression: " ++ (show exp) ++
"\n\n Environment: " ++ (show env) ++
"\n\n Constraints: " ++ (show cl) ++
"\n\n Expr with terms: " ++ (showExprTree env showTermFromEnv 0 exp)) -}
trcBuildResult _ = id
type FuncTerm t = Term (FunctionToken t)
type FuncEnv t = TermEnv (FunctionToken t)
type FuncConstr t = Constr (FuncTerm t)
type FuncScheme t = Scheme (FunctionToken t)
getVid :: Show t => FuncTerm t -> Idx
getVid (Var i) = i
getVid expr = error $ (show expr) ++ " is not a Var term, scm only takes Vars"
scm :: Show t => [FuncTerm t] -> FuncTerm t -> FuncScheme t
scm vlist term = Scheme (nub $ map getVid vlist) term
tup :: [FuncTerm t] -> FuncTerm t
tup l = Term TupTok l
fun :: FuncTerm t -> FuncTerm t -> FuncTerm t
fun a b = Term FunTok [a, b]
vara :: FuncTerm t
vara = (Var 0)
varb :: FuncTerm t
varb = (Var 1)
varc :: FuncTerm t
varc = (Var 2)
vard :: FuncTerm t
vard = (Var 3)
vare :: FuncTerm t
vare = (Var 4)
varf :: FuncTerm t
varf = (Var 5)
varg :: FuncTerm t
varg = (Var 6)
varh :: FuncTerm t
varh = (Var 7)
vari :: FuncTerm t
vari = (Var 8)
varj :: FuncTerm t
varj = (Var 9)
vark :: FuncTerm t
vark = (Var 10)
varl :: FuncTerm t
varl = (Var 11)
-- |Initialize the current level of the TermEnvStack using this IdxTree pattern
initTermEnvInState :: Monad a => Term t -> IdxTree -> StateT (TermEnvStack t) a ()
initTermEnvInState term it = case it of
(IdxNub i) -> do
return ()
(IdxLeaf i vi s) -> do
addTermToStackInState term vi
return ()
(IdxTup i l) -> do
mapM (initTermEnvInState term) l
return ()
buildForIdxTree :: Monad a => IdxTree -> StateT (FuncEnv t) (StateT (IdxSet) a) (FuncEnv t, FuncTerm t)
buildForIdxTree it = case it of
(IdxNub i) -> do
v <- bindNewTermVarInState i
return (emptyTermEnv, v)
(IdxLeaf i vi s) -> do
v <- bindNewTermVarInState i
return (addTermToEnv emptyTermEnv (Scheme [] v) vi, v)
(IdxTup i l) -> do
l' <- mapM buildForIdxTree l
let (venvl, tl) = unzip l'
let term = tup tl
v <- bindTermInState (Scheme [] term) i
return (concatTermEnvs venvl, term)
-- |Instead of creating new vars for the identifiers, here we decompose the
-- |term given, assigning its components to the various leaves of the IdxTree
buildForLetIdxTree :: (Monad m, Show t) =>
FuncEnv t ->
IdxTree ->
FuncTerm t ->
StateT (FuncEnv t) (StateT IdxSet m) (FuncEnv t)
buildForLetIdxTree env it term = let scheme = generalizeTerm env term in
case it of
-- an underscore
(IdxNub i) -> do
term' <- bindTermInState scheme i
return emptyTermEnv
-- an identifier
(IdxLeaf i vi s) -> do
term' <- bindTermInState scheme i
return (addTermToEnv emptyTermEnv term' vi)
-- a tuple of identifiers
(IdxTup i l) -> case term of
(Term TupTok l') | length l == length l' -> do
term' <- bindTermInState scheme i
let ls = zip l l'
envl <- mapM (\(id,tm) -> buildForLetIdxTree env id tm) ls
return (concatTermEnvs envl)
tm -> error $ "Error building scheme env for let expression. Idx tuple " ++ (show it) ++
" does not match term " ++ (show term)
-- |Helper function for building term environments for expr trees. May be called from an 'overriding' function (with the overriding
-- |function passed as the third argument so that control can be passed back to it in the recursive case).
buildTermsForExpr :: (Show t, Eq t, Monad a) =>
FuncEnv t ->
Expr ->
(FuncEnv t -> Expr -> StateT (FuncEnv t) (StateT (IdxSet) a) ([FuncConstr t], FuncTerm t))
-> StateT (FuncEnv t) (StateT (IdxSet) a) ([FuncConstr t], FuncTerm t)
buildTermsForExpr varEnv exp bfun = case exp of
(Lit i vl) -> do -- new term var
v <- bindNewTermVarInState i
return ([], v)
-- (ExprTree.Var i vi s) -> do -- fetch from env
-- declV <- case lookupTermMaybe varEnv vi of
-- (Just dv) -> if isFuncTerm dv -- POTENTIAL PROBLEM: there are circumstances where we can't tell if its a function term.
-- then do -- functions should be renamed per use
-- dv' <- lift $ renewTermVarIds dv
-- return dv'
-- else return dv -- variables should not
-- Nothing -> error $ "var " ++ (show vi) ++ " " ++ s ++
-- "is missing from the dependence term variable environment"
-- v <- bindTermInState declV i
-- return $ trcVarTermBuilding (s, declV) $ ([], v)
(ExprTree.Var i vi s) -> case lookupTermMaybe varEnv vi of
(Just scheme) -> do
term <- lift $ instantiateScheme scheme
bindTermInState (Scheme [] term) i
return $ trcSchemeInstantiation vi scheme term $ ([], term)
--return $ trcVarTermBuilding (s, term) $ ([], term)
Nothing -> error $ "Unbound variable var " ++ (show vi) ++ " " ++ s ++
" when building terms for expression."
(Tup i l) -> do -- new tup term
l' <- mapM (bfun varEnv) l
let (cl,tl) = unzip l'
let term = tup tl
bindTermInState (Scheme [] term) i
return (concat cl, term)
(Rel i l) -> do -- new term var
v <- bindNewTermVarInState i
l' <- mapM (bfun varEnv) l
let (cl,tl) = unzip l'
return ((concat cl), v)
(Fun i it b) -> do -- new fun term
(newVarEnv, t1) <- buildForIdxTree it
(cl, t2) <- trcScopeBuilding newVarEnv $ bfun (concatTermEnvs [varEnv, newVarEnv]) b -- TODO recognise new func bindings
let term = (fun t1 t2)
bindTermInState (Scheme [] term) i
return (cl, term)
(App i fe ve) -> do -- func application
v <- bindNewTermVarInState i
(c1,t1) <- bfun varEnv fe
(c2,t2) <- bfun varEnv ve
return ((t1 :=: fun t2 v):(c1 ++ c2), v)
(If i pe te ee) -> do -- new term var, propagate constraints, make then and else clause terms equal
v <- bindNewTermVarInState i
(c1,t1) <- bfun varEnv pe
(c2,t2) <- bfun varEnv te
(c3,t3) <- bfun varEnv ee
return ((v :=: t2):(v :=: t3):(c1 ++ c2 ++ c3), v) -- TODO: distinction between tuple union and other union?
(Let i it be ie) -> do -- returns term of "in" expr, and constrains binding term to bound term
(c1,t1) <- bfun varEnv be
newVarEnv <- buildForLetIdxTree varEnv it t1
(c2, t2) <- trace ((show t1) ++ "\n") $ trcScopeBuilding newVarEnv $ bfun (concatTermEnvs [varEnv, newVarEnv]) ie
bindTermInState (Scheme [] t2) i
return (c1 ++ c2, t2)
-- |Takes a variable environment, term builder function and expression and returns either
-- |a unified term environment solution to the analysis, or a failing constraint.
performConstraintAnalysis :: (Monad a, Eq t, Show t) =>
(TermEnv t -> Expr -> StateT (TermEnv t) (StateT (IdxSet) a) ([Constr (Term t)], (Term t)))
-> TermEnv t
-> Expr
-> StateT (IdxSet) a (Either (TermEnv t) (Constr (Term t)))
performConstraintAnalysis buildF varEnv exp = do
-- build constraints
((cl,term),expEnv) <- runStateT (buildF varEnv exp) emptyTermEnv
-- unify and apply substitutions
case trcBuildResult (exp, expEnv, cl) $ unifyConstraints cl emptyTermEnv of
(Left subs) -> return (Left $ mapTermEnv (forAllSubs subInScheme subs) expEnv)
(Right con) -> return (Right con)
-- Reprogramming to weave term reconstruction and unification together
-- such that terms are fully expanded before they are generalized
-- |A list of substitutions
type Substs t = [Subst t]
-- |Compose substitution lists such that s2 is applied first, then s1
composeSubsts :: Substs t -> Substs t -> Substs t
composeSubsts s1 s2 = s2 ++ s1
nullSubsts :: Substs t
nullSubsts = []
-- |Apply all substitutions to the term
applySubstsToTerm :: Eq t => Substs (Term t) -> Term t -> Term t
applySubstsToTerm subs term = forAllSubs subInTerm subs term
-- |Apply all substitutions to the term/scheme environment
applySubstsToEnv :: Eq t => Substs (Term t) -> TermEnv t -> TermEnv t
applySubstsToEnv subs env = mapTermEnv (forAllSubs subInScheme subs) env
-- |Apply all substitutions to the constraint list
applySubstsToConstrs :: Eq t => Substs (Term t) -> [Constr (Term t)] -> [Constr (Term t)]
applySubstsToConstrs subs cl = map (\(a :=: b) -> (applySubstsToTerm subs a)
:=: (applySubstsToTerm subs b)) cl
-- |The state monad used by inference functions
type InferenceMonad t m =
StateT (FuncEnv t) (StateT (IdxSet) m) (Substs (FuncTerm t), FuncTerm t)
-- |The type of an inference function
type InferenceFunction t m =
FuncEnv t ->
Expr ->
InferenceMonad t m
-- |The type that is accumulated with folding inferTypes over a list of expressions.
type InferenceFoldType t = (FuncEnv t, Substs (FuncTerm t), [FuncTerm t])
-- |Binary operator to fold over a list of expressions.
-- |Note: Term list returned in reverse order, need to apply "reverse" to it.
inferTermsFoldF :: (Monad m, Show t, Eq t) =>
InferenceFunction t m ->
InferenceFoldType t ->
Expr ->
StateT (FuncEnv t) (StateT (IdxSet) m) (InferenceFoldType t)
inferTermsFoldF f (env, subs, termList) expr = do
(s1, t1) <- f env expr
return (applySubstsToEnv s1 env,
s1 `composeSubsts` subs,
(t1:termList))
-- |Binary operator to fold over a list of expressions, with
-- |the added constraint that all terms in the list are equal.
-- |Note: Term list returned in reverse order, need to apply "reverse" to it.
inferEqTermsFoldF :: (Monad m, Show t, Eq t) =>
InferenceFunction t m ->
InferenceFoldType t ->
Expr ->
StateT (FuncEnv t) (StateT (IdxSet) m) (InferenceFoldType t)
inferEqTermsFoldF f (env, subs, termList) expr = do
(s1, t1) <- f env expr
case termList of
[] -> return (applySubstsToEnv s1 env,
s1 `composeSubsts` subs,
(t1:termList))
(t2:_) -> case unifyConstraints [t1 :=: t2] emptyTermEnv of
(Left s2) -> do
-- TODO potential problem - t1 has already been bound to its
-- expression by f, however this was done before s2 was known or applied to it
let t1' = applySubstsToTerm s2 t1
let sl = s2 `composeSubsts` s1
return (applySubstsToEnv sl env,
sl `composeSubsts` subs,
(t1':termList))
(Right failCon) -> error $ "TermBuilder:inferEqTermsFoldF: Term inference failed in " ++
"term list equality on " ++ (show failCon)
-- |Base function for all term inferencers
inferTerms :: (Monad m, Show t, Eq t) =>
InferenceFunction t m -> -- the overiding function to pass control back to
FuncEnv t -> -- the var environment
Expr -> -- the expression
InferenceMonad t m -- state containing a map from expr ids to terms, and idx set
inferTerms recur varEnv expr = case expr of
-- instantiate the term of a bound variable
(ExprTree.Var i vi s) -> case lookupTermMaybe varEnv vi of
(Just scheme) -> do
term <- lift $ instantiateScheme scheme
bindTermInState (Scheme [] term) i
return $ trcSchemeInstantiation vi scheme term $ (nullSubsts, term)
Nothing -> do
-- condition added so that exVars created in EmbeddedFunctions
-- (which are typically fun vars not yet expanded by unification)
-- are supported.
if vi < 0 && (isPrefixOf "exVar" s)
then do
v <- bindNewTermVarInState i
return (nullSubsts, v)
else error $ "TermBuilder:inferTerms:1 Unbound variable var " ++ (show vi) ++ " " ++ s ++
" when inferring terms. (not an exVar)"
-- create new term var for a literal
(Lit i vl) -> do
v <- bindNewTermVarInState i
return (nullSubsts, v)
-- function abstraction
(Fun i it b) -> do
(newVarEnv, tv) <- buildForIdxTree it
(s1, t1) <- trcScopeBuilding newVarEnv $ recur (concatTermEnvs [varEnv, newVarEnv]) b
let term = (fun (applySubstsToTerm s1 tv) t1)
bindTermInState (Scheme [] term) i
return (s1, term)
-- function application
(App i fe arge) -> do
tv <- bindNewTermVarInState i
(s1, t1) <- recur varEnv fe
(s2, t2) <- recur (applySubstsToEnv s1 varEnv) arge
let constr = (applySubstsToTerm s2 t1) :=: (fun t2 tv)
case unifyConstraints [constr] emptyTermEnv of
(Left s3) -> do
let term = applySubstsToTerm s3 tv
bindTermInState (Scheme [] term) $ trace (("App: " ++ (show fe) ++ " : " ++ (show constr) ++ "\n") ++ "Ret: " ++ (show term) ++ "\n") $ i
return (s3 `composeSubsts` s2 `composeSubsts` s1, term)
(Right failCon) -> error $ "TermBuilder:inferTerms:2 Term inference failed on " ++ (show failCon) ++ " at " ++ (show expr)
-- let expression
(Let i it be ie) -> do
(s1, t1) <- recur varEnv be
env' <- buildForLetIdxTree (applySubstsToEnv s1 varEnv) it t1
let varEnv' = concatTermEnvs [varEnv, env']
(s2, t2) <- recur (applySubstsToEnv s1 varEnv') ie
bindTermInState (Scheme [] t2) i
return (s1 `composeSubsts` s2, t2)
-- if expression
(If i pe te ee) -> do
(s1, t1) <- recur varEnv pe
(s2, t2) <- recur (applySubstsToEnv s1 varEnv) te
(s3, t3) <- recur (applySubstsToEnv (s2 `composeSubsts` s1) varEnv) ee
-- TODO: confused about what subs need to be applied to what, when
case unifyConstraints [t2 :=: t3] emptyTermEnv of
(Left s4) -> do
let term = applySubstsToTerm s4 t3
bindTermInState (Scheme [] term) i
return (s4 `composeSubsts` s3 `composeSubsts` s2 `composeSubsts` s1,
term)
Right failCon -> error $ "TermBuilder:inferTerms:3 Term inference failed on " ++ (show failCon) ++ " at " ++ (show expr)
-- tuple expressions
(Tup i l) -> do
(_,sl,tl) <- foldlM (inferTermsFoldF recur) (varEnv, nullSubsts, []) l
let term = tup $ reverse tl
bindTermInState (Scheme [] term) i
return (sl, term)
-- relation expressions
(Rel i l) -> do
(_,sl,tl) <- foldlM (inferTermsFoldF recur) (varEnv, nullSubsts, []) l
-- Note - FuncTerms don't have relation terms so here we just create a new
-- term variable.
--let term = rel $ reverse tl
--bindTermInState (Scheme [] term) i
term <- bindNewTermVarInState i
return (sl, term)
-- |Term inferencer function where only terms who's terms
-- |do not already exist in the state are investigated.
inferNewTerms :: (Monad m, Show t, Eq t) =>
InferenceFunction t m -> -- the overiding function to pass control back to
FuncEnv t -> -- the var environment
Expr -> -- the expression
InferenceMonad t m -- state containing a map from expr ids to terms, and idx set
inferNewTerms recur varEnv expr = do
let exprId = getExprId expr
currentEnv <- trace ("expr id: " ++ (show exprId) ++ "\n") $ get
case lookup exprId currentEnv of
-- already bound
Just scheme -> do
term <- lift $ instantiateScheme scheme
return $ trace ("existing term for " ++ (show exprId) ++ ": " ++ (show term) ++ "\n") $ (nullSubsts, term)
-- not yet bound
Nothing -> recur varEnv expr
-- |Function that performs term inference using the inference function provided
runTermInferencer :: (Monad m, Show t, Eq t) =>
InferenceFunction t m ->
FuncEnv t ->
Expr ->
StateT IdxSet m (Either (FuncEnv t) (Constr (Term t)))
runTermInferencer func varEnv expr = do
((s,t),expEnv) <- runStateT (func varEnv expr) emptyTermEnv
return (Left $ applySubstsToEnv s expEnv)
-- |Function that performs term inference using the inference function provided
runNewTermInferencer :: (Monad m, Show t, Eq t) =>
InferenceFunction t m ->
FuncEnv t ->
FuncEnv t ->
Expr ->
StateT IdxSet m (Either (FuncEnv t) (Constr (Term t)))
runNewTermInferencer func varEnv exprEnv1 expr = do
((s,t),expEnv2) <- runStateT (inferNewTerms func varEnv expr) exprEnv1
return (Left $ applySubstsToEnv s expEnv2)
-- |addAConstraint takes three terms, and tries to unify the latter two
-- |and apply any substitutions to the first.
addAConstraint :: (Show t, Eq t) => Term t -> Term t -> Term t -> Maybe (Term t)
addAConstraint t a b = case unifyConstraints [a :=: b] emptyTermEnv of
Left subs -> Just $ applySubstsToTerm subs t
Right con -> Nothing
| flocc-net/flocc | v0.1/Compiler/Types/TermBuilder.hs | apache-2.0 | 18,982 | 0 | 28 | 4,393 | 5,535 | 2,826 | 2,709 | 311 | 12 |
-- searchable spaces, based on code by Martin Escardo
module Searchable where
data Searchable a = Finder ((a -> Bool) -> a)
find :: Searchable a -> (a -> Bool) -> a
find (Finder epsilon) p = epsilon p
-- auxiliary function search
search :: Searchable a -> (a -> Bool) -> Maybe a
search s p =
let x = find s p
in if p x then Just x else Nothing
-- quantifiers
exists s p = p (find s p)
forall s p = not (exists s (not . p))
-- some searchable spaces
-- singleton
singleton x = Finder (\p -> x)
-- doubleton
doubleton x y = Finder (\p -> if p x then x else y)
-- finite non-empty sets
finite_set :: [a] -> Searchable a
finite_set lst = Finder (\p ->
let loop [] = undefined
loop [x] = x
loop (x:xs) = if p x then x else loop xs
in loop lst)
-- the sum of two searchable sets a and b is searchable
sum s t = Finder (\p -> let x = Left (find s (p . Left))
y = Right (find t (p . Right))
in if p x then x else y)
-- a union of a searchable family of searchable spaces ss
bigUnion :: Searchable (Searchable a) -> Searchable a
bigUnion ss = Finder (\p -> find (find ss (\s -> exists s p)) p)
-- a union of two sets is a special case
union s t = bigUnion (doubleton s t)
-- the image of a searchable set s under a map f
image f s = Finder (\p -> f (find s (p . f)))
-- monad structure for searchable spaces
instance Monad Searchable where
return = singleton
s >>= f = bigUnion (image f s)
-- product of a and b
a `times` b = do x <- a
y <- b
return (x, y)
-- a product of a list of spaces, where the list may be infinite
prod [] = return []
prod (a:as) = do x <- a
xs <- prod as
return (x:xs)
-- the Cantor space
two = doubleton False True
cantor = prod (repeat two)
-- we may test equality of functions
equal a f g = forall a (\x -> f x == g x)
| andrejbauer/marshall | etc/haskell/Searchable.hs | bsd-2-clause | 1,957 | 0 | 16 | 609 | 748 | 383 | 365 | 38 | 4 |
{-# LANGUAGE TypeFamilies, FlexibleInstances, FlexibleContexts,
DeriveDataTypeable, StandaloneDeriving #-}
module HEP.Automation.MadGraph.Model.C1SLowSimple where
import Data.Typeable
import Data.Data
import Text.Printf
import Text.Parsec
import Control.Monad.Identity
import Text.StringTemplate
import Text.StringTemplate.Helpers
import HEP.Automation.MadGraph.Model
import HEP.Automation.MadGraph.Model.Common
data C1SLowSimple = C1SLowSimple
deriving (Show, Typeable, Data)
instance Model C1SLowSimple where
data ModelParam C1SLowSimple
= C1SLowSimpleParam { mnp :: Double
, gnpR :: Double
, gnpL :: Double
, gnpcuR :: Double
, gnpcuL :: Double }
deriving Show
briefShow _ = "C1SLowSmp"
madgraphVersion _ = MadGraph5
modelName _ = "C1SLowSimple_UFO"
modelFromString str = case str of
"C1SLowSimple_UFO" -> Just C1SLowSimple
_ -> Nothing
paramCard4Model C1SLowSimple = "param_card_C1SLowSimple.dat"
paramCardSetup tpath C1SLowSimple (C1SLowSimpleParam m gR gL gcR gcL) = do
templates <- directoryGroup tpath
return $ ( renderTemplateGroup
templates
[ ("mnp" , (printf "%.4e" m :: String))
, ("gnpR" , (printf "%.4e" gR :: String))
, ("gnpL" , (printf "%.4e" gL :: String))
, ("gnpcuR" , (printf "%.4e" gcR :: String))
, ("gnpcuL" , (printf "%.4e" gcL :: String))
, ("wnp" , (printf "%.4e" (gammanp m gR gL gcR gcL) :: String)) ]
(paramCard4Model C1SLowSimple) ) ++ "\n\n\n"
briefParamShow (C1SLowSimpleParam m gR gL gcR gcL) = "M"++show m++"GR"++show gR++"GL"++show gL ++ "GCR" ++ show gcR ++ "GCL" ++ show gcL
interpreteParam str = let r = parse c1slowsmpparse "" str
in case r of
Right param -> param
Left err -> error (show err)
c1slowsmpparse :: ParsecT String () Identity (ModelParam C1SLowSimple)
c1slowsmpparse = do
char 'M'
massstr <- many1 (oneOf "+-0123456789.eE")
string "GR"
grstr <- many1 (oneOf "+-0123456789.eE")
string "GL"
glstr <- many1 (oneOf "+-0123456789.eE")
string "GCR"
gcrstr <- many1 (oneOf "+-0123456789.eE")
string "GCL"
gclstr <- many1 (oneOf "+-0123456789.eE")
return (C1SLowSimpleParam (read massstr) (read grstr) (read glstr)
(read gcrstr) (read gclstr))
-- mtop :: Double
-- mtop = 172.0
gammanp :: Double -> Double -> Double -> Double -> Double -> Double
gammanp m gR gL gcR gcL =
let gammacu = 3.0 * m/(8.0*pi) * (gcR^(2::Int)+gcL^(2::Int))/2.0
gammatu = if m > mtop
then 3.0 * m/(8.0*pi) * (gR^(2::Int)+gL^(2::Int))/2.0
* (1.0 - (mtop^(2::Int))/(m^(2::Int)))
else 0
in gammacu + gammatu
c1SLowSmpTr :: TypeRep
c1SLowSmpTr = mkTyConApp (mkTyCon "HEP.Automation.MadGraph.Model.C1SLowSimple.C1SLowSimple") []
instance Typeable (ModelParam C1SLowSimple) where
typeOf _ = mkTyConApp modelParamTc [c1SLowSmpTr]
deriving instance Data (ModelParam C1SLowSimple)
| wavewave/madgraph-auto-model | src/HEP/Automation/MadGraph/Model/C1SLowSimple.hs | bsd-2-clause | 3,319 | 0 | 17 | 991 | 994 | 521 | 473 | 72 | 2 |
module Language.Drasil.Code.Imperative.Build.AST where
import Build.Drasil (makeS, MakeString, mkImplicitVar, mkWindowsVar)
type CommandFragment = MakeString
data BuildName = BMain
| BPackName
| BPack BuildName
| BWithExt BuildName Ext
data Ext = CodeExt
| OtherExt MakeString
data BuildDependencies = BcSource
| BcSingle BuildName
data BuildConfig = BuildConfig ([CommandFragment] -> CommandFragment -> BuildCommand) BuildDependencies
data RunType = Standalone
| Interpreter CommandFragment
data Runnable = Runnable BuildName NameOpts RunType
data NameOpts = NameOpts {
packSep :: String,
includeExt :: Bool
}
nameOpts :: NameOpts
nameOpts = NameOpts {
packSep = "/",
includeExt = True
}
type BuildCommand = [CommandFragment]
type InterpreterCommand = String
asFragment :: String -> CommandFragment
asFragment = makeS
osClassDefault :: String -> String -> String -> CommandFragment
osClassDefault = mkWindowsVar
buildAll :: ([CommandFragment] -> CommandFragment -> BuildCommand) -> Maybe BuildConfig
buildAll = Just . flip BuildConfig BcSource
buildSingle :: ([CommandFragment] -> CommandFragment -> BuildCommand) -> BuildName -> Maybe BuildConfig
buildSingle f = Just . BuildConfig f . BcSingle
nativeBinary :: Runnable
nativeBinary = Runnable (BWithExt BPackName $ OtherExt $
osClassDefault "TARGET_EXTENSION" ".exe" "") nameOpts Standalone
interp :: BuildName -> NameOpts -> InterpreterCommand -> Runnable
interp b n = Runnable b n . Interpreter . makeS
interpMM :: InterpreterCommand -> Runnable
interpMM = Runnable mainModuleFile nameOpts . Interpreter . makeS
mainModule :: BuildName
mainModule = BMain
mainModuleFile :: BuildName
mainModuleFile = BWithExt BMain CodeExt
inCodePackage :: BuildName -> BuildName
inCodePackage = BPack
withExt :: BuildName -> String -> BuildName
withExt b = BWithExt b . OtherExt . makeS
cCompiler :: CommandFragment
cCompiler = mkImplicitVar "CC"
cppCompiler :: CommandFragment
cppCompiler = mkImplicitVar "CXX"
| JacquesCarette/literate-scientific-software | code/drasil-code/Language/Drasil/Code/Imperative/Build/AST.hs | bsd-2-clause | 2,075 | 0 | 9 | 383 | 518 | 288 | 230 | 51 | 1 |
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE TemplateHaskell #-}
module Test.Examples.ExpSpec
( spec
) where
import Control.Category (id, (.))
import Control.Lens ((&))
import Data.Bits (xor, (.&.), (.|.))
import Data.Monoid ((<>))
import Prelude hiding (id, (.))
import Test.Hspec (Spec, describe, it)
import Test.QuickCheck (Large (..), Property, counterexample)
import Test.Arbitrary ()
import Test.Execution (describeExecWays, (>-*->), (~*~))
import Toy.Base
import Toy.Execution (ExecWay (..), defCompileX86, translateLang)
import Toy.Exp
import qualified Toy.Lang as L
spec :: Spec
spec = do
let ways =
[ Ex id
, Ex translateLang
, Ex $ defCompileX86 . translateLang
]
describe "expressions" $ do
describeExecWays ways $ \way -> do
describe "arithmetic" $ do
it "plus (uni)" $
uniopTest way (+ 5) (+ 5)
it "minus (uni)" $
uniopTest way (subtract 1) (subtract 1)
it "div (uni)" $
uniopTest way (quot 6) (6 /:)
it "two variables" $
binopTest way const const
it "plus" $
binopTest way (+) (+)
it "complex" $
complexArithTest way
describe "boolean" $ do
it "and" $
binopTest way (asToBool (&&)) (&&:)
it "or" $
binopTest way (asToBool (||)) (||:)
it "xor" $
binopTest way xor (^:)
it "bitwise and" $
binopTest way (.&.) (&:)
it "bitwise or" $
binopTest way (.|.) (|:)
describe "comparisons" $ do
it "<" $
binopTest way (binResToBool (<)) (<:)
it "==" $
binopTest way (binResToBool (==)) (==:)
it "complex" $
boolTest way
describe "misc" $ do
it "large" $
largeTest way
uniopTest
:: ExecWay L.Stmt
-> (Value -> Value)
-> (Exp -> Exp)
-> Property
uniopTest way f1 f2 =
let sample = L.readS "a" <> L.writeS (f2 "a")
in way & sample ~*~ f1
binopTest
:: ExecWay L.Stmt
-> (Value -> Value -> Value)
-> (Exp -> Exp -> Exp)
-> Property
binopTest way f1 f2 = head
[ counterexample "plain" $
way & sample ~*~ f1
, counterexample "large" $
way & sample ~*~ \(Large a) (Large b) -> f1 a b
]
where
sample = L.readS "a" <> L.readS "b" <> L.writeS ("a" `f2` "b")
complexArithTest :: ExecWay L.Stmt -> Property
complexArithTest = sample ~*~ fun
where
sample = mconcat
[ L.readS "a"
, L.readS "b"
, L.readS "c"
, L.writeS $ "a" +: "b" *: 10 -: "c" %: 2
]
fun :: Value -> Value -> Value -> Value
fun a b c = a + b * 10 - (c `rem` 2)
boolTest :: ExecWay L.Stmt -> Property
boolTest = sample ~*~ fun
where
sample = mconcat
[ L.readS "a"
, L.readS "b"
, L.readS "c"
, L.readS "d"
, L.readS "e"
, L.writeS $ "a" ==: "b" &&: "c" <=: "d" ^: "e"
]
fun :: Value -> Value -> Value -> Value -> Value -> Value
fun a b c d e = if (a == b) && (c <= xor d e) then 1 else 0
largeTest :: ExecWay L.Stmt -> Property
largeTest = sample & [] >-*-> [55]
where
sample = L.writeS $ foldr (+) 0 (ValueE <$> [1..10] :: [Exp])
| Martoon-00/toy-compiler | test/Test/Examples/ExpSpec.hs | bsd-3-clause | 3,730 | 0 | 20 | 1,534 | 1,242 | 655 | 587 | 101 | 2 |
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
module Data.Array.Accelerate.BLAS.Internal.Common
( devVF
, devVD
, devSF
, devSD
, allocScalar
, allocVector ) where
import Data.Array.Accelerate
import Data.Array.Accelerate.CUDA.Foreign
import Foreign.CUDA.Ptr
import Prelude hiding (zipWith)
import Control.Applicative ((<$>))
import Data.Array.Accelerate
devVF :: Vector Float -> CIO (DevicePtr Float)
devVF v = devicePtrsOfArray v >>= \((), p) -> return p
{-# INLINE devVF #-}
devVD :: Vector Double -> CIO (DevicePtr Double)
devVD v = devicePtrsOfArray v >>= \((), p) -> return p
{-# INLINE devVD #-}
devSF :: Scalar Float -> CIO (DevicePtr Float)
devSF s = devicePtrsOfArray s >>= \((), p) -> return p
{-# INLINE devSF #-}
devSD :: Scalar Double -> CIO (DevicePtr Double)
devSD s = devicePtrsOfArray s >>= \((), p) -> return p
{-# INLINE devSD #-}
allocScalar :: Elt e => CIO (Scalar e)
allocScalar = allocateArray Z
{-# INLINE allocScalar #-}
allocVector :: Elt e => Int -> CIO (Vector e)
allocVector n = allocateArray (Z :. n)
{-# INLINE allocVector #-} | alpmestan/accelerate-blas | src/Data/Array/Accelerate/BLAS/Common.hs | bsd-3-clause | 1,088 | 0 | 9 | 190 | 365 | 200 | 165 | 33 | 1 |
module ProjectEuler.Problem071 (solution071) where
import Data.Ratio
genericSolution :: Integral a => Ratio a -> a -> a
genericSolution target maxDen = loop initNum initDen 0
where initNum = numerator target
initDen = 1 + denominator target
loop num den closest
| den == maxDen = numerator closest
| (nextNum % den) < target = loop nextNum den (nextNum % den)
| otherwise = loop num (den + 1) closest
where nextNum = num + 1
solution071 :: Integer
solution071 = genericSolution (3 % 7) 1e6
| guillaume-nargeot/project-euler-haskell | src/ProjectEuler/Problem071.hs | bsd-3-clause | 577 | 0 | 12 | 172 | 193 | 97 | 96 | 13 | 1 |
module HVX.DcpTests.OkXAffine where
import Numeric.LinearAlgebra
import HVX
main :: IO ()
main = do
let zero = EConst $ konst 0.0 (2, 1)
x = EVar "x"
e = hexp $ x
_ = zero >=~ e
_ = e <=~ zero
return ()
| chrisnc/hvx | test/DcpTests/OkConstraints.hs | bsd-3-clause | 234 | 0 | 12 | 75 | 99 | 52 | 47 | 11 | 1 |
module DnoList.Wrapper where
import System.Environment
import Data.Yaml
import DnoList.Types
wrapMain :: (Settings -> IO ()) -> IO ()
wrapMain run = do
Just file <- lookupEnv "DNOLIST_SETTINGS"
Just settings <- decodeFile file
run settings
| abbradar/dnolist | src/DnoList/Wrapper.hs | bsd-3-clause | 249 | 0 | 9 | 43 | 87 | 42 | 45 | 9 | 1 |
{-# LANGUAGE OverloadedStrings #-}
module Hasmin.Types.BasicShapeSpec where
import Data.Text (Text)
import Data.Foldable (traverse_)
import Data.Attoparsec.Text (Parser)
import Test.Hspec.QuickCheck (modifyMaxSuccess)
import Hasmin.Parser.Value
import Hasmin.Types.Value
import Hasmin.Types.BasicShape
import Hasmin.TestUtils
basicShapeTests :: Spec
basicShapeTests =
describe "<basic-shape> tests" $ do
traverse_ (matchSpec f) basicShapeTestsInfo
modifyMaxSuccess (const 10000) . it "Minified <basic-shape> maintains semantical equivalence" $
property (prop_minificationEq :: BasicShape -> Bool)
where f :: Parser Value
f = minifyWithTestConfig <$> value
basicShapeTestsInfo :: [(Text, Text)]
basicShapeTestsInfo =
[("inset(1px 2px 1px 2px)", "inset(1px 2px)")
,("inset(1px 1px round 4px / 4px)", "inset(1px round 4px)")
,("inset(1px 1px round 0px 0% / 0 0 0)", "inset(1px)")
,("ellipse(12px 12px at left bottom)", "ellipse(9pt 9pt at 0 100%)")
,("ellipse(12px 12px at center)", "ellipse(9pt 9pt)")
,("ellipse(12px closest-side)", "ellipse(9pt)")
,("ellipse(farthest-side closest-side)", "ellipse(farthest-side)")
,("ellipse(closest-side closest-side)", "ellipse()")
,("polygon(nonzero, 12px 12px)", "polygon(9pt 9pt)")
,("polygon(evenodd, 12px 12px)", "polygon(evenodd,9pt 9pt)")
,("circle(closest-side at center)", "circle()")
,("circle(closest-side at left bottom)", "circle(at 0 100%)")
,("circle(12px 12px at 45%)", "circle(9pt 9pt at 45%)")
]
spec :: Spec
spec = basicShapeTests
main :: IO ()
main = hspec spec
| contivero/hasmin | tests/Hasmin/Types/BasicShapeSpec.hs | bsd-3-clause | 1,648 | 0 | 12 | 298 | 323 | 194 | 129 | 37 | 1 |
module Problem2 where
import Data.Char
import Data.List
import Control.Applicative
import System.IO
import Text.Printf
-- The goal of this code problem is to implement an algorithm for the fractional knapsack problem.
main :: IO ()
main =
hSetBuffering stdin NoBuffering >>= \_ ->
nextNum >>= \n ->
nextNum >>= \w ->
nextItems n >>= \items ->
putStrLn $ print4 $ solve w items
print4 :: (Fractional a, PrintfArg a) => a -> String
print4 x = printf "%.4f" x
solve :: Integer -> [Item] -> Double
solve 0 _ = 0
solve _ [] = 0
solve c (i@(Item v w) : tail)
| w < c = fromIntegral v + solve (c - w) tail
| w > c = (valuePerUnit i) * (fromIntegral c)
| w == c = fromIntegral v
nextItems n = fmap (sortBy (flip compare)) $ sequence $ take n $ repeat nextItem
nextItem :: IO Item
nextItem =
nextNum >>= \v ->
fmap (Item v) nextNum
nextNum :: (Integral a, Read a) => IO a
nextNum = nextNum' ""
nextNum' n = getChar >>= \char ->
if(isDigit char) then nextNum' $ char:n
else if(null n) then nextNum' n
else pure $ read $ reverse n
data Item = Item {value :: Integer, weight :: Integer} deriving (Show, Eq)
instance Ord Item where
compare i1 i2 = compare (valuePerUnit i1) (valuePerUnit i2)
valuePerUnit (Item a b)= fromIntegral a / fromIntegral b
| msosnicki/algorithms | app/week3/Problem2.hs | bsd-3-clause | 1,278 | 0 | 14 | 277 | 544 | 279 | 265 | 37 | 3 |
import qualified Fold as TF
import qualified Prisms as TP
import Test.Hspec
main :: IO ()
main = do
hspec TP.suite
hspec TF.suite
| anchor/ceilometer-common | tests/Main.hs | bsd-3-clause | 155 | 0 | 8 | 48 | 49 | 27 | 22 | 7 | 1 |
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Weather where
import Numeric (showFFloat)
import City
data Condition = Sunny
| Cloudy
| Rain
| Thunderstorm
| Snow
deriving (Show, Eq, Read)
newtype Temperature = Celsius {temp :: Double} deriving (Num, Eq, Ord, Read)
instance Show Temperature where
show x = if temperature > 0
then "+" ++ showFFloat (Just 1) temperature ""
else showFFloat (Just 1) temperature ""
where temperature = temp x
newtype Pressure = HectoPascal {pressure :: Double} deriving (Num, Eq, Ord, Read)
instance Show Pressure where
show x = showFFloat (Just 1) (pressure x) ""
type Humidity = Int
adjustPressure :: Pressure -> Elevation -> Pressure
adjustPressure p e = HectoPascal $ (pressure p) - 0.1 * fromIntegral e
fromPotentialTemp :: Temperature -> Elevation -> Temperature
fromPotentialTemp t e = Celsius $ (temp t) - 9.8 * fromIntegral e
| Michaelt293/TheWeather | src/Weather.hs | bsd-3-clause | 1,003 | 0 | 10 | 273 | 311 | 168 | 143 | 24 | 1 |
{-# LANGUAGE OverloadedStrings #-}
module Siberia.Web where
import Control.Applicative
import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.RWS.Lazy (liftIO)
import Data.Aeson
import Data.ByteString (ByteString)
import Data.ByteString.Char8 (pack, unpack)
import Data.ByteString.Lazy (fromStrict)
import qualified Data.ByteString.Lazy as LB
import qualified Data.ByteString as B
import Data.Monoid ((<>))
import Snap.Core (Method (..), dir, redirect, emptyResponse,
finishWith, getParam, ifTop, method, getRequest,
readRequestBody, route, routeLocal,
setResponseCode, writeLBS, writeBS,
writeText)
import qualified Snap.Core as SC
import qualified Snap.Internal.Http.Types as SC
import Snap.Util.FileServe (serveDirectory, serveFile)
import qualified Data.Collections as Collections
import Data.List (sort)
import Data.Maybe (fromJust, isJust, isNothing)
import qualified Data.Text as T
import Debug.Trace
import Paths_siberia
import Siberia.Internal
import Siberia.YandexDisk
import Snap.Util.FileUploads
import System.Directory
import qualified Network.Http.Client as H
import qualified System.IO.Streams as S
import OpenSSL (withOpenSSL)
import Network.HTTP.Base (urlEncode)
import Network.URI
web :: Web ()
web = liftIO getDataDir >>= \dataDir -> ifTop (serveFile $ dataDir <> "/static/index.html")
<|> method GET ( routeLocal [ ("server/stats", statsHandler )
, ("play", (serveFile $ dataDir <> "/static/pl.html"))
, ("stream", getStreamHandler )
, ("stream/:sid", streamHandlerById )
, ("stream/:sid/metadata", streamMetaHandler )
, ("stream/:sid/stats", streamStatsHandler )
, ("playlist/:sid", getPlaylist)
, ("save", saveHandler)
, ("ya/:sid" , yandexHandler)
, ("verification_code", yandexOauth)
] )
<|> method POST ( routeLocal [ ("stream/:sid", postStreamHandler )
, ("playlist/:sid", changePlaylist)
, ("audio/:sid" , postSongAdd)
, ("audio/link/:sid" , postLinkSongAdd)
] )
<|> method DELETE ( routeLocal [ ("stream/:sid", deleteStreamHandler )
, ("audio/:sid/:fid" , deleteSong)
] )
<|> dir "static" (serveDirectory (dataDir <> "/static"))
yandexHandler :: Web ()
yandexHandler = do
sid <- getParam "sid"
maybe (errorWWW 400) codeRequest sid
where
codeRequest st = redirect $ "https://oauth.yandex.ru/authorize?response_type=token&client_id=" <> idYandex <> "&state=" <> st
{-
POST /token HTTP/1.1
Host: oauth.yandex.ru
Content-type: application/x-www-form-urlencoded
Content-Length: <length>
grant_type=authorization_code&code=<code>&client_id=<client_id>&client_secret=<client_secret>
-}
yandexOauth :: Web ()
yandexOauth = do
r <- getRequest
liftIO $ print $ SC.rqPathInfo r
liftIO $ print $ SC.rqQueryString r
liftIO $ print $ SC.rqContextPath r
token <- getParam "access_token"
tokenType <- getParam "token_type"
st <- getParam "state"
liftIO $ print token
liftIO $ print tokenType
liftIO $ print st
statsHandler :: Web ()
statsHandler = writeText "stats"
saveHandler::Web ()
saveHandler = save "radiobase"
getStreamHandler :: Web ()
getStreamHandler = do
s <- list :: Web [Radio]
writeLBS $ encode s
postStreamHandler::Web ()
postStreamHandler = do
info' <- decode <$> readRequestBody 1024 :: Web (Maybe Radio)
case info' of
Nothing -> errorWWW 400
Just i -> do
(result, infoWithHostPort) <- create i
if result
then writeLBS $ encode infoWithHostPort
else errorWWW 400
-- | get playlist
-- curl http://localhost:8000/playlist/local
-- [{"file":"music4.mp3","position":4},{"file":"music3.mp3","position":3},{"file":"music2.mp3","position":2}]
getPlaylist :: Web ()
getPlaylist = do
sid <- getParam "sid"
maybe (errorWWW 400) listSong sid
where
listSong :: ByteString -> Web ()
listSong i = do
isInBase <- member (toById i)
unless isInBase $ errorWWW 403
list <- getD (toById i) :: Web (Maybe Playlist)
maybe (errorWWW 412) (writeLBS . encode) list
-- add downloader here, afther add link
postLinkSongAdd :: Web ()
postLinkSongAdd = error "postLinkSongAdd"
uploadPolicy :: UploadPolicy
uploadPolicy = setMaximumFormInputSize limitSizeForUpload defaultUploadPolicy
-- | upload file to server
-- | curl -F name=test -F [email protected] http://localhost:8000/song/local -v
postSongAdd :: Web ()
postSongAdd = do
sid <- getParam "sid"
maybe (errorWWW 400) makePath sid
dataDir <- liftIO getDataDir
liftIO $ createDirectoryIfMissing True $ dataDir <> tempDir
let Just channelFolder = unpack <$> sid
handleFileUploads (dataDir <> tempDir) uploadPolicy perPartUploadPolicy $ handlerUploads channelFolder
errorWWW 200
where
makePath :: ByteString -> Web ()
makePath i = do
isInBase <- member (toById i)
unless isInBase $ errorWWW 403
dataDir <- liftIO getDataDir
liftIO $ createDirectoryIfMissing True $ dataDir <> musicDirectory <> unpack i
perPartUploadPolicy :: PartInfo -> PartUploadPolicy
perPartUploadPolicy _ = allowWithMaximumSize limitSizeForUpload
handlerUploads :: String -> [(PartInfo, Either PolicyViolationException FilePath)] -> Web ()
handlerUploads channelFolder = mapM_ fun
where fun :: (PartInfo, Either PolicyViolationException FilePath) -> Web ()
fun (p, Left e) = say . T.pack $ "\nerror when upload file \n\t" ++ show p ++ "\t" ++ show e
fun (p, Right path) = do
let Just filename = unpack <$> partFileName p
say . T.pack $ "\nupload file " ++ filename
dataDir <- liftIO getDataDir
liftIO $ renameFile path $ dataDir <> musicDirectory <> channelFolder <> "/" <> filename
pl <- getD (toById (pack channelFolder)) :: Web (Maybe Playlist)
let uri = nullURI { uriScheme = "file:", uriPath = filename }
case pl :: Maybe Playlist of
Nothing -> setD (toById (pack channelFolder)) $ Just (Collections.singleton $ Song 0 uri Nothing Nothing Nothing :: Playlist)
Just pl' -> do
let Song n _ _ _ _ = Collections.maximum pl'
setD (toById (pack channelFolder)) $ Just $ Collections.insert (Song (n + 1) uri Nothing Nothing Nothing) pl'
-- | delete song from playlist
-- dont remove file from filesystem
-- DELETE request like http://localhost:8000/song/local/3
deleteSong :: Web ()
deleteSong = do
sid <- getParam "sid"
fid <- getParam "fid"
trace (show fid) $ case (sid, fid) of
(Just i, Just n) -> do
isInBase <- member (toById i)
unless isInBase $ errorWWW 403
case reads $ unpack n of
[] -> errorWWW 400
[(n', _)] -> rmSong (Song n' nullURI Nothing Nothing Nothing ) i
_ -> errorWWW 400
_ -> errorWWW 400
where
rmSong :: Song -> ByteString -> Web ()
rmSong song i = do
list <- getD (toById i) :: Web (Maybe Playlist)
let isLast = 1 > (Collections.size $ removeSongFromPlaylist song <$> list)
case isLast of
False -> setD (toById i) $ removeSongFromPlaylist song <$> list
True -> setD (toById i) (Nothing :: Maybe Playlist)
errorWWW 200
-- | mv song in playlist
-- curl http://localhost:8000/playlist/local -d '{"file":"music1.mp3","position":0}'
-- return new playlist
changePlaylist :: Web ()
changePlaylist = do
sid <- getParam "sid"
song <- decode <$> readRequestBody 1024 :: Web (Maybe Song)
unless (isJust song) $ errorWWW 400
maybe (errorWWW 400) (mv $ fromJust song) sid
where
mv :: Song -> ByteString -> Web ()
mv song i = do
isInBase <- member (toById i)
unless isInBase $ errorWWW 403
list <- getD (toById i) :: Web (Maybe Playlist)
when (isNothing list) $ errorWWW 403
setD (toById i) $ moveSongInPlaylist song <$> list
writeLBS . encode $ moveSongInPlaylist song <$> list
removeSongFromPlaylist :: Song -> Playlist -> Playlist
removeSongFromPlaylist s p = let list = Collections.filter (\(Song x _ _ _ _) -> x /= idi s) p
sortedPair = zip (sort $ Collections.toList list) [0 .. ]
in Collections.fromAscList $ map (\(Song _ x a b c, y) -> Song y x a b c) sortedPair
moveSongInPlaylist :: Song -> Playlist -> Playlist
moveSongInPlaylist s@(Song position filename _ _ _) p =
let list = sort $ Collections.toList $ Collections.filter (\(Song _ f _ _ _) -> f /= filename) p
h = take position list
t = drop position list
in Collections.fromAscList $ map (\(Song _ x a b c, y) -> Song y x a b c) $ zip (h ++ [s] ++ t) [0 .. ]
toById :: ByteString -> Radio
toById x = ById . RadioId $ "/" <> x
deleteStreamHandler::Web ()
deleteStreamHandler = do
param <- getParam "sid"
maybe (errorWWW 400) rmSt param
where
rmSt i = do
result <- remove (toById i)
errorWWW (if result then 200 else 403)
streamHandlerById::Web ()
streamHandlerById = do
param <- getParam "sid"
maybe (errorWWW 400) getStream param
where
getStream i = do
isInBase <- member (toById i)
unless isInBase $ errorWWW 403
st <- getD (toById i) :: Web Radio
(writeLBS . encode) st
streamMetaHandler :: Web ()
streamMetaHandler = do
sid <- getParam "sid"
maybe (errorWWW 400) sendMeta sid
where
sendMeta :: ByteString -> Web ()
sendMeta i = do
isInBase <- member (toById i)
unless isInBase $ errorWWW 403
meta' <- getD (toById i) :: Web (Maybe Meta)
(writeLBS . encode) meta'
streamStatsHandler :: Web ()
streamStatsHandler = do
sid <- getParam "sid"
maybe (errorWWW 400) sendStatus sid
where
sendStatus :: ByteString -> Web ()
sendStatus i = do
isInBase <- member (toById i)
unless isInBase $ errorWWW 403
st <- getD (toById i):: Web Status
(writeLBS . encode) st
errorWWW :: Int -> Web ()
errorWWW code = finishWith $ setResponseCode code emptyResponse
| chemist/siberia | src/Siberia/Web.hs | bsd-3-clause | 11,422 | 0 | 22 | 3,688 | 3,215 | 1,617 | 1,598 | 222 | 5 |
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-- | Server types and operations for items that don't involve server state
-- nor our custom monads.
module Game.LambdaHack.Server.ItemRev
( ItemRev, buildItem, newItem, UniqueSet
-- * Item discovery types
, DiscoveryKindRev, serverDiscos, ItemSeedDict
-- * The @FlavourMap@ type
, FlavourMap, emptyFlavourMap, dungeonFlavourMap
) where
import Control.Applicative
import Control.Exception.Assert.Sugar
import Control.Monad
import Data.Binary
import qualified Data.EnumMap.Strict as EM
import qualified Data.EnumSet as ES
import qualified Data.HashMap.Strict as HM
import qualified Data.Ix as Ix
import Data.List
import qualified Data.Set as S
import Game.LambdaHack.Common.Flavour
import Game.LambdaHack.Common.Frequency
import Game.LambdaHack.Common.Item
import qualified Game.LambdaHack.Common.Kind as Kind
import Game.LambdaHack.Common.Misc
import Game.LambdaHack.Common.Msg
import Game.LambdaHack.Common.Random
import Game.LambdaHack.Content.ItemKind (ItemKind)
import qualified Game.LambdaHack.Content.ItemKind as IK
-- | The reverse map to @DiscoveryKind@, needed for item creation.
type DiscoveryKindRev = EM.EnumMap (Kind.Id ItemKind) ItemKindIx
-- | The map of item ids to item seeds, needed for item creation.
type ItemSeedDict = EM.EnumMap ItemId ItemSeed
type UniqueSet = ES.EnumSet (Kind.Id ItemKind)
serverDiscos :: Kind.COps -> Rnd (DiscoveryKind, DiscoveryKindRev)
serverDiscos Kind.COps{coitem=Kind.Ops{obounds, ofoldrWithKey}} = do
let ixs = map toEnum $ take (Ix.rangeSize obounds) [0..]
shuffle :: Eq a => [a] -> Rnd [a]
shuffle [] = return []
shuffle l = do
x <- oneOf l
(x :) <$> shuffle (delete x l)
shuffled <- shuffle ixs
let f ik _ (ikMap, ikRev, ix : rest) =
(EM.insert ix ik ikMap, EM.insert ik ix ikRev, rest)
f ik _ (ikMap, _, []) =
assert `failure` "too short ixs" `twith` (ik, ikMap)
(discoS, discoRev, _) =
ofoldrWithKey f (EM.empty, EM.empty, shuffled)
return (discoS, discoRev)
-- | Build an item with the given stats.
buildItem :: FlavourMap -> DiscoveryKindRev -> Kind.Id ItemKind -> ItemKind
-> LevelId
-> Item
buildItem (FlavourMap flavour) discoRev ikChosen kind jlid =
let jkindIx = discoRev EM.! ikChosen
jsymbol = IK.isymbol kind
jname = IK.iname kind
jflavour =
case IK.iflavour kind of
[fl] -> fl
_ -> flavour EM.! ikChosen
jfeature = IK.ifeature kind
jweight = IK.iweight kind
in Item{..}
-- | Generate an item based on level.
newItem :: Kind.COps -> FlavourMap -> DiscoveryKindRev -> UniqueSet
-> Freqs ItemKind -> Int -> LevelId -> AbsDepth -> AbsDepth
-> Rnd (Maybe ( ItemKnown, ItemFull, ItemDisco
, ItemSeed, GroupName ItemKind ))
newItem Kind.COps{coitem=Kind.Ops{ofoldrGroup}}
flavour discoRev uniqueSet itemFreq lvlSpawned jlid
ldepth@(AbsDepth ldAbs) totalDepth@(AbsDepth depth) = do
-- Effective generation depth of actors (not items) increases with spawns.
let scaledDepth = ldAbs * 10 `div` depth
numSpawnedCoeff = lvlSpawned `div` 2
ldSpawned = max ldAbs -- the first fast spawns are of the nominal level
$ min depth
$ ldAbs + numSpawnedCoeff - scaledDepth
findInterval _ x1y1 [] = (x1y1, (11, 0))
findInterval ld x1y1 ((x, y) : rest) =
if fromIntegral ld * 10 <= x * fromIntegral depth
then (x1y1, (x, y))
else findInterval ld (x, y) rest
linearInterpolation ld dataset =
-- We assume @dataset@ is sorted and between 0 and 10.
let ((x1, y1), (x2, y2)) = findInterval ld (0, 0) dataset
in ceiling
$ fromIntegral y1
+ fromIntegral (y2 - y1)
* (fromIntegral ld * 10 - x1 * fromIntegral depth)
/ ((x2 - x1) * fromIntegral depth)
f _ _ _ ik _ acc | ik `ES.member` uniqueSet = acc
f itemGroup q p ik kind acc =
-- Don't consider lvlSpawned for uniques.
let ld = if IK.Unique `elem` IK.iaspects kind then ldAbs else ldSpawned
rarity = linearInterpolation ld (IK.irarity kind)
in (q * p * rarity, ((ik, kind), itemGroup)) : acc
g (itemGroup, q) = ofoldrGroup itemGroup (f itemGroup q) []
freqDepth = concatMap g itemFreq
freq = toFreq ("newItem ('" <> tshow ldSpawned <> ")") freqDepth
if nullFreq freq then return Nothing
else do
((itemKindId, itemKind), itemGroup) <- frequency freq
-- Number of new items/actors unaffected by number of spawned actors.
itemN <- castDice ldepth totalDepth (IK.icount itemKind)
seed <- fmap toEnum random
let itemBase = buildItem flavour discoRev itemKindId itemKind jlid
itemK = max 1 itemN
itemTimer = []
itemDiscoData = ItemDisco {itemKindId, itemKind, itemAE = Just iae}
itemDisco = Just itemDiscoData
-- Bonuses on items/actors unaffected by number of spawned actors.
iae = seedToAspectsEffects seed itemKind ldepth totalDepth
itemFull = ItemFull {..}
return $ Just ( (jkindIx itemBase, iae)
, itemFull
, itemDiscoData
, seed
, itemGroup )
-- | Flavours assigned by the server to item kinds, in this particular game.
newtype FlavourMap = FlavourMap (EM.EnumMap (Kind.Id ItemKind) Flavour)
deriving (Show, Binary)
emptyFlavourMap :: FlavourMap
emptyFlavourMap = FlavourMap EM.empty
-- | Assigns flavours to item kinds. Assures no flavor is repeated for the same
-- symbol, except for items with only one permitted flavour.
rollFlavourMap :: S.Set Flavour -> Kind.Id ItemKind -> ItemKind
-> Rnd ( EM.EnumMap (Kind.Id ItemKind) Flavour
, EM.EnumMap Char (S.Set Flavour) )
-> Rnd ( EM.EnumMap (Kind.Id ItemKind) Flavour
, EM.EnumMap Char (S.Set Flavour) )
rollFlavourMap fullFlavSet key ik rnd =
let flavours = IK.iflavour ik
in if length flavours == 1
then rnd
else do
(assocs, availableMap) <- rnd
let available =
EM.findWithDefault fullFlavSet (IK.isymbol ik) availableMap
proper = S.fromList flavours `S.intersection` available
assert (not (S.null proper)
`blame` "not enough flavours for items"
`twith` (flavours, available, ik, availableMap)) $ do
flavour <- oneOf (S.toList proper)
let availableReduced = S.delete flavour available
return ( EM.insert key flavour assocs
, EM.insert (IK.isymbol ik) availableReduced availableMap)
-- | Randomly chooses flavour for all item kinds for this game.
dungeonFlavourMap :: Kind.COps -> Rnd FlavourMap
dungeonFlavourMap Kind.COps{coitem=Kind.Ops{ofoldrWithKey}} =
liftM (FlavourMap . fst) $
ofoldrWithKey (rollFlavourMap (S.fromList stdFlav))
(return (EM.empty, EM.empty))
-- | Reverse item map, for item creation, to keep items and item identifiers
-- in bijection.
type ItemRev = HM.HashMap ItemKnown ItemId
| Concomitant/LambdaHack | Game/LambdaHack/Server/ItemRev.hs | bsd-3-clause | 7,164 | 0 | 18 | 1,802 | 2,012 | 1,086 | 926 | -1 | -1 |
import System.Environment (getArgs)
import System.Posix.Files (fileSize, getFileStatus)
main :: IO ()
main = do
[inpFile] <- getArgs
status <- getFileStatus inpFile
print . toInteger . fileSize $ status
| nikai3d/ce-challenges | easy/filesize.hs | bsd-3-clause | 216 | 0 | 9 | 41 | 75 | 39 | 36 | 7 | 1 |
module AnimationSpec (main, spec) where
import Test.Hspec
import Animation
import Data.Aeson (decode)
import qualified Data.ByteString.Lazy.Char8 as C
main :: IO ()
main = hspec spec
spec :: Spec
spec = do
describe "iterate" $ do
it "should iterate between zero and 2" $
interpolate 3 0 2 `shouldBe` [0, 1, 2]
it "should iterate between 10 and 50 for 9 frames" $
interpolate 9 10 50 `shouldBe` [10, 15, 20, 25, 30, 35, 40, 45, 50]
it "should iterate between 10 and 50 for 10 frames" $
interpolate 10 10 50 `shouldBe` [10, 14, 19, 23, 28, 32, 37, 41, 46, 50]
describe "animate typeclass" $ do
it "should animate Points directly to end in two frames" $
animate 2 (Point 0 1) (Point 1 0) `shouldBe` [Point 0 1, Point 1 0]
it "should animate Points in-between the points once for three frames" $
animate 3 (Point 0 2) (Point 2 0) `shouldBe` [Point 0 2, Point 1 1, Point 2 0]
it "should animate the line over 2" $
animate 3 (Line (Point 0 0) (Point 0 2))
(Line (Point 2 0) (Point 2 2)) `shouldBe` [Line (Point 0 0) (Point 0 2),
Line (Point 1 0) (Point 1 2),
Line (Point 2 0) (Point 2 2)]
it "should animate the rectangle over 2" $
animate 3 (Rectangle (Point 0 0) (Point 2 2)) (Rectangle (Point 2 2) (Point 4 4)) `shouldBe` [Rectangle (Point 0 0) (Point 2 2),
Rectangle (Point 1 1) (Point 3 3),
Rectangle (Point 2 2) (Point 4 4)]
it "should animate the circle over 2" $
animate 3 (Circle (Point 0 0) 2) (Circle (Point 2 2) 4) `shouldBe` [Circle (Point 0 0) 2,
Circle (Point 1 1) 3,
Circle (Point 2 2) 4]
it "should animate the ellipse over 2" $
animate 3 (Ellipse (Point 0 0) 2 4) (Ellipse (Point 2 2) 4 2) `shouldBe` [Ellipse (Point 0 0) 2 4,
Ellipse (Point 1 1) 3 3,
Ellipse (Point 2 2) 4 2]
describe "translate typeclass" $ do
it "should translate points" $
translate (Point 1 1) (Point 0 1) `shouldBe` Point 1 2
it "should translate lines" $
translate (Point 1 1) (Line (Point 0 1) (Point 1 0)) `shouldBe` Line (Point 1 2) (Point 2 1)
it "should translate rectangles" $
translate (Point 1 1) (Rectangle (Point 0 1) (Point 1 0)) `shouldBe` Rectangle (Point 1 2) (Point 2 1)
it "should translate circles" $
translate (Point 1 1) (Circle (Point 0 1) 5) `shouldBe` Circle (Point 1 2) 5
it "should translate ellipses" $
translate (Point 1 1) (Ellipse (Point 0 1) 5 6) `shouldBe` Ellipse (Point 1 2) 5 6
describe "json" $ do
it "should decode points" $
(decode . C.pack) "{\"x\": 32, \"y\": 24}" `shouldBe` Just Point {x=32, y=24}
it "should decode lines" $
(decode . C.pack) "{\"start\": {\"x\": 32, \"y\": 24}, \"end\": {\"x\": 24, \"y\": 32}}" `shouldBe` Just (Line Point {x=32, y=24} Point {x=24, y=32})
it "should decode rectangles" $
(decode . C.pack) "{\"topLeft\": {\"x\": 32, \"y\": 24}, \"bottomRight\": {\"x\": 24, \"y\": 32}}" `shouldBe` Just (Rectangle (Point 32 24) (Point 24 32))
it "should decode circles" $
(decode . C.pack) "{\"center\": {\"x\": 1, \"y\": 2}, \"radius\": 3}" `shouldBe` Just (Circle (Point 1 2) 3)
it "should decode ellipses" $
(decode . C.pack) "{\"ellipseCenter\": {\"x\": 1, \"y\": 2}, \"rX\": 3, \"rY\": 4}" `shouldBe` Just (Ellipse (Point 1 2) 3 4)
| matt-keibler/svg-playground | test/AnimationSpec.hs | bsd-3-clause | 3,902 | 0 | 16 | 1,385 | 1,436 | 727 | 709 | 60 | 1 |
{-# LANGUAGE ScopedTypeVariables #-}
module Main (main) where
import Control.Exception
import Control.Applicative
import Network.Socket hiding (send, recv)
import Network.Socket.ByteString.Lazy
import Control.Concurrent.Async
import Data.Time
import System.IO
import Control.Monad
import System.Random
import Codec.Crypto.AES
import qualified Data.ByteString.Lazy as BL
import qualified Data.ByteString as B
import Data.Word
import Data.Binary.Put
import Reactive.Banana as R
import Reactive.Banana.Frameworks as R
import EventSources
import RrcMessages
import Identifiers
import UeContextStates
import LogTools
main :: IO ()
main =
withSocketsDo $ do
let nbOfUes = 100
logh <- openFile "log_ue.txt" WriteMode
startTime <- getCurrentTime
ues <- mapM (async . powerOn logh) [1..nbOfUes]
mapM_ wait ues
endTime <- getCurrentTime
endOfProgram
let diff = endTime `diffUTCTime` startTime
writeToLog logh $ "Time for the " ++ (show nbOfUes) ++ " UEs procedures: " ++ (show diff)
hClose logh
powerOn :: Handle -> Int -> IO ()
powerOn logh ueId =
bracket (connectedSocket "127.0.0.1" "43000")
close (powerOn' logh)
where
powerOn' :: Handle -> Socket -> IO ()
powerOn' logh sock = do
sources <- newAddHandler
network <- compile $ setupNetwork sources ueId logh
actuate network
startProcedure <- getCurrentTime
eventLoop sources sock ueId
endProcedure <- getCurrentTime
let diff = endProcedure `diffUTCTime` startProcedure
writeToLog logh $ "Terminated UE " ++ (show ueId) ++ " execution time(UeSide): " ++ (show diff) ++ " with begin time " ++ (show startProcedure)
return ()
connectedSocket :: HostName -> ServiceName -> IO Socket
connectedSocket host port = do
sock <- socket AF_INET Stream defaultProtocol
addrInfo <- getAddrInfo Nothing (Just host) (Just port)
let primary = head addrInfo
connect sock $ addrAddress primary
return sock
endOfProgram :: IO()
endOfProgram =
bracket (connectedSocket "127.0.0.1" "43000")
close endOfProgram'
where
endOfProgram' :: Socket -> IO ()
endOfProgram' sock = do
_ <- send sock $ encode (EndOfProgramEnb)
return ()
eventLoop :: EventSource (RrcMessage,Socket)-> Socket-> Int -> IO ()
eventLoop message sock ueId = withSocketsDo $ do
_ <- send sock $ encode (RaPreamble RA_RNTI ueId)
loop
where loop = do
messDec <- decode <$> recv sock 1024
fire message (messDec,sock)
when (notlastMessage messDec) loop
where notlastMessage mess = case mess of
(RrcConnectionAccept _ ) -> False
(RrcConnectionReject _ _) -> False
_ -> True
{-----------------------------------------------------
Program Logic
------------------------------------------------------}
setupNetwork :: forall t. Frameworks t =>
EventSource (RrcMessage,Socket) -> Int -> Handle -> Moment t ()
setupNetwork message ueId logh = do
eMessage<- fromAddHandler (addHandler message)
let
bUeState :: Behavior t UeContext_ue
bUeState = stepper (initialUeState ueId) (apply (addSrb_ue <$> bUeState) eRrcConnectionSetup)
incomingMessageType :: (RrcMessage, Socket) -> RrcMessageType
incomingMessageType event = case event of
(RaResponse _ _ _,_)-> RaR
(RrcConnectionSetup _ _ _, _)-> RrcCS
(SecurityModeCommand _ _,_)-> SecurityMCommand
(UeCapabilityEnquiry _ _,_)-> UeCE
(RrcConnectionReconfiguration _ _,_)-> RrcCReconfiguration
(RrcConnectionReject _ _,_)-> RrcCReject
(RrcConnectionAccept _,_)-> RrcCA
eRaResponse = filterE (\t -> (incomingMessageType t) == RaR) eMessage
eRrcConnectionSetup = filterE (\t -> (incomingMessageType t) == RrcCS) eMessage
eSecurityModeCommand = filterE (\t -> (incomingMessageType t) == SecurityMCommand) eMessage
eUeCapabilityEnquiry = filterE (\t -> (incomingMessageType t) == UeCE) eMessage
eRrcConnectionReconfiguration = filterE (\t -> (incomingMessageType t) == RrcCReconfiguration) eMessage
eResponseRaR =
(createRrcCRequest <$> bUeState) <@> eRaResponse
where
createRrcCRequest state (message,socket) =
(RrcConnectionRequest C_RNTI (ueIdCRnti message) (imsi_ue state),socket)
eResponseRrcCS =
(createRrcCSC <$> bUeState) <@> eRrcConnectionSetup
where
createRrcCSC state (message,socket) =
(RrcConnectionSetupComplete (ueIdRntiValue message) (mcc(imsi_ue state) ++ mnc(imsi_ue state)),socket)
eResponseSecurityMCommand =
(createSecurityMComplete <$> bUeState) <@> eSecurityModeCommand
where
createSecurityMComplete state (message,socket) =
if (decode decrypted == "ciphered")
then (SecurityModeComplete (ueCRnti message) True,socket)
else (SecurityModeComplete (ueCRnti message) False,socket)
where
decrypted = decryptResponse (securityKey_ue state) (message_security message)
eResponseUeCE =
createUeCI <$> eUeCapabilityEnquiry
where
createUeCI (message,socket) =
(UeCapabilityInformation (ueCRnti message) (genRandomRatCapabilities ((ueCRnti message)*6) message) ,socket)
where
genRandomRatCapabilities seed message =
zip ratList boolList
where
boolList = take 5 $ randoms (mkStdGen seed):: [Bool]
ratList = (ueCapabilityRequest message)
eResponseRrcCReconfiguration =
createRrcCRC <$> eRrcConnectionReconfiguration
where
createRrcCRC (message,socket) =
if activationComplete
then (RrcConnectionReconfigurationComplete (ueCRnti message) True,socket)
else (RrcConnectionReconfigurationComplete (ueCRnti message) False,socket)
where
epsId = epsRadioBearerIdentity message
activationComplete = not (((head epsId)== (last epsId)) && ((head epsId)== '9'))
eResponseMessage = eResponseRaR `union` eResponseRrcCS `union` eResponseSecurityMCommand `union` eResponseUeCE `union` eResponseRrcCReconfiguration
--Output
reactimate $ sendResponse <$> eResponseMessage
reactimate $ writeToLog logh . showMessage <$> eMessage
reactimate $ (finalLog_ue logh <$> bUeState) <@> eResponseRrcCReconfiguration
showMessage :: (RrcMessage,Socket) -> String
showMessage (message,_) = "Message received: " ++ show message
sendResponse :: (RrcMessage,Socket) -> IO ()
sendResponse (message,sock) = do
_ <- send sock $ encode message
return ()
decryptResponse :: Int -> BL.ByteString -> BL.ByteString
decryptResponse key message =
crypt CTR key' iv Decrypt message
where
key' = B.concat(BL.toChunks(BL.concat[(encode key),(encode key)]))
iv = B.concat(BL.toChunks(runPut(do
putWord64be 0
putWord64be 0
)))
| Ilydocus/frp-prototype | src/ue.hs | bsd-3-clause | 7,184 | 0 | 20 | 1,813 | 2,028 | 1,044 | 984 | 147 | 9 |
module ProjectEuler.Problem024 (solution024) where
import Data.Digits
import Util
solution024 :: Integer
solution024 = unDigits 10 $ sortedPermutations [0..9] !! (1e6 - 1)
| guillaume-nargeot/project-euler-haskell | src/ProjectEuler/Problem024.hs | bsd-3-clause | 174 | 0 | 8 | 24 | 55 | 31 | 24 | 5 | 1 |
module PocStrategy where
import PocParser
import Control.Monad
import Data.Monoid
import qualified Data.Map.Lazy as Map
import Data.List (nub, sort, minimumBy)
import Data.Maybe
type Var = String
type In a = Maybe a
type Out a = [a]
type Tr = In Int
type ArrMap = Map.Map Var Tr
data Access = Access { interIn :: In Var
, interOut :: Out Var
, transposes :: ArrMap
}
deriving (Show, Eq)
-- Monoid structure for (Maybe Access)
unit :: Access
unit = Access Nothing [] Map.empty
plus :: Access -> Access -> Maybe Access
a1 `plus` a2 = do
interIn <- joinIn (interIn a1) (interIn a2)
interOut <- joinOut (interOut a1) (interOut a2)
when (isJust interIn && (fromJust interIn) `elem` interOut) Nothing
tr <- joinTr (transposes a1) (transposes a2)
Just $ Access interIn interOut tr
-- Helper functions for plus --
joinIn :: (Eq a) => In a -> In a -> Maybe (In a)
joinIn x Nothing = return x
joinIn Nothing y = return y
joinIn (Just a) (Just b) = if a == b then return (Just a) else Nothing
joinOut :: (Ord a) => Out a -> Out a -> Maybe (Out a)
joinOut xs ys = return zs
where zs = sort . nub $ xs ++ ys
joinTr :: ArrMap -> ArrMap -> Maybe ArrMap
joinTr m1 m2 = foldM help m1 pairs
where pairs = Map.toList m2
help m (v,t1) = case Map.lookup v m of
Nothing -> return $ Map.insert v t1 m
Just t2 -> do t <- joinTransposes t1 t2
return $ Map.insert v t m
joinTransposes :: Tr -> Tr -> Maybe Tr
joinTransposes i1 i2 = do i1' <- i1
i2' <- i2
if i1 == i2 then Just i1 else Nothing
----
-- The real meat.
chooseStrategy :: Kernel -> Maybe Access
chooseStrategy (Kernel lvs stmts) = case ss of
[] -> Nothing
ss -> Just $ minimumBy accessCmp ss
where ss = (filter notAllOut) . makeStrategy $ map (generate lvs) stmts
notAllOut a = length (interOut a) < length lvs
-- Order strategies on the number of transpositions made
accessCmp :: Access -> Access -> Ordering
accessCmp a b = a' `compare` b'
where nonemptyTr Nothing = False
nonemptyTr (Just a) = a > 0
[a',b'] = map (Map.size . Map.filter nonemptyTr . transposes) [a,b]
-- Fold over all array accesses generated
makeStrategy :: [[Access]] -> [Access]
makeStrategy = foldr combine [unit]
where combine xs ys = catMaybes [ plus x y | x <- xs, y <- ys ]
-- Generate all the possible startegy choices for a single array lookup
-- [LoopVars] ArrAccess -> [Initial As]
generate :: [Var] -> Stmt -> [Access]
generate lvs (ArrAccess arr is) = catMaybes (out : ins)
where ins = map (pushIn arr is) variants -- Coalesced access
out = Just $ Access Nothing variants Map.empty -- Invariant access
variants = filter (isVariantTo is) lvs
pushIn :: String -> [Index] -> String -> Maybe Access
pushIn arr is lv = case variantIndices is lv of
[] -> Just $ Access (Just lv) [] Map.empty
-- Access is invariant to lv
[x] -> Just $ Access (Just lv) [] (Map.singleton arr (Just x))
-- Access is variant in one index.
_ -> Nothing
-- Access is variant in more indexes to lv. No use in pushing in.
pushOut :: [Index] -> [String] -> Maybe Access
pushOut is lvs = Just $ Access Nothing (sort . filter (isVariantTo is) $ lvs) Map.empty
isVariantTo :: [Index] -> String -> Bool
isVariantTo is var = variantIndices is var /= []
-- These indices are numbers! Positions in the array!
-- From innermost to outermost! That is, i is the position of the relevant access.
variantIndices :: [Index] -> String -> [Int]
variantIndices is var = filter (\x -> (is !! x) == Var var) [0..length is-1]
--Temp tester function
makeAccesses :: Kernel -> [[Access]]
makeAccesses (Kernel lvs stmts) = map (generate lvs) stmts
| NicolaiNebel/Bachelor-Poc | src/PocStrategy.hs | bsd-3-clause | 4,139 | 0 | 15 | 1,283 | 1,397 | 722 | 675 | 75 | 3 |
module Intel.ArBB.Variable where
data Variable = Variable String
deriving (Eq, Ord, Show) | svenssonjoel/EmbArBB | Intel/ArBB/Variable.hs | bsd-3-clause | 106 | 0 | 6 | 28 | 31 | 18 | 13 | 3 | 0 |
{-# LANGUAGE CPP, ForeignFunctionInterface #-}
#ifdef STRAIGHT
import StraightForwardSTM
#elif defined(DISSECTED)
import DissectedSTM
#elif defined(LOCKCOUPLING)
import LockCoupling
#elif defined(CAS)
import CASLL
#else
#error Undefined Implementation
#endif
import System.Random(randomRs, mkStdGen)
import Control.Monad(foldM_)
import Control.Concurrent.MVar(takeMVar, putMVar, newEmptyMVar, MVar)
import Control.Concurrent(forkOn, getNumCapabilities)
import Text.Printf(printf)
import Dump
-- 0-1 2 3-6
data Op = Lookup Int | Delete Int | Insert Int
numOps = 3000
threadLoop [] l = return()
threadLoop (r:rs) l =
if mod r 7 <= 1
then find l r >>= \b -> threadLoop rs l
else if mod r 7 == 2
then delete l r >>= \b -> threadLoop rs l
else addToTail l r >>= \b -> threadLoop rs l
mkThreads 0 l = return[]
mkThreads i l = do
mv <- newEmptyMVar
forkOn (i-1) $ do threadLoop (take numOps (randomRs (0, 100000) (mkStdGen i))) l; putMVar mv()
mvs <- mkThreads (i-1) l
return $ mv : mvs
join :: [MVar()] -> IO ()
join [] = return()
join (mv:mvs) = do
takeMVar mv
join mvs
main = do
#if defined(STRAIGHT) || defined(DISSECTED)
putStrLn ("Executing benchmark with " ++ whichSTM)
#endif
l <- newList
let randoms = randomRs (0::Int, 100000) (mkStdGen 0)
let (init, randoms') = splitAt 3000 randoms
foldM_ (\b -> \a -> addToTail l a) () init
-- numCapabilities <- getNumCapabilities
start <- getTime
mvs <- mkThreads 4 l
join mvs
end <- getTime
printf "Time = %0.3f\n" (end - start :: Double)
#if defined(STRAIGHT) || defined(DISSECTED)
printStats
#endif
return()
foreign import ccall unsafe "hs_gettime" getTime :: IO Double | ml9951/ghc | libraries/pastm/examples/damp-comparing-linked-lists/Main.hs | bsd-3-clause | 1,833 | 0 | 16 | 473 | 605 | 308 | 297 | -1 | -1 |
{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
Arity and eta expansion
-}
{-# LANGUAGE CPP #-}
-- | Arity and eta expansion
module CoreArity (
manifestArity, exprArity, typeArity, exprBotStrictness_maybe,
exprEtaExpandArity, findRhsArity, CheapFun, etaExpand
) where
#include "HsVersions.h"
import CoreSyn
import CoreFVs
import CoreUtils
import CoreSubst
import Demand
import Var
import VarEnv
import Id
import Type
import TyCon ( initRecTc, checkRecTc )
import Coercion
import BasicTypes
import Unique
import DynFlags ( DynFlags, GeneralFlag(..), gopt )
import Outputable
import FastString
import Pair
import Util ( debugIsOn )
{-
************************************************************************
* *
manifestArity and exprArity
* *
************************************************************************
exprArity is a cheap-and-cheerful version of exprEtaExpandArity.
It tells how many things the expression can be applied to before doing
any work. It doesn't look inside cases, lets, etc. The idea is that
exprEtaExpandArity will do the hard work, leaving something that's easy
for exprArity to grapple with. In particular, Simplify uses exprArity to
compute the ArityInfo for the Id.
Originally I thought that it was enough just to look for top-level lambdas, but
it isn't. I've seen this
foo = PrelBase.timesInt
We want foo to get arity 2 even though the eta-expander will leave it
unchanged, in the expectation that it'll be inlined. But occasionally it
isn't, because foo is blacklisted (used in a rule).
Similarly, see the ok_note check in exprEtaExpandArity. So
f = __inline_me (\x -> e)
won't be eta-expanded.
And in any case it seems more robust to have exprArity be a bit more intelligent.
But note that (\x y z -> f x y z)
should have arity 3, regardless of f's arity.
-}
manifestArity :: CoreExpr -> Arity
-- ^ manifestArity sees how many leading value lambdas there are,
-- after looking through casts
manifestArity (Lam v e) | isId v = 1 + manifestArity e
| otherwise = manifestArity e
manifestArity (Tick t e) | not (tickishIsCode t) = manifestArity e
manifestArity (Cast e _) = manifestArity e
manifestArity _ = 0
---------------
exprArity :: CoreExpr -> Arity
-- ^ An approximate, fast, version of 'exprEtaExpandArity'
exprArity e = go e
where
go (Var v) = idArity v
go (Lam x e) | isId x = go e + 1
| otherwise = go e
go (Tick t e) | not (tickishIsCode t) = go e
go (Cast e co) = trim_arity (go e) (pSnd (coercionKind co))
-- Note [exprArity invariant]
go (App e (Type _)) = go e
go (App f a) | exprIsTrivial a = (go f - 1) `max` 0
-- See Note [exprArity for applications]
-- NB: coercions count as a value argument
go _ = 0
trim_arity :: Arity -> Type -> Arity
trim_arity arity ty = arity `min` length (typeArity ty)
---------------
typeArity :: Type -> [OneShotInfo]
-- How many value arrows are visible in the type?
-- We look through foralls, and newtypes
-- See Note [exprArity invariant]
typeArity ty
= go initRecTc ty
where
go rec_nts ty
| Just (bndr, ty') <- splitPiTy_maybe ty
= if isIdLikeBinder bndr
then typeOneShot (binderType bndr) : go rec_nts ty'
else go rec_nts ty'
| Just (tc,tys) <- splitTyConApp_maybe ty
, Just (ty', _) <- instNewTyCon_maybe tc tys
, Just rec_nts' <- checkRecTc rec_nts tc -- See Note [Expanding newtypes]
-- in TyCon
-- , not (isClassTyCon tc) -- Do not eta-expand through newtype classes
-- -- See Note [Newtype classes and eta expansion]
-- (no longer required)
= go rec_nts' ty'
-- Important to look through non-recursive newtypes, so that, eg
-- (f x) where f has arity 2, f :: Int -> IO ()
-- Here we want to get arity 1 for the result!
--
-- AND through a layer of recursive newtypes
-- e.g. newtype Stream m a b = Stream (m (Either b (a, Stream m a b)))
| otherwise
= []
---------------
exprBotStrictness_maybe :: CoreExpr -> Maybe (Arity, StrictSig)
-- A cheap and cheerful function that identifies bottoming functions
-- and gives them a suitable strictness signatures. It's used during
-- float-out
exprBotStrictness_maybe e
= case getBotArity (arityType env e) of
Nothing -> Nothing
Just ar -> Just (ar, sig ar)
where
env = AE { ae_ped_bot = True, ae_cheap_fn = \ _ _ -> False }
sig ar = mkClosedStrictSig (replicate ar topDmd) exnRes
-- For this purpose we can be very simple
-- exnRes is a bit less aggressive than botRes
{-
Note [exprArity invariant]
~~~~~~~~~~~~~~~~~~~~~~~~~~
exprArity has the following invariant:
(1) If typeArity (exprType e) = n,
then manifestArity (etaExpand e n) = n
That is, etaExpand can always expand as much as typeArity says
So the case analysis in etaExpand and in typeArity must match
(2) exprArity e <= typeArity (exprType e)
(3) Hence if (exprArity e) = n, then manifestArity (etaExpand e n) = n
That is, if exprArity says "the arity is n" then etaExpand really
can get "n" manifest lambdas to the top.
Why is this important? Because
- In TidyPgm we use exprArity to fix the *final arity* of
each top-level Id, and in
- In CorePrep we use etaExpand on each rhs, so that the visible lambdas
actually match that arity, which in turn means
that the StgRhs has the right number of lambdas
An alternative would be to do the eta-expansion in TidyPgm, at least
for top-level bindings, in which case we would not need the trim_arity
in exprArity. That is a less local change, so I'm going to leave it for today!
Note [Newtype classes and eta expansion]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
NB: this nasty special case is no longer required, because
for newtype classes we don't use the class-op rule mechanism
at all. See Note [Single-method classes] in TcInstDcls. SLPJ May 2013
-------- Old out of date comments, just for interest -----------
We have to be careful when eta-expanding through newtypes. In general
it's a good idea, but annoyingly it interacts badly with the class-op
rule mechanism. Consider
class C a where { op :: a -> a }
instance C b => C [b] where
op x = ...
These translate to
co :: forall a. (a->a) ~ C a
$copList :: C b -> [b] -> [b]
$copList d x = ...
$dfList :: C b -> C [b]
{-# DFunUnfolding = [$copList] #-}
$dfList d = $copList d |> co@[b]
Now suppose we have:
dCInt :: C Int
blah :: [Int] -> [Int]
blah = op ($dfList dCInt)
Now we want the built-in op/$dfList rule will fire to give
blah = $copList dCInt
But with eta-expansion 'blah' might (and in Trac #3772, which is
slightly more complicated, does) turn into
blah = op (\eta. ($dfList dCInt |> sym co) eta)
and now it is *much* harder for the op/$dfList rule to fire, because
exprIsConApp_maybe won't hold of the argument to op. I considered
trying to *make* it hold, but it's tricky and I gave up.
The test simplCore/should_compile/T3722 is an excellent example.
-------- End of old out of date comments, just for interest -----------
Note [exprArity for applications]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we come to an application we check that the arg is trivial.
eg f (fac x) does not have arity 2,
even if f has arity 3!
* We require that is trivial rather merely cheap. Suppose f has arity 2.
Then f (Just y)
has arity 0, because if we gave it arity 1 and then inlined f we'd get
let v = Just y in \w. <f-body>
which has arity 0. And we try to maintain the invariant that we don't
have arity decreases.
* The `max 0` is important! (\x y -> f x) has arity 2, even if f is
unknown, hence arity 0
************************************************************************
* *
Computing the "arity" of an expression
* *
************************************************************************
Note [Definition of arity]
~~~~~~~~~~~~~~~~~~~~~~~~~~
The "arity" of an expression 'e' is n if
applying 'e' to *fewer* than n *value* arguments
converges rapidly
Or, to put it another way
there is no work lost in duplicating the partial
application (e x1 .. x(n-1))
In the divegent case, no work is lost by duplicating because if the thing
is evaluated once, that's the end of the program.
Or, to put it another way, in any context C
C[ (\x1 .. xn. e x1 .. xn) ]
is as efficient as
C[ e ]
It's all a bit more subtle than it looks:
Note [One-shot lambdas]
~~~~~~~~~~~~~~~~~~~~~~~
Consider one-shot lambdas
let x = expensive in \y z -> E
We want this to have arity 1 if the \y-abstraction is a 1-shot lambda.
Note [Dealing with bottom]
~~~~~~~~~~~~~~~~~~~~~~~~~~
A Big Deal with computing arities is expressions like
f = \x -> case x of
True -> \s -> e1
False -> \s -> e2
This happens all the time when f :: Bool -> IO ()
In this case we do eta-expand, in order to get that \s to the
top, and give f arity 2.
This isn't really right in the presence of seq. Consider
(f bot) `seq` 1
This should diverge! But if we eta-expand, it won't. We ignore this
"problem" (unless -fpedantic-bottoms is on), because being scrupulous
would lose an important transformation for many programs. (See
Trac #5587 for an example.)
Consider also
f = \x -> error "foo"
Here, arity 1 is fine. But if it is
f = \x -> case x of
True -> error "foo"
False -> \y -> x+y
then we want to get arity 2. Technically, this isn't quite right, because
(f True) `seq` 1
should diverge, but it'll converge if we eta-expand f. Nevertheless, we
do so; it improves some programs significantly, and increasing convergence
isn't a bad thing. Hence the ABot/ATop in ArityType.
So these two transformations aren't always the Right Thing, and we
have several tickets reporting unexpected bahaviour resulting from
this transformation. So we try to limit it as much as possible:
(1) Do NOT move a lambda outside a known-bottom case expression
case undefined of { (a,b) -> \y -> e }
This showed up in Trac #5557
(2) Do NOT move a lambda outside a case if all the branches of
the case are known to return bottom.
case x of { (a,b) -> \y -> error "urk" }
This case is less important, but the idea is that if the fn is
going to diverge eventually anyway then getting the best arity
isn't an issue, so we might as well play safe
(3) Do NOT move a lambda outside a case unless
(a) The scrutinee is ok-for-speculation, or
(b) more liberally: the scrutinee is cheap (e.g. a variable), and
-fpedantic-bottoms is not enforced (see Trac #2915 for an example)
Of course both (1) and (2) are readily defeated by disguising the bottoms.
4. Note [Newtype arity]
~~~~~~~~~~~~~~~~~~~~~~~~
Non-recursive newtypes are transparent, and should not get in the way.
We do (currently) eta-expand recursive newtypes too. So if we have, say
newtype T = MkT ([T] -> Int)
Suppose we have
e = coerce T f
where f has arity 1. Then: etaExpandArity e = 1;
that is, etaExpandArity looks through the coerce.
When we eta-expand e to arity 1: eta_expand 1 e T
we want to get: coerce T (\x::[T] -> (coerce ([T]->Int) e) x)
HOWEVER, note that if you use coerce bogusly you can ge
coerce Int negate
And since negate has arity 2, you might try to eta expand. But you can't
decopose Int to a function type. Hence the final case in eta_expand.
Note [The state-transformer hack]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Suppose we have
f = e
where e has arity n. Then, if we know from the context that f has
a usage type like
t1 -> ... -> tn -1-> t(n+1) -1-> ... -1-> tm -> ...
then we can expand the arity to m. This usage type says that
any application (x e1 .. en) will be applied to uniquely to (m-n) more args
Consider f = \x. let y = <expensive>
in case x of
True -> foo
False -> \(s:RealWorld) -> e
where foo has arity 1. Then we want the state hack to
apply to foo too, so we can eta expand the case.
Then we expect that if f is applied to one arg, it'll be applied to two
(that's the hack -- we don't really know, and sometimes it's false)
See also Id.isOneShotBndr.
Note [State hack and bottoming functions]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
It's a terrible idea to use the state hack on a bottoming function.
Here's what happens (Trac #2861):
f :: String -> IO T
f = \p. error "..."
Eta-expand, using the state hack:
f = \p. (\s. ((error "...") |> g1) s) |> g2
g1 :: IO T ~ (S -> (S,T))
g2 :: (S -> (S,T)) ~ IO T
Extrude the g2
f' = \p. \s. ((error "...") |> g1) s
f = f' |> (String -> g2)
Discard args for bottomming function
f' = \p. \s. ((error "...") |> g1 |> g3
g3 :: (S -> (S,T)) ~ (S,T)
Extrude g1.g3
f'' = \p. \s. (error "...")
f' = f'' |> (String -> S -> g1.g3)
And now we can repeat the whole loop. Aargh! The bug is in applying the
state hack to a function which then swallows the argument.
This arose in another guise in Trac #3959. Here we had
catch# (throw exn >> return ())
Note that (throw :: forall a e. Exn e => e -> a) is called with [a = IO ()].
After inlining (>>) we get
catch# (\_. throw {IO ()} exn)
We must *not* eta-expand to
catch# (\_ _. throw {...} exn)
because 'catch#' expects to get a (# _,_ #) after applying its argument to
a State#, not another function!
In short, we use the state hack to allow us to push let inside a lambda,
but not to introduce a new lambda.
Note [ArityType]
~~~~~~~~~~~~~~~~
ArityType is the result of a compositional analysis on expressions,
from which we can decide the real arity of the expression (extracted
with function exprEtaExpandArity).
Here is what the fields mean. If an arbitrary expression 'f' has
ArityType 'at', then
* If at = ABot n, then (f x1..xn) definitely diverges. Partial
applications to fewer than n args may *or may not* diverge.
We allow ourselves to eta-expand bottoming functions, even
if doing so may lose some `seq` sharing,
let x = <expensive> in \y. error (g x y)
==> \y. let x = <expensive> in error (g x y)
* If at = ATop as, and n=length as,
then expanding 'f' to (\x1..xn. f x1 .. xn) loses no sharing,
assuming the calls of f respect the one-shot-ness of
its definition.
NB 'f' is an arbitrary expression, eg (f = g e1 e2). This 'f'
can have ArityType as ATop, with length as > 0, only if e1 e2 are
themselves.
* In both cases, f, (f x1), ... (f x1 ... f(n-1)) are definitely
really functions, or bottom, but *not* casts from a data type, in
at least one case branch. (If it's a function in one case branch but
an unsafe cast from a data type in another, the program is bogus.)
So eta expansion is dynamically ok; see Note [State hack and
bottoming functions], the part about catch#
Example:
f = \x\y. let v = <expensive> in
\s(one-shot) \t(one-shot). blah
'f' has ArityType [ManyShot,ManyShot,OneShot,OneShot]
The one-shot-ness means we can, in effect, push that
'let' inside the \st.
Suppose f = \xy. x+y
Then f :: AT [False,False] ATop
f v :: AT [False] ATop
f <expensive> :: AT [] ATop
-------------------- Main arity code ----------------------------
-}
-- See Note [ArityType]
data ArityType = ATop [OneShotInfo] | ABot Arity
-- There is always an explicit lambda
-- to justify the [OneShot], or the Arity
vanillaArityType :: ArityType
vanillaArityType = ATop [] -- Totally uninformative
-- ^ The Arity returned is the number of value args the
-- expression can be applied to without doing much work
exprEtaExpandArity :: DynFlags -> CoreExpr -> Arity
-- exprEtaExpandArity is used when eta expanding
-- e ==> \xy -> e x y
exprEtaExpandArity dflags e
= case (arityType env e) of
ATop oss -> length oss
ABot n -> n
where
env = AE { ae_cheap_fn = mk_cheap_fn dflags isCheapApp
, ae_ped_bot = gopt Opt_PedanticBottoms dflags }
getBotArity :: ArityType -> Maybe Arity
-- Arity of a divergent function
getBotArity (ABot n) = Just n
getBotArity _ = Nothing
mk_cheap_fn :: DynFlags -> CheapAppFun -> CheapFun
mk_cheap_fn dflags cheap_app
| not (gopt Opt_DictsCheap dflags)
= \e _ -> exprIsCheap' cheap_app e
| otherwise
= \e mb_ty -> exprIsCheap' cheap_app e
|| case mb_ty of
Nothing -> False
Just ty -> isDictLikeTy ty
----------------------
findRhsArity :: DynFlags -> Id -> CoreExpr -> Arity -> Arity
-- This implements the fixpoint loop for arity analysis
-- See Note [Arity analysis]
findRhsArity dflags bndr rhs old_arity
= go (rhsEtaExpandArity dflags init_cheap_app rhs)
-- We always call exprEtaExpandArity once, but usually
-- that produces a result equal to old_arity, and then
-- we stop right away (since arities should not decrease)
-- Result: the common case is that there is just one iteration
where
init_cheap_app :: CheapAppFun
init_cheap_app fn n_val_args
| fn == bndr = True -- On the first pass, this binder gets infinite arity
| otherwise = isCheapApp fn n_val_args
go :: Arity -> Arity
go cur_arity
| cur_arity <= old_arity = cur_arity
| new_arity == cur_arity = cur_arity
| otherwise = ASSERT( new_arity < cur_arity )
#ifdef DEBUG
pprTrace "Exciting arity"
(vcat [ ppr bndr <+> ppr cur_arity <+> ppr new_arity
, ppr rhs])
#endif
go new_arity
where
new_arity = rhsEtaExpandArity dflags cheap_app rhs
cheap_app :: CheapAppFun
cheap_app fn n_val_args
| fn == bndr = n_val_args < cur_arity
| otherwise = isCheapApp fn n_val_args
-- ^ The Arity returned is the number of value args the
-- expression can be applied to without doing much work
rhsEtaExpandArity :: DynFlags -> CheapAppFun -> CoreExpr -> Arity
-- exprEtaExpandArity is used when eta expanding
-- e ==> \xy -> e x y
rhsEtaExpandArity dflags cheap_app e
= case (arityType env e) of
ATop (os:oss)
| isOneShotInfo os || has_lam e -> 1 + length oss
-- Don't expand PAPs/thunks
-- Note [Eta expanding thunks]
| otherwise -> 0
ATop [] -> 0
ABot n -> n
where
env = AE { ae_cheap_fn = mk_cheap_fn dflags cheap_app
, ae_ped_bot = gopt Opt_PedanticBottoms dflags }
has_lam (Tick _ e) = has_lam e
has_lam (Lam b e) = isId b || has_lam e
has_lam _ = False
{-
Note [Arity analysis]
~~~~~~~~~~~~~~~~~~~~~
The motivating example for arity analysis is this:
f = \x. let g = f (x+1)
in \y. ...g...
What arity does f have? Really it should have arity 2, but a naive
look at the RHS won't see that. You need a fixpoint analysis which
says it has arity "infinity" the first time round.
This example happens a lot; it first showed up in Andy Gill's thesis,
fifteen years ago! It also shows up in the code for 'rnf' on lists
in Trac #4138.
The analysis is easy to achieve because exprEtaExpandArity takes an
argument
type CheapFun = CoreExpr -> Maybe Type -> Bool
used to decide if an expression is cheap enough to push inside a
lambda. And exprIsCheap' in turn takes an argument
type CheapAppFun = Id -> Int -> Bool
which tells when an application is cheap. This makes it easy to
write the analysis loop.
The analysis is cheap-and-cheerful because it doesn't deal with
mutual recursion. But the self-recursive case is the important one.
Note [Eta expanding through dictionaries]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If the experimental -fdicts-cheap flag is on, we eta-expand through
dictionary bindings. This improves arities. Thereby, it also
means that full laziness is less prone to floating out the
application of a function to its dictionary arguments, which
can thereby lose opportunities for fusion. Example:
foo :: Ord a => a -> ...
foo = /\a \(d:Ord a). let d' = ...d... in \(x:a). ....
-- So foo has arity 1
f = \x. foo dInt $ bar x
The (foo DInt) is floated out, and makes ineffective a RULE
foo (bar x) = ...
One could go further and make exprIsCheap reply True to any
dictionary-typed expression, but that's more work.
See Note [Dictionary-like types] in TcType.hs for why we use
isDictLikeTy here rather than isDictTy
Note [Eta expanding thunks]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
We don't eta-expand
* Trivial RHSs x = y
* PAPs x = map g
* Thunks f = case y of p -> \x -> blah
When we see
f = case y of p -> \x -> blah
should we eta-expand it? Well, if 'x' is a one-shot state token
then 'yes' because 'f' will only be applied once. But otherwise
we (conservatively) say no. My main reason is to avoid expanding
PAPSs
f = g d ==> f = \x. g d x
because that might in turn make g inline (if it has an inline pragma),
which we might not want. After all, INLINE pragmas say "inline only
when saturated" so we don't want to be too gung-ho about saturating!
-}
arityLam :: Id -> ArityType -> ArityType
arityLam id (ATop as) = ATop (idOneShotInfo id : as)
arityLam _ (ABot n) = ABot (n+1)
floatIn :: Bool -> ArityType -> ArityType
-- We have something like (let x = E in b),
-- where b has the given arity type.
floatIn _ (ABot n) = ABot n
floatIn True (ATop as) = ATop as
floatIn False (ATop as) = ATop (takeWhile isOneShotInfo as)
-- If E is not cheap, keep arity only for one-shots
arityApp :: ArityType -> Bool -> ArityType
-- Processing (fun arg) where at is the ArityType of fun,
-- Knock off an argument and behave like 'let'
arityApp (ABot 0) _ = ABot 0
arityApp (ABot n) _ = ABot (n-1)
arityApp (ATop []) _ = ATop []
arityApp (ATop (_:as)) cheap = floatIn cheap (ATop as)
andArityType :: ArityType -> ArityType -> ArityType -- Used for branches of a 'case'
andArityType (ABot n1) (ABot n2)
= ABot (n1 `min` n2)
andArityType (ATop as) (ABot _) = ATop as
andArityType (ABot _) (ATop bs) = ATop bs
andArityType (ATop as) (ATop bs) = ATop (as `combine` bs)
where -- See Note [Combining case branches]
combine (a:as) (b:bs) = (a `bestOneShot` b) : combine as bs
combine [] bs = takeWhile isOneShotInfo bs
combine as [] = takeWhile isOneShotInfo as
{-
Note [Combining case branches]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
go = \x. let z = go e0
go2 = \x. case x of
True -> z
False -> \s(one-shot). e1
in go2 x
We *really* want to eta-expand go and go2.
When combining the barnches of the case we have
ATop [] `andAT` ATop [OneShotLam]
and we want to get ATop [OneShotLam]. But if the inner
lambda wasn't one-shot we don't want to do this.
(We need a proper arity analysis to justify that.)
So we combine the best of the two branches, on the (slightly dodgy)
basis that if we know one branch is one-shot, then they all must be.
-}
---------------------------
type CheapFun = CoreExpr -> Maybe Type -> Bool
-- How to decide if an expression is cheap
-- If the Maybe is Just, the type is the type
-- of the expression; Nothing means "don't know"
data ArityEnv
= AE { ae_cheap_fn :: CheapFun
, ae_ped_bot :: Bool -- True <=> be pedantic about bottoms
}
arityType :: ArityEnv -> CoreExpr -> ArityType
arityType env (Cast e co)
= case arityType env e of
ATop os -> ATop (take co_arity os)
ABot n -> ABot (n `min` co_arity)
where
co_arity = length (typeArity (pSnd (coercionKind co)))
-- See Note [exprArity invariant] (2); must be true of
-- arityType too, since that is how we compute the arity
-- of variables, and they in turn affect result of exprArity
-- Trac #5441 is a nice demo
-- However, do make sure that ATop -> ATop and ABot -> ABot!
-- Casts don't affect that part. Getting this wrong provoked #5475
arityType _ (Var v)
| strict_sig <- idStrictness v
, not $ isTopSig strict_sig
, (ds, res) <- splitStrictSig strict_sig
, let arity = length ds
= if isBotRes res then ABot arity
else ATop (take arity one_shots)
| otherwise
= ATop (take (idArity v) one_shots)
where
one_shots :: [OneShotInfo] -- One-shot-ness derived from the type
one_shots = typeArity (idType v)
-- Lambdas; increase arity
arityType env (Lam x e)
| isId x = arityLam x (arityType env e)
| otherwise = arityType env e
-- Applications; decrease arity, except for types
arityType env (App fun (Type _))
= arityType env fun
arityType env (App fun arg )
= arityApp (arityType env fun) (ae_cheap_fn env arg Nothing)
-- Case/Let; keep arity if either the expression is cheap
-- or it's a 1-shot lambda
-- The former is not really right for Haskell
-- f x = case x of { (a,b) -> \y. e }
-- ===>
-- f x y = case x of { (a,b) -> e }
-- The difference is observable using 'seq'
--
arityType env (Case scrut _ _ alts)
| exprIsBottom scrut || null alts
= ABot 0 -- Do not eta expand
-- See Note [Dealing with bottom (1)]
| otherwise
= case alts_type of
ABot n | n>0 -> ATop [] -- Don't eta expand
| otherwise -> ABot 0 -- if RHS is bottomming
-- See Note [Dealing with bottom (2)]
ATop as | not (ae_ped_bot env) -- See Note [Dealing with bottom (3)]
, ae_cheap_fn env scrut Nothing -> ATop as
| exprOkForSpeculation scrut -> ATop as
| otherwise -> ATop (takeWhile isOneShotInfo as)
where
alts_type = foldr1 andArityType [arityType env rhs | (_,_,rhs) <- alts]
arityType env (Let b e)
= floatIn (cheap_bind b) (arityType env e)
where
cheap_bind (NonRec b e) = is_cheap (b,e)
cheap_bind (Rec prs) = all is_cheap prs
is_cheap (b,e) = ae_cheap_fn env e (Just (idType b))
arityType env (Tick t e)
| not (tickishIsCode t) = arityType env e
arityType _ _ = vanillaArityType
{-
%************************************************************************
%* *
The main eta-expander
%* *
%************************************************************************
We go for:
f = \x1..xn -> N ==> f = \x1..xn y1..ym -> N y1..ym
(n >= 0)
where (in both cases)
* The xi can include type variables
* The yi are all value variables
* N is a NORMAL FORM (i.e. no redexes anywhere)
wanting a suitable number of extra args.
The biggest reason for doing this is for cases like
f = \x -> case x of
True -> \y -> e1
False -> \y -> e2
Here we want to get the lambdas together. A good example is the nofib
program fibheaps, which gets 25% more allocation if you don't do this
eta-expansion.
We may have to sandwich some coerces between the lambdas
to make the types work. exprEtaExpandArity looks through coerces
when computing arity; and etaExpand adds the coerces as necessary when
actually computing the expansion.
Note [No crap in eta-expanded code]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The eta expander is careful not to introduce "crap". In particular,
given a CoreExpr satisfying the 'CpeRhs' invariant (in CorePrep), it
returns a CoreExpr satisfying the same invariant. See Note [Eta
expansion and the CorePrep invariants] in CorePrep.
This means the eta-expander has to do a bit of on-the-fly
simplification but it's not too hard. The alernative, of relying on
a subsequent clean-up phase of the Simplifier to de-crapify the result,
means you can't really use it in CorePrep, which is painful.
Note [Eta expansion and SCCs]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Note that SCCs are not treated specially by etaExpand. If we have
etaExpand 2 (\x -> scc "foo" e)
= (\xy -> (scc "foo" e) y)
So the costs of evaluating 'e' (not 'e y') are attributed to "foo"
Note [Eta expansion and source notes]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CorePrep puts floatable ticks outside of value applications, but not
type applications. As a result we might be trying to eta-expand an
expression like
(src<...> v) @a
which we want to lead to code like
\x -> src<...> v @a x
This means that we need to look through type applications and be ready
to re-add floats on the top.
-}
-- | @etaExpand n us e ty@ returns an expression with
-- the same meaning as @e@, but with arity @n@.
--
-- Given:
--
-- > e' = etaExpand n us e ty
--
-- We should have that:
--
-- > ty = exprType e = exprType e'
etaExpand :: Arity -- ^ Result should have this number of value args
-> CoreExpr -- ^ Expression to expand
-> CoreExpr
-- etaExpand deals with for-alls. For example:
-- etaExpand 1 E
-- where E :: forall a. a -> a
-- would return
-- (/\b. \y::a -> E b y)
--
-- It deals with coerces too, though they are now rare
-- so perhaps the extra code isn't worth it
etaExpand n orig_expr
= go n orig_expr
where
-- Strip off existing lambdas and casts
-- Note [Eta expansion and SCCs]
go 0 expr = expr
go n (Lam v body) | isTyVar v = Lam v (go n body)
| otherwise = Lam v (go (n-1) body)
go n (Cast expr co) = Cast (go n expr) co
go n expr
= -- pprTrace "ee" (vcat [ppr orig_expr, ppr expr, ppr etas]) $
retick $ etaInfoAbs etas (etaInfoApp subst' sexpr etas)
where
in_scope = mkInScopeSet (exprFreeVars expr)
(in_scope', etas) = mkEtaWW n orig_expr in_scope (exprType expr)
subst' = mkEmptySubst in_scope'
-- Find ticks behind type apps.
-- See Note [Eta expansion and source notes]
(expr', args) = collectArgs expr
(ticks, expr'') = stripTicksTop tickishFloatable expr'
sexpr = foldl App expr'' args
retick expr = foldr mkTick expr ticks
-- Wrapper Unwrapper
--------------
data EtaInfo = EtaVar Var -- /\a. [], [] a
-- \x. [], [] x
| EtaCo Coercion -- [] |> co, [] |> (sym co)
instance Outputable EtaInfo where
ppr (EtaVar v) = text "EtaVar" <+> ppr v
ppr (EtaCo co) = text "EtaCo" <+> ppr co
pushCoercion :: Coercion -> [EtaInfo] -> [EtaInfo]
pushCoercion co1 (EtaCo co2 : eis)
| isReflCo co = eis
| otherwise = EtaCo co : eis
where
co = co1 `mkTransCo` co2
pushCoercion co eis = EtaCo co : eis
--------------
etaInfoAbs :: [EtaInfo] -> CoreExpr -> CoreExpr
etaInfoAbs [] expr = expr
etaInfoAbs (EtaVar v : eis) expr = Lam v (etaInfoAbs eis expr)
etaInfoAbs (EtaCo co : eis) expr = Cast (etaInfoAbs eis expr) (mkSymCo co)
--------------
etaInfoApp :: Subst -> CoreExpr -> [EtaInfo] -> CoreExpr
-- (etaInfoApp s e eis) returns something equivalent to
-- ((substExpr s e) `appliedto` eis)
etaInfoApp subst (Lam v1 e) (EtaVar v2 : eis)
= etaInfoApp (CoreSubst.extendSubstWithVar subst v1 v2) e eis
etaInfoApp subst (Cast e co1) eis
= etaInfoApp subst e (pushCoercion co' eis)
where
co' = CoreSubst.substCo subst co1
etaInfoApp subst (Case e b ty alts) eis
= Case (subst_expr subst e) b1 (mk_alts_ty (CoreSubst.substTy subst ty) eis) alts'
where
(subst1, b1) = substBndr subst b
alts' = map subst_alt alts
subst_alt (con, bs, rhs) = (con, bs', etaInfoApp subst2 rhs eis)
where
(subst2,bs') = substBndrs subst1 bs
mk_alts_ty ty [] = ty
mk_alts_ty ty (EtaVar v : eis) = mk_alts_ty (applyTypeToArg ty (varToCoreExpr v)) eis
mk_alts_ty _ (EtaCo co : eis) = mk_alts_ty (pSnd (coercionKind co)) eis
etaInfoApp subst (Let b e) eis
= Let b' (etaInfoApp subst' e eis)
where
(subst', b') = subst_bind subst b
etaInfoApp subst (Tick t e) eis
= Tick (substTickish subst t) (etaInfoApp subst e eis)
etaInfoApp subst e eis
= go (subst_expr subst e) eis
where
go e [] = e
go e (EtaVar v : eis) = go (App e (varToCoreExpr v)) eis
go e (EtaCo co : eis) = go (Cast e co) eis
--------------
mkEtaWW :: Arity -> CoreExpr -> InScopeSet -> Type
-> (InScopeSet, [EtaInfo])
-- EtaInfo contains fresh variables,
-- not free in the incoming CoreExpr
-- Outgoing InScopeSet includes the EtaInfo vars
-- and the original free vars
mkEtaWW orig_n orig_expr in_scope orig_ty
= go orig_n empty_subst orig_ty []
where
empty_subst = mkEmptyTCvSubst in_scope
go n subst ty eis -- See Note [exprArity invariant]
| n == 0
= (getTCvInScope subst, reverse eis)
| Just (bndr,ty') <- splitPiTy_maybe ty
= let ((subst', eta_id'), new_n) = caseBinder bndr
(\tv -> (Type.substTyVarBndr subst tv, n))
(\arg_ty -> (freshEtaVar n subst arg_ty, n-1))
in
-- Avoid free vars of the original expression
go new_n subst' ty' (EtaVar eta_id' : eis)
| Just (co, ty') <- topNormaliseNewType_maybe ty
= -- Given this:
-- newtype T = MkT ([T] -> Int)
-- Consider eta-expanding this
-- eta_expand 1 e T
-- We want to get
-- coerce T (\x::[T] -> (coerce ([T]->Int) e) x)
go n subst ty' (EtaCo co : eis)
| otherwise -- We have an expression of arity > 0,
-- but its type isn't a function.
= WARN( True, (ppr orig_n <+> ppr orig_ty) $$ ppr orig_expr )
(getTCvInScope subst, reverse eis)
-- This *can* legitmately happen:
-- e.g. coerce Int (\x. x) Essentially the programmer is
-- playing fast and loose with types (Happy does this a lot).
-- So we simply decline to eta-expand. Otherwise we'd end up
-- with an explicit lambda having a non-function type
--------------
-- Avoiding unnecessary substitution; use short-cutting versions
subst_expr :: Subst -> CoreExpr -> CoreExpr
subst_expr = substExprSC (text "CoreArity:substExpr")
subst_bind :: Subst -> CoreBind -> (Subst, CoreBind)
subst_bind = substBindSC
--------------
freshEtaVar :: Int -> TCvSubst -> Type -> (TCvSubst, Var)
-- Make a fresh Id, with specified type (after applying substitution)
-- It should be "fresh" in the sense that it's not in the in-scope set
-- of the TvSubstEnv; and it should itself then be added to the in-scope
-- set of the TvSubstEnv
--
-- The Int is just a reasonable starting point for generating a unique;
-- it does not necessarily have to be unique itself.
freshEtaVar n subst ty
= (subst', eta_id')
where
ty' = Type.substTy subst ty
eta_id' = uniqAway (getTCvInScope subst) $
mkSysLocalOrCoVar (fsLit "eta") (mkBuiltinUnique n) ty'
subst' = extendTCvInScope subst eta_id'
| tjakway/ghcjvm | compiler/coreSyn/CoreArity.hs | bsd-3-clause | 36,402 | 0 | 17 | 10,086 | 4,457 | 2,292 | 2,165 | 271 | 7 |
import Data.List
type Edge = (String, STree)
data STree = Node [Edge]
| Leaf
deriving (Show)
type EdgeFunction = [String] -> (Int, [String])
construct :: String -> STree
construct = suf . suffixes
where suf [[]] = Leaf
suf ss = Node [([a], suf n)
| a <- ['\0'..'\255'],
n@(sa:_) <- [ss `clusterBy` a]]
clusterBy ss a = [cs | c:cs <- ss, c == a]
construct2 :: EdgeFunction -> [Char] -> String -> STree
construct2 edge alphabet = suf . suffixes
where suf [[]] = Leaf
suf ss = Node [(take (cpl+1) (a:sa), suf ssr)
| a <- alphabet,
n@(sa:_) <- [ss `clusterBy` a],
(cpl,ssr) <- [edge n]]
clusterBy ss a = [cs | c:cs <- ss, c == a]
simple :: EdgeFunction
simple n = (0, n)
cst :: EdgeFunction
cst [s] = (length s, [[]])
cst awss@((a:w):ss)
| null [c | c:_ <- ss, a /= c] = (cpl + 1, rss)
| otherwise = (0, awss)
where (cpl, rss) = cst (w:[u | _:u <- ss])
{-- snippet suffixes --}
suffixes :: [a] -> [[a]]
suffixes xs@(_:xs') = xs : suffixes xs'
suffixes _ = []
{-- /snippet suffixes --}
{-- snippet noAsPattern --}
noAsPattern :: [a] -> [[a]]
noAsPattern (x:xs) = (x:xs) : noAsPattern xs
noAsPattern _ = []
{-- /snippet noAsPattern --}
{-- snippet suffixes2 --}
suffixes2 xs = init (tails xs)
{-- /snippet suffixes2 --}
{-- snippet compose --}
compose :: (b -> c) -> (a -> b) -> a -> c
compose f g x = f (g x)
{-- /snippet compose --}
{-- snippet suffixes3 --}
suffixes3 xs = compose init tails xs
{-- /snippet suffixes3 --}
{-- snippet suffixes4 --}
suffixes4 = compose init tails
{-- /snippet suffixes4 --}
{-- snippet suffixes5 --}
suffixes5 = init . tails
{-- /snippet suffixes5 --}
| binesiyu/ifl | examples/ch04/SuffixTree.hs | mit | 1,827 | 0 | 13 | 548 | 768 | 423 | 345 | 41 | 2 |
module Settings.Builders.GhcPkg (ghcPkgBuilderArgs) where
import Settings.Builders.Common
ghcPkgBuilderArgs :: Args
ghcPkgBuilderArgs = mconcat
[ builder (GhcPkg Init) ? mconcat [ arg "init", arg =<< getOutput ]
, builder (GhcPkg Update) ? do
verbosity <- expr getVerbosity
context <- getContext
config <- expr $ pkgInplaceConfig context
mconcat [ arg "update"
, arg "--force"
, verbosity < Chatty ? arg "-v0"
, bootPackageDatabaseArgs
, arg config ] ]
| izgzhen/hadrian | src/Settings/Builders/GhcPkg.hs | mit | 565 | 0 | 13 | 177 | 151 | 76 | 75 | 14 | 1 |
module SampleSpec where
import Test.Hspec
import Sample
spec :: Spec
spec = do
describe "helloWorld" $ do
it "hello world string" $
helloWorld `shouldBe` "hello world"
| joker1007/haskell-unittest-sample | test/SampleSpec.hs | mit | 188 | 0 | 12 | 46 | 48 | 26 | 22 | 8 | 1 |
-----------------------------------------------------------------------------
--
-- Object-file symbols (called CLabel for histerical raisins).
--
-- (c) The University of Glasgow 2004-2006
--
-----------------------------------------------------------------------------
{-# LANGUAGE CPP #-}
module CLabel (
CLabel, -- abstract type
ForeignLabelSource(..),
pprDebugCLabel,
mkClosureLabel,
mkTopSRTLabel,
mkInfoTableLabel,
mkEntryLabel,
mkRednCountsLabel,
mkConInfoTableLabel,
mkLargeSRTLabel,
mkApEntryLabel,
mkApInfoTableLabel,
mkClosureTableLabel,
mkBytesLabel,
mkLocalBlockLabel,
mkLocalClosureLabel,
mkLocalInfoTableLabel,
mkLocalClosureTableLabel,
mkBlockInfoTableLabel,
mkBitmapLabel,
mkStringLitLabel,
mkAsmTempLabel,
mkAsmTempDerivedLabel,
mkAsmTempEndLabel,
mkAsmTempDieLabel,
mkSplitMarkerLabel,
mkDirty_MUT_VAR_Label,
mkUpdInfoLabel,
mkBHUpdInfoLabel,
mkIndStaticInfoLabel,
mkMainCapabilityLabel,
mkMAP_FROZEN_infoLabel,
mkMAP_FROZEN0_infoLabel,
mkMAP_DIRTY_infoLabel,
mkSMAP_FROZEN_infoLabel,
mkSMAP_FROZEN0_infoLabel,
mkSMAP_DIRTY_infoLabel,
mkBadAlignmentLabel,
mkArrWords_infoLabel,
mkTopTickyCtrLabel,
mkCAFBlackHoleInfoTableLabel,
mkRtsPrimOpLabel,
mkRtsSlowFastTickyCtrLabel,
mkSelectorInfoLabel,
mkSelectorEntryLabel,
mkCmmInfoLabel,
mkCmmEntryLabel,
mkCmmRetInfoLabel,
mkCmmRetLabel,
mkCmmCodeLabel,
mkCmmDataLabel,
mkCmmClosureLabel,
mkRtsApFastLabel,
mkPrimCallLabel,
mkForeignLabel,
addLabelSize,
foreignLabelStdcallInfo,
isBytesLabel,
isForeignLabel,
isSomeRODataLabel,
isStaticClosureLabel,
mkCCLabel, mkCCSLabel,
DynamicLinkerLabelInfo(..),
mkDynamicLinkerLabel,
dynamicLinkerLabelInfo,
mkPicBaseLabel,
mkDeadStripPreventer,
mkHpcTicksLabel,
hasCAF,
needsCDecl, maybeLocalBlockLabel, externallyVisibleCLabel,
isMathFun,
isCFunctionLabel, isGcPtrLabel, labelDynamic,
-- * Conversions
toClosureLbl, toSlowEntryLbl, toEntryLbl, toInfoLbl, hasHaskellName,
pprCLabel
) where
#include "HsVersions.h"
import GhcPrelude
import IdInfo
import BasicTypes
import {-# SOURCE #-} BlockId (BlockId, mkBlockId)
import Packages
import Module
import Name
import Unique
import PrimOp
import Config
import CostCentre
import Outputable
import FastString
import DynFlags
import Platform
import UniqSet
import Util
import PprCore ( {- instances -} )
-- -----------------------------------------------------------------------------
-- The CLabel type
{- |
'CLabel' is an abstract type that supports the following operations:
- Pretty printing
- In a C file, does it need to be declared before use? (i.e. is it
guaranteed to be already in scope in the places we need to refer to it?)
- If it needs to be declared, what type (code or data) should it be
declared to have?
- Is it visible outside this object file or not?
- Is it "dynamic" (see details below)
- Eq and Ord, so that we can make sets of CLabels (currently only
used in outputting C as far as I can tell, to avoid generating
more than one declaration for any given label).
- Converting an info table label into an entry label.
CLabel usage is a bit messy in GHC as they are used in a number of different
contexts:
- By the C-- AST to identify labels
- By the unregisterised C code generator ("PprC") for naming functions (hence
the name 'CLabel')
- By the native and LLVM code generators to identify labels
For extra fun, each of these uses a slightly different subset of constructors
(e.g. 'AsmTempLabel' and 'AsmTempDerivedLabel' are used only in the NCG and
LLVM backends).
In general, we use 'IdLabel' to represent Haskell things early in the
pipeline. However, later optimization passes will often represent blocks they
create with 'LocalBlockLabel' where there is no obvious 'Name' to hang off the
label.
-}
data CLabel
= -- | A label related to the definition of a particular Id or Con in a .hs file.
IdLabel
Name
CafInfo
IdLabelInfo -- encodes the suffix of the label
-- | A label from a .cmm file that is not associated with a .hs level Id.
| CmmLabel
UnitId -- what package the label belongs to.
FastString -- identifier giving the prefix of the label
CmmLabelInfo -- encodes the suffix of the label
-- | A label with a baked-in \/ algorithmically generated name that definitely
-- comes from the RTS. The code for it must compile into libHSrts.a \/ libHSrts.so
-- If it doesn't have an algorithmically generated name then use a CmmLabel
-- instead and give it an appropriate UnitId argument.
| RtsLabel
RtsLabelInfo
-- | A label associated with a block. These aren't visible outside of the
-- compilation unit in which they are defined. These are generally used to
-- name blocks produced by Cmm-to-Cmm passes and the native code generator,
-- where we don't have a 'Name' to associate the label to and therefore can't
-- use 'IdLabel'.
| LocalBlockLabel
{-# UNPACK #-} !Unique
-- | A 'C' (or otherwise foreign) label.
--
| ForeignLabel
FastString -- name of the imported label.
(Maybe Int) -- possible '@n' suffix for stdcall functions
-- When generating C, the '@n' suffix is omitted, but when
-- generating assembler we must add it to the label.
ForeignLabelSource -- what package the foreign label is in.
FunctionOrData
-- | Local temporary label used for native (or LLVM) code generation; must not
-- appear outside of these contexts. Use primarily for debug information
| AsmTempLabel
{-# UNPACK #-} !Unique
-- | A label \"derived\" from another 'CLabel' by the addition of a suffix.
-- Must not occur outside of the NCG or LLVM code generators.
| AsmTempDerivedLabel
CLabel
FastString -- suffix
| StringLitLabel
{-# UNPACK #-} !Unique
| CC_Label CostCentre
| CCS_Label CostCentreStack
-- | These labels are generated and used inside the NCG only.
-- They are special variants of a label used for dynamic linking
-- see module PositionIndependentCode for details.
| DynamicLinkerLabel DynamicLinkerLabelInfo CLabel
-- | This label is generated and used inside the NCG only.
-- It is used as a base for PIC calculations on some platforms.
-- It takes the form of a local numeric assembler label '1'; and
-- is pretty-printed as 1b, referring to the previous definition
-- of 1: in the assembler source file.
| PicBaseLabel
-- | A label before an info table to prevent excessive dead-stripping on darwin
| DeadStripPreventer CLabel
-- | Per-module table of tick locations
| HpcTicksLabel Module
-- | Static reference table
| SRTLabel !Unique
-- | Label of an StgLargeSRT
| LargeSRTLabel
{-# UNPACK #-} !Unique
-- | A bitmap (function or case return)
| LargeBitmapLabel
{-# UNPACK #-} !Unique
deriving Eq
-- This is laborious, but necessary. We can't derive Ord because
-- Unique doesn't have an Ord instance. Note nonDetCmpUnique in the
-- implementation. See Note [No Ord for Unique]
-- This is non-deterministic but we do not currently support deterministic
-- code-generation. See Note [Unique Determinism and code generation]
instance Ord CLabel where
compare (IdLabel a1 b1 c1) (IdLabel a2 b2 c2) =
compare a1 a2 `thenCmp`
compare b1 b2 `thenCmp`
compare c1 c2
compare (CmmLabel a1 b1 c1) (CmmLabel a2 b2 c2) =
compare a1 a2 `thenCmp`
compare b1 b2 `thenCmp`
compare c1 c2
compare (RtsLabel a1) (RtsLabel a2) = compare a1 a2
compare (LocalBlockLabel u1) (LocalBlockLabel u2) = nonDetCmpUnique u1 u2
compare (ForeignLabel a1 b1 c1 d1) (ForeignLabel a2 b2 c2 d2) =
compare a1 a2 `thenCmp`
compare b1 b2 `thenCmp`
compare c1 c2 `thenCmp`
compare d1 d2
compare (AsmTempLabel u1) (AsmTempLabel u2) = nonDetCmpUnique u1 u2
compare (AsmTempDerivedLabel a1 b1) (AsmTempDerivedLabel a2 b2) =
compare a1 a2 `thenCmp`
compare b1 b2
compare (StringLitLabel u1) (StringLitLabel u2) =
nonDetCmpUnique u1 u2
compare (CC_Label a1) (CC_Label a2) =
compare a1 a2
compare (CCS_Label a1) (CCS_Label a2) =
compare a1 a2
compare (DynamicLinkerLabel a1 b1) (DynamicLinkerLabel a2 b2) =
compare a1 a2 `thenCmp`
compare b1 b2
compare PicBaseLabel PicBaseLabel = EQ
compare (DeadStripPreventer a1) (DeadStripPreventer a2) =
compare a1 a2
compare (HpcTicksLabel a1) (HpcTicksLabel a2) =
compare a1 a2
compare (SRTLabel u1) (SRTLabel u2) =
nonDetCmpUnique u1 u2
compare (LargeSRTLabel u1) (LargeSRTLabel u2) =
nonDetCmpUnique u1 u2
compare (LargeBitmapLabel u1) (LargeBitmapLabel u2) =
nonDetCmpUnique u1 u2
compare IdLabel{} _ = LT
compare _ IdLabel{} = GT
compare CmmLabel{} _ = LT
compare _ CmmLabel{} = GT
compare RtsLabel{} _ = LT
compare _ RtsLabel{} = GT
compare LocalBlockLabel{} _ = LT
compare _ LocalBlockLabel{} = GT
compare ForeignLabel{} _ = LT
compare _ ForeignLabel{} = GT
compare AsmTempLabel{} _ = LT
compare _ AsmTempLabel{} = GT
compare AsmTempDerivedLabel{} _ = LT
compare _ AsmTempDerivedLabel{} = GT
compare StringLitLabel{} _ = LT
compare _ StringLitLabel{} = GT
compare CC_Label{} _ = LT
compare _ CC_Label{} = GT
compare CCS_Label{} _ = LT
compare _ CCS_Label{} = GT
compare DynamicLinkerLabel{} _ = LT
compare _ DynamicLinkerLabel{} = GT
compare PicBaseLabel{} _ = LT
compare _ PicBaseLabel{} = GT
compare DeadStripPreventer{} _ = LT
compare _ DeadStripPreventer{} = GT
compare HpcTicksLabel{} _ = LT
compare _ HpcTicksLabel{} = GT
compare SRTLabel{} _ = LT
compare _ SRTLabel{} = GT
compare LargeSRTLabel{} _ = LT
compare _ LargeSRTLabel{} = GT
-- | Record where a foreign label is stored.
data ForeignLabelSource
-- | Label is in a named package
= ForeignLabelInPackage UnitId
-- | Label is in some external, system package that doesn't also
-- contain compiled Haskell code, and is not associated with any .hi files.
-- We don't have to worry about Haskell code being inlined from
-- external packages. It is safe to treat the RTS package as "external".
| ForeignLabelInExternalPackage
-- | Label is in the package currenly being compiled.
-- This is only used for creating hacky tmp labels during code generation.
-- Don't use it in any code that might be inlined across a package boundary
-- (ie, core code) else the information will be wrong relative to the
-- destination module.
| ForeignLabelInThisPackage
deriving (Eq, Ord)
-- | For debugging problems with the CLabel representation.
-- We can't make a Show instance for CLabel because lots of its components don't have instances.
-- The regular Outputable instance only shows the label name, and not its other info.
--
pprDebugCLabel :: CLabel -> SDoc
pprDebugCLabel lbl
= case lbl of
IdLabel _ _ info-> ppr lbl <> (parens $ text "IdLabel"
<> whenPprDebug (text ":" <> text (show info)))
CmmLabel pkg _name _info
-> ppr lbl <> (parens $ text "CmmLabel" <+> ppr pkg)
RtsLabel{} -> ppr lbl <> (parens $ text "RtsLabel")
ForeignLabel _name mSuffix src funOrData
-> ppr lbl <> (parens $ text "ForeignLabel"
<+> ppr mSuffix
<+> ppr src
<+> ppr funOrData)
_ -> ppr lbl <> (parens $ text "other CLabel")
data IdLabelInfo
= Closure -- ^ Label for closure
| SRT -- ^ Static reference table (TODO: could be removed
-- with the old code generator, but might be needed
-- when we implement the New SRT Plan)
| InfoTable -- ^ Info tables for closures; always read-only
| Entry -- ^ Entry point
| Slow -- ^ Slow entry point
| LocalInfoTable -- ^ Like InfoTable but not externally visible
| LocalEntry -- ^ Like Entry but not externally visible
| RednCounts -- ^ Label of place to keep Ticky-ticky info for this Id
| ConEntry -- ^ Constructor entry point
| ConInfoTable -- ^ Corresponding info table
| ClosureTable -- ^ Table of closures for Enum tycons
| Bytes -- ^ Content of a string literal. See
-- Note [Bytes label].
| BlockInfoTable -- ^ Like LocalInfoTable but for a proc-point block
-- instead of a closure entry-point.
-- See Note [Proc-point local block entry-point].
deriving (Eq, Ord, Show)
data RtsLabelInfo
= RtsSelectorInfoTable Bool{-updatable-} Int{-offset-} -- ^ Selector thunks
| RtsSelectorEntry Bool{-updatable-} Int{-offset-}
| RtsApInfoTable Bool{-updatable-} Int{-arity-} -- ^ AP thunks
| RtsApEntry Bool{-updatable-} Int{-arity-}
| RtsPrimOp PrimOp
| RtsApFast FastString -- ^ _fast versions of generic apply
| RtsSlowFastTickyCtr String
deriving (Eq, Ord)
-- NOTE: Eq on LitString compares the pointer only, so this isn't
-- a real equality.
-- | What type of Cmm label we're dealing with.
-- Determines the suffix appended to the name when a CLabel.CmmLabel
-- is pretty printed.
data CmmLabelInfo
= CmmInfo -- ^ misc rts info tables, suffix _info
| CmmEntry -- ^ misc rts entry points, suffix _entry
| CmmRetInfo -- ^ misc rts ret info tables, suffix _info
| CmmRet -- ^ misc rts return points, suffix _ret
| CmmData -- ^ misc rts data bits, eg CHARLIKE_closure
| CmmCode -- ^ misc rts code
| CmmClosure -- ^ closures eg CHARLIKE_closure
| CmmPrimCall -- ^ a prim call to some hand written Cmm code
deriving (Eq, Ord)
data DynamicLinkerLabelInfo
= CodeStub -- MachO: Lfoo$stub, ELF: foo@plt
| SymbolPtr -- MachO: Lfoo$non_lazy_ptr, Windows: __imp_foo
| GotSymbolPtr -- ELF: foo@got
| GotSymbolOffset -- ELF: foo@gotoff
deriving (Eq, Ord)
-- -----------------------------------------------------------------------------
-- Constructing CLabels
-- -----------------------------------------------------------------------------
-- Constructing IdLabels
-- These are always local:
mkTopSRTLabel :: Unique -> CLabel
mkTopSRTLabel u = SRTLabel u
mkRednCountsLabel :: Name -> CLabel
mkRednCountsLabel name =
IdLabel name NoCafRefs RednCounts -- Note [ticky for LNE]
-- These have local & (possibly) external variants:
mkLocalClosureLabel :: Name -> CafInfo -> CLabel
mkLocalInfoTableLabel :: Name -> CafInfo -> CLabel
mkLocalClosureTableLabel :: Name -> CafInfo -> CLabel
mkLocalClosureLabel name c = IdLabel name c Closure
mkLocalInfoTableLabel name c = IdLabel name c LocalInfoTable
mkLocalClosureTableLabel name c = IdLabel name c ClosureTable
mkClosureLabel :: Name -> CafInfo -> CLabel
mkInfoTableLabel :: Name -> CafInfo -> CLabel
mkEntryLabel :: Name -> CafInfo -> CLabel
mkClosureTableLabel :: Name -> CafInfo -> CLabel
mkConInfoTableLabel :: Name -> CafInfo -> CLabel
mkBytesLabel :: Name -> CLabel
mkClosureLabel name c = IdLabel name c Closure
mkInfoTableLabel name c = IdLabel name c InfoTable
mkEntryLabel name c = IdLabel name c Entry
mkClosureTableLabel name c = IdLabel name c ClosureTable
mkConInfoTableLabel name c = IdLabel name c ConInfoTable
mkBytesLabel name = IdLabel name NoCafRefs Bytes
mkBlockInfoTableLabel :: Name -> CafInfo -> CLabel
mkBlockInfoTableLabel name c = IdLabel name c BlockInfoTable
-- See Note [Proc-point local block entry-point].
-- Constructing Cmm Labels
mkDirty_MUT_VAR_Label, mkSplitMarkerLabel, mkUpdInfoLabel,
mkBHUpdInfoLabel, mkIndStaticInfoLabel, mkMainCapabilityLabel,
mkMAP_FROZEN_infoLabel, mkMAP_FROZEN0_infoLabel, mkMAP_DIRTY_infoLabel,
mkArrWords_infoLabel,
mkTopTickyCtrLabel,
mkCAFBlackHoleInfoTableLabel,
mkSMAP_FROZEN_infoLabel, mkSMAP_FROZEN0_infoLabel,
mkSMAP_DIRTY_infoLabel, mkBadAlignmentLabel :: CLabel
mkDirty_MUT_VAR_Label = mkForeignLabel (fsLit "dirty_MUT_VAR") Nothing ForeignLabelInExternalPackage IsFunction
mkSplitMarkerLabel = CmmLabel rtsUnitId (fsLit "__stg_split_marker") CmmCode
mkUpdInfoLabel = CmmLabel rtsUnitId (fsLit "stg_upd_frame") CmmInfo
mkBHUpdInfoLabel = CmmLabel rtsUnitId (fsLit "stg_bh_upd_frame" ) CmmInfo
mkIndStaticInfoLabel = CmmLabel rtsUnitId (fsLit "stg_IND_STATIC") CmmInfo
mkMainCapabilityLabel = CmmLabel rtsUnitId (fsLit "MainCapability") CmmData
mkMAP_FROZEN_infoLabel = CmmLabel rtsUnitId (fsLit "stg_MUT_ARR_PTRS_FROZEN") CmmInfo
mkMAP_FROZEN0_infoLabel = CmmLabel rtsUnitId (fsLit "stg_MUT_ARR_PTRS_FROZEN0") CmmInfo
mkMAP_DIRTY_infoLabel = CmmLabel rtsUnitId (fsLit "stg_MUT_ARR_PTRS_DIRTY") CmmInfo
mkTopTickyCtrLabel = CmmLabel rtsUnitId (fsLit "top_ct") CmmData
mkCAFBlackHoleInfoTableLabel = CmmLabel rtsUnitId (fsLit "stg_CAF_BLACKHOLE") CmmInfo
mkArrWords_infoLabel = CmmLabel rtsUnitId (fsLit "stg_ARR_WORDS") CmmInfo
mkSMAP_FROZEN_infoLabel = CmmLabel rtsUnitId (fsLit "stg_SMALL_MUT_ARR_PTRS_FROZEN") CmmInfo
mkSMAP_FROZEN0_infoLabel = CmmLabel rtsUnitId (fsLit "stg_SMALL_MUT_ARR_PTRS_FROZEN0") CmmInfo
mkSMAP_DIRTY_infoLabel = CmmLabel rtsUnitId (fsLit "stg_SMALL_MUT_ARR_PTRS_DIRTY") CmmInfo
mkBadAlignmentLabel = CmmLabel rtsUnitId (fsLit "stg_badAlignment") CmmEntry
-----
mkCmmInfoLabel, mkCmmEntryLabel, mkCmmRetInfoLabel, mkCmmRetLabel,
mkCmmCodeLabel, mkCmmDataLabel, mkCmmClosureLabel
:: UnitId -> FastString -> CLabel
mkCmmInfoLabel pkg str = CmmLabel pkg str CmmInfo
mkCmmEntryLabel pkg str = CmmLabel pkg str CmmEntry
mkCmmRetInfoLabel pkg str = CmmLabel pkg str CmmRetInfo
mkCmmRetLabel pkg str = CmmLabel pkg str CmmRet
mkCmmCodeLabel pkg str = CmmLabel pkg str CmmCode
mkCmmDataLabel pkg str = CmmLabel pkg str CmmData
mkCmmClosureLabel pkg str = CmmLabel pkg str CmmClosure
mkLocalBlockLabel :: Unique -> CLabel
mkLocalBlockLabel u = LocalBlockLabel u
-- Constructing RtsLabels
mkRtsPrimOpLabel :: PrimOp -> CLabel
mkRtsPrimOpLabel primop = RtsLabel (RtsPrimOp primop)
mkSelectorInfoLabel :: Bool -> Int -> CLabel
mkSelectorEntryLabel :: Bool -> Int -> CLabel
mkSelectorInfoLabel upd off = RtsLabel (RtsSelectorInfoTable upd off)
mkSelectorEntryLabel upd off = RtsLabel (RtsSelectorEntry upd off)
mkApInfoTableLabel :: Bool -> Int -> CLabel
mkApEntryLabel :: Bool -> Int -> CLabel
mkApInfoTableLabel upd off = RtsLabel (RtsApInfoTable upd off)
mkApEntryLabel upd off = RtsLabel (RtsApEntry upd off)
-- A call to some primitive hand written Cmm code
mkPrimCallLabel :: PrimCall -> CLabel
mkPrimCallLabel (PrimCall str pkg)
= CmmLabel pkg str CmmPrimCall
-- Constructing ForeignLabels
-- | Make a foreign label
mkForeignLabel
:: FastString -- name
-> Maybe Int -- size prefix
-> ForeignLabelSource -- what package it's in
-> FunctionOrData
-> CLabel
mkForeignLabel str mb_sz src fod
= ForeignLabel str mb_sz src fod
-- | Update the label size field in a ForeignLabel
addLabelSize :: CLabel -> Int -> CLabel
addLabelSize (ForeignLabel str _ src fod) sz
= ForeignLabel str (Just sz) src fod
addLabelSize label _
= label
-- | Whether label is a top-level string literal
isBytesLabel :: CLabel -> Bool
isBytesLabel (IdLabel _ _ Bytes) = True
isBytesLabel _lbl = False
-- | Whether label is a non-haskell label (defined in C code)
isForeignLabel :: CLabel -> Bool
isForeignLabel (ForeignLabel _ _ _ _) = True
isForeignLabel _lbl = False
-- | Whether label is a static closure label (can come from haskell or cmm)
isStaticClosureLabel :: CLabel -> Bool
-- Closure defined in haskell (.hs)
isStaticClosureLabel (IdLabel _ _ Closure) = True
-- Closure defined in cmm
isStaticClosureLabel (CmmLabel _ _ CmmClosure) = True
isStaticClosureLabel _lbl = False
-- | Whether label is a .rodata label
isSomeRODataLabel :: CLabel -> Bool
-- info table defined in haskell (.hs)
isSomeRODataLabel (IdLabel _ _ ClosureTable) = True
isSomeRODataLabel (IdLabel _ _ ConInfoTable) = True
isSomeRODataLabel (IdLabel _ _ InfoTable) = True
isSomeRODataLabel (IdLabel _ _ LocalInfoTable) = True
isSomeRODataLabel (IdLabel _ _ BlockInfoTable) = True
-- static reference tables defined in haskell (.hs)
isSomeRODataLabel (IdLabel _ _ SRT) = True
isSomeRODataLabel (SRTLabel _) = True
-- info table defined in cmm (.cmm)
isSomeRODataLabel (CmmLabel _ _ CmmInfo) = True
isSomeRODataLabel _lbl = False
-- | Get the label size field from a ForeignLabel
foreignLabelStdcallInfo :: CLabel -> Maybe Int
foreignLabelStdcallInfo (ForeignLabel _ info _ _) = info
foreignLabelStdcallInfo _lbl = Nothing
-- Constructing Large*Labels
mkLargeSRTLabel :: Unique -> CLabel
mkBitmapLabel :: Unique -> CLabel
mkLargeSRTLabel uniq = LargeSRTLabel uniq
mkBitmapLabel uniq = LargeBitmapLabel uniq
-- Constructing Cost Center Labels
mkCCLabel :: CostCentre -> CLabel
mkCCSLabel :: CostCentreStack -> CLabel
mkCCLabel cc = CC_Label cc
mkCCSLabel ccs = CCS_Label ccs
mkRtsApFastLabel :: FastString -> CLabel
mkRtsApFastLabel str = RtsLabel (RtsApFast str)
mkRtsSlowFastTickyCtrLabel :: String -> CLabel
mkRtsSlowFastTickyCtrLabel pat = RtsLabel (RtsSlowFastTickyCtr pat)
-- Constructing Code Coverage Labels
mkHpcTicksLabel :: Module -> CLabel
mkHpcTicksLabel = HpcTicksLabel
-- Constructing labels used for dynamic linking
mkDynamicLinkerLabel :: DynamicLinkerLabelInfo -> CLabel -> CLabel
mkDynamicLinkerLabel = DynamicLinkerLabel
dynamicLinkerLabelInfo :: CLabel -> Maybe (DynamicLinkerLabelInfo, CLabel)
dynamicLinkerLabelInfo (DynamicLinkerLabel info lbl) = Just (info, lbl)
dynamicLinkerLabelInfo _ = Nothing
mkPicBaseLabel :: CLabel
mkPicBaseLabel = PicBaseLabel
-- Constructing miscellaneous other labels
mkDeadStripPreventer :: CLabel -> CLabel
mkDeadStripPreventer lbl = DeadStripPreventer lbl
mkStringLitLabel :: Unique -> CLabel
mkStringLitLabel = StringLitLabel
mkAsmTempLabel :: Uniquable a => a -> CLabel
mkAsmTempLabel a = AsmTempLabel (getUnique a)
mkAsmTempDerivedLabel :: CLabel -> FastString -> CLabel
mkAsmTempDerivedLabel = AsmTempDerivedLabel
mkAsmTempEndLabel :: CLabel -> CLabel
mkAsmTempEndLabel l = mkAsmTempDerivedLabel l (fsLit "_end")
-- | Construct a label for a DWARF Debug Information Entity (DIE)
-- describing another symbol.
mkAsmTempDieLabel :: CLabel -> CLabel
mkAsmTempDieLabel l = mkAsmTempDerivedLabel l (fsLit "_die")
-- -----------------------------------------------------------------------------
-- Convert between different kinds of label
toClosureLbl :: CLabel -> CLabel
toClosureLbl (IdLabel n _ BlockInfoTable)
= pprPanic "toClosureLbl: BlockInfoTable" (ppr n)
toClosureLbl (IdLabel n c _) = IdLabel n c Closure
toClosureLbl (CmmLabel m str _) = CmmLabel m str CmmClosure
toClosureLbl l = pprPanic "toClosureLbl" (ppr l)
toSlowEntryLbl :: CLabel -> CLabel
toSlowEntryLbl (IdLabel n _ BlockInfoTable)
= pprPanic "toSlowEntryLbl" (ppr n)
toSlowEntryLbl (IdLabel n c _) = IdLabel n c Slow
toSlowEntryLbl l = pprPanic "toSlowEntryLbl" (ppr l)
toEntryLbl :: CLabel -> CLabel
toEntryLbl (IdLabel n c LocalInfoTable) = IdLabel n c LocalEntry
toEntryLbl (IdLabel n c ConInfoTable) = IdLabel n c ConEntry
toEntryLbl (IdLabel n _ BlockInfoTable) = mkLocalBlockLabel (nameUnique n)
-- See Note [Proc-point local block entry-point].
toEntryLbl (IdLabel n c _) = IdLabel n c Entry
toEntryLbl (CmmLabel m str CmmInfo) = CmmLabel m str CmmEntry
toEntryLbl (CmmLabel m str CmmRetInfo) = CmmLabel m str CmmRet
toEntryLbl l = pprPanic "toEntryLbl" (ppr l)
toInfoLbl :: CLabel -> CLabel
toInfoLbl (IdLabel n c LocalEntry) = IdLabel n c LocalInfoTable
toInfoLbl (IdLabel n c ConEntry) = IdLabel n c ConInfoTable
toInfoLbl (IdLabel n c _) = IdLabel n c InfoTable
toInfoLbl (CmmLabel m str CmmEntry) = CmmLabel m str CmmInfo
toInfoLbl (CmmLabel m str CmmRet) = CmmLabel m str CmmRetInfo
toInfoLbl l = pprPanic "CLabel.toInfoLbl" (ppr l)
hasHaskellName :: CLabel -> Maybe Name
hasHaskellName (IdLabel n _ _) = Just n
hasHaskellName _ = Nothing
-- -----------------------------------------------------------------------------
-- Does a CLabel's referent itself refer to a CAF?
hasCAF :: CLabel -> Bool
hasCAF (IdLabel _ _ RednCounts) = False -- Note [ticky for LNE]
hasCAF (IdLabel _ MayHaveCafRefs _) = True
hasCAF _ = False
-- Note [ticky for LNE]
-- ~~~~~~~~~~~~~~~~~~~~~
-- Until 14 Feb 2013, every ticky counter was associated with a
-- closure. Thus, ticky labels used IdLabel. It is odd that
-- CmmBuildInfoTables.cafTransfers would consider such a ticky label
-- reason to add the name to the CAFEnv (and thus eventually the SRT),
-- but it was harmless because the ticky was only used if the closure
-- was also.
--
-- Since we now have ticky counters for LNEs, it is no longer the case
-- that every ticky counter has an actual closure. So I changed the
-- generation of ticky counters' CLabels to not result in their
-- associated id ending up in the SRT.
--
-- NB IdLabel is still appropriate for ticky ids (as opposed to
-- CmmLabel) because the LNE's counter is still related to an .hs Id,
-- that Id just isn't for a proper closure.
-- -----------------------------------------------------------------------------
-- Does a CLabel need declaring before use or not?
--
-- See wiki:Commentary/Compiler/Backends/PprC#Prototypes
needsCDecl :: CLabel -> Bool
-- False <=> it's pre-declared; don't bother
-- don't bother declaring Bitmap labels, we always make sure
-- they are defined before use.
needsCDecl (SRTLabel _) = True
needsCDecl (LargeSRTLabel _) = False
needsCDecl (LargeBitmapLabel _) = False
needsCDecl (IdLabel _ _ _) = True
needsCDecl (LocalBlockLabel _) = True
needsCDecl (StringLitLabel _) = False
needsCDecl (AsmTempLabel _) = False
needsCDecl (AsmTempDerivedLabel _ _) = False
needsCDecl (RtsLabel _) = False
needsCDecl (CmmLabel pkgId _ _)
-- Prototypes for labels defined in the runtime system are imported
-- into HC files via includes/Stg.h.
| pkgId == rtsUnitId = False
-- For other labels we inline one into the HC file directly.
| otherwise = True
needsCDecl l@(ForeignLabel{}) = not (isMathFun l)
needsCDecl (CC_Label _) = True
needsCDecl (CCS_Label _) = True
needsCDecl (HpcTicksLabel _) = True
needsCDecl (DynamicLinkerLabel {}) = panic "needsCDecl DynamicLinkerLabel"
needsCDecl PicBaseLabel = panic "needsCDecl PicBaseLabel"
needsCDecl (DeadStripPreventer {}) = panic "needsCDecl DeadStripPreventer"
-- | If a label is a local block label then return just its 'BlockId', otherwise
-- 'Nothing'.
maybeLocalBlockLabel :: CLabel -> Maybe BlockId
maybeLocalBlockLabel (LocalBlockLabel uq) = Just $ mkBlockId uq
maybeLocalBlockLabel _ = Nothing
-- | Check whether a label corresponds to a C function that has
-- a prototype in a system header somehere, or is built-in
-- to the C compiler. For these labels we avoid generating our
-- own C prototypes.
isMathFun :: CLabel -> Bool
isMathFun (ForeignLabel fs _ _ _) = fs `elementOfUniqSet` math_funs
isMathFun _ = False
math_funs :: UniqSet FastString
math_funs = mkUniqSet [
-- _ISOC99_SOURCE
(fsLit "acos"), (fsLit "acosf"), (fsLit "acosh"),
(fsLit "acoshf"), (fsLit "acoshl"), (fsLit "acosl"),
(fsLit "asin"), (fsLit "asinf"), (fsLit "asinl"),
(fsLit "asinh"), (fsLit "asinhf"), (fsLit "asinhl"),
(fsLit "atan"), (fsLit "atanf"), (fsLit "atanl"),
(fsLit "atan2"), (fsLit "atan2f"), (fsLit "atan2l"),
(fsLit "atanh"), (fsLit "atanhf"), (fsLit "atanhl"),
(fsLit "cbrt"), (fsLit "cbrtf"), (fsLit "cbrtl"),
(fsLit "ceil"), (fsLit "ceilf"), (fsLit "ceill"),
(fsLit "copysign"), (fsLit "copysignf"), (fsLit "copysignl"),
(fsLit "cos"), (fsLit "cosf"), (fsLit "cosl"),
(fsLit "cosh"), (fsLit "coshf"), (fsLit "coshl"),
(fsLit "erf"), (fsLit "erff"), (fsLit "erfl"),
(fsLit "erfc"), (fsLit "erfcf"), (fsLit "erfcl"),
(fsLit "exp"), (fsLit "expf"), (fsLit "expl"),
(fsLit "exp2"), (fsLit "exp2f"), (fsLit "exp2l"),
(fsLit "expm1"), (fsLit "expm1f"), (fsLit "expm1l"),
(fsLit "fabs"), (fsLit "fabsf"), (fsLit "fabsl"),
(fsLit "fdim"), (fsLit "fdimf"), (fsLit "fdiml"),
(fsLit "floor"), (fsLit "floorf"), (fsLit "floorl"),
(fsLit "fma"), (fsLit "fmaf"), (fsLit "fmal"),
(fsLit "fmax"), (fsLit "fmaxf"), (fsLit "fmaxl"),
(fsLit "fmin"), (fsLit "fminf"), (fsLit "fminl"),
(fsLit "fmod"), (fsLit "fmodf"), (fsLit "fmodl"),
(fsLit "frexp"), (fsLit "frexpf"), (fsLit "frexpl"),
(fsLit "hypot"), (fsLit "hypotf"), (fsLit "hypotl"),
(fsLit "ilogb"), (fsLit "ilogbf"), (fsLit "ilogbl"),
(fsLit "ldexp"), (fsLit "ldexpf"), (fsLit "ldexpl"),
(fsLit "lgamma"), (fsLit "lgammaf"), (fsLit "lgammal"),
(fsLit "llrint"), (fsLit "llrintf"), (fsLit "llrintl"),
(fsLit "llround"), (fsLit "llroundf"), (fsLit "llroundl"),
(fsLit "log"), (fsLit "logf"), (fsLit "logl"),
(fsLit "log10l"), (fsLit "log10"), (fsLit "log10f"),
(fsLit "log1pl"), (fsLit "log1p"), (fsLit "log1pf"),
(fsLit "log2"), (fsLit "log2f"), (fsLit "log2l"),
(fsLit "logb"), (fsLit "logbf"), (fsLit "logbl"),
(fsLit "lrint"), (fsLit "lrintf"), (fsLit "lrintl"),
(fsLit "lround"), (fsLit "lroundf"), (fsLit "lroundl"),
(fsLit "modf"), (fsLit "modff"), (fsLit "modfl"),
(fsLit "nan"), (fsLit "nanf"), (fsLit "nanl"),
(fsLit "nearbyint"), (fsLit "nearbyintf"), (fsLit "nearbyintl"),
(fsLit "nextafter"), (fsLit "nextafterf"), (fsLit "nextafterl"),
(fsLit "nexttoward"), (fsLit "nexttowardf"), (fsLit "nexttowardl"),
(fsLit "pow"), (fsLit "powf"), (fsLit "powl"),
(fsLit "remainder"), (fsLit "remainderf"), (fsLit "remainderl"),
(fsLit "remquo"), (fsLit "remquof"), (fsLit "remquol"),
(fsLit "rint"), (fsLit "rintf"), (fsLit "rintl"),
(fsLit "round"), (fsLit "roundf"), (fsLit "roundl"),
(fsLit "scalbln"), (fsLit "scalblnf"), (fsLit "scalblnl"),
(fsLit "scalbn"), (fsLit "scalbnf"), (fsLit "scalbnl"),
(fsLit "sin"), (fsLit "sinf"), (fsLit "sinl"),
(fsLit "sinh"), (fsLit "sinhf"), (fsLit "sinhl"),
(fsLit "sqrt"), (fsLit "sqrtf"), (fsLit "sqrtl"),
(fsLit "tan"), (fsLit "tanf"), (fsLit "tanl"),
(fsLit "tanh"), (fsLit "tanhf"), (fsLit "tanhl"),
(fsLit "tgamma"), (fsLit "tgammaf"), (fsLit "tgammal"),
(fsLit "trunc"), (fsLit "truncf"), (fsLit "truncl"),
-- ISO C 99 also defines these function-like macros in math.h:
-- fpclassify, isfinite, isinf, isnormal, signbit, isgreater,
-- isgreaterequal, isless, islessequal, islessgreater, isunordered
-- additional symbols from _BSD_SOURCE
(fsLit "drem"), (fsLit "dremf"), (fsLit "dreml"),
(fsLit "finite"), (fsLit "finitef"), (fsLit "finitel"),
(fsLit "gamma"), (fsLit "gammaf"), (fsLit "gammal"),
(fsLit "isinf"), (fsLit "isinff"), (fsLit "isinfl"),
(fsLit "isnan"), (fsLit "isnanf"), (fsLit "isnanl"),
(fsLit "j0"), (fsLit "j0f"), (fsLit "j0l"),
(fsLit "j1"), (fsLit "j1f"), (fsLit "j1l"),
(fsLit "jn"), (fsLit "jnf"), (fsLit "jnl"),
(fsLit "lgamma_r"), (fsLit "lgammaf_r"), (fsLit "lgammal_r"),
(fsLit "scalb"), (fsLit "scalbf"), (fsLit "scalbl"),
(fsLit "significand"), (fsLit "significandf"), (fsLit "significandl"),
(fsLit "y0"), (fsLit "y0f"), (fsLit "y0l"),
(fsLit "y1"), (fsLit "y1f"), (fsLit "y1l"),
(fsLit "yn"), (fsLit "ynf"), (fsLit "ynl"),
-- These functions are described in IEEE Std 754-2008 -
-- Standard for Floating-Point Arithmetic and ISO/IEC TS 18661
(fsLit "nextup"), (fsLit "nextupf"), (fsLit "nextupl"),
(fsLit "nextdown"), (fsLit "nextdownf"), (fsLit "nextdownl")
]
-- -----------------------------------------------------------------------------
-- | Is a CLabel visible outside this object file or not?
-- From the point of view of the code generator, a name is
-- externally visible if it has to be declared as exported
-- in the .o file's symbol table; that is, made non-static.
externallyVisibleCLabel :: CLabel -> Bool -- not C "static"
externallyVisibleCLabel (StringLitLabel _) = False
externallyVisibleCLabel (AsmTempLabel _) = False
externallyVisibleCLabel (AsmTempDerivedLabel _ _)= False
externallyVisibleCLabel (RtsLabel _) = True
externallyVisibleCLabel (LocalBlockLabel _) = False
externallyVisibleCLabel (CmmLabel _ _ _) = True
externallyVisibleCLabel (ForeignLabel{}) = True
externallyVisibleCLabel (IdLabel name _ info) = isExternalName name && externallyVisibleIdLabel info
externallyVisibleCLabel (CC_Label _) = True
externallyVisibleCLabel (CCS_Label _) = True
externallyVisibleCLabel (DynamicLinkerLabel _ _) = False
externallyVisibleCLabel (HpcTicksLabel _) = True
externallyVisibleCLabel (LargeBitmapLabel _) = False
externallyVisibleCLabel (SRTLabel _) = False
externallyVisibleCLabel (LargeSRTLabel _) = False
externallyVisibleCLabel (PicBaseLabel {}) = panic "externallyVisibleCLabel PicBaseLabel"
externallyVisibleCLabel (DeadStripPreventer {}) = panic "externallyVisibleCLabel DeadStripPreventer"
externallyVisibleIdLabel :: IdLabelInfo -> Bool
externallyVisibleIdLabel SRT = False
externallyVisibleIdLabel LocalInfoTable = False
externallyVisibleIdLabel LocalEntry = False
externallyVisibleIdLabel BlockInfoTable = False
externallyVisibleIdLabel _ = True
-- -----------------------------------------------------------------------------
-- Finding the "type" of a CLabel
-- For generating correct types in label declarations:
data CLabelType
= CodeLabel -- Address of some executable instructions
| DataLabel -- Address of data, not a GC ptr
| GcPtrLabel -- Address of a (presumably static) GC object
isCFunctionLabel :: CLabel -> Bool
isCFunctionLabel lbl = case labelType lbl of
CodeLabel -> True
_other -> False
isGcPtrLabel :: CLabel -> Bool
isGcPtrLabel lbl = case labelType lbl of
GcPtrLabel -> True
_other -> False
-- | Work out the general type of data at the address of this label
-- whether it be code, data, or static GC object.
labelType :: CLabel -> CLabelType
labelType (IdLabel _ _ info) = idInfoLabelType info
labelType (CmmLabel _ _ CmmData) = DataLabel
labelType (CmmLabel _ _ CmmClosure) = GcPtrLabel
labelType (CmmLabel _ _ CmmCode) = CodeLabel
labelType (CmmLabel _ _ CmmInfo) = DataLabel
labelType (CmmLabel _ _ CmmEntry) = CodeLabel
labelType (CmmLabel _ _ CmmPrimCall) = CodeLabel
labelType (CmmLabel _ _ CmmRetInfo) = DataLabel
labelType (CmmLabel _ _ CmmRet) = CodeLabel
labelType (RtsLabel (RtsSelectorInfoTable _ _)) = DataLabel
labelType (RtsLabel (RtsApInfoTable _ _)) = DataLabel
labelType (RtsLabel (RtsApFast _)) = CodeLabel
labelType (RtsLabel _) = DataLabel
labelType (LocalBlockLabel _) = CodeLabel
labelType (SRTLabel _) = DataLabel
labelType (ForeignLabel _ _ _ IsFunction) = CodeLabel
labelType (ForeignLabel _ _ _ IsData) = DataLabel
labelType (AsmTempLabel _) = panic "labelType(AsmTempLabel)"
labelType (AsmTempDerivedLabel _ _) = panic "labelType(AsmTempDerivedLabel)"
labelType (StringLitLabel _) = DataLabel
labelType (CC_Label _) = DataLabel
labelType (CCS_Label _) = DataLabel
labelType (DynamicLinkerLabel _ _) = DataLabel -- Is this right?
labelType PicBaseLabel = DataLabel
labelType (DeadStripPreventer _) = DataLabel
labelType (HpcTicksLabel _) = DataLabel
labelType (LargeSRTLabel _) = DataLabel
labelType (LargeBitmapLabel _) = DataLabel
idInfoLabelType :: IdLabelInfo -> CLabelType
idInfoLabelType info =
case info of
InfoTable -> DataLabel
LocalInfoTable -> DataLabel
BlockInfoTable -> DataLabel
Closure -> GcPtrLabel
ConInfoTable -> DataLabel
ClosureTable -> DataLabel
RednCounts -> DataLabel
Bytes -> DataLabel
_ -> CodeLabel
-- -----------------------------------------------------------------------------
-- Does a CLabel need dynamic linkage?
-- When referring to data in code, we need to know whether
-- that data resides in a DLL or not. [Win32 only.]
-- @labelDynamic@ returns @True@ if the label is located
-- in a DLL, be it a data reference or not.
labelDynamic :: DynFlags -> Module -> CLabel -> Bool
labelDynamic dflags this_mod lbl =
case lbl of
-- is the RTS in a DLL or not?
RtsLabel _ -> (WayDyn `elem` ways dflags) && (this_pkg /= rtsUnitId)
IdLabel n _ _ -> isDllName dflags this_mod n
-- When compiling in the "dyn" way, each package is to be linked into
-- its own shared library.
CmmLabel pkg _ _
| os == OSMinGW32 ->
(WayDyn `elem` ways dflags) && (this_pkg /= pkg)
| otherwise ->
True
LocalBlockLabel _ -> False
ForeignLabel _ _ source _ ->
if os == OSMinGW32
then case source of
-- Foreign label is in some un-named foreign package (or DLL).
ForeignLabelInExternalPackage -> True
-- Foreign label is linked into the same package as the
-- source file currently being compiled.
ForeignLabelInThisPackage -> False
-- Foreign label is in some named package.
-- When compiling in the "dyn" way, each package is to be
-- linked into its own DLL.
ForeignLabelInPackage pkgId ->
(WayDyn `elem` ways dflags) && (this_pkg /= pkgId)
else -- On Mac OS X and on ELF platforms, false positives are OK,
-- so we claim that all foreign imports come from dynamic
-- libraries
True
HpcTicksLabel m -> (WayDyn `elem` ways dflags) && this_mod /= m
-- Note that DynamicLinkerLabels do NOT require dynamic linking themselves.
_ -> False
where
os = platformOS (targetPlatform dflags)
this_pkg = moduleUnitId this_mod
-----------------------------------------------------------------------------
-- Printing out CLabels.
{-
Convention:
<name>_<type>
where <name> is <Module>_<name> for external names and <unique> for
internal names. <type> is one of the following:
info Info table
srt Static reference table
srtd Static reference table descriptor
entry Entry code (function, closure)
slow Slow entry code (if any)
ret Direct return address
vtbl Vector table
<n>_alt Case alternative (tag n)
dflt Default case alternative
btm Large bitmap vector
closure Static closure
con_entry Dynamic Constructor entry code
con_info Dynamic Constructor info table
static_entry Static Constructor entry code
static_info Static Constructor info table
sel_info Selector info table
sel_entry Selector entry code
cc Cost centre
ccs Cost centre stack
Many of these distinctions are only for documentation reasons. For
example, _ret is only distinguished from _entry to make it easy to
tell whether a code fragment is a return point or a closure/function
entry.
Note [Closure and info labels]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For a function 'foo, we have:
foo_info : Points to the info table describing foo's closure
(and entry code for foo with tables next to code)
foo_closure : Static (no-free-var) closure only:
points to the statically-allocated closure
For a data constructor (such as Just or Nothing), we have:
Just_con_info: Info table for the data constructor itself
the first word of a heap-allocated Just
Just_info: Info table for the *worker function*, an
ordinary Haskell function of arity 1 that
allocates a (Just x) box:
Just = \x -> Just x
Just_closure: The closure for this worker
Nothing_closure: a statically allocated closure for Nothing
Nothing_static_info: info table for Nothing_closure
All these must be exported symbol, EXCEPT Just_info. We don't need to
export this because in other modules we either have
* A reference to 'Just'; use Just_closure
* A saturated call 'Just x'; allocate using Just_con_info
Not exporting these Just_info labels reduces the number of symbols
somewhat.
Note [Bytes label]
~~~~~~~~~~~~~~~~~~
For a top-level string literal 'foo', we have just one symbol 'foo_bytes', which
points to a static data block containing the content of the literal.
Note [Proc-point local block entry-points]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A label for a proc-point local block entry-point has no "_entry" suffix. With
`infoTblLbl` we derive an info table label from a proc-point block ID. If
we convert such an info table label into an entry label we must produce
the label without an "_entry" suffix. So an info table label records
the fact that it was derived from a block ID in `IdLabelInfo` as
`BlockInfoTable`.
The info table label and the local block label are both local labels
and are not externally visible.
-}
instance Outputable CLabel where
ppr c = sdocWithPlatform $ \platform -> pprCLabel platform c
pprCLabel :: Platform -> CLabel -> SDoc
pprCLabel platform (LocalBlockLabel u)
= getPprStyle $ \ sty ->
if asmStyle sty then
ptext (asmTempLabelPrefix platform) <> pprUniqueAlways u
else
char '_' <> pprUniqueAlways u
pprCLabel platform (AsmTempLabel u)
| not (platformUnregisterised platform)
= getPprStyle $ \ sty ->
if asmStyle sty then
ptext (asmTempLabelPrefix platform) <> pprUniqueAlways u
else
char '_' <> pprUniqueAlways u
pprCLabel platform (AsmTempDerivedLabel l suf)
| cGhcWithNativeCodeGen == "YES"
= ptext (asmTempLabelPrefix platform)
<> case l of AsmTempLabel u -> pprUniqueAlways u
LocalBlockLabel u -> pprUniqueAlways u
_other -> pprCLabel platform l
<> ftext suf
pprCLabel platform (DynamicLinkerLabel info lbl)
| cGhcWithNativeCodeGen == "YES"
= pprDynamicLinkerAsmLabel platform info lbl
pprCLabel _ PicBaseLabel
| cGhcWithNativeCodeGen == "YES"
= text "1b"
pprCLabel platform (DeadStripPreventer lbl)
| cGhcWithNativeCodeGen == "YES"
= pprCLabel platform lbl <> text "_dsp"
pprCLabel _ (StringLitLabel u)
| cGhcWithNativeCodeGen == "YES"
= pprUniqueAlways u <> ptext (sLit "_str")
pprCLabel platform lbl
= getPprStyle $ \ sty ->
if cGhcWithNativeCodeGen == "YES" && asmStyle sty
then maybe_underscore (pprAsmCLbl platform lbl)
else pprCLbl lbl
maybe_underscore :: SDoc -> SDoc
maybe_underscore doc
| underscorePrefix = pp_cSEP <> doc
| otherwise = doc
pprAsmCLbl :: Platform -> CLabel -> SDoc
pprAsmCLbl platform (ForeignLabel fs (Just sz) _ _)
| platformOS platform == OSMinGW32
-- In asm mode, we need to put the suffix on a stdcall ForeignLabel.
-- (The C compiler does this itself).
= ftext fs <> char '@' <> int sz
pprAsmCLbl _ lbl
= pprCLbl lbl
pprCLbl :: CLabel -> SDoc
pprCLbl (StringLitLabel u)
= pprUniqueAlways u <> text "_str"
pprCLbl (SRTLabel u)
= pprUniqueAlways u <> pp_cSEP <> text "srt"
pprCLbl (LargeSRTLabel u) = pprUniqueAlways u <> pp_cSEP <> text "srtd"
pprCLbl (LargeBitmapLabel u) = text "b" <> pprUniqueAlways u <> pp_cSEP <> text "btm"
-- Some bitsmaps for tuple constructors have a numeric tag (e.g. '7')
-- until that gets resolved we'll just force them to start
-- with a letter so the label will be legal assmbly code.
pprCLbl (CmmLabel _ str CmmCode) = ftext str
pprCLbl (CmmLabel _ str CmmData) = ftext str
pprCLbl (CmmLabel _ str CmmPrimCall) = ftext str
pprCLbl (LocalBlockLabel u) = text "blk_" <> pprUniqueAlways u
pprCLbl (RtsLabel (RtsApFast str)) = ftext str <> text "_fast"
pprCLbl (RtsLabel (RtsSelectorInfoTable upd_reqd offset))
= sdocWithDynFlags $ \dflags ->
ASSERT(offset >= 0 && offset <= mAX_SPEC_SELECTEE_SIZE dflags)
hcat [text "stg_sel_", text (show offset),
ptext (if upd_reqd
then (sLit "_upd_info")
else (sLit "_noupd_info"))
]
pprCLbl (RtsLabel (RtsSelectorEntry upd_reqd offset))
= sdocWithDynFlags $ \dflags ->
ASSERT(offset >= 0 && offset <= mAX_SPEC_SELECTEE_SIZE dflags)
hcat [text "stg_sel_", text (show offset),
ptext (if upd_reqd
then (sLit "_upd_entry")
else (sLit "_noupd_entry"))
]
pprCLbl (RtsLabel (RtsApInfoTable upd_reqd arity))
= sdocWithDynFlags $ \dflags ->
ASSERT(arity > 0 && arity <= mAX_SPEC_AP_SIZE dflags)
hcat [text "stg_ap_", text (show arity),
ptext (if upd_reqd
then (sLit "_upd_info")
else (sLit "_noupd_info"))
]
pprCLbl (RtsLabel (RtsApEntry upd_reqd arity))
= sdocWithDynFlags $ \dflags ->
ASSERT(arity > 0 && arity <= mAX_SPEC_AP_SIZE dflags)
hcat [text "stg_ap_", text (show arity),
ptext (if upd_reqd
then (sLit "_upd_entry")
else (sLit "_noupd_entry"))
]
pprCLbl (CmmLabel _ fs CmmInfo)
= ftext fs <> text "_info"
pprCLbl (CmmLabel _ fs CmmEntry)
= ftext fs <> text "_entry"
pprCLbl (CmmLabel _ fs CmmRetInfo)
= ftext fs <> text "_info"
pprCLbl (CmmLabel _ fs CmmRet)
= ftext fs <> text "_ret"
pprCLbl (CmmLabel _ fs CmmClosure)
= ftext fs <> text "_closure"
pprCLbl (RtsLabel (RtsPrimOp primop))
= text "stg_" <> ppr primop
pprCLbl (RtsLabel (RtsSlowFastTickyCtr pat))
= text "SLOW_CALL_fast_" <> text pat <> ptext (sLit "_ctr")
pprCLbl (ForeignLabel str _ _ _)
= ftext str
pprCLbl (IdLabel name _cafs flavor) = ppr name <> ppIdFlavor flavor
pprCLbl (CC_Label cc) = ppr cc
pprCLbl (CCS_Label ccs) = ppr ccs
pprCLbl (HpcTicksLabel mod)
= text "_hpc_tickboxes_" <> ppr mod <> ptext (sLit "_hpc")
pprCLbl (AsmTempLabel {}) = panic "pprCLbl AsmTempLabel"
pprCLbl (AsmTempDerivedLabel {})= panic "pprCLbl AsmTempDerivedLabel"
pprCLbl (DynamicLinkerLabel {}) = panic "pprCLbl DynamicLinkerLabel"
pprCLbl (PicBaseLabel {}) = panic "pprCLbl PicBaseLabel"
pprCLbl (DeadStripPreventer {}) = panic "pprCLbl DeadStripPreventer"
ppIdFlavor :: IdLabelInfo -> SDoc
ppIdFlavor x = pp_cSEP <>
(case x of
Closure -> text "closure"
SRT -> text "srt"
InfoTable -> text "info"
LocalInfoTable -> text "info"
Entry -> text "entry"
LocalEntry -> text "entry"
Slow -> text "slow"
RednCounts -> text "ct"
ConEntry -> text "con_entry"
ConInfoTable -> text "con_info"
ClosureTable -> text "closure_tbl"
Bytes -> text "bytes"
BlockInfoTable -> text "info"
)
pp_cSEP :: SDoc
pp_cSEP = char '_'
instance Outputable ForeignLabelSource where
ppr fs
= case fs of
ForeignLabelInPackage pkgId -> parens $ text "package: " <> ppr pkgId
ForeignLabelInThisPackage -> parens $ text "this package"
ForeignLabelInExternalPackage -> parens $ text "external package"
-- -----------------------------------------------------------------------------
-- Machine-dependent knowledge about labels.
underscorePrefix :: Bool -- leading underscore on assembler labels?
underscorePrefix = (cLeadingUnderscore == "YES")
asmTempLabelPrefix :: Platform -> LitString -- for formatting labels
asmTempLabelPrefix platform = case platformOS platform of
OSDarwin -> sLit "L"
OSAIX -> sLit "__L" -- follow IBM XL C's convention
_ -> sLit ".L"
pprDynamicLinkerAsmLabel :: Platform -> DynamicLinkerLabelInfo -> CLabel -> SDoc
pprDynamicLinkerAsmLabel platform dllInfo lbl =
case platformOS platform of
OSDarwin
| platformArch platform == ArchX86_64 ->
case dllInfo of
CodeStub -> char 'L' <> ppr lbl <> text "$stub"
SymbolPtr -> char 'L' <> ppr lbl <> text "$non_lazy_ptr"
GotSymbolPtr -> ppr lbl <> text "@GOTPCREL"
GotSymbolOffset -> ppr lbl
| otherwise ->
case dllInfo of
CodeStub -> char 'L' <> ppr lbl <> text "$stub"
SymbolPtr -> char 'L' <> ppr lbl <> text "$non_lazy_ptr"
_ -> panic "pprDynamicLinkerAsmLabel"
OSAIX ->
case dllInfo of
SymbolPtr -> text "LC.." <> ppr lbl -- GCC's naming convention
_ -> panic "pprDynamicLinkerAsmLabel"
_ | osElfTarget (platformOS platform) -> elfLabel
OSMinGW32 ->
case dllInfo of
SymbolPtr -> text "__imp_" <> ppr lbl
_ -> panic "pprDynamicLinkerAsmLabel"
_ -> panic "pprDynamicLinkerAsmLabel"
where
elfLabel
| platformArch platform == ArchPPC
= case dllInfo of
CodeStub -> -- See Note [.LCTOC1 in PPC PIC code]
ppr lbl <> text "+32768@plt"
SymbolPtr -> text ".LC_" <> ppr lbl
_ -> panic "pprDynamicLinkerAsmLabel"
| platformArch platform == ArchX86_64
= case dllInfo of
CodeStub -> ppr lbl <> text "@plt"
GotSymbolPtr -> ppr lbl <> text "@gotpcrel"
GotSymbolOffset -> ppr lbl
SymbolPtr -> text ".LC_" <> ppr lbl
| platformArch platform == ArchPPC_64 ELF_V1
|| platformArch platform == ArchPPC_64 ELF_V2
= case dllInfo of
GotSymbolPtr -> text ".LC_" <> ppr lbl
<> text "@toc"
GotSymbolOffset -> ppr lbl
SymbolPtr -> text ".LC_" <> ppr lbl
_ -> panic "pprDynamicLinkerAsmLabel"
| otherwise
= case dllInfo of
CodeStub -> ppr lbl <> text "@plt"
SymbolPtr -> text ".LC_" <> ppr lbl
GotSymbolPtr -> ppr lbl <> text "@got"
GotSymbolOffset -> ppr lbl <> text "@gotoff"
| ezyang/ghc | compiler/cmm/CLabel.hs | bsd-3-clause | 54,483 | 0 | 16 | 15,175 | 10,771 | 5,643 | 5,128 | 838 | 23 |
{-
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
\section[RnSource]{Main pass of renamer}
-}
{-# LANGUAGE CPP, ScopedTypeVariables #-}
module RnSource (
rnSrcDecls, addTcgDUs, findSplice
) where
#include "HsVersions.h"
import {-# SOURCE #-} RnExpr( rnLExpr )
import {-# SOURCE #-} RnSplice ( rnSpliceDecl, rnTopSpliceDecls )
import HsSyn
import FieldLabel
import RdrName
import RnTypes
import RnBinds
import RnEnv
import RnNames
import RnHsDoc ( rnHsDoc, rnMbLHsDoc )
import TcAnnotations ( annCtxt )
import TcRnMonad
import ForeignCall ( CCallTarget(..) )
import Module
import HscTypes ( Warnings(..), plusWarns )
import Class ( FunDep )
import PrelNames ( applicativeClassName, pureAName, thenAName
, monadClassName, returnMName, thenMName
, monadFailClassName, failMName, failMName_preMFP
, semigroupClassName, sappendName
, monoidClassName, mappendName
)
import Name
import NameSet
import NameEnv
import Avail
import Outputable
import Bag
import BasicTypes ( RuleName, pprRuleName )
import FastString
import SrcLoc
import DynFlags
import Util ( debugIsOn, partitionWith )
import HscTypes ( HscEnv, hsc_dflags )
import ListSetOps ( findDupsEq, removeDups, equivClasses )
import Digraph ( SCC, flattenSCC, flattenSCCs
, stronglyConnCompFromEdgedVerticesUniq )
import UniqFM
import qualified GHC.LanguageExtensions as LangExt
import Control.Monad
import Control.Arrow ( first )
import Data.List ( sortBy, mapAccumL )
import qualified Data.Set as Set ( difference, fromList, toList, null )
{-
@rnSourceDecl@ `renames' declarations.
It simultaneously performs dependency analysis and precedence parsing.
It also does the following error checks:
\begin{enumerate}
\item
Checks that tyvars are used properly. This includes checking
for undefined tyvars, and tyvars in contexts that are ambiguous.
(Some of this checking has now been moved to module @TcMonoType@,
since we don't have functional dependency information at this point.)
\item
Checks that all variable occurrences are defined.
\item
Checks the @(..)@ etc constraints in the export list.
\end{enumerate}
-}
-- Brings the binders of the group into scope in the appropriate places;
-- does NOT assume that anything is in scope already
rnSrcDecls :: HsGroup RdrName -> RnM (TcGblEnv, HsGroup Name)
-- Rename a top-level HsGroup; used for normal source files *and* hs-boot files
rnSrcDecls group@(HsGroup { hs_valds = val_decls,
hs_splcds = splice_decls,
hs_tyclds = tycl_decls,
hs_derivds = deriv_decls,
hs_fixds = fix_decls,
hs_warnds = warn_decls,
hs_annds = ann_decls,
hs_fords = foreign_decls,
hs_defds = default_decls,
hs_ruleds = rule_decls,
hs_vects = vect_decls,
hs_docs = docs })
= do {
-- (A) Process the fixity declarations, creating a mapping from
-- FastStrings to FixItems.
-- Also checks for duplicates.
local_fix_env <- makeMiniFixityEnv fix_decls ;
-- (B) Bring top level binders (and their fixities) into scope,
-- *except* for the value bindings, which get done in step (D)
-- with collectHsIdBinders. However *do* include
--
-- * Class ops, data constructors, and record fields,
-- because they do not have value declarations.
-- Aso step (C) depends on datacons and record fields
--
-- * For hs-boot files, include the value signatures
-- Again, they have no value declarations
--
(tc_envs, tc_bndrs) <- getLocalNonValBinders local_fix_env group ;
setEnvs tc_envs $ do {
failIfErrsM ; -- No point in continuing if (say) we have duplicate declarations
-- (D1) Bring pattern synonyms into scope.
-- Need to do this before (D2) because rnTopBindsLHS
-- looks up those pattern synonyms (Trac #9889)
extendPatSynEnv val_decls local_fix_env $ \pat_syn_bndrs -> do {
-- (D2) Rename the left-hand sides of the value bindings.
-- This depends on everything from (B) being in scope,
-- and on (C) for resolving record wild cards.
-- It uses the fixity env from (A) to bind fixities for view patterns.
new_lhs <- rnTopBindsLHS local_fix_env val_decls ;
-- Bind the LHSes (and their fixities) in the global rdr environment
let { id_bndrs = collectHsIdBinders new_lhs } ; -- Excludes pattern-synonym binders
-- They are already in scope
traceRn (text "rnSrcDecls" <+> ppr id_bndrs) ;
tc_envs <- extendGlobalRdrEnvRn (map avail id_bndrs) local_fix_env ;
traceRn (text "D2" <+> ppr (tcg_rdr_env (fst tc_envs)));
setEnvs tc_envs $ do {
-- Now everything is in scope, as the remaining renaming assumes.
-- (E) Rename type and class decls
-- (note that value LHSes need to be in scope for default methods)
--
-- You might think that we could build proper def/use information
-- for type and class declarations, but they can be involved
-- in mutual recursion across modules, and we only do the SCC
-- analysis for them in the type checker.
-- So we content ourselves with gathering uses only; that
-- means we'll only report a declaration as unused if it isn't
-- mentioned at all. Ah well.
traceRn (text "Start rnTyClDecls" <+> ppr tycl_decls) ;
(rn_tycl_decls, src_fvs1) <- rnTyClDecls tycl_decls ;
-- (F) Rename Value declarations right-hand sides
traceRn (text "Start rnmono") ;
let { val_bndr_set = mkNameSet id_bndrs `unionNameSet` mkNameSet pat_syn_bndrs } ;
is_boot <- tcIsHsBootOrSig ;
(rn_val_decls, bind_dus) <- if is_boot
-- For an hs-boot, use tc_bndrs (which collects how we're renamed
-- signatures), since val_bndr_set is empty (there are no x = ...
-- bindings in an hs-boot.)
then rnTopBindsBoot tc_bndrs new_lhs
else rnValBindsRHS (TopSigCtxt val_bndr_set) new_lhs ;
traceRn (text "finish rnmono" <+> ppr rn_val_decls) ;
-- (G) Rename Fixity and deprecations
-- Rename fixity declarations and error if we try to
-- fix something from another module (duplicates were checked in (A))
let { all_bndrs = tc_bndrs `unionNameSet` val_bndr_set } ;
rn_fix_decls <- rnSrcFixityDecls all_bndrs fix_decls ;
-- Rename deprec decls;
-- check for duplicates and ensure that deprecated things are defined locally
-- at the moment, we don't keep these around past renaming
rn_warns <- rnSrcWarnDecls all_bndrs warn_decls ;
-- (H) Rename Everything else
(rn_rule_decls, src_fvs2) <- setXOptM LangExt.ScopedTypeVariables $
rnList rnHsRuleDecls rule_decls ;
-- Inside RULES, scoped type variables are on
(rn_vect_decls, src_fvs3) <- rnList rnHsVectDecl vect_decls ;
(rn_foreign_decls, src_fvs4) <- rnList rnHsForeignDecl foreign_decls ;
(rn_ann_decls, src_fvs5) <- rnList rnAnnDecl ann_decls ;
(rn_default_decls, src_fvs6) <- rnList rnDefaultDecl default_decls ;
(rn_deriv_decls, src_fvs7) <- rnList rnSrcDerivDecl deriv_decls ;
(rn_splice_decls, src_fvs8) <- rnList rnSpliceDecl splice_decls ;
-- Haddock docs; no free vars
rn_docs <- mapM (wrapLocM rnDocDecl) docs ;
last_tcg_env <- getGblEnv ;
-- (I) Compute the results and return
let {rn_group = HsGroup { hs_valds = rn_val_decls,
hs_splcds = rn_splice_decls,
hs_tyclds = rn_tycl_decls,
hs_derivds = rn_deriv_decls,
hs_fixds = rn_fix_decls,
hs_warnds = [], -- warns are returned in the tcg_env
-- (see below) not in the HsGroup
hs_fords = rn_foreign_decls,
hs_annds = rn_ann_decls,
hs_defds = rn_default_decls,
hs_ruleds = rn_rule_decls,
hs_vects = rn_vect_decls,
hs_docs = rn_docs } ;
tcf_bndrs = hsTyClForeignBinders rn_tycl_decls rn_foreign_decls ;
other_def = (Just (mkNameSet tcf_bndrs), emptyNameSet) ;
other_fvs = plusFVs [src_fvs1, src_fvs2, src_fvs3, src_fvs4, src_fvs5,
src_fvs6, src_fvs7, src_fvs8] ;
-- It is tiresome to gather the binders from type and class decls
src_dus = [other_def] `plusDU` bind_dus `plusDU` usesOnly other_fvs ;
-- Instance decls may have occurrences of things bound in bind_dus
-- so we must put other_fvs last
final_tcg_env = let tcg_env' = (last_tcg_env `addTcgDUs` src_dus)
in -- we return the deprecs in the env, not in the HsGroup above
tcg_env' { tcg_warns = tcg_warns tcg_env' `plusWarns` rn_warns };
} ;
traceRn (text "last" <+> ppr (tcg_rdr_env final_tcg_env)) ;
traceRn (text "finish rnSrc" <+> ppr rn_group) ;
traceRn (text "finish Dus" <+> ppr src_dus ) ;
return (final_tcg_env, rn_group)
}}}}
addTcgDUs :: TcGblEnv -> DefUses -> TcGblEnv
-- This function could be defined lower down in the module hierarchy,
-- but there doesn't seem anywhere very logical to put it.
addTcgDUs tcg_env dus = tcg_env { tcg_dus = tcg_dus tcg_env `plusDU` dus }
rnList :: (a -> RnM (b, FreeVars)) -> [Located a] -> RnM ([Located b], FreeVars)
rnList f xs = mapFvRn (wrapLocFstM f) xs
{-
*********************************************************
* *
HsDoc stuff
* *
*********************************************************
-}
rnDocDecl :: DocDecl -> RnM DocDecl
rnDocDecl (DocCommentNext doc) = do
rn_doc <- rnHsDoc doc
return (DocCommentNext rn_doc)
rnDocDecl (DocCommentPrev doc) = do
rn_doc <- rnHsDoc doc
return (DocCommentPrev rn_doc)
rnDocDecl (DocCommentNamed str doc) = do
rn_doc <- rnHsDoc doc
return (DocCommentNamed str rn_doc)
rnDocDecl (DocGroup lev doc) = do
rn_doc <- rnHsDoc doc
return (DocGroup lev rn_doc)
{-
*********************************************************
* *
Source-code fixity declarations
* *
*********************************************************
-}
rnSrcFixityDecls :: NameSet -> [LFixitySig RdrName] -> RnM [LFixitySig Name]
-- Rename the fixity decls, so we can put
-- the renamed decls in the renamed syntax tree
-- Errors if the thing being fixed is not defined locally.
--
-- The returned FixitySigs are not actually used for anything,
-- except perhaps the GHCi API
rnSrcFixityDecls bndr_set fix_decls
= do fix_decls <- mapM rn_decl fix_decls
return (concat fix_decls)
where
sig_ctxt = TopSigCtxt bndr_set
rn_decl :: LFixitySig RdrName -> RnM [LFixitySig Name]
-- GHC extension: look up both the tycon and data con
-- for con-like things; hence returning a list
-- If neither are in scope, report an error; otherwise
-- return a fixity sig for each (slightly odd)
rn_decl (L loc (FixitySig fnames fixity))
= do names <- mapM lookup_one fnames
return [ L loc (FixitySig name fixity)
| name <- names ]
lookup_one :: Located RdrName -> RnM [Located Name]
lookup_one (L name_loc rdr_name)
= setSrcSpan name_loc $
-- this lookup will fail if the definition isn't local
do names <- lookupLocalTcNames sig_ctxt what rdr_name
return [ L name_loc name | (_, name) <- names ]
what = text "fixity signature"
{-
*********************************************************
* *
Source-code deprecations declarations
* *
*********************************************************
Check that the deprecated names are defined, are defined locally, and
that there are no duplicate deprecations.
It's only imported deprecations, dealt with in RnIfaces, that we
gather them together.
-}
-- checks that the deprecations are defined locally, and that there are no duplicates
rnSrcWarnDecls :: NameSet -> [LWarnDecls RdrName] -> RnM Warnings
rnSrcWarnDecls _ []
= return NoWarnings
rnSrcWarnDecls bndr_set decls'
= do { -- check for duplicates
; mapM_ (\ dups -> let (L loc rdr:lrdr':_) = dups
in addErrAt loc (dupWarnDecl lrdr' rdr))
warn_rdr_dups
; pairs_s <- mapM (addLocM rn_deprec) decls
; return (WarnSome ((concat pairs_s))) }
where
decls = concatMap (\(L _ d) -> wd_warnings d) decls'
sig_ctxt = TopSigCtxt bndr_set
rn_deprec (Warning rdr_names txt)
-- ensures that the names are defined locally
= do { names <- concatMapM (lookupLocalTcNames sig_ctxt what . unLoc)
rdr_names
; return [(rdrNameOcc rdr, txt) | (rdr, _) <- names] }
what = text "deprecation"
warn_rdr_dups = findDupRdrNames $ concatMap (\(L _ (Warning ns _)) -> ns)
decls
findDupRdrNames :: [Located RdrName] -> [[Located RdrName]]
findDupRdrNames = findDupsEq (\ x -> \ y -> rdrNameOcc (unLoc x) == rdrNameOcc (unLoc y))
-- look for duplicates among the OccNames;
-- we check that the names are defined above
-- invt: the lists returned by findDupsEq always have at least two elements
dupWarnDecl :: Located RdrName -> RdrName -> SDoc
-- Located RdrName -> DeprecDecl RdrName -> SDoc
dupWarnDecl (L loc _) rdr_name
= vcat [text "Multiple warning declarations for" <+> quotes (ppr rdr_name),
text "also at " <+> ppr loc]
{-
*********************************************************
* *
\subsection{Annotation declarations}
* *
*********************************************************
-}
rnAnnDecl :: AnnDecl RdrName -> RnM (AnnDecl Name, FreeVars)
rnAnnDecl ann@(HsAnnotation s provenance expr)
= addErrCtxt (annCtxt ann) $
do { (provenance', provenance_fvs) <- rnAnnProvenance provenance
; (expr', expr_fvs) <- setStage (Splice Untyped) $
rnLExpr expr
; return (HsAnnotation s provenance' expr',
provenance_fvs `plusFV` expr_fvs) }
rnAnnProvenance :: AnnProvenance RdrName -> RnM (AnnProvenance Name, FreeVars)
rnAnnProvenance provenance = do
provenance' <- traverse lookupTopBndrRn provenance
return (provenance', maybe emptyFVs unitFV (annProvenanceName_maybe provenance'))
{-
*********************************************************
* *
\subsection{Default declarations}
* *
*********************************************************
-}
rnDefaultDecl :: DefaultDecl RdrName -> RnM (DefaultDecl Name, FreeVars)
rnDefaultDecl (DefaultDecl tys)
= do { (tys', fvs) <- rnLHsTypes doc_str tys
; return (DefaultDecl tys', fvs) }
where
doc_str = DefaultDeclCtx
{-
*********************************************************
* *
\subsection{Foreign declarations}
* *
*********************************************************
-}
rnHsForeignDecl :: ForeignDecl RdrName -> RnM (ForeignDecl Name, FreeVars)
rnHsForeignDecl (ForeignImport { fd_name = name, fd_sig_ty = ty, fd_fi = spec })
= do { topEnv :: HscEnv <- getTopEnv
; name' <- lookupLocatedTopBndrRn name
; (ty', fvs) <- rnHsSigType (ForeignDeclCtx name) ty
-- Mark any PackageTarget style imports as coming from the current package
; let unitId = thisPackage $ hsc_dflags topEnv
spec' = patchForeignImport unitId spec
; return (ForeignImport { fd_name = name', fd_sig_ty = ty'
, fd_co = noForeignImportCoercionYet
, fd_fi = spec' }, fvs) }
rnHsForeignDecl (ForeignExport { fd_name = name, fd_sig_ty = ty, fd_fe = spec })
= do { name' <- lookupLocatedOccRn name
; (ty', fvs) <- rnHsSigType (ForeignDeclCtx name) ty
; return (ForeignExport { fd_name = name', fd_sig_ty = ty'
, fd_co = noForeignExportCoercionYet
, fd_fe = spec }
, fvs `addOneFV` unLoc name') }
-- NB: a foreign export is an *occurrence site* for name, so
-- we add it to the free-variable list. It might, for example,
-- be imported from another module
-- | For Windows DLLs we need to know what packages imported symbols are from
-- to generate correct calls. Imported symbols are tagged with the current
-- package, so if they get inlined across a package boundry we'll still
-- know where they're from.
--
patchForeignImport :: UnitId -> ForeignImport -> ForeignImport
patchForeignImport unitId (CImport cconv safety fs spec src)
= CImport cconv safety fs (patchCImportSpec unitId spec) src
patchCImportSpec :: UnitId -> CImportSpec -> CImportSpec
patchCImportSpec unitId spec
= case spec of
CFunction callTarget -> CFunction $ patchCCallTarget unitId callTarget
_ -> spec
patchCCallTarget :: UnitId -> CCallTarget -> CCallTarget
patchCCallTarget unitId callTarget =
case callTarget of
StaticTarget src label Nothing isFun
-> StaticTarget src label (Just unitId) isFun
_ -> callTarget
{-
*********************************************************
* *
\subsection{Instance declarations}
* *
*********************************************************
-}
rnSrcInstDecl :: InstDecl RdrName -> RnM (InstDecl Name, FreeVars)
rnSrcInstDecl (TyFamInstD { tfid_inst = tfi })
= do { (tfi', fvs) <- rnTyFamInstDecl Nothing tfi
; return (TyFamInstD { tfid_inst = tfi' }, fvs) }
rnSrcInstDecl (DataFamInstD { dfid_inst = dfi })
= do { (dfi', fvs) <- rnDataFamInstDecl Nothing dfi
; return (DataFamInstD { dfid_inst = dfi' }, fvs) }
rnSrcInstDecl (ClsInstD { cid_inst = cid })
= do { (cid', fvs) <- rnClsInstDecl cid
; return (ClsInstD { cid_inst = cid' }, fvs) }
-- | Warn about non-canonical typeclass instance declarations
--
-- A "non-canonical" instance definition can occur for instances of a
-- class which redundantly defines an operation its superclass
-- provides as well (c.f. `return`/`pure`). In such cases, a canonical
-- instance is one where the subclass inherits its method
-- implementation from its superclass instance (usually the subclass
-- has a default method implementation to that effect). Consequently,
-- a non-canonical instance occurs when this is not the case.
--
-- See also descriptions of 'checkCanonicalMonadInstances' and
-- 'checkCanonicalMonoidInstances'
checkCanonicalInstances :: Name -> LHsSigType Name -> LHsBinds Name -> RnM ()
checkCanonicalInstances cls poly_ty mbinds = do
whenWOptM Opt_WarnNonCanonicalMonadInstances
checkCanonicalMonadInstances
whenWOptM Opt_WarnNonCanonicalMonadFailInstances
checkCanonicalMonadFailInstances
whenWOptM Opt_WarnNonCanonicalMonoidInstances
checkCanonicalMonoidInstances
where
-- | Warn about unsound/non-canonical 'Applicative'/'Monad' instance
-- declarations. Specifically, the following conditions are verified:
--
-- In 'Monad' instances declarations:
--
-- * If 'return' is overridden it must be canonical (i.e. @return = pure@)
-- * If '(>>)' is overridden it must be canonical (i.e. @(>>) = (*>)@)
--
-- In 'Applicative' instance declarations:
--
-- * Warn if 'pure' is defined backwards (i.e. @pure = return@).
-- * Warn if '(*>)' is defined backwards (i.e. @(*>) = (>>)@).
--
checkCanonicalMonadInstances
| cls == applicativeClassName = do
forM_ (bagToList mbinds) $ \(L loc mbind) -> setSrcSpan loc $ do
case mbind of
FunBind { fun_id = L _ name, fun_matches = mg }
| name == pureAName, isAliasMG mg == Just returnMName
-> addWarnNonCanonicalMethod1
Opt_WarnNonCanonicalMonadInstances "pure" "return"
| name == thenAName, isAliasMG mg == Just thenMName
-> addWarnNonCanonicalMethod1
Opt_WarnNonCanonicalMonadInstances "(*>)" "(>>)"
_ -> return ()
| cls == monadClassName = do
forM_ (bagToList mbinds) $ \(L loc mbind) -> setSrcSpan loc $ do
case mbind of
FunBind { fun_id = L _ name, fun_matches = mg }
| name == returnMName, isAliasMG mg /= Just pureAName
-> addWarnNonCanonicalMethod2
Opt_WarnNonCanonicalMonadInstances "return" "pure"
| name == thenMName, isAliasMG mg /= Just thenAName
-> addWarnNonCanonicalMethod2
Opt_WarnNonCanonicalMonadInstances "(>>)" "(*>)"
_ -> return ()
| otherwise = return ()
-- | Warn about unsound/non-canonical 'Monad'/'MonadFail' instance
-- declarations. Specifically, the following conditions are verified:
--
-- In 'Monad' instances declarations:
--
-- * If 'fail' is overridden it must be canonical
-- (i.e. @fail = Control.Monad.Fail.fail@)
--
-- In 'MonadFail' instance declarations:
--
-- * Warn if 'fail' is defined backwards
-- (i.e. @fail = Control.Monad.fail@).
--
checkCanonicalMonadFailInstances
| cls == monadFailClassName = do
forM_ (bagToList mbinds) $ \(L loc mbind) -> setSrcSpan loc $ do
case mbind of
FunBind { fun_id = L _ name, fun_matches = mg }
| name == failMName, isAliasMG mg == Just failMName_preMFP
-> addWarnNonCanonicalMethod1
Opt_WarnNonCanonicalMonadFailInstances "fail"
"Control.Monad.fail"
_ -> return ()
| cls == monadClassName = do
forM_ (bagToList mbinds) $ \(L loc mbind) -> setSrcSpan loc $ do
case mbind of
FunBind { fun_id = L _ name, fun_matches = mg }
| name == failMName_preMFP, isAliasMG mg /= Just failMName
-> addWarnNonCanonicalMethod2
Opt_WarnNonCanonicalMonadFailInstances "fail"
"Control.Monad.Fail.fail"
_ -> return ()
| otherwise = return ()
-- | Check whether Monoid(mappend) is defined in terms of
-- Semigroup((<>)) (and not the other way round). Specifically,
-- the following conditions are verified:
--
-- In 'Monoid' instances declarations:
--
-- * If 'mappend' is overridden it must be canonical
-- (i.e. @mappend = (<>)@)
--
-- In 'Semigroup' instance declarations:
--
-- * Warn if '(<>)' is defined backwards (i.e. @(<>) = mappend@).
--
checkCanonicalMonoidInstances
| cls == semigroupClassName = do
forM_ (bagToList mbinds) $ \(L loc mbind) -> setSrcSpan loc $ do
case mbind of
FunBind { fun_id = L _ name, fun_matches = mg }
| name == sappendName, isAliasMG mg == Just mappendName
-> addWarnNonCanonicalMethod1
Opt_WarnNonCanonicalMonoidInstances "(<>)" "mappend"
_ -> return ()
| cls == monoidClassName = do
forM_ (bagToList mbinds) $ \(L loc mbind) -> setSrcSpan loc $ do
case mbind of
FunBind { fun_id = L _ name, fun_matches = mg }
| name == mappendName, isAliasMG mg /= Just sappendName
-> addWarnNonCanonicalMethod2NoDefault
Opt_WarnNonCanonicalMonoidInstances "mappend" "(<>)"
_ -> return ()
| otherwise = return ()
-- | test whether MatchGroup represents a trivial \"lhsName = rhsName\"
-- binding, and return @Just rhsName@ if this is the case
isAliasMG :: MatchGroup Name (LHsExpr Name) -> Maybe Name
isAliasMG MG {mg_alts = L _ [L _ (Match { m_pats = [], m_grhss = grhss })]}
| GRHSs [L _ (GRHS [] body)] lbinds <- grhss
, L _ EmptyLocalBinds <- lbinds
, L _ (HsVar (L _ rhsName)) <- body = Just rhsName
isAliasMG _ = Nothing
-- got "lhs = rhs" but expected something different
addWarnNonCanonicalMethod1 flag lhs rhs = do
addWarn (Reason flag) $ vcat
[ text "Noncanonical" <+>
quotes (text (lhs ++ " = " ++ rhs)) <+>
text "definition detected"
, instDeclCtxt1 poly_ty
, text "Move definition from" <+>
quotes (text rhs) <+>
text "to" <+> quotes (text lhs)
]
-- expected "lhs = rhs" but got something else
addWarnNonCanonicalMethod2 flag lhs rhs = do
addWarn (Reason flag) $ vcat
[ text "Noncanonical" <+>
quotes (text lhs) <+>
text "definition detected"
, instDeclCtxt1 poly_ty
, text "Either remove definition for" <+>
quotes (text lhs) <+> text "or define as" <+>
quotes (text (lhs ++ " = " ++ rhs))
]
-- like above, but method has no default impl
addWarnNonCanonicalMethod2NoDefault flag lhs rhs = do
addWarn (Reason flag) $ vcat
[ text "Noncanonical" <+>
quotes (text lhs) <+>
text "definition detected"
, instDeclCtxt1 poly_ty
, text "Define as" <+>
quotes (text (lhs ++ " = " ++ rhs))
]
-- stolen from TcInstDcls
instDeclCtxt1 :: LHsSigType Name -> SDoc
instDeclCtxt1 hs_inst_ty
= inst_decl_ctxt (ppr (getLHsInstDeclHead hs_inst_ty))
inst_decl_ctxt :: SDoc -> SDoc
inst_decl_ctxt doc = hang (text "in the instance declaration for")
2 (quotes doc <> text ".")
rnClsInstDecl :: ClsInstDecl RdrName -> RnM (ClsInstDecl Name, FreeVars)
rnClsInstDecl (ClsInstDecl { cid_poly_ty = inst_ty, cid_binds = mbinds
, cid_sigs = uprags, cid_tyfam_insts = ats
, cid_overlap_mode = oflag
, cid_datafam_insts = adts })
= do { (inst_ty', inst_fvs) <- rnLHsInstType (text "an instance declaration") inst_ty
; let (ktv_names, _, head_ty') = splitLHsInstDeclTy inst_ty'
; let cls = case hsTyGetAppHead_maybe head_ty' of
Nothing -> mkUnboundName (mkTcOccFS (fsLit "<class>"))
Just (L _ cls, _) -> cls
-- rnLHsInstType has added an error message
-- if hsTyGetAppHead_maybe fails
-- Rename the bindings
-- The typechecker (not the renamer) checks that all
-- the bindings are for the right class
-- (Slightly strangely) when scoped type variables are on, the
-- forall-d tyvars scope over the method bindings too
; (mbinds', uprags', meth_fvs) <- rnMethodBinds False cls ktv_names mbinds uprags
; checkCanonicalInstances cls inst_ty' mbinds'
-- Rename the associated types, and type signatures
-- Both need to have the instance type variables in scope
; traceRn (text "rnSrcInstDecl" <+> ppr inst_ty' $$ ppr ktv_names)
; ((ats', adts'), more_fvs)
<- extendTyVarEnvFVRn ktv_names $
do { (ats', at_fvs) <- rnATInstDecls rnTyFamInstDecl cls ktv_names ats
; (adts', adt_fvs) <- rnATInstDecls rnDataFamInstDecl cls ktv_names adts
; return ( (ats', adts'), at_fvs `plusFV` adt_fvs) }
; let all_fvs = meth_fvs `plusFV` more_fvs
`plusFV` inst_fvs
; return (ClsInstDecl { cid_poly_ty = inst_ty', cid_binds = mbinds'
, cid_sigs = uprags', cid_tyfam_insts = ats'
, cid_overlap_mode = oflag
, cid_datafam_insts = adts' },
all_fvs) }
-- We return the renamed associated data type declarations so
-- that they can be entered into the list of type declarations
-- for the binding group, but we also keep a copy in the instance.
-- The latter is needed for well-formedness checks in the type
-- checker (eg, to ensure that all ATs of the instance actually
-- receive a declaration).
-- NB: Even the copies in the instance declaration carry copies of
-- the instance context after renaming. This is a bit
-- strange, but should not matter (and it would be more work
-- to remove the context).
rnFamInstDecl :: HsDocContext
-> Maybe (Name, [Name]) -- Nothing => not associated
-- Just (cls,tvs) => associated,
-- and gives class and tyvars of the
-- parent instance delc
-> Located RdrName
-> HsTyPats RdrName
-> rhs
-> (HsDocContext -> rhs -> RnM (rhs', FreeVars))
-> RnM (Located Name, HsTyPats Name, rhs', FreeVars)
rnFamInstDecl doc mb_cls tycon (HsIB { hsib_body = pats }) payload rnPayload
= do { tycon' <- lookupFamInstName (fmap fst mb_cls) tycon
; let loc = case pats of
[] -> pprPanic "rnFamInstDecl" (ppr tycon)
(L loc _ : []) -> loc
(L loc _ : ps) -> combineSrcSpans loc (getLoc (last ps))
; pat_kity_vars_with_dups <- extractHsTysRdrTyVarsDups pats
-- Use the "...Dups" form because it's needed
-- below to report unsed binder on the LHS
; var_names <- mapM (newTyVarNameRn mb_cls . L loc . unLoc) $
freeKiTyVarsAllVars $
rmDupsInRdrTyVars pat_kity_vars_with_dups
-- All the free vars of the family patterns
-- with a sensible binding location
; ((pats', payload'), fvs)
<- bindLocalNamesFV var_names $
do { (pats', pat_fvs) <- rnLHsTypes (FamPatCtx tycon) pats
; (payload', rhs_fvs) <- rnPayload doc payload
-- Report unused binders on the LHS
-- See Note [Unused type variables in family instances]
; let groups :: [[Located RdrName]]
groups = equivClasses cmpLocated $
freeKiTyVarsAllVars pat_kity_vars_with_dups
; tv_nms_dups <- mapM (lookupOccRn . unLoc) $
[ tv | (tv:_:_) <- groups ]
-- Add to the used variables
-- a) any variables that appear *more than once* on the LHS
-- e.g. F a Int a = Bool
-- b) for associated instances, the variables
-- of the instance decl. See
-- Note [Unused type variables in family instances]
; let tv_nms_used = extendNameSetList rhs_fvs $
inst_tvs ++ tv_nms_dups
inst_tvs = case mb_cls of
Nothing -> []
Just (_, inst_tvs) -> inst_tvs
; warnUnusedTypePatterns var_names tv_nms_used
-- See Note [Renaming associated types]
; let bad_tvs = case mb_cls of
Nothing -> []
Just (_,cls_tkvs) -> filter is_bad cls_tkvs
var_name_set = mkNameSet var_names
is_bad cls_tkv = cls_tkv `elemNameSet` rhs_fvs
&& not (cls_tkv `elemNameSet` var_name_set)
; unless (null bad_tvs) (badAssocRhs bad_tvs)
; return ((pats', payload'), rhs_fvs `plusFV` pat_fvs) }
; let anon_wcs = concatMap collectAnonWildCards pats'
all_ibs = anon_wcs ++ var_names
-- all_ibs: include anonymous wildcards in the implicit
-- binders In a type pattern they behave just like any
-- other type variable except for being anoymous. See
-- Note [Wildcards in family instances]
all_fvs = fvs `addOneFV` unLoc tycon'
; return (tycon',
HsIB { hsib_body = pats'
, hsib_vars = all_ibs },
payload',
all_fvs) }
-- type instance => use, hence addOneFV
rnTyFamInstDecl :: Maybe (Name, [Name])
-> TyFamInstDecl RdrName
-> RnM (TyFamInstDecl Name, FreeVars)
rnTyFamInstDecl mb_cls (TyFamInstDecl { tfid_eqn = L loc eqn })
= do { (eqn', fvs) <- rnTyFamInstEqn mb_cls eqn
; return (TyFamInstDecl { tfid_eqn = L loc eqn'
, tfid_fvs = fvs }, fvs) }
rnTyFamInstEqn :: Maybe (Name, [Name])
-> TyFamInstEqn RdrName
-> RnM (TyFamInstEqn Name, FreeVars)
rnTyFamInstEqn mb_cls (TyFamEqn { tfe_tycon = tycon
, tfe_pats = pats
, tfe_rhs = rhs })
= do { (tycon', pats', rhs', fvs) <-
rnFamInstDecl (TySynCtx tycon) mb_cls tycon pats rhs rnTySyn
; return (TyFamEqn { tfe_tycon = tycon'
, tfe_pats = pats'
, tfe_rhs = rhs' }, fvs) }
rnTyFamDefltEqn :: Name
-> TyFamDefltEqn RdrName
-> RnM (TyFamDefltEqn Name, FreeVars)
rnTyFamDefltEqn cls (TyFamEqn { tfe_tycon = tycon
, tfe_pats = tyvars
, tfe_rhs = rhs })
= bindHsQTyVars ctx Nothing (Just cls) [] tyvars $ \ tyvars' _ ->
do { tycon' <- lookupFamInstName (Just cls) tycon
; (rhs', fvs) <- rnLHsType ctx rhs
; return (TyFamEqn { tfe_tycon = tycon'
, tfe_pats = tyvars'
, tfe_rhs = rhs' }, fvs) }
where
ctx = TyFamilyCtx tycon
rnDataFamInstDecl :: Maybe (Name, [Name])
-> DataFamInstDecl RdrName
-> RnM (DataFamInstDecl Name, FreeVars)
rnDataFamInstDecl mb_cls (DataFamInstDecl { dfid_tycon = tycon
, dfid_pats = pats
, dfid_defn = defn })
= do { (tycon', pats', (defn', _), fvs) <-
rnFamInstDecl (TyDataCtx tycon) mb_cls tycon pats defn rnDataDefn
; return (DataFamInstDecl { dfid_tycon = tycon'
, dfid_pats = pats'
, dfid_defn = defn'
, dfid_fvs = fvs }, fvs) }
-- Renaming of the associated types in instances.
-- Rename associated type family decl in class
rnATDecls :: Name -- Class
-> [LFamilyDecl RdrName]
-> RnM ([LFamilyDecl Name], FreeVars)
rnATDecls cls at_decls
= rnList (rnFamDecl (Just cls)) at_decls
rnATInstDecls :: (Maybe (Name, [Name]) -> -- The function that renames
decl RdrName -> -- an instance. rnTyFamInstDecl
RnM (decl Name, FreeVars)) -- or rnDataFamInstDecl
-> Name -- Class
-> [Name]
-> [Located (decl RdrName)]
-> RnM ([Located (decl Name)], FreeVars)
-- Used for data and type family defaults in a class decl
-- and the family instance declarations in an instance
--
-- NB: We allow duplicate associated-type decls;
-- See Note [Associated type instances] in TcInstDcls
rnATInstDecls rnFun cls tv_ns at_insts
= rnList (rnFun (Just (cls, tv_ns))) at_insts
-- See Note [Renaming associated types]
{- Note [Wildcards in family instances]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Wild cards can be used in type/data family instance declarations to indicate
that the name of a type variable doesn't matter. Each wild card will be
replaced with a new unique type variable. For instance:
type family F a b :: *
type instance F Int _ = Int
is the same as
type family F a b :: *
type instance F Int b = Int
This is implemented as follows: during renaming anonymous wild cards
'_' are given freshly generated names. These names are collected after
renaming (rnFamInstDecl) and used to make new type variables during
type checking (tc_fam_ty_pats). One should not confuse these wild
cards with the ones from partial type signatures. The latter generate
fresh meta-variables whereas the former generate fresh skolems.
Note [Unused type variables in family instances]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When the flag -fwarn-unused-type-patterns is on, the compiler reports
warnings about unused type variables in type-family instances. A
tpye variable is considered used (i.e. cannot be turned into a wildcard)
when
* it occurs on the RHS of the family instance
e.g. type instance F a b = a -- a is used on the RHS
* it occurs multiple times in the patterns on the LHS
e.g. type instance F a a = Int -- a appears more than once on LHS
* it is one of the instance-decl variables, for associated types
e.g. instance C (a,b) where
type T (a,b) = a
Here the type pattern in the type instance must be the same as that
for the class instance, so
type T (a,_) = a
would be rejected. So we should not complain about an unused variable b
As usual, the warnings are not reported for for type variables with names
beginning with an underscore.
Extra-constraints wild cards are not supported in type/data family
instance declarations.
Relevant tickets: #3699, #10586, #10982 and #11451.
Note [Renaming associated types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Check that the RHS of the decl mentions only type variables
bound on the LHS. For example, this is not ok
class C a b where
type F a x :: *
instance C (p,q) r where
type F (p,q) x = (x, r) -- BAD: mentions 'r'
c.f. Trac #5515
The same thing applies to kind variables, of course (Trac #7938, #9574):
class Funct f where
type Codomain f :: *
instance Funct ('KProxy :: KProxy o) where
type Codomain 'KProxy = NatTr (Proxy :: o -> *)
Here 'o' is mentioned on the RHS of the Codomain function, but
not on the LHS.
All this applies only for *instance* declarations. In *class*
declarations there is no RHS to worry about, and the class variables
can all be in scope (Trac #5862):
class Category (x :: k -> k -> *) where
type Ob x :: k -> Constraint
id :: Ob x a => x a a
(.) :: (Ob x a, Ob x b, Ob x c) => x b c -> x a b -> x a c
Here 'k' is in scope in the kind signature, just like 'x'.
-}
{-
*********************************************************
* *
\subsection{Stand-alone deriving declarations}
* *
*********************************************************
-}
rnSrcDerivDecl :: DerivDecl RdrName -> RnM (DerivDecl Name, FreeVars)
rnSrcDerivDecl (DerivDecl ty overlap)
= do { standalone_deriv_ok <- xoptM LangExt.StandaloneDeriving
; unless standalone_deriv_ok (addErr standaloneDerivErr)
; (ty', fvs) <- rnLHsInstType (text "In a deriving declaration") ty
; return (DerivDecl ty' overlap, fvs) }
standaloneDerivErr :: SDoc
standaloneDerivErr
= hang (text "Illegal standalone deriving declaration")
2 (text "Use StandaloneDeriving to enable this extension")
{-
*********************************************************
* *
\subsection{Rules}
* *
*********************************************************
-}
rnHsRuleDecls :: RuleDecls RdrName -> RnM (RuleDecls Name, FreeVars)
rnHsRuleDecls (HsRules src rules)
= do { (rn_rules,fvs) <- rnList rnHsRuleDecl rules
; return (HsRules src rn_rules,fvs) }
rnHsRuleDecl :: RuleDecl RdrName -> RnM (RuleDecl Name, FreeVars)
rnHsRuleDecl (HsRule rule_name act vars lhs _fv_lhs rhs _fv_rhs)
= do { let rdr_names_w_loc = map get_var vars
; checkDupRdrNames rdr_names_w_loc
; checkShadowedRdrNames rdr_names_w_loc
; names <- newLocalBndrsRn rdr_names_w_loc
; bindHsRuleVars (snd $ unLoc rule_name) vars names $ \ vars' ->
do { (lhs', fv_lhs') <- rnLExpr lhs
; (rhs', fv_rhs') <- rnLExpr rhs
; checkValidRule (snd $ unLoc rule_name) names lhs' fv_lhs'
; return (HsRule rule_name act vars' lhs' fv_lhs' rhs' fv_rhs',
fv_lhs' `plusFV` fv_rhs') } }
where
get_var (L _ (RuleBndrSig v _)) = v
get_var (L _ (RuleBndr v)) = v
bindHsRuleVars :: RuleName -> [LRuleBndr RdrName] -> [Name]
-> ([LRuleBndr Name] -> RnM (a, FreeVars))
-> RnM (a, FreeVars)
bindHsRuleVars rule_name vars names thing_inside
= go vars names $ \ vars' ->
bindLocalNamesFV names (thing_inside vars')
where
doc = RuleCtx rule_name
go (L l (RuleBndr (L loc _)) : vars) (n : ns) thing_inside
= go vars ns $ \ vars' ->
thing_inside (L l (RuleBndr (L loc n)) : vars')
go (L l (RuleBndrSig (L loc _) bsig) : vars) (n : ns) thing_inside
= rnHsSigWcTypeScoped doc bsig $ \ bsig' ->
go vars ns $ \ vars' ->
thing_inside (L l (RuleBndrSig (L loc n) bsig') : vars')
go [] [] thing_inside = thing_inside []
go vars names _ = pprPanic "bindRuleVars" (ppr vars $$ ppr names)
{-
Note [Rule LHS validity checking]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Check the shape of a transformation rule LHS. Currently we only allow
LHSs of the form @(f e1 .. en)@, where @f@ is not one of the
@forall@'d variables.
We used restrict the form of the 'ei' to prevent you writing rules
with LHSs with a complicated desugaring (and hence unlikely to match);
(e.g. a case expression is not allowed: too elaborate.)
But there are legitimate non-trivial args ei, like sections and
lambdas. So it seems simmpler not to check at all, and that is why
check_e is commented out.
-}
checkValidRule :: FastString -> [Name] -> LHsExpr Name -> NameSet -> RnM ()
checkValidRule rule_name ids lhs' fv_lhs'
= do { -- Check for the form of the LHS
case (validRuleLhs ids lhs') of
Nothing -> return ()
Just bad -> failWithTc (badRuleLhsErr rule_name lhs' bad)
-- Check that LHS vars are all bound
; let bad_vars = [var | var <- ids, not (var `elemNameSet` fv_lhs')]
; mapM_ (addErr . badRuleVar rule_name) bad_vars }
validRuleLhs :: [Name] -> LHsExpr Name -> Maybe (HsExpr Name)
-- Nothing => OK
-- Just e => Not ok, and e is the offending sub-expression
validRuleLhs foralls lhs
= checkl lhs
where
checkl (L _ e) = check e
check (OpApp e1 op _ e2) = checkl op `mplus` checkl_e e1 `mplus` checkl_e e2
check (HsApp e1 e2) = checkl e1 `mplus` checkl_e e2
check (HsAppType e _) = checkl e
check (HsVar (L _ v)) | v `notElem` foralls = Nothing
check other = Just other -- Failure
-- Check an argument
checkl_e (L _ _e) = Nothing -- Was (check_e e); see Note [Rule LHS validity checking]
{- Commented out; see Note [Rule LHS validity checking] above
check_e (HsVar v) = Nothing
check_e (HsPar e) = checkl_e e
check_e (HsLit e) = Nothing
check_e (HsOverLit e) = Nothing
check_e (OpApp e1 op _ e2) = checkl_e e1 `mplus` checkl_e op `mplus` checkl_e e2
check_e (HsApp e1 e2) = checkl_e e1 `mplus` checkl_e e2
check_e (NegApp e _) = checkl_e e
check_e (ExplicitList _ es) = checkl_es es
check_e other = Just other -- Fails
checkl_es es = foldr (mplus . checkl_e) Nothing es
-}
badRuleVar :: FastString -> Name -> SDoc
badRuleVar name var
= sep [text "Rule" <+> doubleQuotes (ftext name) <> colon,
text "Forall'd variable" <+> quotes (ppr var) <+>
text "does not appear on left hand side"]
badRuleLhsErr :: FastString -> LHsExpr Name -> HsExpr Name -> SDoc
badRuleLhsErr name lhs bad_e
= sep [text "Rule" <+> pprRuleName name <> colon,
nest 4 (vcat [err,
text "in left-hand side:" <+> ppr lhs])]
$$
text "LHS must be of form (f e1 .. en) where f is not forall'd"
where
err = case bad_e of
HsUnboundVar uv -> text "Not in scope:" <+> ppr uv
_ -> text "Illegal expression:" <+> ppr bad_e
{-
*********************************************************
* *
\subsection{Vectorisation declarations}
* *
*********************************************************
-}
rnHsVectDecl :: VectDecl RdrName -> RnM (VectDecl Name, FreeVars)
-- FIXME: For the moment, the right-hand side is restricted to be a variable as we cannot properly
-- typecheck a complex right-hand side without invoking 'vectType' from the vectoriser.
rnHsVectDecl (HsVect s var rhs@(L _ (HsVar _)))
= do { var' <- lookupLocatedOccRn var
; (rhs', fv_rhs) <- rnLExpr rhs
; return (HsVect s var' rhs', fv_rhs `addOneFV` unLoc var')
}
rnHsVectDecl (HsVect _ _var _rhs)
= failWith $ vcat
[ text "IMPLEMENTATION RESTRICTION: right-hand side of a VECTORISE pragma"
, text "must be an identifier"
]
rnHsVectDecl (HsNoVect s var)
= do { var' <- lookupLocatedTopBndrRn var -- only applies to local (not imported) names
; return (HsNoVect s var', unitFV (unLoc var'))
}
rnHsVectDecl (HsVectTypeIn s isScalar tycon Nothing)
= do { tycon' <- lookupLocatedOccRn tycon
; return (HsVectTypeIn s isScalar tycon' Nothing, unitFV (unLoc tycon'))
}
rnHsVectDecl (HsVectTypeIn s isScalar tycon (Just rhs_tycon))
= do { tycon' <- lookupLocatedOccRn tycon
; rhs_tycon' <- lookupLocatedOccRn rhs_tycon
; return ( HsVectTypeIn s isScalar tycon' (Just rhs_tycon')
, mkFVs [unLoc tycon', unLoc rhs_tycon'])
}
rnHsVectDecl (HsVectTypeOut _ _ _)
= panic "RnSource.rnHsVectDecl: Unexpected 'HsVectTypeOut'"
rnHsVectDecl (HsVectClassIn s cls)
= do { cls' <- lookupLocatedOccRn cls
; return (HsVectClassIn s cls', unitFV (unLoc cls'))
}
rnHsVectDecl (HsVectClassOut _)
= panic "RnSource.rnHsVectDecl: Unexpected 'HsVectClassOut'"
rnHsVectDecl (HsVectInstIn instTy)
= do { (instTy', fvs) <- rnLHsInstType (text "a VECTORISE pragma") instTy
; return (HsVectInstIn instTy', fvs)
}
rnHsVectDecl (HsVectInstOut _)
= panic "RnSource.rnHsVectDecl: Unexpected 'HsVectInstOut'"
{- **************************************************************
* *
Renaming type, class, instance and role declarations
* *
*****************************************************************
@rnTyDecl@ uses the `global name function' to create a new type
declaration in which local names have been replaced by their original
names, reporting any unknown names.
Renaming type variables is a pain. Because they now contain uniques,
it is necessary to pass in an association list which maps a parsed
tyvar to its @Name@ representation.
In some cases (type signatures of values),
it is even necessary to go over the type first
in order to get the set of tyvars used by it, make an assoc list,
and then go over it again to rename the tyvars!
However, we can also do some scoping checks at the same time.
Note [Dependency analysis of type, class, and instance decls]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A TyClGroup represents a strongly connected components of
type/class/instance decls, together with the role annotations for the
type/class declarations. The renamer uses strongly connected
comoponent analysis to build these groups. We do this for a number of
reasons:
* Improve kind error messages. Consider
data T f a = MkT f a
data S f a = MkS f (T f a)
This has a kind error, but the error message is better if you
check T first, (fixing its kind) and *then* S. If you do kind
inference together, you might get an error reported in S, which
is jolly confusing. See Trac #4875
* Increase kind polymorphism. See TcTyClsDecls
Note [Grouping of type and class declarations]
Why do the instance declarations participate? At least two reasons
* Consider (Trac #11348)
type family F a
type instance F Int = Bool
data R = MkR (F Int)
type Foo = 'MkR 'True
For Foo to kind-check we need to know that (F Int) ~ Bool. But we won't
know that unless we've looked at the type instance declaration for F
before kind-checking Foo.
* Another example is this (Trac #3990).
data family Complex a
data instance Complex Double = CD {-# UNPACK #-} !Double
{-# UNPACK #-} !Double
data T = T {-# UNPACK #-} !(Complex Double)
Here, to generate the right kind of unpacked implementation for T,
we must have access to the 'data instance' declaration.
* Things become more complicated when we introduce transitive
dependencies through imported definitions, like in this scenario:
A.hs
type family Closed (t :: Type) :: Type where
Closed t = Open t
type family Open (t :: Type) :: Type
B.hs
data Q where
Q :: Closed Bool -> Q
type instance Open Int = Bool
type S = 'Q 'True
Somehow, we must ensure that the instance Open Int = Bool is checked before
the type synonym S. While we know that S depends upon 'Q depends upon Closed,
we have no idea that Closed depends upon Open!
To accomodate for these situations, we ensure that an instance is checked
before every @TyClDecl@ on which it does not depend. That's to say, instances
are checked as early as possible in @tcTyAndClassDecls@.
------------------------------------
So much for WHY. What about HOW? It's pretty easy:
(1) Rename the type/class, instance, and role declarations
individually
(2) Do strongly-connected component analysis of the type/class decls,
We'll make a TyClGroup for each SCC
In this step we treat a reference to a (promoted) data constructor
K as a dependency on its parent type. Thus
data T = K1 | K2
data S = MkS (Proxy 'K1)
Here S depends on 'K1 and hence on its parent T.
In this step we ignore instances; see
Note [No dependencies on data instances]
(3) Attach roles to the appropriate SCC
(4) Attach instances to the appropriate SCC.
We add an instance decl to SCC when:
all its free types/classes are bound in this SCC or earlier ones
(5) We make an initial TyClGroup, with empty group_tyclds, for any
(orphan) instances that affect only imported types/classes
Steps (3) and (4) are done by the (mapAccumL mk_group) call.
Note [No dependencies on data instances]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this
data family D a
data instance D Int = D1
data S = MkS (Proxy 'D1)
Here the declaration of S depends on the /data instance/ declaration
for 'D Int'. That makes things a lot more complicated, especially
if the data instance is an assocaited type of an enclosing class instance.
(And the class instance might have several assocatiated type instances
with different dependency structure!)
Ugh. For now we simply don't allow promotion of data constructors for
data instances. See Note [AFamDataCon: not promoting data family
constructors] in TcEnv
-}
rnTyClDecls :: [TyClGroup RdrName]
-> RnM ([TyClGroup Name], FreeVars)
-- Rename the declarations and do dependency analysis on them
rnTyClDecls tycl_ds
= do { -- Rename the type/class, instance, and role declaraations
tycls_w_fvs <- mapM (wrapLocFstM rnTyClDecl)
(tyClGroupTyClDecls tycl_ds)
; let tc_names = mkNameSet (map (tcdName . unLoc . fst) tycls_w_fvs)
; instds_w_fvs <- mapM (wrapLocFstM rnSrcInstDecl) (tyClGroupInstDecls tycl_ds)
; role_annots <- rnRoleAnnots tc_names (tyClGroupRoleDecls tycl_ds)
; tycls_w_fvs <- addBootDeps tycls_w_fvs
-- TBD must add_boot_deps to instds_w_fvs?
-- Do SCC analysis on the type/class decls
; rdr_env <- getGlobalRdrEnv
; let tycl_sccs = depAnalTyClDecls rdr_env tycls_w_fvs
role_annot_env = mkRoleAnnotEnv role_annots
inst_ds_map = mkInstDeclFreeVarsMap rdr_env tc_names instds_w_fvs
(init_inst_ds, rest_inst_ds) = getInsts [] inst_ds_map
first_group
| null init_inst_ds = []
| otherwise = [TyClGroup { group_tyclds = []
, group_roles = []
, group_instds = init_inst_ds }]
((final_inst_ds, orphan_roles), groups)
= mapAccumL mk_group (rest_inst_ds, role_annot_env) tycl_sccs
all_fvs = plusFV (foldr (plusFV . snd) emptyFVs tycls_w_fvs)
(foldr (plusFV . snd) emptyFVs instds_w_fvs)
all_groups = first_group ++ groups
; ASSERT2( null final_inst_ds, ppr instds_w_fvs $$ ppr inst_ds_map
$$ ppr (flattenSCCs tycl_sccs) $$ ppr final_inst_ds )
mapM_ orphanRoleAnnotErr (nameEnvElts orphan_roles)
; traceRn (text "rnTycl dependency analysis made groups" $$ ppr all_groups)
; return (all_groups, all_fvs) }
where
mk_group :: (InstDeclFreeVarsMap, RoleAnnotEnv)
-> SCC (LTyClDecl Name)
-> ( (InstDeclFreeVarsMap, RoleAnnotEnv)
, TyClGroup Name )
mk_group (inst_map, role_env) scc
= ((inst_map', role_env'), group)
where
tycl_ds = flattenSCC scc
bndrs = map (tcdName . unLoc) tycl_ds
(inst_ds, inst_map') = getInsts bndrs inst_map
(roles, role_env') = getRoleAnnots bndrs role_env
group = TyClGroup { group_tyclds = tycl_ds
, group_roles = roles
, group_instds = inst_ds }
depAnalTyClDecls :: GlobalRdrEnv
-> [(LTyClDecl Name, FreeVars)]
-> [SCC (LTyClDecl Name)]
-- See Note [Dependency analysis of type, class, and instance decls]
depAnalTyClDecls rdr_env ds_w_fvs
= stronglyConnCompFromEdgedVerticesUniq edges
where
edges = [ (d, tcdName (unLoc d), map (getParent rdr_env) (nonDetEltsUFM fvs))
| (d, fvs) <- ds_w_fvs ]
-- It's OK to use nonDetEltsUFM here as
-- stronglyConnCompFromEdgedVertices is still deterministic
-- even if the edges are in nondeterministic order as explained
-- in Note [Deterministic SCC] in Digraph.
toParents :: GlobalRdrEnv -> NameSet -> NameSet
toParents rdr_env ns
= nonDetFoldUFM add emptyNameSet ns
-- It's OK to use nonDetFoldUFM because we immediately forget the
-- ordering by creating a set
where
add n s = extendNameSet s (getParent rdr_env n)
getParent :: GlobalRdrEnv -> Name -> Name
getParent rdr_env n
= case lookupGRE_Name rdr_env n of
Just gre -> case gre_par gre of
ParentIs { par_is = p } -> p
FldParent { par_is = p } -> p
_ -> n
Nothing -> n
{- Note [Extra dependencies from .hs-boot files]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This is a long story, so buckle in.
**Dependencies via hs-boot files are not obvious.** Consider the following case:
A.hs-boot
module A where
data A1
B.hs
module B where
import {-# SOURCE #-} A
type B1 = A1
A.hs
module A where
import B
data A2 = MkA2 B1
data A1 = MkA1 A2
Here A2 is really recursive (via B1), but we won't see that easily when
doing dependency analysis when compiling A.hs. When we look at A2,
we see that its free variables are simply B1, but without (recursively) digging
into the definition of B1 will we see that it actually refers to A1 via an
hs-boot file.
**Recursive declarations, even those broken by an hs-boot file, need to
be type-checked together.** Whenever we refer to a declaration via
an hs-boot file, we must be careful not to force the TyThing too early:
ala Note [Tying the knot] if we force the TyThing before we have
defined it ourselves in the local type environment, GHC will error.
Conservatively, then, it would make sense that we to typecheck A1
and A2 from the previous example together, because the two types are
truly mutually recursive through B1.
If we are being clever, we might observe that while kind-checking
A2, we don't actually need to force the TyThing for A1: B1
independently records its kind, so there is no need to go "deeper".
But then we are in an uncomfortable situation where we have
constructed a TyThing for A2 before we have checked A1, and we
have to be absolutely certain we don't force it too deeply until
we get around to kind checking A1, which could be for a very long
time.
Indeed, with datatype promotion, we may very well need to look
at the type of MkA2 before we have kind-checked A1: consider,
data T = MkT (Proxy 'MkA2)
To promote MkA2, we need to lift its type to the kind level.
We never tested this, but it seems likely A1 would get poked
at this point.
**Here's what we do instead.** So it is expedient for us to
make sure A1 and A2 are kind checked together in a loop.
To ensure that our dependency analysis can catch this,
we add a dependency:
- from every local declaration
- to everything that comes from this module's .hs-boot file
(this is gotten from sb_tcs in the SelfBootInfo).
In this case, we'll add an edges
- from A1 to A2 (but that edge is there already)
- from A2 to A1 (which is new)
Well, not quite *every* declaration. Imagine module A
above had another datatype declaration:
data A3 = A3 Int
Even though A3 has a dependency (on Int), all its dependencies are from things
that live on other packages. Since we don't have mutual dependencies across
packages, it is safe not to add the dependencies on the .hs-boot stuff to A2.
Hence function nameIsHomePackageImport.
Note that this is fairly conservative: it essentially implies that
EVERY type declaration in this modules hs-boot file will be kind-checked
together in one giant loop (and furthermore makes every other type
in the module depend on this loop). This is perhaps less than ideal, because
the larger a recursive group, the less polymorphism available (we
cannot infer a type to be polymorphically instantiated while we
are inferring its kind), but no one has hollered about this (yet!)
-}
addBootDeps :: [(LTyClDecl Name, FreeVars)] -> RnM [(LTyClDecl Name, FreeVars)]
-- See Note [Extra dependencies from .hs-boot files]
addBootDeps ds_w_fvs
= do { tcg_env <- getGblEnv
; let this_mod = tcg_mod tcg_env
boot_info = tcg_self_boot tcg_env
add_boot_deps :: [(LTyClDecl Name, FreeVars)] -> [(LTyClDecl Name, FreeVars)]
add_boot_deps ds_w_fvs
= case boot_info of
SelfBoot { sb_tcs = tcs } | not (isEmptyNameSet tcs)
-> map (add_one tcs) ds_w_fvs
_ -> ds_w_fvs
add_one :: NameSet -> (LTyClDecl Name, FreeVars) -> (LTyClDecl Name, FreeVars)
add_one tcs pr@(decl,fvs)
| has_local_imports fvs = (decl, fvs `plusFV` tcs)
| otherwise = pr
has_local_imports fvs
= nameSetAny (nameIsHomePackageImport this_mod) fvs
; return (add_boot_deps ds_w_fvs) }
{- ******************************************************
* *
Role annotations
* *
****************************************************** -}
-- | Renames role annotations, returning them as the values in a NameEnv
-- and checks for duplicate role annotations.
-- It is quite convenient to do both of these in the same place.
-- See also Note [Role annotations in the renamer]
rnRoleAnnots :: NameSet
-> [LRoleAnnotDecl RdrName]
-> RnM [LRoleAnnotDecl Name]
rnRoleAnnots tc_names role_annots
= do { -- Check for duplicates *before* renaming, to avoid
-- lumping together all the unboundNames
let (no_dups, dup_annots) = removeDups role_annots_cmp role_annots
role_annots_cmp (L _ annot1) (L _ annot2)
= roleAnnotDeclName annot1 `compare` roleAnnotDeclName annot2
; mapM_ dupRoleAnnotErr dup_annots
; mapM (wrapLocM rn_role_annot1) no_dups }
where
rn_role_annot1 (RoleAnnotDecl tycon roles)
= do { -- the name is an *occurrence*, but look it up only in the
-- decls defined in this group (see #10263)
tycon' <- lookupSigCtxtOccRn (RoleAnnotCtxt tc_names)
(text "role annotation")
tycon
; return $ RoleAnnotDecl tycon' roles }
dupRoleAnnotErr :: [LRoleAnnotDecl RdrName] -> RnM ()
dupRoleAnnotErr [] = panic "dupRoleAnnotErr"
dupRoleAnnotErr list
= addErrAt loc $
hang (text "Duplicate role annotations for" <+>
quotes (ppr $ roleAnnotDeclName first_decl) <> colon)
2 (vcat $ map pp_role_annot sorted_list)
where
sorted_list = sortBy cmp_annot list
(L loc first_decl : _) = sorted_list
pp_role_annot (L loc decl) = hang (ppr decl)
4 (text "-- written at" <+> ppr loc)
cmp_annot (L loc1 _) (L loc2 _) = loc1 `compare` loc2
orphanRoleAnnotErr :: LRoleAnnotDecl Name -> RnM ()
orphanRoleAnnotErr (L loc decl)
= addErrAt loc $
hang (text "Role annotation for a type previously declared:")
2 (ppr decl) $$
parens (text "The role annotation must be given where" <+>
quotes (ppr $ roleAnnotDeclName decl) <+>
text "is declared.")
{- Note [Role annotations in the renamer]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We must ensure that a type's role annotation is put in the same group as the
proper type declaration. This is because role annotations are needed during
type-checking when creating the type's TyCon. So, rnRoleAnnots builds a
NameEnv (LRoleAnnotDecl Name) that maps a name to a role annotation for that
type, if any. Then, this map can be used to add the role annotations to the
groups after dependency analysis.
This process checks for duplicate role annotations, where we must be careful
to do the check *before* renaming to avoid calling all unbound names duplicates
of one another.
The renaming process, as usual, might identify and report errors for unbound
names. We exclude the annotations for unbound names in the annotation
environment to avoid spurious errors for orphaned annotations.
We then (in rnTyClDecls) do a check for orphan role annotations (role
annotations without an accompanying type decl). The check works by folding
over components (of type [[Either (TyClDecl Name) (InstDecl Name)]]), selecting
out the relevant role declarations for each group, as well as diminishing the
annotation environment. After the fold is complete, anything left over in the
name environment must be an orphan, and errors are generated.
An earlier version of this algorithm short-cut the orphan check by renaming
only with names declared in this module. But, this check is insufficient in
the case of staged module compilation (Template Haskell, GHCi).
See #8485. With the new lookup process (which includes types declared in other
modules), we get better error messages, too.
-}
{- ******************************************************
* *
Dependency info for instances
* *
****************************************************** -}
----------------------------------------------------------
-- | 'InstDeclFreeVarsMap is an association of an
-- @InstDecl@ with @FreeVars@. The @FreeVars@ are
-- the tycon names that are both
-- a) free in the instance declaration
-- b) bound by this group of type/class/instance decls
type InstDeclFreeVarsMap = [(LInstDecl Name, FreeVars)]
-- | Construct an @InstDeclFreeVarsMap@ by eliminating any @Name@s from the
-- @FreeVars@ which are *not* the binders of a @TyClDecl@.
mkInstDeclFreeVarsMap :: GlobalRdrEnv
-> NameSet
-> [(LInstDecl Name, FreeVars)]
-> InstDeclFreeVarsMap
mkInstDeclFreeVarsMap rdr_env tycl_bndrs inst_ds_fvs
= [ (inst_decl, toParents rdr_env fvs `intersectFVs` tycl_bndrs)
| (inst_decl, fvs) <- inst_ds_fvs ]
-- | Get the @LInstDecl@s which have empty @FreeVars@ sets, and the
-- @InstDeclFreeVarsMap@ with these entries removed.
-- We call (getInsts tcs instd_map) when we've completed the declarations
-- for 'tcs'. The call returns (inst_decls, instd_map'), where
-- inst_decls are the instance declarations all of
-- whose free vars are now defined
-- instd_map' is the inst-decl map with 'tcs' removed from
-- the free-var set
getInsts :: [Name] -> InstDeclFreeVarsMap -> ([LInstDecl Name], InstDeclFreeVarsMap)
getInsts bndrs inst_decl_map
= partitionWith pick_me inst_decl_map
where
pick_me :: (LInstDecl Name, FreeVars)
-> Either (LInstDecl Name) (LInstDecl Name, FreeVars)
pick_me (decl, fvs)
| isEmptyNameSet depleted_fvs = Left decl
| otherwise = Right (decl, depleted_fvs)
where
depleted_fvs = delFVs bndrs fvs
{- ******************************************************
* *
Renaming a type or class declaration
* *
****************************************************** -}
rnTyClDecl :: TyClDecl RdrName
-> RnM (TyClDecl Name, FreeVars)
-- All flavours of type family declarations ("type family", "newtype family",
-- and "data family"), both top level and (for an associated type)
-- in a class decl
rnTyClDecl (FamDecl { tcdFam = decl })
= do { (decl', fvs) <- rnFamDecl Nothing decl
; return (FamDecl decl', fvs) }
rnTyClDecl (SynDecl { tcdLName = tycon, tcdTyVars = tyvars, tcdRhs = rhs })
= do { tycon' <- lookupLocatedTopBndrRn tycon
; kvs <- freeKiTyVarsKindVars <$> extractHsTyRdrTyVars rhs
; let doc = TySynCtx tycon
; traceRn (text "rntycl-ty" <+> ppr tycon <+> ppr kvs)
; ((tyvars', rhs'), fvs) <- bindHsQTyVars doc Nothing Nothing kvs tyvars $
\ tyvars' _ ->
do { (rhs', fvs) <- rnTySyn doc rhs
; return ((tyvars', rhs'), fvs) }
; return (SynDecl { tcdLName = tycon', tcdTyVars = tyvars'
, tcdRhs = rhs', tcdFVs = fvs }, fvs) }
-- "data", "newtype" declarations
-- both top level and (for an associated type) in an instance decl
rnTyClDecl (DataDecl { tcdLName = tycon, tcdTyVars = tyvars, tcdDataDefn = defn })
= do { tycon' <- lookupLocatedTopBndrRn tycon
; kvs <- extractDataDefnKindVars defn
; let doc = TyDataCtx tycon
; traceRn (text "rntycl-data" <+> ppr tycon <+> ppr kvs)
; ((tyvars', defn', no_kvs), fvs)
<- bindHsQTyVars doc Nothing Nothing kvs tyvars $ \ tyvars' dep_vars ->
do { ((defn', kind_sig_fvs), fvs) <- rnDataDefn doc defn
; let sig_tvs = filterNameSet isTyVarName kind_sig_fvs
unbound_sig_tvs = sig_tvs `minusNameSet` dep_vars
; return ((tyvars', defn', isEmptyNameSet unbound_sig_tvs), fvs) }
-- See Note [Complete user-supplied kind signatures] in HsDecls
; typeintype <- xoptM LangExt.TypeInType
; let cusk = hsTvbAllKinded tyvars' &&
(not typeintype || no_kvs)
; return (DataDecl { tcdLName = tycon', tcdTyVars = tyvars'
, tcdDataDefn = defn', tcdDataCusk = cusk
, tcdFVs = fvs }, fvs) }
rnTyClDecl (ClassDecl { tcdCtxt = context, tcdLName = lcls,
tcdTyVars = tyvars, tcdFDs = fds, tcdSigs = sigs,
tcdMeths = mbinds, tcdATs = ats, tcdATDefs = at_defs,
tcdDocs = docs})
= do { lcls' <- lookupLocatedTopBndrRn lcls
; let cls' = unLoc lcls'
kvs = [] -- No scoped kind vars except those in
-- kind signatures on the tyvars
-- Tyvars scope over superclass context and method signatures
; ((tyvars', context', fds', ats'), stuff_fvs)
<- bindHsQTyVars cls_doc Nothing Nothing kvs tyvars $ \ tyvars' _ -> do
-- Checks for distinct tyvars
{ (context', cxt_fvs) <- rnContext cls_doc context
; fds' <- rnFds fds
-- The fundeps have no free variables
; (ats', fv_ats) <- rnATDecls cls' ats
; let fvs = cxt_fvs `plusFV`
fv_ats
; return ((tyvars', context', fds', ats'), fvs) }
; (at_defs', fv_at_defs) <- rnList (rnTyFamDefltEqn cls') at_defs
-- No need to check for duplicate associated type decls
-- since that is done by RnNames.extendGlobalRdrEnvRn
-- Check the signatures
-- First process the class op sigs (op_sigs), then the fixity sigs (non_op_sigs).
; let sig_rdr_names_w_locs = [op | L _ (ClassOpSig False ops _) <- sigs
, op <- ops]
; checkDupRdrNames sig_rdr_names_w_locs
-- Typechecker is responsible for checking that we only
-- give default-method bindings for things in this class.
-- The renamer *could* check this for class decls, but can't
-- for instance decls.
-- The newLocals call is tiresome: given a generic class decl
-- class C a where
-- op :: a -> a
-- op {| x+y |} (Inl a) = ...
-- op {| x+y |} (Inr b) = ...
-- op {| a*b |} (a*b) = ...
-- we want to name both "x" tyvars with the same unique, so that they are
-- easy to group together in the typechecker.
; (mbinds', sigs', meth_fvs)
<- rnMethodBinds True cls' (hsAllLTyVarNames tyvars') mbinds sigs
-- No need to check for duplicate method signatures
-- since that is done by RnNames.extendGlobalRdrEnvRn
-- and the methods are already in scope
-- Haddock docs
; docs' <- mapM (wrapLocM rnDocDecl) docs
; let all_fvs = meth_fvs `plusFV` stuff_fvs `plusFV` fv_at_defs
; return (ClassDecl { tcdCtxt = context', tcdLName = lcls',
tcdTyVars = tyvars', tcdFDs = fds', tcdSigs = sigs',
tcdMeths = mbinds', tcdATs = ats', tcdATDefs = at_defs',
tcdDocs = docs', tcdFVs = all_fvs },
all_fvs ) }
where
cls_doc = ClassDeclCtx lcls
-- "type" and "type instance" declarations
rnTySyn :: HsDocContext -> LHsType RdrName -> RnM (LHsType Name, FreeVars)
rnTySyn doc rhs = rnLHsType doc rhs
rnDataDefn :: HsDocContext -> HsDataDefn RdrName
-> RnM ((HsDataDefn Name, NameSet), FreeVars)
-- the NameSet includes all Names free in the kind signature
-- See Note [Complete user-supplied kind signatures]
rnDataDefn doc (HsDataDefn { dd_ND = new_or_data, dd_cType = cType
, dd_ctxt = context, dd_cons = condecls
, dd_kindSig = m_sig, dd_derivs = derivs })
= do { checkTc (h98_style || null (unLoc context))
(badGadtStupidTheta doc)
; (m_sig', sig_fvs) <- case m_sig of
Just sig -> first Just <$> rnLHsKind doc sig
Nothing -> return (Nothing, emptyFVs)
; (context', fvs1) <- rnContext doc context
; (derivs', fvs3) <- rn_derivs derivs
-- For the constructor declarations, drop the LocalRdrEnv
-- in the GADT case, where the type variables in the declaration
-- do not scope over the constructor signatures
-- data T a where { T1 :: forall b. b-> b }
; let { zap_lcl_env | h98_style = \ thing -> thing
| otherwise = setLocalRdrEnv emptyLocalRdrEnv }
; (condecls', con_fvs) <- zap_lcl_env $ rnConDecls condecls
-- No need to check for duplicate constructor decls
-- since that is done by RnNames.extendGlobalRdrEnvRn
; let all_fvs = fvs1 `plusFV` fvs3 `plusFV`
con_fvs `plusFV` sig_fvs
; return (( HsDataDefn { dd_ND = new_or_data, dd_cType = cType
, dd_ctxt = context', dd_kindSig = m_sig'
, dd_cons = condecls'
, dd_derivs = derivs' }
, sig_fvs )
, all_fvs )
}
where
h98_style = case condecls of -- Note [Stupid theta]
L _ (ConDeclGADT {}) : _ -> False
_ -> True
rn_derivs Nothing
= return (Nothing, emptyFVs)
rn_derivs (Just (L loc ds))
= do { (ds', fvs) <- mapFvRn (rnHsSigType doc) ds
; return (Just (L loc ds'), fvs) }
badGadtStupidTheta :: HsDocContext -> SDoc
badGadtStupidTheta _
= vcat [text "No context is allowed on a GADT-style data declaration",
text "(You can put a context on each constructor, though.)"]
rnFamDecl :: Maybe Name -- Just cls => this FamilyDecl is nested
-- inside an *class decl* for cls
-- used for associated types
-> FamilyDecl RdrName
-> RnM (FamilyDecl Name, FreeVars)
rnFamDecl mb_cls (FamilyDecl { fdLName = tycon, fdTyVars = tyvars
, fdInfo = info, fdResultSig = res_sig
, fdInjectivityAnn = injectivity })
= do { tycon' <- lookupLocatedTopBndrRn tycon
; kvs <- extractRdrKindSigVars res_sig
; ((tyvars', res_sig', injectivity'), fv1) <-
bindHsQTyVars doc Nothing mb_cls kvs tyvars $
\ tyvars'@(HsQTvs { hsq_implicit = rn_kvs }) _ ->
do { let rn_sig = rnFamResultSig doc rn_kvs
; (res_sig', fv_kind) <- wrapLocFstM rn_sig res_sig
; injectivity' <- traverse (rnInjectivityAnn tyvars' res_sig')
injectivity
; return ( (tyvars', res_sig', injectivity') , fv_kind ) }
; (info', fv2) <- rn_info info
; return (FamilyDecl { fdLName = tycon', fdTyVars = tyvars'
, fdInfo = info', fdResultSig = res_sig'
, fdInjectivityAnn = injectivity' }
, fv1 `plusFV` fv2) }
where
doc = TyFamilyCtx tycon
----------------------
rn_info (ClosedTypeFamily (Just eqns))
= do { (eqns', fvs) <- rnList (rnTyFamInstEqn Nothing) eqns
-- no class context,
; return (ClosedTypeFamily (Just eqns'), fvs) }
rn_info (ClosedTypeFamily Nothing)
= return (ClosedTypeFamily Nothing, emptyFVs)
rn_info OpenTypeFamily = return (OpenTypeFamily, emptyFVs)
rn_info DataFamily = return (DataFamily, emptyFVs)
rnFamResultSig :: HsDocContext
-> [Name] -- kind variables already in scope
-> FamilyResultSig RdrName
-> RnM (FamilyResultSig Name, FreeVars)
rnFamResultSig _ _ NoSig
= return (NoSig, emptyFVs)
rnFamResultSig doc _ (KindSig kind)
= do { (rndKind, ftvs) <- rnLHsKind doc kind
; return (KindSig rndKind, ftvs) }
rnFamResultSig doc kv_names (TyVarSig tvbndr)
= do { -- `TyVarSig` tells us that user named the result of a type family by
-- writing `= tyvar` or `= (tyvar :: kind)`. In such case we want to
-- be sure that the supplied result name is not identical to an
-- already in-scope type variable from an enclosing class.
--
-- Example of disallowed declaration:
-- class C a b where
-- type F b = a | a -> b
rdr_env <- getLocalRdrEnv
; let resName = hsLTyVarName tvbndr
; when (resName `elemLocalRdrEnv` rdr_env) $
addErrAt (getLoc tvbndr) $
(hsep [ text "Type variable", quotes (ppr resName) <> comma
, text "naming a type family result,"
] $$
text "shadows an already bound type variable")
; bindLHsTyVarBndr doc Nothing -- this might be a lie, but it's used for
-- scoping checks that are irrelevant here
(mkNameSet kv_names) emptyNameSet
-- use of emptyNameSet here avoids
-- redundant duplicate errors
tvbndr $ \ _ _ tvbndr' ->
return (TyVarSig tvbndr', unitFV (hsLTyVarName tvbndr')) }
-- Note [Renaming injectivity annotation]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- During renaming of injectivity annotation we have to make several checks to
-- make sure that it is well-formed. At the moment injectivity annotation
-- consists of a single injectivity condition, so the terms "injectivity
-- annotation" and "injectivity condition" might be used interchangeably. See
-- Note [Injectivity annotation] for a detailed discussion of currently allowed
-- injectivity annotations.
--
-- Checking LHS is simple because the only type variable allowed on the LHS of
-- injectivity condition is the variable naming the result in type family head.
-- Example of disallowed annotation:
--
-- type family Foo a b = r | b -> a
--
-- Verifying RHS of injectivity consists of checking that:
--
-- 1. only variables defined in type family head appear on the RHS (kind
-- variables are also allowed). Example of disallowed annotation:
--
-- type family Foo a = r | r -> b
--
-- 2. for associated types the result variable does not shadow any of type
-- class variables. Example of disallowed annotation:
--
-- class Foo a b where
-- type F a = b | b -> a
--
-- Breaking any of these assumptions results in an error.
-- | Rename injectivity annotation. Note that injectivity annotation is just the
-- part after the "|". Everything that appears before it is renamed in
-- rnFamDecl.
rnInjectivityAnn :: LHsQTyVars Name -- ^ Type variables declared in
-- type family head
-> LFamilyResultSig Name -- ^ Result signature
-> LInjectivityAnn RdrName -- ^ Injectivity annotation
-> RnM (LInjectivityAnn Name)
rnInjectivityAnn tvBndrs (L _ (TyVarSig resTv))
(L srcSpan (InjectivityAnn injFrom injTo))
= do
{ (injDecl'@(L _ (InjectivityAnn injFrom' injTo')), noRnErrors)
<- askNoErrs $
bindLocalNames [hsLTyVarName resTv] $
-- The return type variable scopes over the injectivity annotation
-- e.g. type family F a = (r::*) | r -> a
do { injFrom' <- rnLTyVar injFrom
; injTo' <- mapM rnLTyVar injTo
; return $ L srcSpan (InjectivityAnn injFrom' injTo') }
; let tvNames = Set.fromList $ hsAllLTyVarNames tvBndrs
resName = hsLTyVarName resTv
-- See Note [Renaming injectivity annotation]
lhsValid = EQ == (stableNameCmp resName (unLoc injFrom'))
rhsValid = Set.fromList (map unLoc injTo') `Set.difference` tvNames
-- if renaming of type variables ended with errors (eg. there were
-- not-in-scope variables) don't check the validity of injectivity
-- annotation. This gives better error messages.
; when (noRnErrors && not lhsValid) $
addErrAt (getLoc injFrom)
( vcat [ text $ "Incorrect type variable on the LHS of "
++ "injectivity condition"
, nest 5
( vcat [ text "Expected :" <+> ppr resName
, text "Actual :" <+> ppr injFrom ])])
; when (noRnErrors && not (Set.null rhsValid)) $
do { let errorVars = Set.toList rhsValid
; addErrAt srcSpan $ ( hsep
[ text "Unknown type variable" <> plural errorVars
, text "on the RHS of injectivity condition:"
, interpp'SP errorVars ] ) }
; return injDecl' }
-- We can only hit this case when the user writes injectivity annotation without
-- naming the result:
--
-- type family F a | result -> a
-- type family F a :: * | result -> a
--
-- So we rename injectivity annotation like we normally would except that
-- this time we expect "result" to be reported not in scope by rnLTyVar.
rnInjectivityAnn _ _ (L srcSpan (InjectivityAnn injFrom injTo)) =
setSrcSpan srcSpan $ do
(injDecl', _) <- askNoErrs $ do
injFrom' <- rnLTyVar injFrom
injTo' <- mapM rnLTyVar injTo
return $ L srcSpan (InjectivityAnn injFrom' injTo')
return $ injDecl'
{-
Note [Stupid theta]
~~~~~~~~~~~~~~~~~~~
Trac #3850 complains about a regression wrt 6.10 for
data Show a => T a
There is no reason not to allow the stupid theta if there are no data
constructors. It's still stupid, but does no harm, and I don't want
to cause programs to break unnecessarily (notably HList). So if there
are no data constructors we allow h98_style = True
-}
{- *****************************************************
* *
Support code for type/data declarations
* *
***************************************************** -}
---------------
badAssocRhs :: [Name] -> RnM ()
badAssocRhs ns
= addErr (hang (text "The RHS of an associated type declaration mentions"
<+> pprWithCommas (quotes . ppr) ns)
2 (text "All such variables must be bound on the LHS"))
-----------------
rnConDecls :: [LConDecl RdrName] -> RnM ([LConDecl Name], FreeVars)
rnConDecls = mapFvRn (wrapLocFstM rnConDecl)
rnConDecl :: ConDecl RdrName -> RnM (ConDecl Name, FreeVars)
rnConDecl decl@(ConDeclH98 { con_name = name, con_qvars = qtvs
, con_cxt = mcxt, con_details = details
, con_doc = mb_doc })
= do { _ <- addLocM checkConName name
; new_name <- lookupLocatedTopBndrRn name
; let doc = ConDeclCtx [new_name]
; mb_doc' <- rnMbLHsDoc mb_doc
; (kvs, qtvs') <- get_con_qtvs (hsConDeclArgTys details)
; bindHsQTyVars doc (Just $ inHsDocContext doc) Nothing kvs qtvs' $
\new_tyvars _ -> do
{ (new_context, fvs1) <- case mcxt of
Nothing -> return (Nothing,emptyFVs)
Just lcxt -> do { (lctx',fvs) <- rnContext doc lcxt
; return (Just lctx',fvs) }
; (new_details, fvs2) <- rnConDeclDetails (unLoc new_name) doc details
; let (new_details',fvs3) = (new_details,emptyFVs)
; traceRn (text "rnConDecl" <+> ppr name <+> vcat
[ text "free_kvs:" <+> ppr kvs
, text "qtvs:" <+> ppr qtvs
, text "qtvs':" <+> ppr qtvs' ])
; let all_fvs = fvs1 `plusFV` fvs2 `plusFV` fvs3
new_tyvars' = case qtvs of
Nothing -> Nothing
Just _ -> Just new_tyvars
; return (decl { con_name = new_name, con_qvars = new_tyvars'
, con_cxt = new_context, con_details = new_details'
, con_doc = mb_doc' },
all_fvs) }}
where
cxt = maybe [] unLoc mcxt
get_rdr_tvs tys = extractHsTysRdrTyVars (cxt ++ tys)
get_con_qtvs :: [LHsType RdrName]
-> RnM ([Located RdrName], LHsQTyVars RdrName)
get_con_qtvs arg_tys
| Just tvs <- qtvs -- data T = forall a. MkT (a -> a)
= do { free_vars <- get_rdr_tvs arg_tys
; return (freeKiTyVarsKindVars free_vars, tvs) }
| otherwise -- data T = MkT (a -> a)
= return ([], mkHsQTvs [])
rnConDecl decl@(ConDeclGADT { con_names = names, con_type = ty
, con_doc = mb_doc })
= do { mapM_ (addLocM checkConName) names
; new_names <- mapM lookupLocatedTopBndrRn names
; let doc = ConDeclCtx new_names
; mb_doc' <- rnMbLHsDoc mb_doc
; (ty', fvs) <- rnHsSigType doc ty
; traceRn (text "rnConDecl" <+> ppr names <+> vcat
[ text "fvs:" <+> ppr fvs ])
; return (decl { con_names = new_names, con_type = ty'
, con_doc = mb_doc' },
fvs) }
rnConDeclDetails
:: Name
-> HsDocContext
-> HsConDetails (LHsType RdrName) (Located [LConDeclField RdrName])
-> RnM (HsConDetails (LHsType Name) (Located [LConDeclField Name]), FreeVars)
rnConDeclDetails _ doc (PrefixCon tys)
= do { (new_tys, fvs) <- rnLHsTypes doc tys
; return (PrefixCon new_tys, fvs) }
rnConDeclDetails _ doc (InfixCon ty1 ty2)
= do { (new_ty1, fvs1) <- rnLHsType doc ty1
; (new_ty2, fvs2) <- rnLHsType doc ty2
; return (InfixCon new_ty1 new_ty2, fvs1 `plusFV` fvs2) }
rnConDeclDetails con doc (RecCon (L l fields))
= do { fls <- lookupConstructorFields con
; (new_fields, fvs) <- rnConDeclFields doc fls fields
-- No need to check for duplicate fields
-- since that is done by RnNames.extendGlobalRdrEnvRn
; return (RecCon (L l new_fields), fvs) }
-------------------------------------------------
-- | Brings pattern synonym names and also pattern synonym selectors
-- from record pattern synonyms into scope.
extendPatSynEnv :: HsValBinds RdrName -> MiniFixityEnv
-> ([Name] -> TcRnIf TcGblEnv TcLclEnv a) -> TcM a
extendPatSynEnv val_decls local_fix_env thing = do {
names_with_fls <- new_ps val_decls
; let pat_syn_bndrs = concat [ name: map flSelector fields
| (name, fields) <- names_with_fls ]
; let avails = map patSynAvail pat_syn_bndrs
; (gbl_env, lcl_env) <- extendGlobalRdrEnvRn avails local_fix_env
; let field_env' = extendNameEnvList (tcg_field_env gbl_env) names_with_fls
final_gbl_env = gbl_env { tcg_field_env = field_env' }
; setEnvs (final_gbl_env, lcl_env) (thing pat_syn_bndrs) }
where
new_ps :: HsValBinds RdrName -> TcM [(Name, [FieldLabel])]
new_ps (ValBindsIn binds _) = foldrBagM new_ps' [] binds
new_ps _ = panic "new_ps"
new_ps' :: LHsBindLR RdrName RdrName
-> [(Name, [FieldLabel])]
-> TcM [(Name, [FieldLabel])]
new_ps' bind names
| L bind_loc (PatSynBind (PSB { psb_id = L _ n
, psb_args = RecordPatSyn as })) <- bind
= do
bnd_name <- newTopSrcBinder (L bind_loc n)
let rnames = map recordPatSynSelectorId as
mkFieldOcc :: Located RdrName -> LFieldOcc RdrName
mkFieldOcc (L l name) = L l (FieldOcc (L l name) PlaceHolder)
field_occs = map mkFieldOcc rnames
flds <- mapM (newRecordSelector False [bnd_name]) field_occs
return ((bnd_name, flds): names)
| L bind_loc (PatSynBind (PSB { psb_id = L _ n})) <- bind
= do
bnd_name <- newTopSrcBinder (L bind_loc n)
return ((bnd_name, []): names)
| otherwise
= return names
{-
*********************************************************
* *
\subsection{Support code to rename types}
* *
*********************************************************
-}
rnFds :: [Located (FunDep (Located RdrName))]
-> RnM [Located (FunDep (Located Name))]
rnFds fds
= mapM (wrapLocM rn_fds) fds
where
rn_fds (tys1, tys2)
= do { tys1' <- rnHsTyVars tys1
; tys2' <- rnHsTyVars tys2
; return (tys1', tys2') }
rnHsTyVars :: [Located RdrName] -> RnM [Located Name]
rnHsTyVars tvs = mapM rnHsTyVar tvs
rnHsTyVar :: Located RdrName -> RnM (Located Name)
rnHsTyVar (L l tyvar) = do
tyvar' <- lookupOccRn tyvar
return (L l tyvar')
{-
*********************************************************
* *
findSplice
* *
*********************************************************
This code marches down the declarations, looking for the first
Template Haskell splice. As it does so it
a) groups the declarations into a HsGroup
b) runs any top-level quasi-quotes
-}
findSplice :: [LHsDecl RdrName] -> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))
findSplice ds = addl emptyRdrGroup ds
addl :: HsGroup RdrName -> [LHsDecl RdrName]
-> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))
-- This stuff reverses the declarations (again) but it doesn't matter
addl gp [] = return (gp, Nothing)
addl gp (L l d : ds) = add gp l d ds
add :: HsGroup RdrName -> SrcSpan -> HsDecl RdrName -> [LHsDecl RdrName]
-> RnM (HsGroup RdrName, Maybe (SpliceDecl RdrName, [LHsDecl RdrName]))
-- #10047: Declaration QuasiQuoters are expanded immediately, without
-- causing a group split
add gp _ (SpliceD (SpliceDecl (L _ qq@HsQuasiQuote{}) _)) ds
= do { (ds', _) <- rnTopSpliceDecls qq
; addl gp (ds' ++ ds)
}
add gp loc (SpliceD splice@(SpliceDecl _ flag)) ds
= do { -- We've found a top-level splice. If it is an *implicit* one
-- (i.e. a naked top level expression)
case flag of
ExplicitSplice -> return ()
ImplicitSplice -> do { th_on <- xoptM LangExt.TemplateHaskell
; unless th_on $ setSrcSpan loc $
failWith badImplicitSplice }
; return (gp, Just (splice, ds)) }
where
badImplicitSplice = text "Parse error: module header, import declaration"
$$ text "or top-level declaration expected."
-- Class declarations: pull out the fixity signatures to the top
add gp@(HsGroup {hs_tyclds = ts, hs_fixds = fs}) l (TyClD d) ds
| isClassDecl d
= let fsigs = [ L l f | L l (FixSig f) <- tcdSigs d ] in
addl (gp { hs_tyclds = add_tycld (L l d) ts, hs_fixds = fsigs ++ fs}) ds
| otherwise
= addl (gp { hs_tyclds = add_tycld (L l d) ts }) ds
-- Signatures: fixity sigs go a different place than all others
add gp@(HsGroup {hs_fixds = ts}) l (SigD (FixSig f)) ds
= addl (gp {hs_fixds = L l f : ts}) ds
add gp@(HsGroup {hs_valds = ts}) l (SigD d) ds
= addl (gp {hs_valds = add_sig (L l d) ts}) ds
-- Value declarations: use add_bind
add gp@(HsGroup {hs_valds = ts}) l (ValD d) ds
= addl (gp { hs_valds = add_bind (L l d) ts }) ds
-- Role annotations: added to the TyClGroup
add gp@(HsGroup {hs_tyclds = ts}) l (RoleAnnotD d) ds
= addl (gp { hs_tyclds = add_role_annot (L l d) ts }) ds
-- NB instance declarations go into TyClGroups. We throw them into the first
-- group, just as we do for the TyClD case. The renamer will go on to group
-- and order them later.
add gp@(HsGroup {hs_tyclds = ts}) l (InstD d) ds
= addl (gp { hs_tyclds = add_instd (L l d) ts }) ds
-- The rest are routine
add gp@(HsGroup {hs_derivds = ts}) l (DerivD d) ds
= addl (gp { hs_derivds = L l d : ts }) ds
add gp@(HsGroup {hs_defds = ts}) l (DefD d) ds
= addl (gp { hs_defds = L l d : ts }) ds
add gp@(HsGroup {hs_fords = ts}) l (ForD d) ds
= addl (gp { hs_fords = L l d : ts }) ds
add gp@(HsGroup {hs_warnds = ts}) l (WarningD d) ds
= addl (gp { hs_warnds = L l d : ts }) ds
add gp@(HsGroup {hs_annds = ts}) l (AnnD d) ds
= addl (gp { hs_annds = L l d : ts }) ds
add gp@(HsGroup {hs_ruleds = ts}) l (RuleD d) ds
= addl (gp { hs_ruleds = L l d : ts }) ds
add gp@(HsGroup {hs_vects = ts}) l (VectD d) ds
= addl (gp { hs_vects = L l d : ts }) ds
add gp l (DocD d) ds
= addl (gp { hs_docs = (L l d) : (hs_docs gp) }) ds
add_tycld :: LTyClDecl a -> [TyClGroup a] -> [TyClGroup a]
add_tycld d [] = [TyClGroup { group_tyclds = [d]
, group_roles = []
, group_instds = []
}
]
add_tycld d (ds@(TyClGroup { group_tyclds = tyclds }):dss)
= ds { group_tyclds = d : tyclds } : dss
add_instd :: LInstDecl a -> [TyClGroup a] -> [TyClGroup a]
add_instd d [] = [TyClGroup { group_tyclds = []
, group_roles = []
, group_instds = [d]
}
]
add_instd d (ds@(TyClGroup { group_instds = instds }):dss)
= ds { group_instds = d : instds } : dss
add_role_annot :: LRoleAnnotDecl a -> [TyClGroup a] -> [TyClGroup a]
add_role_annot d [] = [TyClGroup { group_tyclds = []
, group_roles = [d]
, group_instds = []
}
]
add_role_annot d (tycls@(TyClGroup { group_roles = roles }) : rest)
= tycls { group_roles = d : roles } : rest
add_bind :: LHsBind a -> HsValBinds a -> HsValBinds a
add_bind b (ValBindsIn bs sigs) = ValBindsIn (bs `snocBag` b) sigs
add_bind _ (ValBindsOut {}) = panic "RdrHsSyn:add_bind"
add_sig :: LSig a -> HsValBinds a -> HsValBinds a
add_sig s (ValBindsIn bs sigs) = ValBindsIn bs (s:sigs)
add_sig _ (ValBindsOut {}) = panic "RdrHsSyn:add_sig"
| sgillespie/ghc | compiler/rename/RnSource.hs | bsd-3-clause | 96,564 | 1 | 25 | 30,032 | 17,518 | 9,256 | 8,262 | 1,099 | 8 |
{-# LANGUAGE TemplateHaskell, OverloadedStrings, GeneralizedNewtypeDeriving #-}
module SecondTransfer.Socks5.Types (
-- ** Types to be serialized and de-serialized
ClientAuthMethods_Packet (..)
, ServerSelectsMethod_Packet (..)
, ClientRequest_Packet (..)
, cmd_SP3
, address_SP3
, port_SP3
, ServerReply_Packet (..)
, replyField_SP4
, address_SP4
, port_SP4
, AddressType (..)
, ProtocolCommand (..)
, ProtocolVersion (..)
, IndicatedAddress (..)
, ReplyField (..)
-- *** Helpers for serialization, de-serialization
, iaToAddressType
-- *** Logging types
, S5ConnectionId (..)
, Socks5ConnectEvent (..)
, Socks5LogCallback
, Socks5ConnectionCallbacks (..)
, logEvents_S5CC
, blanketPlainTextIO_S5CC
, serviceIsClosing_S5CC
) where
---import Control.Concurrent
-- import qualified Control.Exception as E
import Control.Lens (makeLenses)
import qualified Data.ByteString as B
-- import qualified Data.ByteString.Lazy as LB
--import Data.ByteString.Char8 (pack, unpack)
--import Data.List (find)
import Data.Word
import Data.Int (Int64)
import qualified Network.Socket as NS(SockAddr)
import SecondTransfer.IOCallbacks.Types (IOCallbacks)
import SecondTransfer.IOCallbacks.WrapSocket (AcceptErrorCondition(..))
-------------------------------------------------------------------------------------------------------
--
-- Connection callbacks, used to report Connect behavior
--
------------------------------------------------------------------------------------------------------
-- | Connection ID for SOCKS5 Connections
newtype S5ConnectionId = S5ConnectionId Int64
deriving (Eq, Ord, Enum)
instance Show S5ConnectionId where
show (S5ConnectionId c) = "S5/" ++ (show c)
-- | SOCKS5 Connections, and where are they handled
data Socks5ConnectEvent =
Established_S5Ev NS.SockAddr S5ConnectionId
| HandlingHere_S5Ev B.ByteString S5ConnectionId
| ToExternal_S5Ev B.ByteString Word16 S5ConnectionId
| Dropped_S5Ev B.ByteString S5ConnectionId
| AcceptCondition_S5Ev AcceptErrorCondition
type Socks5LogCallback = Socks5ConnectEvent -> IO ()
-- | Callbacks used by client applications to get notified about interesting
-- events happening at a connection level, or to get asked about things
-- (e.g, about if it is proper to accept a connection). These are used from CoreServer
data Socks5ConnectionCallbacks = Socks5ConnectionCallbacks {
-- | Invoked after the connection is accepted, and after it is finished.
_logEvents_S5CC :: Maybe Socks5LogCallback
-- | Function to transform the plain-text IOCallbacks when a connection is
-- accepted. Handy for implementing metrics, or for slowing things down.
--
, _blanketPlainTextIO_S5CC :: Maybe (IOCallbacks -> IO IOCallbacks)
-- | Function to say if the service is closing
, _serviceIsClosing_S5CC :: Maybe (IO Bool)
}
makeLenses ''Socks5ConnectionCallbacks
-------------------------------------------------------------------------------------------------------
--
-- Serialization types
--
-------------------------------------------------------------------------------------------------------
-- | A nonce which is always equal to five... or we are in troubles
data ProtocolVersion = ProtocolVersion
deriving Show
data AddressType =
IPv4_S5AT
| DomainName_S5AT
| IPv6_S5AT
deriving (Show, Eq, Enum)
-- | The command sent by the client
data ProtocolCommand =
Connect_S5PC
| Bind_S5PC
| UdpAssociate_S5PC
deriving (Show, Eq, Enum)
-- TODO: We need to implement the other types of responses
data ReplyField =
Succeeded_S5RF
| GeneralFailure_S5RF
deriving (Show, Eq, Enum)
-- Datatypes present at different negotiation stages
data ClientAuthMethods_Packet = ClientAuthMethods_Packet {
_version_SP1 :: ProtocolVersion
, _methods_SP1 :: B.ByteString
}
deriving Show
data ServerSelectsMethod_Packet = ServerSelectsMethod_Packet {
_version_SP2 :: ProtocolVersion
, _method_SP2 :: Word8
}
deriving Show
data IndicatedAddress =
IPv4_IA Word32
| DomainName_IA B.ByteString
| IPv6_IA B.ByteString
deriving Show
iaToAddressType :: IndicatedAddress -> AddressType
iaToAddressType (IPv4_IA _) = IPv4_S5AT
iaToAddressType (IPv6_IA _) = IPv6_S5AT
iaToAddressType (DomainName_IA _) = DomainName_S5AT
data ClientRequest_Packet = ClientRequest_Packet {
_version_SP3 :: ProtocolVersion
, _cmd_SP3 :: ProtocolCommand
, _reserved_SP3 :: Word8 -- Should be zero
, _address_SP3 :: IndicatedAddress
, _port_SP3 :: Word16
}
deriving Show
makeLenses ''ClientRequest_Packet
data ServerReply_Packet = ServerReply_Packet {
_version_SP4 :: ProtocolVersion
, _replyField_SP4 :: ReplyField
, _reservedField_SP4 :: Word8 -- Should be zero
, _address_SP4 :: IndicatedAddress
, _port_SP4 :: Word16
}
deriving Show
makeLenses ''ServerReply_Packet
| shimmercat/second-transfer | hs-src/SecondTransfer/Socks5/Types.hs | bsd-3-clause | 6,294 | 0 | 12 | 2,183 | 728 | 448 | 280 | 97 | 1 |
{-# LANGUAGE CPP #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}
#if __GLASGOW_HASKELL__ >= 711
{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
#endif
-----------------------------------------------------------------------------
-- |
-- Module : Control.Lens.Internal.Fold
-- Copyright : (C) 2012-2015 Edward Kmett
-- License : BSD-style (see the file LICENSE)
-- Maintainer : Edward Kmett <[email protected]>
-- Stability : experimental
-- Portability : non-portable
--
----------------------------------------------------------------------------
module Control.Lens.Internal.Fold
(
-- * Monoids for folding
Folding(..)
, Traversed(..)
, Sequenced(..)
, Max(..), getMax
, Min(..), getMin
, Leftmost(..), getLeftmost
, Rightmost(..), getRightmost
, ReifiedMonoid(..)
) where
import Control.Applicative
import Control.Lens.Internal.Getter
import Data.Functor.Bind
import Data.Functor.Contravariant
import Data.Maybe
import Data.Semigroup hiding (Min, getMin, Max, getMax)
import Data.Reflection
import Prelude
#ifdef HLINT
{-# ANN module "HLint: ignore Avoid lambda" #-}
#endif
------------------------------------------------------------------------------
-- Folding
------------------------------------------------------------------------------
-- | A 'Monoid' for a 'Contravariant' 'Applicative'.
newtype Folding f a = Folding { getFolding :: f a }
instance (Contravariant f, Apply f) => Semigroup (Folding f a) where
Folding fr <> Folding fs = Folding (fr .> fs)
{-# INLINE (<>) #-}
instance (Contravariant f, Applicative f) => Monoid (Folding f a) where
mempty = Folding noEffect
{-# INLINE mempty #-}
Folding fr `mappend` Folding fs = Folding (fr *> fs)
{-# INLINE mappend #-}
------------------------------------------------------------------------------
-- Traversed
------------------------------------------------------------------------------
-- | Used internally by 'Control.Lens.Traversal.traverseOf_' and the like.
--
-- The argument 'a' of the result should not be used!
newtype Traversed a f = Traversed { getTraversed :: f a }
instance Apply f => Semigroup (Traversed a f) where
Traversed ma <> Traversed mb = Traversed (ma .> mb)
{-# INLINE (<>) #-}
instance Applicative f => Monoid (Traversed a f) where
mempty = Traversed (pure (error "Traversed: value used"))
{-# INLINE mempty #-}
Traversed ma `mappend` Traversed mb = Traversed (ma *> mb)
{-# INLINE mappend #-}
------------------------------------------------------------------------------
-- Sequenced
------------------------------------------------------------------------------
-- | Used internally by 'Control.Lens.Traversal.mapM_' and the like.
--
-- The argument 'a' of the result should not be used!
newtype Sequenced a m = Sequenced { getSequenced :: m a }
instance Apply m => Semigroup (Sequenced a m) where
Sequenced ma <> Sequenced mb = Sequenced (ma .> mb)
{-# INLINE (<>) #-}
instance Monad m => Monoid (Sequenced a m) where
mempty = Sequenced (return (error "Sequenced: value used"))
{-# INLINE mempty #-}
Sequenced ma `mappend` Sequenced mb = Sequenced (ma >> mb)
{-# INLINE mappend #-}
------------------------------------------------------------------------------
-- Min
------------------------------------------------------------------------------
-- | Used for 'Control.Lens.Fold.minimumOf'.
data Min a = NoMin | Min a
instance Ord a => Semigroup (Min a) where
NoMin <> m = m
m <> NoMin = m
Min a <> Min b = Min (min a b)
{-# INLINE (<>) #-}
instance Ord a => Monoid (Min a) where
mempty = NoMin
{-# INLINE mempty #-}
mappend NoMin m = m
mappend m NoMin = m
mappend (Min a) (Min b) = Min (min a b)
{-# INLINE mappend #-}
-- | Obtain the minimum.
getMin :: Min a -> Maybe a
getMin NoMin = Nothing
getMin (Min a) = Just a
{-# INLINE getMin #-}
------------------------------------------------------------------------------
-- Max
------------------------------------------------------------------------------
-- | Used for 'Control.Lens.Fold.maximumOf'.
data Max a = NoMax | Max a
instance Ord a => Semigroup (Max a) where
NoMax <> m = m
m <> NoMax = m
Max a <> Max b = Max (max a b)
{-# INLINE (<>) #-}
instance Ord a => Monoid (Max a) where
mempty = NoMax
{-# INLINE mempty #-}
mappend NoMax m = m
mappend m NoMax = m
mappend (Max a) (Max b) = Max (max a b)
{-# INLINE mappend #-}
-- | Obtain the maximum.
getMax :: Max a -> Maybe a
getMax NoMax = Nothing
getMax (Max a) = Just a
{-# INLINE getMax #-}
------------------------------------------------------------------------------
-- Leftmost and Rightmost
------------------------------------------------------------------------------
-- | Used for 'Control.Lens.Fold.preview'.
data Leftmost a = LPure | LLeaf a | LStep (Leftmost a)
instance Semigroup (Leftmost a) where
(<>) = mappend
{-# INLINE (<>) #-}
instance Monoid (Leftmost a) where
mempty = LPure
{-# INLINE mempty #-}
mappend x y = LStep $ case x of
LPure -> y
LLeaf _ -> x
LStep x' -> case y of
-- The last two cases make firstOf produce a Just as soon as any element
-- is encountered, and possibly serve as a micro-optimisation; this
-- behaviour can be disabled by replacing them with _ -> mappend x y'.
-- Note that this means that firstOf (backwards folded) [1..] is Just _|_.
LPure -> x'
LLeaf a -> LLeaf $ fromMaybe a (getLeftmost x')
LStep y' -> mappend x' y'
-- | Extract the 'Leftmost' element. This will fairly eagerly determine that it can return 'Just'
-- the moment it sees any element at all.
getLeftmost :: Leftmost a -> Maybe a
getLeftmost LPure = Nothing
getLeftmost (LLeaf a) = Just a
getLeftmost (LStep x) = getLeftmost x
-- | Used for 'Control.Lens.Fold.lastOf'.
data Rightmost a = RPure | RLeaf a | RStep (Rightmost a)
instance Semigroup (Rightmost a) where
(<>) = mappend
{-# INLINE (<>) #-}
instance Monoid (Rightmost a) where
mempty = RPure
{-# INLINE mempty #-}
mappend x y = RStep $ case y of
RPure -> x
RLeaf _ -> y
RStep y' -> case x of
-- The last two cases make lastOf produce a Just as soon as any element
-- is encountered, and possibly serve as a micro-optimisation; this
-- behaviour can be disabled by replacing them with _ -> mappend x y'.
-- Note that this means that lastOf folded [1..] is Just _|_.
RPure -> y'
RLeaf a -> RLeaf $ fromMaybe a (getRightmost y')
RStep x' -> mappend x' y'
-- | Extract the 'Rightmost' element. This will fairly eagerly determine that it can return 'Just'
-- the moment it sees any element at all.
getRightmost :: Rightmost a -> Maybe a
getRightmost RPure = Nothing
getRightmost (RLeaf a) = Just a
getRightmost (RStep x) = getRightmost x
| omefire/lens | src/Control/Lens/Internal/Fold.hs | bsd-3-clause | 6,882 | 0 | 16 | 1,301 | 1,472 | 797 | 675 | 119 | 1 |
{-# LANGUAGE TupleSections, ViewPatterns #-}
-- | Lookup the documentation of a name in a module (and in a specific
-- package in the case of ambiguity).
module Haskell.Docs
(module Haskell.Docs
,Identifier(..)
,PackageName(..))
where
import Haskell.Docs.Cabal
import Haskell.Docs.Formatting
import Haskell.Docs.Ghc
import Haskell.Docs.Haddock
import Haskell.Docs.Index
import Haskell.Docs.Types
import Control.Exception
import Control.Monad
import qualified Data.HashMap.Strict as M
import Data.List
import Data.Ord
import qualified Data.Text as T
import qualified Data.Text.IO as T
import GHC hiding (verbosity)
import MonadUtils
-- -- | Print the documentation of a name in the given module.
searchAndPrintDoc
:: [String] -- ^ GHC Options
-> Bool -- ^ Print modules only.
-> Bool -- ^ S-expression format.
-> Maybe PackageName -- ^ Package.
-> Maybe ModuleName -- ^ Module name.
-> Identifier -- ^ Identifier.
-> Ghc ()
searchAndPrintDoc flags _ms ss _pname _mname ident =
do result <- liftIO (lookupIdent flags
(T.pack (unIdentifier ident)))
case result of
Nothing -> throw NoFindModule
Just pkgModuleMap ->
do pkgs <- getAllPackages flags
docs <- fmap concat
(forM (M.toList pkgModuleMap)
(searchResult pkgs))
if ss
then printSexp docs
else mapM_ (\(_,doc') ->
printIdentDoc False True True doc')
(zip [0 :: Int ..]
(nub docs))
where searchResult pkgs (pkgName,modName) =
case find (matchingPkg pkgName) pkgs of
Nothing -> return []
Just pkg -> searchPkg pkg modName
where matchingPkg pkgNm = (== pkgNm) . T.pack . showPackageName .
getIdentifier
searchPkg pkg modName =
do result <- searchWithPackage
pkg
(Just (head (fmap (makeModuleName . T.unpack) modName)))
ident
case result of
Left err -> throw err
Right (sortBy (comparing identDocPackageName) -> docs) -> return docs
-- | Search only for identifiers and print out all modules associated.
searchAndPrintModules :: [String] -> Identifier -> IO ()
searchAndPrintModules flags ident =
do result <- lookupIdent flags (T.pack (unIdentifier ident))
case result of
Nothing ->
throw NoFindModule
Just packages ->
forM_ (nub (concat (map snd (M.toList packages))))
T.putStrLn
| chrisdone/haskell-docs | src/Haskell/Docs.hs | bsd-3-clause | 2,828 | 0 | 19 | 1,006 | 661 | 350 | 311 | 67 | 5 |
module Translate(translate) where
import Control.Monad
import Data.List
import Data.Generics.PlateData
import HSE
import Type
import Convert
import qualified Desugar
import Supercompile
translate :: IO ()
translate = do
let parse x = fmap fromParseResult $ parseFileWithMode mode x
mode = defaultParseMode{fixities=infixr_ 5 ["&"] ++ baseFixities}
spec <- parse "Text/HTML/TagSoup/Specification.hs"
impl <- parse "Text/HTML/TagSoup/Implementation.hs"
putStrLn "Translating... "
writeFile "TagSoup/Generate/programs/TagSoup.hs" $ regen $ mergeModules spec impl
putStrLn "done"
mergeModules (Module x1 x2 x3 x4 x5 x6 x7) (Module y1 y2 y3 y4 y5 y6 y7) =
Module x1 x2 (x3++y3) Nothing Nothing (x6++y6) (x7++y7)
types = words "String LBS BS"
modes = replicateM 3 [False,True]
showMode [pos,warn,merge] = f pos "Pos" ++ f warn "Warn" ++ f merge "Merge"
where f b s = if b then s else ""
{-
optimise :: Module -> String
optimise (Module x1 x2 x3 x4 x5 x6 x7) = unlines $
["{-# LANGUAGE RecordWildCards, PatternGuards, ScopedTypeVariables #-}"
,"module Text.HTML.TagSoup.Generated(parseTagsOptions) where"
,"import qualified Text.HTML.TagSoup.Manual as Manual"
,"import Data.Typeable"
,"import Data.Maybe"
,"import qualified Data.ByteString.Char8 as BS"
,"import qualified Data.ByteString.Lazy.Char8 as LBS"] ++
map prettyPrint (nub $ filter ((/=) (ModuleName "Text.HTML.TagSoup.Implementation") . importModule) x6) ++
["type LBS = LBS.ByteString"
,"type BS = BS.ByteString"
,"type EntData str = str -> [Tag str]"
,"type EntAttrib str = (str,Bool) -> (str,[Tag str])"
,"patternMatchFail = error \"Pattern match fail\""
,"primEq x y = x == y"
,"primGeq x y = x >= y"
,"primLeq x y = x <= y"] ++
map prettyPrint typedefs ++
["{-# NOINLINE parseTagsOptions #-}"
,"parseTagsOptions :: StringLike str => ParseOptions str -> str -> [Tag str]"] ++
concat [
["parseTagsOptions opts x | Just (ParseOptions pos warn entData entAttrib merge) <- cast (opts,x) ="
," fromJust $ cast $ case (pos,warn,merge) of"] ++
[" ("++pb++","++wb++","++mb++") -> fp"++t++ showMode m ++ " entData entAttrib" | m <- modes, let [pb,wb,mb] = map show m]
| t <- types] ++
["parseTagsOptions opts x = Manual.parseTagsOptions opts x"] ++
concat [
[""
,"{-# NOINLINE fp"++t++showMode m++ " #-}"
,"fp"++t++showMode m++ " :: EntData " ++ t ++ " -> EntAttrib " ++ t ++ " -> " ++ t ++ " -> [Tag " ++ t ++ "]"
,"fp"++t++showMode m++ " entData entAttrib x = main x"
," where"] ++
map (" "++) (concatMap (lines . prettyPrint) $ output $ supercompiler $ input $ mainFunc t m : decls)
| t <- types, m <- modes, let [pb,wb,mb] = map show m]
where
(decls,typedefs) = partition isDecl $ desugar $ prelude ++ x7
-}
regen :: Module -> String
regen (Module x1 x2 x3 x4 x5 x6 x7) = unlines $ concatMap (lines . prettyPrint) $ output $ input $ mainFunc t m : decls
where (decls,typedefs) = partition isDecl $ desugar $ prelude ++ x7
t = head types
m = head modes
mainFunc t [a,b,c] = fromParseResult $ parse $
"main = \\x -> output (ParseOptions " ++ show a ++ " " ++ show b ++ " entData entAttrib " ++ show c ++ ") (parse (toString x))"
prelude = map (fromParseResult . parse)
["id x = x"
,"seq x y = y"
,"null x = case x of z:zs -> False ; _ -> True"
,"not x = case x of True -> False; _ -> True"
,"head x = case x of z:zs -> z ; _ -> error \"head on empty\""
,"tail x = case x of z:zs -> zs; _ -> error \"tail on empty\""
,"dol x y = x y"
,"dot f g x = f (g x)"
,"opOr x y = if x then True else y"
,"opAnd x y = if x then y else False"
,"opEq x y = primEq x y"
,"opGeq x y = primGeq x y"
,"opLeq x y = primLeq x y"
,"opPlusPlus x y = case x of [] -> y ; z:zs -> z : opPlusPlus zs y"
,"opStarStarStar f g x = (f (fst x), g (snd x))"
-- specific to String!
,"toString x = x"
]
isDecl PatBind{} = True
isDecl FunBind{} = True
isDecl TypeSig{} = True
isDecl InfixDecl{} = True
isDecl _ = False
---------------------------------------------------------------------
-- APP SPECIFIC DESUGAR
desugar :: [Decl] -> [Decl]
desugar =
Desugar.singleCase ["S","(,)","(,,)","(,,,)"] .
Desugar.core2 . Desugar.irrefutable . Desugar.untyped . expandOps . expandAmp . expandS .
drop (length recordTypes) . Desugar.records . (recordTypes++)
recordTypes = map (fromParseResult . parse)
["data Tag a = TagOpen a a | TagClose a | TagText a | TagComment a | TagWarning a | TagPosition a a"
,"data ParseOptions a = ParseOptions{optTagPosition,optTagWarning,optEntityData,optEntityAttrib,optTagTextMerge::a}"]
-- 'c' & _ ==> ampChar
-- v & _ ==> ampChar
-- x@C & y ==> ampOut x y
-- plus remove &/Outputable
expandAmp :: [Decl] -> [Decl]
expandAmp = transformBi f . filter (not . isAmp)
where
isAmp InfixDecl{} = True
isAmp ClassDecl{} = True
isAmp InstDecl{} = True
isAmp _ = False
f (InfixApp x op y) | prettyPrint op == "&" = Paren $ apps (var $ g x) [Paren x, Paren y]
f x = x
g Var{} = "ampChar"
g Lit{} = "ampChar"
g _ = "ampOut"
-- For patterns (S v ...) => v@(S ...)
-- For the type, loose the first field
-- For construction, drop the first field
expandS :: [Decl] -> [Decl]
expandS = transformBi fRec . transformBi fPat . descendBi fExp
where
fExp (App (Con s) x) | prettyPrint s == "S" = Con s
fExp x = descend fExp x
fPat (PApp s (PVar x:xs)) | prettyPrint s == "S" = PAsPat x $ PParen $ PApp s xs
fPat x = x
fRec (RecDecl s (x:xs)) | prettyPrint s == "S" = RecDecl s xs
fRec x = x
expandOps :: [Decl] -> [Decl]
expandOps = transformBi f
where
f (Symbol "$") = Ident "dol"
f (Symbol ".") = Ident "dot"
f (Symbol "||") = Ident "opOr"
f (Symbol "&&") = Ident "opAnd"
f (Symbol "==") = Ident "opEq"
f (Symbol ">=") = Ident "opGeq"
f (Symbol "<=") = Ident "opLeq"
f (Symbol "++") = Ident "opPlusPlus"
f (Symbol "***") = Ident "opStarStarStar"
f (Symbol x) = error $ "Unknown symbol: " ++ x
f x = x
| ndmitchell/tagsoup | test/TagSoup/Generate/Translate.hs | bsd-3-clause | 6,340 | 0 | 15 | 1,638 | 1,341 | 685 | 656 | 93 | 11 |
{-|
Module : Idris.Core.CaseTree
Description : Module to define and interact with case trees.
Copyright :
License : BSD3
Maintainer : The Idris Community.
Note: The case-tree elaborator only produces (Case n alts)-cases;
in other words, it never inspects anything else than variables.
ProjCase is a special powerful case construct that allows inspection
of compound terms. Occurrences of ProjCase arise no earlier than
in the function `prune` as a means of optimisation
of already built case trees.
While the intermediate representation (follows in the pipeline, named LExp)
allows casing on arbitrary terms, here we choose to maintain the distinction
in order to allow for better optimisation opportunities.
-}
{-# LANGUAGE DeriveFunctor, DeriveGeneric, FlexibleContexts, FlexibleInstances,
PatternGuards, TypeSynonymInstances #-}
module Idris.Core.CaseTree (
CaseDef(..), SC, SC'(..), CaseAlt, CaseAlt'(..), ErasureInfo
, Phase(..), CaseTree, CaseType(..)
, simpleCase, small, namesUsed, findCalls, findCalls', findUsedArgs
, substSC, substAlt, mkForce
) where
import Idris.Core.TT
import Control.Applicative hiding (Const)
import Control.Monad.Reader
import Control.Monad.State
import Data.List hiding (partition)
import qualified Data.List (partition)
import Data.Maybe
import qualified Data.Set as S
import Debug.Trace
import GHC.Generics (Generic)
data CaseDef = CaseDef [Name] !SC [Term]
deriving Show
data SC' t = Case CaseType Name [CaseAlt' t] -- ^ invariant: lowest tags first
| ProjCase t [CaseAlt' t] -- ^ special case for projections/thunk-forcing before inspection
| STerm !t
| UnmatchedCase String -- ^ error message
| ImpossibleCase -- ^ already checked to be impossible
deriving (Eq, Ord, Functor, Generic)
{-!
deriving instance Binary SC'
!-}
data CaseType = Updatable | Shared
deriving (Eq, Ord, Show, Generic)
type SC = SC' Term
data CaseAlt' t = ConCase Name Int [Name] !(SC' t)
| FnCase Name [Name] !(SC' t) -- ^ reflection function
| ConstCase Const !(SC' t)
| SucCase Name !(SC' t)
| DefaultCase !(SC' t)
deriving (Show, Eq, Ord, Functor, Generic)
{-!
deriving instance Binary CaseAlt'
!-}
type CaseAlt = CaseAlt' Term
instance Show t => Show (SC' t) where
show sc = show' 1 sc
where
show' i (Case up n alts) = "case" ++ u ++ show n ++ " of\n" ++ indent i ++
showSep ("\n" ++ indent i) (map (showA i) alts)
where u = case up of
Updatable -> "! "
Shared -> " "
show' i (ProjCase tm alts) = "case " ++ show tm ++ " of " ++
showSep ("\n" ++ indent i) (map (showA i) alts)
show' i (STerm tm) = show tm
show' i (UnmatchedCase str) = "error " ++ show str
show' i ImpossibleCase = "impossible"
indent i = concat $ take i (repeat " ")
showA i (ConCase n t args sc)
= show n ++ "(" ++ showSep (", ") (map show args) ++ ") => "
++ show' (i+1) sc
showA i (FnCase n args sc)
= "FN " ++ show n ++ "(" ++ showSep (", ") (map show args) ++ ") => "
++ show' (i+1) sc
showA i (ConstCase t sc)
= show t ++ " => " ++ show' (i+1) sc
showA i (SucCase n sc)
= show n ++ "+1 => " ++ show' (i+1) sc
showA i (DefaultCase sc)
= "_ => " ++ show' (i+1) sc
type CaseTree = SC
type Clause = ([Pat], (Term, Term))
type CS = ([Term], Int, [(Name, Type)])
instance TermSize SC where
termsize n (Case _ n' as) = termsize n as
termsize n (ProjCase n' as) = termsize n as
termsize n (STerm t) = termsize n t
termsize n _ = 1
instance TermSize CaseAlt where
termsize n (ConCase _ _ _ s) = termsize n s
termsize n (FnCase _ _ s) = termsize n s
termsize n (ConstCase _ s) = termsize n s
termsize n (SucCase _ s) = termsize n s
termsize n (DefaultCase s) = termsize n s
-- simple terms can be inlined trivially - good for primitives in particular
-- To avoid duplicating work, don't inline something which uses one
-- of its arguments in more than one place
small :: Name -> [Name] -> SC -> Bool
small n args t = let as = findAllUsedArgs t args in
length as == length (nub as) &&
termsize n t < 10
namesUsed :: SC -> [Name]
namesUsed sc = nub $ nu' [] sc where
nu' ps (Case _ n alts) = nub (concatMap (nua ps) alts) \\ [n]
nu' ps (ProjCase t alts) = nub $ nut ps t ++ concatMap (nua ps) alts
nu' ps (STerm t) = nub $ nut ps t
nu' ps _ = []
nua ps (ConCase n i args sc) = nub (nu' (ps ++ args) sc) \\ args
nua ps (FnCase n args sc) = nub (nu' (ps ++ args) sc) \\ args
nua ps (ConstCase _ sc) = nu' ps sc
nua ps (SucCase _ sc) = nu' ps sc
nua ps (DefaultCase sc) = nu' ps sc
nut ps (P _ n _) | n `elem` ps = []
| otherwise = [n]
nut ps (App _ f a) = nut ps f ++ nut ps a
nut ps (Proj t _) = nut ps t
nut ps (Bind n (Let t v) sc) = nut ps v ++ nut (n:ps) sc
nut ps (Bind n b sc) = nut (n:ps) sc
nut ps _ = []
-- | Return all called functions, and which arguments are used
-- in each argument position for the call, in order to help reduce
-- compilation time, and trace all unused arguments
findCalls :: SC -> [Name] -> [(Name, [[Name]])]
findCalls = findCalls' False
findCalls' :: Bool -> SC -> [Name] -> [(Name, [[Name]])]
findCalls' ignoreasserts sc topargs = S.toList $ nu' topargs sc where
nu' ps (Case _ n alts) = S.unions $ map (nua (n : ps)) alts
nu' ps (ProjCase t alts) = S.unions $ nut ps t : map (nua ps) alts
nu' ps (STerm t) = nut ps t
nu' ps _ = S.empty
nua ps (ConCase n i args sc) = nu' (ps ++ args) sc
nua ps (FnCase n args sc) = nu' (ps ++ args) sc
nua ps (ConstCase _ sc) = nu' ps sc
nua ps (SucCase _ sc) = nu' ps sc
nua ps (DefaultCase sc) = nu' ps sc
nut ps (P _ n _) | n `elem` ps = S.empty
| otherwise = S.singleton (n, [])
nut ps fn@(App _ f a)
| (P _ n _, args) <- unApply fn
= if ignoreasserts && n == sUN "assert_total"
then S.empty
else if n `elem` ps
then S.union (nut ps f) (nut ps a)
else S.insert (n, map argNames args)
(S.unions $ map (nut ps) args)
| (P (TCon _ _) n _, _) <- unApply fn = S.empty
| otherwise = S.union (nut ps f) (nut ps a)
nut ps (Bind n (Let t v) sc) = S.union (nut ps v) (nut (n:ps) sc)
nut ps (Proj t _) = nut ps t
nut ps (Bind n b sc) = nut (n:ps) sc
nut ps _ = S.empty
argNames tm = let ns = directUse tm in
filter (\x -> x `elem` ns) topargs
-- Find names which are used directly (i.e. not in a function call) in a term
directUse :: TT Name -> [Name]
directUse (P _ n _) = [n]
directUse (Bind n (Let t v) sc) = nub $ directUse v ++ (directUse sc \\ [n])
++ directUse t
directUse (Bind n b sc) = nub $ directUse (binderTy b) ++ (directUse sc \\ [n])
directUse fn@(App _ f a)
| (P Ref (UN pfk) _, [App _ e w]) <- unApply fn,
pfk == txt "prim_fork"
= directUse e ++ directUse w -- HACK so that fork works
| (P Ref (UN fce) _, [_, _, a]) <- unApply fn,
fce == txt "Force"
= directUse a -- forcing a value counts as a use
| (P Ref n _, args) <- unApply fn = [] -- need to know what n does with them
| (P (TCon _ _) n _, args) <- unApply fn = [] -- type constructors not used at runtime
| otherwise = nub $ directUse f ++ directUse a
directUse (Proj x i) = nub $ directUse x
directUse _ = []
-- Find all directly used arguments (i.e. used but not in function calls)
findUsedArgs :: SC -> [Name] -> [Name]
findUsedArgs sc topargs = nub (findAllUsedArgs sc topargs)
findAllUsedArgs sc topargs = filter (\x -> x `elem` topargs) (nu' sc) where
nu' (Case _ n alts) = n : concatMap nua alts
nu' (ProjCase t alts) = directUse t ++ concatMap nua alts
nu' (STerm t) = directUse t
nu' _ = []
nua (ConCase n i args sc) = nu' sc
nua (FnCase n args sc) = nu' sc
nua (ConstCase _ sc) = nu' sc
nua (SucCase _ sc) = nu' sc
nua (DefaultCase sc) = nu' sc
-- Return whether name is used anywhere in a case tree
isUsed :: SC -> Name -> Bool
isUsed sc n = used sc where
used (Case _ n' alts) = n == n' || any usedA alts
used (ProjCase t alts) = n `elem` freeNames t || any usedA alts
used (STerm t) = n `elem` freeNames t
used _ = False
usedA (ConCase _ _ args sc) = used sc
usedA (FnCase _ args sc) = used sc
usedA (ConstCase _ sc) = used sc
usedA (SucCase _ sc) = used sc
usedA (DefaultCase sc) = used sc
type ErasureInfo = Name -> [Int] -- name to list of inaccessible arguments; empty list if name not found
type CaseBuilder a = ReaderT ErasureInfo (State CS) a
runCaseBuilder :: ErasureInfo -> CaseBuilder a -> (CS -> (a, CS))
runCaseBuilder ei bld = runState $ runReaderT bld ei
data Phase = CoverageCheck [Int] -- list of positions explicitly given
| CompileTime
| RunTime
deriving (Show, Eq)
-- Generate a simple case tree
-- Work Right to Left
simpleCase :: Bool -> SC -> Bool ->
Phase -> FC ->
-- Following two can be empty lists when Phase = CoverageCheck
[Int] -> -- Inaccessible argument positions
[(Type, Bool)] -> -- (Argument type, whether it's canonical)
[([Name], Term, Term)] ->
ErasureInfo ->
TC CaseDef
simpleCase tc defcase reflect phase fc inacc argtys cs erInfo
= sc' tc defcase phase fc (filter (\(_, _, r) ->
case r of
Impossible -> False
_ -> True) cs)
where
sc' tc defcase phase fc []
= return $ CaseDef [] (UnmatchedCase (show fc ++ ":No pattern clauses")) []
sc' tc defcase phase fc cs
= let proj = phase == RunTime
vnames = fstT (head cs)
pats = map (\ (avs, l, r) ->
(avs, toPats reflect tc l, (l, r))) cs
chkPats = mapM chkAccessible pats in
case chkPats of
OK pats ->
let numargs = length (fst (head pats))
ns = take numargs args
(ns', ps') = order phase [(n, i `elem` inacc) | (i,n) <- zip [0..] ns] pats (map snd argtys)
(tree, st) = runCaseBuilder erInfo
(match ns' ps' defcase)
([], numargs, [])
t = CaseDef ns (prune proj (depatt ns' tree)) (fstT st) in
if proj then return (stripLambdas t)
else return t
Error err -> Error (At fc err)
where args = map (\i -> sMN i "e") [0..]
defaultCase True = STerm Erased
defaultCase False = UnmatchedCase "Error"
fstT (x, _, _) = x
lstT (_, _, x) = x
-- Check that all pattern variables are reachable by a case split
-- Otherwise, they won't make sense on the RHS.
chkAccessible (avs, l, c)
| phase /= CompileTime || reflect = return (l, c)
| otherwise = do mapM_ (acc l) avs
return (l, c)
acc [] n = Error (Inaccessible n)
acc (PV x t : xs) n | x == n = OK ()
acc (PCon _ _ _ ps : xs) n = acc (ps ++ xs) n
acc (PSuc p : xs) n = acc (p : xs) n
acc (_ : xs) n = acc xs n
-- For each 'Case', make sure every choice is in the same type family,
-- as directed by the variable type (i.e. there is no implicit type casing
-- going on).
checkSameTypes :: [(Name, Type)] -> SC -> Bool
checkSameTypes tys (Case _ n alts)
= case lookup n tys of
Just t -> and (map (checkAlts t) alts)
_ -> and (map ((checkSameTypes tys).getSC) alts)
where
checkAlts t (ConCase n _ _ sc) = isType n t && checkSameTypes tys sc
checkAlts (Constant t) (ConstCase c sc) = isConstType c t && checkSameTypes tys sc
checkAlts _ (ConstCase c sc) = False
checkAlts _ _ = True
getSC (ConCase _ _ _ sc) = sc
getSC (FnCase _ _ sc) = sc
getSC (ConstCase _ sc) = sc
getSC (SucCase _ sc) = sc
getSC (DefaultCase sc) = sc
checkSameTypes _ _ = True
-- FIXME: All we're actually doing here is checking that we haven't arrived
-- at a specific constructor for a polymorphic argument. I *think* this
-- is sufficient, but if it turns out not to be, fix it!
--
-- Issue #1718 on the issue tracker: https://github.com/idris-lang/Idris-dev/issues/1718
isType n t | (P (TCon _ _) _ _, _) <- unApply t = True
isType n t | (P Ref _ _, _) <- unApply t = True
isType n t = False
isConstType (I _) (AType (ATInt ITNative)) = True
isConstType (BI _) (AType (ATInt ITBig)) = True
isConstType (Fl _) (AType ATFloat) = True
isConstType (Ch _) (AType (ATInt ITChar)) = True
isConstType (Str _) StrType = True
isConstType (B8 _) (AType (ATInt _)) = True
isConstType (B16 _) (AType (ATInt _)) = True
isConstType (B32 _) (AType (ATInt _)) = True
isConstType (B64 _) (AType (ATInt _)) = True
isConstType _ _ = False
data Pat = PCon Bool Name Int [Pat]
| PConst Const
| PInferred Pat
| PV Name Type
| PSuc Pat -- special case for n+1 on Integer
| PReflected Name [Pat]
| PAny
| PTyPat -- typecase, not allowed, inspect last
deriving Show
-- If there are repeated variables, take the *last* one (could be name shadowing
-- in a where clause, so take the most recent).
toPats :: Bool -> Bool -> Term -> [Pat]
toPats reflect tc f = reverse (toPat reflect tc (getArgs f)) where
getArgs (App _ f a) = a : getArgs f
getArgs _ = []
toPat :: Bool -> Bool -> [Term] -> [Pat]
toPat reflect tc = map $ toPat' []
where
toPat' [_,_,arg] (P (DCon t a uniq) nm@(UN n) _)
| n == txt "Delay"
= PCon uniq nm t [PAny, PAny, toPat' [] arg]
toPat' args (P (DCon t a uniq) nm@(NS (UN n) [own]) _)
| n == txt "Read" && own == txt "Ownership"
= PCon False nm t (map shareCons (map (toPat' []) args))
where shareCons (PCon _ n i ps) = PCon False n i (map shareCons ps)
shareCons p = p
toPat' args (P (DCon t a uniq) n _)
= PCon uniq n t $ map (toPat' []) args
-- n + 1
toPat' [p, Constant (BI 1)] (P _ (UN pabi) _)
| pabi == txt "prim__addBigInt"
= PSuc $ toPat' [] p
toPat' [] (P Bound n ty) = PV n ty
toPat' args (App _ f a) = toPat' (a : args) f
toPat' args (Inferred tm) = PInferred (toPat' args tm)
toPat' [] (Constant x) | isTypeConst x = PTyPat
| otherwise = PConst x
toPat' [] (Bind n (Pi _ _ t _) sc)
| reflect && noOccurrence n sc
= PReflected (sUN "->") [toPat' [] t, toPat' [] sc]
toPat' args (P _ n _)
| reflect
= PReflected n $ map (toPat' []) args
toPat' _ t = PAny
fixedN IT8 = "Bits8"
fixedN IT16 = "Bits16"
fixedN IT32 = "Bits32"
fixedN IT64 = "Bits64"
data Partition = Cons [Clause]
| Vars [Clause]
deriving Show
isVarPat (PV _ _ : ps , _) = True
isVarPat (PAny : ps , _) = True
isVarPat (PTyPat : ps , _) = True
isVarPat _ = False
isConPat (PCon _ _ _ _ : ps, _) = True
isConPat (PReflected _ _ : ps, _) = True
isConPat (PSuc _ : ps, _) = True
isConPat (PConst _ : ps, _) = True
isConPat _ = False
partition :: [Clause] -> [Partition]
partition [] = []
partition ms@(m : _)
| isVarPat m = let (vars, rest) = span isVarPat ms in
Vars vars : partition rest
| isConPat m = let (cons, rest) = span isConPat ms in
Cons cons : partition rest
partition xs = error $ "Partition " ++ show xs
-- reorder the patterns so that the one with most distinct names
-- comes next. Take rightmost first, otherwise (i.e. pick value rather
-- than dependency)
--
-- The first argument means [(Name, IsInaccessible)].
order :: Phase -> [(Name, Bool)] -> [Clause] -> [Bool] -> ([Name], [Clause])
-- do nothing at compile time: FIXME (EB): Put this in after checking
-- implications for Franck's reflection work... see issue 3233
-- order CompileTime ns cs _ = (map fst ns, cs)
order _ [] cs cans = ([], cs)
order _ ns' [] cans = (map fst ns', [])
order (CoverageCheck pos) ns' cs cans
= let ns_out = pick 0 [] (map fst ns')
cs_out = map pickClause cs in
(ns_out, cs_out)
where
pickClause (pats, def) = (pick 0 [] pats, def)
-- Order the list so that things in a position in 'pos' are in the first
-- part, then all the other things later. Otherwise preserve order.
pick i skipped [] = reverse skipped
pick i skipped (x : xs)
| i `elem` pos = x : pick (i + 1) skipped xs
| otherwise = pick (i + 1) (x : skipped) xs
order phase ns' cs cans
= let patnames = transpose (map (zip ns') (map (zip cans) (map fst cs)))
-- only sort the arguments where there is no clash in
-- constructor tags between families, the argument type is canonical,
-- and no constructor/constant
-- clash, because otherwise we can't reliable make the
-- case distinction on evaluation
(patnames_ord, patnames_rest)
= Data.List.partition (noClash . map snd) patnames
patnames_ord' = case phase of
CompileTime -> patnames_ord
-- reversing tends to make better case trees
-- and helps erasure
RunTime -> reverse patnames_ord
pats' = transpose (sortBy moreDistinct patnames_ord'
++ patnames_rest) in
(getNOrder pats', zipWith rebuild pats' cs)
where
getNOrder [] = error $ "Failed order on " ++ show (map fst ns', cs)
getNOrder (c : _) = map (fst . fst) c
rebuild patnames clause = (map (snd . snd) patnames, snd clause)
noClash [] = True
noClash ((can, p) : ps) = can && not (any (clashPat p) (map snd ps))
&& noClash ps
clashPat (PCon _ _ _ _) (PConst _) = True
clashPat (PConst _) (PCon _ _ _ _) = True
clashPat (PCon _ _ _ _) (PSuc _) = True
clashPat (PSuc _) (PCon _ _ _ _) = True
clashPat (PCon _ n i _) (PCon _ n' i' _) | i == i' = n /= n'
clashPat _ _ = False
-- this compares (+isInaccessible, -numberOfCases)
moreDistinct xs ys
= compare (snd . fst . head $ xs, numNames [] (map snd ys))
(snd . fst . head $ ys, numNames [] (map snd xs))
numNames xs ((_, PCon _ n _ _) : ps)
| not (Left n `elem` xs) = numNames (Left n : xs) ps
numNames xs ((_, PConst c) : ps)
| not (Right c `elem` xs) = numNames (Right c : xs) ps
numNames xs (_ : ps) = numNames xs ps
numNames xs [] = length xs
-- Reorder the patterns in the clause so that the PInferred patterns come
-- last. Also strip 'PInferred' from the top level patterns so that we can
-- go ahead and match.
orderByInf :: [Name] -> [Clause] -> ([Name], [Clause])
orderByInf vs cs = let alwaysInf = getInf cs in
(selectInf alwaysInf vs,
map deInf (map (selectExp alwaysInf) cs))
where
getInf [] = []
getInf [(pats, def)] = infPos 0 pats
getInf ((pats, def) : cs) = infPos 0 pats `intersect` getInf cs
selectExp :: [Int] -> Clause -> Clause
selectExp infs (pats, def)
= let (notInf, inf) = splitPats 0 infs [] [] pats in
(notInf ++ inf, def)
selectInf :: [Int] -> [a] -> [a]
selectInf infs ns = let (notInf, inf) = splitPats 0 infs [] [] ns in
notInf ++ inf
splitPats i infpos notInf inf [] = (reverse notInf, reverse inf)
splitPats i infpos notInf inf (p : ps)
| i `elem` infpos = splitPats (i + 1) infpos notInf (p : inf) ps
| otherwise = splitPats (i + 1) infpos (p : notInf) inf ps
infPos i [] = []
infPos i (PInferred p : ps) = i : infPos (i + 1) ps
infPos i (_ : ps) = infPos (i + 1) ps
deInf (pats, def) = (map deInfPat pats, def)
deInfPat (PInferred p) = p
deInfPat p = p
match :: [Name] -> [Clause] -> SC -- error case
-> CaseBuilder SC
match [] (([], ret) : xs) err
= do (ts, v, ntys) <- get
put (ts ++ (map (fst.snd) xs), v, ntys)
case snd ret of
Impossible -> return ImpossibleCase
tm -> return $ STerm tm -- run out of arguments
match vs cs err = do let (vs', de_inf) = orderByInf vs cs
ps = partition de_inf
mixture vs' ps err
mixture :: [Name] -> [Partition] -> SC -> CaseBuilder SC
mixture vs [] err = return err
mixture vs (Cons ms : ps) err = do fallthrough <- mixture vs ps err
conRule vs ms fallthrough
mixture vs (Vars ms : ps) err = do fallthrough <- mixture vs ps err
varRule vs ms fallthrough
-- Return the list of inaccessible arguments of a data constructor.
inaccessibleArgs :: Name -> CaseBuilder [Int]
inaccessibleArgs n = do
getInaccessiblePositions <- ask -- this function is the only thing in the environment
return $ getInaccessiblePositions n
data ConType = CName Name Int -- named constructor
| CFn Name -- reflected function name
| CSuc -- n+1
| CConst Const -- constant, not implemented yet
deriving (Show, Eq)
data Group = ConGroup Bool -- Uniqueness flag
ConType -- Constructor
[([Pat], Clause)] -- arguments and rest of alternative
deriving Show
conRule :: [Name] -> [Clause] -> SC -> CaseBuilder SC
conRule (v:vs) cs err = do groups <- groupCons cs
caseGroups (v:vs) groups err
caseGroups :: [Name] -> [Group] -> SC -> CaseBuilder SC
caseGroups (v:vs) gs err = do g <- altGroups gs
return $ Case (getShared gs) v (sort g)
where
getShared (ConGroup True _ _ : _) = Updatable
getShared _ = Shared
altGroups [] = return [DefaultCase err]
altGroups (ConGroup _ (CName n i) args : cs)
= (:) <$> altGroup n i args <*> altGroups cs
altGroups (ConGroup _ (CFn n) args : cs)
= (:) <$> altFnGroup n args <*> altGroups cs
altGroups (ConGroup _ CSuc args : cs)
= (:) <$> altSucGroup args <*> altGroups cs
altGroups (ConGroup _ (CConst c) args : cs)
= (:) <$> altConstGroup c args <*> altGroups cs
altGroup n i args
= do inacc <- inaccessibleArgs n
(newVars, accVars, inaccVars, nextCs) <- argsToAlt inacc args
matchCs <- match (accVars ++ vs ++ inaccVars) nextCs err
return $ ConCase n i newVars matchCs
altFnGroup n args = do (newVars, _, [], nextCs) <- argsToAlt [] args
matchCs <- match (newVars ++ vs) nextCs err
return $ FnCase n newVars matchCs
altSucGroup args = do ([newVar], _, [], nextCs) <- argsToAlt [] args
matchCs <- match (newVar:vs) nextCs err
return $ SucCase newVar matchCs
altConstGroup n args = do (_, _, [], nextCs) <- argsToAlt [] args
matchCs <- match vs nextCs err
return $ ConstCase n matchCs
-- Returns:
-- * names of all variables arising from match
-- * names of accessible variables (subset of all variables)
-- * names of inaccessible variables (subset of all variables)
-- * clauses corresponding to (accVars ++ origVars ++ inaccVars)
argsToAlt :: [Int] -> [([Pat], Clause)] -> CaseBuilder ([Name], [Name], [Name], [Clause])
argsToAlt _ [] = return ([], [], [], [])
argsToAlt inacc rs@((r, m) : rest) = do
newVars <- getNewVars r
let (accVars, inaccVars) = partitionAcc newVars
return (newVars, accVars, inaccVars, addRs rs)
where
-- Create names for new variables arising from the given patterns.
getNewVars :: [Pat] -> CaseBuilder [Name]
getNewVars [] = return []
getNewVars ((PV n t) : ns) = do v <- getVar "e"
nsv <- getNewVars ns
-- Record the type of the variable.
--
-- It seems that the ordering is not important
-- and we can put (v,t) always in front of "ntys"
-- (the varName-type pairs seem to represent a mapping).
--
-- The code that reads this is currently
-- commented out, anyway.
(cs, i, ntys) <- get
put (cs, i, (v, t) : ntys)
return (v : nsv)
getNewVars (PAny : ns) = (:) <$> getVar "i" <*> getNewVars ns
getNewVars (PTyPat : ns) = (:) <$> getVar "t" <*> getNewVars ns
getNewVars (_ : ns) = (:) <$> getVar "e" <*> getNewVars ns
-- Partition a list of things into (accessible, inaccessible) things,
-- according to the list of inaccessible indices.
partitionAcc xs =
( [x | (i,x) <- zip [0..] xs, i `notElem` inacc]
, [x | (i,x) <- zip [0..] xs, i `elem` inacc]
)
addRs [] = []
addRs ((r, (ps, res)) : rs) = ((acc++ps++inacc, res) : addRs rs)
where
(acc, inacc) = partitionAcc r
uniq i (UN n) = MN i n
uniq i n = n
getVar :: String -> CaseBuilder Name
getVar b = do (t, v, ntys) <- get; put (t, v+1, ntys); return (sMN v b)
groupCons :: [Clause] -> CaseBuilder [Group]
groupCons cs = gc [] cs
where
gc acc [] = return acc
gc acc ((p : ps, res) : cs) =
do acc' <- addGroup p ps res acc
gc acc' cs
addGroup p ps res acc = case p of
PCon uniq con i args -> return $ addg uniq (CName con i) args (ps, res) acc
PConst cval -> return $ addConG cval (ps, res) acc
PSuc n -> return $ addg False CSuc [n] (ps, res) acc
PReflected fn args -> return $ addg False (CFn fn) args (ps, res) acc
pat -> fail $ show pat ++ " is not a constructor or constant (can't happen)"
addg uniq c conargs res []
= [ConGroup uniq c [(conargs, res)]]
addg uniq c conargs res (g@(ConGroup _ c' cs):gs)
| c == c' = ConGroup uniq c (cs ++ [(conargs, res)]) : gs
| otherwise = g : addg uniq c conargs res gs
addConG con res [] = [ConGroup False (CConst con) [([], res)]]
addConG con res (g@(ConGroup False (CConst n) cs) : gs)
| con == n = ConGroup False (CConst n) (cs ++ [([], res)]) : gs
-- | otherwise = g : addConG con res gs
addConG con res (g : gs) = g : addConG con res gs
varRule :: [Name] -> [Clause] -> SC -> CaseBuilder SC
varRule (v : vs) alts err =
do alts' <- mapM (repVar v) alts
match vs alts' err
where
repVar v (PV p ty : ps , (lhs, res))
= do (cs, i, ntys) <- get
put (cs, i, (v, ty) : ntys)
return (ps, (lhs, subst p (P Bound v ty) res))
repVar v (PAny : ps , res) = return (ps, res)
repVar v (PTyPat : ps , res) = return (ps, res)
-- fix: case e of S k -> f (S k) ==> case e of S k -> f e
depatt :: [Name] -> SC -> SC
depatt ns tm = dp [] tm
where
dp ms (STerm tm) = STerm (applyMaps ms tm)
dp ms (Case up x alts) = Case up x (map (dpa ms x) alts)
dp ms sc = sc
dpa ms x (ConCase n i args sc)
= ConCase n i args (dp ((x, (n, args)) : ms) sc)
dpa ms x (FnCase n args sc)
= FnCase n args (dp ((x, (n, args)) : ms) sc)
dpa ms x (ConstCase c sc) = ConstCase c (dp ms sc)
dpa ms x (SucCase n sc) = SucCase n (dp ms sc)
dpa ms x (DefaultCase sc) = DefaultCase (dp ms sc)
applyMaps ms f@(App _ _ _)
| (P nt cn pty, args) <- unApply f
= let args' = map (applyMaps ms) args in
applyMap ms nt cn pty args'
where
applyMap [] nt cn pty args' = mkApp (P nt cn pty) args'
applyMap ((x, (n, args)) : ms) nt cn pty args'
| and ((length args == length args') :
(n == cn) : zipWith same args args') = P Ref x Erased
| otherwise = applyMap ms nt cn pty args'
same n (P _ n' _) = n == n'
same _ _ = False
applyMaps ms (App s f a) = App s (applyMaps ms f) (applyMaps ms a)
applyMaps ms t = t
-- FIXME: Do this for SucCase too
-- Issue #1719 on the issue tracker: https://github.com/idris-lang/Idris-dev/issues/1719
prune :: Bool -- ^ Convert single branches to projections (only useful at runtime)
-> SC -> SC
prune proj (Case up n alts) = case alts' of
[] -> ImpossibleCase
-- Projection transformations prevent us from seeing some uses of ctor fields
-- because they delete information about which ctor is being used.
-- Consider:
-- f (X x) = ... x ...
-- vs.
-- f x = ... x!0 ...
--
-- Hence, we disable this step.
-- TODO: re-enable this in toIR
--
-- as@[ConCase cn i args sc]
-- | proj -> mkProj n 0 args (prune proj sc)
-- mkProj n i xs sc = foldr (\x -> projRep x n i) sc xs
-- If none of the args are used in the sc, however, we can just replace it
-- with sc
as@[ConCase cn i args sc]
| proj -> let sc' = prune proj sc in
if any (isUsed sc') args
then Case up n [ConCase cn i args sc']
else sc'
[SucCase cn sc]
| proj
-> projRep cn n (-1) $ prune proj sc
[ConstCase _ sc]
-> prune proj sc
-- Bit of a hack here! The default case will always be 0, make sure
-- it gets caught first.
[s@(SucCase _ _), DefaultCase dc]
-> Case up n [ConstCase (BI 0) dc, s]
as -> Case up n as
where
alts' = filter (not . erased) $ map pruneAlt alts
pruneAlt (ConCase cn i ns sc) = ConCase cn i ns (prune proj sc)
pruneAlt (FnCase cn ns sc) = FnCase cn ns (prune proj sc)
pruneAlt (ConstCase c sc) = ConstCase c (prune proj sc)
pruneAlt (SucCase n sc) = SucCase n (prune proj sc)
pruneAlt (DefaultCase sc) = DefaultCase (prune proj sc)
erased (DefaultCase (STerm Erased)) = True
erased (DefaultCase ImpossibleCase) = True
erased _ = False
projRep :: Name -> Name -> Int -> SC -> SC
projRep arg n i (Case up x alts) | x == arg
= ProjCase (Proj (P Bound n Erased) i) $ map (projRepAlt arg n i) alts
projRep arg n i (Case up x alts)
= Case up x (map (projRepAlt arg n i) alts)
projRep arg n i (ProjCase t alts)
= ProjCase (projRepTm arg n i t) $ map (projRepAlt arg n i) alts
projRep arg n i (STerm t) = STerm (projRepTm arg n i t)
projRep arg n i c = c
projRepAlt arg n i (ConCase cn t args rhs)
= ConCase cn t args (projRep arg n i rhs)
projRepAlt arg n i (FnCase cn args rhs)
= FnCase cn args (projRep arg n i rhs)
projRepAlt arg n i (ConstCase t rhs)
= ConstCase t (projRep arg n i rhs)
projRepAlt arg n i (SucCase sn rhs)
= SucCase sn (projRep arg n i rhs)
projRepAlt arg n i (DefaultCase rhs)
= DefaultCase (projRep arg n i rhs)
projRepTm arg n i t = subst arg (Proj (P Bound n Erased) i) t
prune _ t = t
stripLambdas :: CaseDef -> CaseDef
stripLambdas (CaseDef ns (STerm (Bind x (Lam _ _) sc)) tm)
= stripLambdas (CaseDef (ns ++ [x]) (STerm (instantiate (P Bound x Erased) sc)) tm)
stripLambdas x = x
substSC :: Name -> Name -> SC -> SC
substSC n repl (Case up n' alts)
| n == n' = Case up repl (map (substAlt n repl) alts)
| otherwise = Case up n' (map (substAlt n repl) alts)
substSC n repl (STerm t) = STerm $ subst n (P Bound repl Erased) t
substSC n repl (UnmatchedCase errmsg) = UnmatchedCase errmsg
substSC n repl ImpossibleCase = ImpossibleCase
substSC n repl sc = error $ "unsupported in substSC: " ++ show sc
substAlt :: Name -> Name -> CaseAlt -> CaseAlt
substAlt n repl (ConCase cn a ns sc) = ConCase cn a ns (substSC n repl sc)
substAlt n repl (FnCase fn ns sc) = FnCase fn ns (substSC n repl sc)
substAlt n repl (ConstCase c sc) = ConstCase c (substSC n repl sc)
substAlt n repl (SucCase n' sc)
| n == n' = SucCase n (substSC n repl sc)
| otherwise = SucCase n' (substSC n repl sc)
substAlt n repl (DefaultCase sc) = DefaultCase (substSC n repl sc)
-- mkForce n' n t updates the tree t under the assumption that
-- n' = force n (so basically updating n to n')
mkForce :: Name -> Name -> SC -> SC
mkForce = mkForceSC
where
mkForceSC n arg (Case up x alts) | x == arg
= Case up n $ map (mkForceAlt n arg) alts
mkForceSC n arg (Case up x alts)
= Case up x (map (mkForceAlt n arg) alts)
mkForceSC n arg (ProjCase t alts)
= ProjCase t $ map (mkForceAlt n arg) alts
mkForceSC n arg c = c
mkForceAlt n arg (ConCase cn t args rhs)
= ConCase cn t args (mkForceSC n arg rhs)
mkForceAlt n arg (FnCase cn args rhs)
= FnCase cn args (mkForceSC n arg rhs)
mkForceAlt n arg (ConstCase t rhs)
= ConstCase t (mkForceSC n arg rhs)
mkForceAlt n arg (SucCase sn rhs)
= SucCase sn (mkForceSC n arg rhs)
mkForceAlt n arg (DefaultCase rhs)
= DefaultCase (mkForceSC n arg rhs)
forceTm n arg t = subst n arg t
| Heather/Idris-dev | src/Idris/Core/CaseTree.hs | bsd-3-clause | 34,193 | 0 | 21 | 11,246 | 13,016 | 6,632 | 6,384 | 624 | 21 |
{-# LANGUAGE NondecreasingIndentation #-}
module PlaySound (playSound) where
import System.Process
import System.Exit
import Control.Monad
import Control.Exception
import System.IO.Error
import System.IO
import System.Directory
import System.FilePath
import qualified Data.ByteString.Lazy as B
import System.Environment.Executable
players :: FilePath -> FilePath -> [(FilePath, [String])]
players myDir fn =
[ ("sox", ["-q", fn, "-d"])
, (myDir </> "contrib" </> "playmus", [fn])
]
playSound :: B.ByteString -> IO ()
playSound content = do
dir <- getTemporaryDirectory
(tmp, h) <- openTempFile dir "tttool-audio.tmp"
B.hPutStr h content
hClose h
(myDir,_) <- splitExecutablePath
tryPrograms (players myDir tmp) $ do
putStrLn "Could not play audio file."
putStrLn "Do you have \"sox\" installed?"
removeFile tmp
tryPrograms [] e = e
tryPrograms ((c,args):es) e = do
-- Missing programs cause exceptions on Windows, but error 127 on Linux.
-- Try to handle both here.
r <- tryJust (guard . isDoesNotExistError) $ do
ph <- runProcess c args Nothing Nothing Nothing Nothing Nothing
ret <- waitForProcess ph
if ret == ExitSuccess then return True
else if ret == ExitFailure 127 then return False
else do
putStrLn $ "Failed to execute \"" ++ c ++ "\" (" ++ show ret ++ ")"
exitFailure
case r of
Right True -> return ()
_ -> tryPrograms es e
| colinba/tip-toi-reveng | src/PlaySound.hs | mit | 1,525 | 0 | 19 | 391 | 441 | 228 | 213 | 40 | 4 |
yes = concat . map f | mpickering/hlint-refactor | tests/examples/Default0.hs | bsd-3-clause | 20 | 0 | 6 | 5 | 13 | 6 | 7 | 1 | 1 |
{-# LANGUAGE FlexibleContexts #-}
--------------------------------------------------------------------------------
-- | Miscellaneous string manipulation functions.
module Hakyll.Core.Util.String
( trim
, replaceAll
, splitAll
, needlePrefix
) where
--------------------------------------------------------------------------------
import Data.Char (isSpace)
import Data.List (isPrefixOf)
import Data.Maybe (listToMaybe)
import Text.Regex.TDFA ((=~~))
--------------------------------------------------------------------------------
-- | Trim a string (drop spaces, tabs and newlines at both sides).
trim :: String -> String
trim = reverse . trim' . reverse . trim'
where
trim' = dropWhile isSpace
--------------------------------------------------------------------------------
-- | A simple (but inefficient) regex replace funcion
replaceAll :: String -- ^ Pattern
-> (String -> String) -- ^ Replacement (called on capture)
-> String -- ^ Source string
-> String -- ^ Result
replaceAll pattern f source = replaceAll' source
where
replaceAll' src = case listToMaybe (src =~~ pattern) of
Nothing -> src
Just (o, l) ->
let (before, tmp) = splitAt o src
(capture, after) = splitAt l tmp
in before ++ f capture ++ replaceAll' after
--------------------------------------------------------------------------------
-- | A simple regex split function. The resulting list will contain no empty
-- strings.
splitAll :: String -- ^ Pattern
-> String -- ^ String to split
-> [String] -- ^ Result
splitAll pattern = filter (not . null) . splitAll'
where
splitAll' src = case listToMaybe (src =~~ pattern) of
Nothing -> [src]
Just (o, l) ->
let (before, tmp) = splitAt o src
in before : splitAll' (drop l tmp)
--------------------------------------------------------------------------------
-- | Find the first instance of needle (must be non-empty) in haystack. We
-- return the prefix of haystack before needle is matched.
--
-- Examples:
--
-- > needlePrefix "cd" "abcde" = "ab"
--
-- > needlePrefix "ab" "abc" = ""
--
-- > needlePrefix "ab" "xxab" = "xx"
--
-- > needlePrefix "a" "xx" = "xx"
needlePrefix :: String -> String -> Maybe String
needlePrefix needle haystack = go [] haystack
where
go _ [] = Nothing
go acc xss@(x:xs)
| needle `isPrefixOf` xss = Just $ reverse acc
| otherwise = go (x : acc) xs
| oldmanmike/hakyll | src/Hakyll/Core/Util/String.hs | bsd-3-clause | 2,610 | 0 | 15 | 640 | 501 | 277 | 224 | 39 | 2 |
{-# LANGUAGE CPP #-}
-- to suppress WARNING in "Distribution.Compat.Prelude.Internal"
{-# OPTIONS_GHC -fno-warn-deprecations #-}
-- | This module does two things:
--
-- * Acts as a compatiblity layer, like @base-compat@.
--
-- * Provides commonly used imports.
--
-- This module is a superset of "Distribution.Compat.Prelude" (which
-- this module re-exports)
--
module Distribution.Client.Compat.Prelude
( module Distribution.Compat.Prelude.Internal
, Prelude.IO
, readMaybe
) where
import Prelude (IO)
import Distribution.Compat.Prelude.Internal hiding (IO)
#if MIN_VERSION_base(4,6,0)
import Text.Read
( readMaybe )
#endif
#if !MIN_VERSION_base(4,6,0)
-- | An implementation of readMaybe, for compatibility with older base versions.
readMaybe :: Read a => String -> Maybe a
readMaybe s = case reads s of
[(x,"")] -> Just x
_ -> Nothing
#endif
| mydaum/cabal | cabal-install/Distribution/Client/Compat/Prelude.hs | bsd-3-clause | 907 | 0 | 9 | 178 | 132 | 84 | 48 | 12 | 2 |
module Test19 where
f y = y
| kmate/HaRe | old/testing/refacSlicing/Test19_TokOut.hs | bsd-3-clause | 30 | 0 | 5 | 9 | 12 | 7 | 5 | 2 | 1 |
module Dependent where
import Dependency
dependent :: Int
dependent = dependency
| janicduplessis/buck | test/com/facebook/buck/haskell/testdata/library_test/Dependent.hs | apache-2.0 | 83 | 0 | 4 | 13 | 17 | 11 | 6 | 4 | 1 |
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Data.Aeson (toJSON, eitherDecodeStrict, encode, withObject, withArray)
import Control.Monad as CM (join)
import Data.Aeson.Types (Value (String), Parser, parseMaybe, (.:))
import Control.Monad.Catch (throwM)
import Data.ByteString (ByteString)
import GHC.Exts (fromList, IsString)
import qualified Data.HashMap.Strict as HM (HashMap, fromList)
import qualified Data.ByteString as B (readFile)
import qualified Data.List as DL (sortBy, groupBy)
import qualified Data.Vector as V (toList)
import qualified Data.ByteString.Lazy as BSL (writeFile)
import Data.Hashable (Hashable)
import Data.Maybe (isJust, fromMaybe)
main :: IO ()
main = do
u <- readJSONFileStrict "example.json"
print $ mapFromPairList $ fromMaybe [] (parseMaybe parseArray' u)
writeJSONFileLazy "example_grouped.json" $ toJSON (mapFromPairList $ fromMaybe [] (parseMaybe parseArray' u))
mapFromPairList :: (Eq b, IsString a, Ord a, Hashable a) => [(a, b)] -> HM.HashMap a [b]
mapFromPairList myList = let unzippedGroups = fmap unzip (groupTupleList myList)
in HM.fromList $ fmap (\group -> (head (fst group), snd group)) unzippedGroups
sortTupleList :: (Eq a, Eq b, Ord a) => [(a, b)] -> [(a, b)]
sortTupleList myList = DL.sortBy (\a b -> compare (fst a) (fst b)) myList
groupTupleList :: (Eq a, Eq b, Ord a) => [(a, b)] -> [[(a, b)]]
groupTupleList myList = DL.groupBy pairKeyMatches $ sortTupleList myList
pairKeyMatches :: (Eq a) => (a, b) -> (a, b) -> Bool
pairKeyMatches x y = (fst x) == (fst y)
parseArray' :: Value -> Parser [(String, String)]
parseArray' = withArray "array of tuples" $ \arr ->
mapM parseTuple' (V.toList arr)
parseTuple' :: Value -> Parser (String, String)
parseTuple' = withObject "tuple" $ \o -> do
a <- o .: "a"
b <- o .: "b"
return (a, b)
-- modified from https://stackoverflow.com/a/41566055/382936
readJSONFileStrict :: FilePath -> IO Value
readJSONFileStrict fp = do
bs <- B.readFile fp
case eitherDecodeStrict bs of
Left e -> throwM $ userError e
Right x -> return x
writeJSONFileLazy :: FilePath -> Value -> IO ()
writeJSONFileLazy fp jsonValue =
BSL.writeFile fp (encode jsonValue)
| difley/modern-sawhorse | app/Main.hs | mit | 2,227 | 0 | 14 | 396 | 856 | 468 | 388 | 46 | 2 |
module MppAST where
import PrettyPrint
import ParserPos
{- AST for the M++ language. From M++ language spec. -}
data M_prog = M_prog ([M_decl],[M_stmt]) deriving (Eq)
data M_decl = M_var (String,[M_expr],M_type) Pos
| M_fun (String,[(String,Int,M_type)],M_type,[M_decl],[M_stmt]) Pos
| M_data (String,[(String,[M_type])]) Pos deriving (Eq)
data M_stmt = M_ass (String,[M_expr],M_expr) Pos
| M_while (M_expr,M_stmt) Pos
| M_cond (M_expr,M_stmt,M_stmt) Pos
| M_read (String,[M_expr]) Pos
| M_print M_expr Pos
| M_return M_expr Pos
| M_block ([M_decl],[M_stmt]) Pos
| M_case (M_expr,[(String,[String],M_stmt,Pos)]) Pos deriving (Eq)
data M_type = M_int | M_bool | M_real | M_char | M_strtype String deriving (Eq, Show)
data M_expr = M_ival Int Pos
| M_rval Float Pos
| M_bval Bool Pos
| M_cval Char Pos
| M_size (String,Int) Pos
| M_id (String,[M_expr]) Pos
| M_app (M_operation,[M_expr]) Pos deriving (Eq)
data M_operation = M_fn String
| M_cid String
| M_add | M_mul | M_sub | M_div | M_neg
| M_lt | M_le | M_gt | M_ge | M_eq | M_not | M_and | M_or
| M_float | M_floor | M_ceil deriving (Eq, Show)
ePos :: M_expr -> Pos
ePos (M_ival _ p) = p
ePos (M_rval _ p) = p
ePos (M_bval _ p) = p
ePos (M_cval _ p) = p
ePos (M_size _ p) = p
ePos (M_id _ p) = p
ePos (M_app _ p) = p
instance Show M_prog where
show (M_prog (ds,ss)) = "M_prog (\n" ++ indent ("M_decl (\n" ++
(indent (showlist "\n" ds)) ++ "\n) M_stmt (\n" ++
(indent (showlist "\n" ss)) ++ "\n)") ++ "\n)\n"
instance Show M_decl where
show (M_var v _) = "M_var (" ++ show v ++ ")"
show (M_fun (nm,args, t, ds, ss) _) = "M_fun (" ++ show nm ++ " " ++
show args ++ " " ++ show t ++ "\n" ++ indent ("M_decl (\n" ++
(indent (showlist "\n" ds)) ++ "\n) M_stmt (\n" ++
(indent (showlist "\n" ss)) ++ "\n)") ++ "\n)"
show (M_data (nm, ss) _) = "M_data (" ++ show nm ++ "\n" ++
(indent (showlist "\n" ss )) ++ "\n)"
instance Show M_stmt where
show (M_ass (nm, exprs, val) _) = "M_ass (" ++ show nm ++ ", " ++
(showlist ", " exprs) ++ " " ++ show val ++ ")"
show (M_while (e, st) _) = "M_while (" ++ show e ++ (show st) ++
")"
show (M_cond (e, s1, s2) _) = "M_cond (" ++ show e ++ "\n" ++
(indent (showlist "\n" [s1, s2])) ++ "\n)"
show (M_read (s, exprs) _) = "M_read (" ++ show s ++ "\n" ++
(indent (showlist ", " exprs)) ++ ")"
show (M_print e _) = "M_print (" ++ show e ++ ")"
show (M_return e _) = "M_return (" ++ show e ++ ")"
show (M_block (ds,ss) _) = "M_block (\n" ++ indent ("M_decl (\n" ++
(indent (showlist "\n" ds)) ++ "\n) M_stmt (\n" ++
(indent (showlist "\n" ss)) ++ "\n)") ++ "\n)"
show (M_case (e, cs) _) = "M_case (" ++ show e ++
(indent ("\n" ++ (showlist "\n" cs))) ++ "\n)"
instance Show M_expr where
show (M_ival i _) = "M_ival (" ++ tidy i ++ ")"
show (M_rval r _) = "M_rval (" ++ tidy r ++ ")"
show (M_bval b _) = "M_bval (" ++ tidy b ++ ")"
show (M_cval c _) = "M_cval (" ++ tidy c ++ ")"
show (M_size (nm,sz) _) = "M_size (" ++ tidy (nm,sz) ++ ")"
show (M_id (nm, []) _) = "M_id (" ++ tidy nm ++ " [])"
show (M_id (nm, exprs) _) = "M_id (" ++ tidy nm ++ " " ++
(showlist ", " exprs) ++ ")"
show (M_app (op, []) _) = "M_app (" ++ tidy op ++ " [])"
show (M_app (op, es) _) = "M_app (" ++ tidy op ++ " " ++
(showlist ", " es) ++ ")"
| JamesSullivan1/Mpp | src/MppAST.hs | mit | 3,513 | 0 | 17 | 943 | 1,629 | 878 | 751 | 76 | 1 |
module Main where
import Data.Trie.Test (trieTest)
import Spell.Test (spellTest)
import Test.Hspec (hspec, parallel)
main :: IO ()
main = hspec $ parallel (trieTest >> spellTest)
| fgrsnau/spell | test/Main.hs | mit | 181 | 0 | 8 | 27 | 67 | 39 | 28 | 6 | 1 |
module Rebase.Data.Time.LocalTime
(
module Data.Time.LocalTime
)
where
import Data.Time.LocalTime
| nikita-volkov/rebase | library/Rebase/Data/Time/LocalTime.hs | mit | 101 | 0 | 5 | 12 | 23 | 16 | 7 | 4 | 0 |
import Data.List
import Data.List.Extra
type Box = (Int, Int, Int)
readBox :: String -> Box
readBox s =
let [a, b, c] = map read $ wordsBy (=='x') s
in (a, b, c)
calcBox :: Box -> Int
calcBox (l, w, h) =
let sides = sort [l*w, l*h, w*h]
in 2*sum sides + head sides
answer f = interact $ (++"\n") . show . f
main = answer $ sum . map (calcBox . readBox) . lines
| msullivan/advent-of-code | 2015/A2a.hs | mit | 373 | 0 | 11 | 90 | 216 | 117 | 99 | 13 | 1 |
------------------------------------------------------------------------------
-- | This module defines our application's state type and an alias for its
-- handler monad.
module Application where
------------------------------------------------------------------------------
import Snap
import Control.Lens
import Snap.Snaplet
import Snap.Snaplet.PostgresqlSimple
------------------------------------------------------------------------------
-- | The Haskitter type identifies our application and holds anything our snaplet needs to function.
data Haskitter = Haskitter
{ _pg :: Snaplet Postgres }
makeLenses ''Haskitter
------------------------------------------------------------------------------
-- | (Handle b v) is a Monad
type AppHandler = Handler Haskitter Haskitter
| lkania/Haskitter | src/Application.hs | mit | 808 | 0 | 9 | 105 | 68 | 42 | 26 | -1 | -1 |
{-# LANGUAGE ScopedTypeVariables #-}
module Hasgel.GL.Buffer (
Buffer, BufferData(..), BufferTarget(..), BufferUsage(..), BoundBuffer,
bindBuffer, bufferData,
clearBufferfv, clearDepthBuffer
) where
import Control.Monad.IO.Class (MonadIO (..))
import Foreign (Ptr, Storable (..), castPtr, with, withArray)
import Graphics.GL.Core45
import Graphics.GL.Types
import Hasgel.GL.Object
newtype Buffer = Buffer GLuint deriving (Show)
instance Object Buffer where
object (Buffer obj) = obj
deletes = deletesWith glDeleteBuffers
instance Gen Buffer where
gens = gensWith glGenBuffers Buffer
data BufferTarget =
ArrayBuffer
| ElementArrayBuffer
deriving (Show, Ord, Eq)
marshalBufferTarget :: BufferTarget -> GLenum
marshalBufferTarget ArrayBuffer = GL_ARRAY_BUFFER
marshalBufferTarget ElementArrayBuffer = GL_ELEMENT_ARRAY_BUFFER
data BufferUsage =
StaticDraw
deriving (Show, Ord, Eq)
marshalBufferUsage :: BufferUsage -> GLenum
marshalBufferUsage StaticDraw = GL_STATIC_DRAW
class BufferData a where
withDataPtr :: (BufferData a, MonadIO m) => a -> (Ptr () -> IO b) -> m b
sizeOfData :: BufferData a => a -> Int
instance Storable a => BufferData [a] where
withDataPtr vs action = liftIO . withArray vs $ action . castPtr
sizeOfData vs = length vs * sizeOf (undefined :: a)
type DrawBuffer = GLint
type ClearBuffer = GLenum
type BoundBuffer = WithUse BufferTarget
bindBuffer :: MonadIO m => BufferTarget -> Buffer -> BoundBuffer m a -> m a
bindBuffer target buffer actions = do
glBindBuffer (marshalBufferTarget target) $ object buffer
runWithUse actions target
bufferData :: (MonadIO m, BufferData a) => a -> BufferUsage -> BoundBuffer m ()
bufferData values usage = askUse >>= \target ->
let bytes = fromIntegral $ sizeOfData values
in withDataPtr values $ \ptr ->
glBufferData (marshalBufferTarget target) bytes ptr (marshalBufferUsage usage)
clearBufferfv :: MonadIO m => ClearBuffer -> DrawBuffer -> [GLfloat] -> m ()
clearBufferfv buffer drawBuffer values =
liftIO . withArray values $ glClearBufferfv buffer drawBuffer
clearDepthBuffer :: MonadIO m => GLfloat -> m ()
clearDepthBuffer value = liftIO . with value $ glClearBufferfv GL_DEPTH 0
| Th30n/hasgel | src/Hasgel/GL/Buffer.hs | mit | 2,202 | 0 | 13 | 355 | 699 | 369 | 330 | 51 | 1 |
module Main where
import Prolog
main :: IO ()
main = prolog
| sdemos/prolog | app/Main.hs | mit | 62 | 0 | 6 | 14 | 22 | 13 | 9 | 4 | 1 |
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module ActionSpec (main, spec) where
import Test.Hspec
import Test.QuickCheck
import qualified Test.QuickCheck.Monadic as QC
import Control.Monad.IO.Class
import Data.String.Builder
import Data.List (sort)
import Database (entryName)
import qualified Run
import Data.IORef
import Cipher
import qualified Data.Knob as K
import qualified Data.ByteString.Char8 as B
import System.IO
import Config
import DatabaseSpec (DatabaseFile(..))
mockSink :: IO ((a -> IO ()), IO [a])
mockSink = do
ref <- newIORef []
return (modifyIORef ref . (:), reverse `fmap` readIORef ref)
data PWSafeResult = PWSafeResult {
resultOutput :: String
, resultDatabase :: String
, resultClipboard :: [String]
}
pwsafe :: String -> String -> IO PWSafeResult
pwsafe args db = do
(clipboardSink, clipboardAccessor) <- mockSink
c <- idCipher
encrypt c db
k <- K.newKnob ""
K.withFileHandle k "knob.txt" WriteMode $ \h -> do
Run.run (conf clipboardSink) (const c) h (words args)
db_ <- Cipher.decrypt c
out <- B.unpack `fmap` K.getContents k
clipboard <- clipboardAccessor
return (PWSafeResult out db_ clipboard)
where
conf clipboardSink = Config {
copyToClipboard = clipboardSink
, openUrl = const $ return ()
, generateUser = return "default user"
, generatePassword = return "default password"
}
idCipher :: IO Cipher
idCipher = do
ref <- newIORef ""
return $ Cipher (writeIORef ref) (readIORef ref)
shouldBeBuilder :: String -> Builder -> Expectation
shouldBeBuilder a b = a `shouldBe` build b
shouldBeQC :: (Eq a, Show a) => a -> a -> QC.PropertyM IO ()
actual `shouldBeQC` expected = do
if actual == expected then return () else do
fail $ "expected: " ++ show expected ++ "\n but got: " ++ show actual
main :: IO ()
main = hspec spec
spec :: Spec
spec = do
describe "list" $ do
it "works on a config with one entry" $ do
r <- pwsafe "--list" $ build $ do
"[example.com]"
"user=foo"
"password=bar"
"url=http://example.com"
resultOutput r `shouldBe` " example.com\n"
it "works on a config with arbitrary entries" $ property $ \(DatabaseFile db xs) -> QC.monadicIO $ do
r <- liftIO $ pwsafe "--list" db
let expected = unlines $ sort $ map ((" " ++) . entryName) xs
resultOutput r `shouldBeQC` expected
it "optionally takes a pattern" $ do
r <- pwsafe "--list=bar" $ build $ do
"[foo]"
"[bar]"
"[baz]"
"[foobar]"
"[foobarbaz]"
"[FOOBARBAZ]"
resultOutput r `shouldBe` (build $ do
" FOOBARBAZ"
" bar"
" foobar"
" foobarbaz"
)
describe "add" $ do
it "adds an entry to an empty config" $ do
r <- pwsafe "--add http://example.com/" ""
resultDatabase r `shouldBeBuilder` do
"[example.com]"
"user=default user"
"password=default password"
"url=http://example.com/"
it "adds an entry to a config with one entry" $ do
r <- pwsafe "--add http://example.com/" $ build $ do
"[foobar.com]"
"user=foo"
"password=bar"
resultDatabase r `shouldBeBuilder` do
"[foobar.com]"
"user=foo"
"password=bar"
""
"[example.com]"
"user=default user"
"password=default password"
"url=http://example.com/"
it "adds an entry to an arbitrary config" $ property $ \(DatabaseFile db xs) -> all ((/= "example.com") . entryName) xs ==> QC.monadicIO $ do
r <- liftIO $ pwsafe "--add http://example.com/" db
entry <- return . build $ do
"[example.com]"
"user=default user"
"password=default password"
"url=http://example.com/"
let expected = if null db then entry else db ++ "\n" ++ entry
resultDatabase r `shouldBeQC` expected
it "fails on duplicate entry" $ do
c <- return . build $ do
"[example.com]"
"user=foo"
"password=bar"
"url=http://example.com"
pwsafe "--add http://example.com/" c `shouldThrow` errorCall "Entry with name \"example.com\" already exists!"
it "accepts an optional --user argument" $ do
r <- pwsafe "--add http://example.com/ --user me" ""
resultDatabase r `shouldBeBuilder` do
"[example.com]"
"user=me"
"password=default password"
"url=http://example.com/"
describe "query" $ do
it "copies user name and password to clipboard" $ do
r <- pwsafe "--query example.com" $ build $ do
"[example.com]"
"user=foo"
"password=bar"
"url=http://example.com/"
resultClipboard r `shouldBe` ["foo", "bar"]
it "copies password multiple times to clipboard, if -n is given" $ do
r <- pwsafe "--query example.com -n 3" $ build $ do
"[example.com]"
"user=foo"
"password=bar"
"url=http://example.com/"
resultClipboard r `shouldBe` ["foo", "bar", "bar", "bar"]
it "copies only password to clipboard when given --password-only" $ do
r <- pwsafe "--query example.com --password-only" $ build $ do
"[example.com]"
"user=foo"
"password=bar"
"url=http://example.com/"
resultClipboard r `shouldBe` ["bar"]
describe "idCipher (test helper)" $ do
it "can encrypt and decrypt" $ property $ \s -> QC.monadicIO $ do
r <- liftIO $ do
c <- idCipher
encrypt c s
decrypt c
r `shouldBeQC` s
describe "mockSink (test helper)" $ do
it "provides access to values put into the sink" $ do
(sink, accessor) <- mockSink
sink ("foo" :: String)
sink "bar"
sink "baz"
r <- accessor
r `shouldBe` ["foo", "bar", "baz"]
| sol/pwsafe | test/ActionSpec.hs | mit | 5,938 | 0 | 22 | 1,684 | 1,592 | 767 | 825 | 164 | 2 |
{-# LANGUAGE NoImplicitPrelude, OverloadedStrings, RecordWildCards #-}
module Eyeshadow.Data.Token
(TokenType(..),
Token(..))
where
import qualified Data.Text as Text
import Data.Char
import Data.Maybe
import Eyeshadow.Data.Span
import Eyeshadow.Prelude
data TokenType
= WordTokenType
| NumberTokenType
| StringTokenType
| OperatorTokenType
| PeriodTokenType
| EllipsisTokenType
| HyphenTokenType
| DashTokenType
| CommaTokenType
| ColonTokenType
| SemicolonTokenType
| TickTokenType
| BacktickTokenType
| SpliceTokenType
| ListSpliceTokenType
| OpenParenthesisTokenType
| CloseParenthesisTokenType
| SpaceTokenType
| ParagraphBreakTokenType
deriving (Eq)
data Token =
Token {
tokenType :: TokenType,
tokenSpan :: Span,
tokenText :: Text.Text,
tokenValue :: Maybe Text.Text,
tokenOpenDelimiter :: Maybe Char,
tokenCloseDelimiter :: Maybe Char
}
instance HasSpan Token where
spanOf Token{..} = tokenSpan
instance Show Token where
show Token{..} =
case tokenType of
WordTokenType -> "word"
NumberTokenType -> "number"
StringTokenType -> "string"
OperatorTokenType -> "operator"
PeriodTokenType -> "period"
EllipsisTokenType -> "ellipsis"
HyphenTokenType -> "hyphen"
DashTokenType -> "dash"
CommaTokenType -> "comma"
ColonTokenType -> "colon"
SemicolonTokenType -> "semicolon"
TickTokenType -> "tick"
BacktickTokenType -> "backtick"
SpliceTokenType -> "splice"
ListSpliceTokenType -> "list-splice"
OpenParenthesisTokenType -> "open-parenthesis"
CloseParenthesisTokenType -> "close-parenthesis"
SpaceTokenType -> "space"
ParagraphBreakTokenType -> "paragraph-break"
| IreneKnapp/Eyeshadow | Haskell/Eyeshadow/Data/Token.hs | mit | 1,780 | 0 | 10 | 386 | 341 | 195 | 146 | 62 | 0 |
import Data.Char (ord)
import Data.List
main = do
str <- readFile "Problem0022.txt"
print $ problem22Value str
problem22Value :: String -> Int
problem22Value str = sum $ getNameScores $ sort $ lines str
getNameScores :: [String] -> [Int]
getNameScores names = getNameScores' 1 names
where getNameScores' _ [] = []
getNameScores' i (name:names) = (i * (alphaValue name)):(getNameScores' (i+1) names)
baseAlphaValue :: Int
baseAlphaValue = (ord 'A') - 1
alphaValue :: String -> Int
alphaValue name = sum $ map (\x -> (ord x) - baseAlphaValue) name
| jchitel/ProjectEuler.hs | Problems/Problem0022.hs | mit | 573 | 0 | 11 | 113 | 230 | 119 | 111 | 15 | 2 |
module Cube
( draw
) where
import qualified Graphics.Rendering.OpenGL as GL
draw :: GL.GLfloat -> IO ()
draw s = do
GL.scale s s s
GL.renderPrimitive GL.Quads $ do
-- front
GL.color red
GL.normal (GL.Normal3 z z p1)
GL.vertex (GL.Vertex3 n1 n1 p1)
GL.vertex (GL.Vertex3 p1 n1 p1)
GL.vertex (GL.Vertex3 p1 p1 p1)
GL.vertex (GL.Vertex3 n1 p1 p1)
-- back
GL.color red
GL.normal (GL.Normal3 z z n1)
GL.vertex (GL.Vertex3 n1 n1 n1)
GL.vertex (GL.Vertex3 n1 p1 n1)
GL.vertex (GL.Vertex3 p1 p1 n1)
GL.vertex (GL.Vertex3 p1 n1 n1)
-- top
GL.color green
GL.normal (GL.Normal3 z p1 z)
GL.vertex (GL.Vertex3 n1 p1 n1)
GL.vertex (GL.Vertex3 n1 p1 p1)
GL.vertex (GL.Vertex3 p1 p1 p1)
GL.vertex (GL.Vertex3 p1 p1 n1)
-- bottom
GL.color green
GL.normal (GL.Normal3 z n1 z)
GL.vertex (GL.Vertex3 n1 n1 n1)
GL.vertex (GL.Vertex3 p1 n1 n1)
GL.vertex (GL.Vertex3 p1 n1 p1)
GL.vertex (GL.Vertex3 n1 n1 p1)
-- right
GL.color blue
GL.normal (GL.Normal3 p1 z z)
GL.vertex (GL.Vertex3 p1 n1 n1)
GL.vertex (GL.Vertex3 p1 p1 n1)
GL.vertex (GL.Vertex3 p1 p1 p1)
GL.vertex (GL.Vertex3 p1 n1 p1)
-- left
GL.color blue
GL.normal (GL.Normal3 n1 z z)
GL.vertex (GL.Vertex3 n1 n1 n1)
GL.vertex (GL.Vertex3 n1 n1 p1)
GL.vertex (GL.Vertex3 n1 p1 p1)
GL.vertex (GL.Vertex3 n1 p1 n1)
red, green, blue :: GL.Color4 GL.GLfloat
red = GL.Color4 1 0 0 1
green = GL.Color4 0 1 0 1
blue = GL.Color4 0 0 1 1
z, n1, p1 :: GL.GLfloat
z = 0
n1 = -1
p1 = 1
| spetz911/progames | GLFW/src1/Cube.hs | mit | 1,778 | 0 | 13 | 614 | 814 | 382 | 432 | 51 | 1 |
-- This module was formerly called "HugsUtils" - but it was
-- too messy to make it a "standard Hugs library" so we moved it
-- over here.
module Haskore.Utils(
assert,
unlinesS, concatS, rightS, leftS, centreS,
right, left, centre, spaces,
andOnError, butOnError,
zeroOrMore, oneOrMore,
) where
import Control.Monad
import qualified Control.Exception as X
-- ToDo: decide on appropriate fixities for these functions
infixr 2 `andOnError`, `butOnError`
assert :: Bool -> String -> IO ()
assert True _ = return ()
assert False msg = ioError (userError msg)
unlinesS :: [ShowS] -> ShowS
unlinesS = concatS . map (. (showString "\n"))
concatS :: [ShowS] -> ShowS
concatS = foldr (.) id
rightS, leftS, centreS :: Int -> ShowS -> ShowS
rightS n s = showString (right n (s ""))
leftS n s = showString (left n (s ""))
centreS n s = showString (centre n (s ""))
right,left, centre :: Int -> String -> String
right n s = spaces (n - length s) ++ s
left n s = s ++ spaces (n - length s)
centre n s = spaces l ++ s ++ spaces (n'-l)
where
n' = n - length s
l = n' `div` 2
spaces :: Int -> String
spaces n = replicate (n `max` 0) ' '
-- Resource (de)allocation can interact badly with error handling code.
-- For example, even if the programmer has taken care that every
-- resource allocation is paired with an appropriate deallocation,
-- they might forget to release resources when an exception is
-- invoked. For example, this program would fail to close
-- "outFile" if an error occured while operating on one of the "inFile"s.
--
-- cat :: String -> [String] -> IO ()
-- cat outfile files = do
-- outFile <- open outfile WriteMode
-- mapM_ (\file -> do
-- inFile <- open file ReadMode
-- copy inFile outFile
-- close inFile
-- )
-- files
-- close outFile
--
-- The following functions provide ways of ensuring that a piece of
-- "cleanup code" is executed even if an exception is raised.
--
-- "m `andOnError` k" is like "m >> k" except that "k" gets executed
-- even if an exception is raised in "m".
--
-- "m `butOnError` k" is like "m" except that "k" gets executed if
-- an exception is raised in "m".
--
-- For example, the following version of "cat" guarantees to close all
-- files even if an error occurs.
--
-- cleancat :: String -> [String] -> IO ()
-- cleancat outfile files = do
-- outFile <- open outfile WriteMode
-- mapM_ (\file -> do
-- open file ReadMode >>= \ inFile ->
-- copy inFile outFile `andOnError`
-- close inFile
-- )
-- files
-- `andOnError`
-- close outFile
andOnError :: IO a -> IO b -> IO b
m `andOnError` k = (m `X.catch` \e -> k >> ioError e) >> k
-- Use this to add some cleanup code k that only gets executed
-- if an error occurs during execution of m.
butOnError :: IO a -> IO () -> IO a
m `butOnError` k = (m `X.catch` \e -> k >> ioError e)
zeroOrMore, oneOrMore :: MonadPlus m => m a -> m [a]
zeroOrMore m = return [] `mplus` oneOrMore m
oneOrMore m = do { a <- m; as <- zeroOrMore m; return (a:as) }
| yav/haskore-vintage | src/Haskore/Utils.hs | mit | 3,119 | 10 | 10 | 754 | 712 | 404 | 308 | 35 | 1 |
import System.Random as Random
removeAt :: Int -> [a] -> [a]
removeAt _ [] = []
removeAt 0 (h:t) = t
removeAt x list | x > length list - 1 = error ("list doesnt have index " ++ show x)
| x < 0 = error "X cannot be negative"
| x > 0 = l1 ++ t2
where (l1, (h2:t2)) = splitAt x list
{- Generate a random permutation of the elements of a list. -}
randomPermute :: [a] -> IO [a]
randomPermute [] = return []
randomPermute l = do
rindex <- Random.randomRIO(0, length l - 1)
rest <- randomPermute $ removeAt rindex l
return (l!!rindex:rest)
| andrewaguiar/s99-haskell | p25.hs | mit | 674 | 0 | 11 | 249 | 257 | 128 | 129 | 14 | 1 |
module Stackage.CLI.Setup (
-- TODO
) where
-- TODO: move functionality from main/StackageSetup.hs
| fpco/stackage-setup | src/Stackage/CLI/Setup.hs | mit | 104 | 0 | 3 | 18 | 12 | 9 | 3 | 1 | 0 |
{-# LANGUAGE PartialTypeSignatures #-}
module Ohua.Feature.TailRec.Passes.DFLang where
import Ohua.Prelude
import Ohua.DFLang.Lang
import Ohua.DFLang.Refs as Refs
import Ohua.DFLang.Util
import qualified Ohua.Feature.TailRec.Passes.ALang as ALangPass
import Data.Sequence as DS (fromList)
recurLowering :: DFExpr -> DFExpr
recurLowering (DFExpr letExprs returnVar)
-- 1. Find the recurFun with two outputs
=
flip DFExpr returnVar $
DS.fromList $
filter ((/= ALangPass.recurEndMarker) . nodeRef . functionRef) $
transform transformator (toList letExprs)
where
transformator [] = []
transformator l@(recurStart:rest) =
if nodeRef (functionRef recurStart) /= ALangPass.recurStartMarker
then l
else assert (length (output recurStart) == 2) $
let findEnd l@(LetExpr {functionRef = f})
| nodeRef f == ALangPass.recurEndMarker = l
-- all paths lead to the final recurFun because this is a connected component where
-- the recurFun at the very end has the only outgoing arc.
findEnd e = findEnd $ allSuccessors e
-- FIXME This code is unable to handle stmts,i.e.,
-- function calls whose return value is not used anymore.
allSuccessors b = (head b) $ (flip findUsages rest <=< output) b
endFunction = findEnd $ allSuccessors recurStart
fixRef:cond:recurArgs = callArguments endFunction
in recurStart
{ output = output recurStart <> output endFunction
, functionRef = Refs.recurFun
-- FIXME we don't need the var lists when we use the assertion
-- that these two lists have the same size! and this is always
-- true because these are the arguments to a call to the same
-- function, i.e, the recursion!
, callArguments =
fixRef :
cond : callArguments recurStart <> recurArgs
} :
rest
head b (x:_) = x
head b _ = error $ "head: unable to find usages for " <> show b
| ohua-dev/ohua-core | core/src/Ohua/Feature/TailRec/Passes/DFLang.hs | epl-1.0 | 2,384 | 0 | 18 | 896 | 430 | 233 | 197 | 36 | 5 |
{- Copyright (c) 2005 John Goerzen
<[email protected]>
Please see the COPYRIGHT file
-}
module Config where
import System.Posix.User
import System.Directory
import Data.ConfigFile
import Data.Either.Utils
import Control.Monad
import Data.String.Utils
import Text.Regex
getHomeDir = do uid <- getEffectiveUserID
entry <- getUserEntryForID uid
return (homeDirectory entry)
getConfigPath = do hd <- getHomeDir
return $ hd ++ "/.darcs-buildpackage"
{- | Returns the (upstream, debian) Darcs repository directories for
a package. -}
getDirectories :: String -> IO (String, String)
getDirectories package =
let worker cp =
do cp2 <- set cp "DEFAULT" "package" package
upstr <- get cp2 "DEFAULT" "upstreamrepo"
deb <- get cp2 "DEFAULT" "debianrepo"
return (upstr, deb)
in do cp <- loadCP
return $ forceEither $ worker cp
loadCP :: IO ConfigParser
loadCP =
let startCP = emptyCP {accessfunc = interpolatingAccess 5}
in do cpath <- getConfigPath
isfile <- doesFileExist cpath
unless isfile $ fail $ "Please create the configuration file " ++ cpath
cp <- readfile startCP cpath
return $ forceEither cp
{- | Gets a mirror list. Returns an empty list if no mirror specified. -}
getMirrors :: String -> String -> IO [String]
getMirrors typ package =
do cp <- loadCP
let cp2 = forceEither $ set cp "DEFAULT" "package" package
return $ case get cp2 "DEFAULT" (typ ++ "mirrors") of
Left _ -> []
Right x -> splitRegex (mkRegex "[ \t\n]+") (strip x)
| jgoerzen/darcs-buildpackage | Config.hs | gpl-2.0 | 1,697 | 0 | 13 | 485 | 431 | 209 | 222 | 37 | 2 |
module Matrizer.MTypes where
import qualified Data.Map as Map
import Text.Parsec
import Control.Monad.Error
----------------------------------------------------------------------
-- AST Definition
-----------------------------------------------------------------------
type VarName = String
data Expr = Leaf VarName
| IdentityLeaf Int
| ZeroLeaf Int Int
| LiteralScalar Float
| Branch1 UnOp Expr
| Branch2 BinOp Expr Expr
| Branch3 TernOp Expr Expr Expr
| Let VarName Expr Bool Expr -- bool flag specifies whether this intermediate variable can be optimized out
deriving (Eq, Ord, Show)
data TernOp = MTernaryProduct deriving (Eq, Ord, Show)
data BinOp = MProduct
| MSum
| MDiff
| MLinSolve
| MCholSolve
| MTriSolve
| MScalarProduct
| MHadamardProduct
| MColProduct
deriving (Eq, Ord, Enum, Show)
data UnOp = MInverse
| MTranspose
| MChol
| MTrace
| MDet
| MDeriv VarName
| MUnresolvedDeriv VarName
| MDifferential
| MDiagVM -- convert a vector to a diagonal matrix
| MDiagMV -- extract a matrix diagonal as a vector
| MEntrySum
| MElementWise ScalarOp
deriving (Eq, Ord, Show)
data ScalarOp = MLog
| MExp -- TODO: support matrix exponentials
| MReciprocal
deriving (Eq, Ord, Enum, Show)
-- AST pretty printing
pprint_ternop MTernaryProduct = "***"
pprint_binop MProduct = "mmul"
pprint_binop MScalarProduct = "smul"
pprint_binop MHadamardProduct = "hmul"
pprint_binop MColProduct = "cmul" -- don't really expect people to use this input syntax
-- except for internal test cases
pprint_binop MSum = "add"
pprint_binop MDiff = "sub"
pprint_binop MLinSolve = "solve"
pprint_binop MTriSolve = "triSolve"
pprint_binop MCholSolve = "cholSolve"
pprint_unop MInverse = "inv"
pprint_unop MTranspose = "transpose"
pprint_unop MChol = "chol"
pprint_unop MTrace = "tr"
pprint_unop (MDeriv v) = "deriv_" ++ v
pprint_unop (MUnresolvedDeriv v) = "unresolved_deriv_" ++ v
pprint_unop MDifferential = "differential"
pprint_unop MDet = "det"
pprint_unop MDiagVM = "toDiag"
pprint_unop MDiagMV = "diag"
pprint_unop MEntrySum = "sum"
pprint_unop (MElementWise sop) = pprint_scalarop sop
pprint_scalarop MLog = "log"
pprint_scalarop MExp = "exp"
pprint_scalarop MReciprocal = "recip"
pprint (Leaf a) = a
pprint (IdentityLeaf _) = "I"
pprint (ZeroLeaf _ _) = "0"
pprint (LiteralScalar x) = show x
pprint (Branch1 op c) = "(" ++ pprint_unop op ++ " " ++ pprint c ++ ")"
pprint (Branch2 op a b) = "(" ++ pprint_binop op ++ " " ++ pprint a ++ " "
++ pprint b ++ ")"
pprint (Branch3 op a b c) = "(" ++ pprint_ternop op ++ " " ++ pprint a ++ " "
++ pprint b ++ " " ++ pprint c ++ ")"
pprint (Let v a tmp b) = "(let (" ++ v ++ " := " ++ pprint a ++ (if tmp then " #temporary ) " else ") ") ++ "\n" ++ pprint b ++ ")"
------------------------------------------------------------------------
-- Symbol Table Definition
------------------------------------------------------------------------
type SymbolTable = Map.Map VarName (Matrix, Maybe Expr)
data MatrixSym = MatrixSym String String [MProperty]
data Matrix = Matrix Int Int [MProperty]
data MProperty = Symmetric
| PosDef
| Diagonal
| LowerTriangular
deriving (Eq, Enum)
data PreambleLine = MatrixLine VarName MatrixSym
| SymbolLine Char Int
| BlankLine
deriving (Show)
--------------------------------------------
-- Arjun comment:
-- The parser reads in the symbol table, where each line is a
-- MatrixSym (i.e. "A: n x n" is a MatrixSym Varsize "n" Varsize "n"
-- []). But eventually we want all the Varsizes to be concrete
-- integers, which eventually gets converted to type Matrix. Not sure
-- this is the best way, what about statically checking that the Size
-- constructor is of the "LitSize" type and not the "VarSize" type...?
--------------------------------------------
instance Show MProperty where
show Symmetric = "symmetric"
show PosDef = "posdef"
show Diagonal = "diag"
show LowerTriangular = "ltri"
instance Show Matrix where
show (Matrix r c props) = show r ++ "x" ++ show c ++ " " ++ show props
showDim :: Matrix -> String
showDim (Matrix r c _) = (show r) ++ "x" ++ (show c)
instance Show MatrixSym where
show (MatrixSym r c props) = show r ++ "x" ++ show c ++ " "
++ show props
---------------------------------------------------------------------------------------------------
-- Error definitions
-- Datatype for errors --
data MError = SizeMismatch BinOp Matrix Matrix Expr Expr
| SizeMismatchTern TernOp Matrix Matrix Matrix
| WrongProperties BinOp [MProperty] [MProperty] Expr Expr
| WrongProperties1 UnOp [MProperty] Expr
| InvalidOp UnOp Matrix
| UnboundName VarName
| Default String
| BadDimension String
| AnalysisError String
| Parser ParseError
| BadCrumbs Expr String
| MaybeError String
| BadOptimization Expr Expr MError
| DerivativeFail Expr VarName
| AbstractExpression Expr
showError :: MError -> String
showError (SizeMismatch op m1 m2 t1 t2) =
"Invalid matrix dimensions for operation " ++ show op ++ " ("
++ showDim m1 ++ "), (" ++ showDim m2 ++ ")"
++ ", applied to trees:\n" ++ (show t1) ++ "\n" ++ (show t2)
showError (SizeMismatchTern op m1 m2 m3) =
"Invalid matrix dimensions for ternary operator '"
++ show op ++ "' applied to matrices " ++ showDim m1 ++ ", "
++ showDim m2 ++ ", " ++ showDim m3
showError (WrongProperties op props1 props2 t1 t2) =
"Operator '" ++ show op
++ "' cannot apply to matrices with properties " ++ show props1
++ ", " ++ show props2 ++ ", trees:\n" ++ (show t1) ++ "\n" ++ (show t2)
showError (WrongProperties1 op props t) =
"Operator '" ++ show op
++ "' cannot apply to matrix with properties " ++ show props
++ ", " ++ ", trees:\n" ++ (show t) ++ "\n"
showError (InvalidOp op m) =
"Invalid operation '" ++ show op ++ "' on matrix " ++ show m
showError (UnboundName s) = "Undefined matrix name " ++ s
showError (Default s) = "Default Error???" ++ show s
showError (BadDimension d) = "Invalid dimension specification'" ++ show d ++ "'"
showError (Parser err) = "Parse error at " ++ show err
showError (AnalysisError err) = "Analysis error: " ++ show err
showError (BadCrumbs exp err) = "Breadcrumbs don't match the current expression: " ++ show exp ++ ", additional info: " ++ err
showError (MaybeError err) = "Maybe expression returned Nothing: " ++ show err
showError (BadOptimization t t2 err) = "Optimization rule returned invalid expression.\nOriginal: "++ show t ++ "\nOptimized: " ++ show t2 ++ "\nError: " ++ show err
showError (DerivativeFail expr v) = "Could not differentiate expression: " ++ show expr ++ " with respect to " ++ v
showError (AbstractExpression expr) = "Tried to generate code or compute FLOPs for abstract expression: " ++ show expr
instance Show MError where show = showError
instance Error MError where
noMsg = Default "An error has occurred"
strMsg = Default
type ThrowsError = Either MError
maybeToError :: Maybe a -> ThrowsError a
maybeToError (Just val) = return val
maybeToError Nothing = Left $ MaybeError "automatically converted"
trapError :: b -> (a-> b) -> (ThrowsError a) -> b
trapError d f (Right v) = f v
trapError d f (Left _) = d
--trapError :: (Show a, MonadError a m) => m String -> m String
--trapError action = catchError action (return . show)
extractValue :: ThrowsError a -> a
extractValue (Right val) = val
extractValue (Left err) = error $ show err
---------------------------------------------------------------------------
| davmre/matrizer | src/Matrizer/MTypes.hs | gpl-2.0 | 8,206 | 0 | 15 | 2,095 | 2,019 | 1,045 | 974 | 159 | 2 |
{- Copyright (c) 2006 John Goerzen
<[email protected]>
Please see the COPYRIGHT file
-}
module Config where
import MissingH.ConfigParser
import Database.HDBC.PostgreSQL
import Database.HDBC.ODBC
import Database.HDBC
import System.IO
import Monad
import MissingH.Either
import System.Directory
loadCP :: IO ConfigParser
loadCP =
let startCP = emptyCP {accessfunc = interpolatingAccess 5}
in do cp <- readfile startCP "blogcvt.ini"
return $ forceEither cp
connectDB :: String -> IO Connection
connectDB section =
do cp <- loadCP
let dbtype = forceEither $ get cp section "dbtype"
let connstring = forceEither $ get cp section "connstring"
case dbtype of
"odbc" -> connectODBC connstring
"postgresql" -> connectPostgreSQL connstring
x -> fail $ "Unrecognized dbtype " ++ x
| jgoerzen/blogcvt | Config.hs | gpl-2.0 | 848 | 0 | 11 | 182 | 208 | 105 | 103 | 23 | 3 |
--
-- Copyright (c) 2011 Citrix Systems, Inc.
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
{-# LANGUAGE GeneralizedNewtypeDeriving,PatternGuards,FlexibleInstances,TypeSynonymInstances #-}
module UpgradeEngine ( module JSONTrees
, Migration (..)
, runMigrate
, getCurrentVersion
-- transform a given json file using specified function
, xformJSONFile
-- transform a primary json file using specified function
, xformPrimaryJSON
-- transform all VM json files using specified function
, xformVmJSON
-- transform all dom-store json files using specified function
, xformDomStoreJSON ) where
import Data.String
import Data.List
import Control.Monad
import Control.Monad.State
import System.IO
import qualified System.IO.UTF8 as UTF8
import System.FilePath
import ShellTools
import JSONTrees
mainConfigFile :: String
mainConfigFile = "/config/db"
vmsDirectory :: String
vmsDirectory = "/config/vms"
domStoreDirectory :: String
domStoreDirectory = "/config/dom-store"
-- describe a single migration
data Migration = Migration {
sourceVersion :: Int
, targetVersion :: Int
, actions :: IO ()
}
runMigrate :: Migration -> IO ()
runMigrate m = do
v <- getCurrentVersion
when (v /= sourceVersion m) $
error $ "unexpected DB version, expecting " ++ show (sourceVersion m) ++ ", is " ++ show v
actions m
-- overwrite with new DB version
setCurrentVersion (targetVersion m)
getCurrentVersion :: IO Int
getCurrentVersion = do
config <- configJSON
let (Just versionStr) = fmap jsUnboxString $ jsGet "/db-version" config
return $ read versionStr
setCurrentVersion :: Int -> IO ()
setCurrentVersion v = do
xformPrimaryJSON $ \config ->
jsSet "/db-version" (jsBoxString . show $ v) config
readJSONFile :: FilePath -> IO JSValue
readJSONFile path = do
contents <- UTF8.readFile path
case decodeStrict $ contents of
Error msg -> error $ "malformed JSON file: " ++ msg
Ok json -> return json
configJSON :: IO JSValue
configJSON = readJSONFile mainConfigFile
type JSXform = JSValue -> JSValue
-- apply a transformation on given json file
xformJSONFile :: FilePath -> JSXform -> IO ()
xformJSONFile path xform = do
json <- readJSONFile path
let json' = xform json
writeFile path (jsPretty json')
-- apply a transformation on primary config file
xformPrimaryJSON :: JSXform -> IO ()
xformPrimaryJSON xform = xformJSONFile mainConfigFile xform
-- apply a transformation on all vm json files
xformVmJSON :: JSXform -> IO ()
xformVmJSON = xformDirectory vmsDirectory
-- apply a transformation on all dom-store files
xformDomStoreJSON :: JSXform -> IO ()
xformDomStoreJSON = xformDirectory domStoreDirectory
-- apply xform to all .db files in the given directory
xformDirectory :: String -> JSXform -> IO ()
xformDirectory directory xform = do
files <- directoryDbFiles directory
mapM_ (`xformJSONFile` xform) files
-- get all .db files in the given directory
directoryDbFiles :: String -> IO [FilePath]
directoryDbFiles directory = do
output <-spawnShell' $ "ls -1 " ++ combine directory "*.db"
let files = case output of
Nothing -> []
Just v -> lines v
return $ map (combine directory) files
| OpenXT/manager | upgrade-db/UpgradeEngine.hs | gpl-2.0 | 4,126 | 0 | 15 | 964 | 757 | 397 | 360 | 75 | 2 |
process s = do
upStr <- upCase s
tell "toWords "
return (words upStr) | hmemcpy/milewski-ctfp-pdf | src/content/3.4/code/haskell/snippet22.hs | gpl-3.0 | 81 | 0 | 9 | 25 | 37 | 15 | 22 | 4 | 1 |
module Test
where
import System.Random (randomRIO)
import Data.Array.IO
import Control.Monad
updateWeights :: Double -> Double -> [Double] -> [Double] -> [Double]
updateWeights learnRate error inputs weights =
zipWith (\x y -> x * y * learnRate * error) inputs weights
step :: Double -> Bool
step n = if n > 0 then 1 else 0
perceiveFace :: Image -> Face
perceiveFace img eyesWeigths mouthWeights actfn =
getFace (perceive img eyesWeigths actfn) (perceive img mouthWeights actfn)
-- ska perceive returnera true false, eller en Double?
perceive :: [Double] -> [Double] -> (Double -> Bool) -> Bool
perceive inputs weights actfn = actfn $ sum $ zipWith (*) inputs weights
type Image = [Double]
type Face = Int -- 1 = Happy, 2 = Sad, 3 = Mischievous, 4 = Mad
type Eyes = Bool
type Mouth = Bool
-- getEyesMouth returns the state of the eyes and mouth, given the face type.
-- \ / up brows = True / \ down brows = False
-- \_/ happy mouth = True /-\ sad mouth = False
getEyesMouth :: Face -> (Eyes,Mouth)
getEyesMouth 1 = (False,True) -- Happy
getEyesMouth 2 = (False,False) -- Sad
getEyesMouth 3 = (True,False) -- Mischievous
getEyesMouth 4 = (True,True) -- Mad
getFace :: Eyes -> Mouth -> Face
getFace (False,True) = 1 -- Happy
getFace (False,False) = 2 -- Sad
getFace (True,False) = 3 -- Mischievous
getFace (True,True) = 4 -- Mad
trainFace :: [(Image,Face)] ->
trainFace learnRate (img,face)
-- train takes a list of image and answer pairs to train on, the weights of the
-- output node that should be trained, and the learning rate. It returns updated
-- weights.
train :: Double -> [(Image,Bool)] -> [Double] -> [Double]
train learnRate [] weights = weights -- nothing left to train on
train learnRate ((img,ans):xs) weights =
if perceive img == ans
then train xs weights
else train xs (update weights)
where
perceive img = perceive img weights step
update weigths = updateWeights learnRate 1 img ws
-----------------------------------------------------
-- Flippin' images
-----------------------------------------------------
-- flipCW flips a image clockwise
flipCW :: Image -> Int -> Image
flipCW img width = concat $ flip (chunk img width) []
where flip :: [[Double]] -> [[Double]]
flip [] out = out
flip img out = flip (map tail img) (map head img)
flip180 = reverse
-- Is it worth it, let me work it. I put my thing down, flip it and reverse it
flipCCW img width = flip180 . flipCW
-- http://www.haskell.org/haskellwiki/Random_shuffle
-- | Randomly shuffle a list
-- /O(N)/
shuffle :: [a] -> IO [a]
shuffle xs = do ar <- newArray n xs
forM [1..n] $ \i -> do
j <- randomRIO (i,n)
vi <- readArray ar i
vj <- readArray ar j
writeArray ar j vi
return vj
where
n = length xs
newArray :: Int -> [a] -> IO (IOArray Int a)
newArray n xs = newListArray (1,n) xs
---------------------------------------------
-- Trash:
---------------------------------------------
train2 :: Double -> [Image] -> [Bool] -> [Double] -> [Double]
train2 learnRate [] _ weights = weights -- nothing left to train on
train2 learnRate (img:is) (ans:as) weights =
if perceive img == ans
then train is as weights
else train is as (update weights)
where
perceive img = perceive img weights step
update weigths = updateWeights learnRate 1 img weights
{-
rndElem :: [a] -> IO a
rndElem xs = do rand <- randomRIO (0, length xs)
return $ xs !! rand
-}
| bernilsson/Perceptron | src/Test.hs | gpl-3.0 | 3,678 | 0 | 13 | 935 | 1,041 | 567 | 474 | -1 | -1 |
module Main where
boombang xs = [if (x < 10) then "BOOM!" else "BANG!" | x <- xs, odd x] | yumerov/haskell-study | learnyouahaskell/00-starting-out/boom-bang.hs | gpl-3.0 | 89 | 0 | 8 | 20 | 45 | 25 | 20 | 2 | 2 |
module KRPCHS.SpaceCenter
( AntennaState(..)
, CameraMode(..)
, CargoBayState(..)
, CommLinkType(..)
, ContractState(..)
, ControlSource(..)
, ControlState(..)
, DockingPortState(..)
, LegState(..)
, MotorState(..)
, ParachuteState(..)
, RadiatorState(..)
, ResourceConverterState(..)
, ResourceFlowMode(..)
, ResourceHarvesterState(..)
, SASMode(..)
, SolarPanelState(..)
, SpeedMode(..)
, VesselSituation(..)
, VesselType(..)
, WarpMode(..)
, WheelState(..)
, Antenna
, AutoPilot
, Camera
, CargoBay
, CelestialBody
, CommLink
, CommNode
, Comms
, Contract
, ContractManager
, ContractParameter
, Control
, ControlSurface
, Decoupler
, DockingPort
, Engine
, Experiment
, Fairing
, Flight
, Force
, Intake
, LaunchClamp
, Leg
, Light
, Module
, Node
, Orbit
, Parachute
, Part
, Parts
, Propellant
, RCS
, Radiator
, ReactionWheel
, ReferenceFrame
, Resource
, ResourceConverter
, ResourceHarvester
, ResourceTransfer
, Resources
, ScienceData
, ScienceSubject
, Sensor
, SolarPanel
, Thruster
, Vessel
, Waypoint
, WaypointManager
, Wheel
, antennaCancel
, antennaTransmit
, getAntennaAllowPartial
, getAntennaAllowPartialStream
, getAntennaAllowPartialStreamReq
, getAntennaCanTransmit
, getAntennaCanTransmitStream
, getAntennaCanTransmitStreamReq
, getAntennaCombinable
, getAntennaCombinableStream
, getAntennaCombinableStreamReq
, getAntennaCombinableExponent
, getAntennaCombinableExponentStream
, getAntennaCombinableExponentStreamReq
, getAntennaDeployable
, getAntennaDeployableStream
, getAntennaDeployableStreamReq
, getAntennaDeployed
, getAntennaDeployedStream
, getAntennaDeployedStreamReq
, getAntennaPacketInterval
, getAntennaPacketIntervalStream
, getAntennaPacketIntervalStreamReq
, getAntennaPacketResourceCost
, getAntennaPacketResourceCostStream
, getAntennaPacketResourceCostStreamReq
, getAntennaPacketSize
, getAntennaPacketSizeStream
, getAntennaPacketSizeStreamReq
, getAntennaPart
, getAntennaPartStream
, getAntennaPartStreamReq
, getAntennaPower
, getAntennaPowerStream
, getAntennaPowerStreamReq
, getAntennaState
, getAntennaStateStream
, getAntennaStateStreamReq
, setAntennaAllowPartial
, setAntennaDeployed
, autoPilotDisengage
, autoPilotEngage
, autoPilotTargetPitchAndHeading
, autoPilotWait
, getAutoPilotAttenuationAngle
, getAutoPilotAttenuationAngleStream
, getAutoPilotAttenuationAngleStreamReq
, getAutoPilotAutoTune
, getAutoPilotAutoTuneStream
, getAutoPilotAutoTuneStreamReq
, getAutoPilotDecelerationTime
, getAutoPilotDecelerationTimeStream
, getAutoPilotDecelerationTimeStreamReq
, getAutoPilotError
, getAutoPilotErrorStream
, getAutoPilotErrorStreamReq
, getAutoPilotHeadingError
, getAutoPilotHeadingErrorStream
, getAutoPilotHeadingErrorStreamReq
, getAutoPilotOvershoot
, getAutoPilotOvershootStream
, getAutoPilotOvershootStreamReq
, getAutoPilotPitchError
, getAutoPilotPitchErrorStream
, getAutoPilotPitchErrorStreamReq
, getAutoPilotPitchPIDGains
, getAutoPilotPitchPIDGainsStream
, getAutoPilotPitchPIDGainsStreamReq
, getAutoPilotReferenceFrame
, getAutoPilotReferenceFrameStream
, getAutoPilotReferenceFrameStreamReq
, getAutoPilotRollError
, getAutoPilotRollErrorStream
, getAutoPilotRollErrorStreamReq
, getAutoPilotRollPIDGains
, getAutoPilotRollPIDGainsStream
, getAutoPilotRollPIDGainsStreamReq
, getAutoPilotRollThreshold
, getAutoPilotRollThresholdStream
, getAutoPilotRollThresholdStreamReq
, getAutoPilotSAS
, getAutoPilotSASStream
, getAutoPilotSASStreamReq
, getAutoPilotSASMode
, getAutoPilotSASModeStream
, getAutoPilotSASModeStreamReq
, getAutoPilotStoppingTime
, getAutoPilotStoppingTimeStream
, getAutoPilotStoppingTimeStreamReq
, getAutoPilotTargetDirection
, getAutoPilotTargetDirectionStream
, getAutoPilotTargetDirectionStreamReq
, getAutoPilotTargetHeading
, getAutoPilotTargetHeadingStream
, getAutoPilotTargetHeadingStreamReq
, getAutoPilotTargetPitch
, getAutoPilotTargetPitchStream
, getAutoPilotTargetPitchStreamReq
, getAutoPilotTargetRoll
, getAutoPilotTargetRollStream
, getAutoPilotTargetRollStreamReq
, getAutoPilotTimeToPeak
, getAutoPilotTimeToPeakStream
, getAutoPilotTimeToPeakStreamReq
, getAutoPilotYawPIDGains
, getAutoPilotYawPIDGainsStream
, getAutoPilotYawPIDGainsStreamReq
, setAutoPilotAttenuationAngle
, setAutoPilotAutoTune
, setAutoPilotDecelerationTime
, setAutoPilotOvershoot
, setAutoPilotPitchPIDGains
, setAutoPilotReferenceFrame
, setAutoPilotRollPIDGains
, setAutoPilotRollThreshold
, setAutoPilotSAS
, setAutoPilotSASMode
, setAutoPilotStoppingTime
, setAutoPilotTargetDirection
, setAutoPilotTargetHeading
, setAutoPilotTargetPitch
, setAutoPilotTargetRoll
, setAutoPilotTimeToPeak
, setAutoPilotYawPIDGains
, getCameraDefaultDistance
, getCameraDefaultDistanceStream
, getCameraDefaultDistanceStreamReq
, getCameraDistance
, getCameraDistanceStream
, getCameraDistanceStreamReq
, getCameraFocussedBody
, getCameraFocussedBodyStream
, getCameraFocussedBodyStreamReq
, getCameraFocussedNode
, getCameraFocussedNodeStream
, getCameraFocussedNodeStreamReq
, getCameraFocussedVessel
, getCameraFocussedVesselStream
, getCameraFocussedVesselStreamReq
, getCameraHeading
, getCameraHeadingStream
, getCameraHeadingStreamReq
, getCameraMaxDistance
, getCameraMaxDistanceStream
, getCameraMaxDistanceStreamReq
, getCameraMaxPitch
, getCameraMaxPitchStream
, getCameraMaxPitchStreamReq
, getCameraMinDistance
, getCameraMinDistanceStream
, getCameraMinDistanceStreamReq
, getCameraMinPitch
, getCameraMinPitchStream
, getCameraMinPitchStreamReq
, getCameraMode
, getCameraModeStream
, getCameraModeStreamReq
, getCameraPitch
, getCameraPitchStream
, getCameraPitchStreamReq
, setCameraDistance
, setCameraFocussedBody
, setCameraFocussedNode
, setCameraFocussedVessel
, setCameraHeading
, setCameraMode
, setCameraPitch
, canRailsWarpAt
, canRailsWarpAtStream
, canRailsWarpAtStreamReq
, getCargoBayOpen
, getCargoBayOpenStream
, getCargoBayOpenStreamReq
, getCargoBayPart
, getCargoBayPartStream
, getCargoBayPartStreamReq
, getCargoBayState
, getCargoBayStateStream
, getCargoBayStateStreamReq
, setCargoBayOpen
, celestialBodyAngularVelocity
, celestialBodyAngularVelocityStream
, celestialBodyAngularVelocityStreamReq
, celestialBodyBedrockHeight
, celestialBodyBedrockHeightStream
, celestialBodyBedrockHeightStreamReq
, celestialBodyBedrockPosition
, celestialBodyBedrockPositionStream
, celestialBodyBedrockPositionStreamReq
, celestialBodyBiomeAt
, celestialBodyBiomeAtStream
, celestialBodyBiomeAtStreamReq
, celestialBodyDirection
, celestialBodyDirectionStream
, celestialBodyDirectionStreamReq
, celestialBodyMSLPosition
, celestialBodyMSLPositionStream
, celestialBodyMSLPositionStreamReq
, celestialBodyPosition
, celestialBodyPositionStream
, celestialBodyPositionStreamReq
, celestialBodyRotation
, celestialBodyRotationStream
, celestialBodyRotationStreamReq
, celestialBodySurfaceHeight
, celestialBodySurfaceHeightStream
, celestialBodySurfaceHeightStreamReq
, celestialBodySurfacePosition
, celestialBodySurfacePositionStream
, celestialBodySurfacePositionStreamReq
, celestialBodyVelocity
, celestialBodyVelocityStream
, celestialBodyVelocityStreamReq
, getCelestialBodyAtmosphereDepth
, getCelestialBodyAtmosphereDepthStream
, getCelestialBodyAtmosphereDepthStreamReq
, getCelestialBodyBiomes
, getCelestialBodyBiomesStream
, getCelestialBodyBiomesStreamReq
, getCelestialBodyEquatorialRadius
, getCelestialBodyEquatorialRadiusStream
, getCelestialBodyEquatorialRadiusStreamReq
, getCelestialBodyFlyingHighAltitudeThreshold
, getCelestialBodyFlyingHighAltitudeThresholdStream
, getCelestialBodyFlyingHighAltitudeThresholdStreamReq
, getCelestialBodyGravitationalParameter
, getCelestialBodyGravitationalParameterStream
, getCelestialBodyGravitationalParameterStreamReq
, getCelestialBodyHasAtmosphere
, getCelestialBodyHasAtmosphereStream
, getCelestialBodyHasAtmosphereStreamReq
, getCelestialBodyHasAtmosphericOxygen
, getCelestialBodyHasAtmosphericOxygenStream
, getCelestialBodyHasAtmosphericOxygenStreamReq
, getCelestialBodyInitialRotation
, getCelestialBodyInitialRotationStream
, getCelestialBodyInitialRotationStreamReq
, getCelestialBodyMass
, getCelestialBodyMassStream
, getCelestialBodyMassStreamReq
, getCelestialBodyName
, getCelestialBodyNameStream
, getCelestialBodyNameStreamReq
, getCelestialBodyNonRotatingReferenceFrame
, getCelestialBodyNonRotatingReferenceFrameStream
, getCelestialBodyNonRotatingReferenceFrameStreamReq
, getCelestialBodyOrbit
, getCelestialBodyOrbitStream
, getCelestialBodyOrbitStreamReq
, getCelestialBodyOrbitalReferenceFrame
, getCelestialBodyOrbitalReferenceFrameStream
, getCelestialBodyOrbitalReferenceFrameStreamReq
, getCelestialBodyReferenceFrame
, getCelestialBodyReferenceFrameStream
, getCelestialBodyReferenceFrameStreamReq
, getCelestialBodyRotationAngle
, getCelestialBodyRotationAngleStream
, getCelestialBodyRotationAngleStreamReq
, getCelestialBodyRotationalPeriod
, getCelestialBodyRotationalPeriodStream
, getCelestialBodyRotationalPeriodStreamReq
, getCelestialBodyRotationalSpeed
, getCelestialBodyRotationalSpeedStream
, getCelestialBodyRotationalSpeedStreamReq
, getCelestialBodySatellites
, getCelestialBodySatellitesStream
, getCelestialBodySatellitesStreamReq
, getCelestialBodySpaceHighAltitudeThreshold
, getCelestialBodySpaceHighAltitudeThresholdStream
, getCelestialBodySpaceHighAltitudeThresholdStreamReq
, getCelestialBodySphereOfInfluence
, getCelestialBodySphereOfInfluenceStream
, getCelestialBodySphereOfInfluenceStreamReq
, getCelestialBodySurfaceGravity
, getCelestialBodySurfaceGravityStream
, getCelestialBodySurfaceGravityStreamReq
, clearTarget
, getCommLinkEnd
, getCommLinkEndStream
, getCommLinkEndStreamReq
, getCommLinkSignalStrength
, getCommLinkSignalStrengthStream
, getCommLinkSignalStrengthStreamReq
, getCommLinkStart
, getCommLinkStartStream
, getCommLinkStartStreamReq
, getCommLinkType
, getCommLinkTypeStream
, getCommLinkTypeStreamReq
, getCommNodeIsControlPoint
, getCommNodeIsControlPointStream
, getCommNodeIsControlPointStreamReq
, getCommNodeIsHome
, getCommNodeIsHomeStream
, getCommNodeIsHomeStreamReq
, getCommNodeIsVessel
, getCommNodeIsVesselStream
, getCommNodeIsVesselStreamReq
, getCommNodeName
, getCommNodeNameStream
, getCommNodeNameStreamReq
, getCommNodeVessel
, getCommNodeVesselStream
, getCommNodeVesselStreamReq
, getCommsCanCommunicate
, getCommsCanCommunicateStream
, getCommsCanCommunicateStreamReq
, getCommsCanTransmitScience
, getCommsCanTransmitScienceStream
, getCommsCanTransmitScienceStreamReq
, getCommsControlPath
, getCommsControlPathStream
, getCommsControlPathStreamReq
, getCommsPower
, getCommsPowerStream
, getCommsPowerStreamReq
, getCommsSignalDelay
, getCommsSignalDelayStream
, getCommsSignalDelayStreamReq
, getCommsSignalStrength
, getCommsSignalStrengthStream
, getCommsSignalStrengthStreamReq
, getContractManagerActiveContracts
, getContractManagerActiveContractsStream
, getContractManagerActiveContractsStreamReq
, getContractManagerAllContracts
, getContractManagerAllContractsStream
, getContractManagerAllContractsStreamReq
, getContractManagerCompletedContracts
, getContractManagerCompletedContractsStream
, getContractManagerCompletedContractsStreamReq
, getContractManagerFailedContracts
, getContractManagerFailedContractsStream
, getContractManagerFailedContractsStreamReq
, getContractManagerOfferedContracts
, getContractManagerOfferedContractsStream
, getContractManagerOfferedContractsStreamReq
, getContractManagerTypes
, getContractManagerTypesStream
, getContractManagerTypesStreamReq
, getContractParameterChildren
, getContractParameterChildrenStream
, getContractParameterChildrenStreamReq
, getContractParameterCompleted
, getContractParameterCompletedStream
, getContractParameterCompletedStreamReq
, getContractParameterFailed
, getContractParameterFailedStream
, getContractParameterFailedStreamReq
, getContractParameterFundsCompletion
, getContractParameterFundsCompletionStream
, getContractParameterFundsCompletionStreamReq
, getContractParameterFundsFailure
, getContractParameterFundsFailureStream
, getContractParameterFundsFailureStreamReq
, getContractParameterNotes
, getContractParameterNotesStream
, getContractParameterNotesStreamReq
, getContractParameterOptional
, getContractParameterOptionalStream
, getContractParameterOptionalStreamReq
, getContractParameterReputationCompletion
, getContractParameterReputationCompletionStream
, getContractParameterReputationCompletionStreamReq
, getContractParameterReputationFailure
, getContractParameterReputationFailureStream
, getContractParameterReputationFailureStreamReq
, getContractParameterScienceCompletion
, getContractParameterScienceCompletionStream
, getContractParameterScienceCompletionStreamReq
, getContractParameterTitle
, getContractParameterTitleStream
, getContractParameterTitleStreamReq
, contractAccept
, contractCancel
, contractDecline
, getContractActive
, getContractActiveStream
, getContractActiveStreamReq
, getContractCanBeCanceled
, getContractCanBeCanceledStream
, getContractCanBeCanceledStreamReq
, getContractCanBeDeclined
, getContractCanBeDeclinedStream
, getContractCanBeDeclinedStreamReq
, getContractCanBeFailed
, getContractCanBeFailedStream
, getContractCanBeFailedStreamReq
, getContractDescription
, getContractDescriptionStream
, getContractDescriptionStreamReq
, getContractFailed
, getContractFailedStream
, getContractFailedStreamReq
, getContractFundsAdvance
, getContractFundsAdvanceStream
, getContractFundsAdvanceStreamReq
, getContractFundsCompletion
, getContractFundsCompletionStream
, getContractFundsCompletionStreamReq
, getContractFundsFailure
, getContractFundsFailureStream
, getContractFundsFailureStreamReq
, getContractKeywords
, getContractKeywordsStream
, getContractKeywordsStreamReq
, getContractNotes
, getContractNotesStream
, getContractNotesStreamReq
, getContractParameters
, getContractParametersStream
, getContractParametersStreamReq
, getContractRead
, getContractReadStream
, getContractReadStreamReq
, getContractReputationCompletion
, getContractReputationCompletionStream
, getContractReputationCompletionStreamReq
, getContractReputationFailure
, getContractReputationFailureStream
, getContractReputationFailureStreamReq
, getContractScienceCompletion
, getContractScienceCompletionStream
, getContractScienceCompletionStreamReq
, getContractSeen
, getContractSeenStream
, getContractSeenStreamReq
, getContractState
, getContractStateStream
, getContractStateStreamReq
, getContractSynopsis
, getContractSynopsisStream
, getContractSynopsisStreamReq
, getContractTitle
, getContractTitleStream
, getContractTitleStreamReq
, getContractType
, getContractTypeStream
, getContractTypeStreamReq
, getControlSurfaceAuthorityLimiter
, getControlSurfaceAuthorityLimiterStream
, getControlSurfaceAuthorityLimiterStreamReq
, getControlSurfaceAvailableTorque
, getControlSurfaceAvailableTorqueStream
, getControlSurfaceAvailableTorqueStreamReq
, getControlSurfaceDeployed
, getControlSurfaceDeployedStream
, getControlSurfaceDeployedStreamReq
, getControlSurfaceInverted
, getControlSurfaceInvertedStream
, getControlSurfaceInvertedStreamReq
, getControlSurfacePart
, getControlSurfacePartStream
, getControlSurfacePartStreamReq
, getControlSurfacePitchEnabled
, getControlSurfacePitchEnabledStream
, getControlSurfacePitchEnabledStreamReq
, getControlSurfaceRollEnabled
, getControlSurfaceRollEnabledStream
, getControlSurfaceRollEnabledStreamReq
, getControlSurfaceSurfaceArea
, getControlSurfaceSurfaceAreaStream
, getControlSurfaceSurfaceAreaStreamReq
, getControlSurfaceYawEnabled
, getControlSurfaceYawEnabledStream
, getControlSurfaceYawEnabledStreamReq
, setControlSurfaceAuthorityLimiter
, setControlSurfaceDeployed
, setControlSurfaceInverted
, setControlSurfacePitchEnabled
, setControlSurfaceRollEnabled
, setControlSurfaceYawEnabled
, controlActivateNextStage
, controlActivateNextStageStream
, controlActivateNextStageStreamReq
, controlAddNode
, controlAddNodeStream
, controlAddNodeStreamReq
, controlGetActionGroup
, controlGetActionGroupStream
, controlGetActionGroupStreamReq
, controlRemoveNodes
, controlSetActionGroup
, controlToggleActionGroup
, getControlAbort
, getControlAbortStream
, getControlAbortStreamReq
, getControlAntennas
, getControlAntennasStream
, getControlAntennasStreamReq
, getControlBrakes
, getControlBrakesStream
, getControlBrakesStreamReq
, getControlCargoBays
, getControlCargoBaysStream
, getControlCargoBaysStreamReq
, getControlCurrentStage
, getControlCurrentStageStream
, getControlCurrentStageStreamReq
, getControlForward
, getControlForwardStream
, getControlForwardStreamReq
, getControlGear
, getControlGearStream
, getControlGearStreamReq
, getControlIntakes
, getControlIntakesStream
, getControlIntakesStreamReq
, getControlLegs
, getControlLegsStream
, getControlLegsStreamReq
, getControlLights
, getControlLightsStream
, getControlLightsStreamReq
, getControlNodes
, getControlNodesStream
, getControlNodesStreamReq
, getControlParachutes
, getControlParachutesStream
, getControlParachutesStreamReq
, getControlPitch
, getControlPitchStream
, getControlPitchStreamReq
, getControlRCS
, getControlRCSStream
, getControlRCSStreamReq
, getControlRadiators
, getControlRadiatorsStream
, getControlRadiatorsStreamReq
, getControlReactionWheels
, getControlReactionWheelsStream
, getControlReactionWheelsStreamReq
, getControlResourceHarvesters
, getControlResourceHarvestersStream
, getControlResourceHarvestersStreamReq
, getControlResourceHarvestersActive
, getControlResourceHarvestersActiveStream
, getControlResourceHarvestersActiveStreamReq
, getControlRight
, getControlRightStream
, getControlRightStreamReq
, getControlRoll
, getControlRollStream
, getControlRollStreamReq
, getControlSAS
, getControlSASStream
, getControlSASStreamReq
, getControlSASMode
, getControlSASModeStream
, getControlSASModeStreamReq
, getControlSolarPanels
, getControlSolarPanelsStream
, getControlSolarPanelsStreamReq
, getControlSource
, getControlSourceStream
, getControlSourceStreamReq
, getControlSpeedMode
, getControlSpeedModeStream
, getControlSpeedModeStreamReq
, getControlState
, getControlStateStream
, getControlStateStreamReq
, getControlThrottle
, getControlThrottleStream
, getControlThrottleStreamReq
, getControlUp
, getControlUpStream
, getControlUpStreamReq
, getControlWheelSteering
, getControlWheelSteeringStream
, getControlWheelSteeringStreamReq
, getControlWheelThrottle
, getControlWheelThrottleStream
, getControlWheelThrottleStreamReq
, getControlWheels
, getControlWheelsStream
, getControlWheelsStreamReq
, getControlYaw
, getControlYawStream
, getControlYawStreamReq
, setControlAbort
, setControlAntennas
, setControlBrakes
, setControlCargoBays
, setControlForward
, setControlGear
, setControlIntakes
, setControlLegs
, setControlLights
, setControlParachutes
, setControlPitch
, setControlRCS
, setControlRadiators
, setControlReactionWheels
, setControlResourceHarvesters
, setControlResourceHarvestersActive
, setControlRight
, setControlRoll
, setControlSAS
, setControlSASMode
, setControlSolarPanels
, setControlSpeedMode
, setControlThrottle
, setControlUp
, setControlWheelSteering
, setControlWheelThrottle
, setControlWheels
, setControlYaw
, decouplerDecouple
, decouplerDecoupleStream
, decouplerDecoupleStreamReq
, getDecouplerDecoupled
, getDecouplerDecoupledStream
, getDecouplerDecoupledStreamReq
, getDecouplerImpulse
, getDecouplerImpulseStream
, getDecouplerImpulseStreamReq
, getDecouplerPart
, getDecouplerPartStream
, getDecouplerPartStreamReq
, getDecouplerStaged
, getDecouplerStagedStream
, getDecouplerStagedStreamReq
, dockingPortDirection
, dockingPortDirectionStream
, dockingPortDirectionStreamReq
, dockingPortPosition
, dockingPortPositionStream
, dockingPortPositionStreamReq
, dockingPortRotation
, dockingPortRotationStream
, dockingPortRotationStreamReq
, dockingPortUndock
, dockingPortUndockStream
, dockingPortUndockStreamReq
, getDockingPortDockedPart
, getDockingPortDockedPartStream
, getDockingPortDockedPartStreamReq
, getDockingPortHasShield
, getDockingPortHasShieldStream
, getDockingPortHasShieldStreamReq
, getDockingPortPart
, getDockingPortPartStream
, getDockingPortPartStreamReq
, getDockingPortReengageDistance
, getDockingPortReengageDistanceStream
, getDockingPortReengageDistanceStreamReq
, getDockingPortReferenceFrame
, getDockingPortReferenceFrameStream
, getDockingPortReferenceFrameStreamReq
, getDockingPortShielded
, getDockingPortShieldedStream
, getDockingPortShieldedStreamReq
, getDockingPortState
, getDockingPortStateStream
, getDockingPortStateStreamReq
, setDockingPortShielded
, engineToggleMode
, getEngineActive
, getEngineActiveStream
, getEngineActiveStreamReq
, getEngineAutoModeSwitch
, getEngineAutoModeSwitchStream
, getEngineAutoModeSwitchStreamReq
, getEngineAvailableThrust
, getEngineAvailableThrustStream
, getEngineAvailableThrustStreamReq
, getEngineAvailableTorque
, getEngineAvailableTorqueStream
, getEngineAvailableTorqueStreamReq
, getEngineCanRestart
, getEngineCanRestartStream
, getEngineCanRestartStreamReq
, getEngineCanShutdown
, getEngineCanShutdownStream
, getEngineCanShutdownStreamReq
, getEngineGimbalLimit
, getEngineGimbalLimitStream
, getEngineGimbalLimitStreamReq
, getEngineGimbalLocked
, getEngineGimbalLockedStream
, getEngineGimbalLockedStreamReq
, getEngineGimbalRange
, getEngineGimbalRangeStream
, getEngineGimbalRangeStreamReq
, getEngineGimballed
, getEngineGimballedStream
, getEngineGimballedStreamReq
, getEngineHasFuel
, getEngineHasFuelStream
, getEngineHasFuelStreamReq
, getEngineHasModes
, getEngineHasModesStream
, getEngineHasModesStreamReq
, getEngineKerbinSeaLevelSpecificImpulse
, getEngineKerbinSeaLevelSpecificImpulseStream
, getEngineKerbinSeaLevelSpecificImpulseStreamReq
, getEngineMaxThrust
, getEngineMaxThrustStream
, getEngineMaxThrustStreamReq
, getEngineMaxVacuumThrust
, getEngineMaxVacuumThrustStream
, getEngineMaxVacuumThrustStreamReq
, getEngineMode
, getEngineModeStream
, getEngineModeStreamReq
, getEngineModes
, getEngineModesStream
, getEngineModesStreamReq
, getEnginePart
, getEnginePartStream
, getEnginePartStreamReq
, getEnginePropellantNames
, getEnginePropellantNamesStream
, getEnginePropellantNamesStreamReq
, getEnginePropellantRatios
, getEnginePropellantRatiosStream
, getEnginePropellantRatiosStreamReq
, getEnginePropellants
, getEnginePropellantsStream
, getEnginePropellantsStreamReq
, getEngineSpecificImpulse
, getEngineSpecificImpulseStream
, getEngineSpecificImpulseStreamReq
, getEngineThrottle
, getEngineThrottleStream
, getEngineThrottleStreamReq
, getEngineThrottleLocked
, getEngineThrottleLockedStream
, getEngineThrottleLockedStreamReq
, getEngineThrust
, getEngineThrustStream
, getEngineThrustStreamReq
, getEngineThrustLimit
, getEngineThrustLimitStream
, getEngineThrustLimitStreamReq
, getEngineThrusters
, getEngineThrustersStream
, getEngineThrustersStreamReq
, getEngineVacuumSpecificImpulse
, getEngineVacuumSpecificImpulseStream
, getEngineVacuumSpecificImpulseStreamReq
, setEngineActive
, setEngineAutoModeSwitch
, setEngineGimbalLimit
, setEngineGimbalLocked
, setEngineMode
, setEngineThrustLimit
, experimentDump
, experimentReset
, experimentRun
, experimentTransmit
, getExperimentAvailable
, getExperimentAvailableStream
, getExperimentAvailableStreamReq
, getExperimentBiome
, getExperimentBiomeStream
, getExperimentBiomeStreamReq
, getExperimentData
, getExperimentDataStream
, getExperimentDataStreamReq
, getExperimentDeployed
, getExperimentDeployedStream
, getExperimentDeployedStreamReq
, getExperimentHasData
, getExperimentHasDataStream
, getExperimentHasDataStreamReq
, getExperimentInoperable
, getExperimentInoperableStream
, getExperimentInoperableStreamReq
, getExperimentPart
, getExperimentPartStream
, getExperimentPartStreamReq
, getExperimentRerunnable
, getExperimentRerunnableStream
, getExperimentRerunnableStreamReq
, getExperimentScienceSubject
, getExperimentScienceSubjectStream
, getExperimentScienceSubjectStreamReq
, fairingJettison
, getFairingJettisoned
, getFairingJettisonedStream
, getFairingJettisonedStreamReq
, getFairingPart
, getFairingPartStream
, getFairingPartStreamReq
, getFlightAerodynamicForce
, getFlightAerodynamicForceStream
, getFlightAerodynamicForceStreamReq
, getFlightAngleOfAttack
, getFlightAngleOfAttackStream
, getFlightAngleOfAttackStreamReq
, getFlightAntiNormal
, getFlightAntiNormalStream
, getFlightAntiNormalStreamReq
, getFlightAntiRadial
, getFlightAntiRadialStream
, getFlightAntiRadialStreamReq
, getFlightAtmosphereDensity
, getFlightAtmosphereDensityStream
, getFlightAtmosphereDensityStreamReq
, getFlightBallisticCoefficient
, getFlightBallisticCoefficientStream
, getFlightBallisticCoefficientStreamReq
, getFlightBedrockAltitude
, getFlightBedrockAltitudeStream
, getFlightBedrockAltitudeStreamReq
, getFlightCenterOfMass
, getFlightCenterOfMassStream
, getFlightCenterOfMassStreamReq
, getFlightDirection
, getFlightDirectionStream
, getFlightDirectionStreamReq
, getFlightDrag
, getFlightDragStream
, getFlightDragStreamReq
, getFlightDragCoefficient
, getFlightDragCoefficientStream
, getFlightDragCoefficientStreamReq
, getFlightDynamicPressure
, getFlightDynamicPressureStream
, getFlightDynamicPressureStreamReq
, getFlightElevation
, getFlightElevationStream
, getFlightElevationStreamReq
, getFlightEquivalentAirSpeed
, getFlightEquivalentAirSpeedStream
, getFlightEquivalentAirSpeedStreamReq
, getFlightGForce
, getFlightGForceStream
, getFlightGForceStreamReq
, getFlightHeading
, getFlightHeadingStream
, getFlightHeadingStreamReq
, getFlightHorizontalSpeed
, getFlightHorizontalSpeedStream
, getFlightHorizontalSpeedStreamReq
, getFlightLatitude
, getFlightLatitudeStream
, getFlightLatitudeStreamReq
, getFlightLift
, getFlightLiftStream
, getFlightLiftStreamReq
, getFlightLiftCoefficient
, getFlightLiftCoefficientStream
, getFlightLiftCoefficientStreamReq
, getFlightLongitude
, getFlightLongitudeStream
, getFlightLongitudeStreamReq
, getFlightMach
, getFlightMachStream
, getFlightMachStreamReq
, getFlightMeanAltitude
, getFlightMeanAltitudeStream
, getFlightMeanAltitudeStreamReq
, getFlightNormal
, getFlightNormalStream
, getFlightNormalStreamReq
, getFlightPitch
, getFlightPitchStream
, getFlightPitchStreamReq
, getFlightPrograde
, getFlightProgradeStream
, getFlightProgradeStreamReq
, getFlightRadial
, getFlightRadialStream
, getFlightRadialStreamReq
, getFlightRetrograde
, getFlightRetrogradeStream
, getFlightRetrogradeStreamReq
, getFlightReynoldsNumber
, getFlightReynoldsNumberStream
, getFlightReynoldsNumberStreamReq
, getFlightRoll
, getFlightRollStream
, getFlightRollStreamReq
, getFlightRotation
, getFlightRotationStream
, getFlightRotationStreamReq
, getFlightSideslipAngle
, getFlightSideslipAngleStream
, getFlightSideslipAngleStreamReq
, getFlightSpeed
, getFlightSpeedStream
, getFlightSpeedStreamReq
, getFlightSpeedOfSound
, getFlightSpeedOfSoundStream
, getFlightSpeedOfSoundStreamReq
, getFlightStallFraction
, getFlightStallFractionStream
, getFlightStallFractionStreamReq
, getFlightStaticAirTemperature
, getFlightStaticAirTemperatureStream
, getFlightStaticAirTemperatureStreamReq
, getFlightStaticPressure
, getFlightStaticPressureStream
, getFlightStaticPressureStreamReq
, getFlightStaticPressureAtMSL
, getFlightStaticPressureAtMSLStream
, getFlightStaticPressureAtMSLStreamReq
, getFlightSurfaceAltitude
, getFlightSurfaceAltitudeStream
, getFlightSurfaceAltitudeStreamReq
, getFlightTerminalVelocity
, getFlightTerminalVelocityStream
, getFlightTerminalVelocityStreamReq
, getFlightThrustSpecificFuelConsumption
, getFlightThrustSpecificFuelConsumptionStream
, getFlightThrustSpecificFuelConsumptionStreamReq
, getFlightTotalAirTemperature
, getFlightTotalAirTemperatureStream
, getFlightTotalAirTemperatureStreamReq
, getFlightTrueAirSpeed
, getFlightTrueAirSpeedStream
, getFlightTrueAirSpeedStreamReq
, getFlightVelocity
, getFlightVelocityStream
, getFlightVelocityStreamReq
, getFlightVerticalSpeed
, getFlightVerticalSpeedStream
, getFlightVerticalSpeedStreamReq
, forceRemove
, getForceForceVector
, getForceForceVectorStream
, getForceForceVectorStreamReq
, getForcePart
, getForcePartStream
, getForcePartStreamReq
, getForcePosition
, getForcePositionStream
, getForcePositionStreamReq
, getForceReferenceFrame
, getForceReferenceFrameStream
, getForceReferenceFrameStreamReq
, setForceForceVector
, setForcePosition
, setForceReferenceFrame
, getIntakeArea
, getIntakeAreaStream
, getIntakeAreaStreamReq
, getIntakeFlow
, getIntakeFlowStream
, getIntakeFlowStreamReq
, getIntakeOpen
, getIntakeOpenStream
, getIntakeOpenStreamReq
, getIntakePart
, getIntakePartStream
, getIntakePartStreamReq
, getIntakeSpeed
, getIntakeSpeedStream
, getIntakeSpeedStreamReq
, setIntakeOpen
, launchClampRelease
, getLaunchClampPart
, getLaunchClampPartStream
, getLaunchClampPartStreamReq
, launchVessel
, launchVesselFromSPH
, launchVesselFromVAB
, launchableVessels
, launchableVesselsStream
, launchableVesselsStreamReq
, getLegDeployable
, getLegDeployableStream
, getLegDeployableStreamReq
, getLegDeployed
, getLegDeployedStream
, getLegDeployedStreamReq
, getLegIsGrounded
, getLegIsGroundedStream
, getLegIsGroundedStreamReq
, getLegPart
, getLegPartStream
, getLegPartStreamReq
, getLegState
, getLegStateStream
, getLegStateStreamReq
, setLegDeployed
, getLightActive
, getLightActiveStream
, getLightActiveStreamReq
, getLightColor
, getLightColorStream
, getLightColorStreamReq
, getLightPart
, getLightPartStream
, getLightPartStreamReq
, getLightPowerUsage
, getLightPowerUsageStream
, getLightPowerUsageStreamReq
, setLightActive
, setLightColor
, load
, moduleGetField
, moduleGetFieldStream
, moduleGetFieldStreamReq
, moduleHasAction
, moduleHasActionStream
, moduleHasActionStreamReq
, moduleHasEvent
, moduleHasEventStream
, moduleHasEventStreamReq
, moduleHasField
, moduleHasFieldStream
, moduleHasFieldStreamReq
, moduleResetField
, moduleSetAction
, moduleSetFieldFloat
, moduleSetFieldInt
, moduleSetFieldString
, moduleTriggerEvent
, getModuleActions
, getModuleActionsStream
, getModuleActionsStreamReq
, getModuleEvents
, getModuleEventsStream
, getModuleEventsStreamReq
, getModuleFields
, getModuleFieldsStream
, getModuleFieldsStreamReq
, getModuleName
, getModuleNameStream
, getModuleNameStreamReq
, getModulePart
, getModulePartStream
, getModulePartStreamReq
, nodeBurnVector
, nodeBurnVectorStream
, nodeBurnVectorStreamReq
, nodeDirection
, nodeDirectionStream
, nodeDirectionStreamReq
, nodePosition
, nodePositionStream
, nodePositionStreamReq
, nodeRemainingBurnVector
, nodeRemainingBurnVectorStream
, nodeRemainingBurnVectorStreamReq
, nodeRemove
, getNodeDeltaV
, getNodeDeltaVStream
, getNodeDeltaVStreamReq
, getNodeNormal
, getNodeNormalStream
, getNodeNormalStreamReq
, getNodeOrbit
, getNodeOrbitStream
, getNodeOrbitStreamReq
, getNodeOrbitalReferenceFrame
, getNodeOrbitalReferenceFrameStream
, getNodeOrbitalReferenceFrameStreamReq
, getNodePrograde
, getNodeProgradeStream
, getNodeProgradeStreamReq
, getNodeRadial
, getNodeRadialStream
, getNodeRadialStreamReq
, getNodeReferenceFrame
, getNodeReferenceFrameStream
, getNodeReferenceFrameStreamReq
, getNodeRemainingDeltaV
, getNodeRemainingDeltaVStream
, getNodeRemainingDeltaVStreamReq
, getNodeTimeTo
, getNodeTimeToStream
, getNodeTimeToStreamReq
, getNodeUT
, getNodeUTStream
, getNodeUTStreamReq
, setNodeDeltaV
, setNodeNormal
, setNodePrograde
, setNodeRadial
, setNodeUT
, orbitEccentricAnomalyAtUT
, orbitEccentricAnomalyAtUTStream
, orbitEccentricAnomalyAtUTStreamReq
, orbitOrbitalSpeedAt
, orbitOrbitalSpeedAtStream
, orbitOrbitalSpeedAtStreamReq
, orbitRadiusAtTrueAnomaly
, orbitRadiusAtTrueAnomalyStream
, orbitRadiusAtTrueAnomalyStreamReq
, orbitReferencePlaneDirection
, orbitReferencePlaneDirectionStream
, orbitReferencePlaneDirectionStreamReq
, orbitReferencePlaneNormal
, orbitReferencePlaneNormalStream
, orbitReferencePlaneNormalStreamReq
, orbitTrueAnomalyAtRadius
, orbitTrueAnomalyAtRadiusStream
, orbitTrueAnomalyAtRadiusStreamReq
, orbitTrueAnomalyAtUT
, orbitTrueAnomalyAtUTStream
, orbitTrueAnomalyAtUTStreamReq
, orbitUTAtTrueAnomaly
, orbitUTAtTrueAnomalyStream
, orbitUTAtTrueAnomalyStreamReq
, getOrbitApoapsis
, getOrbitApoapsisStream
, getOrbitApoapsisStreamReq
, getOrbitApoapsisAltitude
, getOrbitApoapsisAltitudeStream
, getOrbitApoapsisAltitudeStreamReq
, getOrbitArgumentOfPeriapsis
, getOrbitArgumentOfPeriapsisStream
, getOrbitArgumentOfPeriapsisStreamReq
, getOrbitBody
, getOrbitBodyStream
, getOrbitBodyStreamReq
, getOrbitEccentricAnomaly
, getOrbitEccentricAnomalyStream
, getOrbitEccentricAnomalyStreamReq
, getOrbitEccentricity
, getOrbitEccentricityStream
, getOrbitEccentricityStreamReq
, getOrbitEpoch
, getOrbitEpochStream
, getOrbitEpochStreamReq
, getOrbitInclination
, getOrbitInclinationStream
, getOrbitInclinationStreamReq
, getOrbitLongitudeOfAscendingNode
, getOrbitLongitudeOfAscendingNodeStream
, getOrbitLongitudeOfAscendingNodeStreamReq
, getOrbitMeanAnomaly
, getOrbitMeanAnomalyStream
, getOrbitMeanAnomalyStreamReq
, getOrbitMeanAnomalyAtEpoch
, getOrbitMeanAnomalyAtEpochStream
, getOrbitMeanAnomalyAtEpochStreamReq
, getOrbitNextOrbit
, getOrbitNextOrbitStream
, getOrbitNextOrbitStreamReq
, getOrbitOrbitalSpeed
, getOrbitOrbitalSpeedStream
, getOrbitOrbitalSpeedStreamReq
, getOrbitPeriapsis
, getOrbitPeriapsisStream
, getOrbitPeriapsisStreamReq
, getOrbitPeriapsisAltitude
, getOrbitPeriapsisAltitudeStream
, getOrbitPeriapsisAltitudeStreamReq
, getOrbitPeriod
, getOrbitPeriodStream
, getOrbitPeriodStreamReq
, getOrbitRadius
, getOrbitRadiusStream
, getOrbitRadiusStreamReq
, getOrbitSemiMajorAxis
, getOrbitSemiMajorAxisStream
, getOrbitSemiMajorAxisStreamReq
, getOrbitSemiMinorAxis
, getOrbitSemiMinorAxisStream
, getOrbitSemiMinorAxisStreamReq
, getOrbitSpeed
, getOrbitSpeedStream
, getOrbitSpeedStreamReq
, getOrbitTimeToApoapsis
, getOrbitTimeToApoapsisStream
, getOrbitTimeToApoapsisStreamReq
, getOrbitTimeToPeriapsis
, getOrbitTimeToPeriapsisStream
, getOrbitTimeToPeriapsisStreamReq
, getOrbitTimeToSOIChange
, getOrbitTimeToSOIChangeStream
, getOrbitTimeToSOIChangeStreamReq
, getOrbitTrueAnomaly
, getOrbitTrueAnomalyStream
, getOrbitTrueAnomalyStreamReq
, parachuteArm
, parachuteDeploy
, getParachuteArmed
, getParachuteArmedStream
, getParachuteArmedStreamReq
, getParachuteDeployAltitude
, getParachuteDeployAltitudeStream
, getParachuteDeployAltitudeStreamReq
, getParachuteDeployMinPressure
, getParachuteDeployMinPressureStream
, getParachuteDeployMinPressureStreamReq
, getParachuteDeployed
, getParachuteDeployedStream
, getParachuteDeployedStreamReq
, getParachutePart
, getParachutePartStream
, getParachutePartStreamReq
, getParachuteState
, getParachuteStateStream
, getParachuteStateStreamReq
, setParachuteDeployAltitude
, setParachuteDeployMinPressure
, partAddForce
, partAddForceStream
, partAddForceStreamReq
, partBoundingBox
, partBoundingBoxStream
, partBoundingBoxStreamReq
, partCenterOfMass
, partCenterOfMassStream
, partCenterOfMassStreamReq
, partDirection
, partDirectionStream
, partDirectionStreamReq
, partInstantaneousForce
, partPosition
, partPositionStream
, partPositionStreamReq
, partRotation
, partRotationStream
, partRotationStreamReq
, partVelocity
, partVelocityStream
, partVelocityStreamReq
, getPartAntenna
, getPartAntennaStream
, getPartAntennaStreamReq
, getPartAxiallyAttached
, getPartAxiallyAttachedStream
, getPartAxiallyAttachedStreamReq
, getPartCargoBay
, getPartCargoBayStream
, getPartCargoBayStreamReq
, getPartCenterOfMassReferenceFrame
, getPartCenterOfMassReferenceFrameStream
, getPartCenterOfMassReferenceFrameStreamReq
, getPartChildren
, getPartChildrenStream
, getPartChildrenStreamReq
, getPartControlSurface
, getPartControlSurfaceStream
, getPartControlSurfaceStreamReq
, getPartCost
, getPartCostStream
, getPartCostStreamReq
, getPartCrossfeed
, getPartCrossfeedStream
, getPartCrossfeedStreamReq
, getPartDecoupleStage
, getPartDecoupleStageStream
, getPartDecoupleStageStreamReq
, getPartDecoupler
, getPartDecouplerStream
, getPartDecouplerStreamReq
, getPartDockingPort
, getPartDockingPortStream
, getPartDockingPortStreamReq
, getPartDryMass
, getPartDryMassStream
, getPartDryMassStreamReq
, getPartDynamicPressure
, getPartDynamicPressureStream
, getPartDynamicPressureStreamReq
, getPartEngine
, getPartEngineStream
, getPartEngineStreamReq
, getPartExperiment
, getPartExperimentStream
, getPartExperimentStreamReq
, getPartFairing
, getPartFairingStream
, getPartFairingStreamReq
, getPartFuelLinesFrom
, getPartFuelLinesFromStream
, getPartFuelLinesFromStreamReq
, getPartFuelLinesTo
, getPartFuelLinesToStream
, getPartFuelLinesToStreamReq
, getPartHighlightColor
, getPartHighlightColorStream
, getPartHighlightColorStreamReq
, getPartHighlighted
, getPartHighlightedStream
, getPartHighlightedStreamReq
, getPartImpactTolerance
, getPartImpactToleranceStream
, getPartImpactToleranceStreamReq
, getPartInertiaTensor
, getPartInertiaTensorStream
, getPartInertiaTensorStreamReq
, getPartIntake
, getPartIntakeStream
, getPartIntakeStreamReq
, getPartIsFuelLine
, getPartIsFuelLineStream
, getPartIsFuelLineStreamReq
, getPartLaunchClamp
, getPartLaunchClampStream
, getPartLaunchClampStreamReq
, getPartLeg
, getPartLegStream
, getPartLegStreamReq
, getPartLight
, getPartLightStream
, getPartLightStreamReq
, getPartMass
, getPartMassStream
, getPartMassStreamReq
, getPartMassless
, getPartMasslessStream
, getPartMasslessStreamReq
, getPartMaxSkinTemperature
, getPartMaxSkinTemperatureStream
, getPartMaxSkinTemperatureStreamReq
, getPartMaxTemperature
, getPartMaxTemperatureStream
, getPartMaxTemperatureStreamReq
, getPartModules
, getPartModulesStream
, getPartModulesStreamReq
, getPartMomentOfInertia
, getPartMomentOfInertiaStream
, getPartMomentOfInertiaStreamReq
, getPartName
, getPartNameStream
, getPartNameStreamReq
, getPartParachute
, getPartParachuteStream
, getPartParachuteStreamReq
, getPartParent
, getPartParentStream
, getPartParentStreamReq
, getPartRCS
, getPartRCSStream
, getPartRCSStreamReq
, getPartRadiallyAttached
, getPartRadiallyAttachedStream
, getPartRadiallyAttachedStreamReq
, getPartRadiator
, getPartRadiatorStream
, getPartRadiatorStreamReq
, getPartReactionWheel
, getPartReactionWheelStream
, getPartReactionWheelStreamReq
, getPartReferenceFrame
, getPartReferenceFrameStream
, getPartReferenceFrameStreamReq
, getPartResourceConverter
, getPartResourceConverterStream
, getPartResourceConverterStreamReq
, getPartResourceHarvester
, getPartResourceHarvesterStream
, getPartResourceHarvesterStreamReq
, getPartResources
, getPartResourcesStream
, getPartResourcesStreamReq
, getPartSensor
, getPartSensorStream
, getPartSensorStreamReq
, getPartShielded
, getPartShieldedStream
, getPartShieldedStreamReq
, getPartSkinTemperature
, getPartSkinTemperatureStream
, getPartSkinTemperatureStreamReq
, getPartSolarPanel
, getPartSolarPanelStream
, getPartSolarPanelStreamReq
, getPartStage
, getPartStageStream
, getPartStageStreamReq
, getPartTag
, getPartTagStream
, getPartTagStreamReq
, getPartTemperature
, getPartTemperatureStream
, getPartTemperatureStreamReq
, getPartThermalConductionFlux
, getPartThermalConductionFluxStream
, getPartThermalConductionFluxStreamReq
, getPartThermalConvectionFlux
, getPartThermalConvectionFluxStream
, getPartThermalConvectionFluxStreamReq
, getPartThermalInternalFlux
, getPartThermalInternalFluxStream
, getPartThermalInternalFluxStreamReq
, getPartThermalMass
, getPartThermalMassStream
, getPartThermalMassStreamReq
, getPartThermalRadiationFlux
, getPartThermalRadiationFluxStream
, getPartThermalRadiationFluxStreamReq
, getPartThermalResourceMass
, getPartThermalResourceMassStream
, getPartThermalResourceMassStreamReq
, getPartThermalSkinMass
, getPartThermalSkinMassStream
, getPartThermalSkinMassStreamReq
, getPartThermalSkinToInternalFlux
, getPartThermalSkinToInternalFluxStream
, getPartThermalSkinToInternalFluxStreamReq
, getPartTitle
, getPartTitleStream
, getPartTitleStreamReq
, getPartVessel
, getPartVesselStream
, getPartVesselStreamReq
, getPartWheel
, getPartWheelStream
, getPartWheelStreamReq
, setPartHighlightColor
, setPartHighlighted
, setPartTag
, partsInDecoupleStage
, partsInDecoupleStageStream
, partsInDecoupleStageStreamReq
, partsInStage
, partsInStageStream
, partsInStageStreamReq
, partsModulesWithName
, partsModulesWithNameStream
, partsModulesWithNameStreamReq
, partsWithModule
, partsWithModuleStream
, partsWithModuleStreamReq
, partsWithName
, partsWithNameStream
, partsWithNameStreamReq
, partsWithTag
, partsWithTagStream
, partsWithTagStreamReq
, partsWithTitle
, partsWithTitleStream
, partsWithTitleStreamReq
, getPartsAll
, getPartsAllStream
, getPartsAllStreamReq
, getPartsAntennas
, getPartsAntennasStream
, getPartsAntennasStreamReq
, getPartsCargoBays
, getPartsCargoBaysStream
, getPartsCargoBaysStreamReq
, getPartsControlSurfaces
, getPartsControlSurfacesStream
, getPartsControlSurfacesStreamReq
, getPartsControlling
, getPartsControllingStream
, getPartsControllingStreamReq
, getPartsDecouplers
, getPartsDecouplersStream
, getPartsDecouplersStreamReq
, getPartsDockingPorts
, getPartsDockingPortsStream
, getPartsDockingPortsStreamReq
, getPartsEngines
, getPartsEnginesStream
, getPartsEnginesStreamReq
, getPartsExperiments
, getPartsExperimentsStream
, getPartsExperimentsStreamReq
, getPartsFairings
, getPartsFairingsStream
, getPartsFairingsStreamReq
, getPartsIntakes
, getPartsIntakesStream
, getPartsIntakesStreamReq
, getPartsLaunchClamps
, getPartsLaunchClampsStream
, getPartsLaunchClampsStreamReq
, getPartsLegs
, getPartsLegsStream
, getPartsLegsStreamReq
, getPartsLights
, getPartsLightsStream
, getPartsLightsStreamReq
, getPartsParachutes
, getPartsParachutesStream
, getPartsParachutesStreamReq
, getPartsRCS
, getPartsRCSStream
, getPartsRCSStreamReq
, getPartsRadiators
, getPartsRadiatorsStream
, getPartsRadiatorsStreamReq
, getPartsReactionWheels
, getPartsReactionWheelsStream
, getPartsReactionWheelsStreamReq
, getPartsResourceConverters
, getPartsResourceConvertersStream
, getPartsResourceConvertersStreamReq
, getPartsResourceHarvesters
, getPartsResourceHarvestersStream
, getPartsResourceHarvestersStreamReq
, getPartsRoot
, getPartsRootStream
, getPartsRootStreamReq
, getPartsSensors
, getPartsSensorsStream
, getPartsSensorsStreamReq
, getPartsSolarPanels
, getPartsSolarPanelsStream
, getPartsSolarPanelsStreamReq
, getPartsWheels
, getPartsWheelsStream
, getPartsWheelsStreamReq
, setPartsControlling
, getPropellantCurrentAmount
, getPropellantCurrentAmountStream
, getPropellantCurrentAmountStreamReq
, getPropellantCurrentRequirement
, getPropellantCurrentRequirementStream
, getPropellantCurrentRequirementStreamReq
, getPropellantDrawStackGauge
, getPropellantDrawStackGaugeStream
, getPropellantDrawStackGaugeStreamReq
, getPropellantIgnoreForIsp
, getPropellantIgnoreForIspStream
, getPropellantIgnoreForIspStreamReq
, getPropellantIgnoreForThrustCurve
, getPropellantIgnoreForThrustCurveStream
, getPropellantIgnoreForThrustCurveStreamReq
, getPropellantIsDeprived
, getPropellantIsDeprivedStream
, getPropellantIsDeprivedStreamReq
, getPropellantName
, getPropellantNameStream
, getPropellantNameStreamReq
, getPropellantRatio
, getPropellantRatioStream
, getPropellantRatioStreamReq
, getPropellantTotalResourceAvailable
, getPropellantTotalResourceAvailableStream
, getPropellantTotalResourceAvailableStreamReq
, getPropellantTotalResourceCapacity
, getPropellantTotalResourceCapacityStream
, getPropellantTotalResourceCapacityStreamReq
, quickload
, quicksave
, getRCSActive
, getRCSActiveStream
, getRCSActiveStreamReq
, getRCSAvailableTorque
, getRCSAvailableTorqueStream
, getRCSAvailableTorqueStreamReq
, getRCSEnabled
, getRCSEnabledStream
, getRCSEnabledStreamReq
, getRCSForwardEnabled
, getRCSForwardEnabledStream
, getRCSForwardEnabledStreamReq
, getRCSHasFuel
, getRCSHasFuelStream
, getRCSHasFuelStreamReq
, getRCSKerbinSeaLevelSpecificImpulse
, getRCSKerbinSeaLevelSpecificImpulseStream
, getRCSKerbinSeaLevelSpecificImpulseStreamReq
, getRCSMaxThrust
, getRCSMaxThrustStream
, getRCSMaxThrustStreamReq
, getRCSMaxVacuumThrust
, getRCSMaxVacuumThrustStream
, getRCSMaxVacuumThrustStreamReq
, getRCSPart
, getRCSPartStream
, getRCSPartStreamReq
, getRCSPitchEnabled
, getRCSPitchEnabledStream
, getRCSPitchEnabledStreamReq
, getRCSPropellantRatios
, getRCSPropellantRatiosStream
, getRCSPropellantRatiosStreamReq
, getRCSPropellants
, getRCSPropellantsStream
, getRCSPropellantsStreamReq
, getRCSRightEnabled
, getRCSRightEnabledStream
, getRCSRightEnabledStreamReq
, getRCSRollEnabled
, getRCSRollEnabledStream
, getRCSRollEnabledStreamReq
, getRCSSpecificImpulse
, getRCSSpecificImpulseStream
, getRCSSpecificImpulseStreamReq
, getRCSThrusters
, getRCSThrustersStream
, getRCSThrustersStreamReq
, getRCSUpEnabled
, getRCSUpEnabledStream
, getRCSUpEnabledStreamReq
, getRCSVacuumSpecificImpulse
, getRCSVacuumSpecificImpulseStream
, getRCSVacuumSpecificImpulseStreamReq
, getRCSYawEnabled
, getRCSYawEnabledStream
, getRCSYawEnabledStreamReq
, setRCSEnabled
, setRCSForwardEnabled
, setRCSPitchEnabled
, setRCSRightEnabled
, setRCSRollEnabled
, setRCSUpEnabled
, setRCSYawEnabled
, getRadiatorDeployable
, getRadiatorDeployableStream
, getRadiatorDeployableStreamReq
, getRadiatorDeployed
, getRadiatorDeployedStream
, getRadiatorDeployedStreamReq
, getRadiatorPart
, getRadiatorPartStream
, getRadiatorPartStreamReq
, getRadiatorState
, getRadiatorStateStream
, getRadiatorStateStreamReq
, setRadiatorDeployed
, getReactionWheelActive
, getReactionWheelActiveStream
, getReactionWheelActiveStreamReq
, getReactionWheelAvailableTorque
, getReactionWheelAvailableTorqueStream
, getReactionWheelAvailableTorqueStreamReq
, getReactionWheelBroken
, getReactionWheelBrokenStream
, getReactionWheelBrokenStreamReq
, getReactionWheelMaxTorque
, getReactionWheelMaxTorqueStream
, getReactionWheelMaxTorqueStreamReq
, getReactionWheelPart
, getReactionWheelPartStream
, getReactionWheelPartStreamReq
, setReactionWheelActive
, referenceFrameCreateHybrid
, referenceFrameCreateHybridStream
, referenceFrameCreateHybridStreamReq
, referenceFrameCreateRelative
, referenceFrameCreateRelativeStream
, referenceFrameCreateRelativeStreamReq
, resourceConverterActive
, resourceConverterActiveStream
, resourceConverterActiveStreamReq
, resourceConverterInputs
, resourceConverterInputsStream
, resourceConverterInputsStreamReq
, resourceConverterName
, resourceConverterNameStream
, resourceConverterNameStreamReq
, resourceConverterOutputs
, resourceConverterOutputsStream
, resourceConverterOutputsStreamReq
, resourceConverterStart
, resourceConverterState
, resourceConverterStateStream
, resourceConverterStateStreamReq
, resourceConverterStatusInfo
, resourceConverterStatusInfoStream
, resourceConverterStatusInfoStreamReq
, resourceConverterStop
, getResourceConverterCount
, getResourceConverterCountStream
, getResourceConverterCountStreamReq
, getResourceConverterPart
, getResourceConverterPartStream
, getResourceConverterPartStreamReq
, getResourceHarvesterActive
, getResourceHarvesterActiveStream
, getResourceHarvesterActiveStreamReq
, getResourceHarvesterCoreTemperature
, getResourceHarvesterCoreTemperatureStream
, getResourceHarvesterCoreTemperatureStreamReq
, getResourceHarvesterDeployed
, getResourceHarvesterDeployedStream
, getResourceHarvesterDeployedStreamReq
, getResourceHarvesterExtractionRate
, getResourceHarvesterExtractionRateStream
, getResourceHarvesterExtractionRateStreamReq
, getResourceHarvesterOptimumCoreTemperature
, getResourceHarvesterOptimumCoreTemperatureStream
, getResourceHarvesterOptimumCoreTemperatureStreamReq
, getResourceHarvesterPart
, getResourceHarvesterPartStream
, getResourceHarvesterPartStreamReq
, getResourceHarvesterState
, getResourceHarvesterStateStream
, getResourceHarvesterStateStreamReq
, getResourceHarvesterThermalEfficiency
, getResourceHarvesterThermalEfficiencyStream
, getResourceHarvesterThermalEfficiencyStreamReq
, setResourceHarvesterActive
, setResourceHarvesterDeployed
, resourceTransferStart
, resourceTransferStartStream
, resourceTransferStartStreamReq
, getResourceTransferAmount
, getResourceTransferAmountStream
, getResourceTransferAmountStreamReq
, getResourceTransferComplete
, getResourceTransferCompleteStream
, getResourceTransferCompleteStreamReq
, getResourceAmount
, getResourceAmountStream
, getResourceAmountStreamReq
, getResourceDensity
, getResourceDensityStream
, getResourceDensityStreamReq
, getResourceEnabled
, getResourceEnabledStream
, getResourceEnabledStreamReq
, getResourceFlowMode
, getResourceFlowModeStream
, getResourceFlowModeStreamReq
, getResourceMax
, getResourceMaxStream
, getResourceMaxStreamReq
, getResourceName
, getResourceNameStream
, getResourceNameStreamReq
, getResourcePart
, getResourcePartStream
, getResourcePartStreamReq
, setResourceEnabled
, resourcesAmount
, resourcesAmountStream
, resourcesAmountStreamReq
, resourcesDensity
, resourcesDensityStream
, resourcesDensityStreamReq
, resourcesFlowMode
, resourcesFlowModeStream
, resourcesFlowModeStreamReq
, resourcesHasResource
, resourcesHasResourceStream
, resourcesHasResourceStreamReq
, resourcesMax
, resourcesMaxStream
, resourcesMaxStreamReq
, resourcesWithResource
, resourcesWithResourceStream
, resourcesWithResourceStreamReq
, getResourcesAll
, getResourcesAllStream
, getResourcesAllStreamReq
, getResourcesEnabled
, getResourcesEnabledStream
, getResourcesEnabledStreamReq
, getResourcesNames
, getResourcesNamesStream
, getResourcesNamesStreamReq
, setResourcesEnabled
, save
, getScienceDataDataAmount
, getScienceDataDataAmountStream
, getScienceDataDataAmountStreamReq
, getScienceDataScienceValue
, getScienceDataScienceValueStream
, getScienceDataScienceValueStreamReq
, getScienceDataTransmitValue
, getScienceDataTransmitValueStream
, getScienceDataTransmitValueStreamReq
, getScienceSubjectDataScale
, getScienceSubjectDataScaleStream
, getScienceSubjectDataScaleStreamReq
, getScienceSubjectIsComplete
, getScienceSubjectIsCompleteStream
, getScienceSubjectIsCompleteStreamReq
, getScienceSubjectScience
, getScienceSubjectScienceStream
, getScienceSubjectScienceStreamReq
, getScienceSubjectScienceCap
, getScienceSubjectScienceCapStream
, getScienceSubjectScienceCapStreamReq
, getScienceSubjectScientificValue
, getScienceSubjectScientificValueStream
, getScienceSubjectScientificValueStreamReq
, getScienceSubjectSubjectValue
, getScienceSubjectSubjectValueStream
, getScienceSubjectSubjectValueStreamReq
, getScienceSubjectTitle
, getScienceSubjectTitleStream
, getScienceSubjectTitleStreamReq
, getSensorActive
, getSensorActiveStream
, getSensorActiveStreamReq
, getSensorPart
, getSensorPartStream
, getSensorPartStreamReq
, getSensorValue
, getSensorValueStream
, getSensorValueStreamReq
, setSensorActive
, getSolarPanelDeployable
, getSolarPanelDeployableStream
, getSolarPanelDeployableStreamReq
, getSolarPanelDeployed
, getSolarPanelDeployedStream
, getSolarPanelDeployedStreamReq
, getSolarPanelEnergyFlow
, getSolarPanelEnergyFlowStream
, getSolarPanelEnergyFlowStreamReq
, getSolarPanelPart
, getSolarPanelPartStream
, getSolarPanelPartStreamReq
, getSolarPanelState
, getSolarPanelStateStream
, getSolarPanelStateStreamReq
, getSolarPanelSunExposure
, getSolarPanelSunExposureStream
, getSolarPanelSunExposureStreamReq
, setSolarPanelDeployed
, thrusterGimbalPosition
, thrusterGimbalPositionStream
, thrusterGimbalPositionStreamReq
, thrusterInitialThrustDirection
, thrusterInitialThrustDirectionStream
, thrusterInitialThrustDirectionStreamReq
, thrusterInitialThrustPosition
, thrusterInitialThrustPositionStream
, thrusterInitialThrustPositionStreamReq
, thrusterThrustDirection
, thrusterThrustDirectionStream
, thrusterThrustDirectionStreamReq
, thrusterThrustPosition
, thrusterThrustPositionStream
, thrusterThrustPositionStreamReq
, getThrusterGimbalAngle
, getThrusterGimbalAngleStream
, getThrusterGimbalAngleStreamReq
, getThrusterGimballed
, getThrusterGimballedStream
, getThrusterGimballedStreamReq
, getThrusterPart
, getThrusterPartStream
, getThrusterPartStreamReq
, getThrusterThrustReferenceFrame
, getThrusterThrustReferenceFrameStream
, getThrusterThrustReferenceFrameStreamReq
, transformDirection
, transformDirectionStream
, transformDirectionStreamReq
, transformPosition
, transformPositionStream
, transformPositionStreamReq
, transformRotation
, transformRotationStream
, transformRotationStreamReq
, transformVelocity
, transformVelocityStream
, transformVelocityStreamReq
, vesselAngularVelocity
, vesselAngularVelocityStream
, vesselAngularVelocityStreamReq
, vesselBoundingBox
, vesselBoundingBoxStream
, vesselBoundingBoxStreamReq
, vesselDirection
, vesselDirectionStream
, vesselDirectionStreamReq
, vesselFlight
, vesselFlightStream
, vesselFlightStreamReq
, vesselPosition
, vesselPositionStream
, vesselPositionStreamReq
, vesselRecover
, vesselResourcesInDecoupleStage
, vesselResourcesInDecoupleStageStream
, vesselResourcesInDecoupleStageStreamReq
, vesselRotation
, vesselRotationStream
, vesselRotationStreamReq
, vesselVelocity
, vesselVelocityStream
, vesselVelocityStreamReq
, getVesselAutoPilot
, getVesselAutoPilotStream
, getVesselAutoPilotStreamReq
, getVesselAvailableControlSurfaceTorque
, getVesselAvailableControlSurfaceTorqueStream
, getVesselAvailableControlSurfaceTorqueStreamReq
, getVesselAvailableEngineTorque
, getVesselAvailableEngineTorqueStream
, getVesselAvailableEngineTorqueStreamReq
, getVesselAvailableOtherTorque
, getVesselAvailableOtherTorqueStream
, getVesselAvailableOtherTorqueStreamReq
, getVesselAvailableRCSTorque
, getVesselAvailableRCSTorqueStream
, getVesselAvailableRCSTorqueStreamReq
, getVesselAvailableReactionWheelTorque
, getVesselAvailableReactionWheelTorqueStream
, getVesselAvailableReactionWheelTorqueStreamReq
, getVesselAvailableThrust
, getVesselAvailableThrustStream
, getVesselAvailableThrustStreamReq
, getVesselAvailableTorque
, getVesselAvailableTorqueStream
, getVesselAvailableTorqueStreamReq
, getVesselBiome
, getVesselBiomeStream
, getVesselBiomeStreamReq
, getVesselComms
, getVesselCommsStream
, getVesselCommsStreamReq
, getVesselControl
, getVesselControlStream
, getVesselControlStreamReq
, getVesselDryMass
, getVesselDryMassStream
, getVesselDryMassStreamReq
, getVesselInertiaTensor
, getVesselInertiaTensorStream
, getVesselInertiaTensorStreamReq
, getVesselKerbinSeaLevelSpecificImpulse
, getVesselKerbinSeaLevelSpecificImpulseStream
, getVesselKerbinSeaLevelSpecificImpulseStreamReq
, getVesselMET
, getVesselMETStream
, getVesselMETStreamReq
, getVesselMass
, getVesselMassStream
, getVesselMassStreamReq
, getVesselMaxThrust
, getVesselMaxThrustStream
, getVesselMaxThrustStreamReq
, getVesselMaxVacuumThrust
, getVesselMaxVacuumThrustStream
, getVesselMaxVacuumThrustStreamReq
, getVesselMomentOfInertia
, getVesselMomentOfInertiaStream
, getVesselMomentOfInertiaStreamReq
, getVesselName
, getVesselNameStream
, getVesselNameStreamReq
, getVesselOrbit
, getVesselOrbitStream
, getVesselOrbitStreamReq
, getVesselOrbitalReferenceFrame
, getVesselOrbitalReferenceFrameStream
, getVesselOrbitalReferenceFrameStreamReq
, getVesselParts
, getVesselPartsStream
, getVesselPartsStreamReq
, getVesselRecoverable
, getVesselRecoverableStream
, getVesselRecoverableStreamReq
, getVesselReferenceFrame
, getVesselReferenceFrameStream
, getVesselReferenceFrameStreamReq
, getVesselResources
, getVesselResourcesStream
, getVesselResourcesStreamReq
, getVesselSituation
, getVesselSituationStream
, getVesselSituationStreamReq
, getVesselSpecificImpulse
, getVesselSpecificImpulseStream
, getVesselSpecificImpulseStreamReq
, getVesselSurfaceReferenceFrame
, getVesselSurfaceReferenceFrameStream
, getVesselSurfaceReferenceFrameStreamReq
, getVesselSurfaceVelocityReferenceFrame
, getVesselSurfaceVelocityReferenceFrameStream
, getVesselSurfaceVelocityReferenceFrameStreamReq
, getVesselThrust
, getVesselThrustStream
, getVesselThrustStreamReq
, getVesselType
, getVesselTypeStream
, getVesselTypeStreamReq
, getVesselVacuumSpecificImpulse
, getVesselVacuumSpecificImpulseStream
, getVesselVacuumSpecificImpulseStreamReq
, setVesselName
, setVesselType
, warpTo
, waypointManagerAddWaypoint
, waypointManagerAddWaypointStream
, waypointManagerAddWaypointStreamReq
, getWaypointManagerColors
, getWaypointManagerColorsStream
, getWaypointManagerColorsStreamReq
, getWaypointManagerIcons
, getWaypointManagerIconsStream
, getWaypointManagerIconsStreamReq
, getWaypointManagerWaypoints
, getWaypointManagerWaypointsStream
, getWaypointManagerWaypointsStreamReq
, waypointRemove
, getWaypointBedrockAltitude
, getWaypointBedrockAltitudeStream
, getWaypointBedrockAltitudeStreamReq
, getWaypointBody
, getWaypointBodyStream
, getWaypointBodyStreamReq
, getWaypointClustered
, getWaypointClusteredStream
, getWaypointClusteredStreamReq
, getWaypointColor
, getWaypointColorStream
, getWaypointColorStreamReq
, getWaypointContract
, getWaypointContractStream
, getWaypointContractStreamReq
, getWaypointGrounded
, getWaypointGroundedStream
, getWaypointGroundedStreamReq
, getWaypointHasContract
, getWaypointHasContractStream
, getWaypointHasContractStreamReq
, getWaypointIcon
, getWaypointIconStream
, getWaypointIconStreamReq
, getWaypointIndex
, getWaypointIndexStream
, getWaypointIndexStreamReq
, getWaypointLatitude
, getWaypointLatitudeStream
, getWaypointLatitudeStreamReq
, getWaypointLongitude
, getWaypointLongitudeStream
, getWaypointLongitudeStreamReq
, getWaypointMeanAltitude
, getWaypointMeanAltitudeStream
, getWaypointMeanAltitudeStreamReq
, getWaypointName
, getWaypointNameStream
, getWaypointNameStreamReq
, getWaypointNearSurface
, getWaypointNearSurfaceStream
, getWaypointNearSurfaceStreamReq
, getWaypointSurfaceAltitude
, getWaypointSurfaceAltitudeStream
, getWaypointSurfaceAltitudeStreamReq
, setWaypointBedrockAltitude
, setWaypointBody
, setWaypointColor
, setWaypointIcon
, setWaypointLatitude
, setWaypointLongitude
, setWaypointMeanAltitude
, setWaypointName
, setWaypointSurfaceAltitude
, getWheelAutoFrictionControl
, getWheelAutoFrictionControlStream
, getWheelAutoFrictionControlStreamReq
, getWheelBrakes
, getWheelBrakesStream
, getWheelBrakesStreamReq
, getWheelBroken
, getWheelBrokenStream
, getWheelBrokenStreamReq
, getWheelDeflection
, getWheelDeflectionStream
, getWheelDeflectionStreamReq
, getWheelDeployable
, getWheelDeployableStream
, getWheelDeployableStreamReq
, getWheelDeployed
, getWheelDeployedStream
, getWheelDeployedStreamReq
, getWheelDriveLimiter
, getWheelDriveLimiterStream
, getWheelDriveLimiterStreamReq
, getWheelGrounded
, getWheelGroundedStream
, getWheelGroundedStreamReq
, getWheelHasBrakes
, getWheelHasBrakesStream
, getWheelHasBrakesStreamReq
, getWheelHasSuspension
, getWheelHasSuspensionStream
, getWheelHasSuspensionStreamReq
, getWheelManualFrictionControl
, getWheelManualFrictionControlStream
, getWheelManualFrictionControlStreamReq
, getWheelMotorEnabled
, getWheelMotorEnabledStream
, getWheelMotorEnabledStreamReq
, getWheelMotorInverted
, getWheelMotorInvertedStream
, getWheelMotorInvertedStreamReq
, getWheelMotorOutput
, getWheelMotorOutputStream
, getWheelMotorOutputStreamReq
, getWheelMotorState
, getWheelMotorStateStream
, getWheelMotorStateStreamReq
, getWheelPart
, getWheelPartStream
, getWheelPartStreamReq
, getWheelPowered
, getWheelPoweredStream
, getWheelPoweredStreamReq
, getWheelRadius
, getWheelRadiusStream
, getWheelRadiusStreamReq
, getWheelRepairable
, getWheelRepairableStream
, getWheelRepairableStreamReq
, getWheelSlip
, getWheelSlipStream
, getWheelSlipStreamReq
, getWheelState
, getWheelStateStream
, getWheelStateStreamReq
, getWheelSteerable
, getWheelSteerableStream
, getWheelSteerableStreamReq
, getWheelSteeringEnabled
, getWheelSteeringEnabledStream
, getWheelSteeringEnabledStreamReq
, getWheelSteeringInverted
, getWheelSteeringInvertedStream
, getWheelSteeringInvertedStreamReq
, getWheelStress
, getWheelStressStream
, getWheelStressStreamReq
, getWheelStressPercentage
, getWheelStressPercentageStream
, getWheelStressPercentageStreamReq
, getWheelStressTolerance
, getWheelStressToleranceStream
, getWheelStressToleranceStreamReq
, getWheelSuspensionDamperStrength
, getWheelSuspensionDamperStrengthStream
, getWheelSuspensionDamperStrengthStreamReq
, getWheelSuspensionSpringStrength
, getWheelSuspensionSpringStrengthStream
, getWheelSuspensionSpringStrengthStreamReq
, getWheelTractionControl
, getWheelTractionControlStream
, getWheelTractionControlStreamReq
, getWheelTractionControlEnabled
, getWheelTractionControlEnabledStream
, getWheelTractionControlEnabledStreamReq
, setWheelAutoFrictionControl
, setWheelBrakes
, setWheelDeployed
, setWheelDriveLimiter
, setWheelManualFrictionControl
, setWheelMotorEnabled
, setWheelMotorInverted
, setWheelSteeringEnabled
, setWheelSteeringInverted
, setWheelTractionControl
, setWheelTractionControlEnabled
, getActiveVessel
, getActiveVesselStream
, getActiveVesselStreamReq
, getBodies
, getBodiesStream
, getBodiesStreamReq
, getCamera
, getCameraStream
, getCameraStreamReq
, getContractManager
, getContractManagerStream
, getContractManagerStreamReq
, getFARAvailable
, getFARAvailableStream
, getFARAvailableStreamReq
, getG
, getGStream
, getGStreamReq
, getMaximumRailsWarpFactor
, getMaximumRailsWarpFactorStream
, getMaximumRailsWarpFactorStreamReq
, getNavball
, getNavballStream
, getNavballStreamReq
, getPhysicsWarpFactor
, getPhysicsWarpFactorStream
, getPhysicsWarpFactorStreamReq
, getRailsWarpFactor
, getRailsWarpFactorStream
, getRailsWarpFactorStreamReq
, getTargetBody
, getTargetBodyStream
, getTargetBodyStreamReq
, getTargetDockingPort
, getTargetDockingPortStream
, getTargetDockingPortStreamReq
, getTargetVessel
, getTargetVesselStream
, getTargetVesselStreamReq
, getUIVisible
, getUIVisibleStream
, getUIVisibleStreamReq
, getUT
, getUTStream
, getUTStreamReq
, getVessels
, getVesselsStream
, getVesselsStreamReq
, getWarpFactor
, getWarpFactorStream
, getWarpFactorStreamReq
, getWarpMode
, getWarpModeStream
, getWarpModeStreamReq
, getWarpRate
, getWarpRateStream
, getWarpRateStreamReq
, getWaypointManager
, getWaypointManagerStream
, getWaypointManagerStreamReq
, setActiveVessel
, setNavball
, setPhysicsWarpFactor
, setRailsWarpFactor
, setTargetBody
, setTargetDockingPort
, setTargetVessel
, setUIVisible
) where
import qualified Data.Int
import qualified Data.Map
import qualified Data.Set
import qualified Data.Text
import qualified Data.Word
import KRPCHS.Internal.Requests
import KRPCHS.Internal.SerializeUtils
{-
- An antenna. Obtained by calling <see cref="M:SpaceCenter.Part.Antenna" />.
-}
newtype Antenna = Antenna { antennaId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Antenna where
encodePb = encodePb . antennaId
decodePb b = Antenna <$> decodePb b
instance KRPCResponseExtractable Antenna
{-
- Provides basic auto-piloting utilities for a vessel.
- Created by calling <see cref="M:SpaceCenter.Vessel.AutoPilot" />.If a client engages the auto-pilot and then closes its connection to the server,
- the auto-pilot will be disengaged and its target reference frame, direction and roll reset to default.
-}
newtype AutoPilot = AutoPilot { autoPilotId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable AutoPilot where
encodePb = encodePb . autoPilotId
decodePb b = AutoPilot <$> decodePb b
instance KRPCResponseExtractable AutoPilot
{-
- Controls the game's camera.
- Obtained by calling <see cref="M:SpaceCenter.Camera" />.
-}
newtype Camera = Camera { cameraId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Camera where
encodePb = encodePb . cameraId
decodePb b = Camera <$> decodePb b
instance KRPCResponseExtractable Camera
{-
- A cargo bay. Obtained by calling <see cref="M:SpaceCenter.Part.CargoBay" />.
-}
newtype CargoBay = CargoBay { cargoBayId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable CargoBay where
encodePb = encodePb . cargoBayId
decodePb b = CargoBay <$> decodePb b
instance KRPCResponseExtractable CargoBay
{-
- Represents a celestial body (such as a planet or moon).
- See <see cref="M:SpaceCenter.Bodies" />.
-}
newtype CelestialBody = CelestialBody { celestialBodyId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable CelestialBody where
encodePb = encodePb . celestialBodyId
decodePb b = CelestialBody <$> decodePb b
instance KRPCResponseExtractable CelestialBody
{-
- Represents a communication node in the network. For example, a vessel or the KSC.
-}
newtype CommLink = CommLink { commLinkId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable CommLink where
encodePb = encodePb . commLinkId
decodePb b = CommLink <$> decodePb b
instance KRPCResponseExtractable CommLink
{-
- Represents a communication node in the network. For example, a vessel or the KSC.
-}
newtype CommNode = CommNode { commNodeId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable CommNode where
encodePb = encodePb . commNodeId
decodePb b = CommNode <$> decodePb b
instance KRPCResponseExtractable CommNode
{-
- Used to interact with CommNet for a given vessel.
- Obtained by calling <see cref="M:SpaceCenter.Vessel.Comms" />.
-}
newtype Comms = Comms { commsId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Comms where
encodePb = encodePb . commsId
decodePb b = Comms <$> decodePb b
instance KRPCResponseExtractable Comms
{-
- A contract. Can be accessed using <see cref="M:SpaceCenter.ContractManager" />.
-}
newtype Contract = Contract { contractId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Contract where
encodePb = encodePb . contractId
decodePb b = Contract <$> decodePb b
instance KRPCResponseExtractable Contract
{-
- Contracts manager.
- Obtained by calling <see cref="M:SpaceCenter.WaypointManager" />.
-}
newtype ContractManager = ContractManager { contractManagerId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ContractManager where
encodePb = encodePb . contractManagerId
decodePb b = ContractManager <$> decodePb b
instance KRPCResponseExtractable ContractManager
{-
- A contract parameter. See <see cref="M:SpaceCenter.Contract.Parameters" />.
-}
newtype ContractParameter = ContractParameter { contractParameterId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ContractParameter where
encodePb = encodePb . contractParameterId
decodePb b = ContractParameter <$> decodePb b
instance KRPCResponseExtractable ContractParameter
{-
- Used to manipulate the controls of a vessel. This includes adjusting the
- throttle, enabling/disabling systems such as SAS and RCS, or altering the
- direction in which the vessel is pointing.
- Obtained by calling <see cref="M:SpaceCenter.Vessel.Control" />.Control inputs (such as pitch, yaw and roll) are zeroed when all clients
- that have set one or more of these inputs are no longer connected.
-}
newtype Control = Control { controlId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Control where
encodePb = encodePb . controlId
decodePb b = Control <$> decodePb b
instance KRPCResponseExtractable Control
{-
- An aerodynamic control surface. Obtained by calling <see cref="M:SpaceCenter.Part.ControlSurface" />.
-}
newtype ControlSurface = ControlSurface { controlSurfaceId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ControlSurface where
encodePb = encodePb . controlSurfaceId
decodePb b = ControlSurface <$> decodePb b
instance KRPCResponseExtractable ControlSurface
{-
- A decoupler. Obtained by calling <see cref="M:SpaceCenter.Part.Decoupler" />
-}
newtype Decoupler = Decoupler { decouplerId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Decoupler where
encodePb = encodePb . decouplerId
decodePb b = Decoupler <$> decodePb b
instance KRPCResponseExtractable Decoupler
{-
- A docking port. Obtained by calling <see cref="M:SpaceCenter.Part.DockingPort" />
-}
newtype DockingPort = DockingPort { dockingPortId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable DockingPort where
encodePb = encodePb . dockingPortId
decodePb b = DockingPort <$> decodePb b
instance KRPCResponseExtractable DockingPort
{-
- An engine, including ones of various types.
- For example liquid fuelled gimballed engines, solid rocket boosters and jet engines.
- Obtained by calling <see cref="M:SpaceCenter.Part.Engine" />.For RCS thrusters <see cref="M:SpaceCenter.Part.RCS" />.
-}
newtype Engine = Engine { engineId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Engine where
encodePb = encodePb . engineId
decodePb b = Engine <$> decodePb b
instance KRPCResponseExtractable Engine
{-
- Obtained by calling <see cref="M:SpaceCenter.Part.Experiment" />.
-}
newtype Experiment = Experiment { experimentId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Experiment where
encodePb = encodePb . experimentId
decodePb b = Experiment <$> decodePb b
instance KRPCResponseExtractable Experiment
{-
- A fairing. Obtained by calling <see cref="M:SpaceCenter.Part.Fairing" />.
-}
newtype Fairing = Fairing { fairingId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Fairing where
encodePb = encodePb . fairingId
decodePb b = Fairing <$> decodePb b
instance KRPCResponseExtractable Fairing
{-
- Used to get flight telemetry for a vessel, by calling <see cref="M:SpaceCenter.Vessel.Flight" />.
- All of the information returned by this class is given in the reference frame
- passed to that method.
- Obtained by calling <see cref="M:SpaceCenter.Vessel.Flight" />.To get orbital information, such as the apoapsis or inclination, see <see cref="T:SpaceCenter.Orbit" />.
-}
newtype Flight = Flight { flightId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Flight where
encodePb = encodePb . flightId
decodePb b = Flight <$> decodePb b
instance KRPCResponseExtractable Flight
{-
- Obtained by calling <see cref="M:SpaceCenter.Part.AddForce" />.
-}
newtype Force = Force { forceId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Force where
encodePb = encodePb . forceId
decodePb b = Force <$> decodePb b
instance KRPCResponseExtractable Force
{-
- An air intake. Obtained by calling <see cref="M:SpaceCenter.Part.Intake" />.
-}
newtype Intake = Intake { intakeId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Intake where
encodePb = encodePb . intakeId
decodePb b = Intake <$> decodePb b
instance KRPCResponseExtractable Intake
{-
- A launch clamp. Obtained by calling <see cref="M:SpaceCenter.Part.LaunchClamp" />.
-}
newtype LaunchClamp = LaunchClamp { launchClampId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable LaunchClamp where
encodePb = encodePb . launchClampId
decodePb b = LaunchClamp <$> decodePb b
instance KRPCResponseExtractable LaunchClamp
{-
- A landing leg. Obtained by calling <see cref="M:SpaceCenter.Part.Leg" />.
-}
newtype Leg = Leg { legId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Leg where
encodePb = encodePb . legId
decodePb b = Leg <$> decodePb b
instance KRPCResponseExtractable Leg
{-
- A light. Obtained by calling <see cref="M:SpaceCenter.Part.Light" />.
-}
newtype Light = Light { lightId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Light where
encodePb = encodePb . lightId
decodePb b = Light <$> decodePb b
instance KRPCResponseExtractable Light
{-
- This can be used to interact with a specific part module. This includes part modules in stock KSP,
- and those added by mods.
-
- In KSP, each part has zero or more
- <a href="http://wiki.kerbalspaceprogram.com/wiki/CFG_File_Documentation#MODULES">PartModulesassociated with it. Each one contains some of the functionality of the part.
- For example, an engine has a "ModuleEngines" part module that contains all the
- functionality of an engine.
-}
newtype Module = Module { moduleId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Module where
encodePb = encodePb . moduleId
decodePb b = Module <$> decodePb b
instance KRPCResponseExtractable Module
{-
- Represents a maneuver node. Can be created using <see cref="M:SpaceCenter.Control.AddNode" />.
-}
newtype Node = Node { nodeId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Node where
encodePb = encodePb . nodeId
decodePb b = Node <$> decodePb b
instance KRPCResponseExtractable Node
{-
- Describes an orbit. For example, the orbit of a vessel, obtained by calling
- <see cref="M:SpaceCenter.Vessel.Orbit" />, or a celestial body, obtained by calling
- <see cref="M:SpaceCenter.CelestialBody.Orbit" />.
-}
newtype Orbit = Orbit { orbitId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Orbit where
encodePb = encodePb . orbitId
decodePb b = Orbit <$> decodePb b
instance KRPCResponseExtractable Orbit
{-
- A parachute. Obtained by calling <see cref="M:SpaceCenter.Part.Parachute" />.
-}
newtype Parachute = Parachute { parachuteId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Parachute where
encodePb = encodePb . parachuteId
decodePb b = Parachute <$> decodePb b
instance KRPCResponseExtractable Parachute
{-
- Represents an individual part. Vessels are made up of multiple parts.
- Instances of this class can be obtained by several methods in <see cref="T:SpaceCenter.Parts" />.
-}
newtype Part = Part { partId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Part where
encodePb = encodePb . partId
decodePb b = Part <$> decodePb b
instance KRPCResponseExtractable Part
{-
- Instances of this class are used to interact with the parts of a vessel.
- An instance can be obtained by calling <see cref="M:SpaceCenter.Vessel.Parts" />.
-}
newtype Parts = Parts { partsId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Parts where
encodePb = encodePb . partsId
decodePb b = Parts <$> decodePb b
instance KRPCResponseExtractable Parts
{-
- A propellant for an engine. Obtains by calling <see cref="M:SpaceCenter.Engine.Propellants" />.
-}
newtype Propellant = Propellant { propellantId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Propellant where
encodePb = encodePb . propellantId
decodePb b = Propellant <$> decodePb b
instance KRPCResponseExtractable Propellant
{-
- An RCS block or thruster. Obtained by calling <see cref="M:SpaceCenter.Part.RCS" />.
-}
newtype RCS = RCS { rCSId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable RCS where
encodePb = encodePb . rCSId
decodePb b = RCS <$> decodePb b
instance KRPCResponseExtractable RCS
{-
- A radiator. Obtained by calling <see cref="M:SpaceCenter.Part.Radiator" />.
-}
newtype Radiator = Radiator { radiatorId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Radiator where
encodePb = encodePb . radiatorId
decodePb b = Radiator <$> decodePb b
instance KRPCResponseExtractable Radiator
{-
- A reaction wheel. Obtained by calling <see cref="M:SpaceCenter.Part.ReactionWheel" />.
-}
newtype ReactionWheel = ReactionWheel { reactionWheelId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ReactionWheel where
encodePb = encodePb . reactionWheelId
decodePb b = ReactionWheel <$> decodePb b
instance KRPCResponseExtractable ReactionWheel
{-
- Represents a reference frame for positions, rotations and
- velocities. Contains:
- <list type="bullet">The position of the origin.The directions of the x, y and z axes.The linear velocity of the frame.The angular velocity of the frame.This class does not contain any properties or methods. It is only
- used as a parameter to other functions.
-}
newtype ReferenceFrame = ReferenceFrame { referenceFrameId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ReferenceFrame where
encodePb = encodePb . referenceFrameId
decodePb b = ReferenceFrame <$> decodePb b
instance KRPCResponseExtractable ReferenceFrame
{-
- An individual resource stored within a part.
- Created using methods in the <see cref="T:SpaceCenter.Resources" /> class.
-}
newtype Resource = Resource { resourceId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Resource where
encodePb = encodePb . resourceId
decodePb b = Resource <$> decodePb b
instance KRPCResponseExtractable Resource
{-
- A resource converter. Obtained by calling <see cref="M:SpaceCenter.Part.ResourceConverter" />.
-}
newtype ResourceConverter = ResourceConverter { resourceConverterId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ResourceConverter where
encodePb = encodePb . resourceConverterId
decodePb b = ResourceConverter <$> decodePb b
instance KRPCResponseExtractable ResourceConverter
{-
- A resource harvester (drill). Obtained by calling <see cref="M:SpaceCenter.Part.ResourceHarvester" />.
-}
newtype ResourceHarvester = ResourceHarvester { resourceHarvesterId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ResourceHarvester where
encodePb = encodePb . resourceHarvesterId
decodePb b = ResourceHarvester <$> decodePb b
instance KRPCResponseExtractable ResourceHarvester
{-
- Transfer resources between parts.
-}
newtype ResourceTransfer = ResourceTransfer { resourceTransferId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ResourceTransfer where
encodePb = encodePb . resourceTransferId
decodePb b = ResourceTransfer <$> decodePb b
instance KRPCResponseExtractable ResourceTransfer
{-
- Represents the collection of resources stored in a vessel, stage or part.
- Created by calling <see cref="M:SpaceCenter.Vessel.Resources" />,
- <see cref="M:SpaceCenter.Vessel.ResourcesInDecoupleStage" /> or
- <see cref="M:SpaceCenter.Part.Resources" />.
-}
newtype Resources = Resources { resourcesId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Resources where
encodePb = encodePb . resourcesId
decodePb b = Resources <$> decodePb b
instance KRPCResponseExtractable Resources
{-
- Obtained by calling <see cref="M:SpaceCenter.Experiment.Data" />.
-}
newtype ScienceData = ScienceData { scienceDataId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ScienceData where
encodePb = encodePb . scienceDataId
decodePb b = ScienceData <$> decodePb b
instance KRPCResponseExtractable ScienceData
{-
- Obtained by calling <see cref="M:SpaceCenter.Experiment.ScienceSubject" />.
-}
newtype ScienceSubject = ScienceSubject { scienceSubjectId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable ScienceSubject where
encodePb = encodePb . scienceSubjectId
decodePb b = ScienceSubject <$> decodePb b
instance KRPCResponseExtractable ScienceSubject
{-
- A sensor, such as a thermometer. Obtained by calling <see cref="M:SpaceCenter.Part.Sensor" />.
-}
newtype Sensor = Sensor { sensorId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Sensor where
encodePb = encodePb . sensorId
decodePb b = Sensor <$> decodePb b
instance KRPCResponseExtractable Sensor
{-
- A solar panel. Obtained by calling <see cref="M:SpaceCenter.Part.SolarPanel" />.
-}
newtype SolarPanel = SolarPanel { solarPanelId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable SolarPanel where
encodePb = encodePb . solarPanelId
decodePb b = SolarPanel <$> decodePb b
instance KRPCResponseExtractable SolarPanel
{-
- The component of an <see cref="T:SpaceCenter.Engine" /> or <see cref="T:SpaceCenter.RCS" /> part that generates thrust.
- Can obtained by calling <see cref="M:SpaceCenter.Engine.Thrusters" /> or <see cref="M:SpaceCenter.RCS.Thrusters" />.Engines can consist of multiple thrusters.
- For example, the S3 KS-25x4 "Mammoth" has four rocket nozzels, and so consists of four thrusters.
-}
newtype Thruster = Thruster { thrusterId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Thruster where
encodePb = encodePb . thrusterId
decodePb b = Thruster <$> decodePb b
instance KRPCResponseExtractable Thruster
{-
- These objects are used to interact with vessels in KSP. This includes getting
- orbital and flight data, manipulating control inputs and managing resources.
- Created using <see cref="M:SpaceCenter.ActiveVessel" /> or <see cref="M:SpaceCenter.Vessels" />.
-}
newtype Vessel = Vessel { vesselId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Vessel where
encodePb = encodePb . vesselId
decodePb b = Vessel <$> decodePb b
instance KRPCResponseExtractable Vessel
{-
- Represents a waypoint. Can be created using <see cref="M:SpaceCenter.WaypointManager.AddWaypoint" />.
-}
newtype Waypoint = Waypoint { waypointId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Waypoint where
encodePb = encodePb . waypointId
decodePb b = Waypoint <$> decodePb b
instance KRPCResponseExtractable Waypoint
{-
- Waypoints are the location markers you can see on the map view showing you where contracts are targeted for.
- With this structure, you can obtain coordinate data for the locations of these waypoints.
- Obtained by calling <see cref="M:SpaceCenter.WaypointManager" />.
-}
newtype WaypointManager = WaypointManager { waypointManagerId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable WaypointManager where
encodePb = encodePb . waypointManagerId
decodePb b = WaypointManager <$> decodePb b
instance KRPCResponseExtractable WaypointManager
{-
- A wheel. Includes landing gear and rover wheels. Obtained by calling <see cref="M:SpaceCenter.Part.Wheel" />.
- Can be used to control the motors, steering and deployment of wheels, among other things.
-}
newtype Wheel = Wheel { wheelId :: Int }
deriving (Show, Eq, Ord)
instance PbSerializable Wheel where
encodePb = encodePb . wheelId
decodePb b = Wheel <$> decodePb b
instance KRPCResponseExtractable Wheel
{-
- The state of an antenna. See <see cref="M:SpaceCenter.Antenna.State" />.
-}
data AntennaState
= AntennaState'Deployed
| AntennaState'Retracted
| AntennaState'Deploying
| AntennaState'Retracting
| AntennaState'Broken
deriving (Show, Eq, Ord, Enum)
instance PbSerializable AntennaState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable AntennaState
{-
- See <see cref="M:SpaceCenter.Camera.Mode" />.
-}
data CameraMode
= CameraMode'Automatic
| CameraMode'Free
| CameraMode'Chase
| CameraMode'Locked
| CameraMode'Orbital
| CameraMode'IVA
| CameraMode'Map
deriving (Show, Eq, Ord, Enum)
instance PbSerializable CameraMode where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable CameraMode
{-
- The state of a cargo bay. See <see cref="M:SpaceCenter.CargoBay.State" />.
-}
data CargoBayState
= CargoBayState'Open
| CargoBayState'Closed
| CargoBayState'Opening
| CargoBayState'Closing
deriving (Show, Eq, Ord, Enum)
instance PbSerializable CargoBayState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable CargoBayState
{-
- The type of a communication link.
- See <see cref="M:SpaceCenter.CommLink.Type" />.
-}
data CommLinkType
= CommLinkType'Home
| CommLinkType'Control
| CommLinkType'Relay
deriving (Show, Eq, Ord, Enum)
instance PbSerializable CommLinkType where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable CommLinkType
{-
- The state of a contract. See <see cref="M:SpaceCenter.Contract.State" />.
-}
data ContractState
= ContractState'Active
| ContractState'Canceled
| ContractState'Completed
| ContractState'DeadlineExpired
| ContractState'Declined
| ContractState'Failed
| ContractState'Generated
| ContractState'Offered
| ContractState'OfferExpired
| ContractState'Withdrawn
deriving (Show, Eq, Ord, Enum)
instance PbSerializable ContractState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable ContractState
{-
- The control source of a vessel.
- See <see cref="M:SpaceCenter.Control.Source" />.
-}
data ControlSource
= ControlSource'Kerbal
| ControlSource'Probe
| ControlSource'None
deriving (Show, Eq, Ord, Enum)
instance PbSerializable ControlSource where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable ControlSource
{-
- The control state of a vessel.
- See <see cref="M:SpaceCenter.Control.State" />.
-}
data ControlState
= ControlState'Full
| ControlState'Partial
| ControlState'None
deriving (Show, Eq, Ord, Enum)
instance PbSerializable ControlState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable ControlState
{-
- The state of a docking port. See <see cref="M:SpaceCenter.DockingPort.State" />.
-}
data DockingPortState
= DockingPortState'Ready
| DockingPortState'Docked
| DockingPortState'Docking
| DockingPortState'Undocking
| DockingPortState'Shielded
| DockingPortState'Moving
deriving (Show, Eq, Ord, Enum)
instance PbSerializable DockingPortState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable DockingPortState
{-
- The state of a landing leg. See <see cref="M:SpaceCenter.Leg.State" />.
-}
data LegState
= LegState'Deployed
| LegState'Retracted
| LegState'Deploying
| LegState'Retracting
| LegState'Broken
deriving (Show, Eq, Ord, Enum)
instance PbSerializable LegState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable LegState
{-
- The state of the motor on a powered wheel. See <see cref="M:SpaceCenter.Wheel.MotorState" />.
-}
data MotorState
= MotorState'Idle
| MotorState'Running
| MotorState'Disabled
| MotorState'Inoperable
| MotorState'NotEnoughResources
deriving (Show, Eq, Ord, Enum)
instance PbSerializable MotorState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable MotorState
{-
- The state of a parachute. See <see cref="M:SpaceCenter.Parachute.State" />.
-}
data ParachuteState
= ParachuteState'Stowed
| ParachuteState'Armed
| ParachuteState'Active
| ParachuteState'SemiDeployed
| ParachuteState'Deployed
| ParachuteState'Cut
deriving (Show, Eq, Ord, Enum)
instance PbSerializable ParachuteState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable ParachuteState
{-
- The state of a radiator. <see cref="T:SpaceCenter.RadiatorState" />
-}
data RadiatorState
= RadiatorState'Extended
| RadiatorState'Retracted
| RadiatorState'Extending
| RadiatorState'Retracting
| RadiatorState'Broken
deriving (Show, Eq, Ord, Enum)
instance PbSerializable RadiatorState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable RadiatorState
{-
- The state of a resource converter. See <see cref="M:SpaceCenter.ResourceConverter.State" />.
-}
data ResourceConverterState
= ResourceConverterState'Running
| ResourceConverterState'Idle
| ResourceConverterState'MissingResource
| ResourceConverterState'StorageFull
| ResourceConverterState'Capacity
| ResourceConverterState'Unknown
deriving (Show, Eq, Ord, Enum)
instance PbSerializable ResourceConverterState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable ResourceConverterState
{-
- The way in which a resource flows between parts. See <see cref="M:SpaceCenter.Resources.FlowMode" />.
-}
data ResourceFlowMode
= ResourceFlowMode'Vessel
| ResourceFlowMode'Stage
| ResourceFlowMode'Adjacent
| ResourceFlowMode'None
deriving (Show, Eq, Ord, Enum)
instance PbSerializable ResourceFlowMode where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable ResourceFlowMode
{-
- The state of a resource harvester. See <see cref="M:SpaceCenter.ResourceHarvester.State" />.
-}
data ResourceHarvesterState
= ResourceHarvesterState'Deploying
| ResourceHarvesterState'Deployed
| ResourceHarvesterState'Retracting
| ResourceHarvesterState'Retracted
| ResourceHarvesterState'Active
deriving (Show, Eq, Ord, Enum)
instance PbSerializable ResourceHarvesterState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable ResourceHarvesterState
{-
- The behavior of the SAS auto-pilot. See <see cref="M:SpaceCenter.AutoPilot.SASMode" />.
-}
data SASMode
= SASMode'StabilityAssist
| SASMode'Maneuver
| SASMode'Prograde
| SASMode'Retrograde
| SASMode'Normal
| SASMode'AntiNormal
| SASMode'Radial
| SASMode'AntiRadial
| SASMode'Target
| SASMode'AntiTarget
deriving (Show, Eq, Ord, Enum)
instance PbSerializable SASMode where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable SASMode
{-
- The state of a solar panel. See <see cref="M:SpaceCenter.SolarPanel.State" />.
-}
data SolarPanelState
= SolarPanelState'Extended
| SolarPanelState'Retracted
| SolarPanelState'Extending
| SolarPanelState'Retracting
| SolarPanelState'Broken
deriving (Show, Eq, Ord, Enum)
instance PbSerializable SolarPanelState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable SolarPanelState
{-
- The mode of the speed reported in the navball.
- See <see cref="M:SpaceCenter.Control.SpeedMode" />.
-}
data SpeedMode
= SpeedMode'Orbit
| SpeedMode'Surface
| SpeedMode'Target
deriving (Show, Eq, Ord, Enum)
instance PbSerializable SpeedMode where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable SpeedMode
{-
- The situation a vessel is in.
- See <see cref="M:SpaceCenter.Vessel.Situation" />.
-}
data VesselSituation
= VesselSituation'PreLaunch
| VesselSituation'Orbiting
| VesselSituation'SubOrbital
| VesselSituation'Escaping
| VesselSituation'Flying
| VesselSituation'Landed
| VesselSituation'Splashed
| VesselSituation'Docked
deriving (Show, Eq, Ord, Enum)
instance PbSerializable VesselSituation where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable VesselSituation
{-
- The type of a vessel.
- See <see cref="M:SpaceCenter.Vessel.Type" />.
-}
data VesselType
= VesselType'Ship
| VesselType'Station
| VesselType'Lander
| VesselType'Probe
| VesselType'Rover
| VesselType'Base
| VesselType'Debris
deriving (Show, Eq, Ord, Enum)
instance PbSerializable VesselType where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable VesselType
{-
- The time warp mode.
- Returned by <see cref="T:SpaceCenter.WarpMode" />
-}
data WarpMode
= WarpMode'Rails
| WarpMode'Physics
| WarpMode'None
deriving (Show, Eq, Ord, Enum)
instance PbSerializable WarpMode where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable WarpMode
{-
- The state of a wheel. See <see cref="M:SpaceCenter.Wheel.State" />.
-}
data WheelState
= WheelState'Deployed
| WheelState'Retracted
| WheelState'Deploying
| WheelState'Retracting
| WheelState'Broken
deriving (Show, Eq, Ord, Enum)
instance PbSerializable WheelState where
encodePb = encodePb . fromEnum
decodePb b = toEnum <$> decodePb b
instance KRPCResponseExtractable WheelState
{-
- Cancel current transmission of data.
-}
antennaCancel :: KRPCHS.SpaceCenter.Antenna -> RPCContext ()
antennaCancel thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_Cancel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Transmit data.
-}
antennaTransmit :: KRPCHS.SpaceCenter.Antenna -> RPCContext ()
antennaTransmit thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_Transmit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Whether partial data transmission is permitted.
-}
getAntennaAllowPartial :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Bool)
getAntennaAllowPartial thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_AllowPartial" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaAllowPartialStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Bool)
getAntennaAllowPartialStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_AllowPartial" [makeArgument 0 thisArg]
in makeStream req
getAntennaAllowPartialStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Bool))
getAntennaAllowPartialStream thisArg = requestStream $ getAntennaAllowPartialStreamReq thisArg
{-
- Whether data can be transmitted by this antenna.
-}
getAntennaCanTransmit :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Bool)
getAntennaCanTransmit thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_CanTransmit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaCanTransmitStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Bool)
getAntennaCanTransmitStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_CanTransmit" [makeArgument 0 thisArg]
in makeStream req
getAntennaCanTransmitStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Bool))
getAntennaCanTransmitStream thisArg = requestStream $ getAntennaCanTransmitStreamReq thisArg
{-
- Whether the antenna can be combined with other antennae on the vessel to boost the power.
-}
getAntennaCombinable :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Bool)
getAntennaCombinable thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_Combinable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaCombinableStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Bool)
getAntennaCombinableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_Combinable" [makeArgument 0 thisArg]
in makeStream req
getAntennaCombinableStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Bool))
getAntennaCombinableStream thisArg = requestStream $ getAntennaCombinableStreamReq thisArg
{-
- Exponent used to calculate the combined power of multiple antennae on a vessel.
-}
getAntennaCombinableExponent :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Double)
getAntennaCombinableExponent thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_CombinableExponent" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaCombinableExponentStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Double)
getAntennaCombinableExponentStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_CombinableExponent" [makeArgument 0 thisArg]
in makeStream req
getAntennaCombinableExponentStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Double))
getAntennaCombinableExponentStream thisArg = requestStream $ getAntennaCombinableExponentStreamReq thisArg
{-
- Whether the antenna is deployable.
-}
getAntennaDeployable :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Bool)
getAntennaDeployable thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_Deployable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaDeployableStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Bool)
getAntennaDeployableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_Deployable" [makeArgument 0 thisArg]
in makeStream req
getAntennaDeployableStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Bool))
getAntennaDeployableStream thisArg = requestStream $ getAntennaDeployableStreamReq thisArg
{-
- Whether the antenna is deployed.Fixed antennas are always deployed.
- Returns an error if you try to deploy a fixed antenna.
-}
getAntennaDeployed :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Bool)
getAntennaDeployed thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaDeployedStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Bool)
getAntennaDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getAntennaDeployedStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Bool))
getAntennaDeployedStream thisArg = requestStream $ getAntennaDeployedStreamReq thisArg
{-
- Interval between sending packets in seconds.
-}
getAntennaPacketInterval :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Float)
getAntennaPacketInterval thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_PacketInterval" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaPacketIntervalStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Float)
getAntennaPacketIntervalStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_PacketInterval" [makeArgument 0 thisArg]
in makeStream req
getAntennaPacketIntervalStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Float))
getAntennaPacketIntervalStream thisArg = requestStream $ getAntennaPacketIntervalStreamReq thisArg
{-
- Units of electric charge consumed per packet sent.
-}
getAntennaPacketResourceCost :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Double)
getAntennaPacketResourceCost thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_PacketResourceCost" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaPacketResourceCostStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Double)
getAntennaPacketResourceCostStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_PacketResourceCost" [makeArgument 0 thisArg]
in makeStream req
getAntennaPacketResourceCostStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Double))
getAntennaPacketResourceCostStream thisArg = requestStream $ getAntennaPacketResourceCostStreamReq thisArg
{-
- Amount of data sent per packet in Mits.
-}
getAntennaPacketSize :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Float)
getAntennaPacketSize thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_PacketSize" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaPacketSizeStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Float)
getAntennaPacketSizeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_PacketSize" [makeArgument 0 thisArg]
in makeStream req
getAntennaPacketSizeStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Float))
getAntennaPacketSizeStream thisArg = requestStream $ getAntennaPacketSizeStreamReq thisArg
{-
- The part object for this antenna.
-}
getAntennaPart :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCHS.SpaceCenter.Part)
getAntennaPart thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaPartStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getAntennaPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_Part" [makeArgument 0 thisArg]
in makeStream req
getAntennaPartStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getAntennaPartStream thisArg = requestStream $ getAntennaPartStreamReq thisArg
{-
- The power of the antenna.
-}
getAntennaPower :: KRPCHS.SpaceCenter.Antenna -> RPCContext (Double)
getAntennaPower thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_Power" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaPowerStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (Double)
getAntennaPowerStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_Power" [makeArgument 0 thisArg]
in makeStream req
getAntennaPowerStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (Double))
getAntennaPowerStream thisArg = requestStream $ getAntennaPowerStreamReq thisArg
{-
- The current state of the antenna.
-}
getAntennaState :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCHS.SpaceCenter.AntennaState)
getAntennaState thisArg = do
let r = makeRequest "SpaceCenter" "Antenna_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAntennaStateStreamReq :: KRPCHS.SpaceCenter.Antenna -> KRPCStreamReq (KRPCHS.SpaceCenter.AntennaState)
getAntennaStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Antenna_get_State" [makeArgument 0 thisArg]
in makeStream req
getAntennaStateStream :: KRPCHS.SpaceCenter.Antenna -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.AntennaState))
getAntennaStateStream thisArg = requestStream $ getAntennaStateStreamReq thisArg
{-
- Whether partial data transmission is permitted.
-}
setAntennaAllowPartial :: KRPCHS.SpaceCenter.Antenna -> Bool -> RPCContext ()
setAntennaAllowPartial thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Antenna_set_AllowPartial" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the antenna is deployed.Fixed antennas are always deployed.
- Returns an error if you try to deploy a fixed antenna.
-}
setAntennaDeployed :: KRPCHS.SpaceCenter.Antenna -> Bool -> RPCContext ()
setAntennaDeployed thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Antenna_set_Deployed" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Disengage the auto-pilot.
-}
autoPilotDisengage :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ()
autoPilotDisengage thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_Disengage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Engage the auto-pilot.
-}
autoPilotEngage :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ()
autoPilotEngage thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_Engage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Set target pitch and heading angles.<param name="pitch">Target pitch angle, in degrees between -90° and +90°.<param name="heading">Target heading angle, in degrees between 0° and 360°.
-}
autoPilotTargetPitchAndHeading :: KRPCHS.SpaceCenter.AutoPilot -> Float -> Float -> RPCContext ()
autoPilotTargetPitchAndHeading thisArg pitchArg headingArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_TargetPitchAndHeading" [makeArgument 0 thisArg, makeArgument 1 pitchArg, makeArgument 2 headingArg]
res <- sendRequest r
processResponse res
{-
- Blocks until the vessel is pointing in the target direction and has the target roll (if set).
-}
autoPilotWait :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ()
autoPilotWait thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_Wait" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- The angle at which the autopilot considers the vessel to be pointing close to the target.
- This determines the midpoint of the target velocity attenuation function.
- A vector of three angles, in degrees, one for each of the pitch, roll and yaw axes.
- Defaults to 1° for each axis.
-}
getAutoPilotAttenuationAngle :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotAttenuationAngle thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_AttenuationAngle" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotAttenuationAngleStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotAttenuationAngleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_AttenuationAngle" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotAttenuationAngleStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotAttenuationAngleStream thisArg = requestStream $ getAutoPilotAttenuationAngleStreamReq thisArg
{-
- Whether the rotation rate controllers PID parameters should be automatically tuned using the
- vessels moment of inertia and available torque. Defaults totrue.
- See <see cref="M:SpaceCenter.AutoPilot.TimeToPeak" /> and <see cref="M:SpaceCenter.AutoPilot.Overshoot" />.
-}
getAutoPilotAutoTune :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Bool)
getAutoPilotAutoTune thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_AutoTune" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotAutoTuneStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Bool)
getAutoPilotAutoTuneStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_AutoTune" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotAutoTuneStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Bool))
getAutoPilotAutoTuneStream thisArg = requestStream $ getAutoPilotAutoTuneStreamReq thisArg
{-
- The time the vessel should take to come to a stop pointing in the target direction.
- This determines the angular acceleration used to decelerate the vessel.
- A vector of three times, in seconds, one for each of the pitch, roll and yaw axes.
- Defaults to 5 seconds for each axis.
-}
getAutoPilotDecelerationTime :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotDecelerationTime thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_DecelerationTime" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotDecelerationTimeStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotDecelerationTimeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_DecelerationTime" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotDecelerationTimeStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotDecelerationTimeStream thisArg = requestStream $ getAutoPilotDecelerationTimeStreamReq thisArg
{-
- The error, in degrees, between the direction the ship has been asked
- to point in and the direction it is pointing in. Returns zero if the auto-pilot
- has not been engaged and SAS is not enabled or is in stability assist mode.
-}
getAutoPilotError :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Float)
getAutoPilotError thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_Error" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotErrorStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Float)
getAutoPilotErrorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_Error" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotErrorStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Float))
getAutoPilotErrorStream thisArg = requestStream $ getAutoPilotErrorStreamReq thisArg
{-
- The error, in degrees, between the vessels current and target heading.
- Returns zero if the auto-pilot has not been engaged.
-}
getAutoPilotHeadingError :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Float)
getAutoPilotHeadingError thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_HeadingError" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotHeadingErrorStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Float)
getAutoPilotHeadingErrorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_HeadingError" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotHeadingErrorStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Float))
getAutoPilotHeadingErrorStream thisArg = requestStream $ getAutoPilotHeadingErrorStreamReq thisArg
{-
- The target overshoot percentage used to autotune the PID controllers.
- A vector of three values, between 0 and 1, for each of the pitch, roll and yaw axes.
- Defaults to 0.01 for each axis.
-}
getAutoPilotOvershoot :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotOvershoot thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_Overshoot" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotOvershootStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotOvershootStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_Overshoot" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotOvershootStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotOvershootStream thisArg = requestStream $ getAutoPilotOvershootStreamReq thisArg
{-
- The error, in degrees, between the vessels current and target pitch.
- Returns zero if the auto-pilot has not been engaged.
-}
getAutoPilotPitchError :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Float)
getAutoPilotPitchError thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_PitchError" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotPitchErrorStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Float)
getAutoPilotPitchErrorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_PitchError" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotPitchErrorStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Float))
getAutoPilotPitchErrorStream thisArg = requestStream $ getAutoPilotPitchErrorStreamReq thisArg
{-
- Gains for the pitch PID controller.When <see cref="M:SpaceCenter.AutoPilot.AutoTune" /> is true, these values are updated automatically, which will overwrite any manual changes.
-}
getAutoPilotPitchPIDGains :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotPitchPIDGains thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_PitchPIDGains" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotPitchPIDGainsStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotPitchPIDGainsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_PitchPIDGains" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotPitchPIDGainsStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotPitchPIDGainsStream thisArg = requestStream $ getAutoPilotPitchPIDGainsStreamReq thisArg
{-
- The reference frame for the target direction (<see cref="M:SpaceCenter.AutoPilot.TargetDirection" />).An error will be thrown if this property is set to a reference frame that rotates with the vessel being controlled,
- as it is impossible to rotate the vessel in such a reference frame.
-}
getAutoPilotReferenceFrame :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getAutoPilotReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_ReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotReferenceFrameStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getAutoPilotReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_ReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotReferenceFrameStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getAutoPilotReferenceFrameStream thisArg = requestStream $ getAutoPilotReferenceFrameStreamReq thisArg
{-
- The error, in degrees, between the vessels current and target roll.
- Returns zero if the auto-pilot has not been engaged or no target roll is set.
-}
getAutoPilotRollError :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Float)
getAutoPilotRollError thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_RollError" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotRollErrorStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Float)
getAutoPilotRollErrorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_RollError" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotRollErrorStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Float))
getAutoPilotRollErrorStream thisArg = requestStream $ getAutoPilotRollErrorStreamReq thisArg
{-
- Gains for the roll PID controller.When <see cref="M:SpaceCenter.AutoPilot.AutoTune" /> is true, these values are updated automatically, which will overwrite any manual changes.
-}
getAutoPilotRollPIDGains :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotRollPIDGains thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_RollPIDGains" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotRollPIDGainsStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotRollPIDGainsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_RollPIDGains" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotRollPIDGainsStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotRollPIDGainsStream thisArg = requestStream $ getAutoPilotRollPIDGainsStreamReq thisArg
{-
- The threshold at which the autopilot will try to match the target roll angle, if any.
- Defaults to 5 degrees.
-}
getAutoPilotRollThreshold :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Double)
getAutoPilotRollThreshold thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_RollThreshold" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotRollThresholdStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Double)
getAutoPilotRollThresholdStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_RollThreshold" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotRollThresholdStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Double))
getAutoPilotRollThresholdStream thisArg = requestStream $ getAutoPilotRollThresholdStreamReq thisArg
{-
- The state of SAS.Equivalent to <see cref="M:SpaceCenter.Control.SAS" />
-}
getAutoPilotSAS :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Bool)
getAutoPilotSAS thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_SAS" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotSASStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Bool)
getAutoPilotSASStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_SAS" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotSASStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Bool))
getAutoPilotSASStream thisArg = requestStream $ getAutoPilotSASStreamReq thisArg
{-
- The current <see cref="T:SpaceCenter.SASMode" />.
- These modes are equivalent to the mode buttons to the left of the navball that appear when SAS is enabled.Equivalent to <see cref="M:SpaceCenter.Control.SASMode" />
-}
getAutoPilotSASMode :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCHS.SpaceCenter.SASMode)
getAutoPilotSASMode thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_SASMode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotSASModeStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (KRPCHS.SpaceCenter.SASMode)
getAutoPilotSASModeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_SASMode" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotSASModeStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.SASMode))
getAutoPilotSASModeStream thisArg = requestStream $ getAutoPilotSASModeStreamReq thisArg
{-
- The maximum amount of time that the vessel should need to come to a complete stop.
- This determines the maximum angular velocity of the vessel.
- A vector of three stopping times, in seconds, one for each of the pitch, roll and yaw axes.
- Defaults to 0.5 seconds for each axis.
-}
getAutoPilotStoppingTime :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotStoppingTime thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_StoppingTime" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotStoppingTimeStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotStoppingTimeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_StoppingTime" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotStoppingTimeStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotStoppingTimeStream thisArg = requestStream $ getAutoPilotStoppingTimeStreamReq thisArg
{-
- Direction vector corresponding to the target pitch and heading.
-}
getAutoPilotTargetDirection :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotTargetDirection thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_TargetDirection" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotTargetDirectionStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotTargetDirectionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_TargetDirection" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotTargetDirectionStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotTargetDirectionStream thisArg = requestStream $ getAutoPilotTargetDirectionStreamReq thisArg
{-
- The target heading, in degrees, between 0° and 360°.
-}
getAutoPilotTargetHeading :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Float)
getAutoPilotTargetHeading thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_TargetHeading" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotTargetHeadingStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Float)
getAutoPilotTargetHeadingStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_TargetHeading" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotTargetHeadingStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Float))
getAutoPilotTargetHeadingStream thisArg = requestStream $ getAutoPilotTargetHeadingStreamReq thisArg
{-
- The target pitch, in degrees, between -90° and +90°.
-}
getAutoPilotTargetPitch :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Float)
getAutoPilotTargetPitch thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_TargetPitch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotTargetPitchStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Float)
getAutoPilotTargetPitchStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_TargetPitch" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotTargetPitchStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Float))
getAutoPilotTargetPitchStream thisArg = requestStream $ getAutoPilotTargetPitchStreamReq thisArg
{-
- The target roll, in degrees.NaNif no target roll is set.
-}
getAutoPilotTargetRoll :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (Float)
getAutoPilotTargetRoll thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_TargetRoll" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotTargetRollStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq (Float)
getAutoPilotTargetRollStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_TargetRoll" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotTargetRollStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream (Float))
getAutoPilotTargetRollStream thisArg = requestStream $ getAutoPilotTargetRollStreamReq thisArg
{-
- The target time to peak used to autotune the PID controllers.
- A vector of three times, in seconds, for each of the pitch, roll and yaw axes.
- Defaults to 3 seconds for each axis.
-}
getAutoPilotTimeToPeak :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotTimeToPeak thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_TimeToPeak" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotTimeToPeakStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotTimeToPeakStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_TimeToPeak" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotTimeToPeakStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotTimeToPeakStream thisArg = requestStream $ getAutoPilotTimeToPeakStreamReq thisArg
{-
- Gains for the yaw PID controller.When <see cref="M:SpaceCenter.AutoPilot.AutoTune" /> is true, these values are updated automatically, which will overwrite any manual changes.
-}
getAutoPilotYawPIDGains :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext ((Double, Double, Double))
getAutoPilotYawPIDGains thisArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_get_YawPIDGains" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getAutoPilotYawPIDGainsStreamReq :: KRPCHS.SpaceCenter.AutoPilot -> KRPCStreamReq ((Double, Double, Double))
getAutoPilotYawPIDGainsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "AutoPilot_get_YawPIDGains" [makeArgument 0 thisArg]
in makeStream req
getAutoPilotYawPIDGainsStream :: KRPCHS.SpaceCenter.AutoPilot -> RPCContext (KRPCStream ((Double, Double, Double)))
getAutoPilotYawPIDGainsStream thisArg = requestStream $ getAutoPilotYawPIDGainsStreamReq thisArg
{-
- The angle at which the autopilot considers the vessel to be pointing close to the target.
- This determines the midpoint of the target velocity attenuation function.
- A vector of three angles, in degrees, one for each of the pitch, roll and yaw axes.
- Defaults to 1° for each axis.
-}
setAutoPilotAttenuationAngle :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotAttenuationAngle thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_AttenuationAngle" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the rotation rate controllers PID parameters should be automatically tuned using the
- vessels moment of inertia and available torque. Defaults totrue.
- See <see cref="M:SpaceCenter.AutoPilot.TimeToPeak" /> and <see cref="M:SpaceCenter.AutoPilot.Overshoot" />.
-}
setAutoPilotAutoTune :: KRPCHS.SpaceCenter.AutoPilot -> Bool -> RPCContext ()
setAutoPilotAutoTune thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_AutoTune" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The time the vessel should take to come to a stop pointing in the target direction.
- This determines the angular acceleration used to decelerate the vessel.
- A vector of three times, in seconds, one for each of the pitch, roll and yaw axes.
- Defaults to 5 seconds for each axis.
-}
setAutoPilotDecelerationTime :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotDecelerationTime thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_DecelerationTime" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The target overshoot percentage used to autotune the PID controllers.
- A vector of three values, between 0 and 1, for each of the pitch, roll and yaw axes.
- Defaults to 0.01 for each axis.
-}
setAutoPilotOvershoot :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotOvershoot thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_Overshoot" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Gains for the pitch PID controller.When <see cref="M:SpaceCenter.AutoPilot.AutoTune" /> is true, these values are updated automatically, which will overwrite any manual changes.
-}
setAutoPilotPitchPIDGains :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotPitchPIDGains thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_PitchPIDGains" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The reference frame for the target direction (<see cref="M:SpaceCenter.AutoPilot.TargetDirection" />).An error will be thrown if this property is set to a reference frame that rotates with the vessel being controlled,
- as it is impossible to rotate the vessel in such a reference frame.
-}
setAutoPilotReferenceFrame :: KRPCHS.SpaceCenter.AutoPilot -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ()
setAutoPilotReferenceFrame thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_ReferenceFrame" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Gains for the roll PID controller.When <see cref="M:SpaceCenter.AutoPilot.AutoTune" /> is true, these values are updated automatically, which will overwrite any manual changes.
-}
setAutoPilotRollPIDGains :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotRollPIDGains thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_RollPIDGains" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The threshold at which the autopilot will try to match the target roll angle, if any.
- Defaults to 5 degrees.
-}
setAutoPilotRollThreshold :: KRPCHS.SpaceCenter.AutoPilot -> Double -> RPCContext ()
setAutoPilotRollThreshold thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_RollThreshold" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of SAS.Equivalent to <see cref="M:SpaceCenter.Control.SAS" />
-}
setAutoPilotSAS :: KRPCHS.SpaceCenter.AutoPilot -> Bool -> RPCContext ()
setAutoPilotSAS thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_SAS" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The current <see cref="T:SpaceCenter.SASMode" />.
- These modes are equivalent to the mode buttons to the left of the navball that appear when SAS is enabled.Equivalent to <see cref="M:SpaceCenter.Control.SASMode" />
-}
setAutoPilotSASMode :: KRPCHS.SpaceCenter.AutoPilot -> KRPCHS.SpaceCenter.SASMode -> RPCContext ()
setAutoPilotSASMode thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_SASMode" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The maximum amount of time that the vessel should need to come to a complete stop.
- This determines the maximum angular velocity of the vessel.
- A vector of three stopping times, in seconds, one for each of the pitch, roll and yaw axes.
- Defaults to 0.5 seconds for each axis.
-}
setAutoPilotStoppingTime :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotStoppingTime thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_StoppingTime" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Direction vector corresponding to the target pitch and heading.
-}
setAutoPilotTargetDirection :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotTargetDirection thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_TargetDirection" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The target heading, in degrees, between 0° and 360°.
-}
setAutoPilotTargetHeading :: KRPCHS.SpaceCenter.AutoPilot -> Float -> RPCContext ()
setAutoPilotTargetHeading thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_TargetHeading" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The target pitch, in degrees, between -90° and +90°.
-}
setAutoPilotTargetPitch :: KRPCHS.SpaceCenter.AutoPilot -> Float -> RPCContext ()
setAutoPilotTargetPitch thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_TargetPitch" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The target roll, in degrees.NaNif no target roll is set.
-}
setAutoPilotTargetRoll :: KRPCHS.SpaceCenter.AutoPilot -> Float -> RPCContext ()
setAutoPilotTargetRoll thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_TargetRoll" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The target time to peak used to autotune the PID controllers.
- A vector of three times, in seconds, for each of the pitch, roll and yaw axes.
- Defaults to 3 seconds for each axis.
-}
setAutoPilotTimeToPeak :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotTimeToPeak thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_TimeToPeak" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Gains for the yaw PID controller.When <see cref="M:SpaceCenter.AutoPilot.AutoTune" /> is true, these values are updated automatically, which will overwrite any manual changes.
-}
setAutoPilotYawPIDGains :: KRPCHS.SpaceCenter.AutoPilot -> (Double, Double, Double) -> RPCContext ()
setAutoPilotYawPIDGains thisArg valueArg = do
let r = makeRequest "SpaceCenter" "AutoPilot_set_YawPIDGains" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Default distance from the camera to the subject, in meters.
-}
getCameraDefaultDistance :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraDefaultDistance thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_DefaultDistance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraDefaultDistanceStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraDefaultDistanceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_DefaultDistance" [makeArgument 0 thisArg]
in makeStream req
getCameraDefaultDistanceStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraDefaultDistanceStream thisArg = requestStream $ getCameraDefaultDistanceStreamReq thisArg
{-
- The distance from the camera to the subject, in meters.
- A value between <see cref="M:SpaceCenter.Camera.MinDistance" /> and <see cref="M:SpaceCenter.Camera.MaxDistance" />.
-}
getCameraDistance :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraDistance thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_Distance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraDistanceStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraDistanceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_Distance" [makeArgument 0 thisArg]
in makeStream req
getCameraDistanceStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraDistanceStream thisArg = requestStream $ getCameraDistanceStreamReq thisArg
{-
- In map mode, the celestial body that the camera is focussed on.
- Returnsnullif the camera is not focussed on a celestial body.
- Returns an error is the camera is not in map mode.
-}
getCameraFocussedBody :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCHS.SpaceCenter.CelestialBody)
getCameraFocussedBody thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_FocussedBody" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraFocussedBodyStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (KRPCHS.SpaceCenter.CelestialBody)
getCameraFocussedBodyStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_FocussedBody" [makeArgument 0 thisArg]
in makeStream req
getCameraFocussedBodyStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CelestialBody))
getCameraFocussedBodyStream thisArg = requestStream $ getCameraFocussedBodyStreamReq thisArg
{-
- In map mode, the maneuver node that the camera is focussed on.
- Returnsnullif the camera is not focussed on a maneuver node.
- Returns an error is the camera is not in map mode.
-}
getCameraFocussedNode :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCHS.SpaceCenter.Node)
getCameraFocussedNode thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_FocussedNode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraFocussedNodeStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (KRPCHS.SpaceCenter.Node)
getCameraFocussedNodeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_FocussedNode" [makeArgument 0 thisArg]
in makeStream req
getCameraFocussedNodeStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Node))
getCameraFocussedNodeStream thisArg = requestStream $ getCameraFocussedNodeStreamReq thisArg
{-
- In map mode, the vessel that the camera is focussed on.
- Returnsnullif the camera is not focussed on a vessel.
- Returns an error is the camera is not in map mode.
-}
getCameraFocussedVessel :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCHS.SpaceCenter.Vessel)
getCameraFocussedVessel thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_FocussedVessel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraFocussedVesselStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (KRPCHS.SpaceCenter.Vessel)
getCameraFocussedVesselStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_FocussedVessel" [makeArgument 0 thisArg]
in makeStream req
getCameraFocussedVesselStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Vessel))
getCameraFocussedVesselStream thisArg = requestStream $ getCameraFocussedVesselStreamReq thisArg
{-
- The heading of the camera, in degrees.
-}
getCameraHeading :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraHeading thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_Heading" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraHeadingStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraHeadingStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_Heading" [makeArgument 0 thisArg]
in makeStream req
getCameraHeadingStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraHeadingStream thisArg = requestStream $ getCameraHeadingStreamReq thisArg
{-
- Maximum distance from the camera to the subject, in meters.
-}
getCameraMaxDistance :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraMaxDistance thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_MaxDistance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraMaxDistanceStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraMaxDistanceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_MaxDistance" [makeArgument 0 thisArg]
in makeStream req
getCameraMaxDistanceStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraMaxDistanceStream thisArg = requestStream $ getCameraMaxDistanceStreamReq thisArg
{-
- The maximum pitch of the camera.
-}
getCameraMaxPitch :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraMaxPitch thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_MaxPitch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraMaxPitchStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraMaxPitchStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_MaxPitch" [makeArgument 0 thisArg]
in makeStream req
getCameraMaxPitchStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraMaxPitchStream thisArg = requestStream $ getCameraMaxPitchStreamReq thisArg
{-
- Minimum distance from the camera to the subject, in meters.
-}
getCameraMinDistance :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraMinDistance thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_MinDistance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraMinDistanceStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraMinDistanceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_MinDistance" [makeArgument 0 thisArg]
in makeStream req
getCameraMinDistanceStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraMinDistanceStream thisArg = requestStream $ getCameraMinDistanceStreamReq thisArg
{-
- The minimum pitch of the camera.
-}
getCameraMinPitch :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraMinPitch thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_MinPitch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraMinPitchStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraMinPitchStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_MinPitch" [makeArgument 0 thisArg]
in makeStream req
getCameraMinPitchStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraMinPitchStream thisArg = requestStream $ getCameraMinPitchStreamReq thisArg
{-
- The current mode of the camera.
-}
getCameraMode :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCHS.SpaceCenter.CameraMode)
getCameraMode thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_Mode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraModeStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (KRPCHS.SpaceCenter.CameraMode)
getCameraModeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_Mode" [makeArgument 0 thisArg]
in makeStream req
getCameraModeStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CameraMode))
getCameraModeStream thisArg = requestStream $ getCameraModeStreamReq thisArg
{-
- The pitch of the camera, in degrees.
- A value between <see cref="M:SpaceCenter.Camera.MinPitch" /> and <see cref="M:SpaceCenter.Camera.MaxPitch" />
-}
getCameraPitch :: KRPCHS.SpaceCenter.Camera -> RPCContext (Float)
getCameraPitch thisArg = do
let r = makeRequest "SpaceCenter" "Camera_get_Pitch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCameraPitchStreamReq :: KRPCHS.SpaceCenter.Camera -> KRPCStreamReq (Float)
getCameraPitchStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Camera_get_Pitch" [makeArgument 0 thisArg]
in makeStream req
getCameraPitchStream :: KRPCHS.SpaceCenter.Camera -> RPCContext (KRPCStream (Float))
getCameraPitchStream thisArg = requestStream $ getCameraPitchStreamReq thisArg
{-
- The distance from the camera to the subject, in meters.
- A value between <see cref="M:SpaceCenter.Camera.MinDistance" /> and <see cref="M:SpaceCenter.Camera.MaxDistance" />.
-}
setCameraDistance :: KRPCHS.SpaceCenter.Camera -> Float -> RPCContext ()
setCameraDistance thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Camera_set_Distance" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- In map mode, the celestial body that the camera is focussed on.
- Returnsnullif the camera is not focussed on a celestial body.
- Returns an error is the camera is not in map mode.
-}
setCameraFocussedBody :: KRPCHS.SpaceCenter.Camera -> KRPCHS.SpaceCenter.CelestialBody -> RPCContext ()
setCameraFocussedBody thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Camera_set_FocussedBody" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- In map mode, the maneuver node that the camera is focussed on.
- Returnsnullif the camera is not focussed on a maneuver node.
- Returns an error is the camera is not in map mode.
-}
setCameraFocussedNode :: KRPCHS.SpaceCenter.Camera -> KRPCHS.SpaceCenter.Node -> RPCContext ()
setCameraFocussedNode thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Camera_set_FocussedNode" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- In map mode, the vessel that the camera is focussed on.
- Returnsnullif the camera is not focussed on a vessel.
- Returns an error is the camera is not in map mode.
-}
setCameraFocussedVessel :: KRPCHS.SpaceCenter.Camera -> KRPCHS.SpaceCenter.Vessel -> RPCContext ()
setCameraFocussedVessel thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Camera_set_FocussedVessel" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The heading of the camera, in degrees.
-}
setCameraHeading :: KRPCHS.SpaceCenter.Camera -> Float -> RPCContext ()
setCameraHeading thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Camera_set_Heading" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The current mode of the camera.
-}
setCameraMode :: KRPCHS.SpaceCenter.Camera -> KRPCHS.SpaceCenter.CameraMode -> RPCContext ()
setCameraMode thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Camera_set_Mode" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The pitch of the camera, in degrees.
- A value between <see cref="M:SpaceCenter.Camera.MinPitch" /> and <see cref="M:SpaceCenter.Camera.MaxPitch" />
-}
setCameraPitch :: KRPCHS.SpaceCenter.Camera -> Float -> RPCContext ()
setCameraPitch thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Camera_set_Pitch" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returnstrueif regular "on-rails" time warp can be used, at the specified warp
- <paramref name="factor" />. The maximum time warp rate is limited by various things,
- including how close the active vessel is to a planet. See
- <a href="http://wiki.kerbalspaceprogram.com/wiki/Time_warp">the KSP wikifor details.<param name="factor">The warp factor to check.
-}
canRailsWarpAt :: Data.Int.Int32 -> RPCContext (Bool)
canRailsWarpAt factorArg = do
let r = makeRequest "SpaceCenter" "CanRailsWarpAt" [makeArgument 0 factorArg]
res <- sendRequest r
processResponse res
canRailsWarpAtStreamReq :: Data.Int.Int32 -> KRPCStreamReq (Bool)
canRailsWarpAtStreamReq factorArg =
let req = makeRequest "SpaceCenter" "CanRailsWarpAt" [makeArgument 0 factorArg]
in makeStream req
canRailsWarpAtStream :: Data.Int.Int32 -> RPCContext (KRPCStream (Bool))
canRailsWarpAtStream factorArg = requestStream $ canRailsWarpAtStreamReq factorArg
{-
- Whether the cargo bay is open.
-}
getCargoBayOpen :: KRPCHS.SpaceCenter.CargoBay -> RPCContext (Bool)
getCargoBayOpen thisArg = do
let r = makeRequest "SpaceCenter" "CargoBay_get_Open" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCargoBayOpenStreamReq :: KRPCHS.SpaceCenter.CargoBay -> KRPCStreamReq (Bool)
getCargoBayOpenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CargoBay_get_Open" [makeArgument 0 thisArg]
in makeStream req
getCargoBayOpenStream :: KRPCHS.SpaceCenter.CargoBay -> RPCContext (KRPCStream (Bool))
getCargoBayOpenStream thisArg = requestStream $ getCargoBayOpenStreamReq thisArg
{-
- The part object for this cargo bay.
-}
getCargoBayPart :: KRPCHS.SpaceCenter.CargoBay -> RPCContext (KRPCHS.SpaceCenter.Part)
getCargoBayPart thisArg = do
let r = makeRequest "SpaceCenter" "CargoBay_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCargoBayPartStreamReq :: KRPCHS.SpaceCenter.CargoBay -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getCargoBayPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CargoBay_get_Part" [makeArgument 0 thisArg]
in makeStream req
getCargoBayPartStream :: KRPCHS.SpaceCenter.CargoBay -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getCargoBayPartStream thisArg = requestStream $ getCargoBayPartStreamReq thisArg
{-
- The state of the cargo bay.
-}
getCargoBayState :: KRPCHS.SpaceCenter.CargoBay -> RPCContext (KRPCHS.SpaceCenter.CargoBayState)
getCargoBayState thisArg = do
let r = makeRequest "SpaceCenter" "CargoBay_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCargoBayStateStreamReq :: KRPCHS.SpaceCenter.CargoBay -> KRPCStreamReq (KRPCHS.SpaceCenter.CargoBayState)
getCargoBayStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CargoBay_get_State" [makeArgument 0 thisArg]
in makeStream req
getCargoBayStateStream :: KRPCHS.SpaceCenter.CargoBay -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CargoBayState))
getCargoBayStateStream thisArg = requestStream $ getCargoBayStateStreamReq thisArg
{-
- Whether the cargo bay is open.
-}
setCargoBayOpen :: KRPCHS.SpaceCenter.CargoBay -> Bool -> RPCContext ()
setCargoBayOpen thisArg valueArg = do
let r = makeRequest "SpaceCenter" "CargoBay_set_Open" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns the angular velocity of the body in the specified reference
- frame. The magnitude of the vector is the rotational speed of the body, in
- radians per second, and the direction of the vector indicates the axis of
- rotation, using the right-hand rule.<param name="referenceFrame">
-}
celestialBodyAngularVelocity :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
celestialBodyAngularVelocity thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_AngularVelocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodyAngularVelocityStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
celestialBodyAngularVelocityStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_AngularVelocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
celestialBodyAngularVelocityStream :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
celestialBodyAngularVelocityStream thisArg referenceFrameArg = requestStream $ celestialBodyAngularVelocityStreamReq thisArg referenceFrameArg
{-
- The height of the surface relative to mean sea level at the given position,
- in meters. When over water, this is the height of the sea-bed and is therefore a
- negative value.<param name="latitude">Latitude in degrees<param name="longitude">Longitude in degrees
-}
celestialBodyBedrockHeight :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> RPCContext (Double)
celestialBodyBedrockHeight thisArg latitudeArg longitudeArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_BedrockHeight" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg]
res <- sendRequest r
processResponse res
celestialBodyBedrockHeightStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCStreamReq (Double)
celestialBodyBedrockHeightStreamReq thisArg latitudeArg longitudeArg =
let req = makeRequest "SpaceCenter" "CelestialBody_BedrockHeight" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg]
in makeStream req
celestialBodyBedrockHeightStream :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> RPCContext (KRPCStream (Double))
celestialBodyBedrockHeightStream thisArg latitudeArg longitudeArg = requestStream $ celestialBodyBedrockHeightStreamReq thisArg latitudeArg longitudeArg
{-
- The position of the surface at the given latitude and longitude, in the given
- reference frame. When over water, this is the position at the bottom of the sea-bed.<param name="latitude">Latitude in degrees<param name="longitude">Longitude in degrees<param name="referenceFrame">Reference frame for the returned position vector
-}
celestialBodyBedrockPosition :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
celestialBodyBedrockPosition thisArg latitudeArg longitudeArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_BedrockPosition" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodyBedrockPositionStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
celestialBodyBedrockPositionStreamReq thisArg latitudeArg longitudeArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_BedrockPosition" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 referenceFrameArg]
in makeStream req
celestialBodyBedrockPositionStream :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
celestialBodyBedrockPositionStream thisArg latitudeArg longitudeArg referenceFrameArg = requestStream $ celestialBodyBedrockPositionStreamReq thisArg latitudeArg longitudeArg referenceFrameArg
{-
- The biomes at the given latitude and longitude, in degrees.
-}
celestialBodyBiomeAt :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> RPCContext (Data.Text.Text)
celestialBodyBiomeAt thisArg latitudeArg longitudeArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_BiomeAt" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg]
res <- sendRequest r
processResponse res
celestialBodyBiomeAtStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCStreamReq (Data.Text.Text)
celestialBodyBiomeAtStreamReq thisArg latitudeArg longitudeArg =
let req = makeRequest "SpaceCenter" "CelestialBody_BiomeAt" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg]
in makeStream req
celestialBodyBiomeAtStream :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> RPCContext (KRPCStream (Data.Text.Text))
celestialBodyBiomeAtStream thisArg latitudeArg longitudeArg = requestStream $ celestialBodyBiomeAtStreamReq thisArg latitudeArg longitudeArg
{-
- Returns the direction in which the north pole of the celestial body is
- pointing, as a unit vector, in the specified reference frame.<param name="referenceFrame">
-}
celestialBodyDirection :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
celestialBodyDirection thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodyDirectionStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
celestialBodyDirectionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
celestialBodyDirectionStream :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
celestialBodyDirectionStream thisArg referenceFrameArg = requestStream $ celestialBodyDirectionStreamReq thisArg referenceFrameArg
{-
- The position at mean sea level at the given latitude and longitude, in the given reference frame.<param name="latitude">Latitude in degrees<param name="longitude">Longitude in degrees<param name="referenceFrame">Reference frame for the returned position vector
-}
celestialBodyMSLPosition :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
celestialBodyMSLPosition thisArg latitudeArg longitudeArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_MSLPosition" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodyMSLPositionStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
celestialBodyMSLPositionStreamReq thisArg latitudeArg longitudeArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_MSLPosition" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 referenceFrameArg]
in makeStream req
celestialBodyMSLPositionStream :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
celestialBodyMSLPositionStream thisArg latitudeArg longitudeArg referenceFrameArg = requestStream $ celestialBodyMSLPositionStreamReq thisArg latitudeArg longitudeArg referenceFrameArg
{-
- Returns the position vector of the center of the body in the specified reference frame.<param name="referenceFrame">
-}
celestialBodyPosition :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
celestialBodyPosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodyPositionStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
celestialBodyPositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
celestialBodyPositionStream :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
celestialBodyPositionStream thisArg referenceFrameArg = requestStream $ celestialBodyPositionStreamReq thisArg referenceFrameArg
{-
- Returns the rotation of the body in the specified reference frame.<param name="referenceFrame">
-}
celestialBodyRotation :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double, Double))
celestialBodyRotation thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodyRotationStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double, Double))
celestialBodyRotationStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
celestialBodyRotationStream :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double, Double)))
celestialBodyRotationStream thisArg referenceFrameArg = requestStream $ celestialBodyRotationStreamReq thisArg referenceFrameArg
{-
- The height of the surface relative to mean sea level at the given position,
- in meters. When over water this is equal to 0.<param name="latitude">Latitude in degrees<param name="longitude">Longitude in degrees
-}
celestialBodySurfaceHeight :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> RPCContext (Double)
celestialBodySurfaceHeight thisArg latitudeArg longitudeArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_SurfaceHeight" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg]
res <- sendRequest r
processResponse res
celestialBodySurfaceHeightStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCStreamReq (Double)
celestialBodySurfaceHeightStreamReq thisArg latitudeArg longitudeArg =
let req = makeRequest "SpaceCenter" "CelestialBody_SurfaceHeight" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg]
in makeStream req
celestialBodySurfaceHeightStream :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> RPCContext (KRPCStream (Double))
celestialBodySurfaceHeightStream thisArg latitudeArg longitudeArg = requestStream $ celestialBodySurfaceHeightStreamReq thisArg latitudeArg longitudeArg
{-
- The position of the surface at the given latitude and longitude, in the given
- reference frame. When over water, this is the position of the surface of the water.<param name="latitude">Latitude in degrees<param name="longitude">Longitude in degrees<param name="referenceFrame">Reference frame for the returned position vector
-}
celestialBodySurfacePosition :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
celestialBodySurfacePosition thisArg latitudeArg longitudeArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_SurfacePosition" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodySurfacePositionStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
celestialBodySurfacePositionStreamReq thisArg latitudeArg longitudeArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_SurfacePosition" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 referenceFrameArg]
in makeStream req
celestialBodySurfacePositionStream :: KRPCHS.SpaceCenter.CelestialBody -> Double -> Double -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
celestialBodySurfacePositionStream thisArg latitudeArg longitudeArg referenceFrameArg = requestStream $ celestialBodySurfacePositionStreamReq thisArg latitudeArg longitudeArg referenceFrameArg
{-
- Returns the velocity vector of the body in the specified reference frame.<param name="referenceFrame">
-}
celestialBodyVelocity :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
celestialBodyVelocity thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_Velocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
celestialBodyVelocityStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
celestialBodyVelocityStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "CelestialBody_Velocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
celestialBodyVelocityStream :: KRPCHS.SpaceCenter.CelestialBody -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
celestialBodyVelocityStream thisArg referenceFrameArg = requestStream $ celestialBodyVelocityStreamReq thisArg referenceFrameArg
{-
- The depth of the atmosphere, in meters.
-}
getCelestialBodyAtmosphereDepth :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodyAtmosphereDepth thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_AtmosphereDepth" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyAtmosphereDepthStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodyAtmosphereDepthStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_AtmosphereDepth" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyAtmosphereDepthStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodyAtmosphereDepthStream thisArg = requestStream $ getCelestialBodyAtmosphereDepthStreamReq thisArg
{-
- The biomes present on this body.
-}
getCelestialBodyBiomes :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Data.Set.Set Data.Text.Text)
getCelestialBodyBiomes thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_Biomes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyBiomesStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Data.Set.Set Data.Text.Text)
getCelestialBodyBiomesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_Biomes" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyBiomesStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Data.Set.Set Data.Text.Text))
getCelestialBodyBiomesStream thisArg = requestStream $ getCelestialBodyBiomesStreamReq thisArg
{-
- The equatorial radius of the body, in meters.
-}
getCelestialBodyEquatorialRadius :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodyEquatorialRadius thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_EquatorialRadius" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyEquatorialRadiusStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodyEquatorialRadiusStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_EquatorialRadius" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyEquatorialRadiusStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodyEquatorialRadiusStream thisArg = requestStream $ getCelestialBodyEquatorialRadiusStreamReq thisArg
{-
- The altitude, in meters, above which a vessel is considered to be flying "high" when doing science.
-}
getCelestialBodyFlyingHighAltitudeThreshold :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodyFlyingHighAltitudeThreshold thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_FlyingHighAltitudeThreshold" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyFlyingHighAltitudeThresholdStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodyFlyingHighAltitudeThresholdStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_FlyingHighAltitudeThreshold" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyFlyingHighAltitudeThresholdStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodyFlyingHighAltitudeThresholdStream thisArg = requestStream $ getCelestialBodyFlyingHighAltitudeThresholdStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Standard_gravitational_parameter">standard
- gravitational parameterof the body inm^3s^{ -2}.
-}
getCelestialBodyGravitationalParameter :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodyGravitationalParameter thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_GravitationalParameter" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyGravitationalParameterStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodyGravitationalParameterStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_GravitationalParameter" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyGravitationalParameterStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodyGravitationalParameterStream thisArg = requestStream $ getCelestialBodyGravitationalParameterStreamReq thisArg
{-
- trueif the body has an atmosphere.
-}
getCelestialBodyHasAtmosphere :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Bool)
getCelestialBodyHasAtmosphere thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_HasAtmosphere" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyHasAtmosphereStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Bool)
getCelestialBodyHasAtmosphereStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_HasAtmosphere" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyHasAtmosphereStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Bool))
getCelestialBodyHasAtmosphereStream thisArg = requestStream $ getCelestialBodyHasAtmosphereStreamReq thisArg
{-
- trueif there is oxygen in the atmosphere, required for air-breathing engines.
-}
getCelestialBodyHasAtmosphericOxygen :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Bool)
getCelestialBodyHasAtmosphericOxygen thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_HasAtmosphericOxygen" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyHasAtmosphericOxygenStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Bool)
getCelestialBodyHasAtmosphericOxygenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_HasAtmosphericOxygen" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyHasAtmosphericOxygenStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Bool))
getCelestialBodyHasAtmosphericOxygenStream thisArg = requestStream $ getCelestialBodyHasAtmosphericOxygenStreamReq thisArg
{-
- The initial rotation angle of the body (at UT 0), in radians.
-}
getCelestialBodyInitialRotation :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Double)
getCelestialBodyInitialRotation thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_InitialRotation" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyInitialRotationStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Double)
getCelestialBodyInitialRotationStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_InitialRotation" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyInitialRotationStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Double))
getCelestialBodyInitialRotationStream thisArg = requestStream $ getCelestialBodyInitialRotationStreamReq thisArg
{-
- The mass of the body, in kilograms.
-}
getCelestialBodyMass :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodyMass thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_Mass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyMassStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodyMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_Mass" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyMassStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodyMassStream thisArg = requestStream $ getCelestialBodyMassStreamReq thisArg
{-
- The name of the body.
-}
getCelestialBodyName :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Data.Text.Text)
getCelestialBodyName thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyNameStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Data.Text.Text)
getCelestialBodyNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_Name" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyNameStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Data.Text.Text))
getCelestialBodyNameStream thisArg = requestStream $ getCelestialBodyNameStreamReq thisArg
{-
- The reference frame that is fixed relative to this celestial body, and
- orientated in a fixed direction (it does not rotate with the body).
- <list type="bullet">The origin is at the center of the body.The axes do not rotate.The x-axis points in an arbitrary direction through the
- equator.The y-axis points from the center of the body towards
- the north pole.The z-axis points in an arbitrary direction through the
- equator.
-}
getCelestialBodyNonRotatingReferenceFrame :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getCelestialBodyNonRotatingReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_NonRotatingReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyNonRotatingReferenceFrameStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getCelestialBodyNonRotatingReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_NonRotatingReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyNonRotatingReferenceFrameStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getCelestialBodyNonRotatingReferenceFrameStream thisArg = requestStream $ getCelestialBodyNonRotatingReferenceFrameStreamReq thisArg
{-
- The orbit of the body.
-}
getCelestialBodyOrbit :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCHS.SpaceCenter.Orbit)
getCelestialBodyOrbit thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_Orbit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyOrbitStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (KRPCHS.SpaceCenter.Orbit)
getCelestialBodyOrbitStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_Orbit" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyOrbitStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Orbit))
getCelestialBodyOrbitStream thisArg = requestStream $ getCelestialBodyOrbitStreamReq thisArg
{-
- Gets the reference frame that is fixed relative to this celestial body, but
- orientated with the body's orbital prograde/normal/radial directions.
- <list type="bullet">The origin is at the center of the body.The axes rotate with the orbital prograde/normal/radial
- directions.The x-axis points in the orbital anti-radial direction.The y-axis points in the orbital prograde direction.The z-axis points in the orbital normal direction.
-}
getCelestialBodyOrbitalReferenceFrame :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getCelestialBodyOrbitalReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_OrbitalReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyOrbitalReferenceFrameStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getCelestialBodyOrbitalReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_OrbitalReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyOrbitalReferenceFrameStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getCelestialBodyOrbitalReferenceFrameStream thisArg = requestStream $ getCelestialBodyOrbitalReferenceFrameStreamReq thisArg
{-
- The reference frame that is fixed relative to the celestial body.
- <list type="bullet">The origin is at the center of the body.The axes rotate with the body.The x-axis points from the center of the body
- towards the intersection of the prime meridian and equator (the
- position at 0° longitude, 0° latitude).The y-axis points from the center of the body
- towards the north pole.The z-axis points from the center of the body
- towards the equator at 90°E longitude.
-}
getCelestialBodyReferenceFrame :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getCelestialBodyReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_ReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyReferenceFrameStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getCelestialBodyReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_ReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyReferenceFrameStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getCelestialBodyReferenceFrameStream thisArg = requestStream $ getCelestialBodyReferenceFrameStreamReq thisArg
{-
- The current rotation angle of the body, in radians.
-}
getCelestialBodyRotationAngle :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Double)
getCelestialBodyRotationAngle thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_RotationAngle" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyRotationAngleStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Double)
getCelestialBodyRotationAngleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_RotationAngle" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyRotationAngleStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Double))
getCelestialBodyRotationAngleStream thisArg = requestStream $ getCelestialBodyRotationAngleStreamReq thisArg
{-
- The sidereal rotational period of the body, in seconds.
-}
getCelestialBodyRotationalPeriod :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodyRotationalPeriod thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_RotationalPeriod" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyRotationalPeriodStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodyRotationalPeriodStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_RotationalPeriod" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyRotationalPeriodStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodyRotationalPeriodStream thisArg = requestStream $ getCelestialBodyRotationalPeriodStreamReq thisArg
{-
- The rotational speed of the body, in radians per second.
-}
getCelestialBodyRotationalSpeed :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodyRotationalSpeed thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_RotationalSpeed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodyRotationalSpeedStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodyRotationalSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_RotationalSpeed" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodyRotationalSpeedStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodyRotationalSpeedStream thisArg = requestStream $ getCelestialBodyRotationalSpeedStreamReq thisArg
{-
- A list of celestial bodies that are in orbit around this celestial body.
-}
getCelestialBodySatellites :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext ([KRPCHS.SpaceCenter.CelestialBody])
getCelestialBodySatellites thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_Satellites" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodySatellitesStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq ([KRPCHS.SpaceCenter.CelestialBody])
getCelestialBodySatellitesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_Satellites" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodySatellitesStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.CelestialBody]))
getCelestialBodySatellitesStream thisArg = requestStream $ getCelestialBodySatellitesStreamReq thisArg
{-
- The altitude, in meters, above which a vessel is considered to be in "high" space when doing science.
-}
getCelestialBodySpaceHighAltitudeThreshold :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodySpaceHighAltitudeThreshold thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_SpaceHighAltitudeThreshold" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodySpaceHighAltitudeThresholdStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodySpaceHighAltitudeThresholdStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_SpaceHighAltitudeThreshold" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodySpaceHighAltitudeThresholdStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodySpaceHighAltitudeThresholdStream thisArg = requestStream $ getCelestialBodySpaceHighAltitudeThresholdStreamReq thisArg
{-
- The radius of the sphere of influence of the body, in meters.
-}
getCelestialBodySphereOfInfluence :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodySphereOfInfluence thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_SphereOfInfluence" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodySphereOfInfluenceStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodySphereOfInfluenceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_SphereOfInfluence" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodySphereOfInfluenceStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodySphereOfInfluenceStream thisArg = requestStream $ getCelestialBodySphereOfInfluenceStreamReq thisArg
{-
- The acceleration due to gravity at sea level (mean altitude) on the body, inm/s^2.
-}
getCelestialBodySurfaceGravity :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (Float)
getCelestialBodySurfaceGravity thisArg = do
let r = makeRequest "SpaceCenter" "CelestialBody_get_SurfaceGravity" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCelestialBodySurfaceGravityStreamReq :: KRPCHS.SpaceCenter.CelestialBody -> KRPCStreamReq (Float)
getCelestialBodySurfaceGravityStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CelestialBody_get_SurfaceGravity" [makeArgument 0 thisArg]
in makeStream req
getCelestialBodySurfaceGravityStream :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext (KRPCStream (Float))
getCelestialBodySurfaceGravityStream thisArg = requestStream $ getCelestialBodySurfaceGravityStreamReq thisArg
{-
- Clears the current target.
-}
clearTarget :: RPCContext ()
clearTarget = do
let r = makeRequest "SpaceCenter" "ClearTarget" []
res <- sendRequest r
processResponse res
{-
- Start point of the link.
-}
getCommLinkEnd :: KRPCHS.SpaceCenter.CommLink -> RPCContext (KRPCHS.SpaceCenter.CommNode)
getCommLinkEnd thisArg = do
let r = makeRequest "SpaceCenter" "CommLink_get_End" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommLinkEndStreamReq :: KRPCHS.SpaceCenter.CommLink -> KRPCStreamReq (KRPCHS.SpaceCenter.CommNode)
getCommLinkEndStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommLink_get_End" [makeArgument 0 thisArg]
in makeStream req
getCommLinkEndStream :: KRPCHS.SpaceCenter.CommLink -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CommNode))
getCommLinkEndStream thisArg = requestStream $ getCommLinkEndStreamReq thisArg
{-
- Signal strength of the link.
-}
getCommLinkSignalStrength :: KRPCHS.SpaceCenter.CommLink -> RPCContext (Double)
getCommLinkSignalStrength thisArg = do
let r = makeRequest "SpaceCenter" "CommLink_get_SignalStrength" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommLinkSignalStrengthStreamReq :: KRPCHS.SpaceCenter.CommLink -> KRPCStreamReq (Double)
getCommLinkSignalStrengthStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommLink_get_SignalStrength" [makeArgument 0 thisArg]
in makeStream req
getCommLinkSignalStrengthStream :: KRPCHS.SpaceCenter.CommLink -> RPCContext (KRPCStream (Double))
getCommLinkSignalStrengthStream thisArg = requestStream $ getCommLinkSignalStrengthStreamReq thisArg
{-
- Start point of the link.
-}
getCommLinkStart :: KRPCHS.SpaceCenter.CommLink -> RPCContext (KRPCHS.SpaceCenter.CommNode)
getCommLinkStart thisArg = do
let r = makeRequest "SpaceCenter" "CommLink_get_Start" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommLinkStartStreamReq :: KRPCHS.SpaceCenter.CommLink -> KRPCStreamReq (KRPCHS.SpaceCenter.CommNode)
getCommLinkStartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommLink_get_Start" [makeArgument 0 thisArg]
in makeStream req
getCommLinkStartStream :: KRPCHS.SpaceCenter.CommLink -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CommNode))
getCommLinkStartStream thisArg = requestStream $ getCommLinkStartStreamReq thisArg
{-
- The type of link.
-}
getCommLinkType :: KRPCHS.SpaceCenter.CommLink -> RPCContext (KRPCHS.SpaceCenter.CommLinkType)
getCommLinkType thisArg = do
let r = makeRequest "SpaceCenter" "CommLink_get_Type" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommLinkTypeStreamReq :: KRPCHS.SpaceCenter.CommLink -> KRPCStreamReq (KRPCHS.SpaceCenter.CommLinkType)
getCommLinkTypeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommLink_get_Type" [makeArgument 0 thisArg]
in makeStream req
getCommLinkTypeStream :: KRPCHS.SpaceCenter.CommLink -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CommLinkType))
getCommLinkTypeStream thisArg = requestStream $ getCommLinkTypeStreamReq thisArg
{-
- Whether the communication node is a control point, for example a manned vessel.
-}
getCommNodeIsControlPoint :: KRPCHS.SpaceCenter.CommNode -> RPCContext (Bool)
getCommNodeIsControlPoint thisArg = do
let r = makeRequest "SpaceCenter" "CommNode_get_IsControlPoint" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommNodeIsControlPointStreamReq :: KRPCHS.SpaceCenter.CommNode -> KRPCStreamReq (Bool)
getCommNodeIsControlPointStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommNode_get_IsControlPoint" [makeArgument 0 thisArg]
in makeStream req
getCommNodeIsControlPointStream :: KRPCHS.SpaceCenter.CommNode -> RPCContext (KRPCStream (Bool))
getCommNodeIsControlPointStream thisArg = requestStream $ getCommNodeIsControlPointStreamReq thisArg
{-
- Whether the communication node is on Kerbin.
-}
getCommNodeIsHome :: KRPCHS.SpaceCenter.CommNode -> RPCContext (Bool)
getCommNodeIsHome thisArg = do
let r = makeRequest "SpaceCenter" "CommNode_get_IsHome" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommNodeIsHomeStreamReq :: KRPCHS.SpaceCenter.CommNode -> KRPCStreamReq (Bool)
getCommNodeIsHomeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommNode_get_IsHome" [makeArgument 0 thisArg]
in makeStream req
getCommNodeIsHomeStream :: KRPCHS.SpaceCenter.CommNode -> RPCContext (KRPCStream (Bool))
getCommNodeIsHomeStream thisArg = requestStream $ getCommNodeIsHomeStreamReq thisArg
{-
- Whether the communication node is a vessel.
-}
getCommNodeIsVessel :: KRPCHS.SpaceCenter.CommNode -> RPCContext (Bool)
getCommNodeIsVessel thisArg = do
let r = makeRequest "SpaceCenter" "CommNode_get_IsVessel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommNodeIsVesselStreamReq :: KRPCHS.SpaceCenter.CommNode -> KRPCStreamReq (Bool)
getCommNodeIsVesselStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommNode_get_IsVessel" [makeArgument 0 thisArg]
in makeStream req
getCommNodeIsVesselStream :: KRPCHS.SpaceCenter.CommNode -> RPCContext (KRPCStream (Bool))
getCommNodeIsVesselStream thisArg = requestStream $ getCommNodeIsVesselStreamReq thisArg
{-
- Name of the communication node.
-}
getCommNodeName :: KRPCHS.SpaceCenter.CommNode -> RPCContext (Data.Text.Text)
getCommNodeName thisArg = do
let r = makeRequest "SpaceCenter" "CommNode_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommNodeNameStreamReq :: KRPCHS.SpaceCenter.CommNode -> KRPCStreamReq (Data.Text.Text)
getCommNodeNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommNode_get_Name" [makeArgument 0 thisArg]
in makeStream req
getCommNodeNameStream :: KRPCHS.SpaceCenter.CommNode -> RPCContext (KRPCStream (Data.Text.Text))
getCommNodeNameStream thisArg = requestStream $ getCommNodeNameStreamReq thisArg
{-
- The vessel for this communication node.
-}
getCommNodeVessel :: KRPCHS.SpaceCenter.CommNode -> RPCContext (KRPCHS.SpaceCenter.Vessel)
getCommNodeVessel thisArg = do
let r = makeRequest "SpaceCenter" "CommNode_get_Vessel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommNodeVesselStreamReq :: KRPCHS.SpaceCenter.CommNode -> KRPCStreamReq (KRPCHS.SpaceCenter.Vessel)
getCommNodeVesselStreamReq thisArg =
let req = makeRequest "SpaceCenter" "CommNode_get_Vessel" [makeArgument 0 thisArg]
in makeStream req
getCommNodeVesselStream :: KRPCHS.SpaceCenter.CommNode -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Vessel))
getCommNodeVesselStream thisArg = requestStream $ getCommNodeVesselStreamReq thisArg
{-
- Whether the vessel can communicate with KSC.
-}
getCommsCanCommunicate :: KRPCHS.SpaceCenter.Comms -> RPCContext (Bool)
getCommsCanCommunicate thisArg = do
let r = makeRequest "SpaceCenter" "Comms_get_CanCommunicate" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommsCanCommunicateStreamReq :: KRPCHS.SpaceCenter.Comms -> KRPCStreamReq (Bool)
getCommsCanCommunicateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Comms_get_CanCommunicate" [makeArgument 0 thisArg]
in makeStream req
getCommsCanCommunicateStream :: KRPCHS.SpaceCenter.Comms -> RPCContext (KRPCStream (Bool))
getCommsCanCommunicateStream thisArg = requestStream $ getCommsCanCommunicateStreamReq thisArg
{-
- Whether the vessel can transmit science data to KSC.
-}
getCommsCanTransmitScience :: KRPCHS.SpaceCenter.Comms -> RPCContext (Bool)
getCommsCanTransmitScience thisArg = do
let r = makeRequest "SpaceCenter" "Comms_get_CanTransmitScience" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommsCanTransmitScienceStreamReq :: KRPCHS.SpaceCenter.Comms -> KRPCStreamReq (Bool)
getCommsCanTransmitScienceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Comms_get_CanTransmitScience" [makeArgument 0 thisArg]
in makeStream req
getCommsCanTransmitScienceStream :: KRPCHS.SpaceCenter.Comms -> RPCContext (KRPCStream (Bool))
getCommsCanTransmitScienceStream thisArg = requestStream $ getCommsCanTransmitScienceStreamReq thisArg
{-
- The communication path used to control the vessel.
-}
getCommsControlPath :: KRPCHS.SpaceCenter.Comms -> RPCContext ([KRPCHS.SpaceCenter.CommLink])
getCommsControlPath thisArg = do
let r = makeRequest "SpaceCenter" "Comms_get_ControlPath" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommsControlPathStreamReq :: KRPCHS.SpaceCenter.Comms -> KRPCStreamReq ([KRPCHS.SpaceCenter.CommLink])
getCommsControlPathStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Comms_get_ControlPath" [makeArgument 0 thisArg]
in makeStream req
getCommsControlPathStream :: KRPCHS.SpaceCenter.Comms -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.CommLink]))
getCommsControlPathStream thisArg = requestStream $ getCommsControlPathStreamReq thisArg
{-
- The combined power of all active antennae on the vessel.
-}
getCommsPower :: KRPCHS.SpaceCenter.Comms -> RPCContext (Double)
getCommsPower thisArg = do
let r = makeRequest "SpaceCenter" "Comms_get_Power" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommsPowerStreamReq :: KRPCHS.SpaceCenter.Comms -> KRPCStreamReq (Double)
getCommsPowerStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Comms_get_Power" [makeArgument 0 thisArg]
in makeStream req
getCommsPowerStream :: KRPCHS.SpaceCenter.Comms -> RPCContext (KRPCStream (Double))
getCommsPowerStream thisArg = requestStream $ getCommsPowerStreamReq thisArg
{-
- Signal delay to KSC in seconds.
-}
getCommsSignalDelay :: KRPCHS.SpaceCenter.Comms -> RPCContext (Double)
getCommsSignalDelay thisArg = do
let r = makeRequest "SpaceCenter" "Comms_get_SignalDelay" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommsSignalDelayStreamReq :: KRPCHS.SpaceCenter.Comms -> KRPCStreamReq (Double)
getCommsSignalDelayStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Comms_get_SignalDelay" [makeArgument 0 thisArg]
in makeStream req
getCommsSignalDelayStream :: KRPCHS.SpaceCenter.Comms -> RPCContext (KRPCStream (Double))
getCommsSignalDelayStream thisArg = requestStream $ getCommsSignalDelayStreamReq thisArg
{-
- Signal strength to KSC.
-}
getCommsSignalStrength :: KRPCHS.SpaceCenter.Comms -> RPCContext (Double)
getCommsSignalStrength thisArg = do
let r = makeRequest "SpaceCenter" "Comms_get_SignalStrength" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getCommsSignalStrengthStreamReq :: KRPCHS.SpaceCenter.Comms -> KRPCStreamReq (Double)
getCommsSignalStrengthStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Comms_get_SignalStrength" [makeArgument 0 thisArg]
in makeStream req
getCommsSignalStrengthStream :: KRPCHS.SpaceCenter.Comms -> RPCContext (KRPCStream (Double))
getCommsSignalStrengthStream thisArg = requestStream $ getCommsSignalStrengthStreamReq thisArg
{-
- A list of all active contracts.
-}
getContractManagerActiveContracts :: KRPCHS.SpaceCenter.ContractManager -> RPCContext ([KRPCHS.SpaceCenter.Contract])
getContractManagerActiveContracts thisArg = do
let r = makeRequest "SpaceCenter" "ContractManager_get_ActiveContracts" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractManagerActiveContractsStreamReq :: KRPCHS.SpaceCenter.ContractManager -> KRPCStreamReq ([KRPCHS.SpaceCenter.Contract])
getContractManagerActiveContractsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractManager_get_ActiveContracts" [makeArgument 0 thisArg]
in makeStream req
getContractManagerActiveContractsStream :: KRPCHS.SpaceCenter.ContractManager -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Contract]))
getContractManagerActiveContractsStream thisArg = requestStream $ getContractManagerActiveContractsStreamReq thisArg
{-
- A list of all contracts.
-}
getContractManagerAllContracts :: KRPCHS.SpaceCenter.ContractManager -> RPCContext ([KRPCHS.SpaceCenter.Contract])
getContractManagerAllContracts thisArg = do
let r = makeRequest "SpaceCenter" "ContractManager_get_AllContracts" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractManagerAllContractsStreamReq :: KRPCHS.SpaceCenter.ContractManager -> KRPCStreamReq ([KRPCHS.SpaceCenter.Contract])
getContractManagerAllContractsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractManager_get_AllContracts" [makeArgument 0 thisArg]
in makeStream req
getContractManagerAllContractsStream :: KRPCHS.SpaceCenter.ContractManager -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Contract]))
getContractManagerAllContractsStream thisArg = requestStream $ getContractManagerAllContractsStreamReq thisArg
{-
- A list of all completed contracts.
-}
getContractManagerCompletedContracts :: KRPCHS.SpaceCenter.ContractManager -> RPCContext ([KRPCHS.SpaceCenter.Contract])
getContractManagerCompletedContracts thisArg = do
let r = makeRequest "SpaceCenter" "ContractManager_get_CompletedContracts" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractManagerCompletedContractsStreamReq :: KRPCHS.SpaceCenter.ContractManager -> KRPCStreamReq ([KRPCHS.SpaceCenter.Contract])
getContractManagerCompletedContractsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractManager_get_CompletedContracts" [makeArgument 0 thisArg]
in makeStream req
getContractManagerCompletedContractsStream :: KRPCHS.SpaceCenter.ContractManager -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Contract]))
getContractManagerCompletedContractsStream thisArg = requestStream $ getContractManagerCompletedContractsStreamReq thisArg
{-
- A list of all failed contracts.
-}
getContractManagerFailedContracts :: KRPCHS.SpaceCenter.ContractManager -> RPCContext ([KRPCHS.SpaceCenter.Contract])
getContractManagerFailedContracts thisArg = do
let r = makeRequest "SpaceCenter" "ContractManager_get_FailedContracts" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractManagerFailedContractsStreamReq :: KRPCHS.SpaceCenter.ContractManager -> KRPCStreamReq ([KRPCHS.SpaceCenter.Contract])
getContractManagerFailedContractsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractManager_get_FailedContracts" [makeArgument 0 thisArg]
in makeStream req
getContractManagerFailedContractsStream :: KRPCHS.SpaceCenter.ContractManager -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Contract]))
getContractManagerFailedContractsStream thisArg = requestStream $ getContractManagerFailedContractsStreamReq thisArg
{-
- A list of all offered, but unaccepted, contracts.
-}
getContractManagerOfferedContracts :: KRPCHS.SpaceCenter.ContractManager -> RPCContext ([KRPCHS.SpaceCenter.Contract])
getContractManagerOfferedContracts thisArg = do
let r = makeRequest "SpaceCenter" "ContractManager_get_OfferedContracts" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractManagerOfferedContractsStreamReq :: KRPCHS.SpaceCenter.ContractManager -> KRPCStreamReq ([KRPCHS.SpaceCenter.Contract])
getContractManagerOfferedContractsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractManager_get_OfferedContracts" [makeArgument 0 thisArg]
in makeStream req
getContractManagerOfferedContractsStream :: KRPCHS.SpaceCenter.ContractManager -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Contract]))
getContractManagerOfferedContractsStream thisArg = requestStream $ getContractManagerOfferedContractsStreamReq thisArg
{-
- A list of all contract types.
-}
getContractManagerTypes :: KRPCHS.SpaceCenter.ContractManager -> RPCContext (Data.Set.Set Data.Text.Text)
getContractManagerTypes thisArg = do
let r = makeRequest "SpaceCenter" "ContractManager_get_Types" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractManagerTypesStreamReq :: KRPCHS.SpaceCenter.ContractManager -> KRPCStreamReq (Data.Set.Set Data.Text.Text)
getContractManagerTypesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractManager_get_Types" [makeArgument 0 thisArg]
in makeStream req
getContractManagerTypesStream :: KRPCHS.SpaceCenter.ContractManager -> RPCContext (KRPCStream (Data.Set.Set Data.Text.Text))
getContractManagerTypesStream thisArg = requestStream $ getContractManagerTypesStreamReq thisArg
{-
- Child contract parameters.
-}
getContractParameterChildren :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext ([KRPCHS.SpaceCenter.ContractParameter])
getContractParameterChildren thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_Children" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterChildrenStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq ([KRPCHS.SpaceCenter.ContractParameter])
getContractParameterChildrenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_Children" [makeArgument 0 thisArg]
in makeStream req
getContractParameterChildrenStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.ContractParameter]))
getContractParameterChildrenStream thisArg = requestStream $ getContractParameterChildrenStreamReq thisArg
{-
- Whether the parameter has been completed.
-}
getContractParameterCompleted :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Bool)
getContractParameterCompleted thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_Completed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterCompletedStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Bool)
getContractParameterCompletedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_Completed" [makeArgument 0 thisArg]
in makeStream req
getContractParameterCompletedStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Bool))
getContractParameterCompletedStream thisArg = requestStream $ getContractParameterCompletedStreamReq thisArg
{-
- Whether the parameter has been failed.
-}
getContractParameterFailed :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Bool)
getContractParameterFailed thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_Failed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterFailedStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Bool)
getContractParameterFailedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_Failed" [makeArgument 0 thisArg]
in makeStream req
getContractParameterFailedStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Bool))
getContractParameterFailedStream thisArg = requestStream $ getContractParameterFailedStreamReq thisArg
{-
- Funds received on completion of the contract parameter.
-}
getContractParameterFundsCompletion :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Double)
getContractParameterFundsCompletion thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_FundsCompletion" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterFundsCompletionStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Double)
getContractParameterFundsCompletionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_FundsCompletion" [makeArgument 0 thisArg]
in makeStream req
getContractParameterFundsCompletionStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Double))
getContractParameterFundsCompletionStream thisArg = requestStream $ getContractParameterFundsCompletionStreamReq thisArg
{-
- Funds lost if the contract parameter is failed.
-}
getContractParameterFundsFailure :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Double)
getContractParameterFundsFailure thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_FundsFailure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterFundsFailureStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Double)
getContractParameterFundsFailureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_FundsFailure" [makeArgument 0 thisArg]
in makeStream req
getContractParameterFundsFailureStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Double))
getContractParameterFundsFailureStream thisArg = requestStream $ getContractParameterFundsFailureStreamReq thisArg
{-
- Notes for the parameter.
-}
getContractParameterNotes :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Data.Text.Text)
getContractParameterNotes thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_Notes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterNotesStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Data.Text.Text)
getContractParameterNotesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_Notes" [makeArgument 0 thisArg]
in makeStream req
getContractParameterNotesStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Data.Text.Text))
getContractParameterNotesStream thisArg = requestStream $ getContractParameterNotesStreamReq thisArg
{-
- Whether the contract parameter is optional.
-}
getContractParameterOptional :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Bool)
getContractParameterOptional thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_Optional" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterOptionalStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Bool)
getContractParameterOptionalStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_Optional" [makeArgument 0 thisArg]
in makeStream req
getContractParameterOptionalStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Bool))
getContractParameterOptionalStream thisArg = requestStream $ getContractParameterOptionalStreamReq thisArg
{-
- Reputation gained on completion of the contract parameter.
-}
getContractParameterReputationCompletion :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Double)
getContractParameterReputationCompletion thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_ReputationCompletion" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterReputationCompletionStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Double)
getContractParameterReputationCompletionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_ReputationCompletion" [makeArgument 0 thisArg]
in makeStream req
getContractParameterReputationCompletionStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Double))
getContractParameterReputationCompletionStream thisArg = requestStream $ getContractParameterReputationCompletionStreamReq thisArg
{-
- Reputation lost if the contract parameter is failed.
-}
getContractParameterReputationFailure :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Double)
getContractParameterReputationFailure thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_ReputationFailure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterReputationFailureStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Double)
getContractParameterReputationFailureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_ReputationFailure" [makeArgument 0 thisArg]
in makeStream req
getContractParameterReputationFailureStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Double))
getContractParameterReputationFailureStream thisArg = requestStream $ getContractParameterReputationFailureStreamReq thisArg
{-
- Science gained on completion of the contract parameter.
-}
getContractParameterScienceCompletion :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Double)
getContractParameterScienceCompletion thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_ScienceCompletion" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterScienceCompletionStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Double)
getContractParameterScienceCompletionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_ScienceCompletion" [makeArgument 0 thisArg]
in makeStream req
getContractParameterScienceCompletionStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Double))
getContractParameterScienceCompletionStream thisArg = requestStream $ getContractParameterScienceCompletionStreamReq thisArg
{-
- Title of the parameter.
-}
getContractParameterTitle :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (Data.Text.Text)
getContractParameterTitle thisArg = do
let r = makeRequest "SpaceCenter" "ContractParameter_get_Title" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParameterTitleStreamReq :: KRPCHS.SpaceCenter.ContractParameter -> KRPCStreamReq (Data.Text.Text)
getContractParameterTitleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ContractParameter_get_Title" [makeArgument 0 thisArg]
in makeStream req
getContractParameterTitleStream :: KRPCHS.SpaceCenter.ContractParameter -> RPCContext (KRPCStream (Data.Text.Text))
getContractParameterTitleStream thisArg = requestStream $ getContractParameterTitleStreamReq thisArg
{-
- Accept an offered contract.
-}
contractAccept :: KRPCHS.SpaceCenter.Contract -> RPCContext ()
contractAccept thisArg = do
let r = makeRequest "SpaceCenter" "Contract_Accept" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Cancel an active contract.
-}
contractCancel :: KRPCHS.SpaceCenter.Contract -> RPCContext ()
contractCancel thisArg = do
let r = makeRequest "SpaceCenter" "Contract_Cancel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Decline an offered contract.
-}
contractDecline :: KRPCHS.SpaceCenter.Contract -> RPCContext ()
contractDecline thisArg = do
let r = makeRequest "SpaceCenter" "Contract_Decline" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Whether the contract is active.
-}
getContractActive :: KRPCHS.SpaceCenter.Contract -> RPCContext (Bool)
getContractActive thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Active" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractActiveStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Bool)
getContractActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Active" [makeArgument 0 thisArg]
in makeStream req
getContractActiveStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Bool))
getContractActiveStream thisArg = requestStream $ getContractActiveStreamReq thisArg
{-
- Whether the contract can be canceled.
-}
getContractCanBeCanceled :: KRPCHS.SpaceCenter.Contract -> RPCContext (Bool)
getContractCanBeCanceled thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_CanBeCanceled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractCanBeCanceledStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Bool)
getContractCanBeCanceledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_CanBeCanceled" [makeArgument 0 thisArg]
in makeStream req
getContractCanBeCanceledStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Bool))
getContractCanBeCanceledStream thisArg = requestStream $ getContractCanBeCanceledStreamReq thisArg
{-
- Whether the contract can be declined.
-}
getContractCanBeDeclined :: KRPCHS.SpaceCenter.Contract -> RPCContext (Bool)
getContractCanBeDeclined thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_CanBeDeclined" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractCanBeDeclinedStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Bool)
getContractCanBeDeclinedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_CanBeDeclined" [makeArgument 0 thisArg]
in makeStream req
getContractCanBeDeclinedStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Bool))
getContractCanBeDeclinedStream thisArg = requestStream $ getContractCanBeDeclinedStreamReq thisArg
{-
- Whether the contract can be failed.
-}
getContractCanBeFailed :: KRPCHS.SpaceCenter.Contract -> RPCContext (Bool)
getContractCanBeFailed thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_CanBeFailed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractCanBeFailedStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Bool)
getContractCanBeFailedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_CanBeFailed" [makeArgument 0 thisArg]
in makeStream req
getContractCanBeFailedStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Bool))
getContractCanBeFailedStream thisArg = requestStream $ getContractCanBeFailedStreamReq thisArg
{-
- Description of the contract.
-}
getContractDescription :: KRPCHS.SpaceCenter.Contract -> RPCContext (Data.Text.Text)
getContractDescription thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Description" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractDescriptionStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Data.Text.Text)
getContractDescriptionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Description" [makeArgument 0 thisArg]
in makeStream req
getContractDescriptionStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Data.Text.Text))
getContractDescriptionStream thisArg = requestStream $ getContractDescriptionStreamReq thisArg
{-
- Whether the contract has been failed.
-}
getContractFailed :: KRPCHS.SpaceCenter.Contract -> RPCContext (Bool)
getContractFailed thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Failed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractFailedStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Bool)
getContractFailedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Failed" [makeArgument 0 thisArg]
in makeStream req
getContractFailedStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Bool))
getContractFailedStream thisArg = requestStream $ getContractFailedStreamReq thisArg
{-
- Funds received when accepting the contract.
-}
getContractFundsAdvance :: KRPCHS.SpaceCenter.Contract -> RPCContext (Double)
getContractFundsAdvance thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_FundsAdvance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractFundsAdvanceStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Double)
getContractFundsAdvanceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_FundsAdvance" [makeArgument 0 thisArg]
in makeStream req
getContractFundsAdvanceStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Double))
getContractFundsAdvanceStream thisArg = requestStream $ getContractFundsAdvanceStreamReq thisArg
{-
- Funds received on completion of the contract.
-}
getContractFundsCompletion :: KRPCHS.SpaceCenter.Contract -> RPCContext (Double)
getContractFundsCompletion thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_FundsCompletion" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractFundsCompletionStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Double)
getContractFundsCompletionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_FundsCompletion" [makeArgument 0 thisArg]
in makeStream req
getContractFundsCompletionStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Double))
getContractFundsCompletionStream thisArg = requestStream $ getContractFundsCompletionStreamReq thisArg
{-
- Funds lost if the contract is failed.
-}
getContractFundsFailure :: KRPCHS.SpaceCenter.Contract -> RPCContext (Double)
getContractFundsFailure thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_FundsFailure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractFundsFailureStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Double)
getContractFundsFailureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_FundsFailure" [makeArgument 0 thisArg]
in makeStream req
getContractFundsFailureStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Double))
getContractFundsFailureStream thisArg = requestStream $ getContractFundsFailureStreamReq thisArg
{-
- Keywords for the contract.
-}
getContractKeywords :: KRPCHS.SpaceCenter.Contract -> RPCContext ([Data.Text.Text])
getContractKeywords thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Keywords" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractKeywordsStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq ([Data.Text.Text])
getContractKeywordsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Keywords" [makeArgument 0 thisArg]
in makeStream req
getContractKeywordsStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream ([Data.Text.Text]))
getContractKeywordsStream thisArg = requestStream $ getContractKeywordsStreamReq thisArg
{-
- Notes for the contract.
-}
getContractNotes :: KRPCHS.SpaceCenter.Contract -> RPCContext (Data.Text.Text)
getContractNotes thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Notes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractNotesStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Data.Text.Text)
getContractNotesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Notes" [makeArgument 0 thisArg]
in makeStream req
getContractNotesStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Data.Text.Text))
getContractNotesStream thisArg = requestStream $ getContractNotesStreamReq thisArg
{-
- Parameters for the contract.
-}
getContractParameters :: KRPCHS.SpaceCenter.Contract -> RPCContext ([KRPCHS.SpaceCenter.ContractParameter])
getContractParameters thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Parameters" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractParametersStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq ([KRPCHS.SpaceCenter.ContractParameter])
getContractParametersStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Parameters" [makeArgument 0 thisArg]
in makeStream req
getContractParametersStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.ContractParameter]))
getContractParametersStream thisArg = requestStream $ getContractParametersStreamReq thisArg
{-
- Whether the contract has been read.
-}
getContractRead :: KRPCHS.SpaceCenter.Contract -> RPCContext (Bool)
getContractRead thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Read" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractReadStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Bool)
getContractReadStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Read" [makeArgument 0 thisArg]
in makeStream req
getContractReadStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Bool))
getContractReadStream thisArg = requestStream $ getContractReadStreamReq thisArg
{-
- Reputation gained on completion of the contract.
-}
getContractReputationCompletion :: KRPCHS.SpaceCenter.Contract -> RPCContext (Double)
getContractReputationCompletion thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_ReputationCompletion" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractReputationCompletionStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Double)
getContractReputationCompletionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_ReputationCompletion" [makeArgument 0 thisArg]
in makeStream req
getContractReputationCompletionStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Double))
getContractReputationCompletionStream thisArg = requestStream $ getContractReputationCompletionStreamReq thisArg
{-
- Reputation lost if the contract is failed.
-}
getContractReputationFailure :: KRPCHS.SpaceCenter.Contract -> RPCContext (Double)
getContractReputationFailure thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_ReputationFailure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractReputationFailureStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Double)
getContractReputationFailureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_ReputationFailure" [makeArgument 0 thisArg]
in makeStream req
getContractReputationFailureStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Double))
getContractReputationFailureStream thisArg = requestStream $ getContractReputationFailureStreamReq thisArg
{-
- Science gained on completion of the contract.
-}
getContractScienceCompletion :: KRPCHS.SpaceCenter.Contract -> RPCContext (Double)
getContractScienceCompletion thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_ScienceCompletion" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractScienceCompletionStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Double)
getContractScienceCompletionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_ScienceCompletion" [makeArgument 0 thisArg]
in makeStream req
getContractScienceCompletionStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Double))
getContractScienceCompletionStream thisArg = requestStream $ getContractScienceCompletionStreamReq thisArg
{-
- Whether the contract has been seen.
-}
getContractSeen :: KRPCHS.SpaceCenter.Contract -> RPCContext (Bool)
getContractSeen thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Seen" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractSeenStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Bool)
getContractSeenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Seen" [makeArgument 0 thisArg]
in makeStream req
getContractSeenStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Bool))
getContractSeenStream thisArg = requestStream $ getContractSeenStreamReq thisArg
{-
- State of the contract.
-}
getContractState :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCHS.SpaceCenter.ContractState)
getContractState thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractStateStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (KRPCHS.SpaceCenter.ContractState)
getContractStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_State" [makeArgument 0 thisArg]
in makeStream req
getContractStateStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ContractState))
getContractStateStream thisArg = requestStream $ getContractStateStreamReq thisArg
{-
- Synopsis for the contract.
-}
getContractSynopsis :: KRPCHS.SpaceCenter.Contract -> RPCContext (Data.Text.Text)
getContractSynopsis thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Synopsis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractSynopsisStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Data.Text.Text)
getContractSynopsisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Synopsis" [makeArgument 0 thisArg]
in makeStream req
getContractSynopsisStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Data.Text.Text))
getContractSynopsisStream thisArg = requestStream $ getContractSynopsisStreamReq thisArg
{-
- Title of the contract.
-}
getContractTitle :: KRPCHS.SpaceCenter.Contract -> RPCContext (Data.Text.Text)
getContractTitle thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Title" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractTitleStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Data.Text.Text)
getContractTitleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Title" [makeArgument 0 thisArg]
in makeStream req
getContractTitleStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Data.Text.Text))
getContractTitleStream thisArg = requestStream $ getContractTitleStreamReq thisArg
{-
- Type of the contract.
-}
getContractType :: KRPCHS.SpaceCenter.Contract -> RPCContext (Data.Text.Text)
getContractType thisArg = do
let r = makeRequest "SpaceCenter" "Contract_get_Type" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getContractTypeStreamReq :: KRPCHS.SpaceCenter.Contract -> KRPCStreamReq (Data.Text.Text)
getContractTypeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Contract_get_Type" [makeArgument 0 thisArg]
in makeStream req
getContractTypeStream :: KRPCHS.SpaceCenter.Contract -> RPCContext (KRPCStream (Data.Text.Text))
getContractTypeStream thisArg = requestStream $ getContractTypeStreamReq thisArg
{-
- The authority limiter for the control surface, which controls how far the control surface will move.
-}
getControlSurfaceAuthorityLimiter :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (Float)
getControlSurfaceAuthorityLimiter thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_AuthorityLimiter" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfaceAuthorityLimiterStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (Float)
getControlSurfaceAuthorityLimiterStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_AuthorityLimiter" [makeArgument 0 thisArg]
in makeStream req
getControlSurfaceAuthorityLimiterStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (Float))
getControlSurfaceAuthorityLimiterStream thisArg = requestStream $ getControlSurfaceAuthorityLimiterStreamReq thisArg
{-
- The available torque in the positive pitch, roll and yaw axes and
- negative pitch, roll and yaw axes of the vessel, in Newton meters.
- These axes correspond to the coordinate axes of the <see cref="M:SpaceCenter.Vessel.ReferenceFrame" />.
-}
getControlSurfaceAvailableTorque :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getControlSurfaceAvailableTorque thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_AvailableTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfaceAvailableTorqueStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getControlSurfaceAvailableTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_AvailableTorque" [makeArgument 0 thisArg]
in makeStream req
getControlSurfaceAvailableTorqueStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getControlSurfaceAvailableTorqueStream thisArg = requestStream $ getControlSurfaceAvailableTorqueStreamReq thisArg
{-
- Whether the control surface has been fully deployed.
-}
getControlSurfaceDeployed :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (Bool)
getControlSurfaceDeployed thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfaceDeployedStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (Bool)
getControlSurfaceDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getControlSurfaceDeployedStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (Bool))
getControlSurfaceDeployedStream thisArg = requestStream $ getControlSurfaceDeployedStreamReq thisArg
{-
- Whether the control surface movement is inverted.
-}
getControlSurfaceInverted :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (Bool)
getControlSurfaceInverted thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_Inverted" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfaceInvertedStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (Bool)
getControlSurfaceInvertedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_Inverted" [makeArgument 0 thisArg]
in makeStream req
getControlSurfaceInvertedStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (Bool))
getControlSurfaceInvertedStream thisArg = requestStream $ getControlSurfaceInvertedStreamReq thisArg
{-
- The part object for this control surface.
-}
getControlSurfacePart :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCHS.SpaceCenter.Part)
getControlSurfacePart thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfacePartStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getControlSurfacePartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_Part" [makeArgument 0 thisArg]
in makeStream req
getControlSurfacePartStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getControlSurfacePartStream thisArg = requestStream $ getControlSurfacePartStreamReq thisArg
{-
- Whether the control surface has pitch control enabled.
-}
getControlSurfacePitchEnabled :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (Bool)
getControlSurfacePitchEnabled thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_PitchEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfacePitchEnabledStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (Bool)
getControlSurfacePitchEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_PitchEnabled" [makeArgument 0 thisArg]
in makeStream req
getControlSurfacePitchEnabledStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (Bool))
getControlSurfacePitchEnabledStream thisArg = requestStream $ getControlSurfacePitchEnabledStreamReq thisArg
{-
- Whether the control surface has roll control enabled.
-}
getControlSurfaceRollEnabled :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (Bool)
getControlSurfaceRollEnabled thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_RollEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfaceRollEnabledStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (Bool)
getControlSurfaceRollEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_RollEnabled" [makeArgument 0 thisArg]
in makeStream req
getControlSurfaceRollEnabledStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (Bool))
getControlSurfaceRollEnabledStream thisArg = requestStream $ getControlSurfaceRollEnabledStreamReq thisArg
{-
- Surface area of the control surface inm^2.
-}
getControlSurfaceSurfaceArea :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (Float)
getControlSurfaceSurfaceArea thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_SurfaceArea" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfaceSurfaceAreaStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (Float)
getControlSurfaceSurfaceAreaStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_SurfaceArea" [makeArgument 0 thisArg]
in makeStream req
getControlSurfaceSurfaceAreaStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (Float))
getControlSurfaceSurfaceAreaStream thisArg = requestStream $ getControlSurfaceSurfaceAreaStreamReq thisArg
{-
- Whether the control surface has yaw control enabled.
-}
getControlSurfaceYawEnabled :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (Bool)
getControlSurfaceYawEnabled thisArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_get_YawEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSurfaceYawEnabledStreamReq :: KRPCHS.SpaceCenter.ControlSurface -> KRPCStreamReq (Bool)
getControlSurfaceYawEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ControlSurface_get_YawEnabled" [makeArgument 0 thisArg]
in makeStream req
getControlSurfaceYawEnabledStream :: KRPCHS.SpaceCenter.ControlSurface -> RPCContext (KRPCStream (Bool))
getControlSurfaceYawEnabledStream thisArg = requestStream $ getControlSurfaceYawEnabledStreamReq thisArg
{-
- The authority limiter for the control surface, which controls how far the control surface will move.
-}
setControlSurfaceAuthorityLimiter :: KRPCHS.SpaceCenter.ControlSurface -> Float -> RPCContext ()
setControlSurfaceAuthorityLimiter thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_set_AuthorityLimiter" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the control surface has been fully deployed.
-}
setControlSurfaceDeployed :: KRPCHS.SpaceCenter.ControlSurface -> Bool -> RPCContext ()
setControlSurfaceDeployed thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_set_Deployed" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the control surface movement is inverted.
-}
setControlSurfaceInverted :: KRPCHS.SpaceCenter.ControlSurface -> Bool -> RPCContext ()
setControlSurfaceInverted thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_set_Inverted" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the control surface has pitch control enabled.
-}
setControlSurfacePitchEnabled :: KRPCHS.SpaceCenter.ControlSurface -> Bool -> RPCContext ()
setControlSurfacePitchEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_set_PitchEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the control surface has roll control enabled.
-}
setControlSurfaceRollEnabled :: KRPCHS.SpaceCenter.ControlSurface -> Bool -> RPCContext ()
setControlSurfaceRollEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_set_RollEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the control surface has yaw control enabled.
-}
setControlSurfaceYawEnabled :: KRPCHS.SpaceCenter.ControlSurface -> Bool -> RPCContext ()
setControlSurfaceYawEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ControlSurface_set_YawEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Activates the next stage. Equivalent to pressing the space bar in-game.A list of vessel objects that are jettisoned from the active vessel.When called, the active vessel may change. It is therefore possible that,
- after calling this function, the object(s) returned by previous call(s) to
- <see cref="M:SpaceCenter.ActiveVessel" /> no longer refer to the active vessel.
-}
controlActivateNextStage :: KRPCHS.SpaceCenter.Control -> RPCContext ([KRPCHS.SpaceCenter.Vessel])
controlActivateNextStage thisArg = do
let r = makeRequest "SpaceCenter" "Control_ActivateNextStage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
controlActivateNextStageStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq ([KRPCHS.SpaceCenter.Vessel])
controlActivateNextStageStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_ActivateNextStage" [makeArgument 0 thisArg]
in makeStream req
controlActivateNextStageStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Vessel]))
controlActivateNextStageStream thisArg = requestStream $ controlActivateNextStageStreamReq thisArg
{-
- Creates a maneuver node at the given universal time, and returns a
- <see cref="T:SpaceCenter.Node" /> object that can be used to modify it.
- Optionally sets the magnitude of the delta-v for the maneuver node
- in the prograde, normal and radial directions.<param name="ut">Universal time of the maneuver node.<param name="prograde">Delta-v in the prograde direction.<param name="normal">Delta-v in the normal direction.<param name="radial">Delta-v in the radial direction.
-}
controlAddNode :: KRPCHS.SpaceCenter.Control -> Double -> Float -> Float -> Float -> RPCContext (KRPCHS.SpaceCenter.Node)
controlAddNode thisArg utArg progradeArg normalArg radialArg = do
let r = makeRequest "SpaceCenter" "Control_AddNode" [makeArgument 0 thisArg, makeArgument 1 utArg, makeArgument 2 progradeArg, makeArgument 3 normalArg, makeArgument 4 radialArg]
res <- sendRequest r
processResponse res
controlAddNodeStreamReq :: KRPCHS.SpaceCenter.Control -> Double -> Float -> Float -> Float -> KRPCStreamReq (KRPCHS.SpaceCenter.Node)
controlAddNodeStreamReq thisArg utArg progradeArg normalArg radialArg =
let req = makeRequest "SpaceCenter" "Control_AddNode" [makeArgument 0 thisArg, makeArgument 1 utArg, makeArgument 2 progradeArg, makeArgument 3 normalArg, makeArgument 4 radialArg]
in makeStream req
controlAddNodeStream :: KRPCHS.SpaceCenter.Control -> Double -> Float -> Float -> Float -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Node))
controlAddNodeStream thisArg utArg progradeArg normalArg radialArg = requestStream $ controlAddNodeStreamReq thisArg utArg progradeArg normalArg radialArg
{-
- Returnstrueif the given action group is enabled.<param name="group">
- A number between 0 and 9 inclusive,
- or between 0 and 250 inclusive when the <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/67235-12oct3116-action-groups-extended-250-action-groups-in-flight-editing-now-kosremotetech">Extended Action Groups modis installed.
-}
controlGetActionGroup :: KRPCHS.SpaceCenter.Control -> Data.Word.Word32 -> RPCContext (Bool)
controlGetActionGroup thisArg groupArg = do
let r = makeRequest "SpaceCenter" "Control_GetActionGroup" [makeArgument 0 thisArg, makeArgument 1 groupArg]
res <- sendRequest r
processResponse res
controlGetActionGroupStreamReq :: KRPCHS.SpaceCenter.Control -> Data.Word.Word32 -> KRPCStreamReq (Bool)
controlGetActionGroupStreamReq thisArg groupArg =
let req = makeRequest "SpaceCenter" "Control_GetActionGroup" [makeArgument 0 thisArg, makeArgument 1 groupArg]
in makeStream req
controlGetActionGroupStream :: KRPCHS.SpaceCenter.Control -> Data.Word.Word32 -> RPCContext (KRPCStream (Bool))
controlGetActionGroupStream thisArg groupArg = requestStream $ controlGetActionGroupStreamReq thisArg groupArg
{-
- Remove all maneuver nodes.
-}
controlRemoveNodes :: KRPCHS.SpaceCenter.Control -> RPCContext ()
controlRemoveNodes thisArg = do
let r = makeRequest "SpaceCenter" "Control_RemoveNodes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Sets the state of the given action group.<param name="group">
- A number between 0 and 9 inclusive,
- or between 0 and 250 inclusive when the <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/67235-12oct3116-action-groups-extended-250-action-groups-in-flight-editing-now-kosremotetech">Extended Action Groups modis installed.<param name="state">
-}
controlSetActionGroup :: KRPCHS.SpaceCenter.Control -> Data.Word.Word32 -> Bool -> RPCContext ()
controlSetActionGroup thisArg groupArg stateArg = do
let r = makeRequest "SpaceCenter" "Control_SetActionGroup" [makeArgument 0 thisArg, makeArgument 1 groupArg, makeArgument 2 stateArg]
res <- sendRequest r
processResponse res
{-
- Toggles the state of the given action group.<param name="group">
- A number between 0 and 9 inclusive,
- or between 0 and 250 inclusive when the <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/67235-12oct3116-action-groups-extended-250-action-groups-in-flight-editing-now-kosremotetech">Extended Action Groups modis installed.
-}
controlToggleActionGroup :: KRPCHS.SpaceCenter.Control -> Data.Word.Word32 -> RPCContext ()
controlToggleActionGroup thisArg groupArg = do
let r = makeRequest "SpaceCenter" "Control_ToggleActionGroup" [makeArgument 0 thisArg, makeArgument 1 groupArg]
res <- sendRequest r
processResponse res
{-
- The state of the abort action group.
-}
getControlAbort :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlAbort thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Abort" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlAbortStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlAbortStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Abort" [makeArgument 0 thisArg]
in makeStream req
getControlAbortStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlAbortStream thisArg = requestStream $ getControlAbortStreamReq thisArg
{-
- Returns whether all antennas on the vessel are deployed,
- and sets the deployment state of all antennas.
- See <see cref="M:SpaceCenter.Antenna.Deployed" />.
-}
getControlAntennas :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlAntennas thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Antennas" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlAntennasStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlAntennasStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Antennas" [makeArgument 0 thisArg]
in makeStream req
getControlAntennasStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlAntennasStream thisArg = requestStream $ getControlAntennasStreamReq thisArg
{-
- The state of the wheel brakes.
-}
getControlBrakes :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlBrakes thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Brakes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlBrakesStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlBrakesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Brakes" [makeArgument 0 thisArg]
in makeStream req
getControlBrakesStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlBrakesStream thisArg = requestStream $ getControlBrakesStreamReq thisArg
{-
- Returns whether any of the cargo bays on the vessel are open,
- and sets the open state of all cargo bays.
- See <see cref="M:SpaceCenter.CargoBay.Open" />.
-}
getControlCargoBays :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlCargoBays thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_CargoBays" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlCargoBaysStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlCargoBaysStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_CargoBays" [makeArgument 0 thisArg]
in makeStream req
getControlCargoBaysStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlCargoBaysStream thisArg = requestStream $ getControlCargoBaysStreamReq thisArg
{-
- The current stage of the vessel. Corresponds to the stage number in
- the in-game UI.
-}
getControlCurrentStage :: KRPCHS.SpaceCenter.Control -> RPCContext (Data.Int.Int32)
getControlCurrentStage thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_CurrentStage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlCurrentStageStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Data.Int.Int32)
getControlCurrentStageStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_CurrentStage" [makeArgument 0 thisArg]
in makeStream req
getControlCurrentStageStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Data.Int.Int32))
getControlCurrentStageStream thisArg = requestStream $ getControlCurrentStageStreamReq thisArg
{-
- The state of the forward translational control.
- A value between -1 and 1.
- Equivalent to the h and n keys.
-}
getControlForward :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlForward thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Forward" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlForwardStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlForwardStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Forward" [makeArgument 0 thisArg]
in makeStream req
getControlForwardStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlForwardStream thisArg = requestStream $ getControlForwardStreamReq thisArg
{-
- The state of the landing gear/legs.
-}
getControlGear :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlGear thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Gear" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlGearStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlGearStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Gear" [makeArgument 0 thisArg]
in makeStream req
getControlGearStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlGearStream thisArg = requestStream $ getControlGearStreamReq thisArg
{-
- Returns whether all of the air intakes on the vessel are open,
- and sets the open state of all air intakes.
- See <see cref="M:SpaceCenter.Intake.Open" />.
-}
getControlIntakes :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlIntakes thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Intakes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlIntakesStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlIntakesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Intakes" [makeArgument 0 thisArg]
in makeStream req
getControlIntakesStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlIntakesStream thisArg = requestStream $ getControlIntakesStreamReq thisArg
{-
- Returns whether all landing legs on the vessel are deployed,
- and sets the deployment state of all landing legs.
- Does not include wheels (for example landing gear).
- See <see cref="M:SpaceCenter.Leg.Deployed" />.
-}
getControlLegs :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlLegs thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Legs" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlLegsStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlLegsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Legs" [makeArgument 0 thisArg]
in makeStream req
getControlLegsStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlLegsStream thisArg = requestStream $ getControlLegsStreamReq thisArg
{-
- The state of the lights.
-}
getControlLights :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlLights thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Lights" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlLightsStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlLightsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Lights" [makeArgument 0 thisArg]
in makeStream req
getControlLightsStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlLightsStream thisArg = requestStream $ getControlLightsStreamReq thisArg
{-
- Returns a list of all existing maneuver nodes, ordered by time from first to last.
-}
getControlNodes :: KRPCHS.SpaceCenter.Control -> RPCContext ([KRPCHS.SpaceCenter.Node])
getControlNodes thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Nodes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlNodesStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq ([KRPCHS.SpaceCenter.Node])
getControlNodesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Nodes" [makeArgument 0 thisArg]
in makeStream req
getControlNodesStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Node]))
getControlNodesStream thisArg = requestStream $ getControlNodesStreamReq thisArg
{-
- Returns whether all parachutes on the vessel are deployed,
- and sets the deployment state of all parachutes.
- Cannot be set tofalse.
- See <see cref="M:SpaceCenter.Parachute.Deployed" />.
-}
getControlParachutes :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlParachutes thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Parachutes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlParachutesStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlParachutesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Parachutes" [makeArgument 0 thisArg]
in makeStream req
getControlParachutesStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlParachutesStream thisArg = requestStream $ getControlParachutesStreamReq thisArg
{-
- The state of the pitch control.
- A value between -1 and 1.
- Equivalent to the w and s keys.
-}
getControlPitch :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlPitch thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Pitch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlPitchStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlPitchStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Pitch" [makeArgument 0 thisArg]
in makeStream req
getControlPitchStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlPitchStream thisArg = requestStream $ getControlPitchStreamReq thisArg
{-
- The state of RCS.
-}
getControlRCS :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlRCS thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_RCS" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlRCSStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlRCSStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_RCS" [makeArgument 0 thisArg]
in makeStream req
getControlRCSStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlRCSStream thisArg = requestStream $ getControlRCSStreamReq thisArg
{-
- Returns whether all radiators on the vessel are deployed,
- and sets the deployment state of all radiators.
- See <see cref="M:SpaceCenter.Radiator.Deployed" />.
-}
getControlRadiators :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlRadiators thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Radiators" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlRadiatorsStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlRadiatorsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Radiators" [makeArgument 0 thisArg]
in makeStream req
getControlRadiatorsStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlRadiatorsStream thisArg = requestStream $ getControlRadiatorsStreamReq thisArg
{-
- Returns whether all reactive wheels on the vessel are active,
- and sets the active state of all reaction wheels.
- See <see cref="M:SpaceCenter.ReactionWheel.Active" />.
-}
getControlReactionWheels :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlReactionWheels thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_ReactionWheels" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlReactionWheelsStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlReactionWheelsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_ReactionWheels" [makeArgument 0 thisArg]
in makeStream req
getControlReactionWheelsStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlReactionWheelsStream thisArg = requestStream $ getControlReactionWheelsStreamReq thisArg
{-
- Returns whether all of the resource harvesters on the vessel are deployed,
- and sets the deployment state of all resource harvesters.
- See <see cref="M:SpaceCenter.ResourceHarvester.Deployed" />.
-}
getControlResourceHarvesters :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlResourceHarvesters thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_ResourceHarvesters" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlResourceHarvestersStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlResourceHarvestersStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_ResourceHarvesters" [makeArgument 0 thisArg]
in makeStream req
getControlResourceHarvestersStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlResourceHarvestersStream thisArg = requestStream $ getControlResourceHarvestersStreamReq thisArg
{-
- Returns whether any of the resource harvesters on the vessel are active,
- and sets the active state of all resource harvesters.
- See <see cref="M:SpaceCenter.ResourceHarvester.Active" />.
-}
getControlResourceHarvestersActive :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlResourceHarvestersActive thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_ResourceHarvestersActive" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlResourceHarvestersActiveStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlResourceHarvestersActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_ResourceHarvestersActive" [makeArgument 0 thisArg]
in makeStream req
getControlResourceHarvestersActiveStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlResourceHarvestersActiveStream thisArg = requestStream $ getControlResourceHarvestersActiveStreamReq thisArg
{-
- The state of the right translational control.
- A value between -1 and 1.
- Equivalent to the j and l keys.
-}
getControlRight :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlRight thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Right" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlRightStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlRightStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Right" [makeArgument 0 thisArg]
in makeStream req
getControlRightStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlRightStream thisArg = requestStream $ getControlRightStreamReq thisArg
{-
- The state of the roll control.
- A value between -1 and 1.
- Equivalent to the q and e keys.
-}
getControlRoll :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlRoll thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Roll" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlRollStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlRollStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Roll" [makeArgument 0 thisArg]
in makeStream req
getControlRollStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlRollStream thisArg = requestStream $ getControlRollStreamReq thisArg
{-
- The state of SAS.Equivalent to <see cref="M:SpaceCenter.AutoPilot.SAS" />
-}
getControlSAS :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlSAS thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_SAS" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSASStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlSASStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_SAS" [makeArgument 0 thisArg]
in makeStream req
getControlSASStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlSASStream thisArg = requestStream $ getControlSASStreamReq thisArg
{-
- The current <see cref="T:SpaceCenter.SASMode" />.
- These modes are equivalent to the mode buttons to
- the left of the navball that appear when SAS is enabled.Equivalent to <see cref="M:SpaceCenter.AutoPilot.SASMode" />
-}
getControlSASMode :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCHS.SpaceCenter.SASMode)
getControlSASMode thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_SASMode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSASModeStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (KRPCHS.SpaceCenter.SASMode)
getControlSASModeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_SASMode" [makeArgument 0 thisArg]
in makeStream req
getControlSASModeStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.SASMode))
getControlSASModeStream thisArg = requestStream $ getControlSASModeStreamReq thisArg
{-
- Returns whether all solar panels on the vessel are deployed,
- and sets the deployment state of all solar panels.
- See <see cref="M:SpaceCenter.SolarPanel.Deployed" />.
-}
getControlSolarPanels :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlSolarPanels thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_SolarPanels" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSolarPanelsStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlSolarPanelsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_SolarPanels" [makeArgument 0 thisArg]
in makeStream req
getControlSolarPanelsStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlSolarPanelsStream thisArg = requestStream $ getControlSolarPanelsStreamReq thisArg
{-
- The source of the vessels control, for example by a kerbal or a probe core.
-}
getControlSource :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCHS.SpaceCenter.ControlSource)
getControlSource thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Source" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSourceStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (KRPCHS.SpaceCenter.ControlSource)
getControlSourceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Source" [makeArgument 0 thisArg]
in makeStream req
getControlSourceStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ControlSource))
getControlSourceStream thisArg = requestStream $ getControlSourceStreamReq thisArg
{-
- The current <see cref="T:SpaceCenter.SpeedMode" /> of the navball.
- This is the mode displayed next to the speed at the top of the navball.
-}
getControlSpeedMode :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCHS.SpaceCenter.SpeedMode)
getControlSpeedMode thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_SpeedMode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlSpeedModeStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (KRPCHS.SpaceCenter.SpeedMode)
getControlSpeedModeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_SpeedMode" [makeArgument 0 thisArg]
in makeStream req
getControlSpeedModeStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.SpeedMode))
getControlSpeedModeStream thisArg = requestStream $ getControlSpeedModeStreamReq thisArg
{-
- The control state of the vessel.
-}
getControlState :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCHS.SpaceCenter.ControlState)
getControlState thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlStateStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (KRPCHS.SpaceCenter.ControlState)
getControlStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_State" [makeArgument 0 thisArg]
in makeStream req
getControlStateStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ControlState))
getControlStateStream thisArg = requestStream $ getControlStateStreamReq thisArg
{-
- The state of the throttle. A value between 0 and 1.
-}
getControlThrottle :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlThrottle thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Throttle" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlThrottleStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlThrottleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Throttle" [makeArgument 0 thisArg]
in makeStream req
getControlThrottleStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlThrottleStream thisArg = requestStream $ getControlThrottleStreamReq thisArg
{-
- The state of the up translational control.
- A value between -1 and 1.
- Equivalent to the i and k keys.
-}
getControlUp :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlUp thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Up" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlUpStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlUpStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Up" [makeArgument 0 thisArg]
in makeStream req
getControlUpStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlUpStream thisArg = requestStream $ getControlUpStreamReq thisArg
{-
- The state of the wheel steering.
- A value between -1 and 1.
- A value of 1 steers to the left, and a value of -1 steers to the right.
-}
getControlWheelSteering :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlWheelSteering thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_WheelSteering" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlWheelSteeringStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlWheelSteeringStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_WheelSteering" [makeArgument 0 thisArg]
in makeStream req
getControlWheelSteeringStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlWheelSteeringStream thisArg = requestStream $ getControlWheelSteeringStreamReq thisArg
{-
- The state of the wheel throttle.
- A value between -1 and 1.
- A value of 1 rotates the wheels forwards, a value of -1 rotates
- the wheels backwards.
-}
getControlWheelThrottle :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlWheelThrottle thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_WheelThrottle" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlWheelThrottleStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlWheelThrottleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_WheelThrottle" [makeArgument 0 thisArg]
in makeStream req
getControlWheelThrottleStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlWheelThrottleStream thisArg = requestStream $ getControlWheelThrottleStreamReq thisArg
{-
- Returns whether all wheels on the vessel are deployed,
- and sets the deployment state of all wheels.
- Does not include landing legs.
- See <see cref="M:SpaceCenter.Wheel.Deployed" />.
-}
getControlWheels :: KRPCHS.SpaceCenter.Control -> RPCContext (Bool)
getControlWheels thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Wheels" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlWheelsStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Bool)
getControlWheelsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Wheels" [makeArgument 0 thisArg]
in makeStream req
getControlWheelsStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Bool))
getControlWheelsStream thisArg = requestStream $ getControlWheelsStreamReq thisArg
{-
- The state of the yaw control.
- A value between -1 and 1.
- Equivalent to the a and d keys.
-}
getControlYaw :: KRPCHS.SpaceCenter.Control -> RPCContext (Float)
getControlYaw thisArg = do
let r = makeRequest "SpaceCenter" "Control_get_Yaw" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getControlYawStreamReq :: KRPCHS.SpaceCenter.Control -> KRPCStreamReq (Float)
getControlYawStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Control_get_Yaw" [makeArgument 0 thisArg]
in makeStream req
getControlYawStream :: KRPCHS.SpaceCenter.Control -> RPCContext (KRPCStream (Float))
getControlYawStream thisArg = requestStream $ getControlYawStreamReq thisArg
{-
- The state of the abort action group.
-}
setControlAbort :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlAbort thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Abort" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all antennas on the vessel are deployed,
- and sets the deployment state of all antennas.
- See <see cref="M:SpaceCenter.Antenna.Deployed" />.
-}
setControlAntennas :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlAntennas thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Antennas" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the wheel brakes.
-}
setControlBrakes :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlBrakes thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Brakes" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether any of the cargo bays on the vessel are open,
- and sets the open state of all cargo bays.
- See <see cref="M:SpaceCenter.CargoBay.Open" />.
-}
setControlCargoBays :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlCargoBays thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_CargoBays" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the forward translational control.
- A value between -1 and 1.
- Equivalent to the h and n keys.
-}
setControlForward :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlForward thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Forward" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the landing gear/legs.
-}
setControlGear :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlGear thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Gear" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all of the air intakes on the vessel are open,
- and sets the open state of all air intakes.
- See <see cref="M:SpaceCenter.Intake.Open" />.
-}
setControlIntakes :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlIntakes thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Intakes" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all landing legs on the vessel are deployed,
- and sets the deployment state of all landing legs.
- Does not include wheels (for example landing gear).
- See <see cref="M:SpaceCenter.Leg.Deployed" />.
-}
setControlLegs :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlLegs thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Legs" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the lights.
-}
setControlLights :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlLights thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Lights" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all parachutes on the vessel are deployed,
- and sets the deployment state of all parachutes.
- Cannot be set tofalse.
- See <see cref="M:SpaceCenter.Parachute.Deployed" />.
-}
setControlParachutes :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlParachutes thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Parachutes" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the pitch control.
- A value between -1 and 1.
- Equivalent to the w and s keys.
-}
setControlPitch :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlPitch thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Pitch" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of RCS.
-}
setControlRCS :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlRCS thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_RCS" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all radiators on the vessel are deployed,
- and sets the deployment state of all radiators.
- See <see cref="M:SpaceCenter.Radiator.Deployed" />.
-}
setControlRadiators :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlRadiators thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Radiators" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all reactive wheels on the vessel are active,
- and sets the active state of all reaction wheels.
- See <see cref="M:SpaceCenter.ReactionWheel.Active" />.
-}
setControlReactionWheels :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlReactionWheels thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_ReactionWheels" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all of the resource harvesters on the vessel are deployed,
- and sets the deployment state of all resource harvesters.
- See <see cref="M:SpaceCenter.ResourceHarvester.Deployed" />.
-}
setControlResourceHarvesters :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlResourceHarvesters thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_ResourceHarvesters" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether any of the resource harvesters on the vessel are active,
- and sets the active state of all resource harvesters.
- See <see cref="M:SpaceCenter.ResourceHarvester.Active" />.
-}
setControlResourceHarvestersActive :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlResourceHarvestersActive thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_ResourceHarvestersActive" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the right translational control.
- A value between -1 and 1.
- Equivalent to the j and l keys.
-}
setControlRight :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlRight thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Right" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the roll control.
- A value between -1 and 1.
- Equivalent to the q and e keys.
-}
setControlRoll :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlRoll thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Roll" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of SAS.Equivalent to <see cref="M:SpaceCenter.AutoPilot.SAS" />
-}
setControlSAS :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlSAS thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_SAS" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The current <see cref="T:SpaceCenter.SASMode" />.
- These modes are equivalent to the mode buttons to
- the left of the navball that appear when SAS is enabled.Equivalent to <see cref="M:SpaceCenter.AutoPilot.SASMode" />
-}
setControlSASMode :: KRPCHS.SpaceCenter.Control -> KRPCHS.SpaceCenter.SASMode -> RPCContext ()
setControlSASMode thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_SASMode" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all solar panels on the vessel are deployed,
- and sets the deployment state of all solar panels.
- See <see cref="M:SpaceCenter.SolarPanel.Deployed" />.
-}
setControlSolarPanels :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlSolarPanels thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_SolarPanels" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The current <see cref="T:SpaceCenter.SpeedMode" /> of the navball.
- This is the mode displayed next to the speed at the top of the navball.
-}
setControlSpeedMode :: KRPCHS.SpaceCenter.Control -> KRPCHS.SpaceCenter.SpeedMode -> RPCContext ()
setControlSpeedMode thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_SpeedMode" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the throttle. A value between 0 and 1.
-}
setControlThrottle :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlThrottle thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Throttle" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the up translational control.
- A value between -1 and 1.
- Equivalent to the i and k keys.
-}
setControlUp :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlUp thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Up" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the wheel steering.
- A value between -1 and 1.
- A value of 1 steers to the left, and a value of -1 steers to the right.
-}
setControlWheelSteering :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlWheelSteering thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_WheelSteering" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the wheel throttle.
- A value between -1 and 1.
- A value of 1 rotates the wheels forwards, a value of -1 rotates
- the wheels backwards.
-}
setControlWheelThrottle :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlWheelThrottle thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_WheelThrottle" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns whether all wheels on the vessel are deployed,
- and sets the deployment state of all wheels.
- Does not include landing legs.
- See <see cref="M:SpaceCenter.Wheel.Deployed" />.
-}
setControlWheels :: KRPCHS.SpaceCenter.Control -> Bool -> RPCContext ()
setControlWheels thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Wheels" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The state of the yaw control.
- A value between -1 and 1.
- Equivalent to the a and d keys.
-}
setControlYaw :: KRPCHS.SpaceCenter.Control -> Float -> RPCContext ()
setControlYaw thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Control_set_Yaw" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Fires the decoupler. Returns the new vessel created when the decoupler fires.
- Throws an exception if the decoupler has already fired.When called, the active vessel may change. It is therefore possible that,
- after calling this function, the object(s) returned by previous call(s) to
- <see cref="M:SpaceCenter.ActiveVessel" /> no longer refer to the active vessel.
-}
decouplerDecouple :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (KRPCHS.SpaceCenter.Vessel)
decouplerDecouple thisArg = do
let r = makeRequest "SpaceCenter" "Decoupler_Decouple" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
decouplerDecoupleStreamReq :: KRPCHS.SpaceCenter.Decoupler -> KRPCStreamReq (KRPCHS.SpaceCenter.Vessel)
decouplerDecoupleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Decoupler_Decouple" [makeArgument 0 thisArg]
in makeStream req
decouplerDecoupleStream :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Vessel))
decouplerDecoupleStream thisArg = requestStream $ decouplerDecoupleStreamReq thisArg
{-
- Whether the decoupler has fired.
-}
getDecouplerDecoupled :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (Bool)
getDecouplerDecoupled thisArg = do
let r = makeRequest "SpaceCenter" "Decoupler_get_Decoupled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDecouplerDecoupledStreamReq :: KRPCHS.SpaceCenter.Decoupler -> KRPCStreamReq (Bool)
getDecouplerDecoupledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Decoupler_get_Decoupled" [makeArgument 0 thisArg]
in makeStream req
getDecouplerDecoupledStream :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (KRPCStream (Bool))
getDecouplerDecoupledStream thisArg = requestStream $ getDecouplerDecoupledStreamReq thisArg
{-
- The impulse that the decoupler imparts when it is fired, in Newton seconds.
-}
getDecouplerImpulse :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (Float)
getDecouplerImpulse thisArg = do
let r = makeRequest "SpaceCenter" "Decoupler_get_Impulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDecouplerImpulseStreamReq :: KRPCHS.SpaceCenter.Decoupler -> KRPCStreamReq (Float)
getDecouplerImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Decoupler_get_Impulse" [makeArgument 0 thisArg]
in makeStream req
getDecouplerImpulseStream :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (KRPCStream (Float))
getDecouplerImpulseStream thisArg = requestStream $ getDecouplerImpulseStreamReq thisArg
{-
- The part object for this decoupler.
-}
getDecouplerPart :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (KRPCHS.SpaceCenter.Part)
getDecouplerPart thisArg = do
let r = makeRequest "SpaceCenter" "Decoupler_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDecouplerPartStreamReq :: KRPCHS.SpaceCenter.Decoupler -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getDecouplerPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Decoupler_get_Part" [makeArgument 0 thisArg]
in makeStream req
getDecouplerPartStream :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getDecouplerPartStream thisArg = requestStream $ getDecouplerPartStreamReq thisArg
{-
- Whether the decoupler is enabled in the staging sequence.
-}
getDecouplerStaged :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (Bool)
getDecouplerStaged thisArg = do
let r = makeRequest "SpaceCenter" "Decoupler_get_Staged" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDecouplerStagedStreamReq :: KRPCHS.SpaceCenter.Decoupler -> KRPCStreamReq (Bool)
getDecouplerStagedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Decoupler_get_Staged" [makeArgument 0 thisArg]
in makeStream req
getDecouplerStagedStream :: KRPCHS.SpaceCenter.Decoupler -> RPCContext (KRPCStream (Bool))
getDecouplerStagedStream thisArg = requestStream $ getDecouplerStagedStreamReq thisArg
{-
- The direction that docking port points in, in the given reference frame.
-}
dockingPortDirection :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
dockingPortDirection thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "DockingPort_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
dockingPortDirectionStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
dockingPortDirectionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "DockingPort_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
dockingPortDirectionStream :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
dockingPortDirectionStream thisArg referenceFrameArg = requestStream $ dockingPortDirectionStreamReq thisArg referenceFrameArg
{-
- The position of the docking port in the given reference frame.
-}
dockingPortPosition :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
dockingPortPosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "DockingPort_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
dockingPortPositionStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
dockingPortPositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "DockingPort_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
dockingPortPositionStream :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
dockingPortPositionStream thisArg referenceFrameArg = requestStream $ dockingPortPositionStreamReq thisArg referenceFrameArg
{-
- The rotation of the docking port, in the given reference frame.
-}
dockingPortRotation :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double, Double))
dockingPortRotation thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "DockingPort_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
dockingPortRotationStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double, Double))
dockingPortRotationStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "DockingPort_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
dockingPortRotationStream :: KRPCHS.SpaceCenter.DockingPort -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double, Double)))
dockingPortRotationStream thisArg referenceFrameArg = requestStream $ dockingPortRotationStreamReq thisArg referenceFrameArg
{-
- Undocks the docking port and returns the new <see cref="T:SpaceCenter.Vessel" /> that is created.
- This method can be called for either docking port in a docked pair.
- Throws an exception if the docking port is not docked to anything.When called, the active vessel may change. It is therefore possible that,
- after calling this function, the object(s) returned by previous call(s) to
- <see cref="M:SpaceCenter.ActiveVessel" /> no longer refer to the active vessel.
-}
dockingPortUndock :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCHS.SpaceCenter.Vessel)
dockingPortUndock thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_Undock" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
dockingPortUndockStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (KRPCHS.SpaceCenter.Vessel)
dockingPortUndockStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_Undock" [makeArgument 0 thisArg]
in makeStream req
dockingPortUndockStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Vessel))
dockingPortUndockStream thisArg = requestStream $ dockingPortUndockStreamReq thisArg
{-
- The part that this docking port is docked to. Returnsnullif this
- docking port is not docked to anything.
-}
getDockingPortDockedPart :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCHS.SpaceCenter.Part)
getDockingPortDockedPart thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_get_DockedPart" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDockingPortDockedPartStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getDockingPortDockedPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_get_DockedPart" [makeArgument 0 thisArg]
in makeStream req
getDockingPortDockedPartStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getDockingPortDockedPartStream thisArg = requestStream $ getDockingPortDockedPartStreamReq thisArg
{-
- Whether the docking port has a shield.
-}
getDockingPortHasShield :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (Bool)
getDockingPortHasShield thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_get_HasShield" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDockingPortHasShieldStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (Bool)
getDockingPortHasShieldStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_get_HasShield" [makeArgument 0 thisArg]
in makeStream req
getDockingPortHasShieldStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (Bool))
getDockingPortHasShieldStream thisArg = requestStream $ getDockingPortHasShieldStreamReq thisArg
{-
- The part object for this docking port.
-}
getDockingPortPart :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCHS.SpaceCenter.Part)
getDockingPortPart thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDockingPortPartStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getDockingPortPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_get_Part" [makeArgument 0 thisArg]
in makeStream req
getDockingPortPartStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getDockingPortPartStream thisArg = requestStream $ getDockingPortPartStreamReq thisArg
{-
- The distance a docking port must move away when it undocks before it
- becomes ready to dock with another port, in meters.
-}
getDockingPortReengageDistance :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (Float)
getDockingPortReengageDistance thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_get_ReengageDistance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDockingPortReengageDistanceStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (Float)
getDockingPortReengageDistanceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_get_ReengageDistance" [makeArgument 0 thisArg]
in makeStream req
getDockingPortReengageDistanceStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (Float))
getDockingPortReengageDistanceStream thisArg = requestStream $ getDockingPortReengageDistanceStreamReq thisArg
{-
- The reference frame that is fixed relative to this docking port, and
- oriented with the port.
- <list type="bullet">The origin is at the position of the docking port.The axes rotate with the docking port.The x-axis points out to the right side of the docking port.The y-axis points in the direction the docking port is facing.The z-axis points out of the bottom off the docking port.This reference frame is not necessarily equivalent to the reference frame
- for the part, returned by <see cref="M:SpaceCenter.Part.ReferenceFrame" />.
-}
getDockingPortReferenceFrame :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getDockingPortReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_get_ReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDockingPortReferenceFrameStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getDockingPortReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_get_ReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getDockingPortReferenceFrameStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getDockingPortReferenceFrameStream thisArg = requestStream $ getDockingPortReferenceFrameStreamReq thisArg
{-
- The state of the docking ports shield, if it has one.
-
- Returnstrueif the docking port has a shield, and the shield is
- closed. Otherwise returnsfalse. When set totrue, the shield is
- closed, and when set tofalsethe shield is opened. If the docking
- port does not have a shield, setting this attribute has no effect.
-}
getDockingPortShielded :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (Bool)
getDockingPortShielded thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_get_Shielded" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDockingPortShieldedStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (Bool)
getDockingPortShieldedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_get_Shielded" [makeArgument 0 thisArg]
in makeStream req
getDockingPortShieldedStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (Bool))
getDockingPortShieldedStream thisArg = requestStream $ getDockingPortShieldedStreamReq thisArg
{-
- The current state of the docking port.
-}
getDockingPortState :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCHS.SpaceCenter.DockingPortState)
getDockingPortState thisArg = do
let r = makeRequest "SpaceCenter" "DockingPort_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getDockingPortStateStreamReq :: KRPCHS.SpaceCenter.DockingPort -> KRPCStreamReq (KRPCHS.SpaceCenter.DockingPortState)
getDockingPortStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "DockingPort_get_State" [makeArgument 0 thisArg]
in makeStream req
getDockingPortStateStream :: KRPCHS.SpaceCenter.DockingPort -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.DockingPortState))
getDockingPortStateStream thisArg = requestStream $ getDockingPortStateStreamReq thisArg
{-
- The state of the docking ports shield, if it has one.
-
- Returnstrueif the docking port has a shield, and the shield is
- closed. Otherwise returnsfalse. When set totrue, the shield is
- closed, and when set tofalsethe shield is opened. If the docking
- port does not have a shield, setting this attribute has no effect.
-}
setDockingPortShielded :: KRPCHS.SpaceCenter.DockingPort -> Bool -> RPCContext ()
setDockingPortShielded thisArg valueArg = do
let r = makeRequest "SpaceCenter" "DockingPort_set_Shielded" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Toggle the current engine mode.
-}
engineToggleMode :: KRPCHS.SpaceCenter.Engine -> RPCContext ()
engineToggleMode thisArg = do
let r = makeRequest "SpaceCenter" "Engine_ToggleMode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Whether the engine is active. Setting this attribute may have no effect,
- depending on <see cref="M:SpaceCenter.Engine.CanShutdown" /> and <see cref="M:SpaceCenter.Engine.CanRestart" />.
-}
getEngineActive :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineActive thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Active" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineActiveStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Active" [makeArgument 0 thisArg]
in makeStream req
getEngineActiveStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineActiveStream thisArg = requestStream $ getEngineActiveStreamReq thisArg
{-
- Whether the engine will automatically switch modes.
-}
getEngineAutoModeSwitch :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineAutoModeSwitch thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_AutoModeSwitch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineAutoModeSwitchStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineAutoModeSwitchStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_AutoModeSwitch" [makeArgument 0 thisArg]
in makeStream req
getEngineAutoModeSwitchStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineAutoModeSwitchStream thisArg = requestStream $ getEngineAutoModeSwitchStreamReq thisArg
{-
- The amount of thrust, in Newtons, that would be produced by the engine
- when activated and with its throttle set to 100%.
- Returns zero if the engine does not have any fuel.
- Takes the engine's current <see cref="M:SpaceCenter.Engine.ThrustLimit" /> and atmospheric conditions into account.
-}
getEngineAvailableThrust :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineAvailableThrust thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_AvailableThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineAvailableThrustStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineAvailableThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_AvailableThrust" [makeArgument 0 thisArg]
in makeStream req
getEngineAvailableThrustStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineAvailableThrustStream thisArg = requestStream $ getEngineAvailableThrustStreamReq thisArg
{-
- The available torque in the pitch, roll and yaw axes of the vessel, in Newton meters.
- These axes correspond to the coordinate axes of the <see cref="M:SpaceCenter.Vessel.ReferenceFrame" />.
- Returns zero if the engine is inactive, or not gimballed.
-}
getEngineAvailableTorque :: KRPCHS.SpaceCenter.Engine -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getEngineAvailableTorque thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_AvailableTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineAvailableTorqueStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getEngineAvailableTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_AvailableTorque" [makeArgument 0 thisArg]
in makeStream req
getEngineAvailableTorqueStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getEngineAvailableTorqueStream thisArg = requestStream $ getEngineAvailableTorqueStreamReq thisArg
{-
- Whether the engine can be restarted once shutdown. If the engine cannot be shutdown,
- returnsfalse. For example, this istruefor liquid fueled rockets
- andfalsefor solid rocket boosters.
-}
getEngineCanRestart :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineCanRestart thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_CanRestart" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineCanRestartStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineCanRestartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_CanRestart" [makeArgument 0 thisArg]
in makeStream req
getEngineCanRestartStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineCanRestartStream thisArg = requestStream $ getEngineCanRestartStreamReq thisArg
{-
- Whether the engine can be shutdown once activated. For example, this istruefor liquid fueled rockets andfalsefor solid rocket boosters.
-}
getEngineCanShutdown :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineCanShutdown thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_CanShutdown" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineCanShutdownStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineCanShutdownStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_CanShutdown" [makeArgument 0 thisArg]
in makeStream req
getEngineCanShutdownStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineCanShutdownStream thisArg = requestStream $ getEngineCanShutdownStreamReq thisArg
{-
- The gimbal limiter of the engine. A value between 0 and 1.
- Returns 0 if the gimbal is locked.
-}
getEngineGimbalLimit :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineGimbalLimit thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_GimbalLimit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineGimbalLimitStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineGimbalLimitStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_GimbalLimit" [makeArgument 0 thisArg]
in makeStream req
getEngineGimbalLimitStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineGimbalLimitStream thisArg = requestStream $ getEngineGimbalLimitStreamReq thisArg
{-
- Whether the engines gimbal is locked in place. Setting this attribute has
- no effect if the engine is not gimballed.
-}
getEngineGimbalLocked :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineGimbalLocked thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_GimbalLocked" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineGimbalLockedStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineGimbalLockedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_GimbalLocked" [makeArgument 0 thisArg]
in makeStream req
getEngineGimbalLockedStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineGimbalLockedStream thisArg = requestStream $ getEngineGimbalLockedStreamReq thisArg
{-
- The range over which the gimbal can move, in degrees.
- Returns 0 if the engine is not gimballed.
-}
getEngineGimbalRange :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineGimbalRange thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_GimbalRange" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineGimbalRangeStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineGimbalRangeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_GimbalRange" [makeArgument 0 thisArg]
in makeStream req
getEngineGimbalRangeStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineGimbalRangeStream thisArg = requestStream $ getEngineGimbalRangeStreamReq thisArg
{-
- Whether the engine is gimballed.
-}
getEngineGimballed :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineGimballed thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Gimballed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineGimballedStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineGimballedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Gimballed" [makeArgument 0 thisArg]
in makeStream req
getEngineGimballedStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineGimballedStream thisArg = requestStream $ getEngineGimballedStreamReq thisArg
{-
- Whether the engine has any fuel available.The engine must be activated for this property to update correctly.
-}
getEngineHasFuel :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineHasFuel thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_HasFuel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineHasFuelStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineHasFuelStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_HasFuel" [makeArgument 0 thisArg]
in makeStream req
getEngineHasFuelStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineHasFuelStream thisArg = requestStream $ getEngineHasFuelStreamReq thisArg
{-
- Whether the engine has multiple modes of operation.
-}
getEngineHasModes :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineHasModes thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_HasModes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineHasModesStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineHasModesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_HasModes" [makeArgument 0 thisArg]
in makeStream req
getEngineHasModesStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineHasModesStream thisArg = requestStream $ getEngineHasModesStreamReq thisArg
{-
- The specific impulse of the engine at sea level on Kerbin, in seconds.
-}
getEngineKerbinSeaLevelSpecificImpulse :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineKerbinSeaLevelSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_KerbinSeaLevelSpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineKerbinSeaLevelSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineKerbinSeaLevelSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_KerbinSeaLevelSpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getEngineKerbinSeaLevelSpecificImpulseStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineKerbinSeaLevelSpecificImpulseStream thisArg = requestStream $ getEngineKerbinSeaLevelSpecificImpulseStreamReq thisArg
{-
- The amount of thrust, in Newtons, that would be produced by the engine
- when activated and fueled, with its throttle and throttle limiter set to 100%.
-}
getEngineMaxThrust :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineMaxThrust thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_MaxThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineMaxThrustStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineMaxThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_MaxThrust" [makeArgument 0 thisArg]
in makeStream req
getEngineMaxThrustStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineMaxThrustStream thisArg = requestStream $ getEngineMaxThrustStreamReq thisArg
{-
- The maximum amount of thrust that can be produced by the engine in a
- vacuum, in Newtons. This is the amount of thrust produced by the engine
- when activated, <see cref="M:SpaceCenter.Engine.ThrustLimit" /> is set to 100%, the main
- vessel's throttle is set to 100% and the engine is in a vacuum.
-}
getEngineMaxVacuumThrust :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineMaxVacuumThrust thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_MaxVacuumThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineMaxVacuumThrustStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineMaxVacuumThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_MaxVacuumThrust" [makeArgument 0 thisArg]
in makeStream req
getEngineMaxVacuumThrustStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineMaxVacuumThrustStream thisArg = requestStream $ getEngineMaxVacuumThrustStreamReq thisArg
{-
- The name of the current engine mode.
-}
getEngineMode :: KRPCHS.SpaceCenter.Engine -> RPCContext (Data.Text.Text)
getEngineMode thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Mode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineModeStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Data.Text.Text)
getEngineModeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Mode" [makeArgument 0 thisArg]
in makeStream req
getEngineModeStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Data.Text.Text))
getEngineModeStream thisArg = requestStream $ getEngineModeStreamReq thisArg
{-
- The available modes for the engine.
- A dictionary mapping mode names to <see cref="T:SpaceCenter.Engine" /> objects.
-}
getEngineModes :: KRPCHS.SpaceCenter.Engine -> RPCContext (Data.Map.Map (Data.Text.Text) (KRPCHS.SpaceCenter.Engine))
getEngineModes thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Modes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineModesStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Data.Map.Map (Data.Text.Text) (KRPCHS.SpaceCenter.Engine))
getEngineModesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Modes" [makeArgument 0 thisArg]
in makeStream req
getEngineModesStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Data.Map.Map (Data.Text.Text) (KRPCHS.SpaceCenter.Engine)))
getEngineModesStream thisArg = requestStream $ getEngineModesStreamReq thisArg
{-
- The part object for this engine.
-}
getEnginePart :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCHS.SpaceCenter.Part)
getEnginePart thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEnginePartStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getEnginePartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Part" [makeArgument 0 thisArg]
in makeStream req
getEnginePartStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getEnginePartStream thisArg = requestStream $ getEnginePartStreamReq thisArg
{-
- The names of the propellants that the engine consumes.
-}
getEnginePropellantNames :: KRPCHS.SpaceCenter.Engine -> RPCContext ([Data.Text.Text])
getEnginePropellantNames thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_PropellantNames" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEnginePropellantNamesStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq ([Data.Text.Text])
getEnginePropellantNamesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_PropellantNames" [makeArgument 0 thisArg]
in makeStream req
getEnginePropellantNamesStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream ([Data.Text.Text]))
getEnginePropellantNamesStream thisArg = requestStream $ getEnginePropellantNamesStreamReq thisArg
{-
- The ratio of resources that the engine consumes. A dictionary mapping resource names
- to the ratio at which they are consumed by the engine.For example, if the ratios are 0.6 for LiquidFuel and 0.4 for Oxidizer, then for every 0.6 units of
- LiquidFuel that the engine burns, it will burn 0.4 units of Oxidizer.
-}
getEnginePropellantRatios :: KRPCHS.SpaceCenter.Engine -> RPCContext (Data.Map.Map (Data.Text.Text) (Float))
getEnginePropellantRatios thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_PropellantRatios" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEnginePropellantRatiosStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Data.Map.Map (Data.Text.Text) (Float))
getEnginePropellantRatiosStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_PropellantRatios" [makeArgument 0 thisArg]
in makeStream req
getEnginePropellantRatiosStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Data.Map.Map (Data.Text.Text) (Float)))
getEnginePropellantRatiosStream thisArg = requestStream $ getEnginePropellantRatiosStreamReq thisArg
{-
- The propellants that the engine consumes.
-}
getEnginePropellants :: KRPCHS.SpaceCenter.Engine -> RPCContext ([KRPCHS.SpaceCenter.Propellant])
getEnginePropellants thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Propellants" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEnginePropellantsStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq ([KRPCHS.SpaceCenter.Propellant])
getEnginePropellantsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Propellants" [makeArgument 0 thisArg]
in makeStream req
getEnginePropellantsStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Propellant]))
getEnginePropellantsStream thisArg = requestStream $ getEnginePropellantsStreamReq thisArg
{-
- The current specific impulse of the engine, in seconds. Returns zero
- if the engine is not active.
-}
getEngineSpecificImpulse :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_SpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_SpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getEngineSpecificImpulseStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineSpecificImpulseStream thisArg = requestStream $ getEngineSpecificImpulseStreamReq thisArg
{-
- The current throttle setting for the engine. A value between 0 and 1.
- This is not necessarily the same as the vessel's main throttle
- setting, as some engines take time to adjust their throttle
- (such as jet engines).
-}
getEngineThrottle :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineThrottle thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Throttle" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineThrottleStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineThrottleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Throttle" [makeArgument 0 thisArg]
in makeStream req
getEngineThrottleStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineThrottleStream thisArg = requestStream $ getEngineThrottleStreamReq thisArg
{-
- Whether the <see cref="M:SpaceCenter.Control.Throttle" /> affects the engine. For example,
- this istruefor liquid fueled rockets, andfalsefor solid rocket
- boosters.
-}
getEngineThrottleLocked :: KRPCHS.SpaceCenter.Engine -> RPCContext (Bool)
getEngineThrottleLocked thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_ThrottleLocked" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineThrottleLockedStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Bool)
getEngineThrottleLockedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_ThrottleLocked" [makeArgument 0 thisArg]
in makeStream req
getEngineThrottleLockedStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Bool))
getEngineThrottleLockedStream thisArg = requestStream $ getEngineThrottleLockedStreamReq thisArg
{-
- The current amount of thrust being produced by the engine, in Newtons.
-}
getEngineThrust :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineThrust thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Thrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineThrustStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Thrust" [makeArgument 0 thisArg]
in makeStream req
getEngineThrustStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineThrustStream thisArg = requestStream $ getEngineThrustStreamReq thisArg
{-
- The thrust limiter of the engine. A value between 0 and 1. Setting this
- attribute may have no effect, for example the thrust limit for a solid
- rocket booster cannot be changed in flight.
-}
getEngineThrustLimit :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineThrustLimit thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_ThrustLimit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineThrustLimitStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineThrustLimitStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_ThrustLimit" [makeArgument 0 thisArg]
in makeStream req
getEngineThrustLimitStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineThrustLimitStream thisArg = requestStream $ getEngineThrustLimitStreamReq thisArg
{-
- The components of the engine that generate thrust.For example, this corresponds to the rocket nozzel on a solid rocket booster,
- or the individual nozzels on a RAPIER engine.
- The overall thrust produced by the engine, as reported by <see cref="M:SpaceCenter.Engine.AvailableThrust" />,
- <see cref="M:SpaceCenter.Engine.MaxThrust" /> and others, is the sum of the thrust generated by each thruster.
-}
getEngineThrusters :: KRPCHS.SpaceCenter.Engine -> RPCContext ([KRPCHS.SpaceCenter.Thruster])
getEngineThrusters thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_Thrusters" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineThrustersStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq ([KRPCHS.SpaceCenter.Thruster])
getEngineThrustersStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_Thrusters" [makeArgument 0 thisArg]
in makeStream req
getEngineThrustersStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Thruster]))
getEngineThrustersStream thisArg = requestStream $ getEngineThrustersStreamReq thisArg
{-
- The vacuum specific impulse of the engine, in seconds.
-}
getEngineVacuumSpecificImpulse :: KRPCHS.SpaceCenter.Engine -> RPCContext (Float)
getEngineVacuumSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "Engine_get_VacuumSpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getEngineVacuumSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.Engine -> KRPCStreamReq (Float)
getEngineVacuumSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Engine_get_VacuumSpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getEngineVacuumSpecificImpulseStream :: KRPCHS.SpaceCenter.Engine -> RPCContext (KRPCStream (Float))
getEngineVacuumSpecificImpulseStream thisArg = requestStream $ getEngineVacuumSpecificImpulseStreamReq thisArg
{-
- Whether the engine is active. Setting this attribute may have no effect,
- depending on <see cref="M:SpaceCenter.Engine.CanShutdown" /> and <see cref="M:SpaceCenter.Engine.CanRestart" />.
-}
setEngineActive :: KRPCHS.SpaceCenter.Engine -> Bool -> RPCContext ()
setEngineActive thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Engine_set_Active" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the engine will automatically switch modes.
-}
setEngineAutoModeSwitch :: KRPCHS.SpaceCenter.Engine -> Bool -> RPCContext ()
setEngineAutoModeSwitch thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Engine_set_AutoModeSwitch" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The gimbal limiter of the engine. A value between 0 and 1.
- Returns 0 if the gimbal is locked.
-}
setEngineGimbalLimit :: KRPCHS.SpaceCenter.Engine -> Float -> RPCContext ()
setEngineGimbalLimit thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Engine_set_GimbalLimit" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the engines gimbal is locked in place. Setting this attribute has
- no effect if the engine is not gimballed.
-}
setEngineGimbalLocked :: KRPCHS.SpaceCenter.Engine -> Bool -> RPCContext ()
setEngineGimbalLocked thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Engine_set_GimbalLocked" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The name of the current engine mode.
-}
setEngineMode :: KRPCHS.SpaceCenter.Engine -> Data.Text.Text -> RPCContext ()
setEngineMode thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Engine_set_Mode" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The thrust limiter of the engine. A value between 0 and 1. Setting this
- attribute may have no effect, for example the thrust limit for a solid
- rocket booster cannot be changed in flight.
-}
setEngineThrustLimit :: KRPCHS.SpaceCenter.Engine -> Float -> RPCContext ()
setEngineThrustLimit thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Engine_set_ThrustLimit" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Dump the experimental data contained by the experiment.
-}
experimentDump :: KRPCHS.SpaceCenter.Experiment -> RPCContext ()
experimentDump thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_Dump" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Reset the experiment.
-}
experimentReset :: KRPCHS.SpaceCenter.Experiment -> RPCContext ()
experimentReset thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_Reset" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Run the experiment.
-}
experimentRun :: KRPCHS.SpaceCenter.Experiment -> RPCContext ()
experimentRun thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_Run" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Transmit all experimental data contained by this part.
-}
experimentTransmit :: KRPCHS.SpaceCenter.Experiment -> RPCContext ()
experimentTransmit thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_Transmit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Determines if the experiment is available given the current conditions.
-}
getExperimentAvailable :: KRPCHS.SpaceCenter.Experiment -> RPCContext (Bool)
getExperimentAvailable thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_Available" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentAvailableStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (Bool)
getExperimentAvailableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_Available" [makeArgument 0 thisArg]
in makeStream req
getExperimentAvailableStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (Bool))
getExperimentAvailableStream thisArg = requestStream $ getExperimentAvailableStreamReq thisArg
{-
- The name of the biome the experiment is currently in.
-}
getExperimentBiome :: KRPCHS.SpaceCenter.Experiment -> RPCContext (Data.Text.Text)
getExperimentBiome thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_Biome" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentBiomeStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (Data.Text.Text)
getExperimentBiomeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_Biome" [makeArgument 0 thisArg]
in makeStream req
getExperimentBiomeStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (Data.Text.Text))
getExperimentBiomeStream thisArg = requestStream $ getExperimentBiomeStreamReq thisArg
{-
- The data contained in this experiment.
-}
getExperimentData :: KRPCHS.SpaceCenter.Experiment -> RPCContext ([KRPCHS.SpaceCenter.ScienceData])
getExperimentData thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_Data" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentDataStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq ([KRPCHS.SpaceCenter.ScienceData])
getExperimentDataStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_Data" [makeArgument 0 thisArg]
in makeStream req
getExperimentDataStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.ScienceData]))
getExperimentDataStream thisArg = requestStream $ getExperimentDataStreamReq thisArg
{-
- Whether the experiment has been deployed.
-}
getExperimentDeployed :: KRPCHS.SpaceCenter.Experiment -> RPCContext (Bool)
getExperimentDeployed thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentDeployedStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (Bool)
getExperimentDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getExperimentDeployedStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (Bool))
getExperimentDeployedStream thisArg = requestStream $ getExperimentDeployedStreamReq thisArg
{-
- Whether the experiment contains data.
-}
getExperimentHasData :: KRPCHS.SpaceCenter.Experiment -> RPCContext (Bool)
getExperimentHasData thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_HasData" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentHasDataStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (Bool)
getExperimentHasDataStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_HasData" [makeArgument 0 thisArg]
in makeStream req
getExperimentHasDataStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (Bool))
getExperimentHasDataStream thisArg = requestStream $ getExperimentHasDataStreamReq thisArg
{-
- Whether the experiment is inoperable.
-}
getExperimentInoperable :: KRPCHS.SpaceCenter.Experiment -> RPCContext (Bool)
getExperimentInoperable thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_Inoperable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentInoperableStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (Bool)
getExperimentInoperableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_Inoperable" [makeArgument 0 thisArg]
in makeStream req
getExperimentInoperableStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (Bool))
getExperimentInoperableStream thisArg = requestStream $ getExperimentInoperableStreamReq thisArg
{-
- The part object for this experiment.
-}
getExperimentPart :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCHS.SpaceCenter.Part)
getExperimentPart thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentPartStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getExperimentPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_Part" [makeArgument 0 thisArg]
in makeStream req
getExperimentPartStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getExperimentPartStream thisArg = requestStream $ getExperimentPartStreamReq thisArg
{-
- Whether the experiment can be re-run.
-}
getExperimentRerunnable :: KRPCHS.SpaceCenter.Experiment -> RPCContext (Bool)
getExperimentRerunnable thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_Rerunnable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentRerunnableStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (Bool)
getExperimentRerunnableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_Rerunnable" [makeArgument 0 thisArg]
in makeStream req
getExperimentRerunnableStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (Bool))
getExperimentRerunnableStream thisArg = requestStream $ getExperimentRerunnableStreamReq thisArg
{-
- Containing information on the corresponding specific science result for the current conditions.
- Returns null if experiment is unavailable.
-}
getExperimentScienceSubject :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCHS.SpaceCenter.ScienceSubject)
getExperimentScienceSubject thisArg = do
let r = makeRequest "SpaceCenter" "Experiment_get_ScienceSubject" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getExperimentScienceSubjectStreamReq :: KRPCHS.SpaceCenter.Experiment -> KRPCStreamReq (KRPCHS.SpaceCenter.ScienceSubject)
getExperimentScienceSubjectStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Experiment_get_ScienceSubject" [makeArgument 0 thisArg]
in makeStream req
getExperimentScienceSubjectStream :: KRPCHS.SpaceCenter.Experiment -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ScienceSubject))
getExperimentScienceSubjectStream thisArg = requestStream $ getExperimentScienceSubjectStreamReq thisArg
{-
- Jettison the fairing. Has no effect if it has already been jettisoned.
-}
fairingJettison :: KRPCHS.SpaceCenter.Fairing -> RPCContext ()
fairingJettison thisArg = do
let r = makeRequest "SpaceCenter" "Fairing_Jettison" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Whether the fairing has been jettisoned.
-}
getFairingJettisoned :: KRPCHS.SpaceCenter.Fairing -> RPCContext (Bool)
getFairingJettisoned thisArg = do
let r = makeRequest "SpaceCenter" "Fairing_get_Jettisoned" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFairingJettisonedStreamReq :: KRPCHS.SpaceCenter.Fairing -> KRPCStreamReq (Bool)
getFairingJettisonedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Fairing_get_Jettisoned" [makeArgument 0 thisArg]
in makeStream req
getFairingJettisonedStream :: KRPCHS.SpaceCenter.Fairing -> RPCContext (KRPCStream (Bool))
getFairingJettisonedStream thisArg = requestStream $ getFairingJettisonedStreamReq thisArg
{-
- The part object for this fairing.
-}
getFairingPart :: KRPCHS.SpaceCenter.Fairing -> RPCContext (KRPCHS.SpaceCenter.Part)
getFairingPart thisArg = do
let r = makeRequest "SpaceCenter" "Fairing_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFairingPartStreamReq :: KRPCHS.SpaceCenter.Fairing -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getFairingPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Fairing_get_Part" [makeArgument 0 thisArg]
in makeStream req
getFairingPartStream :: KRPCHS.SpaceCenter.Fairing -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getFairingPartStream thisArg = requestStream $ getFairingPartStreamReq thisArg
{-
- The total aerodynamic forces acting on the vessel, as a vector pointing in the direction of the force, with its
- magnitude equal to the strength of the force in Newtons.
-}
getFlightAerodynamicForce :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightAerodynamicForce thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_AerodynamicForce" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightAerodynamicForceStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightAerodynamicForceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_AerodynamicForce" [makeArgument 0 thisArg]
in makeStream req
getFlightAerodynamicForceStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightAerodynamicForceStream thisArg = requestStream $ getFlightAerodynamicForceStreamReq thisArg
{-
- Gets the pitch angle between the orientation of the vessel and its velocity vector, in degrees.
-}
getFlightAngleOfAttack :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightAngleOfAttack thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_AngleOfAttack" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightAngleOfAttackStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightAngleOfAttackStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_AngleOfAttack" [makeArgument 0 thisArg]
in makeStream req
getFlightAngleOfAttackStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightAngleOfAttackStream thisArg = requestStream $ getFlightAngleOfAttackStreamReq thisArg
{-
- The unit direction vector pointing in the anti-normal direction.
-}
getFlightAntiNormal :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightAntiNormal thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_AntiNormal" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightAntiNormalStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightAntiNormalStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_AntiNormal" [makeArgument 0 thisArg]
in makeStream req
getFlightAntiNormalStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightAntiNormalStream thisArg = requestStream $ getFlightAntiNormalStreamReq thisArg
{-
- The unit direction vector pointing in the anti-radial direction.
-}
getFlightAntiRadial :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightAntiRadial thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_AntiRadial" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightAntiRadialStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightAntiRadialStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_AntiRadial" [makeArgument 0 thisArg]
in makeStream req
getFlightAntiRadialStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightAntiRadialStream thisArg = requestStream $ getFlightAntiRadialStreamReq thisArg
{-
- The current density of the atmosphere around the vessel, inkg/m^3.
-}
getFlightAtmosphereDensity :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightAtmosphereDensity thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_AtmosphereDensity" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightAtmosphereDensityStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightAtmosphereDensityStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_AtmosphereDensity" [makeArgument 0 thisArg]
in makeStream req
getFlightAtmosphereDensityStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightAtmosphereDensityStream thisArg = requestStream $ getFlightAtmosphereDensityStreamReq thisArg
{-
- Gets the <a href="https://en.wikipedia.org/wiki/Ballistic_coefficient">ballistic coefficient.Requires <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/19321-105-ferram-aerospace-research-v01557-johnson-21816/">Ferram Aerospace Research.
-}
getFlightBallisticCoefficient :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightBallisticCoefficient thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_BallisticCoefficient" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightBallisticCoefficientStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightBallisticCoefficientStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_BallisticCoefficient" [makeArgument 0 thisArg]
in makeStream req
getFlightBallisticCoefficientStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightBallisticCoefficientStream thisArg = requestStream $ getFlightBallisticCoefficientStreamReq thisArg
{-
- The altitude above the surface of the body, in meters. When over water, this is the altitude above the sea floor.
- Measured from the center of mass of the vessel.
-}
getFlightBedrockAltitude :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightBedrockAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_BedrockAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightBedrockAltitudeStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightBedrockAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_BedrockAltitude" [makeArgument 0 thisArg]
in makeStream req
getFlightBedrockAltitudeStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightBedrockAltitudeStream thisArg = requestStream $ getFlightBedrockAltitudeStreamReq thisArg
{-
- The position of the center of mass of the vessel.
-}
getFlightCenterOfMass :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightCenterOfMass thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_CenterOfMass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightCenterOfMassStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightCenterOfMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_CenterOfMass" [makeArgument 0 thisArg]
in makeStream req
getFlightCenterOfMassStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightCenterOfMassStream thisArg = requestStream $ getFlightCenterOfMassStreamReq thisArg
{-
- The direction vector that the vessel is pointing in.
-}
getFlightDirection :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightDirection thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Direction" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightDirectionStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightDirectionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Direction" [makeArgument 0 thisArg]
in makeStream req
getFlightDirectionStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightDirectionStream thisArg = requestStream $ getFlightDirectionStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Aerodynamic_force">aerodynamic dragcurrently acting on the vessel,
- as a vector pointing in the direction of the force, with its magnitude equal to the strength of the force in Newtons.
-}
getFlightDrag :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightDrag thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Drag" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightDragStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightDragStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Drag" [makeArgument 0 thisArg]
in makeStream req
getFlightDragStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightDragStream thisArg = requestStream $ getFlightDragStreamReq thisArg
{-
- Gets the coefficient of drag. This is the amount of drag produced by the vessel. It depends on air speed,
- air density and wing area.Requires <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/19321-105-ferram-aerospace-research-v01557-johnson-21816/">Ferram Aerospace Research.
-}
getFlightDragCoefficient :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightDragCoefficient thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_DragCoefficient" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightDragCoefficientStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightDragCoefficientStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_DragCoefficient" [makeArgument 0 thisArg]
in makeStream req
getFlightDragCoefficientStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightDragCoefficientStream thisArg = requestStream $ getFlightDragCoefficientStreamReq thisArg
{-
- The dynamic pressure acting on the vessel, in Pascals. This is a measure of the strength of the
- aerodynamic forces. It is equal to\frac{1}{2} . \mbox{air density} . \mbox{velocity}^2.
- It is commonly denotedQ.
-}
getFlightDynamicPressure :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightDynamicPressure thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_DynamicPressure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightDynamicPressureStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightDynamicPressureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_DynamicPressure" [makeArgument 0 thisArg]
in makeStream req
getFlightDynamicPressureStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightDynamicPressureStream thisArg = requestStream $ getFlightDynamicPressureStreamReq thisArg
{-
- The elevation of the terrain under the vessel, in meters. This is the height of the terrain above sea level,
- and is negative when the vessel is over the sea.
-}
getFlightElevation :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightElevation thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Elevation" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightElevationStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightElevationStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Elevation" [makeArgument 0 thisArg]
in makeStream req
getFlightElevationStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightElevationStream thisArg = requestStream $ getFlightElevationStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Equivalent_airspeed">equivalent air speedof the vessel, inm/s.
-}
getFlightEquivalentAirSpeed :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightEquivalentAirSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_EquivalentAirSpeed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightEquivalentAirSpeedStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightEquivalentAirSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_EquivalentAirSpeed" [makeArgument 0 thisArg]
in makeStream req
getFlightEquivalentAirSpeedStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightEquivalentAirSpeedStream thisArg = requestStream $ getFlightEquivalentAirSpeedStreamReq thisArg
{-
- The current G force acting on the vessel inm/s^2.
-}
getFlightGForce :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightGForce thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_GForce" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightGForceStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightGForceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_GForce" [makeArgument 0 thisArg]
in makeStream req
getFlightGForceStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightGForceStream thisArg = requestStream $ getFlightGForceStreamReq thisArg
{-
- The heading angle of the vessel relative to north, in degrees. A value between 0° and 360°.
-}
getFlightHeading :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightHeading thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Heading" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightHeadingStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightHeadingStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Heading" [makeArgument 0 thisArg]
in makeStream req
getFlightHeadingStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightHeadingStream thisArg = requestStream $ getFlightHeadingStreamReq thisArg
{-
- The horizontal speed of the vessel in meters per second.
-}
getFlightHorizontalSpeed :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightHorizontalSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_HorizontalSpeed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightHorizontalSpeedStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightHorizontalSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_HorizontalSpeed" [makeArgument 0 thisArg]
in makeStream req
getFlightHorizontalSpeedStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightHorizontalSpeedStream thisArg = requestStream $ getFlightHorizontalSpeedStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Latitude">latitudeof the vessel for the body being orbited, in degrees.
-}
getFlightLatitude :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightLatitude thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Latitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightLatitudeStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightLatitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Latitude" [makeArgument 0 thisArg]
in makeStream req
getFlightLatitudeStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightLatitudeStream thisArg = requestStream $ getFlightLatitudeStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Aerodynamic_force">aerodynamic liftcurrently acting on the vessel,
- as a vector pointing in the direction of the force, with its magnitude equal to the strength of the force in Newtons.
-}
getFlightLift :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightLift thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Lift" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightLiftStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightLiftStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Lift" [makeArgument 0 thisArg]
in makeStream req
getFlightLiftStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightLiftStream thisArg = requestStream $ getFlightLiftStreamReq thisArg
{-
- Gets the coefficient of lift. This is the amount of lift produced by the vessel, and depends on air speed, air density and wing area.Requires <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/19321-105-ferram-aerospace-research-v01557-johnson-21816/">Ferram Aerospace Research.
-}
getFlightLiftCoefficient :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightLiftCoefficient thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_LiftCoefficient" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightLiftCoefficientStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightLiftCoefficientStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_LiftCoefficient" [makeArgument 0 thisArg]
in makeStream req
getFlightLiftCoefficientStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightLiftCoefficientStream thisArg = requestStream $ getFlightLiftCoefficientStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Longitude">longitudeof the vessel for the body being orbited, in degrees.
-}
getFlightLongitude :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightLongitude thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Longitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightLongitudeStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightLongitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Longitude" [makeArgument 0 thisArg]
in makeStream req
getFlightLongitudeStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightLongitudeStream thisArg = requestStream $ getFlightLongitudeStreamReq thisArg
{-
- The speed of the vessel, in multiples of the speed of sound.
-}
getFlightMach :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightMach thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Mach" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightMachStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightMachStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Mach" [makeArgument 0 thisArg]
in makeStream req
getFlightMachStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightMachStream thisArg = requestStream $ getFlightMachStreamReq thisArg
{-
- The altitude above sea level, in meters.
- Measured from the center of mass of the vessel.
-}
getFlightMeanAltitude :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightMeanAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_MeanAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightMeanAltitudeStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightMeanAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_MeanAltitude" [makeArgument 0 thisArg]
in makeStream req
getFlightMeanAltitudeStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightMeanAltitudeStream thisArg = requestStream $ getFlightMeanAltitudeStreamReq thisArg
{-
- The unit direction vector pointing in the normal direction.
-}
getFlightNormal :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightNormal thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Normal" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightNormalStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightNormalStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Normal" [makeArgument 0 thisArg]
in makeStream req
getFlightNormalStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightNormalStream thisArg = requestStream $ getFlightNormalStreamReq thisArg
{-
- The pitch angle of the vessel relative to the horizon, in degrees. A value between -90° and +90°.
-}
getFlightPitch :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightPitch thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Pitch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightPitchStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightPitchStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Pitch" [makeArgument 0 thisArg]
in makeStream req
getFlightPitchStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightPitchStream thisArg = requestStream $ getFlightPitchStreamReq thisArg
{-
- The unit direction vector pointing in the prograde direction.
-}
getFlightPrograde :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightPrograde thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Prograde" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightProgradeStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightProgradeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Prograde" [makeArgument 0 thisArg]
in makeStream req
getFlightProgradeStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightProgradeStream thisArg = requestStream $ getFlightProgradeStreamReq thisArg
{-
- The unit direction vector pointing in the radial direction.
-}
getFlightRadial :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightRadial thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Radial" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightRadialStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightRadialStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Radial" [makeArgument 0 thisArg]
in makeStream req
getFlightRadialStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightRadialStream thisArg = requestStream $ getFlightRadialStreamReq thisArg
{-
- The unit direction vector pointing in the retrograde direction.
-}
getFlightRetrograde :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightRetrograde thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Retrograde" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightRetrogradeStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightRetrogradeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Retrograde" [makeArgument 0 thisArg]
in makeStream req
getFlightRetrogradeStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightRetrogradeStream thisArg = requestStream $ getFlightRetrogradeStreamReq thisArg
{-
- The vessels Reynolds number.Requires <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/19321-105-ferram-aerospace-research-v01557-johnson-21816/">Ferram Aerospace Research.
-}
getFlightReynoldsNumber :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightReynoldsNumber thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_ReynoldsNumber" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightReynoldsNumberStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightReynoldsNumberStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_ReynoldsNumber" [makeArgument 0 thisArg]
in makeStream req
getFlightReynoldsNumberStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightReynoldsNumberStream thisArg = requestStream $ getFlightReynoldsNumberStreamReq thisArg
{-
- The roll angle of the vessel relative to the horizon, in degrees. A value between -180° and +180°.
-}
getFlightRoll :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightRoll thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Roll" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightRollStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightRollStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Roll" [makeArgument 0 thisArg]
in makeStream req
getFlightRollStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightRollStream thisArg = requestStream $ getFlightRollStreamReq thisArg
{-
- The rotation of the vessel.
-}
getFlightRotation :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double, Double))
getFlightRotation thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Rotation" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightRotationStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double, Double))
getFlightRotationStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Rotation" [makeArgument 0 thisArg]
in makeStream req
getFlightRotationStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double, Double)))
getFlightRotationStream thisArg = requestStream $ getFlightRotationStreamReq thisArg
{-
- Gets the yaw angle between the orientation of the vessel and its velocity vector, in degrees.
-}
getFlightSideslipAngle :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightSideslipAngle thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_SideslipAngle" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightSideslipAngleStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightSideslipAngleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_SideslipAngle" [makeArgument 0 thisArg]
in makeStream req
getFlightSideslipAngleStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightSideslipAngleStream thisArg = requestStream $ getFlightSideslipAngleStreamReq thisArg
{-
- The speed of the vessel in meters per second.
-}
getFlightSpeed :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Speed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightSpeedStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Speed" [makeArgument 0 thisArg]
in makeStream req
getFlightSpeedStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightSpeedStream thisArg = requestStream $ getFlightSpeedStreamReq thisArg
{-
- The speed of sound, in the atmosphere around the vessel, inm/s.
-}
getFlightSpeedOfSound :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightSpeedOfSound thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_SpeedOfSound" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightSpeedOfSoundStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightSpeedOfSoundStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_SpeedOfSound" [makeArgument 0 thisArg]
in makeStream req
getFlightSpeedOfSoundStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightSpeedOfSoundStream thisArg = requestStream $ getFlightSpeedOfSoundStreamReq thisArg
{-
- Gets the current amount of stall, between 0 and 1. A value greater than 0.005 indicates a minor stall
- and a value greater than 0.5 indicates a large-scale stall.Requires <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/19321-105-ferram-aerospace-research-v01557-johnson-21816/">Ferram Aerospace Research.
-}
getFlightStallFraction :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightStallFraction thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_StallFraction" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightStallFractionStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightStallFractionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_StallFraction" [makeArgument 0 thisArg]
in makeStream req
getFlightStallFractionStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightStallFractionStream thisArg = requestStream $ getFlightStallFractionStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Total_air_temperature">static (ambient) temperatureof the
- atmosphere around the vessel, in Kelvin.
-}
getFlightStaticAirTemperature :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightStaticAirTemperature thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_StaticAirTemperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightStaticAirTemperatureStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightStaticAirTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_StaticAirTemperature" [makeArgument 0 thisArg]
in makeStream req
getFlightStaticAirTemperatureStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightStaticAirTemperatureStream thisArg = requestStream $ getFlightStaticAirTemperatureStreamReq thisArg
{-
- The static atmospheric pressure acting on the vessel, in Pascals.
-}
getFlightStaticPressure :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightStaticPressure thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_StaticPressure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightStaticPressureStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightStaticPressureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_StaticPressure" [makeArgument 0 thisArg]
in makeStream req
getFlightStaticPressureStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightStaticPressureStream thisArg = requestStream $ getFlightStaticPressureStreamReq thisArg
{-
- The static atmospheric pressure at mean sea level, in Pascals.
-}
getFlightStaticPressureAtMSL :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightStaticPressureAtMSL thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_StaticPressureAtMSL" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightStaticPressureAtMSLStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightStaticPressureAtMSLStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_StaticPressureAtMSL" [makeArgument 0 thisArg]
in makeStream req
getFlightStaticPressureAtMSLStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightStaticPressureAtMSLStream thisArg = requestStream $ getFlightStaticPressureAtMSLStreamReq thisArg
{-
- The altitude above the surface of the body or sea level, whichever is closer, in meters.
- Measured from the center of mass of the vessel.
-}
getFlightSurfaceAltitude :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightSurfaceAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_SurfaceAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightSurfaceAltitudeStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightSurfaceAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_SurfaceAltitude" [makeArgument 0 thisArg]
in makeStream req
getFlightSurfaceAltitudeStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightSurfaceAltitudeStream thisArg = requestStream $ getFlightSurfaceAltitudeStreamReq thisArg
{-
- An estimate of the current terminal velocity of the vessel, inm/s.
- This is the speed at which the drag forces cancel out the force of gravity.
-}
getFlightTerminalVelocity :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightTerminalVelocity thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_TerminalVelocity" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightTerminalVelocityStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightTerminalVelocityStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_TerminalVelocity" [makeArgument 0 thisArg]
in makeStream req
getFlightTerminalVelocityStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightTerminalVelocityStream thisArg = requestStream $ getFlightTerminalVelocityStreamReq thisArg
{-
- Gets the thrust specific fuel consumption for the jet engines on the vessel. This is a measure of the
- efficiency of the engines, with a lower value indicating a more efficient vessel. This value is the
- number of Newtons of fuel that are burned, per hour, to produce one newton of thrust.Requires <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/19321-105-ferram-aerospace-research-v01557-johnson-21816/">Ferram Aerospace Research.
-}
getFlightThrustSpecificFuelConsumption :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightThrustSpecificFuelConsumption thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_ThrustSpecificFuelConsumption" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightThrustSpecificFuelConsumptionStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightThrustSpecificFuelConsumptionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_ThrustSpecificFuelConsumption" [makeArgument 0 thisArg]
in makeStream req
getFlightThrustSpecificFuelConsumptionStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightThrustSpecificFuelConsumptionStream thisArg = requestStream $ getFlightThrustSpecificFuelConsumptionStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Total_air_temperature">total air temperatureof the atmosphere
- around the vessel, in Kelvin. This temperature includes the <see cref="M:SpaceCenter.Flight.StaticAirTemperature" /> and the vessel's kinetic energy.
-}
getFlightTotalAirTemperature :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightTotalAirTemperature thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_TotalAirTemperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightTotalAirTemperatureStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightTotalAirTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_TotalAirTemperature" [makeArgument 0 thisArg]
in makeStream req
getFlightTotalAirTemperatureStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightTotalAirTemperatureStream thisArg = requestStream $ getFlightTotalAirTemperatureStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/True_airspeed">true air speedof the vessel, inm/s.
-}
getFlightTrueAirSpeed :: KRPCHS.SpaceCenter.Flight -> RPCContext (Float)
getFlightTrueAirSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_TrueAirSpeed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightTrueAirSpeedStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Float)
getFlightTrueAirSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_TrueAirSpeed" [makeArgument 0 thisArg]
in makeStream req
getFlightTrueAirSpeedStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Float))
getFlightTrueAirSpeedStream thisArg = requestStream $ getFlightTrueAirSpeedStreamReq thisArg
{-
- The velocity vector of the vessel. The magnitude of the vector is the speed of the vessel in meters per second.
- The direction of the vector is the direction of the vessels motion.
-}
getFlightVelocity :: KRPCHS.SpaceCenter.Flight -> RPCContext ((Double, Double, Double))
getFlightVelocity thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_Velocity" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightVelocityStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq ((Double, Double, Double))
getFlightVelocityStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_Velocity" [makeArgument 0 thisArg]
in makeStream req
getFlightVelocityStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream ((Double, Double, Double)))
getFlightVelocityStream thisArg = requestStream $ getFlightVelocityStreamReq thisArg
{-
- The vertical speed of the vessel in meters per second.
-}
getFlightVerticalSpeed :: KRPCHS.SpaceCenter.Flight -> RPCContext (Double)
getFlightVerticalSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Flight_get_VerticalSpeed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getFlightVerticalSpeedStreamReq :: KRPCHS.SpaceCenter.Flight -> KRPCStreamReq (Double)
getFlightVerticalSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Flight_get_VerticalSpeed" [makeArgument 0 thisArg]
in makeStream req
getFlightVerticalSpeedStream :: KRPCHS.SpaceCenter.Flight -> RPCContext (KRPCStream (Double))
getFlightVerticalSpeedStream thisArg = requestStream $ getFlightVerticalSpeedStreamReq thisArg
{-
- Remove the force.
-}
forceRemove :: KRPCHS.SpaceCenter.Force -> RPCContext ()
forceRemove thisArg = do
let r = makeRequest "SpaceCenter" "Force_Remove" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- The force vector. The magnitude of the vector is the strength of the force in Newtons.
-}
getForceForceVector :: KRPCHS.SpaceCenter.Force -> RPCContext ((Double, Double, Double))
getForceForceVector thisArg = do
let r = makeRequest "SpaceCenter" "Force_get_ForceVector" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getForceForceVectorStreamReq :: KRPCHS.SpaceCenter.Force -> KRPCStreamReq ((Double, Double, Double))
getForceForceVectorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Force_get_ForceVector" [makeArgument 0 thisArg]
in makeStream req
getForceForceVectorStream :: KRPCHS.SpaceCenter.Force -> RPCContext (KRPCStream ((Double, Double, Double)))
getForceForceVectorStream thisArg = requestStream $ getForceForceVectorStreamReq thisArg
{-
- The part that this force is applied to.
-}
getForcePart :: KRPCHS.SpaceCenter.Force -> RPCContext (KRPCHS.SpaceCenter.Part)
getForcePart thisArg = do
let r = makeRequest "SpaceCenter" "Force_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getForcePartStreamReq :: KRPCHS.SpaceCenter.Force -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getForcePartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Force_get_Part" [makeArgument 0 thisArg]
in makeStream req
getForcePartStream :: KRPCHS.SpaceCenter.Force -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getForcePartStream thisArg = requestStream $ getForcePartStreamReq thisArg
{-
- The position at which the force acts.
-}
getForcePosition :: KRPCHS.SpaceCenter.Force -> RPCContext ((Double, Double, Double))
getForcePosition thisArg = do
let r = makeRequest "SpaceCenter" "Force_get_Position" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getForcePositionStreamReq :: KRPCHS.SpaceCenter.Force -> KRPCStreamReq ((Double, Double, Double))
getForcePositionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Force_get_Position" [makeArgument 0 thisArg]
in makeStream req
getForcePositionStream :: KRPCHS.SpaceCenter.Force -> RPCContext (KRPCStream ((Double, Double, Double)))
getForcePositionStream thisArg = requestStream $ getForcePositionStreamReq thisArg
{-
- The reference frame of the force vector and position.
-}
getForceReferenceFrame :: KRPCHS.SpaceCenter.Force -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getForceReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Force_get_ReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getForceReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Force -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getForceReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Force_get_ReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getForceReferenceFrameStream :: KRPCHS.SpaceCenter.Force -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getForceReferenceFrameStream thisArg = requestStream $ getForceReferenceFrameStreamReq thisArg
{-
- The force vector. The magnitude of the vector is the strength of the force in Newtons.
-}
setForceForceVector :: KRPCHS.SpaceCenter.Force -> (Double, Double, Double) -> RPCContext ()
setForceForceVector thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Force_set_ForceVector" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The position at which the force acts.
-}
setForcePosition :: KRPCHS.SpaceCenter.Force -> (Double, Double, Double) -> RPCContext ()
setForcePosition thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Force_set_Position" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The reference frame of the force vector and position.
-}
setForceReferenceFrame :: KRPCHS.SpaceCenter.Force -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ()
setForceReferenceFrame thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Force_set_ReferenceFrame" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The area of the intake's opening, in square meters.
-}
getIntakeArea :: KRPCHS.SpaceCenter.Intake -> RPCContext (Float)
getIntakeArea thisArg = do
let r = makeRequest "SpaceCenter" "Intake_get_Area" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getIntakeAreaStreamReq :: KRPCHS.SpaceCenter.Intake -> KRPCStreamReq (Float)
getIntakeAreaStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Intake_get_Area" [makeArgument 0 thisArg]
in makeStream req
getIntakeAreaStream :: KRPCHS.SpaceCenter.Intake -> RPCContext (KRPCStream (Float))
getIntakeAreaStream thisArg = requestStream $ getIntakeAreaStreamReq thisArg
{-
- The rate of flow into the intake, in units of resource per second.
-}
getIntakeFlow :: KRPCHS.SpaceCenter.Intake -> RPCContext (Float)
getIntakeFlow thisArg = do
let r = makeRequest "SpaceCenter" "Intake_get_Flow" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getIntakeFlowStreamReq :: KRPCHS.SpaceCenter.Intake -> KRPCStreamReq (Float)
getIntakeFlowStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Intake_get_Flow" [makeArgument 0 thisArg]
in makeStream req
getIntakeFlowStream :: KRPCHS.SpaceCenter.Intake -> RPCContext (KRPCStream (Float))
getIntakeFlowStream thisArg = requestStream $ getIntakeFlowStreamReq thisArg
{-
- Whether the intake is open.
-}
getIntakeOpen :: KRPCHS.SpaceCenter.Intake -> RPCContext (Bool)
getIntakeOpen thisArg = do
let r = makeRequest "SpaceCenter" "Intake_get_Open" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getIntakeOpenStreamReq :: KRPCHS.SpaceCenter.Intake -> KRPCStreamReq (Bool)
getIntakeOpenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Intake_get_Open" [makeArgument 0 thisArg]
in makeStream req
getIntakeOpenStream :: KRPCHS.SpaceCenter.Intake -> RPCContext (KRPCStream (Bool))
getIntakeOpenStream thisArg = requestStream $ getIntakeOpenStreamReq thisArg
{-
- The part object for this intake.
-}
getIntakePart :: KRPCHS.SpaceCenter.Intake -> RPCContext (KRPCHS.SpaceCenter.Part)
getIntakePart thisArg = do
let r = makeRequest "SpaceCenter" "Intake_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getIntakePartStreamReq :: KRPCHS.SpaceCenter.Intake -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getIntakePartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Intake_get_Part" [makeArgument 0 thisArg]
in makeStream req
getIntakePartStream :: KRPCHS.SpaceCenter.Intake -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getIntakePartStream thisArg = requestStream $ getIntakePartStreamReq thisArg
{-
- Speed of the flow into the intake, inm/s.
-}
getIntakeSpeed :: KRPCHS.SpaceCenter.Intake -> RPCContext (Float)
getIntakeSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Intake_get_Speed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getIntakeSpeedStreamReq :: KRPCHS.SpaceCenter.Intake -> KRPCStreamReq (Float)
getIntakeSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Intake_get_Speed" [makeArgument 0 thisArg]
in makeStream req
getIntakeSpeedStream :: KRPCHS.SpaceCenter.Intake -> RPCContext (KRPCStream (Float))
getIntakeSpeedStream thisArg = requestStream $ getIntakeSpeedStreamReq thisArg
{-
- Whether the intake is open.
-}
setIntakeOpen :: KRPCHS.SpaceCenter.Intake -> Bool -> RPCContext ()
setIntakeOpen thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Intake_set_Open" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Releases the docking clamp. Has no effect if the clamp has already been released.
-}
launchClampRelease :: KRPCHS.SpaceCenter.LaunchClamp -> RPCContext ()
launchClampRelease thisArg = do
let r = makeRequest "SpaceCenter" "LaunchClamp_Release" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- The part object for this launch clamp.
-}
getLaunchClampPart :: KRPCHS.SpaceCenter.LaunchClamp -> RPCContext (KRPCHS.SpaceCenter.Part)
getLaunchClampPart thisArg = do
let r = makeRequest "SpaceCenter" "LaunchClamp_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLaunchClampPartStreamReq :: KRPCHS.SpaceCenter.LaunchClamp -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getLaunchClampPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "LaunchClamp_get_Part" [makeArgument 0 thisArg]
in makeStream req
getLaunchClampPartStream :: KRPCHS.SpaceCenter.LaunchClamp -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getLaunchClampPartStream thisArg = requestStream $ getLaunchClampPartStreamReq thisArg
{-
- Launch a vessel.<param name="craftDirectory">Name of the directory in the current saves "Ships" directory, that contains the craft file. For example"VAB"or"SPH".<param name="name">Name of the vessel to launch. This is the name of the ".craft" file in the save directory, without the ".craft" file extension.<param name="launchSite">Name of the launch site. For example"LaunchPad"or"Runway".
-}
launchVessel :: Data.Text.Text -> Data.Text.Text -> Data.Text.Text -> RPCContext ()
launchVessel craftDirectoryArg nameArg launchSiteArg = do
let r = makeRequest "SpaceCenter" "LaunchVessel" [makeArgument 0 craftDirectoryArg, makeArgument 1 nameArg, makeArgument 2 launchSiteArg]
res <- sendRequest r
processResponse res
{-
- Launch a new vessel from the SPH onto the runway.<param name="name">Name of the vessel to launch.This is equivalent to calling <see cref="M:SpaceCenter.LaunchVessel" /> with the craft directory set to "SPH" and the launch site set to "Runway".
-}
launchVesselFromSPH :: Data.Text.Text -> RPCContext ()
launchVesselFromSPH nameArg = do
let r = makeRequest "SpaceCenter" "LaunchVesselFromSPH" [makeArgument 0 nameArg]
res <- sendRequest r
processResponse res
{-
- Launch a new vessel from the VAB onto the launchpad.<param name="name">Name of the vessel to launch.This is equivalent to calling <see cref="M:SpaceCenter.LaunchVessel" /> with the craft directory set to "VAB" and the launch site set to "LaunchPad".
-}
launchVesselFromVAB :: Data.Text.Text -> RPCContext ()
launchVesselFromVAB nameArg = do
let r = makeRequest "SpaceCenter" "LaunchVesselFromVAB" [makeArgument 0 nameArg]
res <- sendRequest r
processResponse res
{-
- Returns a list of vessels from the given <paramref name="craftDirectory" /> that can be launched.<param name="craftDirectory">Name of the directory in the current saves "Ships" directory. For example"VAB"or"SPH".
-}
launchableVessels :: Data.Text.Text -> RPCContext ([Data.Text.Text])
launchableVessels craftDirectoryArg = do
let r = makeRequest "SpaceCenter" "LaunchableVessels" [makeArgument 0 craftDirectoryArg]
res <- sendRequest r
processResponse res
launchableVesselsStreamReq :: Data.Text.Text -> KRPCStreamReq ([Data.Text.Text])
launchableVesselsStreamReq craftDirectoryArg =
let req = makeRequest "SpaceCenter" "LaunchableVessels" [makeArgument 0 craftDirectoryArg]
in makeStream req
launchableVesselsStream :: Data.Text.Text -> RPCContext (KRPCStream ([Data.Text.Text]))
launchableVesselsStream craftDirectoryArg = requestStream $ launchableVesselsStreamReq craftDirectoryArg
{-
- Whether the leg is deployable.
-}
getLegDeployable :: KRPCHS.SpaceCenter.Leg -> RPCContext (Bool)
getLegDeployable thisArg = do
let r = makeRequest "SpaceCenter" "Leg_get_Deployable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLegDeployableStreamReq :: KRPCHS.SpaceCenter.Leg -> KRPCStreamReq (Bool)
getLegDeployableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Leg_get_Deployable" [makeArgument 0 thisArg]
in makeStream req
getLegDeployableStream :: KRPCHS.SpaceCenter.Leg -> RPCContext (KRPCStream (Bool))
getLegDeployableStream thisArg = requestStream $ getLegDeployableStreamReq thisArg
{-
- Whether the landing leg is deployed.Fixed landing legs are always deployed.
- Returns an error if you try to deploy fixed landing gear.
-}
getLegDeployed :: KRPCHS.SpaceCenter.Leg -> RPCContext (Bool)
getLegDeployed thisArg = do
let r = makeRequest "SpaceCenter" "Leg_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLegDeployedStreamReq :: KRPCHS.SpaceCenter.Leg -> KRPCStreamReq (Bool)
getLegDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Leg_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getLegDeployedStream :: KRPCHS.SpaceCenter.Leg -> RPCContext (KRPCStream (Bool))
getLegDeployedStream thisArg = requestStream $ getLegDeployedStreamReq thisArg
{-
- Returns whether the leg is touching the ground.
-}
getLegIsGrounded :: KRPCHS.SpaceCenter.Leg -> RPCContext (Bool)
getLegIsGrounded thisArg = do
let r = makeRequest "SpaceCenter" "Leg_get_IsGrounded" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLegIsGroundedStreamReq :: KRPCHS.SpaceCenter.Leg -> KRPCStreamReq (Bool)
getLegIsGroundedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Leg_get_IsGrounded" [makeArgument 0 thisArg]
in makeStream req
getLegIsGroundedStream :: KRPCHS.SpaceCenter.Leg -> RPCContext (KRPCStream (Bool))
getLegIsGroundedStream thisArg = requestStream $ getLegIsGroundedStreamReq thisArg
{-
- The part object for this landing leg.
-}
getLegPart :: KRPCHS.SpaceCenter.Leg -> RPCContext (KRPCHS.SpaceCenter.Part)
getLegPart thisArg = do
let r = makeRequest "SpaceCenter" "Leg_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLegPartStreamReq :: KRPCHS.SpaceCenter.Leg -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getLegPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Leg_get_Part" [makeArgument 0 thisArg]
in makeStream req
getLegPartStream :: KRPCHS.SpaceCenter.Leg -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getLegPartStream thisArg = requestStream $ getLegPartStreamReq thisArg
{-
- The current state of the landing leg.
-}
getLegState :: KRPCHS.SpaceCenter.Leg -> RPCContext (KRPCHS.SpaceCenter.LegState)
getLegState thisArg = do
let r = makeRequest "SpaceCenter" "Leg_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLegStateStreamReq :: KRPCHS.SpaceCenter.Leg -> KRPCStreamReq (KRPCHS.SpaceCenter.LegState)
getLegStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Leg_get_State" [makeArgument 0 thisArg]
in makeStream req
getLegStateStream :: KRPCHS.SpaceCenter.Leg -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.LegState))
getLegStateStream thisArg = requestStream $ getLegStateStreamReq thisArg
{-
- Whether the landing leg is deployed.Fixed landing legs are always deployed.
- Returns an error if you try to deploy fixed landing gear.
-}
setLegDeployed :: KRPCHS.SpaceCenter.Leg -> Bool -> RPCContext ()
setLegDeployed thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Leg_set_Deployed" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the light is switched on.
-}
getLightActive :: KRPCHS.SpaceCenter.Light -> RPCContext (Bool)
getLightActive thisArg = do
let r = makeRequest "SpaceCenter" "Light_get_Active" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLightActiveStreamReq :: KRPCHS.SpaceCenter.Light -> KRPCStreamReq (Bool)
getLightActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Light_get_Active" [makeArgument 0 thisArg]
in makeStream req
getLightActiveStream :: KRPCHS.SpaceCenter.Light -> RPCContext (KRPCStream (Bool))
getLightActiveStream thisArg = requestStream $ getLightActiveStreamReq thisArg
{-
- The color of the light, as an RGB triple.
-}
getLightColor :: KRPCHS.SpaceCenter.Light -> RPCContext ((Float, Float, Float))
getLightColor thisArg = do
let r = makeRequest "SpaceCenter" "Light_get_Color" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLightColorStreamReq :: KRPCHS.SpaceCenter.Light -> KRPCStreamReq ((Float, Float, Float))
getLightColorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Light_get_Color" [makeArgument 0 thisArg]
in makeStream req
getLightColorStream :: KRPCHS.SpaceCenter.Light -> RPCContext (KRPCStream ((Float, Float, Float)))
getLightColorStream thisArg = requestStream $ getLightColorStreamReq thisArg
{-
- The part object for this light.
-}
getLightPart :: KRPCHS.SpaceCenter.Light -> RPCContext (KRPCHS.SpaceCenter.Part)
getLightPart thisArg = do
let r = makeRequest "SpaceCenter" "Light_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLightPartStreamReq :: KRPCHS.SpaceCenter.Light -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getLightPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Light_get_Part" [makeArgument 0 thisArg]
in makeStream req
getLightPartStream :: KRPCHS.SpaceCenter.Light -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getLightPartStream thisArg = requestStream $ getLightPartStreamReq thisArg
{-
- The current power usage, in units of charge per second.
-}
getLightPowerUsage :: KRPCHS.SpaceCenter.Light -> RPCContext (Float)
getLightPowerUsage thisArg = do
let r = makeRequest "SpaceCenter" "Light_get_PowerUsage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getLightPowerUsageStreamReq :: KRPCHS.SpaceCenter.Light -> KRPCStreamReq (Float)
getLightPowerUsageStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Light_get_PowerUsage" [makeArgument 0 thisArg]
in makeStream req
getLightPowerUsageStream :: KRPCHS.SpaceCenter.Light -> RPCContext (KRPCStream (Float))
getLightPowerUsageStream thisArg = requestStream $ getLightPowerUsageStreamReq thisArg
{-
- Whether the light is switched on.
-}
setLightActive :: KRPCHS.SpaceCenter.Light -> Bool -> RPCContext ()
setLightActive thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Light_set_Active" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The color of the light, as an RGB triple.
-}
setLightColor :: KRPCHS.SpaceCenter.Light -> (Float, Float, Float) -> RPCContext ()
setLightColor thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Light_set_Color" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Load the game with the given name.
- This will create a load a save file calledname.sfsfrom the folder of the current save game.
-}
load :: Data.Text.Text -> RPCContext ()
load nameArg = do
let r = makeRequest "SpaceCenter" "Load" [makeArgument 0 nameArg]
res <- sendRequest r
processResponse res
{-
- Returns the value of a field.<param name="name">Name of the field.
-}
moduleGetField :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (Data.Text.Text)
moduleGetField thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Module_GetField" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
moduleGetFieldStreamReq :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> KRPCStreamReq (Data.Text.Text)
moduleGetFieldStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Module_GetField" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
moduleGetFieldStream :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (KRPCStream (Data.Text.Text))
moduleGetFieldStream thisArg nameArg = requestStream $ moduleGetFieldStreamReq thisArg nameArg
{-
- trueif the part has an action with the given name.<param name="name">
-}
moduleHasAction :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (Bool)
moduleHasAction thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Module_HasAction" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
moduleHasActionStreamReq :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> KRPCStreamReq (Bool)
moduleHasActionStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Module_HasAction" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
moduleHasActionStream :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (KRPCStream (Bool))
moduleHasActionStream thisArg nameArg = requestStream $ moduleHasActionStreamReq thisArg nameArg
{-
- trueif the module has an event with the given name.<param name="name">
-}
moduleHasEvent :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (Bool)
moduleHasEvent thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Module_HasEvent" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
moduleHasEventStreamReq :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> KRPCStreamReq (Bool)
moduleHasEventStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Module_HasEvent" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
moduleHasEventStream :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (KRPCStream (Bool))
moduleHasEventStream thisArg nameArg = requestStream $ moduleHasEventStreamReq thisArg nameArg
{-
- Returnstrueif the module has a field with the given name.<param name="name">Name of the field.
-}
moduleHasField :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (Bool)
moduleHasField thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Module_HasField" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
moduleHasFieldStreamReq :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> KRPCStreamReq (Bool)
moduleHasFieldStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Module_HasField" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
moduleHasFieldStream :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext (KRPCStream (Bool))
moduleHasFieldStream thisArg nameArg = requestStream $ moduleHasFieldStreamReq thisArg nameArg
{-
- Set the value of a field to its original value.<param name="name">Name of the field.
-}
moduleResetField :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext ()
moduleResetField thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Module_ResetField" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
{-
- Set the value of an action with the given name.<param name="name"><param name="value">
-}
moduleSetAction :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> Bool -> RPCContext ()
moduleSetAction thisArg nameArg valueArg = do
let r = makeRequest "SpaceCenter" "Module_SetAction" [makeArgument 0 thisArg, makeArgument 1 nameArg, makeArgument 2 valueArg]
res <- sendRequest r
processResponse res
{-
- Set the value of a field to the given floating point number.<param name="name">Name of the field.<param name="value">Value to set.
-}
moduleSetFieldFloat :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> Float -> RPCContext ()
moduleSetFieldFloat thisArg nameArg valueArg = do
let r = makeRequest "SpaceCenter" "Module_SetFieldFloat" [makeArgument 0 thisArg, makeArgument 1 nameArg, makeArgument 2 valueArg]
res <- sendRequest r
processResponse res
{-
- Set the value of a field to the given integer number.<param name="name">Name of the field.<param name="value">Value to set.
-}
moduleSetFieldInt :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> Data.Int.Int32 -> RPCContext ()
moduleSetFieldInt thisArg nameArg valueArg = do
let r = makeRequest "SpaceCenter" "Module_SetFieldInt" [makeArgument 0 thisArg, makeArgument 1 nameArg, makeArgument 2 valueArg]
res <- sendRequest r
processResponse res
{-
- Set the value of a field to the given string.<param name="name">Name of the field.<param name="value">Value to set.
-}
moduleSetFieldString :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> Data.Text.Text -> RPCContext ()
moduleSetFieldString thisArg nameArg valueArg = do
let r = makeRequest "SpaceCenter" "Module_SetFieldString" [makeArgument 0 thisArg, makeArgument 1 nameArg, makeArgument 2 valueArg]
res <- sendRequest r
processResponse res
{-
- Trigger the named event. Equivalent to clicking the button in the right-click menu of the part.<param name="name">
-}
moduleTriggerEvent :: KRPCHS.SpaceCenter.Module -> Data.Text.Text -> RPCContext ()
moduleTriggerEvent thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Module_TriggerEvent" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
{-
- A list of all the names of the modules actions. These are the parts actions that can be assigned
- to action groups in the in-game editor.
-}
getModuleActions :: KRPCHS.SpaceCenter.Module -> RPCContext ([Data.Text.Text])
getModuleActions thisArg = do
let r = makeRequest "SpaceCenter" "Module_get_Actions" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getModuleActionsStreamReq :: KRPCHS.SpaceCenter.Module -> KRPCStreamReq ([Data.Text.Text])
getModuleActionsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Module_get_Actions" [makeArgument 0 thisArg]
in makeStream req
getModuleActionsStream :: KRPCHS.SpaceCenter.Module -> RPCContext (KRPCStream ([Data.Text.Text]))
getModuleActionsStream thisArg = requestStream $ getModuleActionsStreamReq thisArg
{-
- A list of the names of all of the modules events. Events are the clickable buttons
- visible in the right-click menu of the part.
-}
getModuleEvents :: KRPCHS.SpaceCenter.Module -> RPCContext ([Data.Text.Text])
getModuleEvents thisArg = do
let r = makeRequest "SpaceCenter" "Module_get_Events" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getModuleEventsStreamReq :: KRPCHS.SpaceCenter.Module -> KRPCStreamReq ([Data.Text.Text])
getModuleEventsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Module_get_Events" [makeArgument 0 thisArg]
in makeStream req
getModuleEventsStream :: KRPCHS.SpaceCenter.Module -> RPCContext (KRPCStream ([Data.Text.Text]))
getModuleEventsStream thisArg = requestStream $ getModuleEventsStreamReq thisArg
{-
- The modules field names and their associated values, as a dictionary.
- These are the values visible in the right-click menu of the part.
-}
getModuleFields :: KRPCHS.SpaceCenter.Module -> RPCContext (Data.Map.Map (Data.Text.Text) (Data.Text.Text))
getModuleFields thisArg = do
let r = makeRequest "SpaceCenter" "Module_get_Fields" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getModuleFieldsStreamReq :: KRPCHS.SpaceCenter.Module -> KRPCStreamReq (Data.Map.Map (Data.Text.Text) (Data.Text.Text))
getModuleFieldsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Module_get_Fields" [makeArgument 0 thisArg]
in makeStream req
getModuleFieldsStream :: KRPCHS.SpaceCenter.Module -> RPCContext (KRPCStream (Data.Map.Map (Data.Text.Text) (Data.Text.Text)))
getModuleFieldsStream thisArg = requestStream $ getModuleFieldsStreamReq thisArg
{-
- Name of the PartModule. For example, "ModuleEngines".
-}
getModuleName :: KRPCHS.SpaceCenter.Module -> RPCContext (Data.Text.Text)
getModuleName thisArg = do
let r = makeRequest "SpaceCenter" "Module_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getModuleNameStreamReq :: KRPCHS.SpaceCenter.Module -> KRPCStreamReq (Data.Text.Text)
getModuleNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Module_get_Name" [makeArgument 0 thisArg]
in makeStream req
getModuleNameStream :: KRPCHS.SpaceCenter.Module -> RPCContext (KRPCStream (Data.Text.Text))
getModuleNameStream thisArg = requestStream $ getModuleNameStreamReq thisArg
{-
- The part that contains this module.
-}
getModulePart :: KRPCHS.SpaceCenter.Module -> RPCContext (KRPCHS.SpaceCenter.Part)
getModulePart thisArg = do
let r = makeRequest "SpaceCenter" "Module_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getModulePartStreamReq :: KRPCHS.SpaceCenter.Module -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getModulePartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Module_get_Part" [makeArgument 0 thisArg]
in makeStream req
getModulePartStream :: KRPCHS.SpaceCenter.Module -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getModulePartStream thisArg = requestStream $ getModulePartStreamReq thisArg
{-
- Returns a vector whose direction the direction of the maneuver node burn, and whose magnitude
- is the delta-v of the burn in m/s.<param name="referenceFrame">Does not change when executing the maneuver node. See <see cref="M:SpaceCenter.Node.RemainingBurnVector" />.
-}
nodeBurnVector :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
nodeBurnVector thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Node_BurnVector" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
nodeBurnVectorStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
nodeBurnVectorStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Node_BurnVector" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
nodeBurnVectorStream :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
nodeBurnVectorStream thisArg referenceFrameArg = requestStream $ nodeBurnVectorStreamReq thisArg referenceFrameArg
{-
- Returns the unit direction vector of the maneuver nodes burn in the given reference frame.<param name="referenceFrame">
-}
nodeDirection :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
nodeDirection thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Node_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
nodeDirectionStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
nodeDirectionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Node_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
nodeDirectionStream :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
nodeDirectionStream thisArg referenceFrameArg = requestStream $ nodeDirectionStreamReq thisArg referenceFrameArg
{-
- Returns the position vector of the maneuver node in the given reference frame.<param name="referenceFrame">
-}
nodePosition :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
nodePosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Node_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
nodePositionStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
nodePositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Node_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
nodePositionStream :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
nodePositionStream thisArg referenceFrameArg = requestStream $ nodePositionStreamReq thisArg referenceFrameArg
{-
- Returns a vector whose direction the direction of the maneuver node burn, and whose magnitude
- is the delta-v of the burn in m/s. The direction and magnitude change as the burn is executed.<param name="referenceFrame">
-}
nodeRemainingBurnVector :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
nodeRemainingBurnVector thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Node_RemainingBurnVector" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
nodeRemainingBurnVectorStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
nodeRemainingBurnVectorStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Node_RemainingBurnVector" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
nodeRemainingBurnVectorStream :: KRPCHS.SpaceCenter.Node -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
nodeRemainingBurnVectorStream thisArg referenceFrameArg = requestStream $ nodeRemainingBurnVectorStreamReq thisArg referenceFrameArg
{-
- Removes the maneuver node.
-}
nodeRemove :: KRPCHS.SpaceCenter.Node -> RPCContext ()
nodeRemove thisArg = do
let r = makeRequest "SpaceCenter" "Node_Remove" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- The delta-v of the maneuver node, in meters per second.Does not change when executing the maneuver node. See <see cref="M:SpaceCenter.Node.RemainingDeltaV" />.
-}
getNodeDeltaV :: KRPCHS.SpaceCenter.Node -> RPCContext (Double)
getNodeDeltaV thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_DeltaV" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeDeltaVStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (Double)
getNodeDeltaVStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_DeltaV" [makeArgument 0 thisArg]
in makeStream req
getNodeDeltaVStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (Double))
getNodeDeltaVStream thisArg = requestStream $ getNodeDeltaVStreamReq thisArg
{-
- The magnitude of the maneuver nodes delta-v in the normal direction, in meters per second.
-}
getNodeNormal :: KRPCHS.SpaceCenter.Node -> RPCContext (Double)
getNodeNormal thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_Normal" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeNormalStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (Double)
getNodeNormalStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_Normal" [makeArgument 0 thisArg]
in makeStream req
getNodeNormalStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (Double))
getNodeNormalStream thisArg = requestStream $ getNodeNormalStreamReq thisArg
{-
- The orbit that results from executing the maneuver node.
-}
getNodeOrbit :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCHS.SpaceCenter.Orbit)
getNodeOrbit thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_Orbit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeOrbitStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (KRPCHS.SpaceCenter.Orbit)
getNodeOrbitStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_Orbit" [makeArgument 0 thisArg]
in makeStream req
getNodeOrbitStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Orbit))
getNodeOrbitStream thisArg = requestStream $ getNodeOrbitStreamReq thisArg
{-
- Gets the reference frame that is fixed relative to the maneuver node, and
- orientated with the orbital prograde/normal/radial directions of the
- original orbit at the maneuver node's position.
- <list type="bullet">The origin is at the position of the maneuver node.The x-axis points in the orbital anti-radial direction of the original
- orbit, at the position of the maneuver node.The y-axis points in the orbital prograde direction of the original
- orbit, at the position of the maneuver node.The z-axis points in the orbital normal direction of the original orbit,
- at the position of the maneuver node.
-}
getNodeOrbitalReferenceFrame :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getNodeOrbitalReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_OrbitalReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeOrbitalReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getNodeOrbitalReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_OrbitalReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getNodeOrbitalReferenceFrameStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getNodeOrbitalReferenceFrameStream thisArg = requestStream $ getNodeOrbitalReferenceFrameStreamReq thisArg
{-
- The magnitude of the maneuver nodes delta-v in the prograde direction, in meters per second.
-}
getNodePrograde :: KRPCHS.SpaceCenter.Node -> RPCContext (Double)
getNodePrograde thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_Prograde" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeProgradeStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (Double)
getNodeProgradeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_Prograde" [makeArgument 0 thisArg]
in makeStream req
getNodeProgradeStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (Double))
getNodeProgradeStream thisArg = requestStream $ getNodeProgradeStreamReq thisArg
{-
- The magnitude of the maneuver nodes delta-v in the radial direction, in meters per second.
-}
getNodeRadial :: KRPCHS.SpaceCenter.Node -> RPCContext (Double)
getNodeRadial thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_Radial" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeRadialStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (Double)
getNodeRadialStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_Radial" [makeArgument 0 thisArg]
in makeStream req
getNodeRadialStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (Double))
getNodeRadialStream thisArg = requestStream $ getNodeRadialStreamReq thisArg
{-
- Gets the reference frame that is fixed relative to the maneuver node's burn.
- <list type="bullet">The origin is at the position of the maneuver node.The y-axis points in the direction of the burn.The x-axis and z-axis point in arbitrary but fixed directions.
-}
getNodeReferenceFrame :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getNodeReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_ReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getNodeReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_ReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getNodeReferenceFrameStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getNodeReferenceFrameStream thisArg = requestStream $ getNodeReferenceFrameStreamReq thisArg
{-
- Gets the remaining delta-v of the maneuver node, in meters per second. Changes as the node
- is executed. This is equivalent to the delta-v reported in-game.
-}
getNodeRemainingDeltaV :: KRPCHS.SpaceCenter.Node -> RPCContext (Double)
getNodeRemainingDeltaV thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_RemainingDeltaV" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeRemainingDeltaVStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (Double)
getNodeRemainingDeltaVStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_RemainingDeltaV" [makeArgument 0 thisArg]
in makeStream req
getNodeRemainingDeltaVStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (Double))
getNodeRemainingDeltaVStream thisArg = requestStream $ getNodeRemainingDeltaVStreamReq thisArg
{-
- The time until the maneuver node will be encountered, in seconds.
-}
getNodeTimeTo :: KRPCHS.SpaceCenter.Node -> RPCContext (Double)
getNodeTimeTo thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_TimeTo" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeTimeToStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (Double)
getNodeTimeToStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_TimeTo" [makeArgument 0 thisArg]
in makeStream req
getNodeTimeToStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (Double))
getNodeTimeToStream thisArg = requestStream $ getNodeTimeToStreamReq thisArg
{-
- The universal time at which the maneuver will occur, in seconds.
-}
getNodeUT :: KRPCHS.SpaceCenter.Node -> RPCContext (Double)
getNodeUT thisArg = do
let r = makeRequest "SpaceCenter" "Node_get_UT" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getNodeUTStreamReq :: KRPCHS.SpaceCenter.Node -> KRPCStreamReq (Double)
getNodeUTStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Node_get_UT" [makeArgument 0 thisArg]
in makeStream req
getNodeUTStream :: KRPCHS.SpaceCenter.Node -> RPCContext (KRPCStream (Double))
getNodeUTStream thisArg = requestStream $ getNodeUTStreamReq thisArg
{-
- The delta-v of the maneuver node, in meters per second.Does not change when executing the maneuver node. See <see cref="M:SpaceCenter.Node.RemainingDeltaV" />.
-}
setNodeDeltaV :: KRPCHS.SpaceCenter.Node -> Double -> RPCContext ()
setNodeDeltaV thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Node_set_DeltaV" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The magnitude of the maneuver nodes delta-v in the normal direction, in meters per second.
-}
setNodeNormal :: KRPCHS.SpaceCenter.Node -> Double -> RPCContext ()
setNodeNormal thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Node_set_Normal" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The magnitude of the maneuver nodes delta-v in the prograde direction, in meters per second.
-}
setNodePrograde :: KRPCHS.SpaceCenter.Node -> Double -> RPCContext ()
setNodePrograde thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Node_set_Prograde" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The magnitude of the maneuver nodes delta-v in the radial direction, in meters per second.
-}
setNodeRadial :: KRPCHS.SpaceCenter.Node -> Double -> RPCContext ()
setNodeRadial thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Node_set_Radial" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The universal time at which the maneuver will occur, in seconds.
-}
setNodeUT :: KRPCHS.SpaceCenter.Node -> Double -> RPCContext ()
setNodeUT thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Node_set_UT" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The eccentric anomaly at the given universal time.<param name="ut">The universal time, in seconds.
-}
orbitEccentricAnomalyAtUT :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (Double)
orbitEccentricAnomalyAtUT thisArg utArg = do
let r = makeRequest "SpaceCenter" "Orbit_EccentricAnomalyAtUT" [makeArgument 0 thisArg, makeArgument 1 utArg]
res <- sendRequest r
processResponse res
orbitEccentricAnomalyAtUTStreamReq :: KRPCHS.SpaceCenter.Orbit -> Double -> KRPCStreamReq (Double)
orbitEccentricAnomalyAtUTStreamReq thisArg utArg =
let req = makeRequest "SpaceCenter" "Orbit_EccentricAnomalyAtUT" [makeArgument 0 thisArg, makeArgument 1 utArg]
in makeStream req
orbitEccentricAnomalyAtUTStream :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (KRPCStream (Double))
orbitEccentricAnomalyAtUTStream thisArg utArg = requestStream $ orbitEccentricAnomalyAtUTStreamReq thisArg utArg
{-
- The orbital speed at the given time, in meters per second.<param name="time">Time from now, in seconds.
-}
orbitOrbitalSpeedAt :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (Double)
orbitOrbitalSpeedAt thisArg timeArg = do
let r = makeRequest "SpaceCenter" "Orbit_OrbitalSpeedAt" [makeArgument 0 thisArg, makeArgument 1 timeArg]
res <- sendRequest r
processResponse res
orbitOrbitalSpeedAtStreamReq :: KRPCHS.SpaceCenter.Orbit -> Double -> KRPCStreamReq (Double)
orbitOrbitalSpeedAtStreamReq thisArg timeArg =
let req = makeRequest "SpaceCenter" "Orbit_OrbitalSpeedAt" [makeArgument 0 thisArg, makeArgument 1 timeArg]
in makeStream req
orbitOrbitalSpeedAtStream :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (KRPCStream (Double))
orbitOrbitalSpeedAtStream thisArg timeArg = requestStream $ orbitOrbitalSpeedAtStreamReq thisArg timeArg
{-
- The orbital radius at the point in the orbit given by the true anomaly.<param name="trueAnomaly">The true anomaly.
-}
orbitRadiusAtTrueAnomaly :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (Double)
orbitRadiusAtTrueAnomaly thisArg trueAnomalyArg = do
let r = makeRequest "SpaceCenter" "Orbit_RadiusAtTrueAnomaly" [makeArgument 0 thisArg, makeArgument 1 trueAnomalyArg]
res <- sendRequest r
processResponse res
orbitRadiusAtTrueAnomalyStreamReq :: KRPCHS.SpaceCenter.Orbit -> Double -> KRPCStreamReq (Double)
orbitRadiusAtTrueAnomalyStreamReq thisArg trueAnomalyArg =
let req = makeRequest "SpaceCenter" "Orbit_RadiusAtTrueAnomaly" [makeArgument 0 thisArg, makeArgument 1 trueAnomalyArg]
in makeStream req
orbitRadiusAtTrueAnomalyStream :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (KRPCStream (Double))
orbitRadiusAtTrueAnomalyStream thisArg trueAnomalyArg = requestStream $ orbitRadiusAtTrueAnomalyStreamReq thisArg trueAnomalyArg
{-
- The unit direction vector from which the orbits longitude of ascending node is measured,
- in the given reference frame.<param name="referenceFrame">
-}
orbitReferencePlaneDirection :: KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
orbitReferencePlaneDirection referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Orbit_ReferencePlaneDirection" [makeArgument 0 referenceFrameArg]
res <- sendRequest r
processResponse res
orbitReferencePlaneDirectionStreamReq :: KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
orbitReferencePlaneDirectionStreamReq referenceFrameArg =
let req = makeRequest "SpaceCenter" "Orbit_ReferencePlaneDirection" [makeArgument 0 referenceFrameArg]
in makeStream req
orbitReferencePlaneDirectionStream :: KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
orbitReferencePlaneDirectionStream referenceFrameArg = requestStream $ orbitReferencePlaneDirectionStreamReq referenceFrameArg
{-
- The unit direction vector that is normal to the orbits reference plane, in the given
- reference frame. The reference plane is the plane from which the orbits inclination is measured.<param name="referenceFrame">
-}
orbitReferencePlaneNormal :: KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
orbitReferencePlaneNormal referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Orbit_ReferencePlaneNormal" [makeArgument 0 referenceFrameArg]
res <- sendRequest r
processResponse res
orbitReferencePlaneNormalStreamReq :: KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
orbitReferencePlaneNormalStreamReq referenceFrameArg =
let req = makeRequest "SpaceCenter" "Orbit_ReferencePlaneNormal" [makeArgument 0 referenceFrameArg]
in makeStream req
orbitReferencePlaneNormalStream :: KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
orbitReferencePlaneNormalStream referenceFrameArg = requestStream $ orbitReferencePlaneNormalStreamReq referenceFrameArg
{-
- The true anomaly at the given orbital radius.<param name="radius">The orbital radius in meters.
-}
orbitTrueAnomalyAtRadius :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (Double)
orbitTrueAnomalyAtRadius thisArg radiusArg = do
let r = makeRequest "SpaceCenter" "Orbit_TrueAnomalyAtRadius" [makeArgument 0 thisArg, makeArgument 1 radiusArg]
res <- sendRequest r
processResponse res
orbitTrueAnomalyAtRadiusStreamReq :: KRPCHS.SpaceCenter.Orbit -> Double -> KRPCStreamReq (Double)
orbitTrueAnomalyAtRadiusStreamReq thisArg radiusArg =
let req = makeRequest "SpaceCenter" "Orbit_TrueAnomalyAtRadius" [makeArgument 0 thisArg, makeArgument 1 radiusArg]
in makeStream req
orbitTrueAnomalyAtRadiusStream :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (KRPCStream (Double))
orbitTrueAnomalyAtRadiusStream thisArg radiusArg = requestStream $ orbitTrueAnomalyAtRadiusStreamReq thisArg radiusArg
{-
- The true anomaly at the given time.<param name="ut">The universal time in seconds.
-}
orbitTrueAnomalyAtUT :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (Double)
orbitTrueAnomalyAtUT thisArg utArg = do
let r = makeRequest "SpaceCenter" "Orbit_TrueAnomalyAtUT" [makeArgument 0 thisArg, makeArgument 1 utArg]
res <- sendRequest r
processResponse res
orbitTrueAnomalyAtUTStreamReq :: KRPCHS.SpaceCenter.Orbit -> Double -> KRPCStreamReq (Double)
orbitTrueAnomalyAtUTStreamReq thisArg utArg =
let req = makeRequest "SpaceCenter" "Orbit_TrueAnomalyAtUT" [makeArgument 0 thisArg, makeArgument 1 utArg]
in makeStream req
orbitTrueAnomalyAtUTStream :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (KRPCStream (Double))
orbitTrueAnomalyAtUTStream thisArg utArg = requestStream $ orbitTrueAnomalyAtUTStreamReq thisArg utArg
{-
- The universal time, in seconds, corresponding to the given true anomaly.<param name="trueAnomaly">True anomaly.
-}
orbitUTAtTrueAnomaly :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (Double)
orbitUTAtTrueAnomaly thisArg trueAnomalyArg = do
let r = makeRequest "SpaceCenter" "Orbit_UTAtTrueAnomaly" [makeArgument 0 thisArg, makeArgument 1 trueAnomalyArg]
res <- sendRequest r
processResponse res
orbitUTAtTrueAnomalyStreamReq :: KRPCHS.SpaceCenter.Orbit -> Double -> KRPCStreamReq (Double)
orbitUTAtTrueAnomalyStreamReq thisArg trueAnomalyArg =
let req = makeRequest "SpaceCenter" "Orbit_UTAtTrueAnomaly" [makeArgument 0 thisArg, makeArgument 1 trueAnomalyArg]
in makeStream req
orbitUTAtTrueAnomalyStream :: KRPCHS.SpaceCenter.Orbit -> Double -> RPCContext (KRPCStream (Double))
orbitUTAtTrueAnomalyStream thisArg trueAnomalyArg = requestStream $ orbitUTAtTrueAnomalyStreamReq thisArg trueAnomalyArg
{-
- Gets the apoapsis of the orbit, in meters, from the center of mass of the body being orbited.For the apoapsis altitude reported on the in-game map view, use <see cref="M:SpaceCenter.Orbit.ApoapsisAltitude" />.
-}
getOrbitApoapsis :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitApoapsis thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Apoapsis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitApoapsisStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitApoapsisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Apoapsis" [makeArgument 0 thisArg]
in makeStream req
getOrbitApoapsisStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitApoapsisStream thisArg = requestStream $ getOrbitApoapsisStreamReq thisArg
{-
- The apoapsis of the orbit, in meters, above the sea level of the body being orbited.This is equal to <see cref="M:SpaceCenter.Orbit.Apoapsis" /> minus the equatorial radius of the body.
-}
getOrbitApoapsisAltitude :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitApoapsisAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_ApoapsisAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitApoapsisAltitudeStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitApoapsisAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_ApoapsisAltitude" [makeArgument 0 thisArg]
in makeStream req
getOrbitApoapsisAltitudeStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitApoapsisAltitudeStream thisArg = requestStream $ getOrbitApoapsisAltitudeStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Argument_of_periapsis">argument of periapsis, in radians.
-}
getOrbitArgumentOfPeriapsis :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitArgumentOfPeriapsis thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_ArgumentOfPeriapsis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitArgumentOfPeriapsisStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitArgumentOfPeriapsisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_ArgumentOfPeriapsis" [makeArgument 0 thisArg]
in makeStream req
getOrbitArgumentOfPeriapsisStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitArgumentOfPeriapsisStream thisArg = requestStream $ getOrbitArgumentOfPeriapsisStreamReq thisArg
{-
- The celestial body (e.g. planet or moon) around which the object is orbiting.
-}
getOrbitBody :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCHS.SpaceCenter.CelestialBody)
getOrbitBody thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Body" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitBodyStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (KRPCHS.SpaceCenter.CelestialBody)
getOrbitBodyStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Body" [makeArgument 0 thisArg]
in makeStream req
getOrbitBodyStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CelestialBody))
getOrbitBodyStream thisArg = requestStream $ getOrbitBodyStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Eccentric_anomaly">eccentric anomaly.
-}
getOrbitEccentricAnomaly :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitEccentricAnomaly thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_EccentricAnomaly" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitEccentricAnomalyStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitEccentricAnomalyStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_EccentricAnomaly" [makeArgument 0 thisArg]
in makeStream req
getOrbitEccentricAnomalyStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitEccentricAnomalyStream thisArg = requestStream $ getOrbitEccentricAnomalyStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Orbital_eccentricity">eccentricityof the orbit.
-}
getOrbitEccentricity :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitEccentricity thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Eccentricity" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitEccentricityStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitEccentricityStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Eccentricity" [makeArgument 0 thisArg]
in makeStream req
getOrbitEccentricityStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitEccentricityStream thisArg = requestStream $ getOrbitEccentricityStreamReq thisArg
{-
- The time since the epoch (the point at which the
- <a href="https://en.wikipedia.org/wiki/Mean_anomaly">mean anomaly at epochwas measured, in seconds.
-}
getOrbitEpoch :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitEpoch thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Epoch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitEpochStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitEpochStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Epoch" [makeArgument 0 thisArg]
in makeStream req
getOrbitEpochStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitEpochStream thisArg = requestStream $ getOrbitEpochStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Orbital_inclination">inclinationof the orbit,
- in radians.
-}
getOrbitInclination :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitInclination thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Inclination" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitInclinationStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitInclinationStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Inclination" [makeArgument 0 thisArg]
in makeStream req
getOrbitInclinationStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitInclinationStream thisArg = requestStream $ getOrbitInclinationStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Longitude_of_the_ascending_node">longitude of the
- ascending node, in radians.
-}
getOrbitLongitudeOfAscendingNode :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitLongitudeOfAscendingNode thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_LongitudeOfAscendingNode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitLongitudeOfAscendingNodeStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitLongitudeOfAscendingNodeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_LongitudeOfAscendingNode" [makeArgument 0 thisArg]
in makeStream req
getOrbitLongitudeOfAscendingNodeStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitLongitudeOfAscendingNodeStream thisArg = requestStream $ getOrbitLongitudeOfAscendingNodeStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Mean_anomaly">mean anomaly.
-}
getOrbitMeanAnomaly :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitMeanAnomaly thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_MeanAnomaly" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitMeanAnomalyStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitMeanAnomalyStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_MeanAnomaly" [makeArgument 0 thisArg]
in makeStream req
getOrbitMeanAnomalyStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitMeanAnomalyStream thisArg = requestStream $ getOrbitMeanAnomalyStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/Mean_anomaly">mean anomaly at epoch.
-}
getOrbitMeanAnomalyAtEpoch :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitMeanAnomalyAtEpoch thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_MeanAnomalyAtEpoch" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitMeanAnomalyAtEpochStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitMeanAnomalyAtEpochStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_MeanAnomalyAtEpoch" [makeArgument 0 thisArg]
in makeStream req
getOrbitMeanAnomalyAtEpochStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitMeanAnomalyAtEpochStream thisArg = requestStream $ getOrbitMeanAnomalyAtEpochStreamReq thisArg
{-
- If the object is going to change sphere of influence in the future, returns the new orbit
- after the change. Otherwise returnsnull.
-}
getOrbitNextOrbit :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCHS.SpaceCenter.Orbit)
getOrbitNextOrbit thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_NextOrbit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitNextOrbitStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (KRPCHS.SpaceCenter.Orbit)
getOrbitNextOrbitStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_NextOrbit" [makeArgument 0 thisArg]
in makeStream req
getOrbitNextOrbitStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Orbit))
getOrbitNextOrbitStream thisArg = requestStream $ getOrbitNextOrbitStreamReq thisArg
{-
- The current orbital speed in meters per second.
-}
getOrbitOrbitalSpeed :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitOrbitalSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_OrbitalSpeed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitOrbitalSpeedStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitOrbitalSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_OrbitalSpeed" [makeArgument 0 thisArg]
in makeStream req
getOrbitOrbitalSpeedStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitOrbitalSpeedStream thisArg = requestStream $ getOrbitOrbitalSpeedStreamReq thisArg
{-
- The periapsis of the orbit, in meters, from the center of mass of the body being orbited.For the periapsis altitude reported on the in-game map view, use <see cref="M:SpaceCenter.Orbit.PeriapsisAltitude" />.
-}
getOrbitPeriapsis :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitPeriapsis thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Periapsis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitPeriapsisStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitPeriapsisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Periapsis" [makeArgument 0 thisArg]
in makeStream req
getOrbitPeriapsisStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitPeriapsisStream thisArg = requestStream $ getOrbitPeriapsisStreamReq thisArg
{-
- The periapsis of the orbit, in meters, above the sea level of the body being orbited.This is equal to <see cref="M:SpaceCenter.Orbit.Periapsis" /> minus the equatorial radius of the body.
-}
getOrbitPeriapsisAltitude :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitPeriapsisAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_PeriapsisAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitPeriapsisAltitudeStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitPeriapsisAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_PeriapsisAltitude" [makeArgument 0 thisArg]
in makeStream req
getOrbitPeriapsisAltitudeStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitPeriapsisAltitudeStream thisArg = requestStream $ getOrbitPeriapsisAltitudeStreamReq thisArg
{-
- The orbital period, in seconds.
-}
getOrbitPeriod :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitPeriod thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Period" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitPeriodStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitPeriodStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Period" [makeArgument 0 thisArg]
in makeStream req
getOrbitPeriodStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitPeriodStream thisArg = requestStream $ getOrbitPeriodStreamReq thisArg
{-
- The current radius of the orbit, in meters. This is the distance between the center
- of mass of the object in orbit, and the center of mass of the body around which it is orbiting.This value will change over time if the orbit is elliptical.
-}
getOrbitRadius :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitRadius thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Radius" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitRadiusStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitRadiusStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Radius" [makeArgument 0 thisArg]
in makeStream req
getOrbitRadiusStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitRadiusStream thisArg = requestStream $ getOrbitRadiusStreamReq thisArg
{-
- The semi-major axis of the orbit, in meters.
-}
getOrbitSemiMajorAxis :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitSemiMajorAxis thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_SemiMajorAxis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitSemiMajorAxisStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitSemiMajorAxisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_SemiMajorAxis" [makeArgument 0 thisArg]
in makeStream req
getOrbitSemiMajorAxisStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitSemiMajorAxisStream thisArg = requestStream $ getOrbitSemiMajorAxisStreamReq thisArg
{-
- The semi-minor axis of the orbit, in meters.
-}
getOrbitSemiMinorAxis :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitSemiMinorAxis thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_SemiMinorAxis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitSemiMinorAxisStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitSemiMinorAxisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_SemiMinorAxis" [makeArgument 0 thisArg]
in makeStream req
getOrbitSemiMinorAxisStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitSemiMinorAxisStream thisArg = requestStream $ getOrbitSemiMinorAxisStreamReq thisArg
{-
- The current orbital speed of the object in meters per second.This value will change over time if the orbit is elliptical.
-}
getOrbitSpeed :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitSpeed thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_Speed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitSpeedStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitSpeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_Speed" [makeArgument 0 thisArg]
in makeStream req
getOrbitSpeedStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitSpeedStream thisArg = requestStream $ getOrbitSpeedStreamReq thisArg
{-
- The time until the object reaches apoapsis, in seconds.
-}
getOrbitTimeToApoapsis :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitTimeToApoapsis thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_TimeToApoapsis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitTimeToApoapsisStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitTimeToApoapsisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_TimeToApoapsis" [makeArgument 0 thisArg]
in makeStream req
getOrbitTimeToApoapsisStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitTimeToApoapsisStream thisArg = requestStream $ getOrbitTimeToApoapsisStreamReq thisArg
{-
- The time until the object reaches periapsis, in seconds.
-}
getOrbitTimeToPeriapsis :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitTimeToPeriapsis thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_TimeToPeriapsis" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitTimeToPeriapsisStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitTimeToPeriapsisStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_TimeToPeriapsis" [makeArgument 0 thisArg]
in makeStream req
getOrbitTimeToPeriapsisStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitTimeToPeriapsisStream thisArg = requestStream $ getOrbitTimeToPeriapsisStreamReq thisArg
{-
- The time until the object changes sphere of influence, in seconds. ReturnsNaNif the
- object is not going to change sphere of influence.
-}
getOrbitTimeToSOIChange :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitTimeToSOIChange thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_TimeToSOIChange" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitTimeToSOIChangeStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitTimeToSOIChangeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_TimeToSOIChange" [makeArgument 0 thisArg]
in makeStream req
getOrbitTimeToSOIChangeStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitTimeToSOIChangeStream thisArg = requestStream $ getOrbitTimeToSOIChangeStreamReq thisArg
{-
- The <a href="https://en.wikipedia.org/wiki/True_anomaly">true anomaly.
-}
getOrbitTrueAnomaly :: KRPCHS.SpaceCenter.Orbit -> RPCContext (Double)
getOrbitTrueAnomaly thisArg = do
let r = makeRequest "SpaceCenter" "Orbit_get_TrueAnomaly" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getOrbitTrueAnomalyStreamReq :: KRPCHS.SpaceCenter.Orbit -> KRPCStreamReq (Double)
getOrbitTrueAnomalyStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Orbit_get_TrueAnomaly" [makeArgument 0 thisArg]
in makeStream req
getOrbitTrueAnomalyStream :: KRPCHS.SpaceCenter.Orbit -> RPCContext (KRPCStream (Double))
getOrbitTrueAnomalyStream thisArg = requestStream $ getOrbitTrueAnomalyStreamReq thisArg
{-
- Deploys the parachute. This has no effect if the parachute has already
- been armed or deployed. Only applicable to RealChutes parachutes.
-}
parachuteArm :: KRPCHS.SpaceCenter.Parachute -> RPCContext ()
parachuteArm thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_Arm" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Deploys the parachute. This has no effect if the parachute has already
- been deployed.
-}
parachuteDeploy :: KRPCHS.SpaceCenter.Parachute -> RPCContext ()
parachuteDeploy thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_Deploy" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Whether the parachute has been armed or deployed. Only applicable to RealChutes parachutes.
-}
getParachuteArmed :: KRPCHS.SpaceCenter.Parachute -> RPCContext (Bool)
getParachuteArmed thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_get_Armed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getParachuteArmedStreamReq :: KRPCHS.SpaceCenter.Parachute -> KRPCStreamReq (Bool)
getParachuteArmedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parachute_get_Armed" [makeArgument 0 thisArg]
in makeStream req
getParachuteArmedStream :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCStream (Bool))
getParachuteArmedStream thisArg = requestStream $ getParachuteArmedStreamReq thisArg
{-
- The altitude at which the parachute will full deploy, in meters.
- Only applicable to stock parachutes.
-}
getParachuteDeployAltitude :: KRPCHS.SpaceCenter.Parachute -> RPCContext (Float)
getParachuteDeployAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_get_DeployAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getParachuteDeployAltitudeStreamReq :: KRPCHS.SpaceCenter.Parachute -> KRPCStreamReq (Float)
getParachuteDeployAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parachute_get_DeployAltitude" [makeArgument 0 thisArg]
in makeStream req
getParachuteDeployAltitudeStream :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCStream (Float))
getParachuteDeployAltitudeStream thisArg = requestStream $ getParachuteDeployAltitudeStreamReq thisArg
{-
- The minimum pressure at which the parachute will semi-deploy, in atmospheres.
- Only applicable to stock parachutes.
-}
getParachuteDeployMinPressure :: KRPCHS.SpaceCenter.Parachute -> RPCContext (Float)
getParachuteDeployMinPressure thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_get_DeployMinPressure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getParachuteDeployMinPressureStreamReq :: KRPCHS.SpaceCenter.Parachute -> KRPCStreamReq (Float)
getParachuteDeployMinPressureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parachute_get_DeployMinPressure" [makeArgument 0 thisArg]
in makeStream req
getParachuteDeployMinPressureStream :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCStream (Float))
getParachuteDeployMinPressureStream thisArg = requestStream $ getParachuteDeployMinPressureStreamReq thisArg
{-
- Whether the parachute has been deployed.
-}
getParachuteDeployed :: KRPCHS.SpaceCenter.Parachute -> RPCContext (Bool)
getParachuteDeployed thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getParachuteDeployedStreamReq :: KRPCHS.SpaceCenter.Parachute -> KRPCStreamReq (Bool)
getParachuteDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parachute_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getParachuteDeployedStream :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCStream (Bool))
getParachuteDeployedStream thisArg = requestStream $ getParachuteDeployedStreamReq thisArg
{-
- The part object for this parachute.
-}
getParachutePart :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCHS.SpaceCenter.Part)
getParachutePart thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getParachutePartStreamReq :: KRPCHS.SpaceCenter.Parachute -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getParachutePartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parachute_get_Part" [makeArgument 0 thisArg]
in makeStream req
getParachutePartStream :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getParachutePartStream thisArg = requestStream $ getParachutePartStreamReq thisArg
{-
- The current state of the parachute.
-}
getParachuteState :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCHS.SpaceCenter.ParachuteState)
getParachuteState thisArg = do
let r = makeRequest "SpaceCenter" "Parachute_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getParachuteStateStreamReq :: KRPCHS.SpaceCenter.Parachute -> KRPCStreamReq (KRPCHS.SpaceCenter.ParachuteState)
getParachuteStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parachute_get_State" [makeArgument 0 thisArg]
in makeStream req
getParachuteStateStream :: KRPCHS.SpaceCenter.Parachute -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ParachuteState))
getParachuteStateStream thisArg = requestStream $ getParachuteStateStreamReq thisArg
{-
- The altitude at which the parachute will full deploy, in meters.
- Only applicable to stock parachutes.
-}
setParachuteDeployAltitude :: KRPCHS.SpaceCenter.Parachute -> Float -> RPCContext ()
setParachuteDeployAltitude thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Parachute_set_DeployAltitude" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The minimum pressure at which the parachute will semi-deploy, in atmospheres.
- Only applicable to stock parachutes.
-}
setParachuteDeployMinPressure :: KRPCHS.SpaceCenter.Parachute -> Float -> RPCContext ()
setParachuteDeployMinPressure thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Parachute_set_DeployMinPressure" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Exert a constant force on the part, acting at the given position.
- Returns an object that can be used to remove or modify the force.
-}
partAddForce :: KRPCHS.SpaceCenter.Part -> (Double, Double, Double) -> (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCHS.SpaceCenter.Force)
partAddForce thisArg forceArg positionArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_AddForce" [makeArgument 0 thisArg, makeArgument 1 forceArg, makeArgument 2 positionArg, makeArgument 3 referenceFrameArg]
res <- sendRequest r
processResponse res
partAddForceStreamReq :: KRPCHS.SpaceCenter.Part -> (Double, Double, Double) -> (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq (KRPCHS.SpaceCenter.Force)
partAddForceStreamReq thisArg forceArg positionArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Part_AddForce" [makeArgument 0 thisArg, makeArgument 1 forceArg, makeArgument 2 positionArg, makeArgument 3 referenceFrameArg]
in makeStream req
partAddForceStream :: KRPCHS.SpaceCenter.Part -> (Double, Double, Double) -> (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Force))
partAddForceStream thisArg forceArg positionArg referenceFrameArg = requestStream $ partAddForceStreamReq thisArg forceArg positionArg referenceFrameArg
{-
- The axis-aligned bounding box of the vessel in the given reference frame.
- Returns the minimum and maximum vertices of the box.<param name="referenceFrame">This is computed from the collision meshes of the part.
- If the part is not collidable, the box has zero volume and is centered on
- the <see cref="M:SpaceCenter.Part.Position" /> of the part.
-}
partBoundingBox :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
partBoundingBox thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_BoundingBox" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
partBoundingBoxStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
partBoundingBoxStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Part_BoundingBox" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
partBoundingBoxStream :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
partBoundingBoxStream thisArg referenceFrameArg = requestStream $ partBoundingBoxStreamReq thisArg referenceFrameArg
{-
- The position of the parts center of mass in the given reference frame.
- If the part is physicsless, this is equivalent to <see cref="M:SpaceCenter.Part.Position" />.<param name="referenceFrame">
-}
partCenterOfMass :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
partCenterOfMass thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_CenterOfMass" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
partCenterOfMassStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
partCenterOfMassStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Part_CenterOfMass" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
partCenterOfMassStream :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
partCenterOfMassStream thisArg referenceFrameArg = requestStream $ partCenterOfMassStreamReq thisArg referenceFrameArg
{-
- The direction of the part in the given reference frame.<param name="referenceFrame">
-}
partDirection :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
partDirection thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
partDirectionStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
partDirectionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Part_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
partDirectionStream :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
partDirectionStream thisArg referenceFrameArg = requestStream $ partDirectionStreamReq thisArg referenceFrameArg
{-
- Exert an instantaneous force on the part, acting at the given position.The force is applied instantaneously in a single physics update.
-}
partInstantaneousForce :: KRPCHS.SpaceCenter.Part -> (Double, Double, Double) -> (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ()
partInstantaneousForce thisArg forceArg positionArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_InstantaneousForce" [makeArgument 0 thisArg, makeArgument 1 forceArg, makeArgument 2 positionArg, makeArgument 3 referenceFrameArg]
res <- sendRequest r
processResponse res
{-
- The position of the part in the given reference frame.This is a fixed position in the part, defined by the parts model.
- It s not necessarily the same as the parts center of mass.
- Use <see cref="M:SpaceCenter.Part.CenterOfMass" /> to get the parts center of mass.<param name="referenceFrame">
-}
partPosition :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
partPosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
partPositionStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
partPositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Part_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
partPositionStream :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
partPositionStream thisArg referenceFrameArg = requestStream $ partPositionStreamReq thisArg referenceFrameArg
{-
- The rotation of the part in the given reference frame.<param name="referenceFrame">
-}
partRotation :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double, Double))
partRotation thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
partRotationStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double, Double))
partRotationStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Part_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
partRotationStream :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double, Double)))
partRotationStream thisArg referenceFrameArg = requestStream $ partRotationStreamReq thisArg referenceFrameArg
{-
- The velocity of the part in the given reference frame.<param name="referenceFrame">
-}
partVelocity :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
partVelocity thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Part_Velocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
partVelocityStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
partVelocityStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Part_Velocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
partVelocityStream :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
partVelocityStream thisArg referenceFrameArg = requestStream $ partVelocityStreamReq thisArg referenceFrameArg
{-
- A <see cref="T:SpaceCenter.Antenna" /> if the part is an antenna, otherwisenull.
-}
getPartAntenna :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Antenna)
getPartAntenna thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Antenna" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartAntennaStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Antenna)
getPartAntennaStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Antenna" [makeArgument 0 thisArg]
in makeStream req
getPartAntennaStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Antenna))
getPartAntennaStream thisArg = requestStream $ getPartAntennaStreamReq thisArg
{-
- Whether the part is axially attached to its parent, i.e. on the top
- or bottom of its parent. If the part has no parent, returnsfalse.
-}
getPartAxiallyAttached :: KRPCHS.SpaceCenter.Part -> RPCContext (Bool)
getPartAxiallyAttached thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_AxiallyAttached" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartAxiallyAttachedStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Bool)
getPartAxiallyAttachedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_AxiallyAttached" [makeArgument 0 thisArg]
in makeStream req
getPartAxiallyAttachedStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Bool))
getPartAxiallyAttachedStream thisArg = requestStream $ getPartAxiallyAttachedStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.CargoBay" /> if the part is a cargo bay, otherwisenull.
-}
getPartCargoBay :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.CargoBay)
getPartCargoBay thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_CargoBay" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartCargoBayStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.CargoBay)
getPartCargoBayStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_CargoBay" [makeArgument 0 thisArg]
in makeStream req
getPartCargoBayStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CargoBay))
getPartCargoBayStream thisArg = requestStream $ getPartCargoBayStreamReq thisArg
{-
- The reference frame that is fixed relative to this part, and centered on its center of mass.
- <list type="bullet">The origin is at the center of mass of the part, as returned by <see cref="M:SpaceCenter.Part.CenterOfMass" />.The axes rotate with the part.The x, y and z axis directions depend on the design of the part.For docking port parts, this reference frame is not necessarily equivalent to the reference frame
- for the docking port, returned by <see cref="M:SpaceCenter.DockingPort.ReferenceFrame" />.
-}
getPartCenterOfMassReferenceFrame :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getPartCenterOfMassReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_CenterOfMassReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartCenterOfMassReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getPartCenterOfMassReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_CenterOfMassReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getPartCenterOfMassReferenceFrameStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getPartCenterOfMassReferenceFrameStream thisArg = requestStream $ getPartCenterOfMassReferenceFrameStreamReq thisArg
{-
- The parts children. Returns an empty list if the part has no children.
- This, in combination with <see cref="M:SpaceCenter.Part.Parent" />, can be used to traverse the vessels parts tree.
-}
getPartChildren :: KRPCHS.SpaceCenter.Part -> RPCContext ([KRPCHS.SpaceCenter.Part])
getPartChildren thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Children" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartChildrenStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
getPartChildrenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Children" [makeArgument 0 thisArg]
in makeStream req
getPartChildrenStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
getPartChildrenStream thisArg = requestStream $ getPartChildrenStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.ControlSurface" /> if the part is an aerodynamic control surface, otherwisenull.
-}
getPartControlSurface :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.ControlSurface)
getPartControlSurface thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ControlSurface" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartControlSurfaceStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.ControlSurface)
getPartControlSurfaceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ControlSurface" [makeArgument 0 thisArg]
in makeStream req
getPartControlSurfaceStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ControlSurface))
getPartControlSurfaceStream thisArg = requestStream $ getPartControlSurfaceStreamReq thisArg
{-
- The cost of the part, in units of funds.
-}
getPartCost :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartCost thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Cost" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartCostStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartCostStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Cost" [makeArgument 0 thisArg]
in makeStream req
getPartCostStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartCostStream thisArg = requestStream $ getPartCostStreamReq thisArg
{-
- Whether this part is crossfeed capable.
-}
getPartCrossfeed :: KRPCHS.SpaceCenter.Part -> RPCContext (Bool)
getPartCrossfeed thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Crossfeed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartCrossfeedStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Bool)
getPartCrossfeedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Crossfeed" [makeArgument 0 thisArg]
in makeStream req
getPartCrossfeedStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Bool))
getPartCrossfeedStream thisArg = requestStream $ getPartCrossfeedStreamReq thisArg
{-
- The stage in which this part will be decoupled. Returns -1 if the part is never decoupled from the vessel.
-}
getPartDecoupleStage :: KRPCHS.SpaceCenter.Part -> RPCContext (Data.Int.Int32)
getPartDecoupleStage thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_DecoupleStage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartDecoupleStageStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Data.Int.Int32)
getPartDecoupleStageStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_DecoupleStage" [makeArgument 0 thisArg]
in makeStream req
getPartDecoupleStageStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Data.Int.Int32))
getPartDecoupleStageStream thisArg = requestStream $ getPartDecoupleStageStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Decoupler" /> if the part is a decoupler, otherwisenull.
-}
getPartDecoupler :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Decoupler)
getPartDecoupler thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Decoupler" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartDecouplerStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Decoupler)
getPartDecouplerStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Decoupler" [makeArgument 0 thisArg]
in makeStream req
getPartDecouplerStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Decoupler))
getPartDecouplerStream thisArg = requestStream $ getPartDecouplerStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.DockingPort" /> if the part is a docking port, otherwisenull.
-}
getPartDockingPort :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.DockingPort)
getPartDockingPort thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_DockingPort" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartDockingPortStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.DockingPort)
getPartDockingPortStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_DockingPort" [makeArgument 0 thisArg]
in makeStream req
getPartDockingPortStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.DockingPort))
getPartDockingPortStream thisArg = requestStream $ getPartDockingPortStreamReq thisArg
{-
- The mass of the part, not including any resources it contains, in kilograms. Returns zero if the part is massless.
-}
getPartDryMass :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartDryMass thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_DryMass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartDryMassStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartDryMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_DryMass" [makeArgument 0 thisArg]
in makeStream req
getPartDryMassStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartDryMassStream thisArg = requestStream $ getPartDryMassStreamReq thisArg
{-
- The dynamic pressure acting on the part, in Pascals.
-}
getPartDynamicPressure :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartDynamicPressure thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_DynamicPressure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartDynamicPressureStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartDynamicPressureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_DynamicPressure" [makeArgument 0 thisArg]
in makeStream req
getPartDynamicPressureStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartDynamicPressureStream thisArg = requestStream $ getPartDynamicPressureStreamReq thisArg
{-
- An <see cref="T:SpaceCenter.Engine" /> if the part is an engine, otherwisenull.
-}
getPartEngine :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Engine)
getPartEngine thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Engine" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartEngineStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Engine)
getPartEngineStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Engine" [makeArgument 0 thisArg]
in makeStream req
getPartEngineStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Engine))
getPartEngineStream thisArg = requestStream $ getPartEngineStreamReq thisArg
{-
- An <see cref="T:SpaceCenter.Experiment" /> if the part is a science experiment, otherwisenull.
-}
getPartExperiment :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Experiment)
getPartExperiment thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Experiment" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartExperimentStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Experiment)
getPartExperimentStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Experiment" [makeArgument 0 thisArg]
in makeStream req
getPartExperimentStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Experiment))
getPartExperimentStream thisArg = requestStream $ getPartExperimentStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Fairing" /> if the part is a fairing, otherwisenull.
-}
getPartFairing :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Fairing)
getPartFairing thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Fairing" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartFairingStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Fairing)
getPartFairingStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Fairing" [makeArgument 0 thisArg]
in makeStream req
getPartFairingStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Fairing))
getPartFairingStream thisArg = requestStream $ getPartFairingStreamReq thisArg
{-
- The parts that are connected to this part via fuel lines, where the direction of the fuel line is into this part.
-}
getPartFuelLinesFrom :: KRPCHS.SpaceCenter.Part -> RPCContext ([KRPCHS.SpaceCenter.Part])
getPartFuelLinesFrom thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_FuelLinesFrom" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartFuelLinesFromStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
getPartFuelLinesFromStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_FuelLinesFrom" [makeArgument 0 thisArg]
in makeStream req
getPartFuelLinesFromStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
getPartFuelLinesFromStream thisArg = requestStream $ getPartFuelLinesFromStreamReq thisArg
{-
- The parts that are connected to this part via fuel lines, where the direction of the fuel line is out of this part.
-}
getPartFuelLinesTo :: KRPCHS.SpaceCenter.Part -> RPCContext ([KRPCHS.SpaceCenter.Part])
getPartFuelLinesTo thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_FuelLinesTo" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartFuelLinesToStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
getPartFuelLinesToStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_FuelLinesTo" [makeArgument 0 thisArg]
in makeStream req
getPartFuelLinesToStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
getPartFuelLinesToStream thisArg = requestStream $ getPartFuelLinesToStreamReq thisArg
{-
- The color used to highlight the part.
-}
getPartHighlightColor :: KRPCHS.SpaceCenter.Part -> RPCContext ((Double, Double, Double))
getPartHighlightColor thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_HighlightColor" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartHighlightColorStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq ((Double, Double, Double))
getPartHighlightColorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_HighlightColor" [makeArgument 0 thisArg]
in makeStream req
getPartHighlightColorStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream ((Double, Double, Double)))
getPartHighlightColorStream thisArg = requestStream $ getPartHighlightColorStreamReq thisArg
{-
- Whether the part is highlighted.
-}
getPartHighlighted :: KRPCHS.SpaceCenter.Part -> RPCContext (Bool)
getPartHighlighted thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Highlighted" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartHighlightedStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Bool)
getPartHighlightedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Highlighted" [makeArgument 0 thisArg]
in makeStream req
getPartHighlightedStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Bool))
getPartHighlightedStream thisArg = requestStream $ getPartHighlightedStreamReq thisArg
{-
- The impact tolerance of the part, in meters per second.
-}
getPartImpactTolerance :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartImpactTolerance thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ImpactTolerance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartImpactToleranceStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartImpactToleranceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ImpactTolerance" [makeArgument 0 thisArg]
in makeStream req
getPartImpactToleranceStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartImpactToleranceStream thisArg = requestStream $ getPartImpactToleranceStreamReq thisArg
{-
- The inertia tensor of the part in the parts reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- Returns the 3x3 matrix as a list of elements, in row-major order.
-}
getPartInertiaTensor :: KRPCHS.SpaceCenter.Part -> RPCContext ([Double])
getPartInertiaTensor thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_InertiaTensor" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartInertiaTensorStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq ([Double])
getPartInertiaTensorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_InertiaTensor" [makeArgument 0 thisArg]
in makeStream req
getPartInertiaTensorStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream ([Double]))
getPartInertiaTensorStream thisArg = requestStream $ getPartInertiaTensorStreamReq thisArg
{-
- An <see cref="T:SpaceCenter.Intake" /> if the part is an intake, otherwisenull.This includes any part that generates thrust. This covers many different types of engine,
- including liquid fuel rockets, solid rocket boosters and jet engines.
- For RCS thrusters see <see cref="T:SpaceCenter.RCS" />.
-}
getPartIntake :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Intake)
getPartIntake thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Intake" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartIntakeStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Intake)
getPartIntakeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Intake" [makeArgument 0 thisArg]
in makeStream req
getPartIntakeStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Intake))
getPartIntakeStream thisArg = requestStream $ getPartIntakeStreamReq thisArg
{-
- Whether this part is a fuel line.
-}
getPartIsFuelLine :: KRPCHS.SpaceCenter.Part -> RPCContext (Bool)
getPartIsFuelLine thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_IsFuelLine" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartIsFuelLineStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Bool)
getPartIsFuelLineStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_IsFuelLine" [makeArgument 0 thisArg]
in makeStream req
getPartIsFuelLineStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Bool))
getPartIsFuelLineStream thisArg = requestStream $ getPartIsFuelLineStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.LaunchClamp" /> if the part is a launch clamp, otherwisenull.
-}
getPartLaunchClamp :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.LaunchClamp)
getPartLaunchClamp thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_LaunchClamp" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartLaunchClampStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.LaunchClamp)
getPartLaunchClampStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_LaunchClamp" [makeArgument 0 thisArg]
in makeStream req
getPartLaunchClampStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.LaunchClamp))
getPartLaunchClampStream thisArg = requestStream $ getPartLaunchClampStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Leg" /> if the part is a landing leg, otherwisenull.
-}
getPartLeg :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Leg)
getPartLeg thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Leg" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartLegStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Leg)
getPartLegStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Leg" [makeArgument 0 thisArg]
in makeStream req
getPartLegStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Leg))
getPartLegStream thisArg = requestStream $ getPartLegStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Light" /> if the part is a light, otherwisenull.
-}
getPartLight :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Light)
getPartLight thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Light" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartLightStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Light)
getPartLightStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Light" [makeArgument 0 thisArg]
in makeStream req
getPartLightStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Light))
getPartLightStream thisArg = requestStream $ getPartLightStreamReq thisArg
{-
- The current mass of the part, including resources it contains, in kilograms.
- Returns zero if the part is massless.
-}
getPartMass :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartMass thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Mass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartMassStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Mass" [makeArgument 0 thisArg]
in makeStream req
getPartMassStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartMassStream thisArg = requestStream $ getPartMassStreamReq thisArg
{-
- Whether the part is <a href="http://wiki.kerbalspaceprogram.com/wiki/Massless_part">massless.
-}
getPartMassless :: KRPCHS.SpaceCenter.Part -> RPCContext (Bool)
getPartMassless thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Massless" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartMasslessStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Bool)
getPartMasslessStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Massless" [makeArgument 0 thisArg]
in makeStream req
getPartMasslessStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Bool))
getPartMasslessStream thisArg = requestStream $ getPartMasslessStreamReq thisArg
{-
- Maximum temperature that the skin of the part can survive, in Kelvin.
-}
getPartMaxSkinTemperature :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartMaxSkinTemperature thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_MaxSkinTemperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartMaxSkinTemperatureStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartMaxSkinTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_MaxSkinTemperature" [makeArgument 0 thisArg]
in makeStream req
getPartMaxSkinTemperatureStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartMaxSkinTemperatureStream thisArg = requestStream $ getPartMaxSkinTemperatureStreamReq thisArg
{-
- Maximum temperature that the part can survive, in Kelvin.
-}
getPartMaxTemperature :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartMaxTemperature thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_MaxTemperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartMaxTemperatureStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartMaxTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_MaxTemperature" [makeArgument 0 thisArg]
in makeStream req
getPartMaxTemperatureStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartMaxTemperatureStream thisArg = requestStream $ getPartMaxTemperatureStreamReq thisArg
{-
- The modules for this part.
-}
getPartModules :: KRPCHS.SpaceCenter.Part -> RPCContext ([KRPCHS.SpaceCenter.Module])
getPartModules thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Modules" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartModulesStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq ([KRPCHS.SpaceCenter.Module])
getPartModulesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Modules" [makeArgument 0 thisArg]
in makeStream req
getPartModulesStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Module]))
getPartModulesStream thisArg = requestStream $ getPartModulesStreamReq thisArg
{-
- The moment of inertia of the part inkg.m^2around its center of mass
- in the parts reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
-}
getPartMomentOfInertia :: KRPCHS.SpaceCenter.Part -> RPCContext ((Double, Double, Double))
getPartMomentOfInertia thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_MomentOfInertia" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartMomentOfInertiaStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq ((Double, Double, Double))
getPartMomentOfInertiaStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_MomentOfInertia" [makeArgument 0 thisArg]
in makeStream req
getPartMomentOfInertiaStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream ((Double, Double, Double)))
getPartMomentOfInertiaStream thisArg = requestStream $ getPartMomentOfInertiaStreamReq thisArg
{-
- Internal name of the part, as used in
- <a href="http://wiki.kerbalspaceprogram.com/wiki/CFG_File_Documentation">part cfg files.
- For example "Mark1-2Pod".
-}
getPartName :: KRPCHS.SpaceCenter.Part -> RPCContext (Data.Text.Text)
getPartName thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartNameStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Data.Text.Text)
getPartNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Name" [makeArgument 0 thisArg]
in makeStream req
getPartNameStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Data.Text.Text))
getPartNameStream thisArg = requestStream $ getPartNameStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Parachute" /> if the part is a parachute, otherwisenull.
-}
getPartParachute :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Parachute)
getPartParachute thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Parachute" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartParachuteStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Parachute)
getPartParachuteStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Parachute" [makeArgument 0 thisArg]
in makeStream req
getPartParachuteStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Parachute))
getPartParachuteStream thisArg = requestStream $ getPartParachuteStreamReq thisArg
{-
- The parts parent. Returnsnullif the part does not have a parent.
- This, in combination with <see cref="M:SpaceCenter.Part.Children" />, can be used to traverse the vessels parts tree.
-}
getPartParent :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Part)
getPartParent thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Parent" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartParentStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getPartParentStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Parent" [makeArgument 0 thisArg]
in makeStream req
getPartParentStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getPartParentStream thisArg = requestStream $ getPartParentStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.RCS" /> if the part is an RCS block/thruster, otherwisenull.
-}
getPartRCS :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.RCS)
getPartRCS thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_RCS" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartRCSStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.RCS)
getPartRCSStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_RCS" [makeArgument 0 thisArg]
in makeStream req
getPartRCSStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.RCS))
getPartRCSStream thisArg = requestStream $ getPartRCSStreamReq thisArg
{-
- Whether the part is radially attached to its parent, i.e. on the side of its parent.
- If the part has no parent, returnsfalse.
-}
getPartRadiallyAttached :: KRPCHS.SpaceCenter.Part -> RPCContext (Bool)
getPartRadiallyAttached thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_RadiallyAttached" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartRadiallyAttachedStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Bool)
getPartRadiallyAttachedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_RadiallyAttached" [makeArgument 0 thisArg]
in makeStream req
getPartRadiallyAttachedStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Bool))
getPartRadiallyAttachedStream thisArg = requestStream $ getPartRadiallyAttachedStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Radiator" /> if the part is a radiator, otherwisenull.
-}
getPartRadiator :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Radiator)
getPartRadiator thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Radiator" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartRadiatorStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Radiator)
getPartRadiatorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Radiator" [makeArgument 0 thisArg]
in makeStream req
getPartRadiatorStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Radiator))
getPartRadiatorStream thisArg = requestStream $ getPartRadiatorStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.ReactionWheel" /> if the part is a reaction wheel, otherwisenull.
-}
getPartReactionWheel :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.ReactionWheel)
getPartReactionWheel thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ReactionWheel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartReactionWheelStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.ReactionWheel)
getPartReactionWheelStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ReactionWheel" [makeArgument 0 thisArg]
in makeStream req
getPartReactionWheelStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReactionWheel))
getPartReactionWheelStream thisArg = requestStream $ getPartReactionWheelStreamReq thisArg
{-
- The reference frame that is fixed relative to this part, and centered on a fixed position within the part, defined by the parts model.
- <list type="bullet">The origin is at the position of the part, as returned by <see cref="M:SpaceCenter.Part.Position" />.The axes rotate with the part.The x, y and z axis directions depend on the design of the part.For docking port parts, this reference frame is not necessarily equivalent to the reference frame
- for the docking port, returned by <see cref="M:SpaceCenter.DockingPort.ReferenceFrame" />.
-}
getPartReferenceFrame :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getPartReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getPartReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getPartReferenceFrameStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getPartReferenceFrameStream thisArg = requestStream $ getPartReferenceFrameStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.ResourceConverter" /> if the part is a resource converter, otherwisenull.
-}
getPartResourceConverter :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.ResourceConverter)
getPartResourceConverter thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ResourceConverter" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartResourceConverterStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.ResourceConverter)
getPartResourceConverterStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ResourceConverter" [makeArgument 0 thisArg]
in makeStream req
getPartResourceConverterStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ResourceConverter))
getPartResourceConverterStream thisArg = requestStream $ getPartResourceConverterStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.ResourceHarvester" /> if the part is a resource harvester, otherwisenull.
-}
getPartResourceHarvester :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.ResourceHarvester)
getPartResourceHarvester thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ResourceHarvester" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartResourceHarvesterStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.ResourceHarvester)
getPartResourceHarvesterStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ResourceHarvester" [makeArgument 0 thisArg]
in makeStream req
getPartResourceHarvesterStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ResourceHarvester))
getPartResourceHarvesterStream thisArg = requestStream $ getPartResourceHarvesterStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Resources" /> object for the part.
-}
getPartResources :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Resources)
getPartResources thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Resources" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartResourcesStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Resources)
getPartResourcesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Resources" [makeArgument 0 thisArg]
in makeStream req
getPartResourcesStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Resources))
getPartResourcesStream thisArg = requestStream $ getPartResourcesStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Sensor" /> if the part is a sensor, otherwisenull.
-}
getPartSensor :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Sensor)
getPartSensor thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Sensor" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartSensorStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Sensor)
getPartSensorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Sensor" [makeArgument 0 thisArg]
in makeStream req
getPartSensorStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Sensor))
getPartSensorStream thisArg = requestStream $ getPartSensorStreamReq thisArg
{-
- Whether the part is shielded from the exterior of the vessel, for example by a fairing.
-}
getPartShielded :: KRPCHS.SpaceCenter.Part -> RPCContext (Bool)
getPartShielded thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Shielded" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartShieldedStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Bool)
getPartShieldedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Shielded" [makeArgument 0 thisArg]
in makeStream req
getPartShieldedStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Bool))
getPartShieldedStream thisArg = requestStream $ getPartShieldedStreamReq thisArg
{-
- Temperature of the skin of the part, in Kelvin.
-}
getPartSkinTemperature :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartSkinTemperature thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_SkinTemperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartSkinTemperatureStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartSkinTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_SkinTemperature" [makeArgument 0 thisArg]
in makeStream req
getPartSkinTemperatureStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartSkinTemperatureStream thisArg = requestStream $ getPartSkinTemperatureStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.SolarPanel" /> if the part is a solar panel, otherwisenull.
-}
getPartSolarPanel :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.SolarPanel)
getPartSolarPanel thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_SolarPanel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartSolarPanelStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.SolarPanel)
getPartSolarPanelStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_SolarPanel" [makeArgument 0 thisArg]
in makeStream req
getPartSolarPanelStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.SolarPanel))
getPartSolarPanelStream thisArg = requestStream $ getPartSolarPanelStreamReq thisArg
{-
- The stage in which this part will be activated. Returns -1 if the part is not activated by staging.
-}
getPartStage :: KRPCHS.SpaceCenter.Part -> RPCContext (Data.Int.Int32)
getPartStage thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Stage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartStageStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Data.Int.Int32)
getPartStageStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Stage" [makeArgument 0 thisArg]
in makeStream req
getPartStageStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Data.Int.Int32))
getPartStageStream thisArg = requestStream $ getPartStageStreamReq thisArg
{-
- The name tag for the part. Can be set to a custom string using the in-game user interface.This requires either the <a href="http://github.com/krpc/NameTag/releases/latest">NameTagor
- <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/61827-/">kOSmods to be installed.
-}
getPartTag :: KRPCHS.SpaceCenter.Part -> RPCContext (Data.Text.Text)
getPartTag thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Tag" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartTagStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Data.Text.Text)
getPartTagStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Tag" [makeArgument 0 thisArg]
in makeStream req
getPartTagStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Data.Text.Text))
getPartTagStream thisArg = requestStream $ getPartTagStreamReq thisArg
{-
- Temperature of the part, in Kelvin.
-}
getPartTemperature :: KRPCHS.SpaceCenter.Part -> RPCContext (Double)
getPartTemperature thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Temperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartTemperatureStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Double)
getPartTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Temperature" [makeArgument 0 thisArg]
in makeStream req
getPartTemperatureStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Double))
getPartTemperatureStream thisArg = requestStream $ getPartTemperatureStreamReq thisArg
{-
- The rate at which heat energy is conducting into or out of the part via contact with other parts.
- Measured in energy per unit time, or power, in Watts.
- A positive value means the part is gaining heat energy, and negative means it is losing heat energy.
-}
getPartThermalConductionFlux :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalConductionFlux thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalConductionFlux" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalConductionFluxStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalConductionFluxStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalConductionFlux" [makeArgument 0 thisArg]
in makeStream req
getPartThermalConductionFluxStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalConductionFluxStream thisArg = requestStream $ getPartThermalConductionFluxStreamReq thisArg
{-
- The rate at which heat energy is convecting into or out of the part from the surrounding atmosphere.
- Measured in energy per unit time, or power, in Watts.
- A positive value means the part is gaining heat energy, and negative means it is losing heat energy.
-}
getPartThermalConvectionFlux :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalConvectionFlux thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalConvectionFlux" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalConvectionFluxStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalConvectionFluxStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalConvectionFlux" [makeArgument 0 thisArg]
in makeStream req
getPartThermalConvectionFluxStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalConvectionFluxStream thisArg = requestStream $ getPartThermalConvectionFluxStreamReq thisArg
{-
- The rate at which heat energy is begin generated by the part.
- For example, some engines generate heat by combusting fuel.
- Measured in energy per unit time, or power, in Watts.
- A positive value means the part is gaining heat energy, and negative means it is losing heat energy.
-}
getPartThermalInternalFlux :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalInternalFlux thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalInternalFlux" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalInternalFluxStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalInternalFluxStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalInternalFlux" [makeArgument 0 thisArg]
in makeStream req
getPartThermalInternalFluxStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalInternalFluxStream thisArg = requestStream $ getPartThermalInternalFluxStreamReq thisArg
{-
- A measure of how much energy it takes to increase the internal temperature of the part, in Joules per Kelvin.
-}
getPartThermalMass :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalMass thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalMass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalMassStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalMass" [makeArgument 0 thisArg]
in makeStream req
getPartThermalMassStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalMassStream thisArg = requestStream $ getPartThermalMassStreamReq thisArg
{-
- The rate at which heat energy is radiating into or out of the part from the surrounding environment.
- Measured in energy per unit time, or power, in Watts.
- A positive value means the part is gaining heat energy, and negative means it is losing heat energy.
-}
getPartThermalRadiationFlux :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalRadiationFlux thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalRadiationFlux" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalRadiationFluxStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalRadiationFluxStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalRadiationFlux" [makeArgument 0 thisArg]
in makeStream req
getPartThermalRadiationFluxStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalRadiationFluxStream thisArg = requestStream $ getPartThermalRadiationFluxStreamReq thisArg
{-
- A measure of how much energy it takes to increase the temperature of the resources contained in the part, in Joules per Kelvin.
-}
getPartThermalResourceMass :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalResourceMass thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalResourceMass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalResourceMassStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalResourceMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalResourceMass" [makeArgument 0 thisArg]
in makeStream req
getPartThermalResourceMassStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalResourceMassStream thisArg = requestStream $ getPartThermalResourceMassStreamReq thisArg
{-
- A measure of how much energy it takes to increase the skin temperature of the part, in Joules per Kelvin.
-}
getPartThermalSkinMass :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalSkinMass thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalSkinMass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalSkinMassStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalSkinMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalSkinMass" [makeArgument 0 thisArg]
in makeStream req
getPartThermalSkinMassStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalSkinMassStream thisArg = requestStream $ getPartThermalSkinMassStreamReq thisArg
{-
- The rate at which heat energy is transferring between the part's skin and its internals.
- Measured in energy per unit time, or power, in Watts.
- A positive value means the part's internals are gaining heat energy,
- and negative means its skin is gaining heat energy.
-}
getPartThermalSkinToInternalFlux :: KRPCHS.SpaceCenter.Part -> RPCContext (Float)
getPartThermalSkinToInternalFlux thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_ThermalSkinToInternalFlux" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartThermalSkinToInternalFluxStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Float)
getPartThermalSkinToInternalFluxStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_ThermalSkinToInternalFlux" [makeArgument 0 thisArg]
in makeStream req
getPartThermalSkinToInternalFluxStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Float))
getPartThermalSkinToInternalFluxStream thisArg = requestStream $ getPartThermalSkinToInternalFluxStreamReq thisArg
{-
- Title of the part, as shown when the part is right clicked in-game. For example "Mk1-2 Command Pod".
-}
getPartTitle :: KRPCHS.SpaceCenter.Part -> RPCContext (Data.Text.Text)
getPartTitle thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Title" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartTitleStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (Data.Text.Text)
getPartTitleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Title" [makeArgument 0 thisArg]
in makeStream req
getPartTitleStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (Data.Text.Text))
getPartTitleStream thisArg = requestStream $ getPartTitleStreamReq thisArg
{-
- The vessel that contains this part.
-}
getPartVessel :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Vessel)
getPartVessel thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Vessel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartVesselStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Vessel)
getPartVesselStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Vessel" [makeArgument 0 thisArg]
in makeStream req
getPartVesselStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Vessel))
getPartVesselStream thisArg = requestStream $ getPartVesselStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Wheel" /> if the part is a wheel, otherwisenull.
-}
getPartWheel :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCHS.SpaceCenter.Wheel)
getPartWheel thisArg = do
let r = makeRequest "SpaceCenter" "Part_get_Wheel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartWheelStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCStreamReq (KRPCHS.SpaceCenter.Wheel)
getPartWheelStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Part_get_Wheel" [makeArgument 0 thisArg]
in makeStream req
getPartWheelStream :: KRPCHS.SpaceCenter.Part -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Wheel))
getPartWheelStream thisArg = requestStream $ getPartWheelStreamReq thisArg
{-
- The color used to highlight the part.
-}
setPartHighlightColor :: KRPCHS.SpaceCenter.Part -> (Double, Double, Double) -> RPCContext ()
setPartHighlightColor thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Part_set_HighlightColor" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the part is highlighted.
-}
setPartHighlighted :: KRPCHS.SpaceCenter.Part -> Bool -> RPCContext ()
setPartHighlighted thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Part_set_Highlighted" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The name tag for the part. Can be set to a custom string using the in-game user interface.This requires either the <a href="http://github.com/krpc/NameTag/releases/latest">NameTagor
- <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/61827-/">kOSmods to be installed.
-}
setPartTag :: KRPCHS.SpaceCenter.Part -> Data.Text.Text -> RPCContext ()
setPartTag thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Part_set_Tag" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- A list of all parts that are decoupled in the given <paramref name="stage" />.<param name="stage">
-}
partsInDecoupleStage :: KRPCHS.SpaceCenter.Parts -> Data.Int.Int32 -> RPCContext ([KRPCHS.SpaceCenter.Part])
partsInDecoupleStage thisArg stageArg = do
let r = makeRequest "SpaceCenter" "Parts_InDecoupleStage" [makeArgument 0 thisArg, makeArgument 1 stageArg]
res <- sendRequest r
processResponse res
partsInDecoupleStageStreamReq :: KRPCHS.SpaceCenter.Parts -> Data.Int.Int32 -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
partsInDecoupleStageStreamReq thisArg stageArg =
let req = makeRequest "SpaceCenter" "Parts_InDecoupleStage" [makeArgument 0 thisArg, makeArgument 1 stageArg]
in makeStream req
partsInDecoupleStageStream :: KRPCHS.SpaceCenter.Parts -> Data.Int.Int32 -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
partsInDecoupleStageStream thisArg stageArg = requestStream $ partsInDecoupleStageStreamReq thisArg stageArg
{-
- A list of all parts that are activated in the given <paramref name="stage" />.<param name="stage">
-}
partsInStage :: KRPCHS.SpaceCenter.Parts -> Data.Int.Int32 -> RPCContext ([KRPCHS.SpaceCenter.Part])
partsInStage thisArg stageArg = do
let r = makeRequest "SpaceCenter" "Parts_InStage" [makeArgument 0 thisArg, makeArgument 1 stageArg]
res <- sendRequest r
processResponse res
partsInStageStreamReq :: KRPCHS.SpaceCenter.Parts -> Data.Int.Int32 -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
partsInStageStreamReq thisArg stageArg =
let req = makeRequest "SpaceCenter" "Parts_InStage" [makeArgument 0 thisArg, makeArgument 1 stageArg]
in makeStream req
partsInStageStream :: KRPCHS.SpaceCenter.Parts -> Data.Int.Int32 -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
partsInStageStream thisArg stageArg = requestStream $ partsInStageStreamReq thisArg stageArg
{-
- A list of modules (combined across all parts in the vessel) whose
- <see cref="M:SpaceCenter.Module.Name" /> is <paramref name="moduleName" />.<param name="moduleName">
-}
partsModulesWithName :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext ([KRPCHS.SpaceCenter.Module])
partsModulesWithName thisArg moduleNameArg = do
let r = makeRequest "SpaceCenter" "Parts_ModulesWithName" [makeArgument 0 thisArg, makeArgument 1 moduleNameArg]
res <- sendRequest r
processResponse res
partsModulesWithNameStreamReq :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> KRPCStreamReq ([KRPCHS.SpaceCenter.Module])
partsModulesWithNameStreamReq thisArg moduleNameArg =
let req = makeRequest "SpaceCenter" "Parts_ModulesWithName" [makeArgument 0 thisArg, makeArgument 1 moduleNameArg]
in makeStream req
partsModulesWithNameStream :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Module]))
partsModulesWithNameStream thisArg moduleNameArg = requestStream $ partsModulesWithNameStreamReq thisArg moduleNameArg
{-
- A list of all parts that contain a <see cref="T:SpaceCenter.Module" /> whose
- <see cref="M:SpaceCenter.Module.Name" /> is <paramref name="moduleName" />.<param name="moduleName">
-}
partsWithModule :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext ([KRPCHS.SpaceCenter.Part])
partsWithModule thisArg moduleNameArg = do
let r = makeRequest "SpaceCenter" "Parts_WithModule" [makeArgument 0 thisArg, makeArgument 1 moduleNameArg]
res <- sendRequest r
processResponse res
partsWithModuleStreamReq :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
partsWithModuleStreamReq thisArg moduleNameArg =
let req = makeRequest "SpaceCenter" "Parts_WithModule" [makeArgument 0 thisArg, makeArgument 1 moduleNameArg]
in makeStream req
partsWithModuleStream :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
partsWithModuleStream thisArg moduleNameArg = requestStream $ partsWithModuleStreamReq thisArg moduleNameArg
{-
- A list of parts whose <see cref="M:SpaceCenter.Part.Name" /> is <paramref name="name" />.<param name="name">
-}
partsWithName :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext ([KRPCHS.SpaceCenter.Part])
partsWithName thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Parts_WithName" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
partsWithNameStreamReq :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
partsWithNameStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Parts_WithName" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
partsWithNameStream :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
partsWithNameStream thisArg nameArg = requestStream $ partsWithNameStreamReq thisArg nameArg
{-
- A list of all parts whose <see cref="M:SpaceCenter.Part.Tag" /> is <paramref name="tag" />.<param name="tag">
-}
partsWithTag :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext ([KRPCHS.SpaceCenter.Part])
partsWithTag thisArg tagArg = do
let r = makeRequest "SpaceCenter" "Parts_WithTag" [makeArgument 0 thisArg, makeArgument 1 tagArg]
res <- sendRequest r
processResponse res
partsWithTagStreamReq :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
partsWithTagStreamReq thisArg tagArg =
let req = makeRequest "SpaceCenter" "Parts_WithTag" [makeArgument 0 thisArg, makeArgument 1 tagArg]
in makeStream req
partsWithTagStream :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
partsWithTagStream thisArg tagArg = requestStream $ partsWithTagStreamReq thisArg tagArg
{-
- A list of all parts whose <see cref="M:SpaceCenter.Part.Title" /> is <paramref name="title" />.<param name="title">
-}
partsWithTitle :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext ([KRPCHS.SpaceCenter.Part])
partsWithTitle thisArg titleArg = do
let r = makeRequest "SpaceCenter" "Parts_WithTitle" [makeArgument 0 thisArg, makeArgument 1 titleArg]
res <- sendRequest r
processResponse res
partsWithTitleStreamReq :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
partsWithTitleStreamReq thisArg titleArg =
let req = makeRequest "SpaceCenter" "Parts_WithTitle" [makeArgument 0 thisArg, makeArgument 1 titleArg]
in makeStream req
partsWithTitleStream :: KRPCHS.SpaceCenter.Parts -> Data.Text.Text -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
partsWithTitleStream thisArg titleArg = requestStream $ partsWithTitleStreamReq thisArg titleArg
{-
- A list of all of the vessels parts.
-}
getPartsAll :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Part])
getPartsAll thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_All" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsAllStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Part])
getPartsAllStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_All" [makeArgument 0 thisArg]
in makeStream req
getPartsAllStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Part]))
getPartsAllStream thisArg = requestStream $ getPartsAllStreamReq thisArg
{-
- A list of all antennas in the vessel.
-}
getPartsAntennas :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Antenna])
getPartsAntennas thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Antennas" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsAntennasStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Antenna])
getPartsAntennasStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Antennas" [makeArgument 0 thisArg]
in makeStream req
getPartsAntennasStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Antenna]))
getPartsAntennasStream thisArg = requestStream $ getPartsAntennasStreamReq thisArg
{-
- A list of all cargo bays in the vessel.
-}
getPartsCargoBays :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.CargoBay])
getPartsCargoBays thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_CargoBays" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsCargoBaysStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.CargoBay])
getPartsCargoBaysStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_CargoBays" [makeArgument 0 thisArg]
in makeStream req
getPartsCargoBaysStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.CargoBay]))
getPartsCargoBaysStream thisArg = requestStream $ getPartsCargoBaysStreamReq thisArg
{-
- A list of all control surfaces in the vessel.
-}
getPartsControlSurfaces :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.ControlSurface])
getPartsControlSurfaces thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_ControlSurfaces" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsControlSurfacesStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.ControlSurface])
getPartsControlSurfacesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_ControlSurfaces" [makeArgument 0 thisArg]
in makeStream req
getPartsControlSurfacesStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.ControlSurface]))
getPartsControlSurfacesStream thisArg = requestStream $ getPartsControlSurfacesStreamReq thisArg
{-
- The part from which the vessel is controlled.
-}
getPartsControlling :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCHS.SpaceCenter.Part)
getPartsControlling thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Controlling" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsControllingStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getPartsControllingStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Controlling" [makeArgument 0 thisArg]
in makeStream req
getPartsControllingStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getPartsControllingStream thisArg = requestStream $ getPartsControllingStreamReq thisArg
{-
- A list of all decouplers in the vessel.
-}
getPartsDecouplers :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Decoupler])
getPartsDecouplers thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Decouplers" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsDecouplersStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Decoupler])
getPartsDecouplersStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Decouplers" [makeArgument 0 thisArg]
in makeStream req
getPartsDecouplersStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Decoupler]))
getPartsDecouplersStream thisArg = requestStream $ getPartsDecouplersStreamReq thisArg
{-
- A list of all docking ports in the vessel.
-}
getPartsDockingPorts :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.DockingPort])
getPartsDockingPorts thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_DockingPorts" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsDockingPortsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.DockingPort])
getPartsDockingPortsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_DockingPorts" [makeArgument 0 thisArg]
in makeStream req
getPartsDockingPortsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.DockingPort]))
getPartsDockingPortsStream thisArg = requestStream $ getPartsDockingPortsStreamReq thisArg
{-
- A list of all engines in the vessel.This includes any part that generates thrust. This covers many different types of engine,
- including liquid fuel rockets, solid rocket boosters, jet engines and RCS thrusters.
-}
getPartsEngines :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Engine])
getPartsEngines thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Engines" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsEnginesStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Engine])
getPartsEnginesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Engines" [makeArgument 0 thisArg]
in makeStream req
getPartsEnginesStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Engine]))
getPartsEnginesStream thisArg = requestStream $ getPartsEnginesStreamReq thisArg
{-
- A list of all science experiments in the vessel.
-}
getPartsExperiments :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Experiment])
getPartsExperiments thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Experiments" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsExperimentsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Experiment])
getPartsExperimentsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Experiments" [makeArgument 0 thisArg]
in makeStream req
getPartsExperimentsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Experiment]))
getPartsExperimentsStream thisArg = requestStream $ getPartsExperimentsStreamReq thisArg
{-
- A list of all fairings in the vessel.
-}
getPartsFairings :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Fairing])
getPartsFairings thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Fairings" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsFairingsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Fairing])
getPartsFairingsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Fairings" [makeArgument 0 thisArg]
in makeStream req
getPartsFairingsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Fairing]))
getPartsFairingsStream thisArg = requestStream $ getPartsFairingsStreamReq thisArg
{-
- A list of all intakes in the vessel.
-}
getPartsIntakes :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Intake])
getPartsIntakes thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Intakes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsIntakesStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Intake])
getPartsIntakesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Intakes" [makeArgument 0 thisArg]
in makeStream req
getPartsIntakesStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Intake]))
getPartsIntakesStream thisArg = requestStream $ getPartsIntakesStreamReq thisArg
{-
- A list of all launch clamps attached to the vessel.
-}
getPartsLaunchClamps :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.LaunchClamp])
getPartsLaunchClamps thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_LaunchClamps" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsLaunchClampsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.LaunchClamp])
getPartsLaunchClampsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_LaunchClamps" [makeArgument 0 thisArg]
in makeStream req
getPartsLaunchClampsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.LaunchClamp]))
getPartsLaunchClampsStream thisArg = requestStream $ getPartsLaunchClampsStreamReq thisArg
{-
- A list of all landing legs attached to the vessel.
-}
getPartsLegs :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Leg])
getPartsLegs thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Legs" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsLegsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Leg])
getPartsLegsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Legs" [makeArgument 0 thisArg]
in makeStream req
getPartsLegsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Leg]))
getPartsLegsStream thisArg = requestStream $ getPartsLegsStreamReq thisArg
{-
- A list of all lights in the vessel.
-}
getPartsLights :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Light])
getPartsLights thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Lights" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsLightsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Light])
getPartsLightsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Lights" [makeArgument 0 thisArg]
in makeStream req
getPartsLightsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Light]))
getPartsLightsStream thisArg = requestStream $ getPartsLightsStreamReq thisArg
{-
- A list of all parachutes in the vessel.
-}
getPartsParachutes :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Parachute])
getPartsParachutes thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Parachutes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsParachutesStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Parachute])
getPartsParachutesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Parachutes" [makeArgument 0 thisArg]
in makeStream req
getPartsParachutesStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Parachute]))
getPartsParachutesStream thisArg = requestStream $ getPartsParachutesStreamReq thisArg
{-
- A list of all RCS blocks/thrusters in the vessel.
-}
getPartsRCS :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.RCS])
getPartsRCS thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_RCS" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsRCSStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.RCS])
getPartsRCSStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_RCS" [makeArgument 0 thisArg]
in makeStream req
getPartsRCSStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.RCS]))
getPartsRCSStream thisArg = requestStream $ getPartsRCSStreamReq thisArg
{-
- A list of all radiators in the vessel.
-}
getPartsRadiators :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Radiator])
getPartsRadiators thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Radiators" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsRadiatorsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Radiator])
getPartsRadiatorsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Radiators" [makeArgument 0 thisArg]
in makeStream req
getPartsRadiatorsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Radiator]))
getPartsRadiatorsStream thisArg = requestStream $ getPartsRadiatorsStreamReq thisArg
{-
- A list of all reaction wheels in the vessel.
-}
getPartsReactionWheels :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.ReactionWheel])
getPartsReactionWheels thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_ReactionWheels" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsReactionWheelsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.ReactionWheel])
getPartsReactionWheelsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_ReactionWheels" [makeArgument 0 thisArg]
in makeStream req
getPartsReactionWheelsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.ReactionWheel]))
getPartsReactionWheelsStream thisArg = requestStream $ getPartsReactionWheelsStreamReq thisArg
{-
- A list of all resource converters in the vessel.
-}
getPartsResourceConverters :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.ResourceConverter])
getPartsResourceConverters thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_ResourceConverters" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsResourceConvertersStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.ResourceConverter])
getPartsResourceConvertersStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_ResourceConverters" [makeArgument 0 thisArg]
in makeStream req
getPartsResourceConvertersStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.ResourceConverter]))
getPartsResourceConvertersStream thisArg = requestStream $ getPartsResourceConvertersStreamReq thisArg
{-
- A list of all resource harvesters in the vessel.
-}
getPartsResourceHarvesters :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.ResourceHarvester])
getPartsResourceHarvesters thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_ResourceHarvesters" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsResourceHarvestersStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.ResourceHarvester])
getPartsResourceHarvestersStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_ResourceHarvesters" [makeArgument 0 thisArg]
in makeStream req
getPartsResourceHarvestersStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.ResourceHarvester]))
getPartsResourceHarvestersStream thisArg = requestStream $ getPartsResourceHarvestersStreamReq thisArg
{-
- The vessels root part.
-}
getPartsRoot :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCHS.SpaceCenter.Part)
getPartsRoot thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Root" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsRootStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getPartsRootStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Root" [makeArgument 0 thisArg]
in makeStream req
getPartsRootStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getPartsRootStream thisArg = requestStream $ getPartsRootStreamReq thisArg
{-
- A list of all sensors in the vessel.
-}
getPartsSensors :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Sensor])
getPartsSensors thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Sensors" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsSensorsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Sensor])
getPartsSensorsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Sensors" [makeArgument 0 thisArg]
in makeStream req
getPartsSensorsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Sensor]))
getPartsSensorsStream thisArg = requestStream $ getPartsSensorsStreamReq thisArg
{-
- A list of all solar panels in the vessel.
-}
getPartsSolarPanels :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.SolarPanel])
getPartsSolarPanels thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_SolarPanels" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsSolarPanelsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.SolarPanel])
getPartsSolarPanelsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_SolarPanels" [makeArgument 0 thisArg]
in makeStream req
getPartsSolarPanelsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.SolarPanel]))
getPartsSolarPanelsStream thisArg = requestStream $ getPartsSolarPanelsStreamReq thisArg
{-
- A list of all wheels in the vessel.
-}
getPartsWheels :: KRPCHS.SpaceCenter.Parts -> RPCContext ([KRPCHS.SpaceCenter.Wheel])
getPartsWheels thisArg = do
let r = makeRequest "SpaceCenter" "Parts_get_Wheels" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPartsWheelsStreamReq :: KRPCHS.SpaceCenter.Parts -> KRPCStreamReq ([KRPCHS.SpaceCenter.Wheel])
getPartsWheelsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Parts_get_Wheels" [makeArgument 0 thisArg]
in makeStream req
getPartsWheelsStream :: KRPCHS.SpaceCenter.Parts -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Wheel]))
getPartsWheelsStream thisArg = requestStream $ getPartsWheelsStreamReq thisArg
{-
- The part from which the vessel is controlled.
-}
setPartsControlling :: KRPCHS.SpaceCenter.Parts -> KRPCHS.SpaceCenter.Part -> RPCContext ()
setPartsControlling thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Parts_set_Controlling" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The current amount of propellant.
-}
getPropellantCurrentAmount :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Double)
getPropellantCurrentAmount thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_CurrentAmount" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantCurrentAmountStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Double)
getPropellantCurrentAmountStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_CurrentAmount" [makeArgument 0 thisArg]
in makeStream req
getPropellantCurrentAmountStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Double))
getPropellantCurrentAmountStream thisArg = requestStream $ getPropellantCurrentAmountStreamReq thisArg
{-
- The required amount of propellant.
-}
getPropellantCurrentRequirement :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Double)
getPropellantCurrentRequirement thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_CurrentRequirement" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantCurrentRequirementStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Double)
getPropellantCurrentRequirementStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_CurrentRequirement" [makeArgument 0 thisArg]
in makeStream req
getPropellantCurrentRequirementStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Double))
getPropellantCurrentRequirementStream thisArg = requestStream $ getPropellantCurrentRequirementStreamReq thisArg
{-
- If this propellant has a stack gauge or not.
-}
getPropellantDrawStackGauge :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Bool)
getPropellantDrawStackGauge thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_DrawStackGauge" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantDrawStackGaugeStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Bool)
getPropellantDrawStackGaugeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_DrawStackGauge" [makeArgument 0 thisArg]
in makeStream req
getPropellantDrawStackGaugeStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Bool))
getPropellantDrawStackGaugeStream thisArg = requestStream $ getPropellantDrawStackGaugeStreamReq thisArg
{-
- If this propellant should be ignored when calculating required mass flow given specific impulse.
-}
getPropellantIgnoreForIsp :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Bool)
getPropellantIgnoreForIsp thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_IgnoreForIsp" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantIgnoreForIspStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Bool)
getPropellantIgnoreForIspStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_IgnoreForIsp" [makeArgument 0 thisArg]
in makeStream req
getPropellantIgnoreForIspStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Bool))
getPropellantIgnoreForIspStream thisArg = requestStream $ getPropellantIgnoreForIspStreamReq thisArg
{-
- If this propellant should be ignored for thrust curve calculations.
-}
getPropellantIgnoreForThrustCurve :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Bool)
getPropellantIgnoreForThrustCurve thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_IgnoreForThrustCurve" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantIgnoreForThrustCurveStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Bool)
getPropellantIgnoreForThrustCurveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_IgnoreForThrustCurve" [makeArgument 0 thisArg]
in makeStream req
getPropellantIgnoreForThrustCurveStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Bool))
getPropellantIgnoreForThrustCurveStream thisArg = requestStream $ getPropellantIgnoreForThrustCurveStreamReq thisArg
{-
- If this propellant is deprived.
-}
getPropellantIsDeprived :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Bool)
getPropellantIsDeprived thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_IsDeprived" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantIsDeprivedStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Bool)
getPropellantIsDeprivedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_IsDeprived" [makeArgument 0 thisArg]
in makeStream req
getPropellantIsDeprivedStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Bool))
getPropellantIsDeprivedStream thisArg = requestStream $ getPropellantIsDeprivedStreamReq thisArg
{-
- The name of the propellant.
-}
getPropellantName :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Data.Text.Text)
getPropellantName thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantNameStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Data.Text.Text)
getPropellantNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_Name" [makeArgument 0 thisArg]
in makeStream req
getPropellantNameStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Data.Text.Text))
getPropellantNameStream thisArg = requestStream $ getPropellantNameStreamReq thisArg
{-
- The propellant ratio.
-}
getPropellantRatio :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Float)
getPropellantRatio thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_Ratio" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantRatioStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Float)
getPropellantRatioStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_Ratio" [makeArgument 0 thisArg]
in makeStream req
getPropellantRatioStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Float))
getPropellantRatioStream thisArg = requestStream $ getPropellantRatioStreamReq thisArg
{-
- The total amount of the underlying resource currently reachable given resource flow rules.
-}
getPropellantTotalResourceAvailable :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Double)
getPropellantTotalResourceAvailable thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_TotalResourceAvailable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantTotalResourceAvailableStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Double)
getPropellantTotalResourceAvailableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_TotalResourceAvailable" [makeArgument 0 thisArg]
in makeStream req
getPropellantTotalResourceAvailableStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Double))
getPropellantTotalResourceAvailableStream thisArg = requestStream $ getPropellantTotalResourceAvailableStreamReq thisArg
{-
- The total vehicle capacity for the underlying propellant resource, restricted by resource flow rules.
-}
getPropellantTotalResourceCapacity :: KRPCHS.SpaceCenter.Propellant -> RPCContext (Double)
getPropellantTotalResourceCapacity thisArg = do
let r = makeRequest "SpaceCenter" "Propellant_get_TotalResourceCapacity" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getPropellantTotalResourceCapacityStreamReq :: KRPCHS.SpaceCenter.Propellant -> KRPCStreamReq (Double)
getPropellantTotalResourceCapacityStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Propellant_get_TotalResourceCapacity" [makeArgument 0 thisArg]
in makeStream req
getPropellantTotalResourceCapacityStream :: KRPCHS.SpaceCenter.Propellant -> RPCContext (KRPCStream (Double))
getPropellantTotalResourceCapacityStream thisArg = requestStream $ getPropellantTotalResourceCapacityStreamReq thisArg
{-
- Load a quicksave.This is the same as calling <see cref="M:SpaceCenter.Load" /> with the name "quicksave".
-}
quickload :: RPCContext ()
quickload = do
let r = makeRequest "SpaceCenter" "Quickload" []
res <- sendRequest r
processResponse res
{-
- Save a quicksave.This is the same as calling <see cref="M:SpaceCenter.Save" /> with the name "quicksave".
-}
quicksave :: RPCContext ()
quicksave = do
let r = makeRequest "SpaceCenter" "Quicksave" []
res <- sendRequest r
processResponse res
{-
- Whether the RCS thrusters are active.
- An RCS thruster is inactive if the RCS action group is disabled (<see cref="M:SpaceCenter.Control.RCS" />),
- the RCS thruster itself is not enabled (<see cref="M:SpaceCenter.RCS.Enabled" />) or
- it is covered by a fairing (<see cref="M:SpaceCenter.Part.Shielded" />).
-}
getRCSActive :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSActive thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_Active" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSActiveStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_Active" [makeArgument 0 thisArg]
in makeStream req
getRCSActiveStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSActiveStream thisArg = requestStream $ getRCSActiveStreamReq thisArg
{-
- The available torque in the pitch, roll and yaw axes of the vessel, in Newton meters.
- These axes correspond to the coordinate axes of the <see cref="M:SpaceCenter.Vessel.ReferenceFrame" />.
- Returns zero if the RCS is inactive.
-}
getRCSAvailableTorque :: KRPCHS.SpaceCenter.RCS -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getRCSAvailableTorque thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_AvailableTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSAvailableTorqueStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getRCSAvailableTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_AvailableTorque" [makeArgument 0 thisArg]
in makeStream req
getRCSAvailableTorqueStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getRCSAvailableTorqueStream thisArg = requestStream $ getRCSAvailableTorqueStreamReq thisArg
{-
- Whether the RCS thrusters are enabled.
-}
getRCSEnabled :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSEnabled thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_Enabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSEnabledStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_Enabled" [makeArgument 0 thisArg]
in makeStream req
getRCSEnabledStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSEnabledStream thisArg = requestStream $ getRCSEnabledStreamReq thisArg
{-
- Whether the RCS thruster will fire when pitch control input is given.
-}
getRCSForwardEnabled :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSForwardEnabled thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_ForwardEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSForwardEnabledStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSForwardEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_ForwardEnabled" [makeArgument 0 thisArg]
in makeStream req
getRCSForwardEnabledStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSForwardEnabledStream thisArg = requestStream $ getRCSForwardEnabledStreamReq thisArg
{-
- Whether the RCS has fuel available.The RCS thruster must be activated for this property to update correctly.
-}
getRCSHasFuel :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSHasFuel thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_HasFuel" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSHasFuelStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSHasFuelStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_HasFuel" [makeArgument 0 thisArg]
in makeStream req
getRCSHasFuelStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSHasFuelStream thisArg = requestStream $ getRCSHasFuelStreamReq thisArg
{-
- The specific impulse of the RCS at sea level on Kerbin, in seconds.
-}
getRCSKerbinSeaLevelSpecificImpulse :: KRPCHS.SpaceCenter.RCS -> RPCContext (Float)
getRCSKerbinSeaLevelSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_KerbinSeaLevelSpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSKerbinSeaLevelSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Float)
getRCSKerbinSeaLevelSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_KerbinSeaLevelSpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getRCSKerbinSeaLevelSpecificImpulseStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Float))
getRCSKerbinSeaLevelSpecificImpulseStream thisArg = requestStream $ getRCSKerbinSeaLevelSpecificImpulseStreamReq thisArg
{-
- The maximum amount of thrust that can be produced by the RCS thrusters when active, in Newtons.
-}
getRCSMaxThrust :: KRPCHS.SpaceCenter.RCS -> RPCContext (Float)
getRCSMaxThrust thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_MaxThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSMaxThrustStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Float)
getRCSMaxThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_MaxThrust" [makeArgument 0 thisArg]
in makeStream req
getRCSMaxThrustStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Float))
getRCSMaxThrustStream thisArg = requestStream $ getRCSMaxThrustStreamReq thisArg
{-
- The maximum amount of thrust that can be produced by the RCS thrusters when active in a vacuum, in Newtons.
-}
getRCSMaxVacuumThrust :: KRPCHS.SpaceCenter.RCS -> RPCContext (Float)
getRCSMaxVacuumThrust thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_MaxVacuumThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSMaxVacuumThrustStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Float)
getRCSMaxVacuumThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_MaxVacuumThrust" [makeArgument 0 thisArg]
in makeStream req
getRCSMaxVacuumThrustStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Float))
getRCSMaxVacuumThrustStream thisArg = requestStream $ getRCSMaxVacuumThrustStreamReq thisArg
{-
- The part object for this RCS.
-}
getRCSPart :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCHS.SpaceCenter.Part)
getRCSPart thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSPartStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getRCSPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_Part" [makeArgument 0 thisArg]
in makeStream req
getRCSPartStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getRCSPartStream thisArg = requestStream $ getRCSPartStreamReq thisArg
{-
- Whether the RCS thruster will fire when pitch control input is given.
-}
getRCSPitchEnabled :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSPitchEnabled thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_PitchEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSPitchEnabledStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSPitchEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_PitchEnabled" [makeArgument 0 thisArg]
in makeStream req
getRCSPitchEnabledStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSPitchEnabledStream thisArg = requestStream $ getRCSPitchEnabledStreamReq thisArg
{-
- The ratios of resources that the RCS consumes. A dictionary mapping resource names
- to the ratios at which they are consumed by the RCS.
-}
getRCSPropellantRatios :: KRPCHS.SpaceCenter.RCS -> RPCContext (Data.Map.Map (Data.Text.Text) (Float))
getRCSPropellantRatios thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_PropellantRatios" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSPropellantRatiosStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Data.Map.Map (Data.Text.Text) (Float))
getRCSPropellantRatiosStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_PropellantRatios" [makeArgument 0 thisArg]
in makeStream req
getRCSPropellantRatiosStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Data.Map.Map (Data.Text.Text) (Float)))
getRCSPropellantRatiosStream thisArg = requestStream $ getRCSPropellantRatiosStreamReq thisArg
{-
- The names of resources that the RCS consumes.
-}
getRCSPropellants :: KRPCHS.SpaceCenter.RCS -> RPCContext ([Data.Text.Text])
getRCSPropellants thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_Propellants" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSPropellantsStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq ([Data.Text.Text])
getRCSPropellantsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_Propellants" [makeArgument 0 thisArg]
in makeStream req
getRCSPropellantsStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream ([Data.Text.Text]))
getRCSPropellantsStream thisArg = requestStream $ getRCSPropellantsStreamReq thisArg
{-
- Whether the RCS thruster will fire when roll control input is given.
-}
getRCSRightEnabled :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSRightEnabled thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_RightEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSRightEnabledStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSRightEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_RightEnabled" [makeArgument 0 thisArg]
in makeStream req
getRCSRightEnabledStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSRightEnabledStream thisArg = requestStream $ getRCSRightEnabledStreamReq thisArg
{-
- Whether the RCS thruster will fire when roll control input is given.
-}
getRCSRollEnabled :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSRollEnabled thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_RollEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSRollEnabledStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSRollEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_RollEnabled" [makeArgument 0 thisArg]
in makeStream req
getRCSRollEnabledStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSRollEnabledStream thisArg = requestStream $ getRCSRollEnabledStreamReq thisArg
{-
- The current specific impulse of the RCS, in seconds. Returns zero
- if the RCS is not active.
-}
getRCSSpecificImpulse :: KRPCHS.SpaceCenter.RCS -> RPCContext (Float)
getRCSSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_SpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Float)
getRCSSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_SpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getRCSSpecificImpulseStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Float))
getRCSSpecificImpulseStream thisArg = requestStream $ getRCSSpecificImpulseStreamReq thisArg
{-
- A list of thrusters, one of each nozzel in the RCS part.
-}
getRCSThrusters :: KRPCHS.SpaceCenter.RCS -> RPCContext ([KRPCHS.SpaceCenter.Thruster])
getRCSThrusters thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_Thrusters" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSThrustersStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq ([KRPCHS.SpaceCenter.Thruster])
getRCSThrustersStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_Thrusters" [makeArgument 0 thisArg]
in makeStream req
getRCSThrustersStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Thruster]))
getRCSThrustersStream thisArg = requestStream $ getRCSThrustersStreamReq thisArg
{-
- Whether the RCS thruster will fire when yaw control input is given.
-}
getRCSUpEnabled :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSUpEnabled thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_UpEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSUpEnabledStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSUpEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_UpEnabled" [makeArgument 0 thisArg]
in makeStream req
getRCSUpEnabledStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSUpEnabledStream thisArg = requestStream $ getRCSUpEnabledStreamReq thisArg
{-
- The vacuum specific impulse of the RCS, in seconds.
-}
getRCSVacuumSpecificImpulse :: KRPCHS.SpaceCenter.RCS -> RPCContext (Float)
getRCSVacuumSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_VacuumSpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSVacuumSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Float)
getRCSVacuumSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_VacuumSpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getRCSVacuumSpecificImpulseStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Float))
getRCSVacuumSpecificImpulseStream thisArg = requestStream $ getRCSVacuumSpecificImpulseStreamReq thisArg
{-
- Whether the RCS thruster will fire when yaw control input is given.
-}
getRCSYawEnabled :: KRPCHS.SpaceCenter.RCS -> RPCContext (Bool)
getRCSYawEnabled thisArg = do
let r = makeRequest "SpaceCenter" "RCS_get_YawEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRCSYawEnabledStreamReq :: KRPCHS.SpaceCenter.RCS -> KRPCStreamReq (Bool)
getRCSYawEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "RCS_get_YawEnabled" [makeArgument 0 thisArg]
in makeStream req
getRCSYawEnabledStream :: KRPCHS.SpaceCenter.RCS -> RPCContext (KRPCStream (Bool))
getRCSYawEnabledStream thisArg = requestStream $ getRCSYawEnabledStreamReq thisArg
{-
- Whether the RCS thrusters are enabled.
-}
setRCSEnabled :: KRPCHS.SpaceCenter.RCS -> Bool -> RPCContext ()
setRCSEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "RCS_set_Enabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the RCS thruster will fire when pitch control input is given.
-}
setRCSForwardEnabled :: KRPCHS.SpaceCenter.RCS -> Bool -> RPCContext ()
setRCSForwardEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "RCS_set_ForwardEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the RCS thruster will fire when pitch control input is given.
-}
setRCSPitchEnabled :: KRPCHS.SpaceCenter.RCS -> Bool -> RPCContext ()
setRCSPitchEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "RCS_set_PitchEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the RCS thruster will fire when roll control input is given.
-}
setRCSRightEnabled :: KRPCHS.SpaceCenter.RCS -> Bool -> RPCContext ()
setRCSRightEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "RCS_set_RightEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the RCS thruster will fire when roll control input is given.
-}
setRCSRollEnabled :: KRPCHS.SpaceCenter.RCS -> Bool -> RPCContext ()
setRCSRollEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "RCS_set_RollEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the RCS thruster will fire when yaw control input is given.
-}
setRCSUpEnabled :: KRPCHS.SpaceCenter.RCS -> Bool -> RPCContext ()
setRCSUpEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "RCS_set_UpEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the RCS thruster will fire when yaw control input is given.
-}
setRCSYawEnabled :: KRPCHS.SpaceCenter.RCS -> Bool -> RPCContext ()
setRCSYawEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "RCS_set_YawEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the radiator is deployable.
-}
getRadiatorDeployable :: KRPCHS.SpaceCenter.Radiator -> RPCContext (Bool)
getRadiatorDeployable thisArg = do
let r = makeRequest "SpaceCenter" "Radiator_get_Deployable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRadiatorDeployableStreamReq :: KRPCHS.SpaceCenter.Radiator -> KRPCStreamReq (Bool)
getRadiatorDeployableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Radiator_get_Deployable" [makeArgument 0 thisArg]
in makeStream req
getRadiatorDeployableStream :: KRPCHS.SpaceCenter.Radiator -> RPCContext (KRPCStream (Bool))
getRadiatorDeployableStream thisArg = requestStream $ getRadiatorDeployableStreamReq thisArg
{-
- For a deployable radiator,trueif the radiator is extended.
- If the radiator is not deployable, this is alwaystrue.
-}
getRadiatorDeployed :: KRPCHS.SpaceCenter.Radiator -> RPCContext (Bool)
getRadiatorDeployed thisArg = do
let r = makeRequest "SpaceCenter" "Radiator_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRadiatorDeployedStreamReq :: KRPCHS.SpaceCenter.Radiator -> KRPCStreamReq (Bool)
getRadiatorDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Radiator_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getRadiatorDeployedStream :: KRPCHS.SpaceCenter.Radiator -> RPCContext (KRPCStream (Bool))
getRadiatorDeployedStream thisArg = requestStream $ getRadiatorDeployedStreamReq thisArg
{-
- The part object for this radiator.
-}
getRadiatorPart :: KRPCHS.SpaceCenter.Radiator -> RPCContext (KRPCHS.SpaceCenter.Part)
getRadiatorPart thisArg = do
let r = makeRequest "SpaceCenter" "Radiator_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRadiatorPartStreamReq :: KRPCHS.SpaceCenter.Radiator -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getRadiatorPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Radiator_get_Part" [makeArgument 0 thisArg]
in makeStream req
getRadiatorPartStream :: KRPCHS.SpaceCenter.Radiator -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getRadiatorPartStream thisArg = requestStream $ getRadiatorPartStreamReq thisArg
{-
- The current state of the radiator.A fixed radiator is always <see cref="M:SpaceCenter.RadiatorState.Extended" />.
-}
getRadiatorState :: KRPCHS.SpaceCenter.Radiator -> RPCContext (KRPCHS.SpaceCenter.RadiatorState)
getRadiatorState thisArg = do
let r = makeRequest "SpaceCenter" "Radiator_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getRadiatorStateStreamReq :: KRPCHS.SpaceCenter.Radiator -> KRPCStreamReq (KRPCHS.SpaceCenter.RadiatorState)
getRadiatorStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Radiator_get_State" [makeArgument 0 thisArg]
in makeStream req
getRadiatorStateStream :: KRPCHS.SpaceCenter.Radiator -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.RadiatorState))
getRadiatorStateStream thisArg = requestStream $ getRadiatorStateStreamReq thisArg
{-
- For a deployable radiator,trueif the radiator is extended.
- If the radiator is not deployable, this is alwaystrue.
-}
setRadiatorDeployed :: KRPCHS.SpaceCenter.Radiator -> Bool -> RPCContext ()
setRadiatorDeployed thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Radiator_set_Deployed" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the reaction wheel is active.
-}
getReactionWheelActive :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (Bool)
getReactionWheelActive thisArg = do
let r = makeRequest "SpaceCenter" "ReactionWheel_get_Active" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getReactionWheelActiveStreamReq :: KRPCHS.SpaceCenter.ReactionWheel -> KRPCStreamReq (Bool)
getReactionWheelActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ReactionWheel_get_Active" [makeArgument 0 thisArg]
in makeStream req
getReactionWheelActiveStream :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (KRPCStream (Bool))
getReactionWheelActiveStream thisArg = requestStream $ getReactionWheelActiveStreamReq thisArg
{-
- The available torque in the pitch, roll and yaw axes of the vessel, in Newton meters.
- These axes correspond to the coordinate axes of the <see cref="M:SpaceCenter.Vessel.ReferenceFrame" />.
- Returns zero if the reaction wheel is inactive or broken.
-}
getReactionWheelAvailableTorque :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getReactionWheelAvailableTorque thisArg = do
let r = makeRequest "SpaceCenter" "ReactionWheel_get_AvailableTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getReactionWheelAvailableTorqueStreamReq :: KRPCHS.SpaceCenter.ReactionWheel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getReactionWheelAvailableTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ReactionWheel_get_AvailableTorque" [makeArgument 0 thisArg]
in makeStream req
getReactionWheelAvailableTorqueStream :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getReactionWheelAvailableTorqueStream thisArg = requestStream $ getReactionWheelAvailableTorqueStreamReq thisArg
{-
- Whether the reaction wheel is broken.
-}
getReactionWheelBroken :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (Bool)
getReactionWheelBroken thisArg = do
let r = makeRequest "SpaceCenter" "ReactionWheel_get_Broken" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getReactionWheelBrokenStreamReq :: KRPCHS.SpaceCenter.ReactionWheel -> KRPCStreamReq (Bool)
getReactionWheelBrokenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ReactionWheel_get_Broken" [makeArgument 0 thisArg]
in makeStream req
getReactionWheelBrokenStream :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (KRPCStream (Bool))
getReactionWheelBrokenStream thisArg = requestStream $ getReactionWheelBrokenStreamReq thisArg
{-
- The maximum torque the reaction wheel can provide, is it active,
- in the pitch, roll and yaw axes of the vessel, in Newton meters.
- These axes correspond to the coordinate axes of the <see cref="M:SpaceCenter.Vessel.ReferenceFrame" />.
-}
getReactionWheelMaxTorque :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getReactionWheelMaxTorque thisArg = do
let r = makeRequest "SpaceCenter" "ReactionWheel_get_MaxTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getReactionWheelMaxTorqueStreamReq :: KRPCHS.SpaceCenter.ReactionWheel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getReactionWheelMaxTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ReactionWheel_get_MaxTorque" [makeArgument 0 thisArg]
in makeStream req
getReactionWheelMaxTorqueStream :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getReactionWheelMaxTorqueStream thisArg = requestStream $ getReactionWheelMaxTorqueStreamReq thisArg
{-
- The part object for this reaction wheel.
-}
getReactionWheelPart :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (KRPCHS.SpaceCenter.Part)
getReactionWheelPart thisArg = do
let r = makeRequest "SpaceCenter" "ReactionWheel_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getReactionWheelPartStreamReq :: KRPCHS.SpaceCenter.ReactionWheel -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getReactionWheelPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ReactionWheel_get_Part" [makeArgument 0 thisArg]
in makeStream req
getReactionWheelPartStream :: KRPCHS.SpaceCenter.ReactionWheel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getReactionWheelPartStream thisArg = requestStream $ getReactionWheelPartStreamReq thisArg
{-
- Whether the reaction wheel is active.
-}
setReactionWheelActive :: KRPCHS.SpaceCenter.ReactionWheel -> Bool -> RPCContext ()
setReactionWheelActive thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ReactionWheel_set_Active" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Create a hybrid reference frame, which is a custom reference frame
- whose components are inherited from other reference frames.<param name="position">The reference frame providing the position of the origin.<param name="rotation">The reference frame providing the orientation of the frame.<param name="velocity">The reference frame providing the linear velocity of the frame.<param name="angularVelocity">The reference frame providing the angular velocity of the frame.The <paramref name="position" /> is required but all other reference frames are optional.
- If omitted, they are set to the <paramref name="position" /> reference frame.
-}
referenceFrameCreateHybrid :: KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
referenceFrameCreateHybrid positionArg rotationArg velocityArg angularVelocityArg = do
let r = makeRequest "SpaceCenter" "ReferenceFrame_CreateHybrid" [makeArgument 0 positionArg, makeArgument 1 rotationArg, makeArgument 2 velocityArg, makeArgument 3 angularVelocityArg]
res <- sendRequest r
processResponse res
referenceFrameCreateHybridStreamReq :: KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
referenceFrameCreateHybridStreamReq positionArg rotationArg velocityArg angularVelocityArg =
let req = makeRequest "SpaceCenter" "ReferenceFrame_CreateHybrid" [makeArgument 0 positionArg, makeArgument 1 rotationArg, makeArgument 2 velocityArg, makeArgument 3 angularVelocityArg]
in makeStream req
referenceFrameCreateHybridStream :: KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
referenceFrameCreateHybridStream positionArg rotationArg velocityArg angularVelocityArg = requestStream $ referenceFrameCreateHybridStreamReq positionArg rotationArg velocityArg angularVelocityArg
{-
- Create a relative reference frame.<param name="referenceFrame">The parent reference frame.<param name="position">The offset of the position of the origin.<param name="rotation">The rotation to apply to the parent frames rotation, as a quaternion. Defaults to zero.<param name="velocity">The linear velocity to offset the parent frame by. Defaults to zero.<param name="angularVelocity">The angular velocity to offset the parent frame by. Defaults to zero.
-}
referenceFrameCreateRelative :: KRPCHS.SpaceCenter.ReferenceFrame -> (Double, Double, Double) -> (Double, Double, Double, Double) -> (Double, Double, Double) -> (Double, Double, Double) -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
referenceFrameCreateRelative referenceFrameArg positionArg rotationArg velocityArg angularVelocityArg = do
let r = makeRequest "SpaceCenter" "ReferenceFrame_CreateRelative" [makeArgument 0 referenceFrameArg, makeArgument 1 positionArg, makeArgument 2 rotationArg, makeArgument 3 velocityArg, makeArgument 4 angularVelocityArg]
res <- sendRequest r
processResponse res
referenceFrameCreateRelativeStreamReq :: KRPCHS.SpaceCenter.ReferenceFrame -> (Double, Double, Double) -> (Double, Double, Double, Double) -> (Double, Double, Double) -> (Double, Double, Double) -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
referenceFrameCreateRelativeStreamReq referenceFrameArg positionArg rotationArg velocityArg angularVelocityArg =
let req = makeRequest "SpaceCenter" "ReferenceFrame_CreateRelative" [makeArgument 0 referenceFrameArg, makeArgument 1 positionArg, makeArgument 2 rotationArg, makeArgument 3 velocityArg, makeArgument 4 angularVelocityArg]
in makeStream req
referenceFrameCreateRelativeStream :: KRPCHS.SpaceCenter.ReferenceFrame -> (Double, Double, Double) -> (Double, Double, Double, Double) -> (Double, Double, Double) -> (Double, Double, Double) -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
referenceFrameCreateRelativeStream referenceFrameArg positionArg rotationArg velocityArg angularVelocityArg = requestStream $ referenceFrameCreateRelativeStreamReq referenceFrameArg positionArg rotationArg velocityArg angularVelocityArg
{-
- True if the specified converter is active.<param name="index">Index of the converter.
-}
resourceConverterActive :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (Bool)
resourceConverterActive thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_Active" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
resourceConverterActiveStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> KRPCStreamReq (Bool)
resourceConverterActiveStreamReq thisArg indexArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_Active" [makeArgument 0 thisArg, makeArgument 1 indexArg]
in makeStream req
resourceConverterActiveStream :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (KRPCStream (Bool))
resourceConverterActiveStream thisArg indexArg = requestStream $ resourceConverterActiveStreamReq thisArg indexArg
{-
- List of the names of resources consumed by the specified converter.<param name="index">Index of the converter.
-}
resourceConverterInputs :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext ([Data.Text.Text])
resourceConverterInputs thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_Inputs" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
resourceConverterInputsStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> KRPCStreamReq ([Data.Text.Text])
resourceConverterInputsStreamReq thisArg indexArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_Inputs" [makeArgument 0 thisArg, makeArgument 1 indexArg]
in makeStream req
resourceConverterInputsStream :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (KRPCStream ([Data.Text.Text]))
resourceConverterInputsStream thisArg indexArg = requestStream $ resourceConverterInputsStreamReq thisArg indexArg
{-
- The name of the specified converter.<param name="index">Index of the converter.
-}
resourceConverterName :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (Data.Text.Text)
resourceConverterName thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_Name" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
resourceConverterNameStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> KRPCStreamReq (Data.Text.Text)
resourceConverterNameStreamReq thisArg indexArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_Name" [makeArgument 0 thisArg, makeArgument 1 indexArg]
in makeStream req
resourceConverterNameStream :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (KRPCStream (Data.Text.Text))
resourceConverterNameStream thisArg indexArg = requestStream $ resourceConverterNameStreamReq thisArg indexArg
{-
- List of the names of resources produced by the specified converter.<param name="index">Index of the converter.
-}
resourceConverterOutputs :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext ([Data.Text.Text])
resourceConverterOutputs thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_Outputs" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
resourceConverterOutputsStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> KRPCStreamReq ([Data.Text.Text])
resourceConverterOutputsStreamReq thisArg indexArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_Outputs" [makeArgument 0 thisArg, makeArgument 1 indexArg]
in makeStream req
resourceConverterOutputsStream :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (KRPCStream ([Data.Text.Text]))
resourceConverterOutputsStream thisArg indexArg = requestStream $ resourceConverterOutputsStreamReq thisArg indexArg
{-
- Start the specified converter.<param name="index">Index of the converter.
-}
resourceConverterStart :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext ()
resourceConverterStart thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_Start" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
{-
- The state of the specified converter.<param name="index">Index of the converter.
-}
resourceConverterState :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (KRPCHS.SpaceCenter.ResourceConverterState)
resourceConverterState thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_State" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
resourceConverterStateStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> KRPCStreamReq (KRPCHS.SpaceCenter.ResourceConverterState)
resourceConverterStateStreamReq thisArg indexArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_State" [makeArgument 0 thisArg, makeArgument 1 indexArg]
in makeStream req
resourceConverterStateStream :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ResourceConverterState))
resourceConverterStateStream thisArg indexArg = requestStream $ resourceConverterStateStreamReq thisArg indexArg
{-
- Status information for the specified converter.
- This is the full status message shown in the in-game UI.<param name="index">Index of the converter.
-}
resourceConverterStatusInfo :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (Data.Text.Text)
resourceConverterStatusInfo thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_StatusInfo" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
resourceConverterStatusInfoStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> KRPCStreamReq (Data.Text.Text)
resourceConverterStatusInfoStreamReq thisArg indexArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_StatusInfo" [makeArgument 0 thisArg, makeArgument 1 indexArg]
in makeStream req
resourceConverterStatusInfoStream :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext (KRPCStream (Data.Text.Text))
resourceConverterStatusInfoStream thisArg indexArg = requestStream $ resourceConverterStatusInfoStreamReq thisArg indexArg
{-
- Stop the specified converter.<param name="index">Index of the converter.
-}
resourceConverterStop :: KRPCHS.SpaceCenter.ResourceConverter -> Data.Int.Int32 -> RPCContext ()
resourceConverterStop thisArg indexArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_Stop" [makeArgument 0 thisArg, makeArgument 1 indexArg]
res <- sendRequest r
processResponse res
{-
- The number of converters in the part.
-}
getResourceConverterCount :: KRPCHS.SpaceCenter.ResourceConverter -> RPCContext (Data.Int.Int32)
getResourceConverterCount thisArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_get_Count" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceConverterCountStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> KRPCStreamReq (Data.Int.Int32)
getResourceConverterCountStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_get_Count" [makeArgument 0 thisArg]
in makeStream req
getResourceConverterCountStream :: KRPCHS.SpaceCenter.ResourceConverter -> RPCContext (KRPCStream (Data.Int.Int32))
getResourceConverterCountStream thisArg = requestStream $ getResourceConverterCountStreamReq thisArg
{-
- The part object for this converter.
-}
getResourceConverterPart :: KRPCHS.SpaceCenter.ResourceConverter -> RPCContext (KRPCHS.SpaceCenter.Part)
getResourceConverterPart thisArg = do
let r = makeRequest "SpaceCenter" "ResourceConverter_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceConverterPartStreamReq :: KRPCHS.SpaceCenter.ResourceConverter -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getResourceConverterPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceConverter_get_Part" [makeArgument 0 thisArg]
in makeStream req
getResourceConverterPartStream :: KRPCHS.SpaceCenter.ResourceConverter -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getResourceConverterPartStream thisArg = requestStream $ getResourceConverterPartStreamReq thisArg
{-
- Whether the harvester is actively drilling.
-}
getResourceHarvesterActive :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (Bool)
getResourceHarvesterActive thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_Active" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterActiveStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (Bool)
getResourceHarvesterActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_Active" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterActiveStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (Bool))
getResourceHarvesterActiveStream thisArg = requestStream $ getResourceHarvesterActiveStreamReq thisArg
{-
- The core temperature of the drill, in Kelvin.
-}
getResourceHarvesterCoreTemperature :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (Float)
getResourceHarvesterCoreTemperature thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_CoreTemperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterCoreTemperatureStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (Float)
getResourceHarvesterCoreTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_CoreTemperature" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterCoreTemperatureStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (Float))
getResourceHarvesterCoreTemperatureStream thisArg = requestStream $ getResourceHarvesterCoreTemperatureStreamReq thisArg
{-
- Whether the harvester is deployed.
-}
getResourceHarvesterDeployed :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (Bool)
getResourceHarvesterDeployed thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterDeployedStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (Bool)
getResourceHarvesterDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterDeployedStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (Bool))
getResourceHarvesterDeployedStream thisArg = requestStream $ getResourceHarvesterDeployedStreamReq thisArg
{-
- The rate at which the drill is extracting ore, in units per second.
-}
getResourceHarvesterExtractionRate :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (Float)
getResourceHarvesterExtractionRate thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_ExtractionRate" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterExtractionRateStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (Float)
getResourceHarvesterExtractionRateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_ExtractionRate" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterExtractionRateStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (Float))
getResourceHarvesterExtractionRateStream thisArg = requestStream $ getResourceHarvesterExtractionRateStreamReq thisArg
{-
- The core temperature at which the drill will operate with peak efficiency, in Kelvin.
-}
getResourceHarvesterOptimumCoreTemperature :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (Float)
getResourceHarvesterOptimumCoreTemperature thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_OptimumCoreTemperature" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterOptimumCoreTemperatureStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (Float)
getResourceHarvesterOptimumCoreTemperatureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_OptimumCoreTemperature" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterOptimumCoreTemperatureStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (Float))
getResourceHarvesterOptimumCoreTemperatureStream thisArg = requestStream $ getResourceHarvesterOptimumCoreTemperatureStreamReq thisArg
{-
- The part object for this harvester.
-}
getResourceHarvesterPart :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCHS.SpaceCenter.Part)
getResourceHarvesterPart thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterPartStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getResourceHarvesterPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_Part" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterPartStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getResourceHarvesterPartStream thisArg = requestStream $ getResourceHarvesterPartStreamReq thisArg
{-
- The state of the harvester.
-}
getResourceHarvesterState :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCHS.SpaceCenter.ResourceHarvesterState)
getResourceHarvesterState thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterStateStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (KRPCHS.SpaceCenter.ResourceHarvesterState)
getResourceHarvesterStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_State" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterStateStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ResourceHarvesterState))
getResourceHarvesterStateStream thisArg = requestStream $ getResourceHarvesterStateStreamReq thisArg
{-
- The thermal efficiency of the drill, as a percentage of its maximum.
-}
getResourceHarvesterThermalEfficiency :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (Float)
getResourceHarvesterThermalEfficiency thisArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_get_ThermalEfficiency" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceHarvesterThermalEfficiencyStreamReq :: KRPCHS.SpaceCenter.ResourceHarvester -> KRPCStreamReq (Float)
getResourceHarvesterThermalEfficiencyStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceHarvester_get_ThermalEfficiency" [makeArgument 0 thisArg]
in makeStream req
getResourceHarvesterThermalEfficiencyStream :: KRPCHS.SpaceCenter.ResourceHarvester -> RPCContext (KRPCStream (Float))
getResourceHarvesterThermalEfficiencyStream thisArg = requestStream $ getResourceHarvesterThermalEfficiencyStreamReq thisArg
{-
- Whether the harvester is actively drilling.
-}
setResourceHarvesterActive :: KRPCHS.SpaceCenter.ResourceHarvester -> Bool -> RPCContext ()
setResourceHarvesterActive thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_set_Active" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the harvester is deployed.
-}
setResourceHarvesterDeployed :: KRPCHS.SpaceCenter.ResourceHarvester -> Bool -> RPCContext ()
setResourceHarvesterDeployed thisArg valueArg = do
let r = makeRequest "SpaceCenter" "ResourceHarvester_set_Deployed" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Start transferring a resource transfer between a pair of parts. The transfer will move at most
- <paramref name="maxAmount" /> units of the resource, depending on how much of the resource is
- available in the source part and how much storage is available in the destination part.
- Use <see cref="M:SpaceCenter.ResourceTransfer.Complete" /> to check if the transfer is complete.
- Use <see cref="M:SpaceCenter.ResourceTransfer.Amount" /> to see how much of the resource has been transferred.<param name="fromPart">The part to transfer to.<param name="toPart">The part to transfer from.<param name="resource">The name of the resource to transfer.<param name="maxAmount">The maximum amount of resource to transfer.
-}
resourceTransferStart :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.Part -> Data.Text.Text -> Float -> RPCContext (KRPCHS.SpaceCenter.ResourceTransfer)
resourceTransferStart fromPartArg toPartArg resourceArg maxAmountArg = do
let r = makeRequest "SpaceCenter" "ResourceTransfer_Start" [makeArgument 0 fromPartArg, makeArgument 1 toPartArg, makeArgument 2 resourceArg, makeArgument 3 maxAmountArg]
res <- sendRequest r
processResponse res
resourceTransferStartStreamReq :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.Part -> Data.Text.Text -> Float -> KRPCStreamReq (KRPCHS.SpaceCenter.ResourceTransfer)
resourceTransferStartStreamReq fromPartArg toPartArg resourceArg maxAmountArg =
let req = makeRequest "SpaceCenter" "ResourceTransfer_Start" [makeArgument 0 fromPartArg, makeArgument 1 toPartArg, makeArgument 2 resourceArg, makeArgument 3 maxAmountArg]
in makeStream req
resourceTransferStartStream :: KRPCHS.SpaceCenter.Part -> KRPCHS.SpaceCenter.Part -> Data.Text.Text -> Float -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ResourceTransfer))
resourceTransferStartStream fromPartArg toPartArg resourceArg maxAmountArg = requestStream $ resourceTransferStartStreamReq fromPartArg toPartArg resourceArg maxAmountArg
{-
- The amount of the resource that has been transferred.
-}
getResourceTransferAmount :: KRPCHS.SpaceCenter.ResourceTransfer -> RPCContext (Float)
getResourceTransferAmount thisArg = do
let r = makeRequest "SpaceCenter" "ResourceTransfer_get_Amount" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceTransferAmountStreamReq :: KRPCHS.SpaceCenter.ResourceTransfer -> KRPCStreamReq (Float)
getResourceTransferAmountStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceTransfer_get_Amount" [makeArgument 0 thisArg]
in makeStream req
getResourceTransferAmountStream :: KRPCHS.SpaceCenter.ResourceTransfer -> RPCContext (KRPCStream (Float))
getResourceTransferAmountStream thisArg = requestStream $ getResourceTransferAmountStreamReq thisArg
{-
- Whether the transfer has completed.
-}
getResourceTransferComplete :: KRPCHS.SpaceCenter.ResourceTransfer -> RPCContext (Bool)
getResourceTransferComplete thisArg = do
let r = makeRequest "SpaceCenter" "ResourceTransfer_get_Complete" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceTransferCompleteStreamReq :: KRPCHS.SpaceCenter.ResourceTransfer -> KRPCStreamReq (Bool)
getResourceTransferCompleteStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ResourceTransfer_get_Complete" [makeArgument 0 thisArg]
in makeStream req
getResourceTransferCompleteStream :: KRPCHS.SpaceCenter.ResourceTransfer -> RPCContext (KRPCStream (Bool))
getResourceTransferCompleteStream thisArg = requestStream $ getResourceTransferCompleteStreamReq thisArg
{-
- The amount of the resource that is currently stored in the part.
-}
getResourceAmount :: KRPCHS.SpaceCenter.Resource -> RPCContext (Float)
getResourceAmount thisArg = do
let r = makeRequest "SpaceCenter" "Resource_get_Amount" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceAmountStreamReq :: KRPCHS.SpaceCenter.Resource -> KRPCStreamReq (Float)
getResourceAmountStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resource_get_Amount" [makeArgument 0 thisArg]
in makeStream req
getResourceAmountStream :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCStream (Float))
getResourceAmountStream thisArg = requestStream $ getResourceAmountStreamReq thisArg
{-
- The density of the resource, inkg/l.
-}
getResourceDensity :: KRPCHS.SpaceCenter.Resource -> RPCContext (Float)
getResourceDensity thisArg = do
let r = makeRequest "SpaceCenter" "Resource_get_Density" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceDensityStreamReq :: KRPCHS.SpaceCenter.Resource -> KRPCStreamReq (Float)
getResourceDensityStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resource_get_Density" [makeArgument 0 thisArg]
in makeStream req
getResourceDensityStream :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCStream (Float))
getResourceDensityStream thisArg = requestStream $ getResourceDensityStreamReq thisArg
{-
- Whether use of this resource is enabled.
-}
getResourceEnabled :: KRPCHS.SpaceCenter.Resource -> RPCContext (Bool)
getResourceEnabled thisArg = do
let r = makeRequest "SpaceCenter" "Resource_get_Enabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceEnabledStreamReq :: KRPCHS.SpaceCenter.Resource -> KRPCStreamReq (Bool)
getResourceEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resource_get_Enabled" [makeArgument 0 thisArg]
in makeStream req
getResourceEnabledStream :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCStream (Bool))
getResourceEnabledStream thisArg = requestStream $ getResourceEnabledStreamReq thisArg
{-
- The flow mode of the resource.
-}
getResourceFlowMode :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCHS.SpaceCenter.ResourceFlowMode)
getResourceFlowMode thisArg = do
let r = makeRequest "SpaceCenter" "Resource_get_FlowMode" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceFlowModeStreamReq :: KRPCHS.SpaceCenter.Resource -> KRPCStreamReq (KRPCHS.SpaceCenter.ResourceFlowMode)
getResourceFlowModeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resource_get_FlowMode" [makeArgument 0 thisArg]
in makeStream req
getResourceFlowModeStream :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ResourceFlowMode))
getResourceFlowModeStream thisArg = requestStream $ getResourceFlowModeStreamReq thisArg
{-
- The total amount of the resource that can be stored in the part.
-}
getResourceMax :: KRPCHS.SpaceCenter.Resource -> RPCContext (Float)
getResourceMax thisArg = do
let r = makeRequest "SpaceCenter" "Resource_get_Max" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceMaxStreamReq :: KRPCHS.SpaceCenter.Resource -> KRPCStreamReq (Float)
getResourceMaxStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resource_get_Max" [makeArgument 0 thisArg]
in makeStream req
getResourceMaxStream :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCStream (Float))
getResourceMaxStream thisArg = requestStream $ getResourceMaxStreamReq thisArg
{-
- The name of the resource.
-}
getResourceName :: KRPCHS.SpaceCenter.Resource -> RPCContext (Data.Text.Text)
getResourceName thisArg = do
let r = makeRequest "SpaceCenter" "Resource_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourceNameStreamReq :: KRPCHS.SpaceCenter.Resource -> KRPCStreamReq (Data.Text.Text)
getResourceNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resource_get_Name" [makeArgument 0 thisArg]
in makeStream req
getResourceNameStream :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCStream (Data.Text.Text))
getResourceNameStream thisArg = requestStream $ getResourceNameStreamReq thisArg
{-
- The part containing the resource.
-}
getResourcePart :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCHS.SpaceCenter.Part)
getResourcePart thisArg = do
let r = makeRequest "SpaceCenter" "Resource_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourcePartStreamReq :: KRPCHS.SpaceCenter.Resource -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getResourcePartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resource_get_Part" [makeArgument 0 thisArg]
in makeStream req
getResourcePartStream :: KRPCHS.SpaceCenter.Resource -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getResourcePartStream thisArg = requestStream $ getResourcePartStreamReq thisArg
{-
- Whether use of this resource is enabled.
-}
setResourceEnabled :: KRPCHS.SpaceCenter.Resource -> Bool -> RPCContext ()
setResourceEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Resource_set_Enabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Returns the amount of a resource that is currently stored.<param name="name">The name of the resource.
-}
resourcesAmount :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext (Float)
resourcesAmount thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Resources_Amount" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
resourcesAmountStreamReq :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> KRPCStreamReq (Float)
resourcesAmountStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Resources_Amount" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
resourcesAmountStream :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext (KRPCStream (Float))
resourcesAmountStream thisArg nameArg = requestStream $ resourcesAmountStreamReq thisArg nameArg
{-
- Returns the density of a resource, in kg/l.<param name="name">The name of the resource.
-}
resourcesDensity :: Data.Text.Text -> RPCContext (Float)
resourcesDensity nameArg = do
let r = makeRequest "SpaceCenter" "Resources_Density" [makeArgument 0 nameArg]
res <- sendRequest r
processResponse res
resourcesDensityStreamReq :: Data.Text.Text -> KRPCStreamReq (Float)
resourcesDensityStreamReq nameArg =
let req = makeRequest "SpaceCenter" "Resources_Density" [makeArgument 0 nameArg]
in makeStream req
resourcesDensityStream :: Data.Text.Text -> RPCContext (KRPCStream (Float))
resourcesDensityStream nameArg = requestStream $ resourcesDensityStreamReq nameArg
{-
- Returns the flow mode of a resource.<param name="name">The name of the resource.
-}
resourcesFlowMode :: Data.Text.Text -> RPCContext (KRPCHS.SpaceCenter.ResourceFlowMode)
resourcesFlowMode nameArg = do
let r = makeRequest "SpaceCenter" "Resources_FlowMode" [makeArgument 0 nameArg]
res <- sendRequest r
processResponse res
resourcesFlowModeStreamReq :: Data.Text.Text -> KRPCStreamReq (KRPCHS.SpaceCenter.ResourceFlowMode)
resourcesFlowModeStreamReq nameArg =
let req = makeRequest "SpaceCenter" "Resources_FlowMode" [makeArgument 0 nameArg]
in makeStream req
resourcesFlowModeStream :: Data.Text.Text -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ResourceFlowMode))
resourcesFlowModeStream nameArg = requestStream $ resourcesFlowModeStreamReq nameArg
{-
- Check whether the named resource can be stored.<param name="name">The name of the resource.
-}
resourcesHasResource :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext (Bool)
resourcesHasResource thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Resources_HasResource" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
resourcesHasResourceStreamReq :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> KRPCStreamReq (Bool)
resourcesHasResourceStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Resources_HasResource" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
resourcesHasResourceStream :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext (KRPCStream (Bool))
resourcesHasResourceStream thisArg nameArg = requestStream $ resourcesHasResourceStreamReq thisArg nameArg
{-
- Returns the amount of a resource that can be stored.<param name="name">The name of the resource.
-}
resourcesMax :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext (Float)
resourcesMax thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Resources_Max" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
resourcesMaxStreamReq :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> KRPCStreamReq (Float)
resourcesMaxStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Resources_Max" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
resourcesMaxStream :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext (KRPCStream (Float))
resourcesMaxStream thisArg nameArg = requestStream $ resourcesMaxStreamReq thisArg nameArg
{-
- All the individual resources with the given name that can be stored.
-}
resourcesWithResource :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext ([KRPCHS.SpaceCenter.Resource])
resourcesWithResource thisArg nameArg = do
let r = makeRequest "SpaceCenter" "Resources_WithResource" [makeArgument 0 thisArg, makeArgument 1 nameArg]
res <- sendRequest r
processResponse res
resourcesWithResourceStreamReq :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> KRPCStreamReq ([KRPCHS.SpaceCenter.Resource])
resourcesWithResourceStreamReq thisArg nameArg =
let req = makeRequest "SpaceCenter" "Resources_WithResource" [makeArgument 0 thisArg, makeArgument 1 nameArg]
in makeStream req
resourcesWithResourceStream :: KRPCHS.SpaceCenter.Resources -> Data.Text.Text -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Resource]))
resourcesWithResourceStream thisArg nameArg = requestStream $ resourcesWithResourceStreamReq thisArg nameArg
{-
- All the individual resources that can be stored.
-}
getResourcesAll :: KRPCHS.SpaceCenter.Resources -> RPCContext ([KRPCHS.SpaceCenter.Resource])
getResourcesAll thisArg = do
let r = makeRequest "SpaceCenter" "Resources_get_All" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourcesAllStreamReq :: KRPCHS.SpaceCenter.Resources -> KRPCStreamReq ([KRPCHS.SpaceCenter.Resource])
getResourcesAllStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resources_get_All" [makeArgument 0 thisArg]
in makeStream req
getResourcesAllStream :: KRPCHS.SpaceCenter.Resources -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Resource]))
getResourcesAllStream thisArg = requestStream $ getResourcesAllStreamReq thisArg
{-
- Whether use of all the resources are enabled.This is true if all of the resources are enabled. If any of the resources are not enabled, this is false.
-}
getResourcesEnabled :: KRPCHS.SpaceCenter.Resources -> RPCContext (Bool)
getResourcesEnabled thisArg = do
let r = makeRequest "SpaceCenter" "Resources_get_Enabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourcesEnabledStreamReq :: KRPCHS.SpaceCenter.Resources -> KRPCStreamReq (Bool)
getResourcesEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resources_get_Enabled" [makeArgument 0 thisArg]
in makeStream req
getResourcesEnabledStream :: KRPCHS.SpaceCenter.Resources -> RPCContext (KRPCStream (Bool))
getResourcesEnabledStream thisArg = requestStream $ getResourcesEnabledStreamReq thisArg
{-
- A list of resource names that can be stored.
-}
getResourcesNames :: KRPCHS.SpaceCenter.Resources -> RPCContext ([Data.Text.Text])
getResourcesNames thisArg = do
let r = makeRequest "SpaceCenter" "Resources_get_Names" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getResourcesNamesStreamReq :: KRPCHS.SpaceCenter.Resources -> KRPCStreamReq ([Data.Text.Text])
getResourcesNamesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Resources_get_Names" [makeArgument 0 thisArg]
in makeStream req
getResourcesNamesStream :: KRPCHS.SpaceCenter.Resources -> RPCContext (KRPCStream ([Data.Text.Text]))
getResourcesNamesStream thisArg = requestStream $ getResourcesNamesStreamReq thisArg
{-
- Whether use of all the resources are enabled.This is true if all of the resources are enabled. If any of the resources are not enabled, this is false.
-}
setResourcesEnabled :: KRPCHS.SpaceCenter.Resources -> Bool -> RPCContext ()
setResourcesEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Resources_set_Enabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Save the game with a given name.
- This will create a save file calledname.sfsin the folder of the current save game.
-}
save :: Data.Text.Text -> RPCContext ()
save nameArg = do
let r = makeRequest "SpaceCenter" "Save" [makeArgument 0 nameArg]
res <- sendRequest r
processResponse res
{-
- Data amount.
-}
getScienceDataDataAmount :: KRPCHS.SpaceCenter.ScienceData -> RPCContext (Float)
getScienceDataDataAmount thisArg = do
let r = makeRequest "SpaceCenter" "ScienceData_get_DataAmount" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceDataDataAmountStreamReq :: KRPCHS.SpaceCenter.ScienceData -> KRPCStreamReq (Float)
getScienceDataDataAmountStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceData_get_DataAmount" [makeArgument 0 thisArg]
in makeStream req
getScienceDataDataAmountStream :: KRPCHS.SpaceCenter.ScienceData -> RPCContext (KRPCStream (Float))
getScienceDataDataAmountStream thisArg = requestStream $ getScienceDataDataAmountStreamReq thisArg
{-
- Science value.
-}
getScienceDataScienceValue :: KRPCHS.SpaceCenter.ScienceData -> RPCContext (Float)
getScienceDataScienceValue thisArg = do
let r = makeRequest "SpaceCenter" "ScienceData_get_ScienceValue" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceDataScienceValueStreamReq :: KRPCHS.SpaceCenter.ScienceData -> KRPCStreamReq (Float)
getScienceDataScienceValueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceData_get_ScienceValue" [makeArgument 0 thisArg]
in makeStream req
getScienceDataScienceValueStream :: KRPCHS.SpaceCenter.ScienceData -> RPCContext (KRPCStream (Float))
getScienceDataScienceValueStream thisArg = requestStream $ getScienceDataScienceValueStreamReq thisArg
{-
- Transmit value.
-}
getScienceDataTransmitValue :: KRPCHS.SpaceCenter.ScienceData -> RPCContext (Float)
getScienceDataTransmitValue thisArg = do
let r = makeRequest "SpaceCenter" "ScienceData_get_TransmitValue" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceDataTransmitValueStreamReq :: KRPCHS.SpaceCenter.ScienceData -> KRPCStreamReq (Float)
getScienceDataTransmitValueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceData_get_TransmitValue" [makeArgument 0 thisArg]
in makeStream req
getScienceDataTransmitValueStream :: KRPCHS.SpaceCenter.ScienceData -> RPCContext (KRPCStream (Float))
getScienceDataTransmitValueStream thisArg = requestStream $ getScienceDataTransmitValueStreamReq thisArg
{-
- Multiply science value by this to determine data amount in mits.
-}
getScienceSubjectDataScale :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (Float)
getScienceSubjectDataScale thisArg = do
let r = makeRequest "SpaceCenter" "ScienceSubject_get_DataScale" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceSubjectDataScaleStreamReq :: KRPCHS.SpaceCenter.ScienceSubject -> KRPCStreamReq (Float)
getScienceSubjectDataScaleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceSubject_get_DataScale" [makeArgument 0 thisArg]
in makeStream req
getScienceSubjectDataScaleStream :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (KRPCStream (Float))
getScienceSubjectDataScaleStream thisArg = requestStream $ getScienceSubjectDataScaleStreamReq thisArg
{-
- Whether the experiment has been completed.
-}
getScienceSubjectIsComplete :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (Bool)
getScienceSubjectIsComplete thisArg = do
let r = makeRequest "SpaceCenter" "ScienceSubject_get_IsComplete" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceSubjectIsCompleteStreamReq :: KRPCHS.SpaceCenter.ScienceSubject -> KRPCStreamReq (Bool)
getScienceSubjectIsCompleteStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceSubject_get_IsComplete" [makeArgument 0 thisArg]
in makeStream req
getScienceSubjectIsCompleteStream :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (KRPCStream (Bool))
getScienceSubjectIsCompleteStream thisArg = requestStream $ getScienceSubjectIsCompleteStreamReq thisArg
{-
- Amount of science already earned from this subject, not updated until after transmission/recovery.
-}
getScienceSubjectScience :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (Float)
getScienceSubjectScience thisArg = do
let r = makeRequest "SpaceCenter" "ScienceSubject_get_Science" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceSubjectScienceStreamReq :: KRPCHS.SpaceCenter.ScienceSubject -> KRPCStreamReq (Float)
getScienceSubjectScienceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceSubject_get_Science" [makeArgument 0 thisArg]
in makeStream req
getScienceSubjectScienceStream :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (KRPCStream (Float))
getScienceSubjectScienceStream thisArg = requestStream $ getScienceSubjectScienceStreamReq thisArg
{-
- Total science allowable for this subject.
-}
getScienceSubjectScienceCap :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (Float)
getScienceSubjectScienceCap thisArg = do
let r = makeRequest "SpaceCenter" "ScienceSubject_get_ScienceCap" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceSubjectScienceCapStreamReq :: KRPCHS.SpaceCenter.ScienceSubject -> KRPCStreamReq (Float)
getScienceSubjectScienceCapStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceSubject_get_ScienceCap" [makeArgument 0 thisArg]
in makeStream req
getScienceSubjectScienceCapStream :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (KRPCStream (Float))
getScienceSubjectScienceCapStream thisArg = requestStream $ getScienceSubjectScienceCapStreamReq thisArg
{-
- Diminishing value multiplier for decreasing the science value returned from repeated experiments.
-}
getScienceSubjectScientificValue :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (Float)
getScienceSubjectScientificValue thisArg = do
let r = makeRequest "SpaceCenter" "ScienceSubject_get_ScientificValue" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceSubjectScientificValueStreamReq :: KRPCHS.SpaceCenter.ScienceSubject -> KRPCStreamReq (Float)
getScienceSubjectScientificValueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceSubject_get_ScientificValue" [makeArgument 0 thisArg]
in makeStream req
getScienceSubjectScientificValueStream :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (KRPCStream (Float))
getScienceSubjectScientificValueStream thisArg = requestStream $ getScienceSubjectScientificValueStreamReq thisArg
{-
- Multiplier for specific Celestial Body/Experiment Situation combination.
-}
getScienceSubjectSubjectValue :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (Float)
getScienceSubjectSubjectValue thisArg = do
let r = makeRequest "SpaceCenter" "ScienceSubject_get_SubjectValue" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceSubjectSubjectValueStreamReq :: KRPCHS.SpaceCenter.ScienceSubject -> KRPCStreamReq (Float)
getScienceSubjectSubjectValueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceSubject_get_SubjectValue" [makeArgument 0 thisArg]
in makeStream req
getScienceSubjectSubjectValueStream :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (KRPCStream (Float))
getScienceSubjectSubjectValueStream thisArg = requestStream $ getScienceSubjectSubjectValueStreamReq thisArg
{-
- Title of science subject, displayed in science archives
-}
getScienceSubjectTitle :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (Data.Text.Text)
getScienceSubjectTitle thisArg = do
let r = makeRequest "SpaceCenter" "ScienceSubject_get_Title" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getScienceSubjectTitleStreamReq :: KRPCHS.SpaceCenter.ScienceSubject -> KRPCStreamReq (Data.Text.Text)
getScienceSubjectTitleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "ScienceSubject_get_Title" [makeArgument 0 thisArg]
in makeStream req
getScienceSubjectTitleStream :: KRPCHS.SpaceCenter.ScienceSubject -> RPCContext (KRPCStream (Data.Text.Text))
getScienceSubjectTitleStream thisArg = requestStream $ getScienceSubjectTitleStreamReq thisArg
{-
- Whether the sensor is active.
-}
getSensorActive :: KRPCHS.SpaceCenter.Sensor -> RPCContext (Bool)
getSensorActive thisArg = do
let r = makeRequest "SpaceCenter" "Sensor_get_Active" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSensorActiveStreamReq :: KRPCHS.SpaceCenter.Sensor -> KRPCStreamReq (Bool)
getSensorActiveStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Sensor_get_Active" [makeArgument 0 thisArg]
in makeStream req
getSensorActiveStream :: KRPCHS.SpaceCenter.Sensor -> RPCContext (KRPCStream (Bool))
getSensorActiveStream thisArg = requestStream $ getSensorActiveStreamReq thisArg
{-
- The part object for this sensor.
-}
getSensorPart :: KRPCHS.SpaceCenter.Sensor -> RPCContext (KRPCHS.SpaceCenter.Part)
getSensorPart thisArg = do
let r = makeRequest "SpaceCenter" "Sensor_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSensorPartStreamReq :: KRPCHS.SpaceCenter.Sensor -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getSensorPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Sensor_get_Part" [makeArgument 0 thisArg]
in makeStream req
getSensorPartStream :: KRPCHS.SpaceCenter.Sensor -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getSensorPartStream thisArg = requestStream $ getSensorPartStreamReq thisArg
{-
- The current value of the sensor.
-}
getSensorValue :: KRPCHS.SpaceCenter.Sensor -> RPCContext (Data.Text.Text)
getSensorValue thisArg = do
let r = makeRequest "SpaceCenter" "Sensor_get_Value" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSensorValueStreamReq :: KRPCHS.SpaceCenter.Sensor -> KRPCStreamReq (Data.Text.Text)
getSensorValueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Sensor_get_Value" [makeArgument 0 thisArg]
in makeStream req
getSensorValueStream :: KRPCHS.SpaceCenter.Sensor -> RPCContext (KRPCStream (Data.Text.Text))
getSensorValueStream thisArg = requestStream $ getSensorValueStreamReq thisArg
{-
- Whether the sensor is active.
-}
setSensorActive :: KRPCHS.SpaceCenter.Sensor -> Bool -> RPCContext ()
setSensorActive thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Sensor_set_Active" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the solar panel is deployable.
-}
getSolarPanelDeployable :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (Bool)
getSolarPanelDeployable thisArg = do
let r = makeRequest "SpaceCenter" "SolarPanel_get_Deployable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSolarPanelDeployableStreamReq :: KRPCHS.SpaceCenter.SolarPanel -> KRPCStreamReq (Bool)
getSolarPanelDeployableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "SolarPanel_get_Deployable" [makeArgument 0 thisArg]
in makeStream req
getSolarPanelDeployableStream :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCStream (Bool))
getSolarPanelDeployableStream thisArg = requestStream $ getSolarPanelDeployableStreamReq thisArg
{-
- Whether the solar panel is extended.
-}
getSolarPanelDeployed :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (Bool)
getSolarPanelDeployed thisArg = do
let r = makeRequest "SpaceCenter" "SolarPanel_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSolarPanelDeployedStreamReq :: KRPCHS.SpaceCenter.SolarPanel -> KRPCStreamReq (Bool)
getSolarPanelDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "SolarPanel_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getSolarPanelDeployedStream :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCStream (Bool))
getSolarPanelDeployedStream thisArg = requestStream $ getSolarPanelDeployedStreamReq thisArg
{-
- The current amount of energy being generated by the solar panel, in
- units of charge per second.
-}
getSolarPanelEnergyFlow :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (Float)
getSolarPanelEnergyFlow thisArg = do
let r = makeRequest "SpaceCenter" "SolarPanel_get_EnergyFlow" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSolarPanelEnergyFlowStreamReq :: KRPCHS.SpaceCenter.SolarPanel -> KRPCStreamReq (Float)
getSolarPanelEnergyFlowStreamReq thisArg =
let req = makeRequest "SpaceCenter" "SolarPanel_get_EnergyFlow" [makeArgument 0 thisArg]
in makeStream req
getSolarPanelEnergyFlowStream :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCStream (Float))
getSolarPanelEnergyFlowStream thisArg = requestStream $ getSolarPanelEnergyFlowStreamReq thisArg
{-
- The part object for this solar panel.
-}
getSolarPanelPart :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCHS.SpaceCenter.Part)
getSolarPanelPart thisArg = do
let r = makeRequest "SpaceCenter" "SolarPanel_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSolarPanelPartStreamReq :: KRPCHS.SpaceCenter.SolarPanel -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getSolarPanelPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "SolarPanel_get_Part" [makeArgument 0 thisArg]
in makeStream req
getSolarPanelPartStream :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getSolarPanelPartStream thisArg = requestStream $ getSolarPanelPartStreamReq thisArg
{-
- The current state of the solar panel.
-}
getSolarPanelState :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCHS.SpaceCenter.SolarPanelState)
getSolarPanelState thisArg = do
let r = makeRequest "SpaceCenter" "SolarPanel_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSolarPanelStateStreamReq :: KRPCHS.SpaceCenter.SolarPanel -> KRPCStreamReq (KRPCHS.SpaceCenter.SolarPanelState)
getSolarPanelStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "SolarPanel_get_State" [makeArgument 0 thisArg]
in makeStream req
getSolarPanelStateStream :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.SolarPanelState))
getSolarPanelStateStream thisArg = requestStream $ getSolarPanelStateStreamReq thisArg
{-
- The current amount of sunlight that is incident on the solar panel,
- as a percentage. A value between 0 and 1.
-}
getSolarPanelSunExposure :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (Float)
getSolarPanelSunExposure thisArg = do
let r = makeRequest "SpaceCenter" "SolarPanel_get_SunExposure" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getSolarPanelSunExposureStreamReq :: KRPCHS.SpaceCenter.SolarPanel -> KRPCStreamReq (Float)
getSolarPanelSunExposureStreamReq thisArg =
let req = makeRequest "SpaceCenter" "SolarPanel_get_SunExposure" [makeArgument 0 thisArg]
in makeStream req
getSolarPanelSunExposureStream :: KRPCHS.SpaceCenter.SolarPanel -> RPCContext (KRPCStream (Float))
getSolarPanelSunExposureStream thisArg = requestStream $ getSolarPanelSunExposureStreamReq thisArg
{-
- Whether the solar panel is extended.
-}
setSolarPanelDeployed :: KRPCHS.SpaceCenter.SolarPanel -> Bool -> RPCContext ()
setSolarPanelDeployed thisArg valueArg = do
let r = makeRequest "SpaceCenter" "SolarPanel_set_Deployed" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Position around which the gimbal pivots.
-}
thrusterGimbalPosition :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
thrusterGimbalPosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Thruster_GimbalPosition" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
thrusterGimbalPositionStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
thrusterGimbalPositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Thruster_GimbalPosition" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
thrusterGimbalPositionStream :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
thrusterGimbalPositionStream thisArg referenceFrameArg = requestStream $ thrusterGimbalPositionStreamReq thisArg referenceFrameArg
{-
- The direction of the force generated by the thruster, when the engine is in its
- initial position (no gimballing), in the given reference frame.
- This is opposite to the direction in which the thruster expels propellant.<param name="referenceFrame">
-}
thrusterInitialThrustDirection :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
thrusterInitialThrustDirection thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Thruster_InitialThrustDirection" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
thrusterInitialThrustDirectionStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
thrusterInitialThrustDirectionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Thruster_InitialThrustDirection" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
thrusterInitialThrustDirectionStream :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
thrusterInitialThrustDirectionStream thisArg referenceFrameArg = requestStream $ thrusterInitialThrustDirectionStreamReq thisArg referenceFrameArg
{-
- The position at which the thruster generates thrust, when the engine is in its
- initial position (no gimballing), in the given reference frame.<param name="referenceFrame">This position can move when the gimbal rotates. This is because the thrust position and
- gimbal position are not necessarily the same.
-}
thrusterInitialThrustPosition :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
thrusterInitialThrustPosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Thruster_InitialThrustPosition" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
thrusterInitialThrustPositionStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
thrusterInitialThrustPositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Thruster_InitialThrustPosition" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
thrusterInitialThrustPositionStream :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
thrusterInitialThrustPositionStream thisArg referenceFrameArg = requestStream $ thrusterInitialThrustPositionStreamReq thisArg referenceFrameArg
{-
- The direction of the force generated by the thruster, in the given reference frame.
- This is opposite to the direction in which the thruster expels propellant.
- For gimballed engines, this takes into account the current rotation of the gimbal.<param name="referenceFrame">
-}
thrusterThrustDirection :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
thrusterThrustDirection thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Thruster_ThrustDirection" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
thrusterThrustDirectionStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
thrusterThrustDirectionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Thruster_ThrustDirection" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
thrusterThrustDirectionStream :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
thrusterThrustDirectionStream thisArg referenceFrameArg = requestStream $ thrusterThrustDirectionStreamReq thisArg referenceFrameArg
{-
- The position at which the thruster generates thrust, in the given reference frame.
- For gimballed engines, this takes into account the current rotation of the gimbal.<param name="referenceFrame">
-}
thrusterThrustPosition :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
thrusterThrustPosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Thruster_ThrustPosition" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
thrusterThrustPositionStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
thrusterThrustPositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Thruster_ThrustPosition" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
thrusterThrustPositionStream :: KRPCHS.SpaceCenter.Thruster -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
thrusterThrustPositionStream thisArg referenceFrameArg = requestStream $ thrusterThrustPositionStreamReq thisArg referenceFrameArg
{-
- The current gimbal angle in the pitch, roll and yaw axes.
-}
getThrusterGimbalAngle :: KRPCHS.SpaceCenter.Thruster -> RPCContext ((Double, Double, Double))
getThrusterGimbalAngle thisArg = do
let r = makeRequest "SpaceCenter" "Thruster_get_GimbalAngle" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getThrusterGimbalAngleStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCStreamReq ((Double, Double, Double))
getThrusterGimbalAngleStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Thruster_get_GimbalAngle" [makeArgument 0 thisArg]
in makeStream req
getThrusterGimbalAngleStream :: KRPCHS.SpaceCenter.Thruster -> RPCContext (KRPCStream ((Double, Double, Double)))
getThrusterGimbalAngleStream thisArg = requestStream $ getThrusterGimbalAngleStreamReq thisArg
{-
- Whether the thruster is gimballed.
-}
getThrusterGimballed :: KRPCHS.SpaceCenter.Thruster -> RPCContext (Bool)
getThrusterGimballed thisArg = do
let r = makeRequest "SpaceCenter" "Thruster_get_Gimballed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getThrusterGimballedStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCStreamReq (Bool)
getThrusterGimballedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Thruster_get_Gimballed" [makeArgument 0 thisArg]
in makeStream req
getThrusterGimballedStream :: KRPCHS.SpaceCenter.Thruster -> RPCContext (KRPCStream (Bool))
getThrusterGimballedStream thisArg = requestStream $ getThrusterGimballedStreamReq thisArg
{-
- The <see cref="T:SpaceCenter.Part" /> that contains this thruster.
-}
getThrusterPart :: KRPCHS.SpaceCenter.Thruster -> RPCContext (KRPCHS.SpaceCenter.Part)
getThrusterPart thisArg = do
let r = makeRequest "SpaceCenter" "Thruster_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getThrusterPartStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getThrusterPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Thruster_get_Part" [makeArgument 0 thisArg]
in makeStream req
getThrusterPartStream :: KRPCHS.SpaceCenter.Thruster -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getThrusterPartStream thisArg = requestStream $ getThrusterPartStreamReq thisArg
{-
- A reference frame that is fixed relative to the thruster and orientated with
- its thrust direction (<see cref="M:SpaceCenter.Thruster.ThrustDirection" />).
- For gimballed engines, this takes into account the current rotation of the gimbal.
- <list type="bullet">The origin is at the position of thrust for this thruster (<see cref="M:SpaceCenter.Thruster.ThrustPosition" />).The axes rotate with the thrust direction.
- This is the direction in which the thruster expels propellant, including any gimballing.The y-axis points along the thrust direction.The x-axis and z-axis are perpendicular to the thrust direction.
-}
getThrusterThrustReferenceFrame :: KRPCHS.SpaceCenter.Thruster -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getThrusterThrustReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Thruster_get_ThrustReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getThrusterThrustReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Thruster -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getThrusterThrustReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Thruster_get_ThrustReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getThrusterThrustReferenceFrameStream :: KRPCHS.SpaceCenter.Thruster -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getThrusterThrustReferenceFrameStream thisArg = requestStream $ getThrusterThrustReferenceFrameStreamReq thisArg
{-
- Converts a direction vector from one reference frame to another.<param name="direction">Direction vector in reference frame <paramref name="from" />.<param name="from">The reference frame that the direction vector is in.<param name="to">The reference frame to covert the direction vector to.The corresponding direction vector in reference frame <paramref name="to" />.
-}
transformDirection :: (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
transformDirection directionArg fromArg toArg = do
let r = makeRequest "SpaceCenter" "TransformDirection" [makeArgument 0 directionArg, makeArgument 1 fromArg, makeArgument 2 toArg]
res <- sendRequest r
processResponse res
transformDirectionStreamReq :: (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
transformDirectionStreamReq directionArg fromArg toArg =
let req = makeRequest "SpaceCenter" "TransformDirection" [makeArgument 0 directionArg, makeArgument 1 fromArg, makeArgument 2 toArg]
in makeStream req
transformDirectionStream :: (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
transformDirectionStream directionArg fromArg toArg = requestStream $ transformDirectionStreamReq directionArg fromArg toArg
{-
- Converts a position vector from one reference frame to another.<param name="position">Position vector in reference frame <paramref name="from" />.<param name="from">The reference frame that the position vector is in.<param name="to">The reference frame to covert the position vector to.The corresponding position vector in reference frame <paramref name="to" />.
-}
transformPosition :: (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
transformPosition positionArg fromArg toArg = do
let r = makeRequest "SpaceCenter" "TransformPosition" [makeArgument 0 positionArg, makeArgument 1 fromArg, makeArgument 2 toArg]
res <- sendRequest r
processResponse res
transformPositionStreamReq :: (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
transformPositionStreamReq positionArg fromArg toArg =
let req = makeRequest "SpaceCenter" "TransformPosition" [makeArgument 0 positionArg, makeArgument 1 fromArg, makeArgument 2 toArg]
in makeStream req
transformPositionStream :: (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
transformPositionStream positionArg fromArg toArg = requestStream $ transformPositionStreamReq positionArg fromArg toArg
{-
- Converts a rotation from one reference frame to another.<param name="rotation">Rotation in reference frame <paramref name="from" />.<param name="from">The reference frame that the rotation is in.<param name="to">The corresponding rotation in reference frame <paramref name="to" />.The corresponding rotation in reference frame <paramref name="to" />.
-}
transformRotation :: (Double, Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double, Double))
transformRotation rotationArg fromArg toArg = do
let r = makeRequest "SpaceCenter" "TransformRotation" [makeArgument 0 rotationArg, makeArgument 1 fromArg, makeArgument 2 toArg]
res <- sendRequest r
processResponse res
transformRotationStreamReq :: (Double, Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double, Double))
transformRotationStreamReq rotationArg fromArg toArg =
let req = makeRequest "SpaceCenter" "TransformRotation" [makeArgument 0 rotationArg, makeArgument 1 fromArg, makeArgument 2 toArg]
in makeStream req
transformRotationStream :: (Double, Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double, Double)))
transformRotationStream rotationArg fromArg toArg = requestStream $ transformRotationStreamReq rotationArg fromArg toArg
{-
- Converts a velocity vector (acting at the specified position vector) from one
- reference frame to another. The position vector is required to take the
- relative angular velocity of the reference frames into account.<param name="position">Position vector in reference frame <paramref name="from" />.<param name="velocity">Velocity vector in reference frame <paramref name="from" />.<param name="from">The reference frame that the position and velocity vectors are in.<param name="to">The reference frame to covert the velocity vector to.The corresponding velocity in reference frame <paramref name="to" />.
-}
transformVelocity :: (Double, Double, Double) -> (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
transformVelocity positionArg velocityArg fromArg toArg = do
let r = makeRequest "SpaceCenter" "TransformVelocity" [makeArgument 0 positionArg, makeArgument 1 velocityArg, makeArgument 2 fromArg, makeArgument 3 toArg]
res <- sendRequest r
processResponse res
transformVelocityStreamReq :: (Double, Double, Double) -> (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
transformVelocityStreamReq positionArg velocityArg fromArg toArg =
let req = makeRequest "SpaceCenter" "TransformVelocity" [makeArgument 0 positionArg, makeArgument 1 velocityArg, makeArgument 2 fromArg, makeArgument 3 toArg]
in makeStream req
transformVelocityStream :: (Double, Double, Double) -> (Double, Double, Double) -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
transformVelocityStream positionArg velocityArg fromArg toArg = requestStream $ transformVelocityStreamReq positionArg velocityArg fromArg toArg
{-
- Returns the angular velocity of the vessel in the given reference frame. The magnitude of the returned
- vector is the rotational speed in radians per second, and the direction of the vector indicates the
- axis of rotation (using the right hand rule).<param name="referenceFrame">
-}
vesselAngularVelocity :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
vesselAngularVelocity thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Vessel_AngularVelocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
vesselAngularVelocityStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
vesselAngularVelocityStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Vessel_AngularVelocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
vesselAngularVelocityStream :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
vesselAngularVelocityStream thisArg referenceFrameArg = requestStream $ vesselAngularVelocityStreamReq thisArg referenceFrameArg
{-
- The axis-aligned bounding box of the vessel in the given reference frame.
- Returns the minimum and maximum vertices of the box.<param name="referenceFrame">
-}
vesselBoundingBox :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
vesselBoundingBox thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Vessel_BoundingBox" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
vesselBoundingBoxStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
vesselBoundingBoxStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Vessel_BoundingBox" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
vesselBoundingBoxStream :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
vesselBoundingBoxStream thisArg referenceFrameArg = requestStream $ vesselBoundingBoxStreamReq thisArg referenceFrameArg
{-
- Returns the direction in which the vessel is pointing, as a unit vector, in the given reference frame.<param name="referenceFrame">
-}
vesselDirection :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
vesselDirection thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Vessel_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
vesselDirectionStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
vesselDirectionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Vessel_Direction" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
vesselDirectionStream :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
vesselDirectionStream thisArg referenceFrameArg = requestStream $ vesselDirectionStreamReq thisArg referenceFrameArg
{-
- Returns a <see cref="T:SpaceCenter.Flight" /> object that can be used to get flight
- telemetry for the vessel, in the specified reference frame.<param name="referenceFrame">
- Reference frame. Defaults to the vessel's surface reference frame (<see cref="M:SpaceCenter.Vessel.SurfaceReferenceFrame" />).
-}
vesselFlight :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCHS.SpaceCenter.Flight)
vesselFlight thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Vessel_Flight" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
vesselFlightStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq (KRPCHS.SpaceCenter.Flight)
vesselFlightStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Vessel_Flight" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
vesselFlightStream :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Flight))
vesselFlightStream thisArg referenceFrameArg = requestStream $ vesselFlightStreamReq thisArg referenceFrameArg
{-
- Returns the position vector of the center of mass of the vessel in the given reference frame.<param name="referenceFrame">
-}
vesselPosition :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
vesselPosition thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Vessel_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
vesselPositionStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
vesselPositionStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Vessel_Position" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
vesselPositionStream :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
vesselPositionStream thisArg referenceFrameArg = requestStream $ vesselPositionStreamReq thisArg referenceFrameArg
{-
- Recover the vessel.
-}
vesselRecover :: KRPCHS.SpaceCenter.Vessel -> RPCContext ()
vesselRecover thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_Recover" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- Returns a <see cref="T:SpaceCenter.Resources" /> object, that can used to get
- information about resources stored in a given <paramref name="stage" />.<param name="stage">Get resources for parts that are decoupled in this stage.<param name="cumulative">Whenfalse, returns the resources for parts
- decoupled in just the given stage. Whentruereturns the resources decoupled in
- the given stage and all subsequent stages combined.
-}
vesselResourcesInDecoupleStage :: KRPCHS.SpaceCenter.Vessel -> Data.Int.Int32 -> Bool -> RPCContext (KRPCHS.SpaceCenter.Resources)
vesselResourcesInDecoupleStage thisArg stageArg cumulativeArg = do
let r = makeRequest "SpaceCenter" "Vessel_ResourcesInDecoupleStage" [makeArgument 0 thisArg, makeArgument 1 stageArg, makeArgument 2 cumulativeArg]
res <- sendRequest r
processResponse res
vesselResourcesInDecoupleStageStreamReq :: KRPCHS.SpaceCenter.Vessel -> Data.Int.Int32 -> Bool -> KRPCStreamReq (KRPCHS.SpaceCenter.Resources)
vesselResourcesInDecoupleStageStreamReq thisArg stageArg cumulativeArg =
let req = makeRequest "SpaceCenter" "Vessel_ResourcesInDecoupleStage" [makeArgument 0 thisArg, makeArgument 1 stageArg, makeArgument 2 cumulativeArg]
in makeStream req
vesselResourcesInDecoupleStageStream :: KRPCHS.SpaceCenter.Vessel -> Data.Int.Int32 -> Bool -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Resources))
vesselResourcesInDecoupleStageStream thisArg stageArg cumulativeArg = requestStream $ vesselResourcesInDecoupleStageStreamReq thisArg stageArg cumulativeArg
{-
- Returns the rotation of the center of mass of the vessel in the given reference frame.<param name="referenceFrame">
-}
vesselRotation :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double, Double))
vesselRotation thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Vessel_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
vesselRotationStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double, Double))
vesselRotationStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Vessel_Rotation" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
vesselRotationStream :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double, Double)))
vesselRotationStream thisArg referenceFrameArg = requestStream $ vesselRotationStreamReq thisArg referenceFrameArg
{-
- Returns the velocity vector of the center of mass of the vessel in the given reference frame.<param name="referenceFrame">
-}
vesselVelocity :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext ((Double, Double, Double))
vesselVelocity thisArg referenceFrameArg = do
let r = makeRequest "SpaceCenter" "Vessel_Velocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
res <- sendRequest r
processResponse res
vesselVelocityStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> KRPCStreamReq ((Double, Double, Double))
vesselVelocityStreamReq thisArg referenceFrameArg =
let req = makeRequest "SpaceCenter" "Vessel_Velocity" [makeArgument 0 thisArg, makeArgument 1 referenceFrameArg]
in makeStream req
vesselVelocityStream :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.ReferenceFrame -> RPCContext (KRPCStream ((Double, Double, Double)))
vesselVelocityStream thisArg referenceFrameArg = requestStream $ vesselVelocityStreamReq thisArg referenceFrameArg
{-
- An <see cref="T:SpaceCenter.AutoPilot" /> object, that can be used to perform
- simple auto-piloting of the vessel.
-}
getVesselAutoPilot :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.AutoPilot)
getVesselAutoPilot thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AutoPilot" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAutoPilotStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.AutoPilot)
getVesselAutoPilotStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AutoPilot" [makeArgument 0 thisArg]
in makeStream req
getVesselAutoPilotStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.AutoPilot))
getVesselAutoPilotStream thisArg = requestStream $ getVesselAutoPilotStreamReq thisArg
{-
- The maximum torque that the aerodynamic control surfaces can generate.
- Returns the torques inN.maround each of the coordinate axes of the
- vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- These axes are equivalent to the pitch, roll and yaw axes of the vessel.
-}
getVesselAvailableControlSurfaceTorque :: KRPCHS.SpaceCenter.Vessel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableControlSurfaceTorque thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AvailableControlSurfaceTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAvailableControlSurfaceTorqueStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableControlSurfaceTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AvailableControlSurfaceTorque" [makeArgument 0 thisArg]
in makeStream req
getVesselAvailableControlSurfaceTorqueStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getVesselAvailableControlSurfaceTorqueStream thisArg = requestStream $ getVesselAvailableControlSurfaceTorqueStreamReq thisArg
{-
- The maximum torque that the currently active and gimballed engines can generate.
- Returns the torques inN.maround each of the coordinate axes of the
- vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- These axes are equivalent to the pitch, roll and yaw axes of the vessel.
-}
getVesselAvailableEngineTorque :: KRPCHS.SpaceCenter.Vessel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableEngineTorque thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AvailableEngineTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAvailableEngineTorqueStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableEngineTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AvailableEngineTorque" [makeArgument 0 thisArg]
in makeStream req
getVesselAvailableEngineTorqueStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getVesselAvailableEngineTorqueStream thisArg = requestStream $ getVesselAvailableEngineTorqueStreamReq thisArg
{-
- The maximum torque that parts (excluding reaction wheels, gimballed engines, RCS and control surfaces) can generate.
- Returns the torques inN.maround each of the coordinate axes of the
- vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- These axes are equivalent to the pitch, roll and yaw axes of the vessel.
-}
getVesselAvailableOtherTorque :: KRPCHS.SpaceCenter.Vessel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableOtherTorque thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AvailableOtherTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAvailableOtherTorqueStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableOtherTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AvailableOtherTorque" [makeArgument 0 thisArg]
in makeStream req
getVesselAvailableOtherTorqueStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getVesselAvailableOtherTorqueStream thisArg = requestStream $ getVesselAvailableOtherTorqueStreamReq thisArg
{-
- The maximum torque that the currently active RCS thrusters can generate.
- Returns the torques inN.maround each of the coordinate axes of the
- vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- These axes are equivalent to the pitch, roll and yaw axes of the vessel.
-}
getVesselAvailableRCSTorque :: KRPCHS.SpaceCenter.Vessel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableRCSTorque thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AvailableRCSTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAvailableRCSTorqueStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableRCSTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AvailableRCSTorque" [makeArgument 0 thisArg]
in makeStream req
getVesselAvailableRCSTorqueStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getVesselAvailableRCSTorqueStream thisArg = requestStream $ getVesselAvailableRCSTorqueStreamReq thisArg
{-
- The maximum torque that the currently active and powered reaction wheels can generate.
- Returns the torques inN.maround each of the coordinate axes of the
- vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- These axes are equivalent to the pitch, roll and yaw axes of the vessel.
-}
getVesselAvailableReactionWheelTorque :: KRPCHS.SpaceCenter.Vessel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableReactionWheelTorque thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AvailableReactionWheelTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAvailableReactionWheelTorqueStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableReactionWheelTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AvailableReactionWheelTorque" [makeArgument 0 thisArg]
in makeStream req
getVesselAvailableReactionWheelTorqueStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getVesselAvailableReactionWheelTorqueStream thisArg = requestStream $ getVesselAvailableReactionWheelTorqueStreamReq thisArg
{-
- Gets the total available thrust that can be produced by the vessel's
- active engines, in Newtons. This is computed by summing
- <see cref="M:SpaceCenter.Engine.AvailableThrust" /> for every active engine in the vessel.
-}
getVesselAvailableThrust :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselAvailableThrust thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AvailableThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAvailableThrustStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselAvailableThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AvailableThrust" [makeArgument 0 thisArg]
in makeStream req
getVesselAvailableThrustStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselAvailableThrustStream thisArg = requestStream $ getVesselAvailableThrustStreamReq thisArg
{-
- The maximum torque that the vessel generate. Includes contributions from reaction wheels,
- RCS, gimballed engines and aerodynamic control surfaces.
- Returns the torques inN.maround each of the coordinate axes of the
- vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- These axes are equivalent to the pitch, roll and yaw axes of the vessel.
-}
getVesselAvailableTorque :: KRPCHS.SpaceCenter.Vessel -> RPCContext (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableTorque thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_AvailableTorque" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselAvailableTorqueStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (((Double, Double, Double), (Double, Double, Double)))
getVesselAvailableTorqueStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_AvailableTorque" [makeArgument 0 thisArg]
in makeStream req
getVesselAvailableTorqueStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (((Double, Double, Double), (Double, Double, Double))))
getVesselAvailableTorqueStream thisArg = requestStream $ getVesselAvailableTorqueStreamReq thisArg
{-
- The name of the biome the vessel is currently in.
-}
getVesselBiome :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Data.Text.Text)
getVesselBiome thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Biome" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselBiomeStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Data.Text.Text)
getVesselBiomeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Biome" [makeArgument 0 thisArg]
in makeStream req
getVesselBiomeStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Data.Text.Text))
getVesselBiomeStream thisArg = requestStream $ getVesselBiomeStreamReq thisArg
{-
- Returns a <see cref="T:SpaceCenter.Comms" /> object that can be used to interact
- with CommNet for this vessel.
-}
getVesselComms :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.Comms)
getVesselComms thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Comms" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselCommsStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.Comms)
getVesselCommsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Comms" [makeArgument 0 thisArg]
in makeStream req
getVesselCommsStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Comms))
getVesselCommsStream thisArg = requestStream $ getVesselCommsStreamReq thisArg
{-
- Returns a <see cref="T:SpaceCenter.Control" /> object that can be used to manipulate
- the vessel's control inputs. For example, its pitch/yaw/roll controls,
- RCS and thrust.
-}
getVesselControl :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.Control)
getVesselControl thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Control" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselControlStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.Control)
getVesselControlStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Control" [makeArgument 0 thisArg]
in makeStream req
getVesselControlStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Control))
getVesselControlStream thisArg = requestStream $ getVesselControlStreamReq thisArg
{-
- The total mass of the vessel, excluding resources, in kg.
-}
getVesselDryMass :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselDryMass thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_DryMass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselDryMassStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselDryMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_DryMass" [makeArgument 0 thisArg]
in makeStream req
getVesselDryMassStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselDryMassStream thisArg = requestStream $ getVesselDryMassStreamReq thisArg
{-
- The inertia tensor of the vessel around its center of mass, in the vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
- Returns the 3x3 matrix as a list of elements, in row-major order.
-}
getVesselInertiaTensor :: KRPCHS.SpaceCenter.Vessel -> RPCContext ([Double])
getVesselInertiaTensor thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_InertiaTensor" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselInertiaTensorStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq ([Double])
getVesselInertiaTensorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_InertiaTensor" [makeArgument 0 thisArg]
in makeStream req
getVesselInertiaTensorStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream ([Double]))
getVesselInertiaTensorStream thisArg = requestStream $ getVesselInertiaTensorStreamReq thisArg
{-
- The combined specific impulse of all active engines at sea level on Kerbin, in seconds.
- This is computed using the formula
- <a href="http://wiki.kerbalspaceprogram.com/wiki/Specific_impulse#Multiple_engines">described here.
-}
getVesselKerbinSeaLevelSpecificImpulse :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselKerbinSeaLevelSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_KerbinSeaLevelSpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselKerbinSeaLevelSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselKerbinSeaLevelSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_KerbinSeaLevelSpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getVesselKerbinSeaLevelSpecificImpulseStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselKerbinSeaLevelSpecificImpulseStream thisArg = requestStream $ getVesselKerbinSeaLevelSpecificImpulseStreamReq thisArg
{-
- The mission elapsed time in seconds.
-}
getVesselMET :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Double)
getVesselMET thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_MET" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselMETStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Double)
getVesselMETStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_MET" [makeArgument 0 thisArg]
in makeStream req
getVesselMETStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Double))
getVesselMETStream thisArg = requestStream $ getVesselMETStreamReq thisArg
{-
- The total mass of the vessel, including resources, in kg.
-}
getVesselMass :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselMass thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Mass" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselMassStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselMassStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Mass" [makeArgument 0 thisArg]
in makeStream req
getVesselMassStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselMassStream thisArg = requestStream $ getVesselMassStreamReq thisArg
{-
- The total maximum thrust that can be produced by the vessel's active
- engines, in Newtons. This is computed by summing
- <see cref="M:SpaceCenter.Engine.MaxThrust" /> for every active engine.
-}
getVesselMaxThrust :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselMaxThrust thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_MaxThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselMaxThrustStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselMaxThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_MaxThrust" [makeArgument 0 thisArg]
in makeStream req
getVesselMaxThrustStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselMaxThrustStream thisArg = requestStream $ getVesselMaxThrustStreamReq thisArg
{-
- The total maximum thrust that can be produced by the vessel's active
- engines when the vessel is in a vacuum, in Newtons. This is computed by
- summing <see cref="M:SpaceCenter.Engine.MaxVacuumThrust" /> for every active engine.
-}
getVesselMaxVacuumThrust :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselMaxVacuumThrust thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_MaxVacuumThrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselMaxVacuumThrustStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselMaxVacuumThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_MaxVacuumThrust" [makeArgument 0 thisArg]
in makeStream req
getVesselMaxVacuumThrustStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselMaxVacuumThrustStream thisArg = requestStream $ getVesselMaxVacuumThrustStreamReq thisArg
{-
- The moment of inertia of the vessel around its center of mass inkg.m^2.
- The inertia values are around the pitch, roll and yaw directions respectively.
- This corresponds to the vessels reference frame (<see cref="T:SpaceCenter.ReferenceFrame" />).
-}
getVesselMomentOfInertia :: KRPCHS.SpaceCenter.Vessel -> RPCContext ((Double, Double, Double))
getVesselMomentOfInertia thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_MomentOfInertia" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselMomentOfInertiaStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq ((Double, Double, Double))
getVesselMomentOfInertiaStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_MomentOfInertia" [makeArgument 0 thisArg]
in makeStream req
getVesselMomentOfInertiaStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream ((Double, Double, Double)))
getVesselMomentOfInertiaStream thisArg = requestStream $ getVesselMomentOfInertiaStreamReq thisArg
{-
- The name of the vessel.
-}
getVesselName :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Data.Text.Text)
getVesselName thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselNameStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Data.Text.Text)
getVesselNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Name" [makeArgument 0 thisArg]
in makeStream req
getVesselNameStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Data.Text.Text))
getVesselNameStream thisArg = requestStream $ getVesselNameStreamReq thisArg
{-
- The current orbit of the vessel.
-}
getVesselOrbit :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.Orbit)
getVesselOrbit thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Orbit" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselOrbitStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.Orbit)
getVesselOrbitStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Orbit" [makeArgument 0 thisArg]
in makeStream req
getVesselOrbitStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Orbit))
getVesselOrbitStream thisArg = requestStream $ getVesselOrbitStreamReq thisArg
{-
- The reference frame that is fixed relative to the vessel, and orientated with the vessels
- orbital prograde/normal/radial directions.
- <list type="bullet">The origin is at the center of mass of the vessel.The axes rotate with the orbital prograde/normal/radial directions.The x-axis points in the orbital anti-radial direction.The y-axis points in the orbital prograde direction.The z-axis points in the orbital normal direction.Be careful not to confuse this with 'orbit' mode on the navball.
-}
getVesselOrbitalReferenceFrame :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselOrbitalReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_OrbitalReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselOrbitalReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselOrbitalReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_OrbitalReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getVesselOrbitalReferenceFrameStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getVesselOrbitalReferenceFrameStream thisArg = requestStream $ getVesselOrbitalReferenceFrameStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Parts" /> object, that can used to interact with the parts that make up this vessel.
-}
getVesselParts :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.Parts)
getVesselParts thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Parts" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselPartsStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.Parts)
getVesselPartsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Parts" [makeArgument 0 thisArg]
in makeStream req
getVesselPartsStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Parts))
getVesselPartsStream thisArg = requestStream $ getVesselPartsStreamReq thisArg
{-
- Whether the vessel is recoverable.
-}
getVesselRecoverable :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Bool)
getVesselRecoverable thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Recoverable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselRecoverableStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Bool)
getVesselRecoverableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Recoverable" [makeArgument 0 thisArg]
in makeStream req
getVesselRecoverableStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Bool))
getVesselRecoverableStream thisArg = requestStream $ getVesselRecoverableStreamReq thisArg
{-
- The reference frame that is fixed relative to the vessel, and orientated with the vessel.
- <list type="bullet">The origin is at the center of mass of the vessel.The axes rotate with the vessel.The x-axis points out to the right of the vessel.The y-axis points in the forward direction of the vessel.The z-axis points out of the bottom off the vessel.
-}
getVesselReferenceFrame :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_ReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_ReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getVesselReferenceFrameStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getVesselReferenceFrameStream thisArg = requestStream $ getVesselReferenceFrameStreamReq thisArg
{-
- A <see cref="T:SpaceCenter.Resources" /> object, that can used to get information
- about resources stored in the vessel.
-}
getVesselResources :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.Resources)
getVesselResources thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Resources" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselResourcesStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.Resources)
getVesselResourcesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Resources" [makeArgument 0 thisArg]
in makeStream req
getVesselResourcesStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Resources))
getVesselResourcesStream thisArg = requestStream $ getVesselResourcesStreamReq thisArg
{-
- The situation the vessel is in.
-}
getVesselSituation :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.VesselSituation)
getVesselSituation thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Situation" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselSituationStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.VesselSituation)
getVesselSituationStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Situation" [makeArgument 0 thisArg]
in makeStream req
getVesselSituationStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.VesselSituation))
getVesselSituationStream thisArg = requestStream $ getVesselSituationStreamReq thisArg
{-
- The combined specific impulse of all active engines, in seconds. This is computed using the formula
- <a href="http://wiki.kerbalspaceprogram.com/wiki/Specific_impulse#Multiple_engines">described here.
-}
getVesselSpecificImpulse :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_SpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_SpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getVesselSpecificImpulseStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselSpecificImpulseStream thisArg = requestStream $ getVesselSpecificImpulseStreamReq thisArg
{-
- The reference frame that is fixed relative to the vessel, and orientated with the surface
- of the body being orbited.
- <list type="bullet">The origin is at the center of mass of the vessel.The axes rotate with the north and up directions on the surface of the body.The x-axis points in the <a href="https://en.wikipedia.org/wiki/Zenith">zenithdirection (upwards, normal to the body being orbited, from the center of the body towards the center of
- mass of the vessel).The y-axis points northwards towards the
- <a href="https://en.wikipedia.org/wiki/Horizon">astronomical horizon(north, and tangential to the
- surface of the body -- the direction in which a compass would point when on the surface).The z-axis points eastwards towards the
- <a href="https://en.wikipedia.org/wiki/Horizon">astronomical horizon(east, and tangential to the
- surface of the body -- east on a compass when on the surface).Be careful not to confuse this with 'surface' mode on the navball.
-}
getVesselSurfaceReferenceFrame :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselSurfaceReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_SurfaceReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselSurfaceReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselSurfaceReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_SurfaceReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getVesselSurfaceReferenceFrameStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getVesselSurfaceReferenceFrameStream thisArg = requestStream $ getVesselSurfaceReferenceFrameStreamReq thisArg
{-
- The reference frame that is fixed relative to the vessel, and orientated with the velocity
- vector of the vessel relative to the surface of the body being orbited.
- <list type="bullet">The origin is at the center of mass of the vessel.The axes rotate with the vessel's velocity vector.The y-axis points in the direction of the vessel's velocity vector,
- relative to the surface of the body being orbited.The z-axis is in the plane of the
- <a href="https://en.wikipedia.org/wiki/Horizon">astronomical horizon.The x-axis is orthogonal to the other two axes.
-}
getVesselSurfaceVelocityReferenceFrame :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselSurfaceVelocityReferenceFrame thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_SurfaceVelocityReferenceFrame" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselSurfaceVelocityReferenceFrameStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.ReferenceFrame)
getVesselSurfaceVelocityReferenceFrameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_SurfaceVelocityReferenceFrame" [makeArgument 0 thisArg]
in makeStream req
getVesselSurfaceVelocityReferenceFrameStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.ReferenceFrame))
getVesselSurfaceVelocityReferenceFrameStream thisArg = requestStream $ getVesselSurfaceVelocityReferenceFrameStreamReq thisArg
{-
- The total thrust currently being produced by the vessel's engines, in
- Newtons. This is computed by summing <see cref="M:SpaceCenter.Engine.Thrust" /> for
- every engine in the vessel.
-}
getVesselThrust :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselThrust thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Thrust" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselThrustStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselThrustStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Thrust" [makeArgument 0 thisArg]
in makeStream req
getVesselThrustStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselThrustStream thisArg = requestStream $ getVesselThrustStreamReq thisArg
{-
- The type of the vessel.
-}
getVesselType :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCHS.SpaceCenter.VesselType)
getVesselType thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_Type" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselTypeStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (KRPCHS.SpaceCenter.VesselType)
getVesselTypeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_Type" [makeArgument 0 thisArg]
in makeStream req
getVesselTypeStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.VesselType))
getVesselTypeStream thisArg = requestStream $ getVesselTypeStreamReq thisArg
{-
- The combined vacuum specific impulse of all active engines, in seconds. This is computed using the formula
- <a href="http://wiki.kerbalspaceprogram.com/wiki/Specific_impulse#Multiple_engines">described here.
-}
getVesselVacuumSpecificImpulse :: KRPCHS.SpaceCenter.Vessel -> RPCContext (Float)
getVesselVacuumSpecificImpulse thisArg = do
let r = makeRequest "SpaceCenter" "Vessel_get_VacuumSpecificImpulse" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getVesselVacuumSpecificImpulseStreamReq :: KRPCHS.SpaceCenter.Vessel -> KRPCStreamReq (Float)
getVesselVacuumSpecificImpulseStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Vessel_get_VacuumSpecificImpulse" [makeArgument 0 thisArg]
in makeStream req
getVesselVacuumSpecificImpulseStream :: KRPCHS.SpaceCenter.Vessel -> RPCContext (KRPCStream (Float))
getVesselVacuumSpecificImpulseStream thisArg = requestStream $ getVesselVacuumSpecificImpulseStreamReq thisArg
{-
- The name of the vessel.
-}
setVesselName :: KRPCHS.SpaceCenter.Vessel -> Data.Text.Text -> RPCContext ()
setVesselName thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Vessel_set_Name" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The type of the vessel.
-}
setVesselType :: KRPCHS.SpaceCenter.Vessel -> KRPCHS.SpaceCenter.VesselType -> RPCContext ()
setVesselType thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Vessel_set_Type" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Uses time acceleration to warp forward to a time in the future, specified
- by universal time <paramref name="ut" />. This call blocks until the desired
- time is reached. Uses regular "on-rails" or physical time warp as appropriate.
- For example, physical time warp is used when the active vessel is traveling
- through an atmosphere. When using regular "on-rails" time warp, the warp
- rate is limited by <paramref name="maxRailsRate" />, and when using physical
- time warp, the warp rate is limited by <paramref name="maxPhysicsRate" />.<param name="ut">The universal time to warp to, in seconds.<param name="maxRailsRate">The maximum warp rate in regular "on-rails" time warp.<param name="maxPhysicsRate">The maximum warp rate in physical time warp.When the time warp is complete.
-}
warpTo :: Double -> Float -> Float -> RPCContext ()
warpTo utArg maxRailsRateArg maxPhysicsRateArg = do
let r = makeRequest "SpaceCenter" "WarpTo" [makeArgument 0 utArg, makeArgument 1 maxRailsRateArg, makeArgument 2 maxPhysicsRateArg]
res <- sendRequest r
processResponse res
{-
- Creates a waypoint at the given position at ground level, and returns a
- <see cref="T:SpaceCenter.Waypoint" /> object that can be used to modify it.<param name="latitude">Latitude of the waypoint.<param name="longitude">Longitude of the waypoint.<param name="body">Celestial body the waypoint is attached to.<param name="name">Name of the waypoint.
-}
waypointManagerAddWaypoint :: KRPCHS.SpaceCenter.WaypointManager -> Double -> Double -> KRPCHS.SpaceCenter.CelestialBody -> Data.Text.Text -> RPCContext (KRPCHS.SpaceCenter.Waypoint)
waypointManagerAddWaypoint thisArg latitudeArg longitudeArg bodyArg nameArg = do
let r = makeRequest "SpaceCenter" "WaypointManager_AddWaypoint" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 bodyArg, makeArgument 4 nameArg]
res <- sendRequest r
processResponse res
waypointManagerAddWaypointStreamReq :: KRPCHS.SpaceCenter.WaypointManager -> Double -> Double -> KRPCHS.SpaceCenter.CelestialBody -> Data.Text.Text -> KRPCStreamReq (KRPCHS.SpaceCenter.Waypoint)
waypointManagerAddWaypointStreamReq thisArg latitudeArg longitudeArg bodyArg nameArg =
let req = makeRequest "SpaceCenter" "WaypointManager_AddWaypoint" [makeArgument 0 thisArg, makeArgument 1 latitudeArg, makeArgument 2 longitudeArg, makeArgument 3 bodyArg, makeArgument 4 nameArg]
in makeStream req
waypointManagerAddWaypointStream :: KRPCHS.SpaceCenter.WaypointManager -> Double -> Double -> KRPCHS.SpaceCenter.CelestialBody -> Data.Text.Text -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Waypoint))
waypointManagerAddWaypointStream thisArg latitudeArg longitudeArg bodyArg nameArg = requestStream $ waypointManagerAddWaypointStreamReq thisArg latitudeArg longitudeArg bodyArg nameArg
{-
- An example map of known color - seed pairs.
- Any other integers may be used as seed.
-}
getWaypointManagerColors :: KRPCHS.SpaceCenter.WaypointManager -> RPCContext (Data.Map.Map (Data.Text.Text) (Data.Int.Int32))
getWaypointManagerColors thisArg = do
let r = makeRequest "SpaceCenter" "WaypointManager_get_Colors" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointManagerColorsStreamReq :: KRPCHS.SpaceCenter.WaypointManager -> KRPCStreamReq (Data.Map.Map (Data.Text.Text) (Data.Int.Int32))
getWaypointManagerColorsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "WaypointManager_get_Colors" [makeArgument 0 thisArg]
in makeStream req
getWaypointManagerColorsStream :: KRPCHS.SpaceCenter.WaypointManager -> RPCContext (KRPCStream (Data.Map.Map (Data.Text.Text) (Data.Int.Int32)))
getWaypointManagerColorsStream thisArg = requestStream $ getWaypointManagerColorsStreamReq thisArg
{-
- Returns all available icons (from "GameData/Squad/Contracts/Icons/").
-}
getWaypointManagerIcons :: KRPCHS.SpaceCenter.WaypointManager -> RPCContext ([Data.Text.Text])
getWaypointManagerIcons thisArg = do
let r = makeRequest "SpaceCenter" "WaypointManager_get_Icons" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointManagerIconsStreamReq :: KRPCHS.SpaceCenter.WaypointManager -> KRPCStreamReq ([Data.Text.Text])
getWaypointManagerIconsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "WaypointManager_get_Icons" [makeArgument 0 thisArg]
in makeStream req
getWaypointManagerIconsStream :: KRPCHS.SpaceCenter.WaypointManager -> RPCContext (KRPCStream ([Data.Text.Text]))
getWaypointManagerIconsStream thisArg = requestStream $ getWaypointManagerIconsStreamReq thisArg
{-
- A list of all existing waypoints.
-}
getWaypointManagerWaypoints :: KRPCHS.SpaceCenter.WaypointManager -> RPCContext ([KRPCHS.SpaceCenter.Waypoint])
getWaypointManagerWaypoints thisArg = do
let r = makeRequest "SpaceCenter" "WaypointManager_get_Waypoints" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointManagerWaypointsStreamReq :: KRPCHS.SpaceCenter.WaypointManager -> KRPCStreamReq ([KRPCHS.SpaceCenter.Waypoint])
getWaypointManagerWaypointsStreamReq thisArg =
let req = makeRequest "SpaceCenter" "WaypointManager_get_Waypoints" [makeArgument 0 thisArg]
in makeStream req
getWaypointManagerWaypointsStream :: KRPCHS.SpaceCenter.WaypointManager -> RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Waypoint]))
getWaypointManagerWaypointsStream thisArg = requestStream $ getWaypointManagerWaypointsStreamReq thisArg
{-
- Removes the waypoint.
-}
waypointRemove :: KRPCHS.SpaceCenter.Waypoint -> RPCContext ()
waypointRemove thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_Remove" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
{-
- The altitude of the waypoint above the surface of the body, in meters. When over water, this is the altitude above the sea floor.
-}
getWaypointBedrockAltitude :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Double)
getWaypointBedrockAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_BedrockAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointBedrockAltitudeStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Double)
getWaypointBedrockAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_BedrockAltitude" [makeArgument 0 thisArg]
in makeStream req
getWaypointBedrockAltitudeStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Double))
getWaypointBedrockAltitudeStream thisArg = requestStream $ getWaypointBedrockAltitudeStreamReq thisArg
{-
- Celestial body the waypoint is attached to.
-}
getWaypointBody :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCHS.SpaceCenter.CelestialBody)
getWaypointBody thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Body" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointBodyStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (KRPCHS.SpaceCenter.CelestialBody)
getWaypointBodyStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Body" [makeArgument 0 thisArg]
in makeStream req
getWaypointBodyStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.CelestialBody))
getWaypointBodyStream thisArg = requestStream $ getWaypointBodyStreamReq thisArg
{-
- True if this waypoint is part of a set of clustered waypoints with greek letter names appended (Alpha, Beta, Gamma, etc).
- If true, there is a one-to-one correspondence with the greek letter name and the <see cref="M:SpaceCenter.Waypoint.Index" />.
-}
getWaypointClustered :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Bool)
getWaypointClustered thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Clustered" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointClusteredStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Bool)
getWaypointClusteredStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Clustered" [makeArgument 0 thisArg]
in makeStream req
getWaypointClusteredStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Bool))
getWaypointClusteredStream thisArg = requestStream $ getWaypointClusteredStreamReq thisArg
{-
- The seed of the icon color. See <see cref="M:SpaceCenter.WaypointManager.Colors" /> for example colors.
-}
getWaypointColor :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Data.Int.Int32)
getWaypointColor thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Color" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointColorStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Data.Int.Int32)
getWaypointColorStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Color" [makeArgument 0 thisArg]
in makeStream req
getWaypointColorStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Data.Int.Int32))
getWaypointColorStream thisArg = requestStream $ getWaypointColorStreamReq thisArg
{-
- The associated contract.
-}
getWaypointContract :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCHS.SpaceCenter.Contract)
getWaypointContract thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Contract" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointContractStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (KRPCHS.SpaceCenter.Contract)
getWaypointContractStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Contract" [makeArgument 0 thisArg]
in makeStream req
getWaypointContractStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Contract))
getWaypointContractStream thisArg = requestStream $ getWaypointContractStreamReq thisArg
{-
- True if waypoint is actually glued to the ground.
-}
getWaypointGrounded :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Bool)
getWaypointGrounded thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Grounded" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointGroundedStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Bool)
getWaypointGroundedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Grounded" [makeArgument 0 thisArg]
in makeStream req
getWaypointGroundedStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Bool))
getWaypointGroundedStream thisArg = requestStream $ getWaypointGroundedStreamReq thisArg
{-
- Whether the waypoint belongs to a contract.
-}
getWaypointHasContract :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Bool)
getWaypointHasContract thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_HasContract" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointHasContractStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Bool)
getWaypointHasContractStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_HasContract" [makeArgument 0 thisArg]
in makeStream req
getWaypointHasContractStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Bool))
getWaypointHasContractStream thisArg = requestStream $ getWaypointHasContractStreamReq thisArg
{-
- The icon of the waypoint.
-}
getWaypointIcon :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Data.Text.Text)
getWaypointIcon thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Icon" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointIconStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Data.Text.Text)
getWaypointIconStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Icon" [makeArgument 0 thisArg]
in makeStream req
getWaypointIconStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Data.Text.Text))
getWaypointIconStream thisArg = requestStream $ getWaypointIconStreamReq thisArg
{-
- The integer index of this waypoint amongst its cluster of sibling waypoints.
- In other words, when you have a cluster of waypoints called "Somewhere Alpha", "Somewhere Beta", and "Somewhere Gamma",
- then the alpha site has index 0, the beta site has index 1 and the gamma site has index 2.
- When <see cref="M:SpaceCenter.Waypoint.Clustered" /> is false, this value is zero but meaningless.
-}
getWaypointIndex :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Data.Int.Int32)
getWaypointIndex thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Index" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointIndexStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Data.Int.Int32)
getWaypointIndexStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Index" [makeArgument 0 thisArg]
in makeStream req
getWaypointIndexStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Data.Int.Int32))
getWaypointIndexStream thisArg = requestStream $ getWaypointIndexStreamReq thisArg
{-
- The latitude of the waypoint.
-}
getWaypointLatitude :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Double)
getWaypointLatitude thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Latitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointLatitudeStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Double)
getWaypointLatitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Latitude" [makeArgument 0 thisArg]
in makeStream req
getWaypointLatitudeStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Double))
getWaypointLatitudeStream thisArg = requestStream $ getWaypointLatitudeStreamReq thisArg
{-
- The longitude of the waypoint.
-}
getWaypointLongitude :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Double)
getWaypointLongitude thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Longitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointLongitudeStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Double)
getWaypointLongitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Longitude" [makeArgument 0 thisArg]
in makeStream req
getWaypointLongitudeStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Double))
getWaypointLongitudeStream thisArg = requestStream $ getWaypointLongitudeStreamReq thisArg
{-
- The altitude of the waypoint above sea level, in meters.
-}
getWaypointMeanAltitude :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Double)
getWaypointMeanAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_MeanAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointMeanAltitudeStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Double)
getWaypointMeanAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_MeanAltitude" [makeArgument 0 thisArg]
in makeStream req
getWaypointMeanAltitudeStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Double))
getWaypointMeanAltitudeStream thisArg = requestStream $ getWaypointMeanAltitudeStreamReq thisArg
{-
- Name of the waypoint as it appears on the map and the contract.
-}
getWaypointName :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Data.Text.Text)
getWaypointName thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_Name" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointNameStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Data.Text.Text)
getWaypointNameStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_Name" [makeArgument 0 thisArg]
in makeStream req
getWaypointNameStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Data.Text.Text))
getWaypointNameStream thisArg = requestStream $ getWaypointNameStreamReq thisArg
{-
- True if waypoint is a point near or on the body rather than high in orbit.
-}
getWaypointNearSurface :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Bool)
getWaypointNearSurface thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_NearSurface" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointNearSurfaceStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Bool)
getWaypointNearSurfaceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_NearSurface" [makeArgument 0 thisArg]
in makeStream req
getWaypointNearSurfaceStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Bool))
getWaypointNearSurfaceStream thisArg = requestStream $ getWaypointNearSurfaceStreamReq thisArg
{-
- The altitude of the waypoint above the surface of the body or sea level, whichever is closer, in meters.
-}
getWaypointSurfaceAltitude :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (Double)
getWaypointSurfaceAltitude thisArg = do
let r = makeRequest "SpaceCenter" "Waypoint_get_SurfaceAltitude" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWaypointSurfaceAltitudeStreamReq :: KRPCHS.SpaceCenter.Waypoint -> KRPCStreamReq (Double)
getWaypointSurfaceAltitudeStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Waypoint_get_SurfaceAltitude" [makeArgument 0 thisArg]
in makeStream req
getWaypointSurfaceAltitudeStream :: KRPCHS.SpaceCenter.Waypoint -> RPCContext (KRPCStream (Double))
getWaypointSurfaceAltitudeStream thisArg = requestStream $ getWaypointSurfaceAltitudeStreamReq thisArg
{-
- The altitude of the waypoint above the surface of the body, in meters. When over water, this is the altitude above the sea floor.
-}
setWaypointBedrockAltitude :: KRPCHS.SpaceCenter.Waypoint -> Double -> RPCContext ()
setWaypointBedrockAltitude thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_BedrockAltitude" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Celestial body the waypoint is attached to.
-}
setWaypointBody :: KRPCHS.SpaceCenter.Waypoint -> KRPCHS.SpaceCenter.CelestialBody -> RPCContext ()
setWaypointBody thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_Body" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The seed of the icon color. See <see cref="M:SpaceCenter.WaypointManager.Colors" /> for example colors.
-}
setWaypointColor :: KRPCHS.SpaceCenter.Waypoint -> Data.Int.Int32 -> RPCContext ()
setWaypointColor thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_Color" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The icon of the waypoint.
-}
setWaypointIcon :: KRPCHS.SpaceCenter.Waypoint -> Data.Text.Text -> RPCContext ()
setWaypointIcon thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_Icon" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The latitude of the waypoint.
-}
setWaypointLatitude :: KRPCHS.SpaceCenter.Waypoint -> Double -> RPCContext ()
setWaypointLatitude thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_Latitude" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The longitude of the waypoint.
-}
setWaypointLongitude :: KRPCHS.SpaceCenter.Waypoint -> Double -> RPCContext ()
setWaypointLongitude thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_Longitude" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The altitude of the waypoint above sea level, in meters.
-}
setWaypointMeanAltitude :: KRPCHS.SpaceCenter.Waypoint -> Double -> RPCContext ()
setWaypointMeanAltitude thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_MeanAltitude" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Name of the waypoint as it appears on the map and the contract.
-}
setWaypointName :: KRPCHS.SpaceCenter.Waypoint -> Data.Text.Text -> RPCContext ()
setWaypointName thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_Name" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The altitude of the waypoint above the surface of the body or sea level, whichever is closer, in meters.
-}
setWaypointSurfaceAltitude :: KRPCHS.SpaceCenter.Waypoint -> Double -> RPCContext ()
setWaypointSurfaceAltitude thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Waypoint_set_SurfaceAltitude" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether automatic friction control is enabled.
-}
getWheelAutoFrictionControl :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelAutoFrictionControl thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_AutoFrictionControl" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelAutoFrictionControlStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelAutoFrictionControlStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_AutoFrictionControl" [makeArgument 0 thisArg]
in makeStream req
getWheelAutoFrictionControlStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelAutoFrictionControlStream thisArg = requestStream $ getWheelAutoFrictionControlStreamReq thisArg
{-
- The braking force, as a percentage of maximum, when the brakes are applied.
-}
getWheelBrakes :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelBrakes thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Brakes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelBrakesStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelBrakesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Brakes" [makeArgument 0 thisArg]
in makeStream req
getWheelBrakesStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelBrakesStream thisArg = requestStream $ getWheelBrakesStreamReq thisArg
{-
- Whether the wheel is broken.
-}
getWheelBroken :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelBroken thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Broken" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelBrokenStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelBrokenStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Broken" [makeArgument 0 thisArg]
in makeStream req
getWheelBrokenStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelBrokenStream thisArg = requestStream $ getWheelBrokenStreamReq thisArg
{-
- Current deflection of the wheel.
-}
getWheelDeflection :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelDeflection thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Deflection" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelDeflectionStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelDeflectionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Deflection" [makeArgument 0 thisArg]
in makeStream req
getWheelDeflectionStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelDeflectionStream thisArg = requestStream $ getWheelDeflectionStreamReq thisArg
{-
- Whether the wheel is deployable.
-}
getWheelDeployable :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelDeployable thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Deployable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelDeployableStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelDeployableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Deployable" [makeArgument 0 thisArg]
in makeStream req
getWheelDeployableStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelDeployableStream thisArg = requestStream $ getWheelDeployableStreamReq thisArg
{-
- Whether the wheel is deployed.
-}
getWheelDeployed :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelDeployed thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Deployed" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelDeployedStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelDeployedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Deployed" [makeArgument 0 thisArg]
in makeStream req
getWheelDeployedStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelDeployedStream thisArg = requestStream $ getWheelDeployedStreamReq thisArg
{-
- Manual setting for the motor limiter.
- Only takes effect if the wheel has automatic traction control disabled.
- A value between 0 and 100 inclusive.
-}
getWheelDriveLimiter :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelDriveLimiter thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_DriveLimiter" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelDriveLimiterStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelDriveLimiterStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_DriveLimiter" [makeArgument 0 thisArg]
in makeStream req
getWheelDriveLimiterStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelDriveLimiterStream thisArg = requestStream $ getWheelDriveLimiterStreamReq thisArg
{-
- Whether the wheel is touching the ground.
-}
getWheelGrounded :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelGrounded thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Grounded" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelGroundedStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelGroundedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Grounded" [makeArgument 0 thisArg]
in makeStream req
getWheelGroundedStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelGroundedStream thisArg = requestStream $ getWheelGroundedStreamReq thisArg
{-
- Whether the wheel has brakes.
-}
getWheelHasBrakes :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelHasBrakes thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_HasBrakes" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelHasBrakesStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelHasBrakesStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_HasBrakes" [makeArgument 0 thisArg]
in makeStream req
getWheelHasBrakesStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelHasBrakesStream thisArg = requestStream $ getWheelHasBrakesStreamReq thisArg
{-
- Whether the wheel has suspension.
-}
getWheelHasSuspension :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelHasSuspension thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_HasSuspension" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelHasSuspensionStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelHasSuspensionStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_HasSuspension" [makeArgument 0 thisArg]
in makeStream req
getWheelHasSuspensionStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelHasSuspensionStream thisArg = requestStream $ getWheelHasSuspensionStreamReq thisArg
{-
- Manual friction control value. Only has an effect if automatic friction control is disabled.
- A value between 0 and 5 inclusive.
-}
getWheelManualFrictionControl :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelManualFrictionControl thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_ManualFrictionControl" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelManualFrictionControlStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelManualFrictionControlStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_ManualFrictionControl" [makeArgument 0 thisArg]
in makeStream req
getWheelManualFrictionControlStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelManualFrictionControlStream thisArg = requestStream $ getWheelManualFrictionControlStreamReq thisArg
{-
- Whether the motor is enabled.
-}
getWheelMotorEnabled :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelMotorEnabled thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_MotorEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelMotorEnabledStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelMotorEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_MotorEnabled" [makeArgument 0 thisArg]
in makeStream req
getWheelMotorEnabledStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelMotorEnabledStream thisArg = requestStream $ getWheelMotorEnabledStreamReq thisArg
{-
- Whether the direction of the motor is inverted.
-}
getWheelMotorInverted :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelMotorInverted thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_MotorInverted" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelMotorInvertedStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelMotorInvertedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_MotorInverted" [makeArgument 0 thisArg]
in makeStream req
getWheelMotorInvertedStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelMotorInvertedStream thisArg = requestStream $ getWheelMotorInvertedStreamReq thisArg
{-
- The output of the motor. This is the torque currently being generated, in Newton meters.
-}
getWheelMotorOutput :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelMotorOutput thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_MotorOutput" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelMotorOutputStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelMotorOutputStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_MotorOutput" [makeArgument 0 thisArg]
in makeStream req
getWheelMotorOutputStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelMotorOutputStream thisArg = requestStream $ getWheelMotorOutputStreamReq thisArg
{-
- Whether the direction of the motor is inverted.
-}
getWheelMotorState :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCHS.SpaceCenter.MotorState)
getWheelMotorState thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_MotorState" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelMotorStateStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (KRPCHS.SpaceCenter.MotorState)
getWheelMotorStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_MotorState" [makeArgument 0 thisArg]
in makeStream req
getWheelMotorStateStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.MotorState))
getWheelMotorStateStream thisArg = requestStream $ getWheelMotorStateStreamReq thisArg
{-
- The part object for this wheel.
-}
getWheelPart :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCHS.SpaceCenter.Part)
getWheelPart thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Part" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelPartStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (KRPCHS.SpaceCenter.Part)
getWheelPartStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Part" [makeArgument 0 thisArg]
in makeStream req
getWheelPartStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.Part))
getWheelPartStream thisArg = requestStream $ getWheelPartStreamReq thisArg
{-
- Whether the wheel is powered by a motor.
-}
getWheelPowered :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelPowered thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Powered" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelPoweredStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelPoweredStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Powered" [makeArgument 0 thisArg]
in makeStream req
getWheelPoweredStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelPoweredStream thisArg = requestStream $ getWheelPoweredStreamReq thisArg
{-
- Radius of the wheel, in meters.
-}
getWheelRadius :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelRadius thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Radius" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelRadiusStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelRadiusStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Radius" [makeArgument 0 thisArg]
in makeStream req
getWheelRadiusStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelRadiusStream thisArg = requestStream $ getWheelRadiusStreamReq thisArg
{-
- Whether the wheel is repairable.
-}
getWheelRepairable :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelRepairable thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Repairable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelRepairableStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelRepairableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Repairable" [makeArgument 0 thisArg]
in makeStream req
getWheelRepairableStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelRepairableStream thisArg = requestStream $ getWheelRepairableStreamReq thisArg
{-
- Current slip of the wheel.
-}
getWheelSlip :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelSlip thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Slip" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelSlipStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelSlipStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Slip" [makeArgument 0 thisArg]
in makeStream req
getWheelSlipStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelSlipStream thisArg = requestStream $ getWheelSlipStreamReq thisArg
{-
- The current state of the wheel.
-}
getWheelState :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCHS.SpaceCenter.WheelState)
getWheelState thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_State" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelStateStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (KRPCHS.SpaceCenter.WheelState)
getWheelStateStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_State" [makeArgument 0 thisArg]
in makeStream req
getWheelStateStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (KRPCHS.SpaceCenter.WheelState))
getWheelStateStream thisArg = requestStream $ getWheelStateStreamReq thisArg
{-
- Whether the wheel has steering.
-}
getWheelSteerable :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelSteerable thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Steerable" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelSteerableStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelSteerableStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Steerable" [makeArgument 0 thisArg]
in makeStream req
getWheelSteerableStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelSteerableStream thisArg = requestStream $ getWheelSteerableStreamReq thisArg
{-
- Whether the wheel steering is enabled.
-}
getWheelSteeringEnabled :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelSteeringEnabled thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_SteeringEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelSteeringEnabledStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelSteeringEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_SteeringEnabled" [makeArgument 0 thisArg]
in makeStream req
getWheelSteeringEnabledStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelSteeringEnabledStream thisArg = requestStream $ getWheelSteeringEnabledStreamReq thisArg
{-
- Whether the wheel steering is inverted.
-}
getWheelSteeringInverted :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelSteeringInverted thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_SteeringInverted" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelSteeringInvertedStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelSteeringInvertedStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_SteeringInverted" [makeArgument 0 thisArg]
in makeStream req
getWheelSteeringInvertedStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelSteeringInvertedStream thisArg = requestStream $ getWheelSteeringInvertedStreamReq thisArg
{-
- Current stress on the wheel.
-}
getWheelStress :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelStress thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_Stress" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelStressStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelStressStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_Stress" [makeArgument 0 thisArg]
in makeStream req
getWheelStressStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelStressStream thisArg = requestStream $ getWheelStressStreamReq thisArg
{-
- Current stress on the wheel as a percentage of its stress tolerance.
-}
getWheelStressPercentage :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelStressPercentage thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_StressPercentage" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelStressPercentageStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelStressPercentageStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_StressPercentage" [makeArgument 0 thisArg]
in makeStream req
getWheelStressPercentageStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelStressPercentageStream thisArg = requestStream $ getWheelStressPercentageStreamReq thisArg
{-
- Stress tolerance of the wheel.
-}
getWheelStressTolerance :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelStressTolerance thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_StressTolerance" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelStressToleranceStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelStressToleranceStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_StressTolerance" [makeArgument 0 thisArg]
in makeStream req
getWheelStressToleranceStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelStressToleranceStream thisArg = requestStream $ getWheelStressToleranceStreamReq thisArg
{-
- Suspension damper strength, as set in the editor.
-}
getWheelSuspensionDamperStrength :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelSuspensionDamperStrength thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_SuspensionDamperStrength" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelSuspensionDamperStrengthStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelSuspensionDamperStrengthStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_SuspensionDamperStrength" [makeArgument 0 thisArg]
in makeStream req
getWheelSuspensionDamperStrengthStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelSuspensionDamperStrengthStream thisArg = requestStream $ getWheelSuspensionDamperStrengthStreamReq thisArg
{-
- Suspension spring strength, as set in the editor.
-}
getWheelSuspensionSpringStrength :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelSuspensionSpringStrength thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_SuspensionSpringStrength" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelSuspensionSpringStrengthStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelSuspensionSpringStrengthStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_SuspensionSpringStrength" [makeArgument 0 thisArg]
in makeStream req
getWheelSuspensionSpringStrengthStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelSuspensionSpringStrengthStream thisArg = requestStream $ getWheelSuspensionSpringStrengthStreamReq thisArg
{-
- Setting for the traction control.
- Only takes effect if the wheel has automatic traction control enabled.
- A value between 0 and 5 inclusive.
-}
getWheelTractionControl :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Float)
getWheelTractionControl thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_TractionControl" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelTractionControlStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Float)
getWheelTractionControlStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_TractionControl" [makeArgument 0 thisArg]
in makeStream req
getWheelTractionControlStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Float))
getWheelTractionControlStream thisArg = requestStream $ getWheelTractionControlStreamReq thisArg
{-
- Whether automatic traction control is enabled.
- A wheel only has traction control if it is powered.
-}
getWheelTractionControlEnabled :: KRPCHS.SpaceCenter.Wheel -> RPCContext (Bool)
getWheelTractionControlEnabled thisArg = do
let r = makeRequest "SpaceCenter" "Wheel_get_TractionControlEnabled" [makeArgument 0 thisArg]
res <- sendRequest r
processResponse res
getWheelTractionControlEnabledStreamReq :: KRPCHS.SpaceCenter.Wheel -> KRPCStreamReq (Bool)
getWheelTractionControlEnabledStreamReq thisArg =
let req = makeRequest "SpaceCenter" "Wheel_get_TractionControlEnabled" [makeArgument 0 thisArg]
in makeStream req
getWheelTractionControlEnabledStream :: KRPCHS.SpaceCenter.Wheel -> RPCContext (KRPCStream (Bool))
getWheelTractionControlEnabledStream thisArg = requestStream $ getWheelTractionControlEnabledStreamReq thisArg
{-
- Whether automatic friction control is enabled.
-}
setWheelAutoFrictionControl :: KRPCHS.SpaceCenter.Wheel -> Bool -> RPCContext ()
setWheelAutoFrictionControl thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_AutoFrictionControl" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The braking force, as a percentage of maximum, when the brakes are applied.
-}
setWheelBrakes :: KRPCHS.SpaceCenter.Wheel -> Float -> RPCContext ()
setWheelBrakes thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_Brakes" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the wheel is deployed.
-}
setWheelDeployed :: KRPCHS.SpaceCenter.Wheel -> Bool -> RPCContext ()
setWheelDeployed thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_Deployed" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Manual setting for the motor limiter.
- Only takes effect if the wheel has automatic traction control disabled.
- A value between 0 and 100 inclusive.
-}
setWheelDriveLimiter :: KRPCHS.SpaceCenter.Wheel -> Float -> RPCContext ()
setWheelDriveLimiter thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_DriveLimiter" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Manual friction control value. Only has an effect if automatic friction control is disabled.
- A value between 0 and 5 inclusive.
-}
setWheelManualFrictionControl :: KRPCHS.SpaceCenter.Wheel -> Float -> RPCContext ()
setWheelManualFrictionControl thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_ManualFrictionControl" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the motor is enabled.
-}
setWheelMotorEnabled :: KRPCHS.SpaceCenter.Wheel -> Bool -> RPCContext ()
setWheelMotorEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_MotorEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the direction of the motor is inverted.
-}
setWheelMotorInverted :: KRPCHS.SpaceCenter.Wheel -> Bool -> RPCContext ()
setWheelMotorInverted thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_MotorInverted" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the wheel steering is enabled.
-}
setWheelSteeringEnabled :: KRPCHS.SpaceCenter.Wheel -> Bool -> RPCContext ()
setWheelSteeringEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_SteeringEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the wheel steering is inverted.
-}
setWheelSteeringInverted :: KRPCHS.SpaceCenter.Wheel -> Bool -> RPCContext ()
setWheelSteeringInverted thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_SteeringInverted" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Setting for the traction control.
- Only takes effect if the wheel has automatic traction control enabled.
- A value between 0 and 5 inclusive.
-}
setWheelTractionControl :: KRPCHS.SpaceCenter.Wheel -> Float -> RPCContext ()
setWheelTractionControl thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_TractionControl" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether automatic traction control is enabled.
- A wheel only has traction control if it is powered.
-}
setWheelTractionControlEnabled :: KRPCHS.SpaceCenter.Wheel -> Bool -> RPCContext ()
setWheelTractionControlEnabled thisArg valueArg = do
let r = makeRequest "SpaceCenter" "Wheel_set_TractionControlEnabled" [makeArgument 0 thisArg, makeArgument 1 valueArg]
res <- sendRequest r
processResponse res
{-
- The currently active vessel.
-}
getActiveVessel :: RPCContext (KRPCHS.SpaceCenter.Vessel)
getActiveVessel = do
let r = makeRequest "SpaceCenter" "get_ActiveVessel" []
res <- sendRequest r
processResponse res
getActiveVesselStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.Vessel)
getActiveVesselStreamReq =
let req = makeRequest "SpaceCenter" "get_ActiveVessel" []
in makeStream req
getActiveVesselStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.Vessel))
getActiveVesselStream = requestStream $ getActiveVesselStreamReq
{-
- A dictionary of all celestial bodies (planets, moons, etc.) in the game,
- keyed by the name of the body.
-}
getBodies :: RPCContext (Data.Map.Map (Data.Text.Text) (KRPCHS.SpaceCenter.CelestialBody))
getBodies = do
let r = makeRequest "SpaceCenter" "get_Bodies" []
res <- sendRequest r
processResponse res
getBodiesStreamReq :: KRPCStreamReq (Data.Map.Map (Data.Text.Text) (KRPCHS.SpaceCenter.CelestialBody))
getBodiesStreamReq =
let req = makeRequest "SpaceCenter" "get_Bodies" []
in makeStream req
getBodiesStream :: RPCContext (KRPCStream (Data.Map.Map (Data.Text.Text) (KRPCHS.SpaceCenter.CelestialBody)))
getBodiesStream = requestStream $ getBodiesStreamReq
{-
- An object that can be used to control the camera.
-}
getCamera :: RPCContext (KRPCHS.SpaceCenter.Camera)
getCamera = do
let r = makeRequest "SpaceCenter" "get_Camera" []
res <- sendRequest r
processResponse res
getCameraStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.Camera)
getCameraStreamReq =
let req = makeRequest "SpaceCenter" "get_Camera" []
in makeStream req
getCameraStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.Camera))
getCameraStream = requestStream $ getCameraStreamReq
{-
- The contract manager.
-}
getContractManager :: RPCContext (KRPCHS.SpaceCenter.ContractManager)
getContractManager = do
let r = makeRequest "SpaceCenter" "get_ContractManager" []
res <- sendRequest r
processResponse res
getContractManagerStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.ContractManager)
getContractManagerStreamReq =
let req = makeRequest "SpaceCenter" "get_ContractManager" []
in makeStream req
getContractManagerStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.ContractManager))
getContractManagerStream = requestStream $ getContractManagerStreamReq
{-
- Whether <a href="http://forum.kerbalspaceprogram.com/index.php?/topic/19321-105-ferram-aerospace-research-v01557-johnson-21816/">Ferram Aerospace Researchis installed.
-}
getFARAvailable :: RPCContext (Bool)
getFARAvailable = do
let r = makeRequest "SpaceCenter" "get_FARAvailable" []
res <- sendRequest r
processResponse res
getFARAvailableStreamReq :: KRPCStreamReq (Bool)
getFARAvailableStreamReq =
let req = makeRequest "SpaceCenter" "get_FARAvailable" []
in makeStream req
getFARAvailableStream :: RPCContext (KRPCStream (Bool))
getFARAvailableStream = requestStream $ getFARAvailableStreamReq
{-
- The value of the <a href="https://en.wikipedia.org/wiki/Gravitational_constant">gravitational constantG inN(m/kg)^2.
-}
getG :: RPCContext (Double)
getG = do
let r = makeRequest "SpaceCenter" "get_G" []
res <- sendRequest r
processResponse res
getGStreamReq :: KRPCStreamReq (Double)
getGStreamReq =
let req = makeRequest "SpaceCenter" "get_G" []
in makeStream req
getGStream :: RPCContext (KRPCStream (Double))
getGStream = requestStream $ getGStreamReq
{-
- The current maximum regular "on-rails" warp factor that can be set.
- A value between 0 and 7 inclusive. See
- <a href="http://wiki.kerbalspaceprogram.com/wiki/Time_warp">the KSP wikifor details.
-}
getMaximumRailsWarpFactor :: RPCContext (Data.Int.Int32)
getMaximumRailsWarpFactor = do
let r = makeRequest "SpaceCenter" "get_MaximumRailsWarpFactor" []
res <- sendRequest r
processResponse res
getMaximumRailsWarpFactorStreamReq :: KRPCStreamReq (Data.Int.Int32)
getMaximumRailsWarpFactorStreamReq =
let req = makeRequest "SpaceCenter" "get_MaximumRailsWarpFactor" []
in makeStream req
getMaximumRailsWarpFactorStream :: RPCContext (KRPCStream (Data.Int.Int32))
getMaximumRailsWarpFactorStream = requestStream $ getMaximumRailsWarpFactorStreamReq
{-
- Whether the navball is visible.
-}
getNavball :: RPCContext (Bool)
getNavball = do
let r = makeRequest "SpaceCenter" "get_Navball" []
res <- sendRequest r
processResponse res
getNavballStreamReq :: KRPCStreamReq (Bool)
getNavballStreamReq =
let req = makeRequest "SpaceCenter" "get_Navball" []
in makeStream req
getNavballStream :: RPCContext (KRPCStream (Bool))
getNavballStream = requestStream $ getNavballStreamReq
{-
- The physical time warp rate. A value between 0 and 3 inclusive. 0 means
- no time warp. Returns 0 if regular "on-rails" time warp is active.
-}
getPhysicsWarpFactor :: RPCContext (Data.Int.Int32)
getPhysicsWarpFactor = do
let r = makeRequest "SpaceCenter" "get_PhysicsWarpFactor" []
res <- sendRequest r
processResponse res
getPhysicsWarpFactorStreamReq :: KRPCStreamReq (Data.Int.Int32)
getPhysicsWarpFactorStreamReq =
let req = makeRequest "SpaceCenter" "get_PhysicsWarpFactor" []
in makeStream req
getPhysicsWarpFactorStream :: RPCContext (KRPCStream (Data.Int.Int32))
getPhysicsWarpFactorStream = requestStream $ getPhysicsWarpFactorStreamReq
{-
- The time warp rate, using regular "on-rails" time warp. A value between
- 0 and 7 inclusive. 0 means no time warp. Returns 0 if physical time warp
- is active.
-
- If requested time warp factor cannot be set, it will be set to the next
- lowest possible value. For example, if the vessel is too close to a
- planet. See <a href="http://wiki.kerbalspaceprogram.com/wiki/Time_warp">
- the KSP wikifor details.
-}
getRailsWarpFactor :: RPCContext (Data.Int.Int32)
getRailsWarpFactor = do
let r = makeRequest "SpaceCenter" "get_RailsWarpFactor" []
res <- sendRequest r
processResponse res
getRailsWarpFactorStreamReq :: KRPCStreamReq (Data.Int.Int32)
getRailsWarpFactorStreamReq =
let req = makeRequest "SpaceCenter" "get_RailsWarpFactor" []
in makeStream req
getRailsWarpFactorStream :: RPCContext (KRPCStream (Data.Int.Int32))
getRailsWarpFactorStream = requestStream $ getRailsWarpFactorStreamReq
{-
- The currently targeted celestial body.
-}
getTargetBody :: RPCContext (KRPCHS.SpaceCenter.CelestialBody)
getTargetBody = do
let r = makeRequest "SpaceCenter" "get_TargetBody" []
res <- sendRequest r
processResponse res
getTargetBodyStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.CelestialBody)
getTargetBodyStreamReq =
let req = makeRequest "SpaceCenter" "get_TargetBody" []
in makeStream req
getTargetBodyStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.CelestialBody))
getTargetBodyStream = requestStream $ getTargetBodyStreamReq
{-
- The currently targeted docking port.
-}
getTargetDockingPort :: RPCContext (KRPCHS.SpaceCenter.DockingPort)
getTargetDockingPort = do
let r = makeRequest "SpaceCenter" "get_TargetDockingPort" []
res <- sendRequest r
processResponse res
getTargetDockingPortStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.DockingPort)
getTargetDockingPortStreamReq =
let req = makeRequest "SpaceCenter" "get_TargetDockingPort" []
in makeStream req
getTargetDockingPortStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.DockingPort))
getTargetDockingPortStream = requestStream $ getTargetDockingPortStreamReq
{-
- The currently targeted vessel.
-}
getTargetVessel :: RPCContext (KRPCHS.SpaceCenter.Vessel)
getTargetVessel = do
let r = makeRequest "SpaceCenter" "get_TargetVessel" []
res <- sendRequest r
processResponse res
getTargetVesselStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.Vessel)
getTargetVesselStreamReq =
let req = makeRequest "SpaceCenter" "get_TargetVessel" []
in makeStream req
getTargetVesselStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.Vessel))
getTargetVesselStream = requestStream $ getTargetVesselStreamReq
{-
- Whether the UI is visible.
-}
getUIVisible :: RPCContext (Bool)
getUIVisible = do
let r = makeRequest "SpaceCenter" "get_UIVisible" []
res <- sendRequest r
processResponse res
getUIVisibleStreamReq :: KRPCStreamReq (Bool)
getUIVisibleStreamReq =
let req = makeRequest "SpaceCenter" "get_UIVisible" []
in makeStream req
getUIVisibleStream :: RPCContext (KRPCStream (Bool))
getUIVisibleStream = requestStream $ getUIVisibleStreamReq
{-
- The current universal time in seconds.
-}
getUT :: RPCContext (Double)
getUT = do
let r = makeRequest "SpaceCenter" "get_UT" []
res <- sendRequest r
processResponse res
getUTStreamReq :: KRPCStreamReq (Double)
getUTStreamReq =
let req = makeRequest "SpaceCenter" "get_UT" []
in makeStream req
getUTStream :: RPCContext (KRPCStream (Double))
getUTStream = requestStream $ getUTStreamReq
{-
- A list of all the vessels in the game.
-}
getVessels :: RPCContext ([KRPCHS.SpaceCenter.Vessel])
getVessels = do
let r = makeRequest "SpaceCenter" "get_Vessels" []
res <- sendRequest r
processResponse res
getVesselsStreamReq :: KRPCStreamReq ([KRPCHS.SpaceCenter.Vessel])
getVesselsStreamReq =
let req = makeRequest "SpaceCenter" "get_Vessels" []
in makeStream req
getVesselsStream :: RPCContext (KRPCStream ([KRPCHS.SpaceCenter.Vessel]))
getVesselsStream = requestStream $ getVesselsStreamReq
{-
- The current warp factor. This is the index of the rate at which time
- is passing for either regular "on-rails" or physical time warp. Returns 0
- if time warp is not active. When in on-rails time warp, this is equal to
- <see cref="M:SpaceCenter.RailsWarpFactor" />, and in physics time warp, this is equal to
- <see cref="M:SpaceCenter.PhysicsWarpFactor" />.
-}
getWarpFactor :: RPCContext (Float)
getWarpFactor = do
let r = makeRequest "SpaceCenter" "get_WarpFactor" []
res <- sendRequest r
processResponse res
getWarpFactorStreamReq :: KRPCStreamReq (Float)
getWarpFactorStreamReq =
let req = makeRequest "SpaceCenter" "get_WarpFactor" []
in makeStream req
getWarpFactorStream :: RPCContext (KRPCStream (Float))
getWarpFactorStream = requestStream $ getWarpFactorStreamReq
{-
- The current time warp mode. Returns <see cref="M:SpaceCenter.WarpMode.None" /> if time
- warp is not active, <see cref="M:SpaceCenter.WarpMode.Rails" /> if regular "on-rails" time warp
- is active, or <see cref="M:SpaceCenter.WarpMode.Physics" /> if physical time warp is active.
-}
getWarpMode :: RPCContext (KRPCHS.SpaceCenter.WarpMode)
getWarpMode = do
let r = makeRequest "SpaceCenter" "get_WarpMode" []
res <- sendRequest r
processResponse res
getWarpModeStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.WarpMode)
getWarpModeStreamReq =
let req = makeRequest "SpaceCenter" "get_WarpMode" []
in makeStream req
getWarpModeStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.WarpMode))
getWarpModeStream = requestStream $ getWarpModeStreamReq
{-
- The current warp rate. This is the rate at which time is passing for
- either on-rails or physical time warp. For example, a value of 10 means
- time is passing 10x faster than normal. Returns 1 if time warp is not
- active.
-}
getWarpRate :: RPCContext (Float)
getWarpRate = do
let r = makeRequest "SpaceCenter" "get_WarpRate" []
res <- sendRequest r
processResponse res
getWarpRateStreamReq :: KRPCStreamReq (Float)
getWarpRateStreamReq =
let req = makeRequest "SpaceCenter" "get_WarpRate" []
in makeStream req
getWarpRateStream :: RPCContext (KRPCStream (Float))
getWarpRateStream = requestStream $ getWarpRateStreamReq
{-
- The waypoint manager.
-}
getWaypointManager :: RPCContext (KRPCHS.SpaceCenter.WaypointManager)
getWaypointManager = do
let r = makeRequest "SpaceCenter" "get_WaypointManager" []
res <- sendRequest r
processResponse res
getWaypointManagerStreamReq :: KRPCStreamReq (KRPCHS.SpaceCenter.WaypointManager)
getWaypointManagerStreamReq =
let req = makeRequest "SpaceCenter" "get_WaypointManager" []
in makeStream req
getWaypointManagerStream :: RPCContext (KRPCStream (KRPCHS.SpaceCenter.WaypointManager))
getWaypointManagerStream = requestStream $ getWaypointManagerStreamReq
{-
- The currently active vessel.
-}
setActiveVessel :: KRPCHS.SpaceCenter.Vessel -> RPCContext ()
setActiveVessel valueArg = do
let r = makeRequest "SpaceCenter" "set_ActiveVessel" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the navball is visible.
-}
setNavball :: Bool -> RPCContext ()
setNavball valueArg = do
let r = makeRequest "SpaceCenter" "set_Navball" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
{-
- The physical time warp rate. A value between 0 and 3 inclusive. 0 means
- no time warp. Returns 0 if regular "on-rails" time warp is active.
-}
setPhysicsWarpFactor :: Data.Int.Int32 -> RPCContext ()
setPhysicsWarpFactor valueArg = do
let r = makeRequest "SpaceCenter" "set_PhysicsWarpFactor" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
{-
- The time warp rate, using regular "on-rails" time warp. A value between
- 0 and 7 inclusive. 0 means no time warp. Returns 0 if physical time warp
- is active.
-
- If requested time warp factor cannot be set, it will be set to the next
- lowest possible value. For example, if the vessel is too close to a
- planet. See <a href="http://wiki.kerbalspaceprogram.com/wiki/Time_warp">
- the KSP wikifor details.
-}
setRailsWarpFactor :: Data.Int.Int32 -> RPCContext ()
setRailsWarpFactor valueArg = do
let r = makeRequest "SpaceCenter" "set_RailsWarpFactor" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
{-
- The currently targeted celestial body.
-}
setTargetBody :: KRPCHS.SpaceCenter.CelestialBody -> RPCContext ()
setTargetBody valueArg = do
let r = makeRequest "SpaceCenter" "set_TargetBody" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
{-
- The currently targeted docking port.
-}
setTargetDockingPort :: KRPCHS.SpaceCenter.DockingPort -> RPCContext ()
setTargetDockingPort valueArg = do
let r = makeRequest "SpaceCenter" "set_TargetDockingPort" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
{-
- The currently targeted vessel.
-}
setTargetVessel :: KRPCHS.SpaceCenter.Vessel -> RPCContext ()
setTargetVessel valueArg = do
let r = makeRequest "SpaceCenter" "set_TargetVessel" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
{-
- Whether the UI is visible.
-}
setUIVisible :: Bool -> RPCContext ()
setUIVisible valueArg = do
let r = makeRequest "SpaceCenter" "set_UIVisible" [makeArgument 0 valueArg]
res <- sendRequest r
processResponse res
| Cahu/krpc-hs | src/KRPCHS/SpaceCenter.hs | gpl-3.0 | 737,499 | 0 | 14 | 97,100 | 144,303 | 73,302 | 71,001 | 11,145 | 1 |
module System.Log where
import qualified Control.Concurrent as Concurrent
import qualified Control.Concurrent.Async as Async
import qualified Control.Concurrent.STM as STM
import qualified Control.Concurrent.STM.TChan as TChan
import qualified Control.Concurrent.STM.TVar as TVar
import qualified Control.Monad as Monad
import qualified Data.List as List
import qualified Data.Maybe as Maybe
import qualified Data.Time.LocalTime as LocalTime
import qualified Data.Time.Format as TimeFormat
import qualified Data.Word as Word
import qualified System.IO as IO
import qualified System.Directory as Dir
import qualified System.FilePath as FilePath
data Logger = Logger
{ logFile :: Maybe FilePath.FilePath
, logFileSize :: Integer
, logRotations :: Word.Word8
, logChan :: TChan.TChan LogMessage
, logAsync :: TVar.TVar (Maybe (Async.Async ()))
}
data Level = DEBUG | INFO | WARN | ERROR | CRITICAL
deriving (Show, Read, Eq, Ord)
data LogMessage = LogStop | LogMsg Level String
createLogger :: Maybe FilePath.FilePath -> Integer -> Word.Word8 -> IO Logger
createLogger mbFilePath maxSize rotations = do
case mbFilePath of
Nothing -> return ()
Just filePath -> check filePath
chan <- TChan.newTChanIO
tvAsync <- TVar.newTVarIO Nothing
let logger = Logger mbFilePath maxSize rotations chan tvAsync
async <- Async.async (consumeLogChan logger)
-- link ensures exceptions raised in async are
-- propagated to this thread.
Async.link async
STM.atomically (TVar.writeTVar (logAsync logger) (Just async))
return logger
stopLogger :: Logger -> IO ()
stopLogger logger = do
mbasync <- TVar.readTVarIO (logAsync logger)
STM.atomically (TChan.writeTChan (logChan logger) LogStop)
-- wait for it to quit
maybe (return ()) Async.wait mbasync
consumeLogChan :: Logger -> IO ()
consumeLogChan logger = do
openLogFile (logFile logger) >>= consume logger
openLogFile :: Maybe FilePath.FilePath -> IO IO.Handle
openLogFile mbFilePath = do
handle <- maybe (return IO.stdout) (\f -> IO.openFile f IO.AppendMode) mbFilePath
-- Set line buffering on all handles, including stdout
-- (which ought to have it by default but apparently
-- does not, at least on windows).
IO.hSetBuffering handle IO.LineBuffering
return handle
type LogConsumer = Logger -> IO.Handle -> IO ()
consume :: LogConsumer
consume logger handle = do
msg <- STM.atomically (TChan.readTChan (logChan logger))
handleLogMessage logger handle consume msg
-- Run the logger down: consume everything from
-- the channel, and quit when it is empty.
consumeFinally :: LogConsumer
consumeFinally logger handle =
STM.atomically (TChan.tryReadTChan (logChan logger))
>>= maybe (return ())
(handleLogMessage logger handle consumeFinally)
handleLogMessage :: Logger -> IO.Handle -> LogConsumer -> LogMessage -> IO ()
handleLogMessage logger handle k msg = do
case msg of
LogStop -> consumeFinally logger handle
LogMsg _ m -> do
IO.hPutStrLn handle m
rotateHandle logger handle >>= k logger
-- Check if the log file needs to be rotated,
-- and do so if required. Returns the current handle,
-- or a new one if it is rotated.
rotateHandle :: Logger -> IO.Handle -> IO IO.Handle
rotateHandle logger handle = do
if logFile logger == Nothing then return handle
else do
size <- IO.hFileSize handle
if size < logFileSize logger then return handle
else do
IO.hClose handle
rotateFiles (Maybe.fromJust (logFile logger)) (logRotations logger)
openLogFile (logFile logger)
check :: FilePath.FilePath -> IO ()
check file = do
let dir = FilePath.takeDirectory file
dirExist <- Dir.doesDirectoryExist dir
Monad.unless dirExist $ fail $ dir ++ " does not exist or is not a directory."
dirPerm <- Dir.getPermissions dir
Monad.unless (Dir.writable dirPerm) $ fail $ dir ++ " is not writable."
exist <- Dir.doesFileExist file
Monad.when exist $ do
perm <- Dir.getPermissions file
Monad.unless (Dir.writable perm) $ fail $ file ++ " is not writable."
rotateFiles :: FilePath.FilePath -> Word.Word8 -> IO ()
rotateFiles path n = mapM_ move srcdsts
where
dsts' = reverse . ("":) . map (('.':). show) $ [0..n-1]
dsts = map (path++) dsts'
srcs = tail dsts
srcdsts = zip srcs dsts
move (src,dst) = do
exist <- Dir.doesFileExist src
Monad.when exist $ Dir.renameFile src dst
rpad :: String -> Int -> String
rpad str n = let l = List.length str in
str ++ replicate (n-l) ' '
writeChan :: Level -> Logger -> String -> IO ()
writeChan level logger msg = do
threadId <- Concurrent.myThreadId
let tid = drop 9 (show threadId)
let format = "%Y-%m-%dT%H:%M:%S.%q"
now <- LocalTime.getZonedTime
let tz = TimeFormat.formatTime TimeFormat.defaultTimeLocale "%z" now
let t = TimeFormat.formatTime TimeFormat.defaultTimeLocale format now
-- Truncate picosecond component to 8 DP.
-- My windows machine is only accurate to 7 DP, 8 onwards is just 0s.
let timestr = (take 28 t) ++ tz
let leveltidstr = ' ':rpad (show level) 8 ++ ' ':rpad tid 7
let logmsg = LogMsg level (timestr ++ leveltidstr ++ ' ':msg)
STM.atomically (TChan.writeTChan (logChan logger) logmsg)
debug, info, warn, error, critical :: Logger -> String -> IO ()
debug = writeChan DEBUG
info = writeChan INFO
warn = writeChan WARN
error = writeChan ERROR
critical = writeChan CRITICAL
| abayley/netpoll | src/System/Log.hs | gpl-3.0 | 5,593 | 0 | 17 | 1,225 | 1,694 | 856 | 838 | 117 | 3 |
module Handler.ProductList where
import Import
getProductListR :: Handler Value
getProductListR = do
prods <- runDB $ selectList [] [Asc ProductName]
variants <- runDB $ selectList [] [Asc ProductVariantSku]
returnJson $ object ["product" .= prods, "productVariant" .= variants]
postProductListR :: Handler Value
postProductListR = do
ProductList [p] <- requireJsonBody
insertedProduct <- runDB $ insertEntity p
returnJson insertedProduct
newtype ProductList = ProductList [Product]
instance FromJSON ProductList where
parseJSON (Object o) = do
productJson <- o .: "product"
p <- parseJSON productJson
return $ ProductList [p]
parseJSON _ = mzero
| Southern-Exposure-Seed-Exchange/Order-Manager-Prototypes | yesod/Handler/ProductList.hs | gpl-3.0 | 751 | 0 | 11 | 191 | 215 | 105 | 110 | 19 | 1 |
{- |
Module : Web.Handler
Description : Application-specific handler functions.
Copyright : (c) 2011 Cedric Staub, 2012 Benedikt Schmidt
License : GPL-3
Maintainer : Cedric Staub <[email protected]>
Stability : experimental
Portability : non-portable
-}
{-# LANGUAGE
OverloadedStrings, QuasiQuotes, TypeFamilies, FlexibleContexts,
RankNTypes, TemplateHaskell, CPP #-}
module Web.Handler
( getOverviewR
, getOverviewDiffR
, getRootR
, postRootR
, getTheorySourceR
, getTheorySourceDiffR
, getTheoryMessageDeductionR
, getTheoryMessageDeductionDiffR
, getTheoryVariantsR
, getTheoryVariantsDiffR
, getTheoryPathMR
, getTheoryPathDiffMR
-- , getTheoryPathDR
, getTheoryGraphR
, getTheoryGraphDiffR
, getAutoProverR
, getAutoDiffProverR
, getAutoProverDiffR
, getDeleteStepR
, getDeleteStepDiffR
, getKillThreadR
, getNextTheoryPathR
, getNextTheoryPathDiffR
, getPrevTheoryPathR
, getPrevTheoryPathDiffR
, getSaveTheoryR
, getDownloadTheoryR
, getDownloadTheoryDiffR
-- , getEditTheoryR
-- , postEditTheoryR
-- , getEditPathR
-- , postEditPathR
, getUnloadTheoryR
, getUnloadTheoryDiffR
-- , getThreadsR
)
where
import Theory (
ClosedTheory,
ClosedDiffTheory,
-- EitherClosedTheory,
Side,
thyName, diffThyName, removeLemma,
removeLemmaDiff, removeDiffLemma,
openTheory, sorryProver, runAutoProver,
sorryDiffProver, runAutoDiffProver,
prettyClosedTheory, prettyOpenTheory,
openDiffTheory,
prettyClosedDiffTheory, prettyOpenDiffTheory
)
import Theory.Proof (AutoProver(..), SolutionExtractor(..), Prover, DiffProver, apHeuristic)
import Text.PrettyPrint.Html
import Theory.Constraint.System.Dot
import Web.Hamlet
import Web.Instances ()
import Web.Settings
import Web.Theory
import Web.Types
import Yesod.Core
import Yesod.Json()
import Control.Monad.Trans.Resource (runResourceT)
import Data.Label
import Data.Maybe
import Data.String (fromString)
import Data.List (intersperse)
import Data.Monoid (mconcat)
import Data.Conduit as C ( ($$) )
import Data.Conduit.List (consume)
import qualified Blaze.ByteString.Builder as B
import qualified Data.ByteString.Char8 as BS
import qualified Data.Map as M
import qualified Data.Text as T
import qualified Data.Text.Encoding as T (encodeUtf8, decodeUtf8)
import qualified Data.Text.Lazy.Encoding as TLE
import qualified Data.Traversable as Tr
import Network.HTTP.Types ( urlDecode )
import Control.Applicative
import Control.Concurrent
import qualified Control.Concurrent.Thread as Thread ( forkIO )
import Control.DeepSeq
import Control.Exception.Base
import qualified Control.Exception.Lifted as E
import Control.Monad
import qualified Data.Binary as Bin
import Data.Time.LocalTime
import System.Directory
import Debug.Trace (trace)
-- Quasi-quotation syntax changed from GHC 6 to 7,
-- so we need this switch in order to support both
#if __GLASGOW_HASKELL__ >= 700
#define HAMLET hamlet
#else
#define HAMLET $hamlet
#endif
------------------------------------------------------------------------------
-- Manipulate the state
------------------------------------------------------------------------------
-- | Store theory map in file if option enabled.
storeTheory :: WebUI
-> EitherTheoryInfo
-> TheoryIdx
-> IO ()
storeTheory yesod thy idx =
when (autosaveProofstate yesod) $ do
let f = workDir yesod++"/"++autosaveSubdir++"/"++show idx++".img"
Bin.encodeFile (f++".tmp") thy
renameFile (f++".tmp") f
-- | Load a theory given an index.
getTheory :: TheoryIdx -> Handler (Maybe EitherTheoryInfo)
getTheory idx = do
yesod <- getYesod
liftIO $ withMVar (theoryVar yesod) $ return. M.lookup idx
-- | Store a theory, return index.
putTheory :: Maybe TheoryInfo -- ^ Index of parent theory
-> Maybe TheoryOrigin -- ^ Origin of this theory
-> ClosedTheory -- ^ The new closed theory
-> Handler TheoryIdx
putTheory parent origin thy = do
yesod <- getYesod
liftIO $ modifyMVar (theoryVar yesod) $ \theories -> do
time <- getZonedTime
let idx | M.null theories = 1
| otherwise = fst (M.findMax theories) + 1
parentIdx = tiIndex <$> parent
parentOrigin = tiOrigin <$> parent
newOrigin = parentOrigin <|> origin <|> (Just Interactive)
newThy = Trace (
TheoryInfo idx thy time parentIdx False (fromJust newOrigin)
(maybe (defaultAutoProver yesod) tiAutoProver parent))
storeTheory yesod newThy idx
return (M.insert idx newThy theories, idx)
-- | Store a theory, return index.
putDiffTheory :: Maybe DiffTheoryInfo -- ^ Index of parent theory
-> Maybe TheoryOrigin -- ^ Origin of this theory
-> ClosedDiffTheory -- ^ The new closed theory
-> Handler TheoryIdx
putDiffTheory parent origin thy = do
yesod <- getYesod
liftIO $ modifyMVar (theoryVar yesod) $ \theories -> do
time <- getZonedTime
let idx | M.null theories = 1
| otherwise = fst (M.findMax theories) + 1
parentIdx = dtiIndex <$> parent
parentOrigin = dtiOrigin <$> parent
newOrigin = parentOrigin <|> origin <|> (Just Interactive)
newThy = Diff (
DiffTheoryInfo idx thy time parentIdx False (fromJust newOrigin)
(maybe (defaultAutoProver yesod) dtiAutoProver parent))
storeTheory yesod newThy idx
return (M.insert idx newThy theories, idx)
-- | Delete theory.
delTheory :: TheoryIdx -> Handler ()
delTheory idx = do
yesod <- getYesod
liftIO $ modifyMVar_ (theoryVar yesod) $ \theories -> do
let theories' = M.delete idx theories
-- FIXME: delete from autosave directory?
return theories'
-- | Get a map of all stored theories.
getTheories :: Handler TheoryMap
getTheories = do
yesod <- getYesod
liftIO $ withMVar (theoryVar yesod) return
-- -- | Modify a theory in the map of theories.
-- adjTheory :: TheoryIdx
-- -> (TheoryInfo -> TheoryInfo)
-- -> Handler ()
-- adjTheory idx f = do
-- yesod <- getYesod
-- liftIO $ modifyMVar_ (theoryVar yesod) $ \theories ->
-- case M.lookup idx theories of
-- Just th -> do
-- case th of
-- Trace thy -> do
-- let newThy = f thy
-- storeTheory yesod (Trace newThy) idx
-- return $ M.insert idx (Trace newThy) theories
-- Diff _ -> error "adjTheory: found DiffTheory"
-- Nothing -> error "adjTheory: invalid theory index"
-- | Modify a theory in the map of theories.
adjEitherTheory :: TheoryIdx
-> (EitherTheoryInfo -> EitherTheoryInfo)
-> Handler ()
adjEitherTheory idx f = do
yesod <- getYesod
liftIO $ modifyMVar_ (theoryVar yesod) $ \theories ->
case M.lookup idx theories of
Just thy -> do
let newThy = f thy
storeTheory yesod newThy idx
return $ M.insert idx newThy theories
Nothing -> error "adjEitherTheory: invalid theory index"
-- -- | Modify a theory in the map of theories.
-- adjDiffTheory :: TheoryIdx
-- -> (DiffTheoryInfo -> DiffTheoryInfo)
-- -> Handler ()
-- adjDiffTheory idx f = do
-- yesod <- getYesod
-- liftIO $ modifyMVar_ (theoryVar yesod) $ \theories ->
-- case M.lookup idx theories of
-- Just th -> do
-- case th of
-- Diff thy -> do
-- let newThy = f thy
-- storeTheory yesod (Diff newThy) idx
-- return $ M.insert idx (Diff newThy) theories
-- Trace _ -> error "adjTheory: found normal Theory"
-- Nothing -> error "adjTheory: invalid theory index"
-- | Debug tracing.
dtrace :: WebUI -> String -> a -> a
dtrace yesod msg | debug yesod = trace msg
| otherwise = id
-- | Register a thread for killing.
putThread :: T.Text -- ^ Request path
-> ThreadId -- ^ Thread ID
-> Handler ()
putThread str tid = do
yesod <- getYesod
liftIO $ dtrace yesod msg $
modifyMVar_ (threadVar yesod) $ return . (M.insert str tid)
where
msg = "Registering thread: " ++ T.unpack str
-- | Unregister a thread for killing.
delThread :: T.Text -- ^ Request path
-> Handler ()
delThread str = do
yesod <- getYesod
liftIO $ dtrace yesod msg $
modifyMVar_ (threadVar yesod) $ return . (M.delete str)
where
msg = "Deleting thread: " ++ T.unpack str
-- | Get a thread for the given request URL.
getThread :: T.Text -- ^ Request path
-> Handler (Maybe ThreadId)
getThread str = do
yesod <- getYesod
liftIO $ dtrace yesod msg $
withMVar (threadVar yesod) $ return . M.lookup str
where
msg = "Retrieving thread id of: " ++ T.unpack str
{-
-- | Get the map of all threads.
-- getThreads :: MonadIO m
-- => GenericHandler m [T.Text]
getThreads = do
yesod <- getYesod
liftIO $ withMVar (threadVar yesod) (return . M.keys)
-}
------------------------------------------------------------------------------
-- Helper functions
------------------------------------------------------------------------------
-- | Print exceptions, if they happen.
traceExceptions :: MonadBaseControl IO m => String -> m a -> m a
traceExceptions info =
E.handle handler
where
handler :: MonadBaseControl IO m => E.SomeException -> m a
handler e =
trace (info ++ ": exception `" ++ show e ++ "'") $ E.throwIO e
-- | Helper functions for generating JSON reponses.
jsonResp :: JsonResponse -> Handler RepJson
jsonResp = return . RepJson . toContent . responseToJson
responseToJson :: JsonResponse -> Value
responseToJson = go
where
jsonObj key val = object [ key .= val ]
go (JsonAlert msg) = jsonObj "alert" $ toJSON msg
go (JsonRedirect url) = jsonObj "redirect" $ toJSON url
go (JsonHtml title content) = object
[ "html" .= contentToJson content
, "title" .= title ]
contentToJson (ContentBuilder b _) = toJSON $ TLE.decodeUtf8 $ B.toLazyByteString b
contentToJson _ = error "Unsupported content format in json response!"
-- | Fully evaluate a value in a thread that can be canceled.
evalInThread :: NFData a
=> IO a
-> Handler (Either SomeException a)
evalInThread io = do
renderF <- getUrlRender
maybeRoute <- getCurrentRoute
case maybeRoute of
Just route -> do
let key = renderF route
(tid, wait) <- liftIO $ Thread.forkIO $ do x <- io
evaluate (rnf x)
return x
putThread key tid
res <- liftIO $ wait
delThread key
return res
Nothing -> Right `liftM` liftIO io
-- | Evaluate a handler with a given theory specified by the index,
-- return notFound if theory does not exist.
withTheory :: TheoryIdx
-> (TheoryInfo -> Handler a)
-> Handler a
withTheory idx handler = do
maybeThy <- getTheory idx
case maybeThy of
Just eitherTi -> case eitherTi of
Trace ti -> handler ti
Diff _ -> notFound
Nothing -> notFound
-- | Evaluate a handler with a given theory specified by the index,
-- return notFound if theory does not exist.
withBothTheory :: TheoryIdx
-> (TheoryInfo -> Handler a)
-> (DiffTheoryInfo -> Handler a)
-> Handler a
withBothTheory idx handler diffhandler = do
maybeThy <- getTheory idx
case maybeThy of
Just eitherTi -> case eitherTi of
Trace ti -> handler ti
Diff ti -> diffhandler ti
Nothing -> notFound
-- | Evaluate a handler with a given theory specified by the index,
-- return notFound if theory does not exist.
withDiffTheory :: TheoryIdx
-> (DiffTheoryInfo -> Handler a)
-> Handler a
withDiffTheory idx handler = do
maybeThy <- getTheory idx
case maybeThy of
Just eitherTi -> case eitherTi of
Trace _ -> notFound
Diff ti -> handler ti
Nothing -> notFound
-- | Evaluate a handler with a given theory specified by the index,
-- return notFound if theory does not exist.
withEitherTheory :: TheoryIdx
-> (EitherTheoryInfo -> Handler a)
-> Handler a
withEitherTheory idx handler = do
maybeThy <- getTheory idx
case maybeThy of
Just ti -> handler ti
Nothing -> notFound
{-
-- | Run a form and provide a JSON response.
-- formHandler :: (HamletValue h, HamletUrl h ~ WebUIRoute, h ~ Widget ())
-- => T.Text -- ^ The form title
-- -> Form WebUI WebUI a -- ^ The formlet to run
-- -> (Widget () -> Enctype -> Html -> h) -- ^ Template to render form with
-- -> (a -> GenericHandler IO RepJson) -- ^ Function to call on success
-- -> Handler RepJson
formHandler title formlet template success = do
-- (result, widget, enctype, nonce) <- runFormPost formlet
((result, widget), enctype) <- runFormPost formlet
case result of
FormMissing -> do
RepHtml content <- ajaxLayout (template widget enctype)
jsonResp $ JsonHtml title content
FormFailure _ -> jsonResp $ JsonAlert
"Missing fields in form. Please fill out all required fields."
FormSuccess ret -> lift (success ret)
-}
-- | Modify a theory, redirect if successful.
modifyTheory :: TheoryInfo -- ^ Theory to modify
-> (ClosedTheory -> IO (Maybe ClosedTheory)) -- ^ Function to apply
-> (ClosedTheory -> TheoryPath) -- ^ Compute the new path
-> JsonResponse -- ^ Response on failure
-> Handler Value
modifyTheory ti f fpath errResponse = do
res <- evalInThread (liftIO $ f (tiTheory ti))
case res of
Left e -> return (excResponse e)
Right Nothing -> return (responseToJson errResponse)
Right (Just thy) -> do
newThyIdx <- putTheory (Just ti) Nothing thy
newUrl <- getUrlRender <*> pure (OverviewR newThyIdx (fpath thy))
return . responseToJson $ JsonRedirect newUrl
where
excResponse e = responseToJson
(JsonAlert $ "Last request failed with exception: " `T.append` (T.pack (show e)))
-- | Modify a theory, redirect if successful.
modifyDiffTheory :: DiffTheoryInfo -- ^ Theory to modify
-> (ClosedDiffTheory -> IO (Maybe ClosedDiffTheory)) -- ^ Function to apply
-> (ClosedDiffTheory -> DiffTheoryPath) -- ^ Compute the new path
-> JsonResponse -- ^ Response on failure
-> Handler Value
modifyDiffTheory ti f fpath errResponse = do
res <- evalInThread (liftIO $ f (dtiTheory ti))
case res of
Left e -> return (excResponse e)
Right Nothing -> return (responseToJson errResponse)
Right (Just thy) -> do
newThyIdx <- putDiffTheory (Just ti) Nothing thy
newUrl <- getUrlRender <*> pure (OverviewDiffR newThyIdx (fpath thy))
return . responseToJson $ JsonRedirect newUrl
where
excResponse e = responseToJson
(JsonAlert $ "Last request failed with exception: " `T.append` (T.pack (show e)))
------------------------------------------------------------------------------
-- Handler functions
------------------------------------------------------------------------------
-- | The root handler lists all theories by default,
-- or load a new theory if the corresponding form was submitted.
getRootR :: Handler Html
getRootR = do
theories <- getTheories
defaultLayout $ do
setTitle "Welcome to the Tamarin prover"
rootTpl theories
data File = File T.Text
deriving Show
postRootR :: Handler Html
postRootR = do
result <- lookupFile "uploadedTheory"
case result of
Nothing ->
setMessage "Post request failed."
Just fileinfo -> do
-- content <- liftIO $ LBS.fromChunks <$> (fileSource fileinfo $$ consume)
content <- liftIO $ runResourceT (fileSource fileinfo C.$$ consume)
if null content
then setMessage "No theory file given."
else do
yesod <- getYesod
if isDiffTheory yesod
then do
closedThy <- liftIO $ diffParseThy yesod (T.unpack $ T.decodeUtf8 $ BS.concat content)
case closedThy of
Left err -> setMessage $ "Theory loading failed:\n" <> toHtml err
Right thy -> do
void $ putDiffTheory Nothing
(Just $ Upload $ T.unpack $ fileName fileinfo) thy
setMessage "Loaded new theory!"
else do
closedThy <- liftIO $ parseThy yesod (T.unpack $ T.decodeUtf8 $ BS.concat content)
case closedThy of
Left err -> setMessage $ "Theory loading failed:\n" <> toHtml err
Right thy -> do
void $ putTheory Nothing
(Just $ Upload $ T.unpack $ fileName fileinfo) thy
setMessage "Loaded new theory!"
theories <- getTheories
defaultLayout $ do
setTitle "Welcome to the Tamarin prover"
rootTpl theories
-- | Show overview over theory (framed layout).
getOverviewR :: TheoryIdx -> TheoryPath -> Handler Html
getOverviewR idx path = withTheory idx ( \ti -> do
renderF <- getUrlRender
defaultLayout $ do
overview <- liftIO $ overviewTpl renderF ti path
setTitle (toHtml $ "Theory: " ++ get thyName (tiTheory ti))
overview )
-- | Show overview over diff theory (framed layout).
getOverviewDiffR :: TheoryIdx -> DiffTheoryPath -> Handler Html
getOverviewDiffR idx path = withDiffTheory idx ( \ti -> do
renderF <- getUrlRender
defaultLayout $ do
overview <- liftIO $ overviewDiffTpl renderF ti path
setTitle (toHtml $ "DiffTheory: " ++ get diffThyName (dtiTheory ti))
overview )
-- | Show source (pretty-printed open theory).
getTheorySourceR :: TheoryIdx -> Handler RepPlain
getTheorySourceR idx = withBothTheory idx ( \ti ->
return $ RepPlain $ toContent $ prettyRender ti) ( \ti ->
return $ RepPlain $ toContent $ prettyRenderDiff ti)
where
prettyRender = render . prettyClosedTheory . tiTheory
prettyRenderDiff = render . prettyClosedDiffTheory . dtiTheory
-- | Show source (pretty-printed open diff theory).
getTheorySourceDiffR :: TheoryIdx -> Handler RepPlain
getTheorySourceDiffR idx = withBothTheory idx ( \ti ->
return $ RepPlain $ toContent $ prettyRender ti) ( \ti ->
return $ RepPlain $ toContent $ prettyRenderDiff ti)
where
prettyRender = render . prettyClosedTheory . tiTheory
prettyRenderDiff = render . prettyClosedDiffTheory . dtiTheory
-- | Show variants (pretty-printed closed theory).
getTheoryVariantsR :: TheoryIdx -> Handler RepPlain
getTheoryVariantsR idx = withBothTheory idx ( \ti ->
return $ RepPlain $ toContent $ prettyRender ti ) ( \ti ->
return $ RepPlain $ toContent $ prettyRenderDiff ti )
where prettyRender = render . prettyClosedTheory . tiTheory
prettyRenderDiff = render . prettyClosedDiffTheory . dtiTheory
-- | Show variants (pretty-printed closed diff theory).
getTheoryVariantsDiffR :: TheoryIdx -> Handler RepPlain
getTheoryVariantsDiffR idx = withBothTheory idx ( \ti ->
return $ RepPlain $ toContent $ prettyRender ti ) ( \ti ->
return $ RepPlain $ toContent $ prettyRenderDiff ti )
where prettyRender = render . prettyClosedTheory . tiTheory
prettyRenderDiff = render . prettyClosedDiffTheory . dtiTheory
-- | Show variants (pretty-printed closed theory).
getTheoryMessageDeductionR :: TheoryIdx -> Handler RepPlain
getTheoryMessageDeductionR idx = withBothTheory idx ( \ti ->
return $ RepPlain $ toContent $ prettyRender ti ) ( \ti ->
return $ RepPlain $ toContent $ prettyRenderDiff ti )
where prettyRender = render . prettyClosedTheory . tiTheory
prettyRenderDiff = render . prettyClosedDiffTheory . dtiTheory
-- | Show variants (pretty-printed closed theory).
getTheoryMessageDeductionDiffR :: TheoryIdx -> Handler RepPlain
getTheoryMessageDeductionDiffR idx = withBothTheory idx ( \ti ->
return $ RepPlain $ toContent $ prettyRender ti ) ( \ti ->
return $ RepPlain $ toContent $ prettyRenderDiff ti )
where prettyRender = render . prettyClosedTheory . tiTheory
prettyRenderDiff = render . prettyClosedDiffTheory . dtiTheory
-- | Show a given path within a theory (main view).
getTheoryPathMR :: TheoryIdx
-> TheoryPath
-> Handler RepJson
getTheoryPathMR idx path = do
renderUrl <- getUrlRender
jsonValue <- withTheory idx (go renderUrl path)
return $ RepJson $ toContent jsonValue
where
--
-- Handle method paths by trying to solve the given goal/method
--
go _ (TheoryMethod lemma proofPath i) ti = modifyTheory ti
(\thy -> return $ applyMethodAtPath thy lemma proofPath heuristic i)
(\thy -> nextSmartThyPath thy (TheoryProof lemma proofPath))
(JsonAlert "Sorry, but the prover failed on the selected method!")
where
heuristic = apHeuristic (tiAutoProver ti)
--
-- Handle generic paths by trying to render them
--
go renderUrl _ ti = do
let title = T.pack $ titleThyPath (tiTheory ti) path
let html = htmlThyPath renderUrl ti path
return $ responseToJson (JsonHtml title $ toContent html)
-- | Show a given path within a diff theory (main view).
getTheoryPathDiffMR :: TheoryIdx
-> DiffTheoryPath
-> Handler RepJson
getTheoryPathDiffMR idx path = do
-- error ("failed in handler" ++ show path)
renderUrl <- getUrlRender
jsonValue <- withDiffTheory idx (goDiff renderUrl path)
return $ RepJson $ toContent jsonValue
where
--
-- Handle method paths by trying to solve the given goal/method
--
goDiff _ (DiffTheoryMethod s lemma proofPath i) ti = modifyDiffTheory ti
(\thy -> return $ applyMethodAtPathDiff thy s lemma proofPath heuristic i)
(\thy -> nextSmartDiffThyPath thy (DiffTheoryProof s lemma proofPath))
(JsonAlert "Sorry, but the prover failed on the selected method!")
where
heuristic = apHeuristic (dtiAutoProver ti)
goDiff _ (DiffTheoryDiffMethod lemma proofPath i) ti = modifyDiffTheory ti
(\thy -> return $ applyDiffMethodAtPath thy lemma proofPath heuristic i)
(\thy -> nextSmartDiffThyPath thy (DiffTheoryDiffProof lemma proofPath))
(JsonAlert "Sorry, but the prover failed on the selected method!")
where
heuristic = apHeuristic (dtiAutoProver ti)
--
-- Handle generic paths by trying to render them
--
goDiff renderUrl _ ti = do
let title = T.pack $ titleDiffThyPath (dtiTheory ti) path
let html = htmlDiffThyPath renderUrl ti path
return $ responseToJson (JsonHtml title $ toContent html)
-- | Run the some prover on a given proof path.
getProverR :: (T.Text, AutoProver -> Prover)
-> TheoryIdx -> TheoryPath -> Handler RepJson
getProverR (name, mkProver) idx path = do
jsonValue <- withTheory idx (go path)
return $ RepJson $ toContent jsonValue
where
go (TheoryProof lemma proofPath) ti = modifyTheory ti
(\thy ->
return $ applyProverAtPath thy lemma proofPath autoProver)
(\thy -> nextSmartThyPath thy path)
(JsonAlert $ "Sorry, but " <> name <> " failed!")
where
autoProver = mkProver (tiAutoProver ti)
go _ _ = return $ responseToJson $ JsonAlert $
"Can't run " <> name <> " on the given theory path!"
-- | Run the some prover on a given proof path.
getProverDiffR :: (T.Text, AutoProver -> Prover)
-> TheoryIdx -> Side -> DiffTheoryPath -> Handler RepJson
getProverDiffR (name, mkProver) idx s path = do
jsonValue <- withDiffTheory idx (goDiff s path)
return $ RepJson $ toContent jsonValue
where
goDiff s'' (DiffTheoryProof s' lemma proofPath) ti =
if s''==s'
then modifyDiffTheory ti
(\thy ->
return $ applyProverAtPathDiff thy s' lemma proofPath autoProver)
(\thy -> nextSmartDiffThyPath thy path)
(JsonAlert $ "Sorry, but " <> name <> " failed!")
else
return $ responseToJson $ JsonAlert $
"Can't run " <> name <> " on the given theory path!"
where
autoProver = mkProver (dtiAutoProver ti)
goDiff _ _ _ = return $ responseToJson $ JsonAlert $
"Can't run " <> name <> " on the given theory path!"
-- | Run the some prover on a given proof path.
getDiffProverR :: (T.Text, AutoProver -> DiffProver)
-> TheoryIdx -> DiffTheoryPath -> Handler RepJson
getDiffProverR (name, mkProver) idx path = do
jsonValue <- withDiffTheory idx (goDiff path)
return $ RepJson $ toContent jsonValue
where
goDiff (DiffTheoryDiffProof lemma proofPath) ti =
modifyDiffTheory ti
(\thy ->
return $ applyDiffProverAtPath thy lemma proofPath autoProver)
(\thy -> nextSmartDiffThyPath thy path)
(JsonAlert $ "Sorry, but " <> name <> " failed!")
where
autoProver = mkProver (dtiAutoProver ti)
goDiff _ _ = return $ responseToJson $ JsonAlert $
"Can't run " <> name <> " on the given theory path!"
-- | Run an autoprover on a given proof path.
getAutoProverR :: TheoryIdx
-> SolutionExtractor
-> Int -- autoprover bound to use
-> TheoryPath -> Handler RepJson
getAutoProverR idx extractor bound =
getProverR (fullName, runAutoProver . adapt) idx
where
adapt autoProver = autoProver { apBound = actualBound, apCut = extractor }
withCommas = intersperse ", "
fullName = mconcat $ proverName : " (" : withCommas qualifiers ++ [")"]
qualifiers = extractorQualfier ++ boundQualifier
(actualBound, boundQualifier)
| bound > 0 = (Just bound, ["bound " <> T.pack (show bound)])
| otherwise = (Nothing, [] )
(proverName, extractorQualfier) = case extractor of
CutNothing -> ("characterization", ["dfs"])
CutDFS -> ("the autoprover", [] )
CutBFS -> ("the autoprover", ["bfs"])
-- | Run an autoprover on a given proof path.
getAutoProverDiffR :: TheoryIdx
-> SolutionExtractor
-> Int -- autoprover bound to use
-> Side -> DiffTheoryPath -> Handler RepJson
getAutoProverDiffR idx extractor bound s =
getProverDiffR (fullName, runAutoProver . adapt) idx s
where
adapt autoProver = autoProver { apBound = actualBound, apCut = extractor }
withCommas = intersperse ", "
fullName = mconcat $ proverName : " (" : withCommas qualifiers ++ [")"]
qualifiers = extractorQualfier ++ boundQualifier
(actualBound, boundQualifier)
| bound > 0 = (Just bound, ["bound " <> T.pack (show bound)])
| otherwise = (Nothing, [] )
(proverName, extractorQualfier) = case extractor of
CutNothing -> ("characterization", ["dfs"])
CutDFS -> ("the autoprover", [] )
CutBFS -> ("the autoprover", ["bfs"])
-- | Run an autoprover on a given proof path.
getAutoDiffProverR :: TheoryIdx
-> SolutionExtractor
-> Int -- autoprover bound to use
-> DiffTheoryPath -> Handler RepJson
getAutoDiffProverR idx extractor bound =
getDiffProverR (fullName, runAutoDiffProver . adapt) idx
where
adapt autoProver = autoProver { apBound = actualBound, apCut = extractor }
withCommas = intersperse ", "
fullName = mconcat $ proverName : " (" : withCommas qualifiers ++ [")"]
qualifiers = extractorQualfier ++ boundQualifier
(actualBound, boundQualifier)
| bound > 0 = (Just bound, ["bound " <> T.pack (show bound)])
| otherwise = (Nothing, [] )
(proverName, extractorQualfier) = case extractor of
CutNothing -> ("characterization", ["dfs"])
CutDFS -> ("the autoprover", [] )
CutBFS -> ("the autoprover", ["bfs"])
{-
-- | Show a given path within a theory (debug view).
getTheoryPathDR :: TheoryIdx -> TheoryPath -> Handler Html
getTheoryPathDR idx path = withTheory idx $ \ti -> ajaxLayout $ do
-- let maybeDebug = htmlThyDbgPath (tiTheory ti) path
-- let maybeWidget = wrapHtmlDoc <$> maybeDebug
return [hamlet|
<h2>Theory information</h2>
<ul>
<li>Index = #{show (tiIndex ti)}
<li>Path = #{show path}
<li>Time = #{show (tiTime ti)}
<li>Origin = #{show (tiOrigin ti)}
<li>NextPath = #{show (nextThyPath (tiTheory ti) path)}
<li>PrevPath = #{show (prevThyPath (tiTheory ti) path)}
<li>NextSmartPath = #{show (nextSmartThyPath (tiTheory ti) path)}
<li>PrevSmartPath = #{show (prevSmartThyPath (tiTheory ti) path)}
|]
{-
$if isJust maybeWidget
<h2>Current sequent</h2><br>
\^{fromJust maybeWidget}
|]
-}
-}
-- | Get rendered graph for theory and given path.
getTheoryGraphR :: TheoryIdx -> TheoryPath -> Handler ()
getTheoryGraphR idx path = withTheory idx ( \ti -> do
yesod <- getYesod
compact <- isNothing <$> lookupGetParam "uncompact"
compress <- isNothing <$> lookupGetParam "uncompress"
img <- liftIO $ traceExceptions "getTheoryGraphR" $
imgThyPath
(imageFormat yesod)
(dotCmd yesod)
(cacheDir yesod)
(graphStyle compact compress)
(tiTheory ti) path
sendFile (fromString . imageFormatMIME $ imageFormat yesod) img)
where
graphStyle d c = dotStyle d . compression c
dotStyle True = dotSystemCompact CompactBoringNodes
dotStyle False = dotSystemCompact FullBoringNodes
compression True = compressSystem
compression False = id
-- | Get rendered graph for theory and given path.
getTheoryGraphDiffR :: TheoryIdx -> DiffTheoryPath -> Handler ()
getTheoryGraphDiffR idx path = withDiffTheory idx ( \ti -> do
yesod <- getYesod
compact <- isNothing <$> lookupGetParam "uncompact"
compress <- isNothing <$> lookupGetParam "uncompress"
img <- liftIO $ traceExceptions "getTheoryGraphDiffR" $
imgDiffThyPath
(imageFormat yesod)
(dotCmd yesod)
(cacheDir yesod)
(graphStyle compact compress)
(dtiTheory ti) path
sendFile (fromString . imageFormatMIME $ imageFormat yesod) img)
where
graphStyle d c = dotStyle d . compression c
dotStyle True = dotSystemCompact CompactBoringNodes
dotStyle False = dotSystemCompact FullBoringNodes
compression True = compressSystem
compression False = id
-- | Kill a thread (aka 'cancel request').
getKillThreadR :: Handler RepPlain
getKillThreadR = do
maybeKey <- lookupGetParam "path"
case maybeKey of
Just key0 -> do
let key = T.decodeUtf8 . urlDecode True . T.encodeUtf8 $ key0
tryKillThread key
return $ RepPlain $ toContent ("Canceled request!" :: T.Text)
Nothing -> invalidArgs ["No path to kill specified!"]
where
-- thread waiting for the result is responsible for
-- updating the ThreadMap.
tryKillThread k = do
maybeTid <- getThread k
case maybeTid of
Nothing -> trace ("Killing failed: "++ T.unpack k) $ return ()
Just tid -> trace ("Killing: " ++ T.unpack k)
(liftIO $ killThread tid)
-- | Get the 'next' theory path for a given path.
-- This function is used for implementing keyboard shortcuts.
getNextTheoryPathR :: TheoryIdx -- ^ Theory index
-> String -- ^ Jumping mode (smart?)
-> TheoryPath -- ^ Current path
-> Handler RepPlain
getNextTheoryPathR idx md path = withTheory idx (\ti -> do
url <- getUrlRender <*> pure (TheoryPathMR idx $ next md (tiTheory ti) path)
return . RepPlain $ toContent url)
where
next "normal" = nextThyPath
next "smart" = nextSmartThyPath
next _ = const id
-- | Get the 'next' theory path for a given path.
-- This function is used for implementing keyboard shortcuts.
getNextTheoryPathDiffR :: TheoryIdx -- ^ Theory index
-> String -- ^ Jumping mode (smart?)
-> DiffTheoryPath -- ^ Current path
-> Handler RepPlain
getNextTheoryPathDiffR idx md path = withDiffTheory idx (\ti -> do
url <- getUrlRender <*> pure (TheoryPathDiffMR idx $ nextDiff md (dtiTheory ti) path)
return . RepPlain $ toContent url)
where
nextDiff "normal" = nextDiffThyPath
nextDiff "smart" = nextSmartDiffThyPath
nextDiff _ = const id
-- | Get the 'prev' theory path for a given path.
-- This function is used for implementing keyboard shortcuts.
getPrevTheoryPathR :: TheoryIdx -> String -> TheoryPath -> Handler RepPlain
getPrevTheoryPathR idx md path = withTheory idx (\ti -> do
url <- getUrlRender <*> pure (TheoryPathMR idx $ prev md (tiTheory ti) path)
return $ RepPlain $ toContent url)
where
prev "normal" = prevThyPath
prev "smart" = prevSmartThyPath
prev _ = const id
-- | Get the 'prev' theory path for a given path.
-- This function is used for implementing keyboard shortcuts.
getPrevTheoryPathDiffR :: TheoryIdx -> String -> DiffTheoryPath -> Handler RepPlain
getPrevTheoryPathDiffR idx md path = withDiffTheory idx (\ti -> do
url <- getUrlRender <*> pure (TheoryPathDiffMR idx $ prevDiff md (dtiTheory ti) path)
return $ RepPlain $ toContent url)
where
prevDiff "normal" = prevDiffThyPath
prevDiff "smart" = prevSmartDiffThyPath
prevDiff _ = const id
{-
-- | Get the edit theory page.
getEditTheoryR :: TheoryIdx -> Handler RepJson
getEditTheoryR = postEditTheoryR
-- | Post edit theory page form data.
postEditTheoryR :: TheoryIdx -> Handler RepJson
postEditTheoryR idx = withTheory idx $ \ti -> formHandler
"Edit theory"
(theoryFormlet ti)
theoryFormTpl $ \(Textarea input) ->
E.handle exHandler $ do
yesod <- getYesod
closedThy <- checkProofs <$> parseThy yesod (T.unpack input)
newIdx <- putTheory (Just ti) Nothing closedThy
jsonResp . JsonRedirect =<<
getUrlRender <*> pure (OverviewR newIdx)
where
-- theoryFormlet ti = fieldsToDivs $ textareaField
theoryFormlet ti = textareaField
(FieldSettings
("Edit theory source: " `T.append` name ti)
(toHtml $ name ti) Nothing Nothing)
(Just $ Textarea $ T.pack $ render $ prettyClosedTheory $ tiTheory ti)
exHandler :: MonadBaseControl IO m => E.SomeException -> GHandler m RepJson
exHandler err = jsonResp $ JsonAlert $ T.unlines
[ "Unable to load theory due to parse error!"
, "Parser returned the message:"
, T.pack $ show err ]
name = T.pack . get thyName . tiTheory
theoryFormTpl = formTpl (EditTheoryR idx) "Load as new theory"
-}
{-
SM: Path editing hs bitrotted. Re-enable/implement once we really need it.
-- | Get the add lemma page.
getEditPathR :: TheoryIdx -> TheoryPath -> Handler RepJson
getEditPathR = postEditPathR
-- | Post edit theory page form data.
postEditPathR :: TheoryIdx -> TheoryPath -> Handler RepJson
postEditPathR idx (TheoryLemma lemmaName) = withTheory idx $ \ti -> do
yesod <- getYesod
let lemma = lookupLemma lemmaName (tiTheory ti)
formHandler
(T.pack $ action lemma)
(formlet lemma)
(lemmaFormTpl lemma) $ \(Textarea input) ->
case parseLemma (T.unpack input) of
Left err -> jsonResp $ JsonAlert $ T.unlines
[ "Unable to add lemma to theory due to parse error!"
, "Parser returned the message:"
, T.pack $ show err ]
Right newLemma -> (RepJson . toContent . fromValue) <$> modifyTheory ti
-- Add or replace lemma
(\thy -> do
let openThy = openTheory thy
openThy' = case lemma of
Nothing -> addLemma newLemma openThy
Just _ -> removeLemma lemmaName openThy
>>= addLemma newLemma
-- SM: Theory closing has to be implemented again.
-- Probably, the whole path editing has to be rethought.
traverse (closeThy yesod) openThy')
-- Error response
(JsonAlert $ T.unwords
[ "Unable to add lemma to theory."
, "Does a lemma with the same name already exist?" ])
where
path (Just l) = TheoryLemma (get lName l)
path Nothing = TheoryLemma ""
action (Just l) = "Edit lemma " ++ get lName l
action Nothing = "Add new lemma"
-- formlet lemma = fieldsToDivs $ textareaField
formlet lemma = textareaField
(FieldSettings
(T.pack $ action lemma)
(toHtml $ action lemma)
Nothing Nothing)
(Textarea . T.pack . render . prettyLemma prettyProof <$> lemma)
lemmaFormTpl lemma = formTpl (EditPathR idx (path lemma)) "Submit"
postEditPathR _ _ =
jsonResp $ JsonAlert $ "Editing for this path is not implemented!"
-}
-- | Delete a given proof step.
getDeleteStepR :: TheoryIdx -> TheoryPath -> Handler RepJson
getDeleteStepR idx path = do
jsonValue <- withTheory idx (go path)
return $ RepJson $ toContent jsonValue
where
go (TheoryLemma lemma) ti = modifyTheory ti
(return . removeLemma lemma)
(const path)
(JsonAlert "Sorry, but removing the selected lemma failed!")
go (TheoryProof lemma proofPath) ti = modifyTheory ti
(\thy -> return $
applyProverAtPath thy lemma proofPath (sorryProver (Just "removed")))
(const path)
(JsonAlert "Sorry, but removing the selected proof step failed!")
go _ _ = return . responseToJson $ JsonAlert
"Can't delete the given theory path!"
-- | Delete a given proof step.
getDeleteStepDiffR :: TheoryIdx -> DiffTheoryPath -> Handler RepJson
getDeleteStepDiffR idx path = do
jsonValue <- withDiffTheory idx (goDiff path)
return $ RepJson $ toContent jsonValue
where
goDiff (DiffTheoryLemma s lemma) ti = modifyDiffTheory ti
(return . removeLemmaDiff s lemma)
(const path)
(JsonAlert "Sorry, but removing the selected lemma failed!")
goDiff (DiffTheoryProof s lemma proofPath) ti = modifyDiffTheory ti
(\thy -> return $
applyProverAtPathDiff thy s lemma proofPath (sorryProver (Just "removed")))
(const path)
(JsonAlert "Sorry, but removing the selected proof step failed!")
goDiff (DiffTheoryDiffLemma lemma) ti = modifyDiffTheory ti
(return . removeDiffLemma lemma)
(const path)
(JsonAlert "Sorry, but removing the selected lemma failed!")
goDiff (DiffTheoryDiffProof lemma proofPath) ti = modifyDiffTheory ti
(\thy -> return $
applyDiffProverAtPath thy lemma proofPath (sorryDiffProver (Just "removed")))
(const path)
(JsonAlert "Sorry, but removing the selected proof step failed!")
goDiff _ _ = return . responseToJson $ JsonAlert
"Can't delete the given theory path!"
-- | Save a theory to the working directory.
getSaveTheoryR :: TheoryIdx -> Handler RepJson
getSaveTheoryR idx = withEitherTheory idx $ \eti -> do
case eti of
Trace ti -> do
let origin = tiOrigin ti
case origin of
-- Saving interactive/uploaded files not supported yet.
Interactive -> notFound
Upload _ -> notFound
-- Saving of local files implemented.
Local file -> do
-- Save theory to disk
liftIO $ writeFile file (prettyRender ti)
-- Find original theorie(s) with same origin
-- Set original -> modified
thys <- M.filter (same origin) <$> getTheories
_ <- Tr.mapM (\t -> adjEitherTheory (getEitherTheoryIndex t) (setPrimary False)) thys
-- Find current theory
-- Set modified -> original
adjEitherTheory (tiIndex ti) (setPrimary True)
-- Return message
jsonResp (JsonAlert $ T.pack $ "Saved theory to file: " ++ file)
Diff ti -> do
let origin = dtiOrigin ti
case origin of
-- Saving interactive/uploaded files not supported yet.
Interactive -> notFound
Upload _ -> notFound
-- Saving of local files implemented.
Local file -> do
-- Save theory to disk
liftIO $ writeFile file (prettyRenderD ti)
-- Find original theorie(s) with same origin
-- Set original -> modified
thys <- M.filter (same origin) <$> getTheories
_ <- Tr.mapM (\t -> adjEitherTheory (getEitherTheoryIndex t) (setPrimary False)) thys
-- Find current theory
-- Set modified -> original
adjEitherTheory (dtiIndex ti) (setPrimary True)
-- Return message
jsonResp (JsonAlert $ T.pack $ "Saved theory to file: " ++ file)
where
prettyRender ti = render $ prettyOpenTheory $ openTheory $ tiTheory ti
prettyRenderD ti = render $ prettyOpenDiffTheory $ openDiffTheory $ dtiTheory ti
same origin (Trace ti) = tiPrimary ti && (tiOrigin ti == origin)
same origin (Diff ti) = dtiPrimary ti && (dtiOrigin ti == origin)
setPrimary :: Bool -> EitherTheoryInfo -> EitherTheoryInfo
setPrimary bool (Trace ti) = Trace (ti { tiPrimary = bool })
setPrimary bool (Diff ti) = Diff (ti { dtiPrimary = bool })
-- | Prompt downloading of theory.
getDownloadTheoryR :: TheoryIdx -> String -> Handler (ContentType, Content)
getDownloadTheoryR idx _ = do
RepPlain source <- getTheorySourceR idx
return (typeOctet, source)
-- | Prompt downloading of theory.
getDownloadTheoryDiffR :: TheoryIdx -> String -> Handler (ContentType, Content)
getDownloadTheoryDiffR = getDownloadTheoryR
-- | Unload a theory from the interactive server.
getUnloadTheoryR :: TheoryIdx -> Handler RepPlain
getUnloadTheoryR idx = do
delTheory idx
redirect RootR
-- | Unload a theory from the interactive server.
getUnloadTheoryDiffR :: TheoryIdx -> Handler RepPlain
getUnloadTheoryDiffR = getUnloadTheoryR
{-
-- | Show a list of all currently running threads.
getThreadsR :: Handler Html
getThreadsR = do
threads <- getThreads
defaultLayout $ do
setTitle "Registered threads"
addWidget (threadsTpl threads)
-}
| ekr/tamarin-prover | src/Web/Handler.hs | gpl-3.0 | 44,176 | 520 | 24 | 12,734 | 8,245 | 4,349 | 3,896 | 674 | 8 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- |
-- Module : Network.Google.Resource.Content.Orders.CanceltestOrderbycustomer
-- Copyright : (c) 2015-2016 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Sandbox only. Cancels a test order for customer-initiated cancellation.
--
-- /See:/ <https://developers.google.com/shopping-content/v2/ Content API for Shopping Reference> for @content.orders.canceltestorderbycustomer@.
module Network.Google.Resource.Content.Orders.CanceltestOrderbycustomer
(
-- * REST Resource
OrdersCanceltestOrderbycustomerResource
-- * Creating a Request
, ordersCanceltestOrderbycustomer
, OrdersCanceltestOrderbycustomer
-- * Request Lenses
, ocoXgafv
, ocoMerchantId
, ocoUploadProtocol
, ocoAccessToken
, ocoUploadType
, ocoPayload
, ocoOrderId
, ocoCallback
) where
import Network.Google.Prelude
import Network.Google.ShoppingContent.Types
-- | A resource alias for @content.orders.canceltestorderbycustomer@ method which the
-- 'OrdersCanceltestOrderbycustomer' request conforms to.
type OrdersCanceltestOrderbycustomerResource =
"content" :>
"v2.1" :>
Capture "merchantId" (Textual Word64) :>
"testorders" :>
Capture "orderId" Text :>
"cancelByCustomer" :>
QueryParam "$.xgafv" Xgafv :>
QueryParam "upload_protocol" Text :>
QueryParam "access_token" Text :>
QueryParam "uploadType" Text :>
QueryParam "callback" Text :>
QueryParam "alt" AltJSON :>
ReqBody '[JSON]
OrdersCancelTestOrderByCustomerRequest
:>
Post '[JSON]
OrdersCancelTestOrderByCustomerResponse
-- | Sandbox only. Cancels a test order for customer-initiated cancellation.
--
-- /See:/ 'ordersCanceltestOrderbycustomer' smart constructor.
data OrdersCanceltestOrderbycustomer =
OrdersCanceltestOrderbycustomer'
{ _ocoXgafv :: !(Maybe Xgafv)
, _ocoMerchantId :: !(Textual Word64)
, _ocoUploadProtocol :: !(Maybe Text)
, _ocoAccessToken :: !(Maybe Text)
, _ocoUploadType :: !(Maybe Text)
, _ocoPayload :: !OrdersCancelTestOrderByCustomerRequest
, _ocoOrderId :: !Text
, _ocoCallback :: !(Maybe Text)
}
deriving (Eq, Show, Data, Typeable, Generic)
-- | Creates a value of 'OrdersCanceltestOrderbycustomer' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'ocoXgafv'
--
-- * 'ocoMerchantId'
--
-- * 'ocoUploadProtocol'
--
-- * 'ocoAccessToken'
--
-- * 'ocoUploadType'
--
-- * 'ocoPayload'
--
-- * 'ocoOrderId'
--
-- * 'ocoCallback'
ordersCanceltestOrderbycustomer
:: Word64 -- ^ 'ocoMerchantId'
-> OrdersCancelTestOrderByCustomerRequest -- ^ 'ocoPayload'
-> Text -- ^ 'ocoOrderId'
-> OrdersCanceltestOrderbycustomer
ordersCanceltestOrderbycustomer pOcoMerchantId_ pOcoPayload_ pOcoOrderId_ =
OrdersCanceltestOrderbycustomer'
{ _ocoXgafv = Nothing
, _ocoMerchantId = _Coerce # pOcoMerchantId_
, _ocoUploadProtocol = Nothing
, _ocoAccessToken = Nothing
, _ocoUploadType = Nothing
, _ocoPayload = pOcoPayload_
, _ocoOrderId = pOcoOrderId_
, _ocoCallback = Nothing
}
-- | V1 error format.
ocoXgafv :: Lens' OrdersCanceltestOrderbycustomer (Maybe Xgafv)
ocoXgafv = lens _ocoXgafv (\ s a -> s{_ocoXgafv = a})
-- | The ID of the account that manages the order. This cannot be a
-- multi-client account.
ocoMerchantId :: Lens' OrdersCanceltestOrderbycustomer Word64
ocoMerchantId
= lens _ocoMerchantId
(\ s a -> s{_ocoMerchantId = a})
. _Coerce
-- | Upload protocol for media (e.g. \"raw\", \"multipart\").
ocoUploadProtocol :: Lens' OrdersCanceltestOrderbycustomer (Maybe Text)
ocoUploadProtocol
= lens _ocoUploadProtocol
(\ s a -> s{_ocoUploadProtocol = a})
-- | OAuth access token.
ocoAccessToken :: Lens' OrdersCanceltestOrderbycustomer (Maybe Text)
ocoAccessToken
= lens _ocoAccessToken
(\ s a -> s{_ocoAccessToken = a})
-- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").
ocoUploadType :: Lens' OrdersCanceltestOrderbycustomer (Maybe Text)
ocoUploadType
= lens _ocoUploadType
(\ s a -> s{_ocoUploadType = a})
-- | Multipart request metadata.
ocoPayload :: Lens' OrdersCanceltestOrderbycustomer OrdersCancelTestOrderByCustomerRequest
ocoPayload
= lens _ocoPayload (\ s a -> s{_ocoPayload = a})
-- | The ID of the test order to cancel.
ocoOrderId :: Lens' OrdersCanceltestOrderbycustomer Text
ocoOrderId
= lens _ocoOrderId (\ s a -> s{_ocoOrderId = a})
-- | JSONP
ocoCallback :: Lens' OrdersCanceltestOrderbycustomer (Maybe Text)
ocoCallback
= lens _ocoCallback (\ s a -> s{_ocoCallback = a})
instance GoogleRequest
OrdersCanceltestOrderbycustomer
where
type Rs OrdersCanceltestOrderbycustomer =
OrdersCancelTestOrderByCustomerResponse
type Scopes OrdersCanceltestOrderbycustomer =
'["https://www.googleapis.com/auth/content"]
requestClient OrdersCanceltestOrderbycustomer'{..}
= go _ocoMerchantId _ocoOrderId _ocoXgafv
_ocoUploadProtocol
_ocoAccessToken
_ocoUploadType
_ocoCallback
(Just AltJSON)
_ocoPayload
shoppingContentService
where go
= buildClient
(Proxy ::
Proxy OrdersCanceltestOrderbycustomerResource)
mempty
| brendanhay/gogol | gogol-shopping-content/gen/Network/Google/Resource/Content/Orders/CanceltestOrderbycustomer.hs | mpl-2.0 | 6,340 | 0 | 20 | 1,539 | 882 | 511 | 371 | 135 | 1 |
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}
-- Derived from AWS service descriptions, licensed under Apache 2.0.
-- |
-- Module : Network.AWS.EFS.DeleteMountTarget
-- Copyright : (c) 2013-2015 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes the specified mount target.
--
-- This operation forcibly breaks any mounts of the file system via the
-- mount target being deleted, which might disrupt instances or
-- applications using those mounts. To avoid applications getting cut off
-- abruptly, you might consider unmounting any mounts of the mount target,
-- if feasible. The operation also deletes the associated network
-- interface. Uncommitted writes may be lost, but breaking a mount target
-- using this operation does not corrupt the file system itself. The file
-- system you created remains. You can mount an EC2 instance in your VPC
-- using another mount target.
--
-- This operation requires permission for the following action on the file
-- system:
--
-- - 'elasticfilesystem:DeleteMountTarget'
--
-- The 'DeleteMountTarget' call returns while the mount target state is
-- still \"deleting\". You can check the mount target deletion by calling
-- the DescribeMountTargets API, which returns a list of mount target
-- descriptions for the given file system.
--
-- The operation also requires permission for the following Amazon EC2
-- action on the mount target\'s network interface:
--
-- - 'ec2:DeleteNetworkInterface'
--
-- /See:/ <http://docs.aws.amazon.com/directoryservice/latest/devguide/API_DeleteMountTarget.html AWS API Reference> for DeleteMountTarget.
module Network.AWS.EFS.DeleteMountTarget
(
-- * Creating a Request
deleteMountTarget
, DeleteMountTarget
-- * Request Lenses
, dMountTargetId
-- * Destructuring the Response
, deleteMountTargetResponse
, DeleteMountTargetResponse
) where
import Network.AWS.EFS.Types
import Network.AWS.EFS.Types.Product
import Network.AWS.Prelude
import Network.AWS.Request
import Network.AWS.Response
-- | /See:/ 'deleteMountTarget' smart constructor.
newtype DeleteMountTarget = DeleteMountTarget'
{ _dMountTargetId :: Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
-- | Creates a value of 'DeleteMountTarget' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'dMountTargetId'
deleteMountTarget
:: Text -- ^ 'dMountTargetId'
-> DeleteMountTarget
deleteMountTarget pMountTargetId_ =
DeleteMountTarget'
{ _dMountTargetId = pMountTargetId_
}
-- | String. The ID of the mount target to delete.
dMountTargetId :: Lens' DeleteMountTarget Text
dMountTargetId = lens _dMountTargetId (\ s a -> s{_dMountTargetId = a});
instance AWSRequest DeleteMountTarget where
type Rs DeleteMountTarget = DeleteMountTargetResponse
request = delete eFS
response = receiveNull DeleteMountTargetResponse'
instance ToHeaders DeleteMountTarget where
toHeaders = const mempty
instance ToPath DeleteMountTarget where
toPath DeleteMountTarget'{..}
= mconcat
["/2015-02-01/mount-targets/", toBS _dMountTargetId]
instance ToQuery DeleteMountTarget where
toQuery = const mempty
-- | /See:/ 'deleteMountTargetResponse' smart constructor.
data DeleteMountTargetResponse =
DeleteMountTargetResponse'
deriving (Eq,Read,Show,Data,Typeable,Generic)
-- | Creates a value of 'DeleteMountTargetResponse' with the minimum fields required to make a request.
--
deleteMountTargetResponse
:: DeleteMountTargetResponse
deleteMountTargetResponse = DeleteMountTargetResponse'
| olorin/amazonka | amazonka-efs/gen/Network/AWS/EFS/DeleteMountTarget.hs | mpl-2.0 | 4,140 | 0 | 9 | 746 | 364 | 232 | 132 | 49 | 1 |
module Main (Test()) where
| lspitzner/brittany | data/Test139.hs | agpl-3.0 | 27 | 0 | 5 | 4 | 12 | 8 | 4 | 3 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.