-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Haskell Open Sound Control
--   
--   hosc implements a subset of the Open Sound Control
--   byte protocol, http://opensoundcontrol.org/.
--   
--   Sound.OSC.Core implements the actual protocol.
--   
--   Sound.OSC.Transport.FD implements a file descriptor
--   based transport layer for UDP and TCP.
--   
--   Sound.OSC.Transport.Monad implements a monadic interface to the
--   FD transport layer.
--   
--   Composite modules are at Sound.OSC and Sound.OSC.FD.
@package hosc
@version 0.15

-- | Waiting (for replies).
module Sound.OSC.Wait

-- | Real valued variant of timeout.
timeout_r :: Double -> IO a -> IO (Maybe a)

-- | Repeat action until predicate f is True when applied to
--   result.
untilPredicate :: Monad m => (a -> Bool) -> m a -> m a

-- | Repeat action until f does not give Nothing when applied
--   to result.
untilMaybe :: Monad m => (a -> Maybe b) -> m a -> m b

-- | Alegbraic data types for OSC datum and packets.
module Sound.OSC.Type

-- | NTP time in real-valued (fractional) form.
type Time = Double

-- | Constant indicating a bundle to be executed immediately.
immediately :: Time

-- | Type enumerating Datum categories.
type Datum_Type = Char

-- | Type for ASCII strings (strict Char8 ByteString).
type ASCII = ByteString

-- | Type-specialised pack.
ascii :: String -> ASCII

-- | Type-specialised unpack.
ascii_to_string :: ASCII -> String

-- | Four-byte midi message.
data MIDI
MIDI :: Word8 -> Word8 -> Word8 -> Word8 -> MIDI

-- | The basic elements of OSC messages.
data Datum
Int32 :: Int32 -> Datum
[d_int32] :: Datum -> Int32
Int64 :: Int64 -> Datum
[d_int64] :: Datum -> Int64
Float :: Float -> Datum
[d_float] :: Datum -> Float
Double :: Double -> Datum
[d_double] :: Datum -> Double
ASCII_String :: ASCII -> Datum
[d_ascii_string] :: Datum -> ASCII
Blob :: ByteString -> Datum
[d_blob] :: Datum -> ByteString
TimeStamp :: Time -> Datum
[d_timestamp] :: Datum -> Time
Midi :: MIDI -> Datum
[d_midi] :: Datum -> MIDI

-- | Single character identifier of an OSC datum.
datum_tag :: Datum -> Datum_Type

-- | Datum as Integral if Int32 or Int64.
--   
--   
--   let d = [Int32 5,Int64 5,Float 5.5,Double 5.5]
--   in map datum_integral d == [Just (5::Int),Just 5,Nothing,Nothing]
--   
datum_integral :: Integral i => Datum -> Maybe i

-- | Datum as Floating if Int32, Int64,
--   Float, Double or TimeStamp.
--   
--   
--   let d = [Int32 5,Int64 5,Float 5,Double 5,TimeStamp 5]
--   in Data.Maybe.mapMaybe datum_floating d == replicate 5 (5::Double)
--   
datum_floating :: Floating n => Datum -> Maybe n

-- | Class for translating to and from Datum. There are instances
--   for the direct Datum field types.
--   
--   
--   d_put (1::Int32) == Int32 1
--   d_put (1::Int64) == Int64 1
--   d_put (1::Float) == Float 1
--   d_put (1::Double) == Double 1
--   d_put (C.pack "str") == ASCII_String (C.pack "str")
--   d_put (B.pack [37,37]) == Blob (B.pack [37,37])
--   d_put (MIDI 0 0 0 0) == Midi (MIDI 0 0 0 0)
--   
--   
--   There are also instances for standard Haskell types.
--   
--   
--   d_put (1::Int) == Int64 1
--   d_put (1::Integer) == Int64 1
--   
class Datem a
d_put :: Datem a => a -> Datum
d_get :: Datem a => Datum -> Maybe a

-- | Type generalised Int32.
--   
--   
--   int32 (1::Int32) == int32 (1::Integer)
--   d_int32 (int32 (maxBound::Int32)) == maxBound
--   int32 (((2::Int) ^ (64::Int))::Int) == Int32 0
--   
int32 :: Integral n => n -> Datum

