Haskell бесконечный список увеличивающихся пар

Игнорируя метод helper, понимание списка, которое у вас есть, будет перечислять все пары, но порядок элементов является проблемой. У вас будет бесконечно много пар, таких как (0, m), за которыми за которыми следует бесконечное количество пар, таких как (1, m). Конечно, elem будет постоянно перебирать все пары (0, m), никогда не достигая (1, m) или (2, m) и т. д.

Я не уверен, почему у вас есть метод helper — с его помощью вы только строите список пар, таких как [(0,0), (1,1), (2,2), ...], потому что вы отфильтровали m = n. Это было частью требований?

Как предложил @hammar, начните с 0 = m + n и перечислите пары (m, n). Затем перечислите пары (m, n), где 1 = m + n. Тогда ваш список будет выглядеть как [(0,0), (0,1), (1,0), (0,2), (1,1), (2,0), ...].

Вспомогательная функция гарантирует, что пары представляют собой список в форме [ (0,0) , (1,1) , (2,2) ... ].

Таким образом, пары elem ( m , n ) могут быть реализованы как:

elem (m , n) _ |  m == n    = True
               |  otherwise = False

Это реализация с постоянным временем.

я первый написал

Prelude> let pairs = [(m, n) | t <- [0..]
                     , let m = head $ take 1 $ drop t [0..] 
                     , let n = head $ take 1 $ drop (t + 1) [0..]]

Что, как мне казалось, отвечало трем условиям, поставленным профессором. Но Хаммар указал, что если я выбрал в качестве ответа этот список, то есть список пар вида (t, t+1), то я мог бы также выбрать список

repeat [(0,0)] 

Что ж, оба они, кажется, отвечают на вопрос профессора, учитывая, что, кажется, нет упоминания о том, что список должен содержать все комбинации [0..] и [0..].

Помимо этого, Hammer помог мне увидеть, как можно составить список всех комбинаций, облегчив вычисление elem за конечное время путем построения бесконечного списка из конечных списков. Вот два других конечных списка — менее лаконичных, чем предложение Хаммара о диагоналях, — которые, кажется, строят все комбинации [0..] и [0..]:

edges = concat [concat [[(m,n),(n,m)] | let m = t, n <- take m [0..]] ++ [(t,t)] 
      | t <- [0..]]


*Main> take 9 edges
[(0,0),(1,0),(0,1),(1,1),(2,0),(0,2),(2,1),(1,2),(2,2)]

которые строят ребра (t, 0..t) (0..t, t), и

oddSpirals size = concat [spiral m size' | m <- n] where
  size' = if size < 3 then 3 else if even size then size - 1 else size
  n = map (\y -> (fst y * size' + div size' 2, snd y * size' + div size' 2)) 
          [(x, t-x) | let size' = 5, t <- [0..], x <- [0..t]]
  spiral seed size = spiral' (size - 1) "-" 1 [seed]
  spiral' limit op count result
    | count == limit =
       let op' = if op == "-" then (-) else (+)
           m = foldl (\a b -> a ++ [(op' (fst $ last a) b, snd $ last a)]) result (replicate count 1)
           nextOp = if op == "-" then "+" else "-"
           nextOp' = if op == "-" then (+) else (-)
           n = foldl (\a b -> a ++ [(fst $ last a, nextOp' (snd $ last a) b)]) m (replicate count 1)
           n' = foldl (\a b -> a ++ [(nextOp' (fst $ last a) b, snd $ last a)]) n (replicate count 1)
       in n'
    | otherwise      =
        let op' = if op == "-" then (-) else (+)
            m = foldl (\a b -> a ++ [(op' (fst $ last a) b, snd $ last a)]) result (replicate count 1)
            nextOp = if op == "-" then "+" else "-"
            nextOp' = if op == "-" then (+) else (-)
            n = foldl (\a b -> a ++ [(fst $ last a, nextOp' (snd $ last a) b)]) m (replicate count 1)
        in spiral' limit nextOp (count + 1) n


*Main> take 9 $ oddSpirals 3
[(1,1),(0,1),(0,2),(1,2),(2,2),(2,1),(2,0),(1,0),(0,0)]

которые строят спирали по часовой стрелке длины «размера» в квадрате, наложенные на алгоритм диагоналей Хаммара.

Я считаю, что решение вашей задачи:

pairs = [(x,y) | u <- [0..], x <- [0..u], y <-[0..u] , u == x+y]