Haskell not in scope list comprehension

问题

 all_nat x = [ls| sum ls == x]

I'd like to write a function that given an integer x it returns all the lists that the result of their elements when summed is the integer x but I always get the error "not in scope: 'ls' " for both times it apperas. I'm new to haskell. What's the syntax error here?

回答1:

The problem is that you need to define all used variables somewhere, but ls is undefined. Moreover, it can't be defined automatically, because the compiler doesn't know about the task — how the list should be generated? Ho long can it be? Are terms positive or not, integral or not? Unfortunately your code definition of the problem is quite vague for modern non-AI languages. Let's help the compiler. To solve such problems, it's often useful to involve some math and infer the algorithm inductively. For example, let's write an algorithm with ordered lists (where [2,1] and [1,2] are different solutions):

1. Start with a basis, where you know the output for some given input. For example, for 0 there is only an empty list of terms (if 0 could be a term, any number could be decomposed as a sum in infinitely many ways). So, let's define that:

allNats 0 = [[]] --One empty list

1. An inductive step. Assuming we can decompose a number n, we can decompose any number n+k for any positive k, by adding k as a term to all decompositions of n. In other words: for numbers greater than 0, we can take any number k from 1 to n, and make it the first term of all decompositions of (n­-k):

allNats n = [ k:rest                   --Add k as a head to the rest, where
            | k <- [1 .. n]            --k is taken from 1 to n, and
            , rest <- allNats (n - k)] --rest is taken from solutions for (n—k)

That's all! Let's test it:

ghci> allNat 4
[[1,1,1,1],[1,1,2],[1,2,1],[1,3],[2,1,1],[2,2],[3,1],[4]]

回答2:

Let's break this up into two parts. If I've understood your question correctly, the first step is to generate all possible (sub)lists from a list. There's a function to do this, called subsequences.

The second step is to evaluate the sum of each subsequence, and keep the subsequences with the sum you want. So your list comprehension looks like this:

all_nat x = [ls| ls <- subsequences [1..x], sum ls == x]

回答3:

What about

getAllSums x = [(l,r)| l <- partial_nat, r <- partial_nat, l + r == x ]
  where partial_nat = [1..x]

来源：https://stackoverflow.com/questions/22478551/haskell-not-in-scope-list-comprehension