-- | Type generalised Int64.
--   
--   
--   int64 (1::Int32) == int64 (1::Integer)
--   d_int64 (int64 (maxBound::Int64)) == maxBound
--   
int64 :: Integral n => n -> Datum

-- | Type generalised Float.
--   
--   
--   float (1::Int) == float (1::Double)
--   floatRange (undefined::Float) == (-125,128)
--   isInfinite (d_float (float (encodeFloat 1 256 :: Double))) == True
--   
float :: Real n => n -> Datum

-- | Type generalised Double.
--   
--   
--   double (1::Int) == double (1::Double)
--   double (encodeFloat 1 256 :: Double) == Double 1.157920892373162e77
--   
double :: Real n => n -> Datum

-- | ASCII_String of pack.
--   
--   
--   string "string" == ASCII_String (C.pack "string")
--   
string :: String -> Datum

-- | Four-tuple variant of Midi . MIDI.
--   
--   
--   midi (0,0,0,0) == Midi (MIDI 0 0 0 0)
--   
midi :: (Word8, Word8, Word8, Word8) -> Datum

-- | OSC address pattern. This is strictly an ASCII value, but it is very
--   common to pattern match on addresses and matching on ByteString
--   requires OverloadedStrings.
type Address_Pattern = String

-- | An OSC message.
data Message
Message :: Address_Pattern -> [Datum] -> Message
[messageAddress] :: Message -> Address_Pattern
[messageDatum] :: Message -> [Datum]

-- | Message constructor. It is an error if the
--   Address_Pattern doesn't conform to the OSC specification.
message :: Address_Pattern -> [Datum] -> Message

-- | Message argument types are given by a descriptor.
--   
--   
--   C.unpack (descriptor [Int32 1,Float 1,string "1"]) == ",ifs"
--   
descriptor :: [Datum] -> ASCII

-- | Descriptor tags are comma prefixed.
descriptor_tags :: ASCII -> ASCII

-- | An OSC bundle.
data Bundle
Bundle :: Time -> [Message] -> Bundle
[bundleTime] :: Bundle -> Time
[bundleMessages] :: Bundle -> [Message]

-- | OSC Bundles can be ordered (time ascending).

-- | Bundle constructor. It is an error if the Message
--   list is empty.
bundle :: Time -> [Message] -> Bundle

-- | An OSC Packet is either a Message or a Bundle.
data Packet
Packet_Message :: Message -> Packet
[packetMessage] :: Packet -> Message
Packet_Bundle :: Bundle -> Packet
[packetBundle] :: Packet -> Bundle

-- | Packet_Bundle . bundle.
p_bundle :: Time -> [Message] -> Packet

-- | Packet_Message . message.
p_message :: Address_Pattern -> [Datum] -> Packet

-- | The Time of Packet, if the Packet is a
--   Message this is immediately.
packetTime :: Packet -> Time

-- | Retrieve the set of Messages from a Packet.
packetMessages :: Packet -> [Message]

-- | If Packet is a Message add immediately timestamp,
--   else id.
packet_to_bundle :: Packet -> Bundle

-- | If Packet is a Message or a Bundle with an
--   immediate time tag and with one element, return the
--   Message, else Nothing.
packet_to_message :: Packet -> Maybe Message

-- | Is Packet immediate, ie. a Bundle with timestamp
--   immediately, or a plain Message.
packet_is_immediate :: Packet -> Bool

-- | Variant of either for Packet.
at_packet :: (Message -> a) -> (Bundle -> a) -> Packet -> a

-- | Does Message have the specified Address_Pattern.
message_has_address :: Address_Pattern -> Message -> Bool

-- | Do any of the Messages at Bundle have the specified
--   Address_Pattern.
bundle_has_address :: Address_Pattern -> Bundle -> Bool

-- | Does Packet have the specified Address_Pattern, ie.
--   message_has_address or bundle_has_address.
packet_has_address :: Address_Pattern -> Packet -> Bool

-- | Perhaps a precision value for floating point numbers.
type FP_Precision = Maybe Int

