Am Montag 20 April 2009 02:10:42 schrieb Michael Mossey:

Some additional thoughts:

Here is something I'm struggling with. Let's say a piece of music is several staves filled with chords. Staves have names. Each chord in a staff has a time.

In informal notation:

staff "fred": (time 1.0, chord 1), (time 1.5, chord 2), (time 2.0, chord 3) staff "bob" : (time 1.0, chord 4), (time 2.0, chord 5)

When laying out music, I need to find "verticals", which are chords located on different staves which happen to coincide in time. For instance, the above has three verticals:

time 1.0: ("fred", chord 1), ("bob", chord 4) time 1.5: ("fred", chord 2) time 2.0: ("fred", chord 3), ("bob", chord 5)

I want to write a function that converts the first way of organizing the information into the second. I tried writing types like

type Chord = ... type Time = Double type Name = String

type TimedChord = (Time,Chord) type Staff = [(Time,Chord)] type NamedStaff = (Name,Staff) type NamedChord = (Name,Chord) type Vertical = [NamedChord] type TimedVertical = (Time,Vertical)

The function I want is

convert :: [NamedStaff] -> [TimedVertical]

What about import Data.Function (on) import Data.List convert namedStaffs = map timeVertical verticals where nameTimedChords (name,tcs) = [(time,name,chord) | (time, chord) <- tcs] timedNamedChords = sort . foldr merge [] . map nameTimedChords $ namedStaffs fst3 (x,_,_) = x verticals = groupBy ((==) `on` fst3) timedNamedChords timeVertical v@((t,_,_):_) = (t,[(name,chord) | (_,name,chord) <- v]) ?

As you can imagine, this is a confusing mess, with all these variants on named and timed things. I thought it might help to create functors called Named and Timed, which might help abstracting operations on named and timed things. For example,

datatype Named a = Named { namedName :: Name, namedData :: a }

instance Functor Named = name a :: Name name a = namedName a x `fmap` f = Named { namedName = namedName x, namedData = f $ namedData x }

Any other suggestions? Thanks, Mike

Michael Mossey wrote:

toVerticals :: [[NamedTimedChord]] -> [[NamedTimedChord]] toVerticals [] = [] toVerticals staves = firstVertical : toVerticals remainder where time3 (_,time,_) = time firstVertT = minimum $ map (time3 . head) staves usingStaves = [ s | s <- staves, time3 (head s) == firstVertT ] notUsingStaves = [ s | s <- staves, time3 (head s) /= firstVertT ]

realized I could use Data.List.partition for this

firstVertical = map head usingStaves remainder = leftOfUsing ++ notUsingStaves leftOfUsing = filter (not . null) (map tail usingStaves) _______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners

Maybe just bikeshedding here (and on -beginners, no less), but this seems like a job for Data.Traversable.sequence? sequence :: Monad m => t (m a) -> m (t a) Cheers, S. On Apr 20, 2009, at 3:00 AM, Heinrich Apfelmus wrote:

Functors sounds good to me.

data Named a = N Name a data Timed a = T Time a

instance Functor Named where ... instance Functor Timed where ...

convert :: Named [Timed Chord] -> Timed [Named Chord]

Bu you can also use plain type synonyms

type Named a = (Name,a) type Timed a = (Time,a)

and write your own record selectors by hand

name :: Named a -> Name name = fst

time :: Timed a -> Time time = fst

value :: (b,a) -> a value = snd

Regards, apfelmus

-- http://apfelmus.nfshost.com

_______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners

Hello, I would like to write a function convert :: [(Name, [(Time, Chord)])] -> [(Time, [(Name, Chord)])] which transposes a finite map [(Name,b)] of event lists [(Time,a)] into an event list of finite maps. Sterling remarked that this looks very much like a job for sequence , but since event lists are not even applicative functors, I wonder whether an abstraction with less requirements can be found. Below is a first try. Heinrich Apfelmus wrote:

Sterling Clover wrote:

...

Maybe just bikeshedding here (and on -beginners, no less), but this seems like a job for Data.Traversable.sequence?

sequence :: Monad m => t (m a) -> m (t a)

Great idea!

My type signature is wrong, it should actually read

convert :: [Named [Timed Chord]] -> [Timed [Named Chord]]

I'm not sure whether sequence applies directly,

type EventList a = [Timed a]

is not a monad. It's not quite an applicative functor either, because in

(<*>) :: EventList (a -> b) -> EventList a -> EventList b

it's not clear what should happen to events from the left and right list that are not simultaneous. This needs further thought.

It appears that type EventList a = [(Time, a)] -- ascending times is not an applicative functor, but only a "monoid preserving functor" instance Monoid a => Monoid (EventList a) where mempty = [] mappend xs ys = map mconcat . groupBy ((==) `on` fst) . sortBy (comparing fst) (xs ++ ys) The same is true for type Group a = [(Name, a)] instance Monoid a => Monoid (Group a) where ... Put differently, we have two functions unionWith :: (a -> a -> a) -> EventList a -> EventList a -> EventList a unionWith :: (a -> a -> a) -> Group a -> Group a -> Group a Additionally, we need concat :: (a -> a -> a) -> Group a -> a and a strange function cobind' :: Functor f => Group (f a) -> Group (f (Group a)) cobind' xs = [(name, fmap (\y -> (name,y)) x) | (name,x) <- xs] that is reminiscent of a comonad. With this machinery, we can write convert :: Group (EventList a) -> EventList (Group a) convert = concat (unionWith (unionWith snd)) . cobind' No idea whether all this is overkill. After all, convert is but a glorified transpose. Regards, apfelmus -- http://apfelmus.nfshost.com