[Haskell-cafe] Anonymous, Unique Types, maybe

[Scott Lawrence]

(Sorry if this email is rather unclear - I know my desired end result, 
but neither how to acheive nor explain it well. Here goes.)

I'm processing lists, using them sortof as streams. (Whether that's a 
good idea isn't the issue here - but let me know if it isn't!) 
Fundamentally, there are two types of operations (at least, that are 
relevant here) - those that change the length of the list and those that 
don't.

Some operators might take more than one list/stream as an argument, 
combining them in some way or another. Obviously, if the lists were 
different lengths, the operator would fail. I don't want that to happen 
at run time, so I want to check for it statically, presumably via the 
type system. I could do this manually:

type AList = [Event]
type BList = [Event]
type CList = [Event]

myMapish :: AList -> AList
mySelect :: AList -> (Event -> Bool) -> BList
myOtherSelect :: BList -> CList

but I'd rather not have to manually define a new type for every new list 
length:

myMapish :: List a -> List a
mySelect :: List a -> List ?

The '?' would be an anonymous, unique type - unless there's a better way 
to accomplish this.

Hope that was clear, and thanks (as always) for the help (and being 
awesome).

-- 
Scott Lawrence