-- | Variant of showFFloat that deletes trailing zeros.
--   
--   
--   map (floatPP (Just 4)) [1,pi] == ["1.0","3.1416"]
--   
floatPP :: RealFloat n => Maybe Int -> n -> String

-- | Pretty printer for Time.
--   
--   
--   timePP (Just 4) (1/3) == "0.3333"
--   
timePP :: FP_Precision -> Time -> String

-- | Pretty printer for vectors.
--   
--   
--   vecPP [1::Int,2,3] == "<1,2,3>"
--   
vecPP :: Show a => [a] -> String

-- | Pretty printer for Datum.
--   
--   
--   let d = [Int32 1,Float 1.2,string "str",midi (0,0x90,0x40,0x60)]
--   in map datumPP d ==  ["1","1.2","\"str\"","<0,144,64,96>"]
--   
datumPP :: FP_Precision -> Datum -> String

-- | Pretty printer for Message.
messagePP :: FP_Precision -> Message -> String

-- | Pretty printer for Bundle.
bundlePP :: FP_Precision -> Bundle -> String

-- | Pretty printer for Packet.
packetPP :: FP_Precision -> Packet -> String

-- | Variant of read.
readMaybe :: (Read a) => String -> Maybe a

-- | Given Datum_Type attempt to parse Datum at
--   String.
--   
--   
--   parse_datum 'i' "42" == Just (Int32 42)
--   parse_datum 'h' "42" == Just (Int64 42)
--   parse_datum 'f' "3.14159" == Just (Float 3.14159)
--   parse_datum 'd' "3.14159" == Just (Double 3.14159)
--   parse_datum 's' "\"pi\"" == Just (string "pi")
--   parse_datum 'b' "[112,105]" == Just (Blob (B.pack [112,105]))
--   parse_datum 'm' "(0,144,60,90)" == Just (midi (0,144,60,90))
--   
parse_datum :: Datum_Type -> String -> Maybe Datum
instance GHC.Show.Show Sound.OSC.Type.Packet
instance GHC.Read.Read Sound.OSC.Type.Packet
instance GHC.Classes.Eq Sound.OSC.Type.Packet
instance GHC.Show.Show Sound.OSC.Type.Bundle
instance GHC.Read.Read Sound.OSC.Type.Bundle
instance GHC.Classes.Eq Sound.OSC.Type.Bundle
instance GHC.Show.Show Sound.OSC.Type.Message
instance GHC.Read.Read Sound.OSC.Type.Message
instance GHC.Classes.Eq Sound.OSC.Type.Message
instance GHC.Show.Show Sound.OSC.Type.Datum
instance GHC.Read.Read Sound.OSC.Type.Datum
instance GHC.Classes.Eq Sound.OSC.Type.Datum
instance GHC.Read.Read Sound.OSC.Type.MIDI
instance GHC.Show.Show Sound.OSC.Type.MIDI
instance GHC.Classes.Eq Sound.OSC.Type.MIDI
instance Sound.OSC.Type.Datem GHC.Int.Int32
instance Sound.OSC.Type.Datem GHC.Int.Int64
instance Sound.OSC.Type.Datem GHC.Types.Int
instance Sound.OSC.Type.Datem GHC.Integer.Type.Integer
instance Sound.OSC.Type.Datem GHC.Types.Float
instance Sound.OSC.Type.Datem GHC.Types.Double
instance Sound.OSC.Type.Datem Data.ByteString.Internal.ByteString
instance Sound.OSC.Type.Datem Data.ByteString.Lazy.Internal.ByteString
instance Sound.OSC.Type.Datem Sound.OSC.Type.MIDI
instance GHC.Classes.Ord Sound.OSC.Type.Bundle

-- | OSC related timing functions. OSC timestamps are NTP values,
--   http://ntp.org/.
module Sound.OSC.Time

-- | Type for integer (binary) representation of NTP time.
type NTPi = Word64

-- | Unix/Posix epoch time in real-valued (fractional) form.
type UT = Double

-- | Convert a real-valued NTP timestamp to an NTPi timestamp.
ntpr_to_ntpi :: RealFrac n => n -> NTPi

-- | Convert an NTPi timestamp to a real-valued NTP timestamp.
ntpi_to_ntpr :: Fractional n => NTPi -> n

