hosc-0.15: Haskell Open Sound Control

Safe HaskellSafe
LanguageHaskell98

Sound.OSC.Type

Contents

Description

Alegbraic data types for OSC datum and packets.

Synopsis

Time

type Time = Double #

NTP time in real-valued (fractional) form.

immediately :: Time #

Constant indicating a bundle to be executed immediately.

Datum

type Datum_Type = Char #

Type enumerating Datum categories.

type ASCII = ByteString #

Type for ASCII strings (strict Char8 ByteString).

ascii :: String -> ASCII #

Type-specialised pack.

ascii_to_string :: ASCII -> String #

Type-specialised unpack.

data MIDI #

Four-byte midi message.

Constructors

MIDI Word8 Word8 Word8 Word8 

Instances

data Datum #

The basic elements of OSC messages.

Constructors

Int32 

Fields

Int64 

Fields

Float 

Fields

Double 

Fields

ASCII_String 
Blob 

Fields

TimeStamp 

Fields

Midi 

Fields

datum_tag :: Datum -> Datum_Type #

Single character identifier of an OSC 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]
in map datum_integral d == [Just (5::Int),Just 5,Nothing,Nothing]

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]
in Data.Maybe.mapMaybe datum_floating d == replicate 5 (5::Double)

class Datem a where #

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

Minimal complete definition

d_put, d_get

Methods

d_put :: a -> Datum #

d_get :: Datum -> Maybe a #

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

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 #

Type generalised Int64.

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

float :: Real 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

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

Type generalised Double.

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

string :: String -> Datum #

ASCII_String of pack.

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

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

Four-tuple variant of Midi . MIDI.

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

Message

type Address_Pattern = String #

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.

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

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

descriptor :: [Datum] -> ASCII #

Message argument types are given by a descriptor.

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

descriptor_tags :: ASCII -> ASCII #

Descriptor tags are comma prefixed.

Bundle

data Bundle #

An OSC bundle.

Constructors

Bundle 

Instances

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

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

Packet

packetTime :: Packet -> Time #

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

packetMessages :: Packet -> [Message] #

Retrieve the set of Messages from a Packet.

packet_to_bundle :: Packet -> Bundle #

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

packet_to_message :: Packet -> Maybe Message #

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 #

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

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

Variant of either for Packet.

Address Query

bundle_has_address :: Address_Pattern -> Bundle -> Bool #

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

Pretty printing

type FP_Precision = Maybe Int #

Perhaps a precision value for floating point numbers.

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

Variant of showFFloat that deletes trailing zeros.

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

timePP :: FP_Precision -> Time -> String #

Pretty printer for Time.

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

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

Pretty printer for vectors.

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

datumPP :: FP_Precision -> Datum -> 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>"]

messagePP :: FP_Precision -> Message -> String #

Pretty printer for Message.

bundlePP :: FP_Precision -> Bundle -> String #

Pretty printer for Bundle.

packetPP :: FP_Precision -> Packet -> String #

Pretty printer for Packet.

Parser

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

Variant of read.

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

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