Sound.Osc

Composite of Sound.Osc.Core and Sound.Osc.Transport.Monad.

Documentation

class Monad m => MonadIO (m :: Type -> Type) where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Instances

MonadIO IO

Since: base-4.9.0.0

Defined in Control.Monad.IO.Class

Methods

liftIO :: IO a -> IO a

MonadIO Q

Defined in Language.Haskell.TH.Syntax

Methods

liftIO :: IO a -> Q a

MonadIO m => MonadIO (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

liftIO :: IO a -> MaybeT m a

MonadIO m => MonadIO (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

liftIO :: IO a -> IdentityT m a

MonadIO m => MonadIO (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

liftIO :: IO a -> ReaderT r m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

liftIO :: IO a -> WriterT w m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

liftIO :: IO a -> WriterT w m a

MonadIO m => MonadIO (ParsecT s u m)

Defined in Text.Parsec.Prim

Methods

liftIO :: IO a -> ParsecT s u m a

MonadIO m => MonadIO (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

liftIO :: IO a -> ContT r m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

liftIO :: IO a -> RWST r w s m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

liftIO :: IO a -> RWST r w s m a

data Message

An Osc message, an Address_Pattern and a sequence of Datum.

Constructors

Message

Fields

• messageAddress :: !Address_Pattern
• messageDatum :: ![Datum]

Instances

Read Message

Defined in Sound.Osc.Packet

Methods

readsPrec :: Int -> ReadS Message

readList :: ReadS [Message]

readPrec :: ReadPrec Message

readListPrec :: ReadPrec [Message]

Show Message

Defined in Sound.Osc.Packet

Methods

showsPrec :: Int -> Message -> ShowS

show :: Message -> String

showList :: [Message] -> ShowS

Eq Message

Defined in Sound.Osc.Packet

Methods

(==) :: Message -> Message -> Bool

(/=) :: Message -> Message -> Bool

Ord Message

Defined in Sound.Osc.Packet

Methods

compare :: Message -> Message -> Ordering

(<) :: Message -> Message -> Bool

(<=) :: Message -> Message -> Bool

(>) :: Message -> Message -> Bool

(>=) :: Message -> Message -> Bool

max :: Message -> Message -> Message

min :: Message -> Message -> Message

data Datum

The basic elements of Osc messages.

Constructors

Int32

Fields

• d_int32 :: !Int32

Int64

Fields

• d_int64 :: !Int64

Float

Fields

• d_float :: !Float

Double

Fields

• d_double :: !Double

AsciiString

Fields

• d_ascii_string :: !Ascii

Blob

Fields

• d_blob :: !Blob

TimeStamp

Fields

• d_timestamp :: !Time

Midi

Fields

• d_midi :: !MidiData

Instances

Read Datum

Defined in Sound.Osc.Datum

Methods

readsPrec :: Int -> ReadS Datum

readList :: ReadS [Datum]

readPrec :: ReadPrec Datum

readListPrec :: ReadPrec [Datum]

Show Datum

Defined in Sound.Osc.Datum

Methods

showsPrec :: Int -> Datum -> ShowS

show :: Datum -> String

showList :: [Datum] -> ShowS

Eq Datum

Defined in Sound.Osc.Datum

Methods

(==) :: Datum -> Datum -> Bool

(/=) :: Datum -> Datum -> Bool

Ord Datum

Defined in Sound.Osc.Datum

Methods

compare :: Datum -> Datum -> Ordering

(<) :: Datum -> Datum -> Bool

(<=) :: Datum -> Datum -> Bool

(>) :: Datum -> Datum -> Bool

(>=) :: Datum -> Datum -> Bool

max :: Datum -> Datum -> Datum

min :: Datum -> Datum -> Datum

type Packet = PacketOf Message

type Time = Double

A real-valued time stamp. For Osc proper this is an Ntp64 time in real-valued (fractional) form. For SuperCollider Nrt programs this is elapsed time since the start of the score. This is the primary form of timestamp used by hosc.

type DatumType = Char

Type enumerating Datum categories.

type Address_Pattern = String

Osc address pattern. This is strictly an Ascii value, however it is very common to pattern match on addresses and matching on Data.ByteString.Char8 requires OverloadedStrings.

type Ntp64 = Word64

Type for binary (integeral) representation of a 64-bit Ntp timestamp (ie. ntpi). The Ntp epoch is January 1, 1900. Ntp v4 also includes a 128-bit format, which is not used by Osc.

class (DuplexOsc m, MonadIO m) => Transport m

Transport is DuplexOsc with a MonadIO constraint.

Instances

(Transport t, MonadIO io) => Transport (ReaderT t io)

Transport over ReaderT.

Defined in Sound.Osc.Transport.Monad

data OscProtocol

Protocol, either Udp or Tcp

Constructors

Udp

Tcp

Instances

Read OscProtocol

Defined in Sound.Osc.Transport.Fd.Socket

Methods

readsPrec :: Int -> ReadS OscProtocol

readList :: ReadS [OscProtocol]

readPrec :: ReadPrec OscProtocol

readListPrec :: ReadPrec [OscProtocol]

Show OscProtocol

Defined in Sound.Osc.Transport.Fd.Socket

Methods

showsPrec :: Int -> OscProtocol -> ShowS

show :: OscProtocol -> String

showList :: [OscProtocol] -> ShowS

Eq OscProtocol

Defined in Sound.Osc.Transport.Fd.Socket

Methods

(==) :: OscProtocol -> OscProtocol -> Bool

(/=) :: OscProtocol -> OscProtocol -> Bool

type Ascii = ByteString

Type for Ascii strings (strict Char8 ByteString)

type Blob = ByteString

Type for Word8 arrays, these are stored with an Datum length prefix.

data MidiData

Four-byte midi message: port-id, status-byte, data, data.

Constructors

MidiData !Word8 !Word8 !Word8 !Word8

Instances

Read MidiData

Defined in Sound.Osc.Datum

Methods

readsPrec :: Int -> ReadS MidiData

readList :: ReadS [MidiData]

readPrec :: ReadPrec MidiData

readListPrec :: ReadPrec [MidiData]

Show MidiData

Defined in Sound.Osc.Datum

Methods

showsPrec :: Int -> MidiData -> ShowS

show :: MidiData -> String

showList :: [MidiData] -> ShowS

Eq MidiData

Defined in Sound.Osc.Datum

Methods

(==) :: MidiData -> MidiData -> Bool

(/=) :: MidiData -> MidiData -> Bool

Ord MidiData

Defined in Sound.Osc.Datum

Methods

compare :: MidiData -> MidiData -> Ordering

(<) :: MidiData -> MidiData -> Bool

(<=) :: MidiData -> MidiData -> Bool

(>) :: MidiData -> MidiData -> Bool

(>=) :: MidiData -> MidiData -> Bool

max :: MidiData -> MidiData -> MidiData

min :: MidiData -> MidiData -> MidiData

data BundleOf t

An Osc bundle, a Time and a sequence of Messages. The type parameter specifies the element type. Ordinarily this is Message, which does not allow recursion.

Constructors

Bundle

Fields

• bundleTime :: !Time
• bundleMessages :: ![t]

Instances

Read t => Read (BundleOf t)

Defined in Sound.Osc.Packet

Methods

readsPrec :: Int -> ReadS (BundleOf t)

readList :: ReadS [BundleOf t]

readPrec :: ReadPrec (BundleOf t)

readListPrec :: ReadPrec [BundleOf t]

Show t => Show (BundleOf t)

Defined in Sound.Osc.Packet

Methods

showsPrec :: Int -> BundleOf t -> ShowS

show :: BundleOf t -> String

showList :: [BundleOf t] -> ShowS

Eq t => Eq (BundleOf t)

Defined in Sound.Osc.Packet

Methods

(==) :: BundleOf t -> BundleOf t -> Bool

(/=) :: BundleOf t -> BundleOf t -> Bool

Eq t => Ord (BundleOf t)

Osc BundleOfs can be ordered (time ascending).

Defined in Sound.Osc.Packet

Methods

compare :: BundleOf t -> BundleOf t -> Ordering

(<) :: BundleOf t -> BundleOf t -> Bool

(<=) :: BundleOf t -> BundleOf t -> Bool

(>) :: BundleOf t -> BundleOf t -> Bool

(>=) :: BundleOf t -> BundleOf t -> Bool

max :: BundleOf t -> BundleOf t -> BundleOf t

min :: BundleOf t -> BundleOf t -> BundleOf t

type Bundle = BundleOf Message

data PacketOf t

An Osc Packet is either a Message or a 'Bundle t'.

Constructors

Packet_Message

Fields

• packetMessage :: !Message

Packet_Bundle

Fields

• packetBundle :: !(BundleOf t)

Instances

Read t => Read (PacketOf t)

Defined in Sound.Osc.Packet

Methods

readsPrec :: Int -> ReadS (PacketOf t)

readList :: ReadS [PacketOf t]

readPrec :: ReadPrec (PacketOf t)

readListPrec :: ReadPrec [PacketOf t]

Show t => Show (PacketOf t)

Defined in Sound.Osc.Packet

Methods

showsPrec :: Int -> PacketOf t -> ShowS

show :: PacketOf t -> String

showList :: [PacketOf t] -> ShowS

Eq t => Eq (PacketOf t)

Defined in Sound.Osc.Packet

Methods

(==) :: PacketOf t -> PacketOf t -> Bool

(/=) :: PacketOf t -> PacketOf t -> Bool

type NtpReal = Double

Ntp time in real-valued (fractional) form.

type PosixReal = Double

Unix/Posix time in real-valued (fractional) form. The Unix/Posix epoch is January 1, 1970.

class Monad m => SendOsc m where

Sender monad.

Methods

sendPacket :: PacketOf Message -> m ()

Encode and send an Osc packet.

Instances

(Transport t, MonadIO io) => SendOsc (ReaderT t io)

SendOsc over ReaderT.

Defined in Sound.Osc.Transport.Monad

Methods

sendPacket :: PacketOf Message -> ReaderT t io ()

class Monad m => RecvOsc m where

Receiver monad.

Methods

recvPacket :: m (PacketOf Message)

Receive and decode an Osc packet.

Instances

(Transport t, MonadIO io) => RecvOsc (ReaderT t io)

RecvOsc over ReaderT.

Defined in Sound.Osc.Transport.Monad

Methods

recvPacket :: ReaderT t io (PacketOf Message)

class (SendOsc m, RecvOsc m) => DuplexOsc m

DuplexOsc is the union of SendOsc and RecvOsc.

Instances

(Transport t, MonadIO io) => DuplexOsc (ReaderT t io)

DuplexOsc over ReaderT.

Defined in Sound.Osc.Transport.Monad

type Connection t a = ReaderT t IO a

Transport connection.

type OscHostname = String

Hostname

type OscPort = Int

Port number

type OscSocketAddress = (OscProtocol, OscHostname, OscPort)

Socket address

data OscSocket

Socket

Constructors

OscUdpSocket Udp

OscTcpSocket Tcp

Instances

Transport OscSocket

OscSocket is an instance of Transport.

Defined in Sound.Osc.Transport.Fd.Socket

Methods

sendPacket :: OscSocket -> PacketOf Message -> IO ()

recvPacket :: OscSocket -> IO (PacketOf Message)

recvPacketOr :: OscSocket -> IO (Either String Packet)

close :: OscSocket -> IO ()

time :: MonadIO m => m NtpReal

string :: String -> Datum

AsciiString of pack.

>>> string "string" == AsciiString (ByteString.Char8.pack "string")
True

ascii :: String -> Ascii

Type-specialised pack.

float :: Real n => n -> Datum

Type generalised Float.

>>> float (1::Int) == float (1::Double)
True

>>> floatRange (undefined::Float)
(-125,128)

>>> isInfinite (d_float (float (encodeFloat 1 256 :: Double)))
True

double :: Real n => n -> Datum

Type generalised Double.

>>> double (1::Int) == double (1::Double)
True

>>> double (encodeFloat 1 256 :: Double) == Double 1.157920892373162e77
True

decodeMessage :: ByteString -> Message

Decode an Osc Message from a lazy ByteString.

>>> let b = ByteString.Lazy.pack [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
>>> decodeMessage b == Message "/g_free" [Int32 0]
True

decodeBundle :: ByteString -> BundleOf Message

Decode an Osc BundleOf from a lazy ByteString.

decodePacket :: ByteString -> PacketOf Message

Decode an Osc packet from a lazy ByteString.

>>> let b = ByteString.Lazy.pack [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
>>> decodePacket b == Packet_Message (Message "/g_free" [Int32 0])
True

get_packet :: Get (PacketOf Message)

Get an Osc Packet.

decodePacket_strict :: ByteString -> PacketOf Message

Decode an Osc packet from a strict Char8 ByteString.

decodeMessageOr :: ByteString -> Either String Message

Either decode Osc message or return an error message. Prevents application halt for non-valid messagebundlepacket arrives.

>>> let b = ByteString.Lazy.pack [1,2,3,2,1]
>>> decodePacketOr b
Left "not enough bytes"

decodeBundleOr :: ByteString -> Either String Bundle

decodePacketOr :: ByteString -> Either String Packet

build_packet :: PacketOf Message -> Builder

Builder for an Osc Packet.

encodeMessage :: Message -> ByteString

Encode an Osc Message, ie. encodePacket of Packet_Message.

>>> let m = [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
>>> encodeMessage (Message "/g_free" [Int32 0]) == L.pack m
True

encodeBundle :: BundleOf Message -> ByteString

Encode an Osc BundleOf, ie. encodePacket of Packet_Bundle.

>>> let m = [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
>>> let b = [35,98,117,110,100,108,101,0,0,0,0,0,0,0,0,1,0,0,0,16] ++ m
>>> encodeBundle (Bundle immediately [Message "/g_free" [Int32 0]]) == L.pack b
True

encodePacket :: PacketOf Message -> ByteString

Encode an Osc Packet.

encodePacket_strict :: PacketOf Message -> ByteString

Encode an Osc Packet to a strict ByteString.

getSystemTimeAsNtpReal :: IO NtpReal

Get the system time, epoch start of 1970 UTC, leap-seconds ignored. getSystemTime is typically much faster than getCurrentTime, however it is not available in Hugs.

pauseThreadLimit :: Fractional n => n

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.

untilPredicate :: Monad m => (a -> Bool) -> m a -> m a

Repeat action until predicate f is True when applied to result.

ascii_to_string :: Ascii -> String

Type-specialised unpack.

blob_pack :: [Word8] -> Blob

Type-specialised pack.

blob_pack_int :: [Int] -> Blob

Type-specialised pack.

blob_unpack :: Blob -> [Word8]

Type-specialised unpack.

blob_unpack_int :: Blob -> [Int]

Type-specialised unpack.

midi_pack :: [Word8] -> MidiData

midi_pack_int :: [Int] -> MidiData

Type-specialised pack.

midi_unpack_int :: MidiData -> [Int]

Type-specialised unpack.

osc_types_required :: [(DatumType, String)]

List of required data types (tag, name).

osc_types_optional :: [(DatumType, String)]

List of optional data types (tag,name).

osc_types :: [(DatumType, String)]

List of all data types (tag,name).

osc_type_name :: DatumType -> Maybe String

Lookup name of type.

osc_type_name_err :: DatumType -> String

Erroring variant.

datum_tag :: Datum -> DatumType

Single character identifier of an Osc datum.

datum_type_name :: Datum -> (DatumType, String)

Type and name of Datum.

datum_integral :: Integral i => Datum -> Maybe i

Datum as Integral if Int32 or Int64.

>>> let d = [Int32 5,Int64 5,Float 5.5,Double 5.5]
>>> map datum_integral d == [Just (5::Int),Just 5,Nothing,Nothing]
True

datum_floating :: Floating n => Datum -> Maybe n

Datum as Floating if Int32, Int64, Float, Double or TimeStamp.

>>> let d = [Int32 5,Int64 5,Float 5,Double 5,TimeStamp 5]
>>> mapMaybe datum_floating d == replicate 5 (5::Double)
True

int32 :: Integral n => n -> Datum

Type generalised Datum.

>>> int32 (1::Int32) == int32 (1::Integer)
True

>>> d_int32 (int32 (maxBound::Int32)) == maxBound
True

>>> int32 (((2::Int) ^ (64::Int))::Int) == Int32 0
True

int64 :: Integral n => n -> Datum

Type generalised Int64.

>>> int64 (1::Int32) == int64 (1::Integer)
True

>>> d_int64 (int64 (maxBound::Int64)) == maxBound
True

midi :: (Word8, Word8, Word8, Word8) -> Datum

Four-tuple variant of Midi . MidiData.

>>> midi (0,0,0,0) == Midi (MidiData 0 0 0 0)
True

blob :: [Word8] -> Datum

Blob of blob_pack.

signatureFor :: [Datum] -> String

Message argument types are given by a signature.

>>> signatureFor [Int32 1,Float 1,string "1"]
",ifs"

descriptor :: [Datum] -> Ascii

The descriptor is an Ascii encoded signature.

>>> descriptor [Int32 1,Float 1,string "1"] == ascii ",ifs"
True

descriptor_tags :: Ascii -> Ascii

Descriptor tags are comma prefixed.

message :: Address_Pattern -> [Datum] -> Message

Message constructor. It is an error if the Address_Pattern doesn't conform to the Osc specification.

messageSignature :: Message -> String

messageDescriptor :: Message -> Ascii

bundle :: Time -> [t] -> BundleOf t

BundleOf constructor. It is an error if the Message list is empty.

p_bundle :: Time -> [t] -> PacketOf t

Packet_Bundle of bundle.

p_message :: Address_Pattern -> [Datum] -> PacketOf t

Packet_Message of message.

immediately :: Time

Constant indicating a bundle to be executed immediately. It has the Ntp64 representation of 1.

>>> immediately == (1 / (2 ^ 32))
True

packetTime :: PacketOf t -> Time

The Time of Packet, if the Packet is a Message this is immediately.

at_packet :: (Message -> a) -> (BundleOf t -> a) -> PacketOf t -> a

Variant of either for Packet.

packetMessages :: PacketOf Message -> [Message]

Retrieve the set of Messages from a Packet.

packet_to_bundle :: PacketOf Message -> BundleOf Message

If Packet is a Message add immediately timestamp, else id.

packet_to_message :: PacketOf Message -> Maybe Message

If Packet is a Message or a BundleOf with an immediate time tag and with one element, return the Message, else Nothing.

packet_is_immediate :: PacketOf t -> Bool

Is Packet immediate, ie. a BundleOf with timestamp immediately, or a plain Message.

message_has_address :: Address_Pattern -> Message -> Bool

Does Message have the specified Address_Pattern.

bundle_has_address :: Address_Pattern -> BundleOf Message -> Bool

Do any of the Messages at 'Bundle Message' have the specified Address_Pattern.

packet_has_address :: Address_Pattern -> PacketOf Message -> Bool

Does Packet have the specified Address_Pattern, ie. message_has_address or bundle_has_address.

ntpr_to_ntpi :: NtpReal -> Ntp64

Convert an NtpReal timestamp to an Ntp64 timestamp.

>>> ntpr_to_ntpi 0
0

fmap ntpr_to_ntpi time

ntpi_to_ntpr :: Ntp64 -> NtpReal

Convert an Ntp64 timestamp to a real-valued Ntp timestamp.

>>> ntpi_to_ntpr 0
0.0

ntp_posix_epoch_diff :: Num n => n

Difference (in seconds) between Ntp and Posix epochs.

>>> ntp_posix_epoch_diff / (24 * 60 * 60)
25567.0

>>> 25567 `div` 365
70

posix_to_ntpi :: PosixReal -> Ntp64

Convert a PosixReal timestamp to an Ntp64 timestamp.

posix_to_ntpr :: Num n => n -> n

Convert Unix/Posix to Ntp.

ntpr_to_posix :: Num n => n -> n

Convert Ntp to Unix/Posix.

ntpi_to_posix :: Ntp64 -> PosixReal

Convert Ntp64 to Unix/Posix.

ntpr_to_posixtime :: NtpReal -> POSIXTime

Convert Time to POSIXTime.

posixtime_to_ntpr :: POSIXTime -> NtpReal

Convert POSIXTime to Time.

posix_epoch :: UTCTime

The time at 1970-01-01:00:00:00 which is the Unix/Posix epoch.

utc_to_posix :: Fractional n => UTCTime -> n

Convert UTCTime to Unix/Posix.

getCurrentTimeAsPosix :: IO PosixReal

utc_to_posix of Clock.getCurrentTime.

getPosixTimeAsPosix :: IO PosixReal

realToFrac of Clock.Posix.getPOSIXTime

get_ct = getCurrentTimeAsPosix
get_pt = getPosixTimeAsPosix
(ct,pt) <- get_ct >>= \t0 -> get_pt >>= \t1 -> return (t0,t1)
print (pt - ct,pt - ct < 1e-5)

currentTime :: IO NtpReal

Read current real-valued Ntp timestamp.

getSystemTimeInMicroseconds :: IO (Int64, Word32)

System time with fractional part in microseconds (us) instead of nanoseconds (ns).

pauseThreadFor :: RealFrac n => n -> IO ()

Pause current thread for the indicated duration (in seconds), see pauseThreadLimit.

pauseThreadUntilTime :: RealFrac n => n -> IO ()

Pause current thread until the given time, see pauseThreadLimit.

sleepThreadFor :: RealFrac n => n -> IO ()

Sleep current thread for the indicated duration (in seconds). Divides long sleeps into parts smaller than pauseThreadLimit.

sleepThreadUntilTime :: RealFrac n => n -> IO ()

Sleep current thread until the given time. Divides long sleeps into parts smaller than pauseThreadLimit.

wait :: MonadIO m => Double -> m ()

pauseThread :: (MonadIO m, RealFrac n) => n -> m ()

sleepThread :: (RealFrac n, MonadIO m) => n -> m ()

pauseThreadUntil :: (MonadIO m, RealFrac n) => n -> m ()

sleepThreadUntil :: (RealFrac n, MonadIO m) => n -> m ()

untilMaybe :: Monad m => (a -> Maybe b) -> m a -> m b

Repeat action until f does not give Nothing when applied to result.

withTransport :: Transport t => IO t -> Connection t r -> IO r

Bracket Open Sound Control communication.

sendMessage :: SendOsc m => Message -> m ()

Type restricted synonym for sendOsc.

sendBundle :: SendOsc m => BundleOf Message -> m ()

Type restricted synonym for sendOsc.

recvBundle :: RecvOsc m => m (BundleOf Message)

Variant of recvPacket that runs packet_to_bundle.

recvMessage :: RecvOsc m => m (Maybe Message)

Variant of recvPacket that runs packet_to_message.

recvMessage_err :: RecvOsc m => m Message

Erroring variant.

recvMessages :: RecvOsc m => m [Message]

Variant of recvPacket that runs packetMessages.

waitUntil :: RecvOsc m => (PacketOf Message -> Bool) -> m (PacketOf Message)

Wait for a Packet where the supplied predicate is True, discarding intervening packets.

waitFor :: RecvOsc m => (PacketOf Message -> Maybe a) -> m a

Wait for a Packet where the supplied function does not give Nothing, discarding intervening packets.

waitImmediate :: RecvOsc m => m (PacketOf Message)

waitUntil packet_is_immediate.

waitMessage :: RecvOsc m => m Message

waitFor packet_to_message, ie. an incoming Message or immediate mode Bundle with one element.

waitAddress :: RecvOsc m => Address_Pattern -> m (PacketOf Message)

A waitFor for variant using packet_has_address to match on the Address_Pattern of incoming Packets.

waitReply :: RecvOsc m => Address_Pattern -> m Message

Variant on waitAddress that returns matching Message.

waitDatum :: RecvOsc m => Address_Pattern -> m [Datum]

Variant of waitReply that runs messageDatum.

withTransport_ :: Transport t => IO t -> Connection t r -> IO ()

void of withTransport.

openOscSocket :: OscSocketAddress -> IO OscSocket

Open socket at address