Что означает синтаксис "просто" в Haskell?

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

что может быть, конструктивно

определение выглядит примерно так:

data Maybe a = Just a
             | Nothing

это объявление определяет тип,Maybe a, который параметризуется переменной типа a, что просто означает, что вы можете использовать его с любым типом вместо a.

Строительство и разрушение

тип имеет два конструктора, Just a и Nothing. Если тип имеет несколько конструкторов, это означает, что значение типа должно быть построено только с одним из возможных конструкторов. Для этого типа значение было либо построено через Just или Nothing, нет никаких других (без ошибок) возможностей.

С Nothing не имеет типа параметра, когда он используется в качестве конструктора он называет a постоянное значение, которое является членом типа Maybe a для всех типов a. Но это Just конструктор имеет параметр типа, что означает, что при использовании в качестве конструктора он действует как функция от типа a до Maybe a, т. е. он имеет вид a -> Maybe a

Итак, конструкторы типа строят значение этого типа; другая сторона вещей-это когда вы хотели бы использовать это значение, и именно там сопоставление шаблонов вступает в игру. В отличие от функций, конструкторы могут быть используется в выражениях привязки шаблонов, и это способ, которым вы можете сделать case analysis значений, принадлежащих типам с несколькими конструкторами.

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

case maybeVal of
    Nothing   -> "There is nothing!"
    Just val  -> "There is a value, and it is " ++ (show val)

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

Что Может Означать

может быть, вы уже были знакомы с тем, как это работает; на самом деле нет никакой магии Maybe значения, это просто нормальный алгебраический тип данных Хаскелла (ADT). Но он используется совсем немного, потому что он эффективно "поднимает" или расширяет тип, такой как Integer из вашего примера, в новый контекст, в котором он имеет дополнительное значение (Nothing) это означает отсутствие ценности! Затем система типов требует, чтобы вы проверили это дополнительное значение, прежде чем оно позволит вам получить Integer это может быть там. Это предотвращает значительное количество ошибок.

многие языки сегодня обрабатывают такое значение "без значения" с помощью нулевых ссылок. Тони хор, выдающийся компьютерный ученый (он изобрел Quicksort и является лауреатом премии Тьюринга), владеет до этого как его "ошибка на миллиард долларов". Тип "может быть" - это не единственный способ исправить это, но он оказался эффективным способом сделать это.

может быть, как функтор

идея преобразования одного типа в другой такой, что операции над старым типом могут и преобразование для работы над новым типом-это концепция, лежащая в основе класса типа Haskell под названием Functor, который Maybe a имеет полезный экземпляр.

Functor обеспечивает метод называется fmap, который отображает функции, которые варьируются по значениям из базового типа (например,Integer) к функциям, которые варьируются по значениям от поднятого типа (например,Maybe Integer). Функция, преобразованная с помощью fmap для работы на Maybe значение работает следующим образом:

case maybeVal of
  Nothing  -> Nothing         -- there is nothing, so just return Nothing
  Just val -> Just (f val)    -- there is a value, so apply the function to it

так что если у вас есть Maybe Integer стоимостью m_x и Int -> Int функции f, вы можете сделать fmap f m_x чтобы применить функцию f непосредственно Maybe Integer не беспокоясь, если это на самом деле есть значение или нет. На самом деле, вы могли бы применить целую цепочку поднятых Integer -> Integer функции Maybe Integer значения и только должны беспокоиться о явной проверке Nothing один раз, когда вы закончите.

может быть, как монада

я не знаю, насколько вы знакомы с понятием Monad пока нет, но вы хотя бы использовали IO a раньше, и подпись типа IO a выглядит удивительно похожим на Maybe a. Хотя IO в том, что он не подвергайте его конструкторы для вас и, таким образом, могут быть "запущены" только системой времени выполнения Haskell, это все еще Functor кроме того,Monad. На самом деле, есть важный смысл, в котором Monad - это просто особый вид Functor С некоторыми дополнительными функциями, но это не место для разговора об этом.

во всяком случае, монады любят IO сопоставьте типы с новыми типами, которые представляют "вычисления, которые приводят к значениям", и вы можете поднять функции в Monad типы через очень fmap-как функция называется liftM что превращает регулярную функцию в " вычисление, которое приводит к значению, полученному при оценке функции."

вы, наверное, догадались (если вы читали это далеко), что Maybe тоже Monad. Он представляет собой "вычисления, которые могут не возвращать значение". Так же, как и с fmap например, это позволяет выполнять целую кучу вычислений без явной проверки ошибок после каждого шага. И в самом деле так элемент Monad экземпляр построен, вычисление на Maybe значения остановка как только a Nothing встречается, так что это похоже на немедленное прерывание или бесполезное возвращение в середине вычисления.

Вы Могли Бы Написать, Может Быть,

как я уже говорил, нет ничего присущего Maybe тип, который выпекается в синтаксисе языка или системы. Если Haskell не предоставил его по умолчанию, вы можете предоставить все его функциональность себя! На самом деле, вы можете написать его снова самостоятельно, с разными именами, и получить ту же функциональность.

надеюсь, вы понимаете Maybe тип и его конструкторы сейчас, но если есть еще что-то непонятное, дайте мне знать!