История изменений
Исправление AndreyKl, (текущая версия) :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который может иметь одно из двух значений - либо Just val (например Just 3) либо Nothing.
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
(Maybe Int) myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . ( toString(res) )
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что внешний myDivision первым аргументом ждёт Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что получилось у тебя как я понял по описанию - это просто замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исправление AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который может иметь одно из двух значений - либо Just val (например Just 3) либо Nothing.
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
(Maybe Int) myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что внешний myDivision первым аргументом ждёт Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что получилось у тебя как я понял по описанию - это просто замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исправление AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который может иметь одно из двух значений - либо Just val (например Just 3) либо Nothing. Примерно как union в си.
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
(Maybe Int) myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что внешний myDivision первым аргументом ждёт Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что получилось у тебя как я понял по описанию - это просто замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исправление AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который имеет только два значения - либо Just val (например Just 3) либо Nothing
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
(Maybe Int) myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что внешний myDivision первым аргументом ждёт Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что получилось у тебя как я понял по описанию - это просто замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исправление AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который имеет только два значения - либо Just val (например Just 3) либо Nothing
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
(Maybe Int) myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что myDivision ждёт Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что получилось у тебя как я понял по описанию - это просто замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исправление AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который имеет только два значения - либо Just val (например Just 3) либо Nothing
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
(Maybe Int) myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что myDivision ждёт [inlnie]Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что получилось у тебя как я понял по описанию - это просто замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исправление AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который имеет только два значения - либо Just val (например Just 3) либо Nothing
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
(Maybe Int) myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что myDivision ждёт [inlnie]Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что у тебя - это замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исправление AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который имеет только два значения - либо Just val (например Just 3) либо Nothing
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
Maybe Int myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что myDivision ждёт [inlnie]Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
Ну и понятное дело что в языках которые это умеют хорошо и правильно, есть целая плеяда инструментов для работы с такими вещами: функторы, аппликативы, монады, эффекты, изо-,ката-,гило- и прочие морфизмы..
А то что у тебя - это замена «громогласного» npe на «тихий» npe. Как по мне так станет только хуже, потому что даже во время выполнения ошибка будет дополнительно маскироваться и вылезать уж в самом конце операции.
Исходная версия AndreyKl, :
Я у себя во фреймворке (на PHP) как-то делал закладку на NPE-less работу. Вместо NULL свой объект Nil, любые операции от которого возвращают такой же Nil.
Это немного не то что имеется ввиду под npe-less.
Обычно вводится тип вроде Maybe a (конкретизированный пример Maybe Int) который имеет только два значения - либо Just val (например Just 3) либо Nothing
И во время написания кода там где функция может не вернуть значение (например, в случае ошибки) вместо объявления вроде Int myDivision(Int a, Int b) и возвращения Null в случае ошибки пишут нечто вроде
Maybe Int myDivision(Int a, Int b) {
if b == 0 then Nothing else Just (a / b)
}
case myDivision(v1, v2) of
(Just res) => echo 'Результат: ' . (toString res)
Nothing => echo 'Неожиданный результат. Вы что на ноль что ли делите?!'
echo myDivision(v1, v2) то код не скомпилируется потому что эхо ждёт строку, а получает Maybe Int. И такой вызов не скомпилируется myDivision(myDivision(v0, v1), v2) потому что myDivision ждёт [inlnie]Int, а получает Maybe Int.Т.е суть в том что компилятор предупредит если забудешь обработать возврат пустого значения.
А то что у тебя - это замена «громогласного» npe на «тихий» npe.