-- | Difference (in seconds) between NTP and UT epochs.
--   
--   
--   ntp_ut_epoch_diff / (24 * 60 * 60) == 25567
--   
ntp_ut_epoch_diff :: Num n => n

-- | Convert a UT timestamp to an NTPi timestamp.
ut_to_ntpi :: UT -> NTPi

-- | Convert Unix/Posix to NTP.
ut_to_ntpr :: Num n => n -> n

-- | Convert NTP to Unix/Posix.
ntpr_to_ut :: Num n => n -> n

-- | Convert NTPi to Unix/Posix.
ntpi_to_ut :: NTPi -> UT

-- | The time at 1970-01-01:00:00:00.
ut_epoch :: UTCTime

-- | Convert UTCTime to Unix/Posix.
utc_to_ut :: Fractional n => UTCTime -> n

-- | Read current real-valued NTP timestamp.
--   
--   
--   do {ct <- fmap utc_to_ut T.getCurrentTime
--      ;pt <- fmap realToFrac T.getPOSIXTime
--      ;print (pt - ct,pt - ct < 1e-5)}
--   
time :: MonadIO m => m Time

-- | The pauseThread limit (in seconds). Values larger than this
--   require a different thread delay mechanism, see sleepThread.
--   The value is the number of microseconds in maxBound::Int.
pauseThreadLimit :: Fractional n => n

-- | Pause current thread for the indicated duration (in seconds), see
--   pauseThreadLimit.
pauseThread :: (MonadIO m, Ord n, RealFrac n) => n -> m ()

-- | Type restricted pauseThread.
wait :: MonadIO m => Double -> m ()

-- | Pause current thread until the given Time, see
--   pauseThreadLimit.
pauseThreadUntil :: MonadIO m => Time -> m ()

-- | Sleep current thread for the indicated duration (in seconds). Divides
--   long sleeps into parts smaller than pauseThreadLimit.
sleepThread :: (RealFrac n, MonadIO m) => n -> m ()

-- | Sleep current thread until the given Time. Divides long sleeps
--   into parts smaller than pauseThreadLimit.
sleepThreadUntil :: MonadIO m => Time -> m ()

-- | Datum normalisation.
module Sound.OSC.Normalise

-- | Lift Int32 to Int64 and Float to Double.
--   
--   
--   map normalise_datum [Int32 1,Float 1] == [Int64 1,Double 1]
--   
normalise_datum :: Datum -> Datum

-- | A normalised Message has only Int64 and Double
--   numerical values.
--   
--   
--   let m = message "/m" [Int32 0,Float 0]
--   in normalise_message m == message "/m" [Int64 0,Double 0]
--   
normalise_message :: Message -> Message

-- | A normalised Bundle has only Int64 and Double
--   numerical values.
normalise_bundle :: Bundle -> Bundle

-- | Map a normalising function over datum at an OSC Message.
message_coerce :: (Datum -> Datum) -> Message -> Message

-- | Map a normalising function over datum at an OSC Bundle.
bundle_coerce :: (Datum -> Datum) -> Bundle -> Bundle

-- | Coerce Int32, Int64 and Float to Double.
--   
--   
--   map datum_promote [Int32 5,Float 5] == [Double 5,Double 5]
--   
datum_promote :: Datum -> Datum

-- | Datum as Int64 if Int32, Int64,
--   Float or Double.
--   
--   
--   let d = [Int32 5,Int64 5,Float 5.5,Double 5.5,string "5"]
--   in map datum_floor d == [Int64 5,Int64 5,Int64 5,Int64 5,string "5"]
--   
datum_floor :: Datum -> Datum

-- | Datum related functions.
module Sound.OSC.Datum

-- | Type specialised d_get.
--   
--   
--   map datum_int32 [Int32 1,Float 1] == [Just 1,Nothing]
--   
datum_int32 :: Datum -> Maybe Int32

-- | Type specialised d_get.
datum_int64 :: Datum -> Maybe Int64

-- | Type specialised d_get.
datum_float :: Datum -> Maybe Float

-- | Type specialised d_get.
datum_double :: Datum -> Maybe Double

