hosc-0.15: Haskell Open Sound Control

Safe HaskellSafe-Inferred




Alegbraic data types for OSC datum and packets.



type Time = Double Source

NTP time in real-valued (fractional) form.

immediately :: Time Source

Constant indicating a bundle to be executed immediately.


type Datum_Type = Char Source

Type enumerating Datum categories.

type ASCII = ByteString Source

Type for ASCII strings (strict Char8 ByteString).

ascii :: String -> ASCII Source

Type-specialised pack.

ascii_to_string :: ASCII -> String Source

Type-specialised unpack.

data MIDI Source

Four-byte midi message.


MIDI Word8 Word8 Word8 Word8 


data Datum Source

The basic elements of OSC messages.




d_int32 :: Int32


d_int64 :: Int64


d_float :: Float


d_double :: Double


d_blob :: ByteString


d_timestamp :: Time


d_midi :: MIDI


datum_tag :: Datum -> Datum_Type Source

Single character identifier of an OSC datum.

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

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_floating :: Floating n => Datum -> Maybe n Source

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)

class Datem a where Source

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


d_put :: a -> Datum Source

d_get :: Datum -> Maybe a Source

int32 :: Integral n => n -> Datum Source

Type generalised Int32.

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

int64 :: Integral n => n -> Datum Source

Type generalised Int64.

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

float :: Real n => n -> Datum Source

Type generalised Float.

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

double :: Real n => n -> Datum Source

Type generalised Double.

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

string :: String -> Datum Source

ASCII_String of pack.

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

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

Four-tuple variant of Midi . MIDI.

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


type Address_Pattern = String Source

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.

data Message Source

An OSC message.

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

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

descriptor :: [Datum] -> ASCII Source

Message argument types are given by a descriptor.

C.unpack (descriptor [Int32 1,Float 1,string "1"]) == ",ifs"

descriptor_tags :: ASCII -> ASCII Source

Descriptor tags are comma prefixed.


data Bundle Source

An OSC bundle.




Eq Bundle 
Ord Bundle

OSC Bundles can be ordered (time ascending).

Read Bundle 
Show Bundle 
OSC Bundle 

bundle :: Time -> [Message] -> Bundle Source

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


data Packet Source

An OSC Packet is either a Message or a Bundle.

packetTime :: Packet -> Time Source

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

packetMessages :: Packet -> [Message] Source

Retrieve the set of Messages from a Packet.

packet_to_bundle :: Packet -> Bundle Source

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

packet_to_message :: Packet -> Maybe Message Source

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

packet_is_immediate :: Packet -> Bool Source

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

at_packet :: (Message -> a) -> (Bundle -> a) -> Packet -> a Source

Variant of either for Packet.

Address Query

bundle_has_address :: Address_Pattern -> Bundle -> Bool Source

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

Pretty printing

type FP_Precision = Maybe Int Source

Perhaps a precision value for floating point numbers.

floatPP :: RealFloat n => Maybe Int -> n -> String Source

Variant of showFFloat that deletes trailing zeros.

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

timePP :: FP_Precision -> Time -> String Source

Pretty printer for Time.

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

vecPP :: Show a => [a] -> String Source

Pretty printer for vectors.

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

datumPP :: FP_Precision -> Datum -> String Source

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>"]

messagePP :: FP_Precision -> Message -> String Source

Pretty printer for Message.

bundlePP :: FP_Precision -> Bundle -> String Source

Pretty printer for Bundle.

packetPP :: FP_Precision -> Packet -> String Source

Pretty printer for Packet.


readMaybe :: Read a => String -> Maybe a Source

Variant of read.

parse_datum :: Datum_Type -> String -> Maybe Datum Source

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))