проверить, является ли список целых чисел возрастающим

У вас есть несколько проблем.

Во-первых, вам не хватает случая для списка только с 1 элементом, который должен быть базовым случаем и возвращать #t. В противном случае вы будете использовать (second x) в списке только с 1 элементом, что является ошибкой.

Затем, когда в списке 2 или более элементов, он увеличивается, если первый элемент меньше второго элемента и конец списка также увеличивается. Вы проверяете только первые два элемента. Ваше предложение else выполняется только тогда, когда первый и второй элементы равны, потому что первые две проверки cond обрабатывают < и >. Рекурсивный вызов не является отдельным случаем, он объединен со случаем, когда первые два элемента возрастают.

(define (ascending x)
  (match x
    ('() #f) ;; Empty list is error
    ((cons hd '()) #t) ;; 1-element is success
    ((cons hd tl)
     (if (< hd (second x))
         (ascending tl)
         #f))))

if также можно упростить до:

(and (< hd (second x)) (ascending tl))

Поскольку функция #'< принимает любое количество аргументов, вы можете просто сделать:

(apply #'< '(1 2 3 4)) => T

Если вам разрешено использовать сопоставление с шаблоном для решения этой проблемы, вы можете использовать более сложные шаблоны, чтобы разбить свою проблему на отдельные части.

(: ascending? : (Listof Integer) -> Boolean :)
(define (ascending? xs)
  (match xs
    [(list)           #f] ;; empty list is not considered ascending
    [(list a)         #t] ;; single-element list is always ascending
    ;; match first two elements (a, b) and remaining elements as c
    ;; a should be less than b, and recurse
    [(list a b c ...) (and (< a b) (ascending? (cons b c)))]))

Для меня это читается намного лучше, чем соответствие стиля '() или (cons ...). А поскольку в третьем случае мы использовали более выразительный шаблон, код, который на самом деле делает что-то, остается очень простым.

(ascending? '())               ;; => #f
(ascending? '(1))              ;; => #t
(ascending? '(1 2))            ;; => #t
(ascending? '(1 2 3 4 5 6 7))  ;; => #t
(ascending? '(1 2 3 1))        ;; => #f

Я должен упомянуть, что нет ничего плохого в другом стиле шаблонов, который вы использовали. Я просто думаю, что легче читать, когда шаблоны последовательны. Таким образом, вместо того, чтобы сопоставлять '() с cons и list и т. д., если вы хотите использовать стиль шаблонов в кавычках, используйте их для каждого случая, чтобы было легче увидеть, какие случаи вы обрабатываете.

Эта ascending? процедура работает так же, только использует другой стиль выражений сопоставления с образцом.

(: ascending? : (Listof Integer) -> Boolean :)
(define (ascending? xs)
  (match xs
    [`()               #f]
    [`(,a)             #t]
    [`(,a . (,b . ,c)) (and (< a b) (ascending? (cons b c)))]))

И еще: ты сказал...

Проверьте, не пуст ли список, и выдайте ошибку. Сделанный. Поставить галочку.

Возврат #f не вызывает ошибку. Если вы действительно намерены вызвать ошибку, если кто-то передает пустой список, вам следует использовать процедуру error

...
(match xs
  [(list) (error 'ascending? "empty list given")]
  ...

Для меня иногда полезно придерживаться абстракций более высокого уровня в описании проблемы, а не декомпозировать проблему, чтобы вписать ее в шаблон программирования, такой как сопоставление с образцом.

Технические характеристики

Например, можно сказать, что строго упорядоченный список имеет два математических свойства:

1. Список отсортирован (монотонно).

2. Длина списка равна мощности множества, содержащего все элементы списка.

Реализация

Работая с этой более математической спецификацией:

 #lang typed/racket
 (: strictly-ordered-list? : (Listof Integer) -> Boolean)
 (define (strictly-ordered-list? xs) 
   (define sorted (sort xs <))
     (and (equal? xs sorted)
       (= (set-count (list->set xs))
          (length sorted))))

Обсуждение

Реализация написана на интересующем нас уровне абстракции, списках. Он проверяет свойства списков и не увязает в переборе и сравнении элементов. Потенциально, он торгует немного скоростью, но обычно для данных интересного размера O (n log n) по сравнению с O (n) вряд ли будет узким местом.