The major difference from just `foo = "thing1" ; things = [foo, ...` is
On Dec 30, 2015 10:05 PM, wrote:
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.
