On Dec 30, 2015 10:05 PM, <amindfv@gmail.com> wrote:
> The major difference from just `foo = "thing1" ; things = [foo, ...` is that it's much more visually clear which values are in `things` (imagine I create a `baz` but forget to add it to `things`).

The best I've found is to use `where` profusely:

```
things
  = [ foo
    , bar
    , baz
    ]
  where
    foo = _
    bar = _
    baz = _
```

If you forget to define `baz` but include it in the list, you get an error for a name not bound, and if you define it but forget to include it in the list, you get an error with `-Wall -Werror` for an unused binding.

Now, if you want some of them at the top level, you do this ugly thing:

```
(
  foo,
  bar,
  things
  ) = (
    foo,
    bar,
    things
  )
  where
    things
      = [ foo
        , bar
        , baz
        ]
    foo = _
    bar = _
    baz = _
```

Just don't get the order wrong on the tuples for things with the same types.  Welp!

It's a bit less awful if you always want all the items in e. g. a list exported to the top level, as in your example, but this is a bit more general.  It's still awful, but using tuples instead of list patterns allows you heterogeneous toplevel exports and more structures than just lists.

You could also define a record:

```
{-# LANGUAGE RecordWildCards #-}

data R
  = R
    { foo :: {- something -}
    , bar :: {- something else -}
    , things :: {- stuff -}
    }

R {..} = R {..} where
  foo = _
  bar = _
  baz = _
  things
    = [ foo
      , bar
      , baz
      ]
```

This costs you explicit type signatures in the record declaration, but `-Wall` would ask for those on toplevel bindings anyway.

I don't think this could be solved easily with syntax; consider

```
things x = foo@(x, x + 1)
```

`foo` can't be made toplevel easily.