Documentation

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)

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

NTP time in real-valued (fractional) form (ie. ntpr). This is the primary form of timestamp used by hosc.

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

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

Convert a real-valued NTP timestamp to an NTPi timestamp.

ntpr_to_ntpi immediately == 1
fmap ntpr_to_ntpi time

Convert an NTPi timestamp to a real-valued NTP timestamp.

Difference (in seconds) between NTP and UT epochs.

ntp_ut_epoch_diff / (24 * 60 * 60) == 25567
25567 `div` 365 == 70

Convert a UT timestamp to an NTPi timestamp.

Convert Unix/Posix to NTP.

Convert NTP to Unix/Posix.

Convert NTPi to Unix/Posix.

Convert Time to POSIXTime.

Convert POSIXTime to Time.

The time at 1970-01-01:00:00:00.

Convert UTCTime to Unix/Posix.

Read current real-valued NTP timestamp.

get_ct = fmap utc_to_ut T.getCurrentTime
get_pt = fmap realToFrac T.getPOSIXTime
(ct,pt) <- get_ct >>= \t0 -> get_pt >>= \t1 -> return (t0,t1)
print (pt - ct,pt - ct < 1e-5)

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.

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

Type restricted pauseThread.

Pause current thread until the given Time, see pauseThreadLimit.

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

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

Detailed 37-character ISO 8601 format, including fractional seconds and '+0000' suffix.

Parse time according to iso_8601_fmt

iso_8601_to_utctime "2015-11-26T00:29:37,145875000000+0000"

UTC time in iso_8601_fmt.

tm <- fmap (utctime_to_iso_8601 . T.posixSecondsToUTCTime) T.getPOSIXTime
(length tm,sum [4+1+2+1+2,1,2+1+2+1+2,1,12,1,4],sum [10,1,8,1,12,1,4]) == (37,37,37)

ISO 8601 of Time.

tm <- fmap ntpr_to_iso_8601 time
import System.Process {- process -}
rawSystem "date" ["-d",tm]

t = 15708783354150518784
s = "2015-11-26T00:22:19,366058349609+0000"
ntpr_to_iso_8601 (ntpi_to_ntpr t) == s

Time of ISO 8601.

t = 15708783354150518784
s = "2015-11-26T00:22:19,366058349609+0000"
fmap ntpr_to_ntpi (iso_8601_to_ntpr s) == Just t

Alias for ntpr_to_iso_8601.

time_pp immediately == "1900-01-01T00:00:00,000000000000+0000"
fmap time_pp time

Perhaps a precision value for floating point numbers.

The basic elements of OSC messages.

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

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

Type for ASCII strings (strict Lexeme8 ByteString).

Type enumerating Datum categories.

Type-specialised pack.

Type-specialised unpack.

Type-specialised pack.

Type-specialised unpack.

List of required data types (tag,name).

List of optional data types (tag,name).

List of all data types (tag,name).

Lookup name of type.

Erroring variant.

Single character identifier of an OSC datum.

Type and name of Datum.

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]

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)

Type generalised Int32.

int32 (1::Int32) == int32 (1::Integer)
d_int32 (int32 (maxBound::Int32)) == maxBound
int32 (((2::Int) ^ (64::Int))::Int) == Int32 0

Type generalised Int64.

int64 (1::Int32) == int64 (1::Integer)
d_int64 (int64 (maxBound::Int64)) == maxBound

Type generalised Float.

float (1::Int) == float (1::Double)
floatRange (undefined::Float) == (-125,128)
isInfinite (d_float (float (encodeFloat 1 256 :: Double))) == True

Type generalised Double.

double (1::Int) == double (1::Double)
double (encodeFloat 1 256 :: Double) == Double 1.157920892373162e77

ASCII_String of pack.

string "string" == ASCII_String (Char8.pack "string")

Four-tuple variant of Midi . MIDI.

midi (0,0,0,0) == Midi (MIDI 0 0 0 0)

Message argument types are given by a descriptor.

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

Descriptor tags are comma prefixed.

