[Haskell] pattern matching woes

[Ryan Paul]

I recently elected to employ Haskell for my functional programming needs
rather than Ocaml. Thus far, I have been relatively happy with the
expressiveness and syntactic grace of Haskell, but there are a few
aspects of Haskell's syntax that irritate me...

In OCaml, when I am doing pattern matching, I can string together
patterns to which I wish to assign the same result.

for example:
match a with X z | Y z | Z z -> True | _ -> False

I cannot find a good way to do this with Haskell. I would really like to
be able to do that, and I cant think of any reasons why it shouldnt be
possible - could such a feature be added to the Haskell standard?

If anybody can suggest possible alternatives, I would like to see them -
the following is the actual code in question, from one of my compiler
projects:

The Haskell code:

flatten a = case a of
  App l -> flatten' l
  List l -> a : flatten' l
  Arg l -> a : flatten l
  Ret l -> a : flatten l
  Fun _ l -> a : flatten' l
  Call _ l -> a : flatten' l
  Assign _ l -> a : flatten l
  Op x _ z -> a : flatten x ++ flatten z
  _ -> [a]

  where
    flatten' l = foldl (\x y -> x ++ (flatten y)) [] l

As compared to the ocaml equivelent:

let rec flatten a =
  let proc l = (List.fold_left (fun x y -> x @ (flatten y)) [] l) in
  match a with
  | Op (x,y,z) -> a :: (flatten x) @ (flatten z)
  | Assign (n,l) -> a :: (flatten l)
  | Fun (n,l) | Call (n,l) -> a :: (proc l)
  | App l | List l -> a :: (proc l)
  | Arg l | Ret l -> a :: (flatten l)
  | _ -> [a]


My second issue is with modules. I regularly use modules to clean up
namespace issues. When I want to do this with Haskell, I have to define
the module in a separate file and then use qualified import to bring it
into the file in which I want to use it. Often, I dont particularly want
or need to use the module again elsewhere, so putting it in a separate
file is counterintuitive. I would like to be able to nest my modules,
and have the parent module be able to do a qualified import on the
modules inside of it.

The following is an example of how I use nested modules in OCaml:

module Get =
  struct

  let funcs    = function App l       -> l >< Is.func    | _ -> [] ;;
  let params   = function Fun (n,l)   -> l >< Is.param   | _ -> [] ;;
  let assigns  = function Fun (n,l)   -> l >< Is.assign  | _ -> [] ;;
  let calls    = function Fun (n,l)   -> l >< Is.call    | _ -> [] ;;
  let vargs    = function Call (n,l)  -> l >< Is.varg    | _ -> [] ;;

  module All =
    struct
    
    let funcs   a = (flatten a) >< Is.func     ;;
    let assigns a = (flatten a) >< Is.assign   ;;
    let strs    a = (flatten a) >< Is.str      ;;
    let consts  a = (flatten a) >< Is.const    ;;
    let calls   a = (flatten a) >< Is.call     ;;
    
    end
  end

When I want to extract all the calls from a func recursively, I would do
something like:

Get.All.calls somefunc

If I just wanted to get the calls at the very top level, I would do:

Get.calls somefunc

Note: i'm not subscribed to the mailing list, so if you respond, please
cc your response to my email address.

Thanks!

-- SegPhault