Обработка ошибок

Статья
08/27/2023

Результат вычисления выражения M приводит к одному из следующих результатов:

Создается одно значение.
Возникает ошибка, указывающая, что процесс оценки выражения не удалось создать значение. Ошибка содержит одно значение записи, которое можно использовать для предоставления дополнительных сведений о том, что вызвало неполное вычисление.

Ошибки могут возникать из выражения и обрабатываться из выражения.

Создание ошибок

Синтаксис для создания ошибки выглядит следующим образом:

выражение error-raising-expression:
error выражение

Текстовые значения можно использовать в качестве сокращенных значений ошибок. Например:

error "Hello, world" // error with message "Hello, world"

Полные значения ошибок — это записи и можно создать с помощью Error.Record функции:

error Error.Record("FileNotFound", "File my.txt not found",
     "my.txt")

Приведенное выше выражение эквивалентно следующему:

error [ 
    Reason = "FileNotFound", 
    Message = "File my.txt not found", 
    Detail = "my.txt" 
]

При возникновении ошибки текущая оценка выражений будет остановлена, и стек вычислений выражений будет отсохнет до тех пор, пока не произойдет одно из следующих действий:

Пока не будет достигнуто поле записи, элемент раздела или переменная let — в совокупности — запись. Запись помечена как ошибка, значение ошибки сохраняется с этой записью, а затем распространяется. Любой последующий доступ к этой записи приведет к возникновению идентичной ошибки. Другие записи записи, раздела или выражения пусть не обязательно затронуты (если они не получают доступ к записи, помеченной как ошибка).
Достигается выражение верхнего уровня. В этом случае результат оценки выражения верхнего уровня является ошибкой вместо значения.
try Достигается выражение. В этом случае ошибка фиксируется и возвращается в качестве значения.

Обработка ошибок

Выражение обработки ошибок (неофициально известное как "выражение try") используется для обработки ошибки:

Выражение error-handling-expression:
      tryВыбор_{обработчика ошибок защищенного выражения}
защищенное-выражение:
      выражение
Обработчик ошибок:
      Предложение в противном случае
      предложение catch-
предложение-otherwise:
      otherwiseвыражение по умолчанию
выражение по умолчанию:
      выражение
предложение catch-:
      catchcatch-function
catch-function:
      (параметр-name_opt) => function-body

При оценке выражения обработки ошибок без обработчика ошибок следует учитывать следующее:

Если оценка защищенного выражения не приводит к ошибке и создает значение x, значение, созданное выражением обработки ошибок, является записью следующей формы:

    [ HasErrors = false, Value = x ]

Если оценка защищенного выражения вызывает значение ошибки e, результат выражения обработки ошибок является записью следующей формы:

    [ HasErrors = true, Error = e ]

При оценке выражения обработки ошибок с помощью обработчика ошибок содержится следующее:

Перед обработчиком ошибок необходимо оценить защищенное выражение.
Обработчик ошибок должен оцениваться только в том случае, если оценка защищенного выражения вызывает ошибку.
Если оценка защищенного выражения вызывает ошибку, значение, созданное выражением обработки ошибок, является результатом оценки обработчика ошибок.
Ошибки, возникающие во время оценки обработчика ошибок, распространяются.
Когда вычисляемый обработчик ошибок является предложением catch-, вызывается функция catch. Если эта функция принимает параметр, значение ошибки будет передано в качестве значения.

В следующем примере показано выражение обработки ошибок в случае, когда ошибка не возникает:

let
    x = try "A"
in
    if x[HasError] then x[Error] else x[Value] 
// "A"

В следующем примере показано создание ошибки, а затем обработка ошибки:

let
    x = try error "A" 
in
    if x[HasError] then x[Error] else x[Value] 
// [ Reason = "Expression.Error", Message = "A", Detail = null ]

Предыдущий пример можно переписать с меньшим синтаксисом с помощью предложения catch-с функцией catch, которая принимает параметр:

let
    x = try error "A" catch (e) => e
in
    x
// [ Reason = "Expression.Error", Message = "A", Detail = null ]

Предложение в противном случае можно использовать для замены ошибок, обрабатываемых выражением try, альтернативным значением:

try error "A" otherwise 1 
// 1

Предложение catch-с нулевым параметром catch-function является более длинным альтернативным синтаксисом для предложения в противном случае:

try error "A" catch () => 1 
// 1

Если обработчик ошибок также вызывает ошибку, то выполняется все выражение try:

try error "A" otherwise error "B" 
// error with message "B"

try error "A" catch () => error "B" 
// error with message "B"

try error "A" catch (e) => error "B" 
// error with message "B"

Ошибки в записи и разрешить инициализаторам

В следующем примере показан инициализатор записей с полем A , которое вызывает ошибку и обращается к двум другим полям B и C. Поле B не обрабатывает ошибку, которая возникает, Aно C делает. Окончательное поле D не обращается и A поэтому оно не влияет на ошибку.A

[ 
    A = error "A", 
    B = A + 1,
    C = let x =
            try A in
                if not x[HasError] then x[Value]
                else x[Error], 
    D = 1 + 1 
]

Результатом оценки приведенного выше выражения является:

[ 
    A = // error with message "A" 
    B = // error with message "A" 
    C = "A", 
    D = 2 
]

Обработка ошибок в M должна быть выполнена близко к причине ошибок для устранения последствий инициализации ленивых полей и отложенных вычислений закрытия. В следующем примере показана неудачная попытка обработки ошибки с помощью try выражения:

let
    f = (x) => [ a = error "bad", b = x ],
    g = try f(42) otherwise 123
in 
    g[a]  // error "bad"

В этом примере определение g было предназначено для обработки ошибки, возникаемой при вызове f. Однако ошибка вызывается инициализатором полей, который выполняется только при необходимости и таким образом после возврата записи из f и передается через try выражение.

Не реализована ошибка

Несмотря на разработку выражения, автор может отказаться от реализации для некоторых частей выражения, но может по-прежнему иметь возможность выполнять выражение. Один из способов обработки этого дела — вызвать ошибку для неимблированных частей. Например:

(x, y) =>
     if x > y then
         x - y
     else
         error Error.Record("Expression.Error", 
            "Not Implemented")

Символ многоточия (...) можно использовать в качестве ярлыка error.

not-implemented-expression:
...

Например, следующий пример эквивалентен предыдущему примеру:

(x, y) => if x > y then x - y else ...

Поделиться через

Обработка ошибок

Создание ошибок

Обработка ошибок

Ошибки в записи и разрешить инициализаторам

Не реализована ошибка

Обратная связь

Дополнительные ресурсы