Монады, чистые/грязные функции

я только начал разбираться в этих вещах и не совсем понимаю как мне реализовать те функции которые так легко реализуются в императивных языках

как я понял если я считываю что-то из файла, и возвращаю это из функции то получу String обернутый в IO, ковыряясь в гугле, вычитал, что от IO избавиться вообще никак нельзя. А что если мне просто надо считать из файла допустим список слов? Я пытался делать вот так:
позже выполняю вот так
и если я правильно понимаю мне возвращается тут просто String обернутый в IO, я хочу избавиться хоть как нибудь от IO и пытаюсь просто написать какую-нибудь функцию которая бы мне возвращала лист строк
если я правильно понимаю, то переменная t сейчас имеет тип [String].
Здесь вместо точек я поначалу писал return t но потом, почитав различных статей, понял что return оборачивает все в монаду...

Так каким же образом мне просто получить из файла список строк (просто вернуть из функции [String], ну или более грубо: как считать из файла список строк, так чтобы с ним можно было работать как с обычным списком а не как с какой то монадой (вообще мне нужно считать словарь из файла, а потом с ним работать))?

0

Теперь понятно, почему вы так фиксируете себя на чистоте. Нет, в haskell иначе.

Представим, что вы написали монадический трансформер. По вашему определению он будет чистым. Теперь параметризуем его монадой IO. И что получается? Чистый трансформер внезапно превращается в грязный?!

В haskell почти все функции чистые. Нет, даже не так. Почти все функции ссылочно-прозрачные. А ссылочная прозрачность является достаточным условием для чистоты.

Если по простому, то ссылочная прозрачность позволяет вставлять тело функции где угодно и когда угодно его вычислять. Чистота же значит, что вывод функции зависит только от входных параметров. Если функция не является ссылочно-прозрачной, то мы обязаны добавить прагму NOINLINE.

Вот берем некий побочный эффект. Пусть это будет значение IO (). По факту это только некоторая функция, скрытая за фасадом вычисления IO. Она вполне может зависеть только от входных параметров. И это так. Все чисто. Побочный эффект появляется при применении этой функции во время вычисления main.

Но в haskell часто говорят о некотором значении с типом Double как о чистом значении. IO Double - это уже вычисление вещественного числа. Оно как бы чистым не называется, но это уже другая трактовка многозначного термина чистоты.

При программировании лучше избегать сложных вложенных типов. Лучше определить Double, чем IO Double, но это не всегда возможно. Вот, собственно, отсюда идет идея о том, чтобы как можно больше писать так называемых «чистых функций». Нужно различать контекст, где какой смысл вкладывается в понятие чистоты.

0

Кто считает и что значит "самый правильный"?

Сужу по величине ажиотажа.

Насколько понял, это концепция заимствования (borrowing) в языке Rust.

Год возникновения Clean – 1987, Rust – 2010. Вот и думай, кто у кого и что заимствовал.

Кроме монад IO и ST в Haskell существует множество других монад, в том числе список тоже монада.

Мне кажется, что те проблемы, которые решает монада MayBe, можно решить без притягивания концепции монад. Это вопрос дизайна языка. Взять, к примеру, операцию деления. Результат операции — MayBe Float (иногда она выдаёт ошибку — когда делят на ноль). Операция деления не оказывает побочных эффектов. Она детерминирована, т.*е. при одинаковых входных данных даёт одинаковые выходные. Ну и зачем это делать через монады? Пусть эта операция выдавала бы тип Float, а вот обработку ошибки сделать по другому. Пользоваться типом Float удобнее, нежели MayBe Float. Кстати, я тут выше писал:
Наверняка тут ошибка. Потому что «return» превращает, допустим Integer, в IO Integer. А тут хотелось бы обратное преобразование: IO Integer в Integer.

0

Сообщение от communicay Вот и думай, кто у кого и что заимствовал.

Ещё раз. Концепция заимствования (borrowing) в языке Rust. Я не написал что клин взяли что то из раст.

Сообщение от communicay Взять, к примеру, операцию деления. Результат операции — MayBe Float

О чём вы? Результат функций (/) и div тот же что и у их аргументов.
Maybe как монаду удобно использовать если есть функции a -> Maybe b, мы эти функции вызываем последовательно, передавая результат в следующую, а если какая то функция вернёт Nothing, то оставшиеся функции не вызываются.
В цепочку можно включить и функцию вида a -> b (без монады).

Сообщение от communicay Наверняка тут ошибка

Точка после return нужна. Например

1

Влезаю в беседу, как запахло холиваром. Впрочем, хороший повод высказать своё мнение и начать знакомство.

Мне в целом очень нравится, что пишет dsorokin. А вопрошающий не слушает. Взять хотя бы:

Сообщение от dsorokin Предлагаю на время забыть про чистоту совсем. Она только путает. Скажу, что в haskell все функции являются формально чистыми.

Вообще, в рассматриваемом вопросе я бы это утверждение возвёл в качестве первого догмата.

Однажды мы с KolodeznyDiver участвовали в обсуждении чистоты в Хаскелль. Тема ушла в холивары.
Так вот, там я пытался аргументировать, что понятие чистой функции возникло в программировании в протиповес понятию функции, используемом в том же программировании. При этом понятие функции в программировании отличается от понятия функции во всех остальных областях человеческой деятельности, где под словом "функция" как раз понимается чистая функция, а иных нет.

В тех ЯП, где можно делать присваивания, изменения глобального состояния и т.п., функциями с сигнатурой A -> B называются те подпрограммы, которые в начале принимают объект типа A, а в конце возвращают (т.е. оставляют в памяти) объект типа B. В математике же под функциями понимается однозначное соответствие объекта B объекту A, и ничего сверх этого.
В чисто функциональных ЯП все функции чистые, т.е. все функции являются функциями в строго математическом (и общечеловеческом, за исключением программистов) понимании.

Однако, уже имеется устойчивая традиция в программировании, в т.ч. в употреблении терминов. Поэтому теперь всякий раз, когда мы говорим "функция", мы должны уточнять, что функция чистая, имея в виду то, что она возвращает результат, однозначно определяемый аргументом.
Также в традиции программистов рассматривается, например, функция чтения строки get_string как нечистая функция с сигнатурой () -> String. В чисто функциональных ЯП get_string является чистой (других здесь нет) функцией с другим типом, например, () -> IO String.

Если бы от меня зависело, как употреблять термины, которые, объективно говоря, сейчас употребляются непоследовательно, я бы предложил следующее:
чистая функция типа A -> B — ...
m-грязная функция A -> B — это чистая функция типа A -> m B
грязная функция — это IO-грязная функция.
То есть предлагаю понятие нечистой (грязной) функции обыграть через категорию Клейсли.

P.S. KolodeznyDiver, речь идёт о том, что в самописной реализации деления по-хорошему нельзя делить на ноль, а потому там будет Maybe. Стандартная реализация при делении на ноль кидает исключение, то есть _|_.

1

Сообщение от Mysterious Light в самописной реализации деления по-хорошему нельзя делить на ноль, а потому там будет Maybe

Мы в разделе Haskell, а в Haskell, по стандарту, функции деления имеют сигнатуру a -> a -> a и никаких Maybe, в случае деления на ноль выбрасывается ArithException.

1