recursive unpacking of a list through function signatures

Question

I'm trying to write a function in sml which 'unpacks' a nest list of arbitrary depth. For example unpack [[[1,2]]] should yield [1,2]. I 'm trying something like :

fun unpack xs = if nestedp (xs) then unpack (hd xs) else xs;

with fun nestedp [_] = true | nestedp _ = false;

sml doesn't like unpack defined this way because it infers that the type of unpack as 'a list -> 'a . The return of the call to hd is passed back into unpack but it now doesn't 'see' a list but a single variable.

Is it possible to unpack a nested list this way at all ?

i don't think sml's type system can handle this. can you think of a way to write the type of your function? i can't (but it's been some time since i used ml). — andrew cooke, Sep 03 '11 at 21:37
basically it would be something like 'a list -> 'b list, where 'a is of type 'a list list (say) and 'b would be 'a list (because one level of nesting would be removed). — fons haffmans, Sep 03 '11 at 21:40
this is the haskell take - http://stackoverflow.com/questions/5994051/is-there-a-function-to-flatten-a-nested-list-of-elements - but it uses "MultiParamTypeClasses" — andrew cooke, Sep 03 '11 at 21:42
right, but to describe that requires a type system that's more sophisticated than anything in sml. there's no way (that i can remember at least) to start saying things like that about a and b. — andrew cooke, Sep 03 '11 at 21:44
thanks for the feedback. I googled some more and essentially found that the way to handle this is set up a data type for nested lists and take it from there. — fons haffmans, Sep 04 '11 at 12:59
that will let you handle data structures that contain either a value or another list, so you should be able to write a function that does what you want. but even then, the type of the function won't show what it does (unless you return a list rather than an instance of your new type). that's not really a problem (you get your function after all), but it's still annoying that type systems aren't that flexible. — andrew cooke, Sep 04 '11 at 13:21

Sebastian Paaske Tørholm · Accepted Answer · 2011-09-07T19:43:15.557

You cannot do this for the built in list type, as you wouldn't be able to get the types to match up.

For instance, one might think it'd be possible with a function of type 'a list list -> 'a list, and then applying it recursively until it reaches a base case of a non-nested list. You would, however, not be able to detect the base case in any way, leaving your types mismatched.

You could, however, do it if you created your own list type:

datatype 'a nestableList = Cons of 'a * 'a nestableList
                         | NCons of 'a nestableList * 'a nestableList
                         | Nil;

Here, Cons and Nil would work the same as :: and [], while NCons would allow for nested list building.

As an example:

(* The list [[1, 2], [[3], [4, 5, 6]]] *)
val nlist = NCons(
              Cons(1, Cons(2, Nil)),
              NCons(
                NCons(
                  Cons(3, Nil),
                  Cons(4, Cons(5, Cons(6, Nil)))
                ),
                Nil
              )
           );

You could then flatten this nested list type like this:

fun flatten nls =
let
  fun flatten_ Nil                 = []
    | flatten_ (NCons(head, tail)) = flatten head @ flatten tail
    | flatten_ ( Cons(head, tail)) = head :: flatten tail
in
    flatten_ nls
end;

Which then could be used like this

val flattenedNlist = flatten nlist;     (* Yields [1, 2, 3, 4, 5, 6] *)

Here I have it yield a regular list, but it could easily be changed to return a list of the same type instead.

recursive unpacking of a list through function signatures

1 Answers1