-- | Type specialised d_get.
--   
--   
--   datum_ascii (d_put (C.pack "string")) == Just (C.pack "string")
--   
datum_ascii :: Datum -> Maybe ASCII

-- | unpack of d_get.
--   
--   
--   datum_string (d_put (C.pack "string")) == Just "string"
--   map datum_string [string "string",Int32 5] == [Just "string",Nothing]
--   
datum_string :: Datum -> Maybe String

-- | Type specialised d_get.
datum_blob :: Datum -> Maybe ByteString

-- | Maybe variant of d_timestamp.
datum_timestamp :: Datum -> Maybe Time

-- | Type specialised d_get.
datum_midi :: Datum -> Maybe MIDI

-- | Datum as sequence of Word8 if ASCII_String,
--   Blob or Midi.
--   
--   
--   let d = [string "5",Blob (B.pack [53]),midi (0x00,0x90,0x40,0x60)]
--   in Data.Maybe.mapMaybe datum_sequence d == [[53],[53],[0,144,64,96]]
--   
datum_sequence :: Datum -> Maybe [Word8]

-- | Bit-level type casts and byte layout string typecasts.
module Sound.OSC.Coding.Cast

-- | The IEEE byte representation of a float.
f32_w32 :: Float -> Word32

-- | Inverse of f32_w32.
w32_f32 :: Word32 -> Float

-- | The IEEE byte representation of a double.
f64_w64 :: Double -> Word64

-- | Inverse of f64_i64.
w64_f64 :: Word64 -> Double

-- | Transform a haskell string into a C string (a null suffixed byte
--   string).
str_cstr :: String -> [Word8]

-- | Inverse of str_cstr.
cstr_str :: [Word8] -> String

-- | Transform a haskell string to a pascal string (a length prefixed byte
--   string).
str_pstr :: String -> [Word8]

-- | Inverse of str_pstr.
pstr_str :: [Word8] -> String

-- | Byte-level coding utility functions.
module Sound.OSC.Coding.Byte

-- | Encode a signed 8-bit integer.
encode_i8 :: Int -> ByteString

-- | Encode an un-signed 8-bit integer.
encode_u8 :: Int -> ByteString

-- | Encode a signed 16-bit integer.
encode_i16 :: Int -> ByteString

-- | Encode a signed 32-bit integer.
encode_i32 :: Int -> ByteString

-- | Encode an unsigned 16-bit integer.
encode_u32 :: Int -> ByteString

-- | Encode a signed 64-bit integer.
encode_i64 :: Int64 -> ByteString

-- | Encode an unsigned 64-bit integer.
encode_u64 :: Word64 -> ByteString

-- | Encode a 32-bit IEEE floating point number.
encode_f32 :: Float -> ByteString

-- | Encode a 64-bit IEEE floating point number.
encode_f64 :: Double -> ByteString

-- | Encode an ASCII string.
encode_str :: ASCII -> ByteString

-- | Decode an un-signed 8-bit integer.
decode_u8 :: ByteString -> Int

-- | Decode a signed 8-bit integer.
decode_i8 :: ByteString -> Int

-- | Decode a signed 16-bit integer.
decode_i16 :: ByteString -> Int

-- | Decode a signed 32-bit integer.
decode_i32 :: ByteString -> Int

-- | Decode an unsigned 32-bit integer.
decode_u32 :: ByteString -> Int

-- | Decode a signed 64-bit integer.
decode_i64 :: ByteString -> Int64

-- | Decode an unsigned 64-bit integer.
decode_u64 :: ByteString -> Word64

-- | Decode a 32-bit IEEE floating point number.
decode_f32 :: ByteString -> Float

-- | Decode a 64-bit IEEE floating point number.
decode_f64 :: ByteString -> Double

-- | Decode an ASCII string.
decode_str :: ByteString -> ASCII

-- | Bundle header as a (strict) ByteString.
bundleHeader_strict :: ByteString

-- | Bundle header as a lazy ByteString.
bundleHeader :: ByteString

-- | The number of bytes required to align an OSC value to the next 4-byte
--   boundary.
--   
--   
--   map align [0::Int .. 7] == [0,3,2,1,0,3,2,1]
--   
align :: (Num i, Bits i) => i -> i

