-- GENERATED by C->Haskell Compiler, version 0.28.8 Switcheroo, 25 November 2017 (Haskell)
-- Edit the ORIGNAL .chs file instead!


{-# LINE 1 "./QuantLib/Instrument.chs" #-}
module QuantLib.Instrument
  (
    -- * Types
    -- ** Instrument hierarchy
    GenInstrument
  , Instrument

    -- ** Additional results
  , AdditionalResultVal(..)

    -- ** Exercises and callability
  , Exercise(..)
  , ExerciseType(..)
  , Callability(..)
  , CallabilityType(..)

    -- ** Conventions
  , PositionType(..)
  , SettlementType(..)
  , SettlementMethod(..)
  , OptionType(..)
  , BarrierType(..)
  , DoubleBarrierType(..)
  , PartialBarrierRange(..)
  , AverageType(..)
  , Seniority(..)
  , PricingModel(..)
  , PerpetualFuturesPayoffType(..)
  , PerpetualFuturesFundingType(..)

    -- * Constructors
  , asInstrument
  , perpetualFutures
  , composite

    -- * Mutators
  , setPricingEngine

    -- * Inspectors
  , npv
  , errorEstimate
  , isExpired
  , valuationDate
  , additionalResults
  ) where
import qualified Foreign.C.Types as C2HSImp
import qualified Foreign.ForeignPtr as C2HSImp
import qualified Foreign.Marshal.Utils as C2HSImp
import qualified Foreign.Ptr as C2HSImp


import QuantLib.Internal
import QuantLib.Internal.Type hiding(ptr)
import QuantLib.Internal.Common








{-# LINE 56 "./QuantLib/Instrument.chs" #-}


{-# LINE 57 "./QuantLib/Instrument.chs" #-}


{-# LINE 58 "./QuantLib/Instrument.chs" #-}


{-# LINE 59 "./QuantLib/Instrument.chs" #-}


{-# LINE 60 "./QuantLib/Instrument.chs" #-}


data SettlementType = Physical
                    | Cash
  deriving (Enum,Show,Eq,Read)

{-# LINE 62 "./QuantLib/Instrument.chs" #-}

data SettlementMethod = PhysicalOTC
                      | PhysicalCleared
                      | CollateralizedCashPrice
                      | ParYieldCurve
  deriving (Int -> SettlementMethod
SettlementMethod -> Int
SettlementMethod -> [SettlementMethod]
SettlementMethod -> SettlementMethod
SettlementMethod -> SettlementMethod -> [SettlementMethod]
SettlementMethod
-> SettlementMethod -> SettlementMethod -> [SettlementMethod]
(SettlementMethod -> SettlementMethod)
-> (SettlementMethod -> SettlementMethod)
-> (Int -> SettlementMethod)
-> (SettlementMethod -> Int)
-> (SettlementMethod -> [SettlementMethod])
-> (SettlementMethod -> SettlementMethod -> [SettlementMethod])
-> (SettlementMethod -> SettlementMethod -> [SettlementMethod])
-> (SettlementMethod
    -> SettlementMethod -> SettlementMethod -> [SettlementMethod])
-> Enum SettlementMethod
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SettlementMethod -> SettlementMethod
succ :: SettlementMethod -> SettlementMethod
$cpred :: SettlementMethod -> SettlementMethod
pred :: SettlementMethod -> SettlementMethod
$ctoEnum :: Int -> SettlementMethod
toEnum :: Int -> SettlementMethod
$cfromEnum :: SettlementMethod -> Int
fromEnum :: SettlementMethod -> Int
$cenumFrom :: SettlementMethod -> [SettlementMethod]
enumFrom :: SettlementMethod -> [SettlementMethod]
$cenumFromThen :: SettlementMethod -> SettlementMethod -> [SettlementMethod]
enumFromThen :: SettlementMethod -> SettlementMethod -> [SettlementMethod]
$cenumFromTo :: SettlementMethod -> SettlementMethod -> [SettlementMethod]
enumFromTo :: SettlementMethod -> SettlementMethod -> [SettlementMethod]
$cenumFromThenTo :: SettlementMethod
-> SettlementMethod -> SettlementMethod -> [SettlementMethod]
enumFromThenTo :: SettlementMethod
-> SettlementMethod -> SettlementMethod -> [SettlementMethod]
Enum,Int -> SettlementMethod -> ShowS
[SettlementMethod] -> ShowS
SettlementMethod -> String
(Int -> SettlementMethod -> ShowS)
-> (SettlementMethod -> String)
-> ([SettlementMethod] -> ShowS)
-> Show SettlementMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SettlementMethod -> ShowS
showsPrec :: Int -> SettlementMethod -> ShowS
$cshow :: SettlementMethod -> String
show :: SettlementMethod -> String
$cshowList :: [SettlementMethod] -> ShowS
showList :: [SettlementMethod] -> ShowS
Show,SettlementMethod -> SettlementMethod -> Bool
(SettlementMethod -> SettlementMethod -> Bool)
-> (SettlementMethod -> SettlementMethod -> Bool)
-> Eq SettlementMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SettlementMethod -> SettlementMethod -> Bool
== :: SettlementMethod -> SettlementMethod -> Bool
$c/= :: SettlementMethod -> SettlementMethod -> Bool
/= :: SettlementMethod -> SettlementMethod -> Bool
Eq,ReadPrec [SettlementMethod]
ReadPrec SettlementMethod
Int -> ReadS SettlementMethod
ReadS [SettlementMethod]
(Int -> ReadS SettlementMethod)
-> ReadS [SettlementMethod]
-> ReadPrec SettlementMethod
-> ReadPrec [SettlementMethod]
-> Read SettlementMethod
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SettlementMethod
readsPrec :: Int -> ReadS SettlementMethod
$creadList :: ReadS [SettlementMethod]
readList :: ReadS [SettlementMethod]
$creadPrec :: ReadPrec SettlementMethod
readPrec :: ReadPrec SettlementMethod
$creadListPrec :: ReadPrec [SettlementMethod]
readListPrec :: ReadPrec [SettlementMethod]
Read)

{-# LINE 63 "./QuantLib/Instrument.chs" #-}

data BarrierType = DownIn
                 | UpIn
                 | DownOut
                 | UpOut
  deriving (Enum,Show,Eq,Read)

{-# LINE 64 "./QuantLib/Instrument.chs" #-}

data DoubleBarrierType = KnockIn
                       | KnockOut
                       | KIKO
                       | KOKI
  deriving (Enum,Show,Eq,Read)

{-# LINE 65 "./QuantLib/Instrument.chs" #-}

data PartialBarrierRange = Start
                         | EndB1
                         | EndB2
  deriving (Show,Eq,Read)
instance Enum PartialBarrierRange where
  succ Start = EndB1
  succ EndB1 = EndB2
  succ EndB2 = error "PartialBarrierRange.succ: EndB2 has no successor"

  pred EndB1 = Start
  pred EndB2 = EndB1
  pred Start = error "PartialBarrierRange.pred: Start has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from EndB2

  fromEnum Start = 0
  fromEnum EndB1 = 2
  fromEnum EndB2 = 3

  toEnum 0 = Start
  toEnum 2 = EndB1
  toEnum 3 = EndB2
  toEnum unmatched = error ("PartialBarrierRange.toEnum: Cannot match " ++ show unmatched)

{-# LINE 66 "./QuantLib/Instrument.chs" #-}

data AverageType = Arithmetic
                 | Geometric
  deriving (Enum,Show,Eq,Read)

{-# LINE 67 "./QuantLib/Instrument.chs" #-}

data Seniority = SecDom
               | SeniorSec
               | SnrFor
               | SeniorUnSec
               | SubLT2
               | SubLoweTier2
               | JrSubT2
               | SubUpperTier2
               | PrefT1
               | SubTier1
               | NoSeniority
  deriving (Show,Eq,Read)
instance Enum Seniority where
  succ SecDom = SnrFor
  succ SeniorSec = SnrFor
  succ SnrFor = SubLT2
  succ SeniorUnSec = SubLT2
  succ SubLT2 = JrSubT2
  succ SubLoweTier2 = JrSubT2
  succ JrSubT2 = PrefT1
  succ SubUpperTier2 = PrefT1
  succ PrefT1 = NoSeniority
  succ SubTier1 = NoSeniority
  pred :: RestructuringType -> RestructuringType
succ NoSeniority = error "Seniority.succ: NoSeniority has no successor"

  pred SnrFor = SecDom
  pred SeniorUnSec = SecDom
  pred SubLT2 = SnrFor
  pred SubLoweTier2 = SnrFor
  pred JrSubT2 = SubLT2
  pred SubUpperTier2 = SubLT2
  pred PrefT1 = JrSubT2
  pred SubTier1 = JrSubT2
  pred NoSeniority = PrefT1
  pred SecDom = error "Seniority.pred: SecDom has no predecessor"
  pred SeniorSec = error "Seniority.pred: SeniorSec has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from NoSeniority

  fromEnum SecDom = 0
  fromEnum SeniorSec = 0
  fromEnum SnrFor = 1
  fromEnum SeniorUnSec = 1
  fromEnum SubLT2 = 2
  fromEnum SubLoweTier2 = 2
  fromEnum JrSubT2 = 3
  fromEnum SubUpperTier2 = 3
  fromEnum PrefT1 = 4
  fromEnum SubTier1 = 4
  fromEnum NoSeniority = 5

  toEnum 0 = SecDom
  toEnum 1 = SnrFor
  toEnum 2 = SubLT2
  toEnum :: Int -> AtomicDefaultType
toEnum Int
3 = JrSubT2
  toEnum Int
4 = PrefT1
  toEnum Int
5 = NoSeniority
  toEnum unmatched = error ("Seniority.toEnum: Cannot match " ++ show unmatched)

{-# LINE 68 "./QuantLib/Instrument.chs" #-}

data PricingModel = Midpoint
                  | ISDA
  deriving (Enum,Show,Eq,Read)

{-# LINE 69 "./QuantLib/Instrument.chs" #-}

data RestructuringType = NoRestructuring
                       | XR
                       | ModifiedRestructuring
                       | MR
                       | ModifiedModifiedRestructuring
                       | MM
                       | FullRestructuring
                       | CR
                       | AnyRestructuring
  deriving (Show,Eq,Read)
instance Enum RestructuringType where
  succ NoRestructuring = ModifiedRestructuring
  succ XR = ModifiedRestructuring
  succ ModifiedRestructuring = ModifiedModifiedRestructuring
  succ MR = ModifiedModifiedRestructuring
  succ ModifiedModifiedRestructuring = FullRestructuring
  succ MM = FullRestructuring
  succ FullRestructuring = AnyRestructuring
  succ CR = AnyRestructuring
  succ AnyRestructuring = error "RestructuringType.succ: AnyRestructuring has no successor"

  pred ModifiedRestructuring = NoRestructuring
  pred MR = NoRestructuring
  pred ModifiedModifiedRestructuring = ModifiedRestructuring
  pred MM = ModifiedRestructuring
  pred FullRestructuring = ModifiedModifiedRestructuring
  pred CR = ModifiedModifiedRestructuring
  pred AnyRestructuring = FullRestructuring
  pred NoRestructuring = error "RestructuringType.pred: NoRestructuring has no predecessor"
  pred XR = error "RestructuringType.pred: XR has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from AnyRestructuring

  fromEnum NoRestructuring = 0
  fromEnum XR = 0
  fromEnum ModifiedRestructuring = 1
  fromEnum MR = 1
  fromEnum ModifiedModifiedRestructuring = 2
  fromEnum MM = 2
  fromEnum FullRestructuring = 3
  fromEnum CR = 3
  fromEnum AnyRestructuring = 4

  toEnum 0 = NoRestructuring
  toEnum 1 = ModifiedRestructuring
  toEnum 2 = ModifiedModifiedRestructuring
  toEnum 3 = FullRestructuring
  toEnum 4 = AnyRestructuring
  toEnum unmatched = error ("RestructuringType.toEnum: Cannot match " ++ show unmatched)

{-# LINE 70 "./QuantLib/Instrument.chs" #-}

data AtomicDefaultType = Restructuring
                       | Bankruptcy
                       | FailureToPay
                       | RepudiationMoratorium
                       | Acceleration
                       | ObligationAcceleration
                       | Default
                       | ObligationDefault
                       | CrossDefault
                       | Downgrade
                       | MergerEvent
  deriving (Show,Eq,Read)
instance Enum AtomicDefaultType where
  succ Restructuring = Bankruptcy
  succ Bankruptcy = FailureToPay
  succ FailureToPay = RepudiationMoratorium
  succ RepudiationMoratorium = Acceleration
  succ Acceleration = Default
  succ ObligationAcceleration = Default
  succ Default = Downgrade
  succ ObligationDefault = Downgrade
  succ CrossDefault = Downgrade
  succ Downgrade = MergerEvent
  succ MergerEvent = error "AtomicDefaultType.succ: MergerEvent has no successor"

  pred Bankruptcy = Restructuring
  pred FailureToPay = Bankruptcy
  pred RepudiationMoratorium = FailureToPay
  pred Acceleration = RepudiationMoratorium
  pred ObligationAcceleration = RepudiationMoratorium
  pred Default = Acceleration
  pred ObligationDefault = Acceleration
  pred CrossDefault = Acceleration
  pred Downgrade = Default
  pred MergerEvent = Downgrade
  pred Restructuring = error "AtomicDefaultType.pred: Restructuring has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from MergerEvent

  fromEnum Restructuring = 0
  fromEnum Bankruptcy = 1
  fromEnum FailureToPay = 2
  fromEnum RepudiationMoratorium = 3
  fromEnum Acceleration = 4
  fromEnum ObligationAcceleration = 4
  fromEnum Default = 5
  fromEnum ObligationDefault = 5
  fromEnum CrossDefault = 5
  fromEnum Downgrade = 6
  fromEnum MergerEvent = 7

  toEnum 0 = Restructuring
  toEnum 1 = Bankruptcy
  toEnum 2 = FailureToPay
  toEnum 3 = RepudiationMoratorium
  toEnum 4 = Acceleration
  toEnum 5 = Default
  toEnum 6 = Downgrade
  toEnum 7 = MergerEvent
  toEnum unmatched = error ("AtomicDefaultType.toEnum: Cannot match " ++ show unmatched)

{-# LINE 71 "./QuantLib/Instrument.chs" #-}

data PerpetualFuturesPayoffType = PerpetualFuturesLinear
                                | PerpetualFuturesInverse
                                | PerpetualFuturesQuanto
  deriving (Show,Eq,Read)
instance Enum PerpetualFuturesPayoffType where
  succ PerpetualFuturesLinear = PerpetualFuturesInverse
  succ PerpetualFuturesInverse = PerpetualFuturesQuanto
  succ PerpetualFuturesQuanto = error "PerpetualFuturesPayoffType.succ: PerpetualFuturesQuanto has no successor"

  pred PerpetualFuturesInverse = PerpetualFuturesLinear
  pred PerpetualFuturesQuanto = PerpetualFuturesInverse
  pred PerpetualFuturesLinear = error "PerpetualFuturesPayoffType.pred: PerpetualFuturesLinear has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from PerpetualFuturesQuanto

  fromEnum PerpetualFuturesLinear = 0
  fromEnum PerpetualFuturesInverse = 1
  fromEnum PerpetualFuturesQuanto = 2

  toEnum 0 = PerpetualFuturesLinear
  toEnum 1 = PerpetualFuturesInverse
  toEnum 2 = PerpetualFuturesQuanto
  toEnum unmatched = error ("PerpetualFuturesPayoffType.toEnum: Cannot match " ++ show unmatched)

{-# LINE 72 "./QuantLib/Instrument.chs" #-}

data PerpetualFuturesFundingType = PerpetualFuturesFundingWithPreviousSpot
                                 | PerpetualFuturesFundingWithCurrentSpot
  deriving (Show,Eq,Read)
instance Enum PerpetualFuturesFundingType where
  succ PerpetualFuturesFundingWithPreviousSpot = PerpetualFuturesFundingWithCurrentSpot
  succ PerpetualFuturesFundingWithCurrentSpot = error "PerpetualFuturesFundingType.succ: PerpetualFuturesFundingWithCurrentSpot has no successor"

  pred PerpetualFuturesFundingWithCurrentSpot = PerpetualFuturesFundingWithPreviousSpot
  pred PerpetualFuturesFundingWithPreviousSpot = error "PerpetualFuturesFundingType.pred: PerpetualFuturesFundingWithPreviousSpot has no predecessor"

  enumFromTo from to = go from
    where
      end = fromEnum to
      go v = case compare (fromEnum v) end of
                 LT -> v : go (succ v)
                 EQ -> [v]
                 GT -> []

  enumFrom from = enumFromTo from PerpetualFuturesFundingWithCurrentSpot

  fromEnum PerpetualFuturesFundingWithPreviousSpot = 0
  fromEnum PerpetualFuturesFundingWithCurrentSpot = 1

  toEnum 0 = PerpetualFuturesFundingWithPreviousSpot
  toEnum 1 = PerpetualFuturesFundingWithCurrentSpot
  toEnum unmatched = error ("PerpetualFuturesFundingType.toEnum: Cannot match " ++ show unmatched)

{-# LINE 73 "./QuantLib/Instrument.chs" #-}


-- |Constructs a perpetual future. Linear contracts settle and margin in the
-- domestic currency of the underlying FOR/DOM pair; Inverse contracts do so
-- in the foreign currency; Quanto contracts use a separate quanto currency.
-- A zero-length funding frequency selects continuous funding; otherwise
-- funding is discrete at the supplied period.
perpetualFutures :: (PerpetualFuturesPayoffType) -- ^payoffType
 -> (PerpetualFuturesFundingType) -- ^fundingType
 -> ((Int,TimeUnit)) -- ^fundingFrequency
 -> (Calendar) -- ^fundingCalendar
 -> (DayCounter) -- ^fundingDayCounter
 -> IO ((Instrument))
perpetualFutures a1 a2 a3 a4 a5 =
  let {a1' = fromEnumC a1} in 
  let {a2' = fromEnumC a2} in 
  let {(a3'1, a3'2) = fromEnumQuantity a3} in 
  withCalendar a4 $ \a4' -> 
  withDayCounter a5 $ \a5' -> 
  preErrorCheck $ \a6' -> 
  perpetualFutures'_ a1' a2' a3'1  a3'2 a4' a5' a6' >>= \res ->
  peekInstrument res >>= \res' ->
  errorCheck  a6'>>
  return (res')

{-# LINE 85 "./QuantLib/Instrument.chs" #-}


-- |Returns the net present value of the given Instrument
npv :: (GenInstrument i) -> IO ((Double))
npv a1 =
  withInstrument a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  npv'_ a1' a2' >>= \res ->
  let {res' = realToFrac res} in
  errorCheck  a2'>>
  return (res')

{-# LINE 88 "./QuantLib/Instrument.chs" #-}


-- |returns the error estimate on the NPV when available.
errorEstimate :: (GenInstrument i) -> IO ((Double))
errorEstimate a1 =
  withInstrument a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  errorEstimate'_ a1' a2' >>= \res ->
  let {res' = realToFrac res} in
  errorCheck  a2'>>
  return (res')

{-# LINE 91 "./QuantLib/Instrument.chs" #-}


-- |returns whether the instrument might have value greater than zero.
isExpired :: (GenInstrument i) -> IO ((Bool))
isExpired a1 =
  withInstrument a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  isExpired'_ a1' a2' >>= \res ->
  let {res' = C2HSImp.toBool res} in
  errorCheck  a2'>>
  return (res')

{-# LINE 94 "./QuantLib/Instrument.chs" #-}


-- |returns the date the net present value refers to.
valuationDate :: (GenInstrument i) -> IO ((Day))
valuationDate a1 =
  withInstrument a1 $ \a1' -> 
  preErrorCheck $ \a2' -> 
  valuationDate'_ a1' a2' >>= \res ->
  let {res' = toDay res} in
  errorCheck  a2'>>
  return (res')

{-# LINE 97 "./QuantLib/Instrument.chs" #-}


-- |Returns QuantLib's `additionalResults()` map for the given Instrument, as an association list
-- keyed by the C++ result name. The map's values are populated by the pricing engine;
-- `additionalResults()` calls `calculate()` internally, so this is safe and idempotent after
-- pricing.
additionalResults :: (GenInstrument i) -> IO (([(String, AdditionalResultVal)]))
additionalResults a1 =
  withInstrument a1 $ \a1' -> 
  preArray $ \(a2'1, a2'2) -> 
  preErrorCheck $ \a3' -> 
  additionalResults'_ a1' a2'1  a2'2 a3' >>
  peekAdditionalResults  a2'1  a2'2>>= \a2'' -> 
  errorCheck  a3'>>
  return (a2'')

{-# LINE 103 "./QuantLib/Instrument.chs" #-}


-- |Builds a composite instrument whose NPV is the sum of the given instruments' NPVs, each scaled by its paired multiplier.
composite :: [(Instrument, Double)] -> IO Instrument
composite = (uncurry qlCompositeInstrument) . unzip

qlCompositeInstrument :: ([GenInstrument i]) -- ^instruments
 -> ([Double]) -- ^multipliers
 -> IO ((Instrument))
qlCompositeInstrument a1 a2 =
  withInstrumentArray a1 $ \(a1'1, a1'2) -> 
  withDoubleArray a2 $ \(a2'1, a2'2) -> 
  preErrorCheck $ \a3' -> 
  qlCompositeInstrument'_ a1'1  a1'2 a2'1  a2'2 a3' >>= \res ->
  peekInstrument res >>= \res' ->
  errorCheck  a3'>>
  return (res')

{-# LINE 111 "./QuantLib/Instrument.chs" #-}


-- |Sets the pricing engine used to compute the instrument's results.
setPricingEngine :: (GenInstrument i) -> (PricingEngine) -> IO ()
setPricingEngine a1 a2 =
  withInstrument a1 $ \a1' -> 
  withPricingEngine a2 $ \a2' -> 
  preErrorCheck $ \a3' -> 
  setPricingEngine'_ a1' a2' a3' >>
  errorCheck  a3'>>
  return ()

{-# LINE 114 "./QuantLib/Instrument.chs" #-}


-- vim: set ff=unix ts=8 sts=2 sw=2 et:

foreign import ccall safe "QuantLib/Instrument.chs.h qlPerpetualFutures"
  perpetualFutures'_ :: (C2HSImp.CInt -> (C2HSImp.CInt -> (C2HSImp.CInt -> (C2HSImp.CInt -> ((C2HSImp.Ptr (CCalendar)) -> ((C2HSImp.Ptr (CDayCounter)) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CInstrument'))))))))))

foreign import ccall safe "QuantLib/Instrument.chs.h qlInstrumentNPV"
  npv'_ :: ((C2HSImp.Ptr (CInstrument')) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO C2HSImp.CDouble)))

foreign import ccall safe "QuantLib/Instrument.chs.h qlInstrumentErrorEstimate"
  errorEstimate'_ :: ((C2HSImp.Ptr (CInstrument')) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO C2HSImp.CDouble)))

foreign import ccall safe "QuantLib/Instrument.chs.h qlInstrumentIsExpired"
  isExpired'_ :: ((C2HSImp.Ptr (CInstrument')) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO C2HSImp.CInt)))

foreign import ccall safe "QuantLib/Instrument.chs.h qlInstrumentValuationDate"
  valuationDate'_ :: ((C2HSImp.Ptr (CInstrument')) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO C2HSImp.CInt)))

foreign import ccall safe "QuantLib/Instrument.chs.h qlInstrumentAdditionalResults"
  additionalResults'_ :: ((C2HSImp.Ptr (CInstrument')) -> ((C2HSImp.Ptr C2HSImp.CUInt) -> ((C2HSImp.Ptr (RawResultPtr)) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO ())))))

foreign import ccall safe "QuantLib/Instrument.chs.h qlCompositeInstrument"
  qlCompositeInstrument'_ :: (C2HSImp.CUInt -> ((C2HSImp.Ptr (C2HSImp.Ptr (CInstrument'))) -> (C2HSImp.CUInt -> ((C2HSImp.Ptr C2HSImp.CDouble) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO (C2HSImp.Ptr (CInstrument'))))))))

foreign import ccall safe "QuantLib/Instrument.chs.h qlInstrumentSetPricingEngine"
  setPricingEngine'_ :: ((C2HSImp.Ptr (CInstrument')) -> ((C2HSImp.Ptr (CPricingEngine)) -> ((C2HSImp.Ptr (C2HSImp.Ptr C2HSImp.CChar)) -> (IO ()))))