Variant of showFFloat that deletes trailing zeros.

map (floatPP (Just 4)) [1,pi] == ["1.0","3.1416"]

Pretty printer for Time.

timePP (Just 4) (1/3) == "0.3333"

Pretty printer for vectors.

vecPP [1::Int,2,3] == "<1,2,3>"

Pretty printer for blobs, two-digit zero-padded hexadecimal.

Pretty printer for Datum.

let d = [Int32 1,Float 1.2,string "str",midi (0,0x90,0x40,0x60)]
map (datumPP (Just 5)) d ==  ["1","1.2","\"str\"","<0,144,64,96>"]

Variant of datumPP that appends the datum_type_name.

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 (blob_pack [112,105]))
parse_datum 'm' "(0,144,60,90)" == Just (midi (0,144,60,90))

Erroring variant of parse_datum.

An OSC Packet is either a Message or a Bundle.

An OSC bundle, a Time and a sequence of Messages.

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

OSC address pattern. This is strictly an ASCII value, however it is very common to pattern match on addresses and matching on ByteString requires OverloadedStrings.

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

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

Packet_Bundle of bundle.

Packet_Message of message.

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

Retrieve the set of Messages from a Packet.

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

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

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

Variant of either for Packet.

Does Message have the specified Address_Pattern.

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

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

Pretty printer for Message.

Pretty printer for Bundle.

Pretty printer for Packet.

Builder for an OSC Packet.

Encode an OSC Packet.

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

Encode an OSC Bundle, 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

Encode an OSC Packet to a strict ByteString.

Get an OSC Packet.

Decode an OSC Message from a lazy ByteString.

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

Decode an OSC Bundle from a lazy ByteString.

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]
decodePacket b == Packet_Message (Message "/g_free" [Int32 0])

Decode an OSC packet from a strict ByteString.

Variant of timeout where time is given in fractional seconds.

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

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

Transport connection.

Transport is DuplexOSC with a MonadIO constraint.

DuplexOSC is the union of SendOSC and RecvOSC.

Receiver monad.

Sender monad.

Bracket Open Sound Control communication.

void of withTransport.

Type restricted synonym for sendOSC.

Type restricted synonym for sendOSC.

Variant of recvPacket that runs packet_to_bundle.

Variant of recvPacket that runs packet_to_message.

Erroring variant.

Variant of recvPacket that runs packetMessages.

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

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

waitUntil packet_is_immediate.

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

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

Variant on waitAddress that returns matching Message.

Variant of waitReply that runs messageDatum.

The UDP transport handle data type.

Return the port number associated with the UDP socket.

Send packet over UDP.

Receive packet over UDP.

Close UDP.

Bracket UDP communication.

Create and initialise UDP socket.

Set option, ie. Broadcast or RecvTimeOut.

Get option.

Make a UDP connection.

Trivial UDP server socket.

import Control.Concurrent 

let u0 = udpServer "127.0.0.1" 57300
t0 <- forkIO (FD.withTransport u0 (\fd -> forever (FD.recvMessage fd >>= print)))

let u1 = openUDP "127.0.0.1" 57300
FD.withTransport u1 (\fd -> FD.sendMessage fd (Packet.message "/n" []))

Variant of udpServer that doesn't require the host address.

Send variant to send to specified address.

Recv variant to collect message source address.

The TCP transport handle data type.

Send packet over TCP.

Receive packet over TCP.

Close TCP.

Bracket UDP communication.

Create and initialise TCP socket.

Convert Socket to TCP.

Create and initialise TCP.

Make a TCP connection.

import Sound.OSC.Datum 
import Sound.OSC.Time 
let t = openTCP "127.0.0.1" 57110
let m1 = Packet.message "/dumpOSC" [Int32 1]
let m2 = Packet.message "/g_new" [Int32 1]
FD.withTransport t (\fd -> let f = FD.sendMessage fd in f m1 >> pauseThread 0.25 >> f m2)

accept connection at s and run f.

sequence_ of repeat.

A trivial TCP OSC server.