-- | Base-level decode function for OSC packets (slow). For ordinary use
--   see Binary.
module Sound.OSC.Coding.Decode.Base

-- | Decode an OSC Message.
decodeMessage :: ByteString -> Message

-- | Decode an OSC Bundle.
decodeBundle :: ByteString -> Bundle

-- | Decode an OSC Packet.
--   
--   
--   let b = B.pack [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
--   in decodePacket b == Message "/g_free" [Int 0]
--   
decodePacket :: ByteString -> Packet

-- | Optimised decode function for OSC packets.
module Sound.OSC.Coding.Decode.Binary

-- | Get an OSC Packet.
getPacket :: Get Packet

-- | Decode an OSC packet from a lazy ByteString.
--   
--   
--   let b = B.pack [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
--   in decodeOSC b == Message "/g_free" [Int 0]
--   
decodePacket :: ByteString -> Packet

-- | Decode an OSC packet from a strict ByteString.
decodePacket_strict :: ByteString -> Packet

-- | Base-level encode function for OSC packets (slow). For ordinary use
--   see Builder.
module Sound.OSC.Coding.Encode.Base

-- | Encode an OSC Message.
encodeMessage :: Message -> ByteString

-- | Encode an OSC Bundle.
encodeBundle :: Bundle -> ByteString

-- | Encode an OSC Packet.
encodePacket :: Packet -> ByteString

-- | Optimised encode function for OSC packets.
module Sound.OSC.Coding.Encode.Builder

-- | Builder monoid for an OSC Packet.
build_packet :: Packet -> Builder

-- | Encode an OSC Message.
encodeMessage :: Message -> ByteString

-- | Encode an OSC Bundle.
encodeBundle :: Bundle -> ByteString

-- | Encode an OSC Packet to a lazy ByteString.
--   
--   
--   let b = L.pack [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
--   in encodeOSC (Message "/g_free" [Int 0]) == b
--   
encodePacket :: Packet -> ByteString

-- | Encode an Packet packet to a strict ByteString.
encodePacket_strict :: Packet -> ByteString

-- | A type-class to provide coding operations to different data types
--   using the same function names.
module Sound.OSC.Coding

-- | Converting from and to binary packet representations.
class Coding a
encodePacket :: Coding a => Packet -> a
decodePacket :: Coding a => a -> Packet

-- | An encodePacket and decodePacket pair over
--   ByteString.
type Coder = (Packet -> ByteString, ByteString -> Packet)

-- | encodePacket . Packet_Message.
encodeMessage :: Coding c => Message -> c

-- | encodePacket . Packet_Bundle.
encodeBundle :: Coding c => Bundle -> c

-- | packet_to_message . decodePacket.
decodeMessage :: Coding c => c -> Maybe Message

-- | packet_to_bundle . decodePacket.
decodeBundle :: Coding c => c -> Bundle
instance Sound.OSC.Coding.Coding Data.ByteString.Internal.ByteString
instance Sound.OSC.Coding.Coding Data.ByteString.Lazy.Internal.ByteString
instance Sound.OSC.Coding.Coding GHC.Base.String

-- | Typeclass for encoding and decoding OSC packets.
module Sound.OSC.Class

-- | A type-class for values that can be translated to and from OSC
--   Packets.
class OSC o
toPacket :: OSC o => o -> Packet
fromPacket :: OSC o => Packet -> Maybe o

-- | encodePacket . toPacket.
encodeOSC :: (Coding c, OSC o) => o -> c

-- | fromPacket . decodePacket.
decodeOSC :: (Coding c, OSC o) => c -> Maybe o
instance Sound.OSC.Class.OSC Sound.OSC.Type.Message
instance Sound.OSC.Class.OSC Sound.OSC.Type.Bundle
instance Sound.OSC.Class.OSC Sound.OSC.Type.Packet

-- | Composite of non-transport related modules.
--   
--   Provides the Datum, Message, Bundle and
--   Packet types and the Datem, OSC and Coding
--   type-classes.
--   
--   The basic constructors are message and bundle, the basic
--   coding functions are encodePacket and decodePacket.
--   
--   
--   import Sound.OSC.Core
--   
--   let {o = bundle immediately [message "/g_free" [Int32 0]]
--       ;e = encodeBundle o :: String}
--   in decodeBundle e == o
--   
module Sound.OSC.Core

-- | An abstract transport layer with implementations for UDP and
--   TCP transport.
module Sound.OSC.Transport.FD

-- | Abstract over the underlying transport protocol.
class Transport t

-- | Encode and send an OSC packet.
sendOSC :: (Transport t, OSC o) => t -> o -> IO ()

-- | Receive and decode an OSC packet.
recvPacket :: Transport t => t -> IO Packet

-- | Close an existing connection.
close :: Transport t => t -> IO ()

-- | Bracket OSC communication.
withTransport :: Transport t => IO t -> (t -> IO a) -> IO a

-- | Type restricted synonym for sendOSC.
sendMessage :: Transport t => t -> Message -> IO ()

-- | Type restricted synonym for sendOSC.
sendBundle :: Transport t => t -> Bundle -> IO ()

-- | Variant of recvPacket that runs fromPacket.
recvOSC :: (Transport t, OSC o) => t -> IO (Maybe o)

-- | Variant of recvPacket that runs packet_to_bundle.
recvBundle :: (Transport t) => t -> IO Bundle

-- | Variant of recvPacket that runs packet_to_message.
recvMessage :: (Transport t) => t -> IO (Maybe Message)

-- | Variant of recvPacket that runs packetMessages.
recvMessages :: (Transport t) => t -> IO [Message]

-- | Variant of recvPacket that implements an n second
--   timeout.
recvPacketTimeout :: (Transport t) => Double -> t -> IO (Maybe Packet)

-- | Wait for a Packet where the supplied predicate is True,
--   discarding intervening packets.
waitUntil :: (Transport t) => t -> (Packet -> Bool) -> IO Packet

-- | Wait for a Packet where the supplied function does not give
--   Nothing, discarding intervening packets.
waitFor :: (Transport t) => t -> (Packet -> Maybe a) -> IO a

-- | waitUntil packet_is_immediate.
waitImmediate :: Transport t => t -> IO Packet

-- | waitFor packet_to_message, ie. an incoming
--   Message or immediate mode Bundle with one element.
waitMessage :: Transport t => t -> IO Message

-- | A waitFor for variant using packet_has_address to match
--   on the Address_Pattern of incoming Packets.
waitAddress :: Transport t => t -> Address_Pattern -> IO Packet

-- | Variant on waitAddress that returns matching Message.
waitReply :: Transport t => t -> Address_Pattern -> IO Message

-- | Variant of waitReply that runs messageDatum.
waitDatum :: Transport t => t -> Address_Pattern -> IO [Datum]

-- | OSC over TCP implementation.
module Sound.OSC.Transport.FD.TCP

-- | The TCP transport handle data type.
data TCP
TCP :: Handle -> TCP
[tcpHandle] :: TCP -> Handle

-- | Make a TCP connection.
openTCP :: String -> Int -> IO TCP

-- | A trivial TCP OSC server.
tcpServer' :: Int -> (TCP -> IO ()) -> IO ()
instance Sound.OSC.Transport.FD.Transport Sound.OSC.Transport.FD.TCP.TCP

-- | OSC over UDP implementation.
module Sound.OSC.Transport.FD.UDP

-- | The UDP transport handle data type.
data UDP
UDP :: Socket -> UDP
[udpSocket] :: UDP -> Socket

-- | Return the port number associated with the UDP socket.
udpPort :: Integral n => UDP -> IO n

-- | Create and initialise UDP socket.
udp_socket :: (Socket -> SockAddr -> IO ()) -> String -> Int -> IO UDP

-- | Make a UDP connection.
--   
--   
--   let t = openUDP "127.0.0.1" 57110
--   in withTransport t (\fd -> recvT 0.5 fd >>= print)
--   
openUDP :: String -> Int -> IO UDP

-- | Trivial UDP server socket.
--   
--   
--   import Control.Concurrent
--   
--   
--   
--   let {f fd = forever (recvMessage fd >>= print)
--       ;t = udpServer "127.0.0.1" 57300}
--   in void (forkIO (withTransport t f))
--   
--   
--   
--   let t = openUDP "127.0.0.1" 57300
--   in withTransport t (\fd -> sendMessage fd (message "/n" []))
--   
udpServer :: String -> Int -> IO UDP

-- | Send variant to send to specified address.
sendTo :: OSC o => UDP -> o -> SockAddr -> IO ()

-- | Recv variant to collect message source address.
recvFrom :: UDP -> IO (Packet, SockAddr)
instance Sound.OSC.Transport.FD.Transport Sound.OSC.Transport.FD.UDP.UDP

-- | Composite of Sound.OSC.Core and Sound.OSC.Transport.FD.
module Sound.OSC.FD

-- | Monad class implementing an Open Sound Control transport.
module Sound.OSC.Transport.Monad

-- | Sender monad.
class Monad m => SendOSC m

-- | Encode and send an OSC packet.
sendOSC :: (SendOSC m, OSC o) => o -> m ()

-- | Receiver monad.
class Monad m => RecvOSC m

-- | Receive and decode an OSC packet.
recvPacket :: RecvOSC m => m Packet

-- | DuplexOSC is the union of SendOSC and RecvOSC.
class (SendOSC m, RecvOSC m) => DuplexOSC m

-- | Transport is DuplexOSC with a MonadIO constraint.
class (DuplexOSC m, MonadIO m) => Transport m

-- | Transport connection.
type Connection t a = ReaderT t IO a

-- | Bracket Open Sound Control communication.
withTransport :: Transport t => IO t -> Connection t a -> IO a

-- | Type restricted synonym for sendOSC.
sendMessage :: SendOSC m => Message -> m ()

-- | Type restricted synonym for sendOSC.
sendBundle :: SendOSC m => Bundle -> m ()

-- | Variant of recvPacket that runs fromPacket.
recvOSC :: (RecvOSC m, OSC o) => m (Maybe o)

-- | Variant of recvPacket that runs packet_to_bundle.
recvBundle :: (RecvOSC m) => m Bundle

-- | Variant of recvPacket that runs packet_to_message.
recvMessage :: (RecvOSC m) => m (Maybe Message)

-- | Variant of recvPacket that runs packetMessages.
recvMessages :: (RecvOSC m) => m [Message]

-- | Wait for a Packet where the supplied predicate is True,
--   discarding intervening packets.
waitUntil :: (RecvOSC m) => (Packet -> Bool) -> m Packet

-- | Wait for a Packet where the supplied function does not give
--   Nothing, discarding intervening packets.
waitFor :: (RecvOSC m) => (Packet -> Maybe a) -> m a

-- | waitUntil packet_is_immediate.
waitImmediate :: RecvOSC m => m Packet

-- | waitFor packet_to_message, ie. an incoming
--   Message or immediate mode Bundle with one element.
waitMessage :: RecvOSC m => m Message

-- | A waitFor for variant using packet_has_address to match
--   on the Address_Pattern of incoming Packets.
waitAddress :: RecvOSC m => Address_Pattern -> m Packet

-- | Variant on waitAddress that returns matching Message.
waitReply :: RecvOSC m => Address_Pattern -> m Message

-- | Variant of waitReply that runs messageDatum.
waitDatum :: RecvOSC m => Address_Pattern -> m [Datum]
instance (Sound.OSC.Transport.FD.Transport t, Control.Monad.IO.Class.MonadIO io) => Sound.OSC.Transport.Monad.SendOSC (Control.Monad.Trans.Reader.ReaderT t io)
instance (Sound.OSC.Transport.FD.Transport t, Control.Monad.IO.Class.MonadIO io) => Sound.OSC.Transport.Monad.RecvOSC (Control.Monad.Trans.Reader.ReaderT t io)
instance (Sound.OSC.Transport.FD.Transport t, Control.Monad.IO.Class.MonadIO io) => Sound.OSC.Transport.Monad.DuplexOSC (Control.Monad.Trans.Reader.ReaderT t io)
instance (Sound.OSC.Transport.FD.Transport t, Control.Monad.IO.Class.MonadIO io) => Sound.OSC.Transport.Monad.Transport (Control.Monad.Trans.Reader.ReaderT t io)

-- | Composite of Sound.OSC.Core and
--   Sound.OSC.Transport.Monad.
module Sound.OSC
