简化 Haskell 中的嵌套列表输入

Question

I'm making a function to flatten a nested list of arbitrary depth.

flatten.hs

data NestedList a = Regular a | Nested [NestedList a]

flatten::NestedList a -> [a]
flatten (Regular a) = [a]
flatten (Nested a) = concatMap flatten a

Right now if I want to flatten the list [1,2,3,[1,[1, 2]],2] I have to input it like (Nested [Regular 1, Regular 2, Regular 3, Nested [Regular 1, Nested [Regular 1, Regular 2]], Regular 2]) . Is there a way to simplify the input value? I know about OverloadedLists but have no idea how to work with them.

Answer 1

You can get part-way there with OverloadedLists :

The key here is defining an IsList instance. With overloaded lists, if GHC sees something like:

[x,y,z]

and can parse x , y , z as all the same type item , then it will put them into a list [x,y,z] :: [item] and call:

fromList :: [item] -> NestedList a

You have to choose the right definition of item to get this to work. And, since you want to be able to write:

[[another_nested_list],[another_nested_list]]

with the inner lists parsed exactly the same way, it turns out you need item to be NestedList a , too:

fromList :: [NestedList a] -> NestedList a

This gives the IsList instance:

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE OverloadedLists #-}

import GHC.Exts

data NestedList a = Regular a | Nested [NestedList a] deriving (Show)

instance IsList (NestedList a) where
  type Item (NestedList a) = NestedList a
  fromList = Nested

With this in place, you can write:

> flatten [Regular 1, Regular 2, Regular 3, [Regular 1, [Regular 1, Regular 2]], Regular 2]
[1,2,3,1,1,2,2]

Unfortunately, it doesn't work without the Regular s because 1 can't be parsed as an item , namely NestedList a .

You can play a dirty trick by defining a Num instance to parse the integer literal into a NestedList a like so:

instance (Num a) => Num (NestedList a) where
  fromInteger = Regular . fromInteger

and that'll let you write:

flatten [1,2,3,[1,[1,2]],2]
> [1,2,3,1,1,2,2]

That gets it working with integers only. If you try to write:

> flatten [[1.5,2.5]]
> flatten [["bar"],[["foo"]]

you'll get errors. You'd need to define a Fractional instance to handle 1.5 and an IsString instance (using OverloadedStrings ) to handle "bar" .